Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "FUNC_0(struct iscsi_context *VAR_0, int VAR_1,\nvoid *VAR_2, void *VAR_3)\n{", "struct IscsiTask *VAR_4 = VAR_3;", "struct scsi_task *VAR_5 = VAR_2;", "VAR_4->VAR_1 = VAR_1;", "VAR_4->do_retry = 0;", "VAR_4->VAR_5 = VAR_5;", "if (VAR_1 != SCSI_STATUS_GOOD) {", "if (VAR_4->retries++ < ISCSI_CMD_RETRIES) {", "if (VAR_1 == SCSI_STATUS_CHECK_CONDITION\n&& VAR_5->sense.key == SCSI_SENSE_UNIT_ATTENTION) {", "error_report(\"iSCSI CheckCondition: %s\",\niscsi_get_error(VAR_0));", "VAR_4->do_retry = 1;", "goto out;", "}", "if (VAR_1 == SCSI_STATUS_BUSY || VAR_1 == 0x28) {", "unsigned VAR_6 =\nexp_random(iscsi_retry_times[VAR_4->retries - 1]);", "error_report(\"iSCSI Busy/TaskSetFull (retry #%u in %u ms): %s\",\nVAR_4->retries, VAR_6,\niscsi_get_error(VAR_0));", "aio_timer_init(VAR_4->iscsilun->aio_context,\n&VAR_4->retry_timer, QEMU_CLOCK_REALTIME,\nSCALE_MS, iscsi_retry_timer_expired, VAR_4);", "timer_mod(&VAR_4->retry_timer,\nqemu_clock_get_ms(QEMU_CLOCK_REALTIME) + VAR_6);", "VAR_4->do_retry = 1;", "return;", "}", "}", "error_report(\"iSCSI Failure: %s\", iscsi_get_error(VAR_0));", "} else {", "VAR_4->iscsilun->force_next_flush |= VAR_4->force_next_flush;", "}", "out:\nif (VAR_4->co) {", "VAR_4->bh = aio_bh_new(VAR_4->iscsilun->aio_context,\niscsi_co_generic_bh_cb, VAR_4);", "qemu_bh_schedule(VAR_4->bh);", "} else {", "VAR_4->complete = 1;", "}", "}" ]

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

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

[ "int VAR_0 avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,\nint *frame_size_ptr,\nAVPacket *avpkt)\n{", "AVFrame frame = {0};", "int ret, got_frame = 0;", "if (avctx->get_buffer != avcodec_default_get_buffer) {", "av_log(avctx, AV_LOG_ERROR, \"Custom get_buffer() for use with\"\n\"avcodec_decode_audio3() detected. Overriding with avcodec_default_get_buffer\\n\");", "av_log(avctx, AV_LOG_ERROR, \"Please port your application to \"\n\"avcodec_decode_audio4()\\n\");", "avctx->get_buffer = avcodec_default_get_buffer;", "}", "ret = avcodec_decode_audio4(avctx, &frame, &got_frame, avpkt);", "if (ret >= 0 && got_frame) {", "int ch, plane_size;", "int planar = av_sample_fmt_is_planar(avctx->sample_fmt);", "int data_size = av_samples_get_buffer_size(&plane_size, avctx->channels,\nframe.nb_samples,\navctx->sample_fmt, 1);", "if (*frame_size_ptr < data_size) {", "av_log(avctx, AV_LOG_ERROR, \"output buffer size is too small for \"\n\"the current frame (%d < %d)\\n\", *frame_size_ptr, data_size);", "return AVERROR(EINVAL);", "}", "memcpy(samples, frame.extended_data[0], plane_size);", "if (planar && avctx->channels > 1) {", "uint8_t *out = ((uint8_t *)samples) + plane_size;", "for (ch = 1; ch < avctx->channels; ch++) {", "memcpy(out, frame.extended_data[ch], plane_size);", "out += plane_size;", "}", "}", "*frame_size_ptr = data_size;", "} else {", "*frame_size_ptr = 0;", "}", "return ret;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext * VAR_0)\n{", "AVIOContext *pb = VAR_0->pb;", "APEContext *ape = VAR_0->priv_data;", "AVStream *st;", "uint32_t tag;", "int VAR_1;", "int VAR_2, VAR_3 = 0;", "int64_t pts, file_size;", "ape->junklength = avio_tell(pb);", "tag = avio_rl32(pb);", "if (tag != MKTAG('M', 'A', 'C', ' '))\nreturn AVERROR_INVALIDDATA;", "ape->fileversion = avio_rl16(pb);", "if (ape->fileversion < APE_MIN_VERSION || ape->fileversion > APE_MAX_VERSION) {", "av_log(VAR_0, AV_LOG_ERROR, \"Unsupported file version - %d.%02d\\n\",\nape->fileversion / 1000, (ape->fileversion % 1000) / 10);", "return AVERROR_PATCHWELCOME;", "}", "if (ape->fileversion >= 3980) {", "ape->padding1 = avio_rl16(pb);", "ape->descriptorlength = avio_rl32(pb);", "ape->headerlength = avio_rl32(pb);", "ape->seektablelength = avio_rl32(pb);", "ape->wavheaderlength = avio_rl32(pb);", "ape->audiodatalength = avio_rl32(pb);", "ape->audiodatalength_high = avio_rl32(pb);", "ape->wavtaillength = avio_rl32(pb);", "avio_read(pb, ape->md5, 16);", "if (ape->descriptorlength > 52)\navio_skip(pb, ape->descriptorlength - 52);", "ape->compressiontype = avio_rl16(pb);", "ape->formatflags = avio_rl16(pb);", "ape->blocksperframe = avio_rl32(pb);", "ape->finalframeblocks = avio_rl32(pb);", "ape->totalframes = avio_rl32(pb);", "ape->bps = avio_rl16(pb);", "ape->channels = avio_rl16(pb);", "ape->samplerate = avio_rl32(pb);", "} else {", "ape->descriptorlength = 0;", "ape->headerlength = 32;", "ape->compressiontype = avio_rl16(pb);", "ape->formatflags = avio_rl16(pb);", "ape->channels = avio_rl16(pb);", "ape->samplerate = avio_rl32(pb);", "ape->wavheaderlength = avio_rl32(pb);", "ape->wavtaillength = avio_rl32(pb);", "ape->totalframes = avio_rl32(pb);", "ape->finalframeblocks = avio_rl32(pb);", "if (ape->formatflags & MAC_FORMAT_FLAG_HAS_PEAK_LEVEL) {", "avio_skip(pb, 4);", "ape->headerlength += 4;", "}", "if (ape->formatflags & MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS) {", "ape->seektablelength = avio_rl32(pb);", "ape->headerlength += 4;", "ape->seektablelength *= sizeof(int32_t);", "} else", "ape->seektablelength = ape->totalframes * sizeof(int32_t);", "if (ape->formatflags & MAC_FORMAT_FLAG_8_BIT)\nape->bps = 8;", "else if (ape->formatflags & MAC_FORMAT_FLAG_24_BIT)\nape->bps = 24;", "else\nape->bps = 16;", "if (ape->fileversion >= 3950)\nape->blocksperframe = 73728 * 4;", "else if (ape->fileversion >= 3900 || (ape->fileversion >= 3800 && ape->compressiontype >= 4000))\nape->blocksperframe = 73728;", "else\nape->blocksperframe = 9216;", "if (!(ape->formatflags & MAC_FORMAT_FLAG_CREATE_WAV_HEADER))\navio_skip(pb, ape->wavheaderlength);", "}", "if(!ape->totalframes){", "av_log(VAR_0, AV_LOG_ERROR, \"No frames in the file!\\n\");", "return AVERROR(EINVAL);", "}", "if(ape->totalframes > UINT_MAX / sizeof(APEFrame)){", "av_log(VAR_0, AV_LOG_ERROR, \"Too many frames: %\"PRIu32\"\\n\",\nape->totalframes);", "return AVERROR_INVALIDDATA;", "}", "if (ape->seektablelength / sizeof(*ape->seektable) < ape->totalframes) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Number of seek entries is less than number of frames: %zu vs. %\"PRIu32\"\\n\",\nape->seektablelength / sizeof(*ape->seektable), ape->totalframes);", "return AVERROR_INVALIDDATA;", "}", "ape->frames = av_malloc(ape->totalframes * sizeof(APEFrame));", "if(!ape->frames)\nreturn AVERROR(ENOMEM);", "ape->firstframe = ape->junklength + ape->descriptorlength + ape->headerlength + ape->seektablelength + ape->wavheaderlength;", "if (ape->fileversion < 3810)\nape->firstframe += ape->totalframes;", "ape->currentframe = 0;", "ape->totalsamples = ape->finalframeblocks;", "if (ape->totalframes > 1)\nape->totalsamples += ape->blocksperframe * (ape->totalframes - 1);", "if (ape->seektablelength > 0) {", "ape->seektable = av_malloc(ape->seektablelength);", "if (!ape->seektable)\nreturn AVERROR(ENOMEM);", "for (VAR_1 = 0; VAR_1 < ape->seektablelength / sizeof(uint32_t) && !pb->eof_reached; VAR_1++)", "ape->seektable[VAR_1] = avio_rl32(pb);", "if (ape->fileversion < 3810) {", "ape->bittable = av_malloc(ape->totalframes);", "if (!ape->bittable)\nreturn AVERROR(ENOMEM);", "for (VAR_1 = 0; VAR_1 < ape->totalframes && !pb->eof_reached; VAR_1++)", "ape->bittable[VAR_1] = avio_r8(pb);", "}", "}", "ape->frames[0].pos = ape->firstframe;", "ape->frames[0].nblocks = ape->blocksperframe;", "ape->frames[0].skip = 0;", "for (VAR_1 = 1; VAR_1 < ape->totalframes; VAR_1++) {", "ape->frames[VAR_1].pos = ape->seektable[VAR_1] + ape->junklength;", "ape->frames[VAR_1].nblocks = ape->blocksperframe;", "ape->frames[VAR_1 - 1].size = ape->frames[VAR_1].pos - ape->frames[VAR_1 - 1].pos;", "ape->frames[VAR_1].skip = (ape->frames[VAR_1].pos - ape->frames[0].pos) & 3;", "}", "ape->frames[ape->totalframes - 1].nblocks = ape->finalframeblocks;", "file_size = avio_size(pb);", "if (file_size > 0) {", "VAR_3 = file_size - ape->frames[ape->totalframes - 1].pos -\nape->wavtaillength;", "VAR_3 -= VAR_3 & 3;", "}", "if (file_size <= 0 || VAR_3 <= 0)\nVAR_3 = ape->finalframeblocks * 8;", "ape->frames[ape->totalframes - 1].size = VAR_3;", "for (VAR_1 = 0; VAR_1 < ape->totalframes; VAR_1++) {", "if(ape->frames[VAR_1].skip){", "ape->frames[VAR_1].pos -= ape->frames[VAR_1].skip;", "ape->frames[VAR_1].size += ape->frames[VAR_1].skip;", "}", "ape->frames[VAR_1].size = (ape->frames[VAR_1].size + 3) & ~3;", "}", "if (ape->fileversion < 3810) {", "for (VAR_1 = 0; VAR_1 < ape->totalframes; VAR_1++) {", "if (VAR_1 < ape->totalframes - 1 && ape->bittable[VAR_1 + 1])\nape->frames[VAR_1].size += 4;", "ape->frames[VAR_1].skip <<= 3;", "ape->frames[VAR_1].skip += ape->bittable[VAR_1];", "}", "}", "ape_dumpinfo(VAR_0, ape);", "av_log(VAR_0, AV_LOG_DEBUG, \"Decoding file - v%d.%02d, compression level %\"PRIu16\"\\n\",\nape->fileversion / 1000, (ape->fileversion % 1000) / 10,\nape->compressiontype);", "st = avformat_new_stream(VAR_0, NULL);", "if (!st)\nreturn AVERROR(ENOMEM);", "VAR_2 = (ape->totalframes == 0) ? 0 : ((ape->totalframes - 1) * ape->blocksperframe) + ape->finalframeblocks;", "st->codec->codec_type = AVMEDIA_TYPE_AUDIO;", "st->codec->codec_id = AV_CODEC_ID_APE;", "st->codec->codec_tag = MKTAG('A', 'P', 'E', ' ');", "st->codec->channels = ape->channels;", "st->codec->sample_rate = ape->samplerate;", "st->codec->bits_per_coded_sample = ape->bps;", "st->nb_frames = ape->totalframes;", "st->start_time = 0;", "st->duration = VAR_2;", "avpriv_set_pts_info(st, 64, 1, ape->samplerate);", "if (ff_alloc_extradata(st->codec, APE_EXTRADATA_SIZE))\nreturn AVERROR(ENOMEM);", "AV_WL16(st->codec->extradata + 0, ape->fileversion);", "AV_WL16(st->codec->extradata + 2, ape->compressiontype);", "AV_WL16(st->codec->extradata + 4, ape->formatflags);", "pts = 0;", "for (VAR_1 = 0; VAR_1 < ape->totalframes; VAR_1++) {", "ape->frames[VAR_1].pts = pts;", "av_add_index_entry(st, ape->frames[VAR_1].pos, ape->frames[VAR_1].pts, 0, 0, AVINDEX_KEYFRAME);", "pts += ape->blocksperframe;", "}", "if (pb->seekable) {", "ff_ape_parse_tag(VAR_0);", "avio_seek(pb, 0, SEEK_SET);", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 23 ], [ 27 ], [ 29, 31 ], [ 35 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 77, 79 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151, 153 ], [ 155, 157 ], [ 159, 161 ], [ 165, 167 ], [ 169, 171 ], [ 173, 175 ], [ 181, 183 ], [ 185 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199, 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209, 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221, 223 ], [ 225 ], [ 227, 229 ], [ 231 ], [ 237 ], [ 239, 241 ], [ 245 ], [ 247 ], [ 249, 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 297 ], [ 299 ], [ 301, 303 ], [ 305 ], [ 307 ], [ 309, 311 ], [ 313 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335, 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 349 ], [ 353, 355, 357 ], [ 363 ], [ 365, 367 ], [ 371 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 399, 401 ], [ 403 ], [ 405 ], [ 407 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 437 ], [ 439 ] ]

[ "int FUNC_0(AVCodecContext *VAR_0, VdpDecoderProfile VAR_1,\nint VAR_2)\n{", "VDPAUHWContext *hwctx = VAR_0->hwaccel_context;", "VDPAUContext *vdctx = VAR_0->internal->hwaccel_priv_data;", "VdpVideoSurfaceQueryCapabilities *surface_query_caps;", "VdpDecoderQueryCapabilities *decoder_query_caps;", "VdpDecoderCreate *create;", "void *VAR_3;", "VdpStatus status;", "VdpBool supported;", "uint32_t max_level, max_mb, max_width, max_height;", "VdpChromaType type;", "uint32_t width;", "uint32_t height;", "vdctx->width = UINT32_MAX;", "vdctx->height = UINT32_MAX;", "if (av_vdpau_get_surface_parameters(VAR_0, &type, &width, &height))\nreturn AVERROR(ENOSYS);", "if (hwctx) {", "hwctx->reset = 0;", "if (hwctx->context.decoder != VDP_INVALID_HANDLE) {", "vdctx->decoder = hwctx->context.decoder;", "vdctx->render = hwctx->context.render;", "vdctx->device = VDP_INVALID_HANDLE;", "return 0;", "}", "vdctx->device = hwctx->device;", "vdctx->get_proc_address = hwctx->get_proc_address;", "if (hwctx->flags & AV_HWACCEL_FLAG_IGNORE_LEVEL)\nVAR_2 = 0;", "if (!(hwctx->flags & AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH) &&\ntype != VDP_CHROMA_TYPE_420)\nreturn AVERROR(ENOSYS);", "} else {", "AVHWFramesContext *frames_ctx = NULL;", "AVVDPAUDeviceContext *dev_ctx;", "if (VAR_0->hw_frames_ctx) {", "frames_ctx = (AVHWFramesContext*)VAR_0->hw_frames_ctx->data;", "} else if (VAR_0->hw_device_ctx) {", "int VAR_4;", "VAR_0->hw_frames_ctx = av_hwframe_ctx_alloc(VAR_0->hw_device_ctx);", "if (!VAR_0->hw_frames_ctx)\nreturn AVERROR(ENOMEM);", "frames_ctx = (AVHWFramesContext*)VAR_0->hw_frames_ctx->data;", "frames_ctx->format = AV_PIX_FMT_VDPAU;", "frames_ctx->sw_format = VAR_0->sw_pix_fmt;", "frames_ctx->width = VAR_0->coded_width;", "frames_ctx->height = VAR_0->coded_height;", "VAR_4 = av_hwframe_ctx_init(VAR_0->hw_frames_ctx);", "if (VAR_4 < 0) {", "av_buffer_unref(&VAR_0->hw_frames_ctx);", "return VAR_4;", "}", "}", "if (!frames_ctx) {", "av_log(VAR_0, AV_LOG_ERROR, \"A hardware frames context is \"\n\"required for VDPAU decoding.\\n\");", "return AVERROR(EINVAL);", "}", "dev_ctx = frames_ctx->device_ctx->hwctx;", "vdctx->device = dev_ctx->device;", "vdctx->get_proc_address = dev_ctx->get_proc_address;", "if (VAR_0->hwaccel_flags & AV_HWACCEL_FLAG_IGNORE_LEVEL)\nVAR_2 = 0;", "}", "if (VAR_2 < 0)\nreturn AVERROR(ENOTSUP);", "status = vdctx->get_proc_address(vdctx->device,\nVDP_FUNC_ID_GET_INFORMATION_STRING,\n&VAR_3);", "if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);", "else\ninfo = VAR_3;", "status = info(&info_string);", "if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);", "if (VAR_0->codec_id == AV_CODEC_ID_HEVC && strncmp(info_string, \"NVIDIA \", 7) == 0 &&\n!(VAR_0->hwaccel_flags & AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH)) {", "av_log(VAR_0, AV_LOG_VERBOSE, \"HEVC with NVIDIA VDPAU drivers is buggy, skipping.\\n\");", "return AVERROR(ENOTSUP);", "}", "status = vdctx->get_proc_address(vdctx->device,\nVDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES,\n&VAR_3);", "if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);", "else\nsurface_query_caps = VAR_3;", "status = surface_query_caps(vdctx->device, type, &supported,\n&max_width, &max_height);", "if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);", "if (supported != VDP_TRUE ||\nmax_width < width || max_height < height)\nreturn AVERROR(ENOTSUP);", "status = vdctx->get_proc_address(vdctx->device,\nVDP_FUNC_ID_DECODER_QUERY_CAPABILITIES,\n&VAR_3);", "if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);", "else\ndecoder_query_caps = VAR_3;", "status = decoder_query_caps(vdctx->device, VAR_1, &supported, &max_level,\n&max_mb, &max_width, &max_height);", "#ifdef VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE\nif ((status != VDP_STATUS_OK || supported != VDP_TRUE) && VAR_1 == VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE) {", "VAR_1 = VDP_DECODER_PROFILE_H264_MAIN;", "status = decoder_query_caps(vdctx->device, VAR_1, &supported,\n&max_level, &max_mb,\n&max_width, &max_height);", "}", "#endif\nif (status != VDP_STATUS_OK)\nreturn vdpau_error(status);", "if (supported != VDP_TRUE || max_level < VAR_2 ||\nmax_width < width || max_height < height)\nreturn AVERROR(ENOTSUP);", "status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_CREATE,\n&VAR_3);", "if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);", "else\ncreate = VAR_3;", "status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_RENDER,\n&VAR_3);", "if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);", "else\nvdctx->render = VAR_3;", "status = create(vdctx->device, VAR_1, width, height, VAR_0->refs,\n&vdctx->decoder);", "if (status == VDP_STATUS_OK) {", "vdctx->width = VAR_0->coded_width;", "vdctx->height = VAR_0->coded_height;", "}", "return vdpau_error(status);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 41, 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 73, 75 ], [ 79, 81, 83 ], [ 85 ], [ 87 ], [ 89 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113, 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 145 ], [ 147, 149 ], [ 151 ], [ 153 ], [ 157 ], [ 161 ], [ 163 ], [ 167, 169 ], [ 171 ], [ 175, 177 ], [ 181, 183, 185 ], [ 187, 189 ], [ 191, 193 ], [ 197 ], [ 199, 201 ], [ 203, 205 ], [ 207 ], [ 209 ], [ 211 ], [ 215, 217, 219 ], [ 221, 223 ], [ 225, 227 ], [ 231, 233 ], [ 235, 237 ], [ 239, 241, 243 ], [ 247, 249, 251 ], [ 253, 255 ], [ 257, 259 ], [ 263, 265 ], [ 267, 269 ], [ 271 ], [ 273, 275, 277 ], [ 279 ], [ 281, 283, 285 ], [ 289, 291, 293 ], [ 297, 299 ], [ 301, 303 ], [ 305, 307 ], [ 311, 313 ], [ 315, 317 ], [ 319, 321 ], [ 325, 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 339 ], [ 341 ] ]

[ "static int FUNC_0(AVProbeData *VAR_0)\n{", "unsigned int VAR_1, VAR_2;", "if (VAR_0->buf_size < 20)\nreturn 0;", "VAR_1 = AV_RL32(&VAR_0->buf[0]);", "if ((VAR_1 == 0) || (VAR_1 > 1024))\nreturn 0;", "VAR_1 = AV_RL32(&VAR_0->buf[4]);", "if ((VAR_1 == 0) || (VAR_1 > 1024))\nreturn 0;", "VAR_2 = AV_RL32(&VAR_0->buf[8]);", "if (VAR_2 && (VAR_2 < 8000 || VAR_2 > 48000))\nreturn 0;", "VAR_1 = AV_RL32(&VAR_0->buf[12]);", "if (VAR_1 > 2 || VAR_2 && !VAR_1)\nreturn 0;", "VAR_1 = AV_RL32(&VAR_0->buf[16]);", "if (VAR_1 > 2 || VAR_2 && !VAR_1)\nreturn 0;", "return AVPROBE_SCORE_EXTENSION;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 35, 37 ], [ 43 ], [ 45, 47 ], [ 53 ], [ 55, 57 ], [ 63 ], [ 65, 67 ], [ 73 ], [ 75, 77 ], [ 83 ], [ 85, 87 ], [ 93 ], [ 95 ] ]

[ "static inline int FUNC_0(MpegEncContext *VAR_0,\nuint8_t *VAR_1, uint8_t *VAR_2,\nint VAR_3, int VAR_4,\nop_pixels_func *VAR_5,\nint VAR_6, int VAR_7)\n{", "int VAR_8 = 0;", "int VAR_9 = 0;", "VAR_3 += VAR_6 >> 1;", "VAR_4 += VAR_7 >> 1;", "VAR_3 = av_clip(VAR_3, -16, VAR_0->width);", "if (VAR_3 != VAR_0->width)\nVAR_8 |= VAR_6 & 1;", "VAR_4 = av_clip(VAR_4, -16, VAR_0->height);", "if (VAR_4 != VAR_0->height)\nVAR_8 |= (VAR_7 & 1) << 1;", "VAR_2 += VAR_4 * VAR_0->linesize + VAR_3;", "if ((unsigned)VAR_3 > FFMAX(VAR_0->h_edge_pos - (VAR_6 & 1) - 8, 0) ||\n(unsigned)VAR_4 > FFMAX(VAR_0->v_edge_pos - (VAR_7 & 1) - 8, 0)) {", "VAR_0->vdsp.emulated_edge_mc(VAR_0->edge_emu_buffer, VAR_2,\nVAR_0->linesize, VAR_0->linesize,\n9, 9,\nVAR_3, VAR_4,\nVAR_0->h_edge_pos, VAR_0->v_edge_pos);", "VAR_2 = VAR_0->edge_emu_buffer;", "VAR_9 = 1;", "}", "VAR_5[VAR_8](VAR_1, VAR_2, VAR_0->linesize, 8);", "return VAR_9;", "}" ]

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

[ "static inline void FUNC_0(float *VAR_0)\n{", "int VAR_1;", "for (VAR_1 = 0; VAR_1 < 256; VAR_1++) {", "VAR_0[VAR_1] += VAR_0[VAR_1 + 256];", "VAR_0[VAR_1 + 256] = 0;", "}", "}" ]

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

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

[ "SCSIDevice *FUNC_0(SCSIBus *bus, DriveInfo *dinfo, int unit)\n{", "const char *VAR_0;", "DeviceState *dev;", "VAR_0 = bdrv_is_sg(dinfo->bdrv) ? \"scsi-generic\" : \"scsi-disk\";", "dev = qdev_create(&bus->qbus, VAR_0);", "qdev_prop_set_uint32(dev, \"scsi-id\", unit);", "qdev_prop_set_drive(dev, \"drive\", dinfo);", "qdev_init(dev);", "return DO_UPCAST(SCSIDevice, qdev, dev);", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "FilmDemuxContext *film = VAR_0->priv_data;", "av_free(film->sample_table);", "av_free(film->stereo_buffer);", "return 0;", "}" ]

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

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

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "SchroDecoderParams *p_schro_params = avctx->priv_data;", "schro_init();", "schro_debug_set_level(avctx->debug);", "p_schro_params->decoder = schro_decoder_new();", "schro_decoder_set_skip_ratio(p_schro_params->decoder, 1);", "if (!p_schro_params->decoder)\nreturn -1;", "ff_schro_queue_init(&p_schro_params->dec_frame_queue);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 7 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 31 ], [ 33 ], [ 35 ] ]

[ "static void FUNC_0(AVFormatContext *VAR_0)\n{", "int64_t start_time, start_time1, start_time_text, end_time, end_time1;", "int64_t duration, duration1, filesize;", "int VAR_1;", "AVStream *st;", "AVProgram *p;", "start_time = INT64_MAX;", "start_time_text = INT64_MAX;", "end_time = INT64_MIN;", "duration = INT64_MIN;", "for(VAR_1 = 0;VAR_1 < VAR_0->nb_streams; VAR_1++) {", "st = VAR_0->streams[VAR_1];", "if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {", "start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);", "if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {", "if (start_time1 < start_time_text)\nstart_time_text = start_time1;", "} else", "start_time = FFMIN(start_time, start_time1);", "end_time1 = AV_NOPTS_VALUE;", "if (st->duration != AV_NOPTS_VALUE) {", "end_time1 = start_time1\n+ av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);", "end_time = FFMAX(end_time, end_time1);", "}", "for(p = NULL; (p = av_find_program_from_stream(VAR_0, p, VAR_1)); ){", "if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)\np->start_time = start_time1;", "if(p->end_time < end_time1)\np->end_time = end_time1;", "}", "}", "if (st->duration != AV_NOPTS_VALUE) {", "duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);", "duration = FFMAX(duration, duration1);", "}", "}", "if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))\nstart_time = start_time_text;", "else if(start_time > start_time_text)\nav_log(VAR_0, AV_LOG_VERBOSE, \"Ignoring outlier non primary stream starttime %f\\n\", start_time_text / (float)AV_TIME_BASE);", "if (start_time != INT64_MAX) {", "VAR_0->start_time = start_time;", "if (end_time != INT64_MIN) {", "if (VAR_0->nb_programs) {", "for (VAR_1=0; VAR_1<VAR_0->nb_programs; VAR_1++) {", "p = VAR_0->programs[VAR_1];", "if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)\nduration = FFMAX(duration, p->end_time - p->start_time);", "}", "} else", "duration = FFMAX(duration, end_time - start_time);", "}", "}", "if (duration != INT64_MIN && duration > 0 && VAR_0->duration == AV_NOPTS_VALUE) {", "VAR_0->duration = duration;", "}", "if (VAR_0->pb && (filesize = avio_size(VAR_0->pb)) > 0 && VAR_0->duration != AV_NOPTS_VALUE) {", "VAR_0->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /\n(double)VAR_0->duration;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 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 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101, 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125, 127 ], [ 129 ], [ 131 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,\nError **VAR_3)\n{", "int VAR_4, VAR_5;", "uint32_t vid = 0;", "BDRVSheepdogState *s = VAR_0->opaque;", "char VAR_6[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];", "uint32_t snapid;", "char *VAR_7 = NULL;", "QemuOpts *opts;", "Error *local_err = NULL;", "const char *VAR_8;", "s->VAR_0 = VAR_0;", "s->aio_context = bdrv_get_aio_context(VAR_0);", "opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);", "qemu_opts_absorb_qdict(opts, VAR_1, &local_err);", "if (local_err) {", "error_propagate(VAR_3, local_err);", "VAR_4 = -EINVAL;", "goto err_no_fd;", "}", "VAR_8 = qemu_opt_get(opts, \"VAR_8\");", "QLIST_INIT(&s->inflight_aio_head);", "QLIST_INIT(&s->failed_aio_head);", "QLIST_INIT(&s->inflight_aiocb_head);", "s->VAR_5 = -1;", "memset(VAR_6, 0, sizeof(VAR_6));", "memset(tag, 0, sizeof(tag));", "if (strstr(VAR_8, \":\nVAR_4 = sd_parse_uri(s, VAR_8, VAR_6, &snapid, tag);", "} else {", "VAR_4 = parse_vdiname(s, VAR_8, VAR_6, &snapid, tag);", "}", "if (VAR_4 < 0) {", "error_setg(VAR_3, \"Can't parse VAR_8\");", "goto err_no_fd;", "}", "s->VAR_5 = get_sheep_fd(s, VAR_3);", "if (s->VAR_5 < 0) {", "VAR_4 = s->VAR_5;", "goto err_no_fd;", "}", "VAR_4 = find_vdi_name(s, VAR_6, snapid, tag, &vid, true, VAR_3);", "if (VAR_4) {", "goto err;", "}", "s->cache_flags = SD_FLAG_CMD_CACHE;", "if (VAR_2 & BDRV_O_NOCACHE) {", "s->cache_flags = SD_FLAG_CMD_DIRECT;", "}", "s->discard_supported = true;", "if (snapid || tag[0] != '\\0') {", "DPRINTF(\"%\" PRIx32 \" snapshot inode was open.\\n\", vid);", "s->is_snapshot = true;", "}", "VAR_5 = connect_to_sdog(s, VAR_3);", "if (VAR_5 < 0) {", "VAR_4 = VAR_5;", "goto err;", "}", "VAR_7 = g_malloc(SD_INODE_SIZE);", "VAR_4 = read_object(VAR_5, s->VAR_0, VAR_7, vid_to_vdi_oid(vid),\n0, SD_INODE_SIZE, 0, s->cache_flags);", "closesocket(VAR_5);", "if (VAR_4) {", "error_setg(VAR_3, \"Can't read snapshot inode\");", "goto err;", "}", "memcpy(&s->inode, VAR_7, sizeof(s->inode));", "VAR_0->total_sectors = s->inode.vdi_size / BDRV_SECTOR_SIZE;", "pstrcpy(s->name, sizeof(s->name), VAR_6);", "qemu_co_mutex_init(&s->lock);", "qemu_co_queue_init(&s->overlapping_queue);", "qemu_opts_del(opts);", "g_free(VAR_7);", "return 0;", "err:\naio_set_fd_handler(bdrv_get_aio_context(VAR_0), s->VAR_5,\nfalse, NULL, NULL, NULL, NULL);", "closesocket(s->VAR_5);", "err_no_fd:\nqemu_opts_del(opts);", "g_free(VAR_7);", "return VAR_4;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153, 155 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 193, 195, 197 ], [ 199 ], [ 201, 203 ], [ 205 ], [ 207 ], [ 209 ] ]

[ "static void FUNC_0 (VncState *VAR_0) {", "char VAR_1[3] = { 0, 0, 0 };", "vnc_write_u8(VAR_0, VAR_0->depth * 8);", "if (VAR_0->depth == 4) vnc_write_u8(VAR_0, 24);", "else vnc_write_u8(VAR_0, VAR_0->depth * 8);", "#ifdef WORDS_BIGENDIAN\nvnc_write_u8(VAR_0, 1);", "#else\nvnc_write_u8(VAR_0, 0);", "#endif\nvnc_write_u8(VAR_0, 1);", "if (VAR_0->depth == 4) {", "vnc_write_u16(VAR_0, 0xFF);", "vnc_write_u16(VAR_0, 0xFF);", "vnc_write_u16(VAR_0, 0xFF);", "vnc_write_u8(VAR_0, 16);", "vnc_write_u8(VAR_0, 8);", "vnc_write_u8(VAR_0, 0);", "VAR_0->send_hextile_tile = send_hextile_tile_32;", "} else if (VAR_0->depth == 2) {", "vnc_write_u16(VAR_0, 31);", "vnc_write_u16(VAR_0, 63);", "vnc_write_u16(VAR_0, 31);", "vnc_write_u8(VAR_0, 11);", "vnc_write_u8(VAR_0, 5);", "vnc_write_u8(VAR_0, 0);", "VAR_0->send_hextile_tile = send_hextile_tile_16;", "} else if (VAR_0->depth == 1) {", "vnc_write_u16(VAR_0, 7);", "vnc_write_u16(VAR_0, 7);", "vnc_write_u16(VAR_0, 3);", "vnc_write_u8(VAR_0, 5);", "vnc_write_u8(VAR_0, 2);", "vnc_write_u8(VAR_0, 0);", "VAR_0->send_hextile_tile = send_hextile_tile_8;", "}", "VAR_0->client_red_max = VAR_0->server_red_max;", "VAR_0->client_green_max = VAR_0->server_green_max;", "VAR_0->client_blue_max = VAR_0->server_blue_max;", "VAR_0->client_red_shift = VAR_0->server_red_shift;", "VAR_0->client_green_shift = VAR_0->server_green_shift;", "VAR_0->client_blue_shift = VAR_0->server_blue_shift;", "VAR_0->pix_bpp = VAR_0->depth * 8;", "VAR_0->write_pixels = vnc_write_pixels_copy;", "vnc_write(VAR_0, VAR_1, 3);", "}" ]

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

[ [ 1 ], [ 3 ], [ 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 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ] ]

[ "static int FUNC_0(VP8Context *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "VP56RangeCoder *c = &VAR_0->c;", "int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;", "int VAR_12 = VAR_0->avctx->VAR_12;", "int VAR_13 = VAR_0->avctx->VAR_13;", "VAR_0->keyframe = !(VAR_1[0] & 1);", "VAR_0->profile = (VAR_1[0]>>1) & 7;", "VAR_0->invisible = !(VAR_1[0] & 0x10);", "VAR_3 = AV_RL24(VAR_1) >> 5;", "VAR_1 += 3;", "VAR_2 -= 3;", "if (VAR_0->profile > 3)\nav_log(VAR_0->avctx, AV_LOG_WARNING, \"Unknown profile %d\\n\", VAR_0->profile);", "if (!VAR_0->profile)\nmemcpy(VAR_0->put_pixels_tab, VAR_0->vp8dsp.put_vp8_epel_pixels_tab, sizeof(VAR_0->put_pixels_tab));", "else\nmemcpy(VAR_0->put_pixels_tab, VAR_0->vp8dsp.put_vp8_bilinear_pixels_tab, sizeof(VAR_0->put_pixels_tab));", "if (VAR_3 > VAR_2 - 7*VAR_0->keyframe) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Header size larger than data provided\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_0->keyframe) {", "if (AV_RL24(VAR_1) != 0x2a019d) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid start code 0x%x\\n\", AV_RL24(VAR_1));", "return AVERROR_INVALIDDATA;", "}", "VAR_12 = AV_RL16(VAR_1+3) & 0x3fff;", "VAR_13 = AV_RL16(VAR_1+5) & 0x3fff;", "VAR_4 = VAR_1[4] >> 6;", "VAR_5 = VAR_1[6] >> 6;", "VAR_1 += 7;", "VAR_2 -= 7;", "if (VAR_4 || VAR_5)\nav_log_missing_feature(VAR_0->avctx, \"Upscaling\", 1);", "VAR_0->update_golden = VAR_0->update_altref = VP56_FRAME_CURRENT;", "for (VAR_6 = 0; VAR_6 < 4; VAR_6++)", "for (VAR_7 = 0; VAR_7 < 16; VAR_7++)", "memcpy(VAR_0->prob->token[VAR_6][VAR_7], vp8_token_default_probs[VAR_6][vp8_coeff_band[VAR_7]],\nsizeof(VAR_0->prob->token[VAR_6][VAR_7]));", "memcpy(VAR_0->prob->pred16x16, vp8_pred16x16_prob_inter, sizeof(VAR_0->prob->pred16x16));", "memcpy(VAR_0->prob->pred8x8c , vp8_pred8x8c_prob_inter , sizeof(VAR_0->prob->pred8x8c));", "memcpy(VAR_0->prob->mvc , vp8_mv_default_prob , sizeof(VAR_0->prob->mvc));", "memset(&VAR_0->segmentation, 0, sizeof(VAR_0->segmentation));", "}", "if (!VAR_0->macroblocks_base ||\nVAR_12 != VAR_0->avctx->VAR_12 || VAR_13 != VAR_0->avctx->VAR_13) {", "if ((VAR_11 = update_dimensions(VAR_0, VAR_12, VAR_13)) < 0)\nreturn VAR_11;", "}", "ff_vp56_init_range_decoder(c, VAR_1, VAR_3);", "VAR_1 += VAR_3;", "VAR_2 -= VAR_3;", "if (VAR_0->keyframe) {", "if (vp8_rac_get(c))\nav_log(VAR_0->avctx, AV_LOG_WARNING, \"Unspecified colorspace\\n\");", "vp8_rac_get(c);", "}", "if ((VAR_0->segmentation.enabled = vp8_rac_get(c)))\nparse_segment_info(VAR_0);", "else\nVAR_0->segmentation.update_map = 0;", "VAR_0->filter.simple = vp8_rac_get(c);", "VAR_0->filter.level = vp8_rac_get_uint(c, 6);", "VAR_0->filter.sharpness = vp8_rac_get_uint(c, 3);", "if ((VAR_0->lf_delta.enabled = vp8_rac_get(c)))\nif (vp8_rac_get(c))\nupdate_lf_deltas(VAR_0);", "if (setup_partitions(VAR_0, VAR_1, VAR_2)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid partitions\\n\");", "return AVERROR_INVALIDDATA;", "}", "get_quants(VAR_0);", "if (!VAR_0->keyframe) {", "update_refs(VAR_0);", "VAR_0->sign_bias[VP56_FRAME_GOLDEN] = vp8_rac_get(c);", "VAR_0->sign_bias[VP56_FRAME_GOLDEN2 ] = vp8_rac_get(c);", "}", "if (!(VAR_0->update_probabilities = vp8_rac_get(c)))\nVAR_0->prob[1] = VAR_0->prob[0];", "VAR_0->update_last = VAR_0->keyframe || vp8_rac_get(c);", "for (VAR_6 = 0; VAR_6 < 4; VAR_6++)", "for (VAR_7 = 0; VAR_7 < 8; VAR_7++)", "for (VAR_8 = 0; VAR_8 < 3; VAR_8++)", "for (VAR_9 = 0; VAR_9 < NUM_DCT_TOKENS-1; VAR_9++)", "if (vp56_rac_get_prob_branchy(c, vp8_token_update_probs[VAR_6][VAR_7][VAR_8][VAR_9])) {", "int prob = vp8_rac_get_uint(c, 8);", "for (VAR_10 = 0; vp8_coeff_band_indexes[VAR_7][VAR_10] >= 0; VAR_10++)", "VAR_0->prob->token[VAR_6][vp8_coeff_band_indexes[VAR_7][VAR_10]][VAR_8][VAR_9] = prob;", "}", "if ((VAR_0->mbskip_enabled = vp8_rac_get(c)))\nVAR_0->prob->mbskip = vp8_rac_get_uint(c, 8);", "if (!VAR_0->keyframe) {", "VAR_0->prob->intra = vp8_rac_get_uint(c, 8);", "VAR_0->prob->last = vp8_rac_get_uint(c, 8);", "VAR_0->prob->golden = vp8_rac_get_uint(c, 8);", "if (vp8_rac_get(c))\nfor (VAR_6 = 0; VAR_6 < 4; VAR_6++)", "VAR_0->prob->pred16x16[VAR_6] = vp8_rac_get_uint(c, 8);", "if (vp8_rac_get(c))\nfor (VAR_6 = 0; VAR_6 < 3; VAR_6++)", "VAR_0->prob->pred8x8c[VAR_6] = vp8_rac_get_uint(c, 8);", "for (VAR_6 = 0; VAR_6 < 2; VAR_6++)", "for (VAR_7 = 0; VAR_7 < 19; VAR_7++)", "if (vp56_rac_get_prob_branchy(c, vp8_mv_update_prob[VAR_6][VAR_7]))\nVAR_0->prob->mvc[VAR_6][VAR_7] = vp8_rac_get_nn(c);", "}", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 35, 37 ], [ 39, 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79, 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91, 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107, 109 ], [ 111, 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 129, 131 ], [ 133 ], [ 135 ], [ 139, 141 ], [ 143, 145 ], [ 149 ], [ 151 ], [ 153 ], [ 157, 159, 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 195, 197 ], [ 201 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 225, 227 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 241, 243 ], [ 245 ], [ 247, 249 ], [ 251 ], [ 257 ], [ 259 ], [ 261, 263 ], [ 265 ], [ 269 ], [ 271 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0,\nint64_t VAR_1)\n{", "BDRVQcowState *s = VAR_0->opaque;", "int VAR_2;", "if (cache_refcount_updates) {", "VAR_2 = write_refcount_block(VAR_0);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "}", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_LOAD);", "VAR_2 = bdrv_pread(VAR_0->file, VAR_1, s->refcount_block_cache,\ns->cluster_size);", "if (VAR_2 < 0) {", "return VAR_2;", "}", "s->refcount_block_cache_offset = VAR_1;", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 36 ], [ 38 ], [ 42 ], [ 44 ], [ 46 ] ]

[ "void FUNC_0(Coroutine *VAR_0, void *VAR_1)\n{", "Coroutine *self = qemu_coroutine_self();", "CoroutineAction ret;", "trace_qemu_coroutine_enter(self, VAR_0, VAR_1);", "if (VAR_0->caller) {", "fprintf(stderr, \"Co-routine re-entered recursively\\n\");", "abort();", "}", "VAR_0->caller = self;", "VAR_0->entry_arg = VAR_1;", "ret = qemu_coroutine_switch(self, VAR_0, COROUTINE_ENTER);", "qemu_co_queue_run_restart(VAR_0);", "switch (ret) {", "case COROUTINE_YIELD:\nreturn;", "case COROUTINE_TERMINATE:\ntrace_qemu_coroutine_terminate(VAR_0);", "coroutine_delete(VAR_0);", "return;", "default:\nabort();", "}", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "AVFrame *frame = VAR_1;", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "int VAR_6, VAR_7;", "IMCContext *q = VAR_0->priv_data;", "LOCAL_ALIGNED_16(uint16_t, buf16, [IMC_BLOCK_SIZE / 2]);", "if (VAR_5 < IMC_BLOCK_SIZE * VAR_0->channels) {", "av_log(VAR_0, AV_LOG_ERROR, \"frame too small!\\n\");", "return AVERROR_INVALIDDATA;", "}", "frame->nb_samples = COEFFS;", "if ((VAR_6 = ff_get_buffer(VAR_0, frame, 0)) < 0)\nreturn VAR_6;", "for (VAR_7 = 0; VAR_7 < VAR_0->channels; VAR_7++) {", "q->out_samples = (float *)frame->extended_data[VAR_7];", "q->bdsp.bswap16_buf(buf16, (const uint16_t *) VAR_4, IMC_BLOCK_SIZE / 2);", "init_get_bits(&q->gb, (const uint8_t*)buf16, IMC_BLOCK_SIZE * 8);", "VAR_4 += IMC_BLOCK_SIZE;", "if ((VAR_6 = imc_decode_block(VAR_0, q, VAR_7)) < 0)\nreturn VAR_6;", "}", "if (VAR_0->channels == 2) {", "q->fdsp.butterflies_float((float *)frame->extended_data[0],\n(float *)frame->extended_data[1], COEFFS);", "}", "*VAR_2 = 1;", "return IMC_BLOCK_SIZE * VAR_0->channels;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 37 ], [ 39, 41 ], [ 45 ], [ 47 ], [ 51 ], [ 55 ], [ 59 ], [ 63, 65 ], [ 67 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 81 ], [ 85 ], [ 87 ] ]

[ "int FUNC_0(VLC *VAR_0, int VAR_1, int VAR_2,\nconst void *VAR_3, int VAR_4, int VAR_5,\nconst void *VAR_6, int VAR_7, int VAR_8)\n{", "VAR_0->VAR_3 = VAR_1;", "VAR_0->table = NULL;", "VAR_0->table_allocated = 0;", "VAR_0->table_size = 0;", "#ifdef DEBUG_VLC\nprintf(\"build table VAR_2=%d\\n\", VAR_2);", "#endif\nif (build_table(VAR_0, VAR_1, VAR_2,\nVAR_3, VAR_4, VAR_5,\nVAR_6, VAR_7, VAR_8,\n0, 0) < 0) {", "av_free(VAR_0->table);", "return -1;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(AVFilterContext *VAR_0)\n{", "IDETContext *idet = VAR_0->priv;", "int VAR_1, VAR_2;", "int64_t alpha[2]={0};", "int64_t delta=0;", "Type type, best_type;", "int VAR_3 = 0;", "for (VAR_2 = 0; VAR_2 < idet->csp->nb_components; VAR_2++) {", "int w = idet->cur->video->w;", "int h = idet->cur->video->h;", "int refs = idet->cur->linesize[VAR_2];", "if (VAR_2 && VAR_2<3) {", "w >>= idet->csp->log2_chroma_w;", "h >>= idet->csp->log2_chroma_h;", "}", "for (VAR_1 = 2; VAR_1 < h - 2; VAR_1++) {", "uint8_t *prev = &idet->prev->data[VAR_2][VAR_1*refs];", "uint8_t *cur = &idet->cur ->data[VAR_2][VAR_1*refs];", "uint8_t *next = &idet->next->data[VAR_2][VAR_1*refs];", "alpha[ VAR_1 &1] += idet->filter_line(cur-refs, prev, cur+refs, w);", "alpha[(VAR_1^1)&1] += idet->filter_line(cur-refs, next, cur+refs, w);", "delta += idet->filter_line(cur-refs, cur, cur+refs, w);", "}", "}", "if (alpha[0] / (float)alpha[1] > idet->interlace_threshold){", "type = TFF;", "}else if(alpha[1] / (float)alpha[0] > idet->interlace_threshold){", "type = BFF;", "}else if(alpha[1] / (float)delta > idet->progressive_threshold){", "type = PROGRSSIVE;", "}else{", "type = UNDETERMINED;", "}", "memmove(idet->history+1, idet->history, HIST_SIZE-1);", "idet->history[0] = type;", "best_type = UNDETERMINED;", "for(VAR_2=0; VAR_2<HIST_SIZE; VAR_2++){", "if(idet->history[VAR_2] != UNDETERMINED){", "if(best_type == UNDETERMINED)\nbest_type = idet->history[VAR_2];", "if(idet->history[VAR_2] == best_type) {", "VAR_3++;", "}else{", "VAR_3=0;", "break;", "}", "}", "}", "if(idet->last_type == UNDETERMINED){", "if(VAR_3 ) idet->last_type = best_type;", "}else{", "if(VAR_3>2) idet->last_type = best_type;", "}", "if (idet->last_type == TFF){", "idet->cur->video->top_field_first = 1;", "idet->cur->video->interlaced = 1;", "}else if(idet->last_type == BFF){", "idet->cur->video->top_field_first = 0;", "idet->cur->video->interlaced = 1;", "}else if(idet->last_type == PROGRSSIVE){", "idet->cur->video->interlaced = 0;", "}", "idet->prestat [ type] ++;", "idet->poststat[idet->last_type] ++;", "av_log(VAR_0, AV_LOG_DEBUG, \"Single frame:%s, Multi frame:%s\\n\", type2str(type), type2str(idet->last_type));", "}" ]

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

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

[ "static void FUNC_0(uint64_t *VAR_0, uint64_t *VAR_1, uint64_t VAR_2)\n{", "uint64_t q, r, a1, a0;", "int VAR_3, VAR_4;", "a0 = *VAR_0;", "a1 = *VAR_1;", "if (a1 == 0) {", "q = a0 / VAR_2;", "r = a0 % VAR_2;", "*VAR_0 = q;", "*VAR_1 = r;", "} else {", "for(VAR_3 = 0; VAR_3 < 64; VAR_3++) {", "a1 = (a1 << 1) | (a0 >> 63);", "if (a1 >= VAR_2) {", "a1 -= VAR_2;", "VAR_4 = 1;", "} else {", "VAR_4 = 0;", "}", "a0 = (a0 << 1) | VAR_4;", "}", "#if defined(DEBUG_MULDIV)\nprintf(\"div: 0x%016llx%016llx / 0x%016llx: q=0x%016llx r=0x%016llx\\n\",\n*VAR_1, *VAR_0, VAR_2, a0, a1);", "#endif\n*VAR_0 = a0;", "*VAR_1 = a1;", "}", "}" ]

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

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

[ "static float FUNC_0(struct AACEncContext *VAR_0,\nPutBitContext *VAR_1, const float *VAR_2,\nconst float *VAR_3, int VAR_4, int VAR_5,\nint VAR_6, const float VAR_7, const float VAR_8,\nint *VAR_9)\n{", "const float VAR_10 = ff_aac_pow34sf_tab[POW_SF2_ZERO - VAR_5 + SCALE_ONE_POS - SCALE_DIV_512];", "const float VAR_11 = ff_aac_pow2sf_tab [POW_SF2_ZERO + VAR_5 - SCALE_ONE_POS + SCALE_DIV_512];", "int VAR_12;", "float VAR_13 = 0;", "int VAR_14, VAR_15, VAR_16, VAR_17;", "int VAR_18 = 0;", "uint8_t *p_bits = (uint8_t *)ff_aac_spectral_bits[VAR_6-1];", "float *VAR_19 = (float *)ff_aac_codebook_vectors[VAR_6-1];", "for (VAR_12 = 0; VAR_12 < VAR_4; VAR_12 += 4) {", "const float *VAR_20, *VAR_21;", "int VAR_22, VAR_23;", "int VAR_24, VAR_25, VAR_26, VAR_27;", "int *VAR_28 = (int *)&VAR_2[VAR_12];", "float *VAR_29 = (float *)&VAR_2[VAR_12];", "float VAR_30, VAR_31, VAR_32, VAR_33;", "int VAR_34, VAR_35, VAR_36, VAR_37, VAR_38;", "VAR_14 = VAR_3[VAR_12 ] * VAR_10 + ROUND_STANDARD;", "VAR_15 = VAR_3[VAR_12+1] * VAR_10 + ROUND_STANDARD;", "VAR_16 = VAR_3[VAR_12+2] * VAR_10 + ROUND_STANDARD;", "VAR_17 = VAR_3[VAR_12+3] * VAR_10 + ROUND_STANDARD;", "__asm__ volatile (\n\".set push \\n\\t\"\n\".set noreorder \\n\\t\"\n\"ori %[VAR_38], $zero, 12 \\n\\t\"\n\"ori %[VAR_24], $zero, 0 \\n\\t\"\n\"ori %[VAR_26], $zero, 0 \\n\\t\"\n\"slt %[VAR_34], %[VAR_38], %[VAR_14] \\n\\t\"\n\"slt %[VAR_35], %[VAR_38], %[VAR_15] \\n\\t\"\n\"slt %[VAR_36], %[VAR_38], %[VAR_16] \\n\\t\"\n\"slt %[VAR_37], %[VAR_38], %[VAR_17] \\n\\t\"\n\"movn %[VAR_14], %[VAR_38], %[VAR_34] \\n\\t\"\n\"movn %[VAR_15], %[VAR_38], %[VAR_35] \\n\\t\"\n\"movn %[VAR_16], %[VAR_38], %[VAR_36] \\n\\t\"\n\"movn %[VAR_17], %[VAR_38], %[VAR_37] \\n\\t\"\n\"lw %[VAR_34], 0(%[VAR_28]) \\n\\t\"\n\"lw %[VAR_35], 4(%[VAR_28]) \\n\\t\"\n\"lw %[VAR_36], 8(%[VAR_28]) \\n\\t\"\n\"lw %[VAR_37], 12(%[VAR_28]) \\n\\t\"\n\"slt %[VAR_34], %[VAR_34], $zero \\n\\t\"\n\"movn %[VAR_24], %[VAR_34], %[VAR_14] \\n\\t\"\n\"slt %[VAR_36], %[VAR_36], $zero \\n\\t\"\n\"movn %[VAR_26], %[VAR_36], %[VAR_16] \\n\\t\"\n\"slt %[VAR_35], %[VAR_35], $zero \\n\\t\"\n\"sll %[VAR_34], %[VAR_24], 1 \\n\\t\"\n\"or %[VAR_34], %[VAR_34], %[VAR_35] \\n\\t\"\n\"movn %[VAR_24], %[VAR_34], %[VAR_15] \\n\\t\"\n\"slt %[VAR_37], %[VAR_37], $zero \\n\\t\"\n\"sll %[VAR_34], %[VAR_26], 1 \\n\\t\"\n\"or %[VAR_34], %[VAR_34], %[VAR_37] \\n\\t\"\n\"movn %[VAR_26], %[VAR_34], %[VAR_17] \\n\\t\"\n\"slt %[VAR_25], $zero, %[VAR_14] \\n\\t\"\n\"slt %[VAR_35], $zero, %[VAR_15] \\n\\t\"\n\"slt %[VAR_27], $zero, %[VAR_16] \\n\\t\"\n\"slt %[VAR_36], $zero, %[VAR_17] \\n\\t\"\n\"addu %[VAR_25], %[VAR_25], %[VAR_35] \\n\\t\"\n\"addu %[VAR_27], %[VAR_27], %[VAR_36] \\n\\t\"\n\".set pop \\n\\t\"\n: [VAR_14]\"+r\"(VAR_14), [VAR_15]\"+r\"(VAR_15),\n[VAR_16]\"+r\"(VAR_16), [VAR_17]\"+r\"(VAR_17),\n[VAR_24]\"=&r\"(VAR_24), [VAR_25]\"=&r\"(VAR_25),\n[VAR_26]\"=&r\"(VAR_26), [VAR_27]\"=&r\"(VAR_27),\n[VAR_34]\"=&r\"(VAR_34), [VAR_35]\"=&r\"(VAR_35), [VAR_36]\"=&r\"(VAR_36), [VAR_37]\"=&r\"(VAR_37),\n[VAR_38]\"=&r\"(VAR_38)\n: [VAR_28]\"r\"(VAR_28)\n: \"memory\"\n);", "VAR_22 = 13 * VAR_14;", "VAR_22 += VAR_15;", "VAR_23 = 13 * VAR_16;", "VAR_23 += VAR_17;", "VAR_18 += p_bits[VAR_22];", "VAR_18 += p_bits[VAR_23];", "VAR_18 += upair12_sign_bits[VAR_22];", "VAR_18 += upair12_sign_bits[VAR_23];", "VAR_20 = &VAR_19[VAR_22*2];", "VAR_21 = &VAR_19[VAR_23*2];", "__asm__ volatile (\n\".set push \\n\\t\"\n\".set noreorder \\n\\t\"\n\"lwc1 %[VAR_30], 0(%[VAR_29]) \\n\\t\"\n\"lwc1 %[VAR_31], 4(%[VAR_29]) \\n\\t\"\n\"lwc1 %[VAR_32], 8(%[VAR_29]) \\n\\t\"\n\"lwc1 %[VAR_33], 12(%[VAR_29]) \\n\\t\"\n\"abs.VAR_0 %[VAR_30], %[VAR_30] \\n\\t\"\n\"abs.VAR_0 %[VAR_31], %[VAR_31] \\n\\t\"\n\"abs.VAR_0 %[VAR_32], %[VAR_32] \\n\\t\"\n\"abs.VAR_0 %[VAR_33], %[VAR_33] \\n\\t\"\n\"lwc1 $f0, 0(%[VAR_20]) \\n\\t\"\n\"lwc1 $f1, 4(%[VAR_20]) \\n\\t\"\n\"lwc1 $f2, 0(%[VAR_21]) \\n\\t\"\n\"lwc1 $f3, 4(%[VAR_21]) \\n\\t\"\n\"nmsub.VAR_0 %[VAR_30], %[VAR_30], $f0, %[VAR_11] \\n\\t\"\n\"nmsub.VAR_0 %[VAR_31], %[VAR_31], $f1, %[VAR_11] \\n\\t\"\n\"nmsub.VAR_0 %[VAR_32], %[VAR_32], $f2, %[VAR_11] \\n\\t\"\n\"nmsub.VAR_0 %[VAR_33], %[VAR_33], $f3, %[VAR_11] \\n\\t\"\n\".set pop \\n\\t\"\n: [VAR_30]\"=&f\"(VAR_30), [VAR_31]\"=&f\"(VAR_31),\n[VAR_32]\"=&f\"(VAR_32), [VAR_33]\"=&f\"(VAR_33)\n: [VAR_29]\"r\"(VAR_29), [VAR_20]\"r\"(VAR_20),\n[VAR_21]\"r\"(VAR_21), [VAR_11]\"f\"(VAR_11)\n: \"$f0\", \"$f1\", \"$f2\", \"$f3\",\n\"memory\"\n);", "VAR_13 += VAR_30 * VAR_30 + VAR_31 * VAR_31\n+ VAR_32 * VAR_32 + VAR_33 * VAR_33;", "}", "if (VAR_9)\n*VAR_9 = VAR_18;", "return VAR_13 * VAR_7 + VAR_18;", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61, 63, 65, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 137, 141, 143, 145, 147, 149, 151, 153, 155, 157 ], [ 161 ], [ 163 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 187, 189, 191, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 229, 233, 235, 237, 239, 241, 243, 245 ], [ 249, 251 ], [ 253 ], [ 257, 259 ], [ 261 ], [ 263 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, const AVFrame *VAR_1, opj_image_t *VAR_2)\n{", "int VAR_3;", "int VAR_4;", "int VAR_5;", "int VAR_6;", "int VAR_7;", "int *VAR_8;", "int VAR_9;", "const int VAR_10 = VAR_2->VAR_10;", "uint16_t *frame_ptr;", "for (VAR_3 = 0; VAR_3 < VAR_10; ++VAR_3) {", "if (VAR_2->comps[VAR_3].w > VAR_1->linesize[VAR_3]) {", "av_log(VAR_0, AV_LOG_ERROR, \"Error: VAR_1's linesize is too small for the VAR_2\\n\");", "return 0;", "}", "}", "for (VAR_3 = 0; VAR_3 < VAR_10; ++VAR_3) {", "VAR_6 = VAR_0->VAR_6 / VAR_2->comps[VAR_3].dx;", "VAR_7 = VAR_0->VAR_7 / VAR_2->comps[VAR_3].dy;", "frame_ptr = (uint16_t *)VAR_1->data[VAR_3];", "for (VAR_5 = 0; VAR_5 < VAR_7; ++VAR_5) {", "VAR_8 = VAR_2->comps[VAR_3].data + VAR_5 * VAR_2->comps[VAR_3].w;", "VAR_9 = VAR_5 * (VAR_1->linesize[VAR_3] / 2);", "for (VAR_4 = 0; VAR_4 < VAR_6; ++VAR_4)", "VAR_8[VAR_4] = frame_ptr[VAR_9++];", "for (; VAR_4 < VAR_2->comps[VAR_3].w; ++VAR_4) {", "VAR_8[VAR_4] = VAR_8[VAR_4 - 1];", "}", "}", "for (; VAR_5 < VAR_2->comps[VAR_3].h; ++VAR_5) {", "VAR_8 = VAR_2->comps[VAR_3].data + VAR_5 * VAR_2->comps[VAR_3].w;", "for (VAR_4 = 0; VAR_4 < VAR_2->comps[VAR_3].w; ++VAR_4) {", "VAR_8[VAR_4] = VAR_8[VAR_4 - VAR_2->comps[VAR_3].w];", "}", "}", "}", "return 1;", "}" ]

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

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

[ "inline static void FUNC_0(hcscale)(uint16_t *dst, int dstWidth, uint8_t *src1, uint8_t *src2,\nint srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter,\nint16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode,\nint srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,\nint32_t *mmx2FilterPos)\n{", "if(srcFormat==IMGFMT_YUY2)\n{", "FUNC_0(yuy2ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_UYVY)\n{", "FUNC_0(uyvyToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_BGR32)\n{", "FUNC_0(bgr32ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_BGR24)\n{", "FUNC_0(bgr24ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_BGR16)\n{", "FUNC_0(bgr16ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_BGR15)\n{", "FUNC_0(bgr15ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_RGB32)\n{", "FUNC_0(rgb32ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(srcFormat==IMGFMT_RGB24)\n{", "FUNC_0(rgb24ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);", "src1= formatConvBuffer;", "src2= formatConvBuffer+2048;", "}", "else if(isGray(srcFormat))\n{", "return;", "}", "#ifdef HAVE_MMX\nif(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))\n#else\nif(!(flags&SWS_FAST_BILINEAR))\n#endif\n{", "FUNC_0(hScale)(dst , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);", "FUNC_0(hScale)(dst+2048, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);", "}", "else\n{", "#if defined(ARCH_X86) || defined(ARCH_X86_64)\n#ifdef HAVE_MMX2\nint VAR_0;", "if(canMMX2BeUsed)\n{", "asm volatile(\n\"pxor %%mm7, %%mm7\t\t\\n\\t\"\n\"mov %0, %%\"REG_c\"\t\t\\n\\t\"\n\"mov %1, %%\"REG_D\"\t\t\\n\\t\"\n\"mov %2, %%\"REG_d\"\t\t\\n\\t\"\n\"mov %3, %%\"REG_b\"\t\t\\n\\t\"\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\nPREFETCH\" (%%\"REG_c\")\t\t\\n\\t\"\nPREFETCH\" 32(%%\"REG_c\")\t\t\\n\\t\"\nPREFETCH\" 64(%%\"REG_c\")\t\t\\n\\t\"\n#ifdef ARCH_X86_64\n#define FUNNY_UV_CODE \\\n\"movl (%%\"REG_b\"), %%esi\t\\n\\t\"\\\n\"call *%4\t\t\t\\n\\t\"\\\n\"movl (%%\"REG_b\", %%\"REG_a\"), %%esi\\n\\t\"\\\n\"add %%\"REG_S\", %%\"REG_c\"\t\\n\\t\"\\\n\"add %%\"REG_a\", %%\"REG_D\"\t\\n\\t\"\\\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\\n#else\n#define FUNNY_UV_CODE \\\n\"movl (%%\"REG_b\"), %%esi\t\\n\\t\"\\\n\"call *%4\t\t\t\\n\\t\"\\\n\"addl (%%\"REG_b\", %%\"REG_a\"), %%\"REG_c\"\\n\\t\"\\\n\"add %%\"REG_a\", %%\"REG_D\"\t\\n\\t\"\\\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\\n#endif\nFUNNY_UV_CODE\nFUNNY_UV_CODE\nFUNNY_UV_CODE\nFUNNY_UV_CODE\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\n\"mov %5, %%\"REG_c\"\t\t\\n\\t\"\n\"mov %1, %%\"REG_D\"\t\t\\n\\t\"\n\"add $4096, %%\"REG_D\"\t\t\\n\\t\"\nPREFETCH\" (%%\"REG_c\")\t\t\\n\\t\"\nPREFETCH\" 32(%%\"REG_c\")\t\t\\n\\t\"\nPREFETCH\" 64(%%\"REG_c\")\t\t\\n\\t\"\nFUNNY_UV_CODE\nFUNNY_UV_CODE\nFUNNY_UV_CODE\nFUNNY_UV_CODE\n:: \"m\" (src1), \"m\" (dst), \"m\" (mmx2Filter), \"m\" (mmx2FilterPos),\n\"m\" (funnyUVCode), \"m\" (src2)\n: \"%\"REG_a, \"%\"REG_b, \"%\"REG_c, \"%\"REG_d, \"%\"REG_S, \"%\"REG_D\n);", "for(VAR_0=dstWidth-1; (VAR_0*xInc)>>16 >=srcW-1; VAR_0--)", "{", "dst[VAR_0] = src1[srcW-1]*128;", "dst[VAR_0+2048] = src2[srcW-1]*128;", "}", "}", "else\n{", "#endif\nlong xInc_shr16 = (long) (xInc >> 16);", "int xInc_mask = xInc & 0xffff;", "asm volatile(\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\n\"xor %%\"REG_b\", %%\"REG_b\"\t\t\\n\\t\"\n\"xorl %%ecx, %%ecx\t\t\\n\\t\"\n\".balign 16\t\t\t\\n\\t\"\n\"1:\t\t\t\t\\n\\t\"\n\"mov %0, %%\"REG_S\"\t\t\\n\\t\"\n\"movzbl (%%\"REG_S\", %%\"REG_b\"), %%edi\t\\n\\t\"\n\"movzbl 1(%%\"REG_S\", %%\"REG_b\"), %%esi\t\\n\\t\"\n\"subl %%edi, %%esi\t\t\\n\\t\" - src[xx]\n\"imull %%ecx, %%esi\t\t\\n\\t\"\n\"shll $16, %%edi\t\t\\n\\t\"\n\"addl %%edi, %%esi\t\t\\n\\t\" *2*xalpha + src[xx]*(1-2*xalpha)\n\"mov %1, %%\"REG_D\"\t\t\\n\\t\"\n\"shrl $9, %%esi\t\t\t\\n\\t\"\n\"movw %%si, (%%\"REG_D\", %%\"REG_a\", 2)\\n\\t\"\n\"movzbl (%5, %%\"REG_b\"), %%edi\t\\n\\t\"\n\"movzbl 1(%5, %%\"REG_b\"), %%esi\t\\n\\t\"\n\"subl %%edi, %%esi\t\t\\n\\t\" - src[xx]\n\"imull %%ecx, %%esi\t\t\\n\\t\"\n\"shll $16, %%edi\t\t\\n\\t\"\n\"addl %%edi, %%esi\t\t\\n\\t\" *2*xalpha + src[xx]*(1-2*xalpha)\n\"mov %1, %%\"REG_D\"\t\t\\n\\t\"\n\"shrl $9, %%esi\t\t\t\\n\\t\"\n\"movw %%si, 4096(%%\"REG_D\", %%\"REG_a\", 2)\\n\\t\"\n\"addw %4, %%cx\t\t\t\\n\\t\"\n\"adc %3, %%\"REG_b\"\t\t\\n\\t\"\n\"add $1, %%\"REG_a\"\t\t\\n\\t\"\n\"cmp %2, %%\"REG_a\"\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n#if defined(ARCH_X86_64) && ((__GNUC__ > 3) || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 4))\n:: \"m\" (src1), \"m\" (dst), \"g\" ((long)dstWidth), \"m\" (xInc_shr16), \"m\" (xInc_mask),\n#else\n:: \"m\" (src1), \"m\" (dst), \"m\" ((long)dstWidth), \"m\" (xInc_shr16), \"m\" (xInc_mask),\n#endif\n\"r\" (src2)\n: \"%\"REG_a, \"%\"REG_b, \"%ecx\", \"%\"REG_D, \"%esi\"\n);", "#ifdef HAVE_MMX2\n}", "#endif\n#else\nint VAR_0;", "unsigned int VAR_1=0;", "for(VAR_0=0;VAR_0<dstWidth;VAR_0++)", "{", "register unsigned int xx=VAR_1>>16;", "register unsigned int xalpha=(VAR_1&0xFFFF)>>9;", "dst[VAR_0]=(src1[xx]*(xalpha^127)+src1[xx+1]*xalpha);", "dst[VAR_0+2048]=(src2[xx]*(xalpha^127)+src2[xx+1]*xalpha);", "VAR_1+=xInc;", "}", "#endif\n}", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11 ], [ 13, 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 119, 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, 175, 179, 181, 183, 185, 187, 189, 191, 195, 199, 201, 203, 205, 207, 209, 213, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 241, 243, 245, 247, 251, 253, 255, 257 ], [ 259 ], [ 261 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273, 275 ], [ 277, 279 ], [ 281 ], [ 283, 285, 287, 289, 291, 293, 295, 297, 299, 301, 303, 305, 307, 309, 311, 313, 317, 319, 321, 323, 325, 327, 329, 331, 333, 337, 339, 341, 343, 345, 353, 355, 357, 359, 361, 363, 365, 367 ], [ 369, 371 ], [ 373, 375, 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 401 ], [ 403 ], [ 405, 407 ], [ 409 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "TAKDemuxContext *tc = VAR_0->priv_data;", "AVIOContext *pb = VAR_0->pb;", "GetBitContext gb;", "AVStream *st;", "uint8_t *buffer = NULL;", "int VAR_1;", "st = avformat_new_stream(VAR_0, 0);", "if (!st)\nreturn AVERROR(ENOMEM);", "st->codec->codec_type = AVMEDIA_TYPE_AUDIO;", "st->codec->codec_id = AV_CODEC_ID_TAK;", "st->need_parsing = AVSTREAM_PARSE_FULL_RAW;", "tc->mlast_frame = 0;", "if (avio_rl32(pb) != MKTAG('t', 'B', 'a', 'K')) {", "avio_seek(pb, -4, SEEK_CUR);", "return 0;", "}", "while (!url_feof(pb)) {", "enum TAKMetaDataType VAR_2;", "int VAR_3;", "VAR_2 = avio_r8(pb) & 0x7f;", "VAR_3 = avio_rl24(pb);", "switch (VAR_2) {", "case TAK_METADATA_STREAMINFO:\ncase TAK_METADATA_LAST_FRAME:\ncase TAK_METADATA_ENCODER:\nif (VAR_3 <= 3)\nreturn AVERROR_INVALIDDATA;", "buffer = av_malloc(VAR_3 - 3 + FF_INPUT_BUFFER_PADDING_SIZE);", "if (!buffer)\nreturn AVERROR(ENOMEM);", "ffio_init_checksum(pb, tak_check_crc, 0xCE04B7U);", "if (avio_read(pb, buffer, VAR_3 - 3) != VAR_3 - 3) {", "av_freep(&buffer);", "return AVERROR(EIO);", "}", "if (ffio_get_checksum(VAR_0->pb) != avio_rb24(pb)) {", "av_log(VAR_0, AV_LOG_ERROR, \"%d metadata block CRC error.\\n\", VAR_2);", "if (VAR_0->error_recognition & AV_EF_EXPLODE) {", "av_freep(&buffer);", "return AVERROR_INVALIDDATA;", "}", "}", "init_get_bits8(&gb, buffer, VAR_3 - 3);", "break;", "case TAK_METADATA_MD5: {", "uint8_t md5[16];", "int VAR_4;", "if (VAR_3 != 19)\nreturn AVERROR_INVALIDDATA;", "ffio_init_checksum(pb, tak_check_crc, 0xCE04B7U);", "avio_read(pb, md5, 16);", "if (ffio_get_checksum(VAR_0->pb) != avio_rb24(pb)) {", "av_log(VAR_0, AV_LOG_ERROR, \"MD5 metadata block CRC error.\\n\");", "if (VAR_0->error_recognition & AV_EF_EXPLODE)\nreturn AVERROR_INVALIDDATA;", "}", "av_log(VAR_0, AV_LOG_VERBOSE, \"MD5=\");", "for (VAR_4 = 0; VAR_4 < 16; VAR_4++)", "av_log(VAR_0, AV_LOG_VERBOSE, \"%02x\", md5[VAR_4]);", "av_log(VAR_0, AV_LOG_VERBOSE, \"\\n\");", "break;", "}", "case TAK_METADATA_END: {", "int64_t curpos = avio_tell(pb);", "if (pb->seekable) {", "ff_ape_parse_tag(VAR_0);", "avio_seek(pb, curpos, SEEK_SET);", "}", "tc->data_end += curpos;", "return 0;", "}", "default:\nVAR_1 = avio_skip(pb, VAR_3);", "if (VAR_1 < 0)\nreturn VAR_1;", "}", "if (VAR_2 == TAK_METADATA_STREAMINFO) {", "TAKStreamInfo ti;", "avpriv_tak_parse_streaminfo(&gb, &ti);", "if (ti.samples > 0)\nst->duration = ti.samples;", "st->codec->bits_per_coded_sample = ti.bps;", "if (ti.ch_layout)\nst->codec->channel_layout = ti.ch_layout;", "st->codec->sample_rate = ti.sample_rate;", "st->codec->channels = ti.channels;", "st->start_time = 0;", "avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);", "st->codec->extradata = buffer;", "st->codec->extradata_size = VAR_3 - 3;", "buffer = NULL;", "} else if (VAR_2 == TAK_METADATA_LAST_FRAME) {", "if (VAR_3 != 11)\nreturn AVERROR_INVALIDDATA;", "tc->mlast_frame = 1;", "tc->data_end = get_bits64(&gb, TAK_LAST_FRAME_POS_BITS) +\nget_bits(&gb, TAK_LAST_FRAME_SIZE_BITS);", "av_freep(&buffer);", "} else if (VAR_2 == TAK_METADATA_ENCODER) {", "av_log(VAR_0, AV_LOG_VERBOSE, \"encoder version: %0X\\n\",\nget_bits_long(&gb, TAK_ENCODER_VERSION_BITS));", "av_freep(&buffer);", "}", "}", "return AVERROR_EOF;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 61 ], [ 63, 65, 67, 69, 71 ], [ 75 ], [ 77, 79 ], [ 84 ], [ 86 ], [ 88 ], [ 90 ], [ 92 ], [ 94 ], [ 96 ], [ 98 ], [ 100 ], [ 102 ], [ 104 ], [ 106 ], [ 110 ], [ 112 ], [ 114 ], [ 116 ], [ 118 ], [ 122, 124 ], [ 126 ], [ 128 ], [ 130 ], [ 132 ], [ 134, 136 ], [ 138 ], [ 142 ], [ 144 ], [ 146 ], [ 148 ], [ 150 ], [ 152 ], [ 154 ], [ 156 ], [ 160 ], [ 162 ], [ 164 ], [ 166 ], [ 170 ], [ 172 ], [ 174 ], [ 176, 178 ], [ 180, 182 ], [ 184 ], [ 188 ], [ 190 ], [ 194 ], [ 196, 198 ], [ 200 ], [ 202, 204 ], [ 206 ], [ 208 ], [ 210 ], [ 212 ], [ 214 ], [ 216 ], [ 218 ], [ 220 ], [ 222, 224 ], [ 226 ], [ 228, 230 ], [ 232 ], [ 234 ], [ 236, 238 ], [ 240 ], [ 242 ], [ 244 ], [ 248 ], [ 250 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "CPUState *env = VAR_0;", "int VAR_1;", "cpu_synchronize_state(env);", "env->fpus_vmstate = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;", "env->fptag_vmstate = 0;", "for(VAR_1 = 0; VAR_1 < 8; VAR_1++) {", "env->fptag_vmstate |= ((!env->fptags[VAR_1]) << VAR_1);", "}", "#ifdef USE_X86LDOUBLE\nenv->fpregs_format_vmstate = 0;", "#else\nenv->fpregs_format_vmstate = 1;", "#endif\n}" ]

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

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

[ "static uint64_t FUNC_0(CPUARMState *env, const ARMCPRegInfo *ri)\n{", "GICv3CPUState *cs = icc_cs_from_env(env);", "uint64_t value = 0;", "int VAR_0;", "for (VAR_0 = 0; VAR_0 < cs->num_list_regs; VAR_0++) {", "uint64_t lr = cs->ich_lr_el2[VAR_0];", "if ((lr & ICH_LR_EL2_STATE_MASK) == 0 &&\n((lr & ICH_LR_EL2_HW) == 1 || (lr & ICH_LR_EL2_EOI) == 0)) {", "value |= (1 << VAR_0);", "}", "}", "trace_gicv3_ich_elrsr_read(gicv3_redist_affid(cs), value);", "return value;", "}" ]

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

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

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

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

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

[ "static int FUNC_0(FLACContext *VAR_0, int VAR_1, int VAR_2)\n{", "int VAR_3;", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \" SUBFRAME FIXED\\n\");", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \" warm up samples: %d\\n\", VAR_2);", "for (VAR_3 = 0; VAR_3 < VAR_2; VAR_3++)", "{", "VAR_0->decoded[VAR_1][VAR_3] = get_sbits(&VAR_0->gb, VAR_0->curr_bps);", "}", "if (decode_residuals(VAR_0, VAR_1, VAR_2) < 0)\nreturn -1;", "switch(VAR_2)\n{", "case 0:\nbreak;", "case 1:\nfor (VAR_3 = VAR_2; VAR_3 < VAR_0->blocksize; VAR_3++)", "VAR_0->decoded[VAR_1][VAR_3] += VAR_0->decoded[VAR_1][VAR_3-1];", "break;", "case 2:\nfor (VAR_3 = VAR_2; VAR_3 < VAR_0->blocksize; VAR_3++)", "VAR_0->decoded[VAR_1][VAR_3] += 2*VAR_0->decoded[VAR_1][VAR_3-1]\n- VAR_0->decoded[VAR_1][VAR_3-2];", "break;", "case 3:\nfor (VAR_3 = VAR_2; VAR_3 < VAR_0->blocksize; VAR_3++)", "VAR_0->decoded[VAR_1][VAR_3] += 3*VAR_0->decoded[VAR_1][VAR_3-1]\n- 3*VAR_0->decoded[VAR_1][VAR_3-2]\n+ VAR_0->decoded[VAR_1][VAR_3-3];", "break;", "case 4:\nfor (VAR_3 = VAR_2; VAR_3 < VAR_0->blocksize; VAR_3++)", "VAR_0->decoded[VAR_1][VAR_3] += 4*VAR_0->decoded[VAR_1][VAR_3-1]\n- 6*VAR_0->decoded[VAR_1][VAR_3-2]\n+ 4*VAR_0->decoded[VAR_1][VAR_3-3]\n- VAR_0->decoded[VAR_1][VAR_3-4];", "break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"illegal pred order %d\\n\", VAR_2);", "return -1;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 31, 33 ], [ 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 ], [ 99 ], [ 101 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,\nconst AVFrame *VAR_2, int *VAR_3)\n{", "AACEncContext *s = VAR_0->priv_data;", "float **VAR_4 = s->planar_samples, *VAR_5, *VAR_6, *VAR_7;", "ChannelElement *cpe;", "SingleChannelElement *sce;", "IndividualChannelStream *ics;", "int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16;", "int VAR_17, VAR_18, VAR_19, VAR_20;", "int VAR_21 = 0, VAR_22 = 0, VAR_23 = 0, VAR_24 = 0;", "int VAR_25[4];", "FFPsyWindowInfo windows[AAC_MAX_CHANNELS];", "if (s->last_frame == 2)\nreturn 0;", "if (VAR_2) {", "if ((VAR_15 = ff_af_queue_add(&s->afq, VAR_2)) < 0)\nreturn VAR_15;", "}", "copy_input_samples(s, VAR_2);", "if (s->psypp)\nff_psy_preprocess(s->psypp, s->planar_samples, s->channels);", "if (!VAR_0->frame_number)\nreturn 0;", "VAR_14 = 0;", "for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) {", "FFPsyWindowInfo* wi = windows + VAR_14;", "VAR_13 = s->chan_map[VAR_8+1];", "VAR_12 = VAR_13 == TYPE_CPE ? 2 : 1;", "cpe = &s->cpe[VAR_8];", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {", "float clip_avoidance_factor;", "sce = &cpe->VAR_10[VAR_10];", "ics = &sce->ics;", "s->cur_channel = VAR_14 + VAR_10;", "VAR_7 = &VAR_4[s->cur_channel][0];", "VAR_5 = VAR_7 + 1024;", "VAR_6 = VAR_5 + (448+64);", "if (!VAR_2)\nVAR_6 = NULL;", "if (VAR_13 == TYPE_LFE) {", "wi[VAR_10].window_type[0] = ONLY_LONG_SEQUENCE;", "wi[VAR_10].window_shape = 0;", "wi[VAR_10].num_windows = 1;", "wi[VAR_10].grouping[0] = 1;", "ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;", "} else {", "wi[VAR_10] = s->psy.model->window(&s->psy, VAR_5, VAR_6, s->cur_channel,\nics->window_sequence[0]);", "}", "ics->window_sequence[1] = ics->window_sequence[0];", "ics->window_sequence[0] = wi[VAR_10].window_type[0];", "ics->use_kb_window[1] = ics->use_kb_window[0];", "ics->use_kb_window[0] = wi[VAR_10].window_shape;", "ics->num_windows = wi[VAR_10].num_windows;", "ics->swb_sizes = s->psy.bands [ics->num_windows == 8];", "ics->num_swb = VAR_13 == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];", "ics->max_sfb = FFMIN(ics->max_sfb, ics->num_swb);", "ics->swb_offset = wi[VAR_10].window_type[0] == EIGHT_SHORT_SEQUENCE ?\nff_swb_offset_128 [s->samplerate_index]:\nff_swb_offset_1024[s->samplerate_index];", "ics->tns_max_bands = wi[VAR_10].window_type[0] == EIGHT_SHORT_SEQUENCE ?\nff_tns_max_bands_128 [s->samplerate_index]:\nff_tns_max_bands_1024[s->samplerate_index];", "clip_avoidance_factor = 0.0f;", "for (VAR_11 = 0; VAR_11 < ics->num_windows; VAR_11++)", "ics->group_len[VAR_11] = wi[VAR_10].grouping[VAR_11];", "for (VAR_11 = 0; VAR_11 < ics->num_windows; VAR_11++) {", "if (wi[VAR_10].clipping[VAR_11] > CLIP_AVOIDANCE_FACTOR) {", "ics->window_clipping[VAR_11] = 1;", "clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[VAR_10].clipping[VAR_11]);", "} else {", "ics->window_clipping[VAR_11] = 0;", "}", "}", "if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {", "ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;", "} else {", "ics->clip_avoidance_factor = 1.0f;", "}", "apply_window_and_mdct(s, sce, VAR_7);", "if (s->options.ltp && s->coder->update_ltp) {", "s->coder->update_ltp(s, sce);", "apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);", "s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);", "}", "if (isnan(cpe->VAR_10->coeffs[0])) {", "av_log(VAR_0, AV_LOG_ERROR, \"Input contains NaN\\n\");", "return AVERROR(EINVAL);", "}", "avoid_clipping(s, sce);", "}", "VAR_14 += VAR_12;", "}", "if ((VAR_15 = ff_alloc_packet2(VAR_0, VAR_1, 8192 * s->channels, 0)) < 0)\nreturn VAR_15;", "VAR_16 = VAR_9 = 0;", "do {", "init_put_bits(&s->pb, VAR_1->data, VAR_1->size);", "if ((VAR_0->frame_number & 0xFF)==1 && !(VAR_0->flags & AV_CODEC_FLAG_BITEXACT))\nput_bitstream_info(s, LIBAVCODEC_IDENT);", "VAR_14 = 0;", "VAR_17 = 0;", "memset(VAR_25, 0, sizeof(VAR_25));", "for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) {", "FFPsyWindowInfo* wi = windows + VAR_14;", "const float *coeffs[2];", "VAR_13 = s->chan_map[VAR_8+1];", "VAR_12 = VAR_13 == TYPE_CPE ? 2 : 1;", "cpe = &s->cpe[VAR_8];", "cpe->common_window = 0;", "memset(cpe->is_mask, 0, sizeof(cpe->is_mask));", "memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));", "put_bits(&s->pb, 3, VAR_13);", "put_bits(&s->pb, 4, VAR_25[VAR_13]++);", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {", "sce = &cpe->VAR_10[VAR_10];", "coeffs[VAR_10] = sce->coeffs;", "sce->ics.predictor_present = 0;", "sce->ics.ltp.present = 0;", "memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));", "memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));", "memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));", "for (VAR_11 = 0; VAR_11 < 128; VAR_11++)", "if (sce->band_type[VAR_11] > RESERVED_BT)\nsce->band_type[VAR_11] = 0;", "}", "s->psy.bitres.alloc = -1;", "s->psy.bitres.bits = s->last_frame_pb_count / s->channels;", "s->psy.model->analyze(&s->psy, VAR_14, coeffs, wi);", "if (s->psy.bitres.alloc > 0) {", "VAR_17 += s->psy.bitres.alloc\n* (s->lambda / (VAR_0->global_quality ? VAR_0->global_quality : 120));", "s->psy.bitres.alloc /= VAR_12;", "}", "s->cur_type = VAR_13;", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {", "s->cur_channel = VAR_14 + VAR_10;", "if (s->options.pns && s->coder->mark_pns)\ns->coder->mark_pns(s, VAR_0, &cpe->VAR_10[VAR_10]);", "s->coder->search_for_quantizers(VAR_0, s, &cpe->VAR_10[VAR_10], s->lambda);", "}", "if (VAR_12 > 1\n&& wi[0].window_type[0] == wi[1].window_type[0]\n&& wi[0].window_shape == wi[1].window_shape) {", "cpe->common_window = 1;", "for (VAR_11 = 0; VAR_11 < wi[0].num_windows; VAR_11++) {", "if (wi[0].grouping[VAR_11] != wi[1].grouping[VAR_11]) {", "cpe->common_window = 0;", "break;", "}", "}", "}", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {", "sce = &cpe->VAR_10[VAR_10];", "s->cur_channel = VAR_14 + VAR_10;", "if (s->options.tns && s->coder->search_for_tns)\ns->coder->search_for_tns(s, sce);", "if (s->options.tns && s->coder->apply_tns_filt)\ns->coder->apply_tns_filt(s, sce);", "if (sce->tns.present)\nVAR_23 = 1;", "if (s->options.pns && s->coder->search_for_pns)\ns->coder->search_for_pns(s, VAR_0, sce);", "}", "s->cur_channel = VAR_14;", "if (s->options.intensity_stereo) {", "if (s->coder->search_for_is)\ns->coder->search_for_is(s, VAR_0, cpe);", "if (cpe->VAR_22) VAR_22 = 1;", "apply_intensity_stereo(cpe);", "}", "if (s->options.pred) {", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {", "sce = &cpe->VAR_10[VAR_10];", "s->cur_channel = VAR_14 + VAR_10;", "if (s->options.pred && s->coder->search_for_pred)\ns->coder->search_for_pred(s, sce);", "if (cpe->VAR_10[VAR_10].ics.predictor_present) VAR_24 = 1;", "}", "if (s->coder->adjust_common_pred)\ns->coder->adjust_common_pred(s, cpe);", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {", "sce = &cpe->VAR_10[VAR_10];", "s->cur_channel = VAR_14 + VAR_10;", "if (s->options.pred && s->coder->apply_main_pred)\ns->coder->apply_main_pred(s, sce);", "}", "s->cur_channel = VAR_14;", "}", "if (s->options.mid_side) {", "if (s->options.mid_side == -1 && s->coder->search_for_ms)\ns->coder->search_for_ms(s, cpe);", "else if (cpe->common_window)\nmemset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));", "apply_mid_side_stereo(cpe);", "}", "adjust_frame_information(cpe, VAR_12);", "if (s->options.ltp) {", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {", "sce = &cpe->VAR_10[VAR_10];", "s->cur_channel = VAR_14 + VAR_10;", "if (s->coder->search_for_ltp)\ns->coder->search_for_ltp(s, sce, cpe->common_window);", "if (sce->ics.ltp.present) VAR_24 = 1;", "}", "s->cur_channel = VAR_14;", "if (s->coder->adjust_common_ltp)\ns->coder->adjust_common_ltp(s, cpe);", "}", "if (VAR_12 == 2) {", "put_bits(&s->pb, 1, cpe->common_window);", "if (cpe->common_window) {", "put_ics_info(s, &cpe->VAR_10[0].ics);", "if (s->coder->encode_main_pred)\ns->coder->encode_main_pred(s, &cpe->VAR_10[0]);", "if (s->coder->encode_ltp_info)\ns->coder->encode_ltp_info(s, &cpe->VAR_10[0], 1);", "encode_ms_info(&s->pb, cpe);", "if (cpe->VAR_21) VAR_21 = 1;", "}", "}", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {", "s->cur_channel = VAR_14 + VAR_10;", "encode_individual_channel(VAR_0, s, &cpe->VAR_10[VAR_10], cpe->common_window);", "}", "VAR_14 += VAR_12;", "}", "if (VAR_0->flags & CODEC_FLAG_QSCALE) {", "break;", "}", "VAR_16 = put_bits_count(&s->pb);", "VAR_18 = VAR_0->bit_rate * 1024 / VAR_0->sample_rate;", "VAR_18 = FFMIN(VAR_18, 6144 * s->channels - 3);", "VAR_19 = FFMAX(VAR_17, VAR_18);", "VAR_19 = FFMIN(VAR_19, 6144 * s->channels - 3);", "VAR_20 = FFMIN(FFMAX(VAR_18 - VAR_18/4, VAR_17), VAR_19);", "VAR_20 = VAR_20 - VAR_20/8;", "VAR_19 = VAR_19 + VAR_19/2;", "if ( VAR_9 == 0\n|| (VAR_9 < 5 && (VAR_16 < VAR_20 || VAR_16 > VAR_19))\n|| VAR_16 >= 6144 * s->channels - 3 )\n{", "float VAR_26 = ((float)VAR_18) / VAR_16;", "if (VAR_16 >= VAR_20 && VAR_16 <= VAR_19) {", "VAR_26 = sqrtf(sqrtf(VAR_26));", "VAR_26 = av_clipf(VAR_26, 0.9f, 1.1f);", "} else {", "VAR_26 = sqrtf(VAR_26);", "}", "s->lambda = FFMIN(s->lambda * VAR_26, 65536.f);", "if (VAR_26 > 0.9f && VAR_26 < 1.1f) {", "break;", "} else {", "if (VAR_22 || VAR_21 || VAR_23 || VAR_24) {", "for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) {", "VAR_12 = VAR_13 == TYPE_CPE ? 2 : 1;", "cpe = &s->cpe[VAR_8];", "for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++)", "memcpy(cpe->VAR_10[VAR_10].coeffs, cpe->VAR_10[VAR_10].pcoeffs, sizeof(cpe->VAR_10[VAR_10].coeffs));", "}", "}", "VAR_9++;", "}", "} else {", "break;", "}", "} while (1);", "if (s->options.ltp && s->coder->ltp_insert_new_frame)\ns->coder->ltp_insert_new_frame(s);", "put_bits(&s->pb, 3, TYPE_END);", "flush_put_bits(&s->pb);", "s->last_frame_pb_count = put_bits_count(&s->pb);", "s->lambda_sum += s->lambda;", "s->lambda_count++;", "if (!VAR_2)\ns->last_frame++;", "ff_af_queue_remove(&s->afq, VAR_0->frame_size, &VAR_1->pts,\n&VAR_1->duration);", "VAR_1->size = put_bits_count(&s->pb) >> 3;", "*VAR_3 = 1;", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 47 ], [ 49, 51 ], [ 55, 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 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 ], [ 185 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217, 219 ], [ 221 ], [ 223 ], [ 225 ], [ 229, 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279, 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 295, 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309, 311 ], [ 313 ], [ 315 ], [ 317, 319, 321 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347, 349 ], [ 351, 353 ], [ 355, 357 ], [ 359, 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369, 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387, 389 ], [ 391 ], [ 393 ], [ 395, 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405, 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417, 419 ], [ 421, 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439, 441 ], [ 443 ], [ 445 ], [ 447 ], [ 449, 451 ], [ 453 ], [ 455 ], [ 457 ], [ 459 ], [ 461 ], [ 463, 465 ], [ 467, 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 479 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 493 ], [ 497 ], [ 499 ], [ 511 ], [ 513 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 527 ], [ 529 ], [ 533, 535, 537, 539 ], [ 541 ], [ 545 ], [ 559 ], [ 561 ], [ 563 ], [ 567 ], [ 569 ], [ 571 ], [ 577 ], [ 579 ], [ 581 ], [ 583 ], [ 585 ], [ 589 ], [ 591 ], [ 593 ], [ 595 ], [ 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ], [ 609 ], [ 611 ], [ 615, 617 ], [ 621 ], [ 623 ], [ 627 ], [ 631 ], [ 633 ], [ 637, 639 ], [ 643, 645 ], [ 649 ], [ 651 ], [ 653 ], [ 655 ] ]

[ "void FUNC_0(VirtIODevice *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{", "VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(VAR_0);", "uint32_t val = VAR_2;", "if (VAR_1 > (VAR_0->config_len - sizeof(val)))\nreturn;", "stl_p(VAR_0->config + VAR_1, val);", "if (k->set_config) {", "k->set_config(VAR_0, VAR_0->config);", "}", "}" ]

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

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

[ "int FUNC_0(BlockDriverState **VAR_0, const char *VAR_1,\nQDict *VAR_2, const char *VAR_3, int VAR_4,\nbool VAR_5, Error **VAR_6)\n{", "QDict *image_options;", "int VAR_7;", "char *VAR_8;", "const char *VAR_9;", "assert(VAR_0);", "assert(*VAR_0 == NULL);", "VAR_8 = g_strdup_printf(\"%s.\", VAR_3);", "qdict_extract_subqdict(VAR_2, &image_options, VAR_8);", "g_free(VAR_8);", "VAR_9 = qdict_get_try_str(VAR_2, VAR_3);", "if (!VAR_1 && !VAR_9 && !qdict_size(image_options)) {", "if (VAR_5) {", "VAR_7 = 0;", "} else {", "error_setg(VAR_6, \"A block device must be specified for \\\"%s\\\"\",\nVAR_3);", "VAR_7 = -EINVAL;", "}", "goto done;", "}", "VAR_7 = bdrv_open(VAR_0, VAR_1, VAR_9, image_options, VAR_4, NULL, VAR_6);", "done:\nqdict_del(VAR_2, VAR_3);", "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 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 52 ], [ 54 ], [ 58 ], [ 62, 64 ], [ 66 ], [ 68 ] ]

[ "static void FUNC_0(MUSBState *VAR_0, MUSBEndPoint *VAR_1,\nint VAR_2, int VAR_3, int VAR_4, USBCallback VAR_5, int VAR_6)\n{", "int VAR_7;", "int VAR_8 = VAR_2 && VAR_6;", "int VAR_9;", "VAR_9 = VAR_2 ? (VAR_1->type[VAR_8] >> 4) & 3 : 0;", "VAR_1->timeout[VAR_6] = musb_timeout(VAR_9,\nVAR_1->type[VAR_8] >> 6, VAR_1->interval[VAR_8]);", "VAR_1->interrupt[VAR_6] = VAR_9 == USB_ENDPOINT_XFER_INT;", "VAR_1->delayed_cb[VAR_6] = VAR_5;", "VAR_1->packey[VAR_6].p.VAR_3 = VAR_3;", "VAR_1->packey[VAR_6].p.devaddr = VAR_1->faddr[VAR_8];", "VAR_1->packey[VAR_6].p.devep = VAR_1->type[VAR_8] & 0xf;", "VAR_1->packey[VAR_6].p.data = (void *) VAR_1->buf[VAR_8];", "VAR_1->packey[VAR_6].p.VAR_4 = VAR_4;", "VAR_1->packey[VAR_6].VAR_1 = VAR_1;", "VAR_1->packey[VAR_6].VAR_6 = VAR_6;", "if (VAR_0->port.dev)\nVAR_7 = usb_handle_packet(VAR_0->port.dev, &VAR_1->packey[VAR_6].p);", "else\nVAR_7 = USB_RET_NODEV;", "if (VAR_7 == USB_RET_ASYNC) {", "VAR_1->status[VAR_6] = VAR_4;", "return;", "}", "VAR_1->status[VAR_6] = VAR_7;", "musb_schedule_cb(&VAR_0->port, &VAR_1->packey[VAR_6].p);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 25 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57, 59 ], [ 61, 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ] ]

[ "bool FUNC_0(const char *file)\n{", "st_set_trace_file_enabled(false);", "free(trace_file_name);", "if (!file) {", "if (asprintf(&trace_file_name, CONFIG_TRACE_FILE, getpid()) < 0) {", "trace_file_name = NULL;", "return false;", "}", "} else {", "if (asprintf(&trace_file_name, \"%s\", file) < 0) {", "trace_file_name = NULL;", "return false;", "}", "}", "st_set_trace_file_enabled(true);", "return true;", "}" ]

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

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

[ "static int FUNC_0(struct CPUPhysMemoryClient *VAR_0,\nint VAR_1)\n{", "return kvm_set_migration_log(VAR_1);", "}" ]

[ 1, 1, 0 ]

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

[ "static AVFilterContext *FUNC_0(const char **buf, AVFilterGraph *graph,\nint index, AVClass *log_ctx)\n{", "char *VAR_0 = NULL;", "char *VAR_1 = consume_string(buf);", "if(**buf == '=') {", "(*buf)++;", "VAR_0 = consume_string(buf);", "}", "return create_filter(graph, index, VAR_1, VAR_0, log_ctx);", "}" ]

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

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

[ "static AVCodec *FUNC_0(enum AVCodecID codec_id)\n{", "AVCodec *res;", "avcodec_register_all();", "av_log_set_level(AV_LOG_PANIC);", "res = avcodec_find_decoder(codec_id);", "if (!res)\nerror(\"Failed to find decoder\");", "return res;", "}" ]

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

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

[ "static int FUNC_0(gboolean VAR_0, HANDLE *VAR_1, gint VAR_2,\nGPollFD *VAR_3, guint VAR_4, gint VAR_5)\n{", "DWORD ready;", "GPollFD *f;", "int VAR_6;", "if (VAR_0) {", "ready = MsgWaitForMultipleObjectsEx(VAR_2, VAR_1, VAR_5,\nQS_ALLINPUT, MWMO_ALERTABLE);", "if (ready == WAIT_FAILED) {", "gchar *emsg = g_win32_error_message(GetLastError());", "g_warning(\"MsgWaitForMultipleObjectsEx failed: %s\", emsg);", "g_free(emsg);", "}", "} else if (VAR_2 == 0) {", "if (VAR_5 == INFINITE) {", "ready = WAIT_FAILED;", "} else {", "SleepEx(VAR_5, TRUE);", "ready = WAIT_TIMEOUT;", "}", "} else {", "ready =\nWaitForMultipleObjectsEx(VAR_2, VAR_1, FALSE, VAR_5, TRUE);", "if (ready == WAIT_FAILED) {", "gchar *emsg = g_win32_error_message(GetLastError());", "g_warning(\"WaitForMultipleObjectsEx failed: %s\", emsg);", "g_free(emsg);", "}", "}", "if (ready == WAIT_FAILED) {", "return -1;", "} else if (ready == WAIT_TIMEOUT || ready == WAIT_IO_COMPLETION) {", "return 0;", "} else if (VAR_0 && ready == WAIT_OBJECT_0 + VAR_2) {", "for (f = VAR_3; f < &VAR_3[VAR_4]; ++f) {", "if (f->fd == G_WIN32_MSG_HANDLE && f->events & G_IO_IN) {", "f->revents |= G_IO_IN;", "}", "}", "if (VAR_5 != 0 || VAR_2 == 0) {", "return 1;", "}", "VAR_6 = FUNC_0(FALSE, VAR_1, VAR_2, VAR_3, VAR_4, 0);", "return (VAR_6 == -1) ? -1 : 1 + VAR_6;", "} else if (", "ready < WAIT_OBJECT_0 + VAR_2) {", "for (f = VAR_3; f < &VAR_3[VAR_4]; ++f) {", "if ((HANDLE) f->fd == VAR_1[ready - WAIT_OBJECT_0]) {", "f->revents = f->events;", "}", "}", "if (VAR_5 == 0 && VAR_2 > 1) {", "int VAR_7;", "if (ready < VAR_2 - 1) {", "for (VAR_7 = ready - WAIT_OBJECT_0 + 1; VAR_7 < VAR_2; VAR_7++) {", "VAR_1[VAR_7-1] = VAR_1[VAR_7];", "}", "}", "VAR_2--;", "VAR_6 = FUNC_0(FALSE, VAR_1, VAR_2, VAR_3, VAR_4, 0);", "return (VAR_6 == -1) ? -1 : 1 + VAR_6;", "}", "return 1;", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 109 ], [ 111 ], [ 113 ], [ 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 151 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 183 ] ]

[ "int FUNC_0(CPUState *VAR_0, struct kvm_run *VAR_1)\n{", "if (VAR_0->interrupt_request & CPU_INTERRUPT_NMI) {", "VAR_0->interrupt_request &= ~CPU_INTERRUPT_NMI;", "DPRINTF(\"injected NMI\\n\");", "kvm_vcpu_ioctl(VAR_0, KVM_NMI);", "}", "if (!kvm_irqchip_in_kernel()) {", "if (VAR_0->interrupt_request & CPU_INTERRUPT_INIT) {", "VAR_0->exit_request = 1;", "}", "if (VAR_1->ready_for_interrupt_injection &&\n(VAR_0->interrupt_request & CPU_INTERRUPT_HARD) &&\n(VAR_0->eflags & IF_MASK)) {", "int VAR_2;", "VAR_0->interrupt_request &= ~CPU_INTERRUPT_HARD;", "VAR_2 = cpu_get_pic_interrupt(VAR_0);", "if (VAR_2 >= 0) {", "struct kvm_interrupt VAR_3;", "VAR_3.VAR_2 = VAR_2;", "DPRINTF(\"injected interrupt %d\\n\", VAR_2);", "kvm_vcpu_ioctl(VAR_0, KVM_INTERRUPT, &VAR_3);", "}", "}", "if ((VAR_0->interrupt_request & CPU_INTERRUPT_HARD)) {", "VAR_1->request_interrupt_window = 1;", "} else {", "VAR_1->request_interrupt_window = 0;", "}", "DPRINTF(\"setting tpr\\n\");", "VAR_1->cr8 = cpu_get_apic_tpr(VAR_0->apic_state);", "}", "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 ]

[ [ 1, 3 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 33, 35, 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ] ]

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "}" ]

[ 0, 0 ]

[ [ 1, 3 ], [ 7 ] ]

[ "static void FUNC_0 (void *VAR_0, target_phys_addr_t VAR_1, uint32_t VAR_2)\n{", "M48t59State *NVRAM = VAR_0;", "m48t59_write(NVRAM, VAR_1, VAR_2 & 0xff);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(JSONLexer *VAR_0, char VAR_1, bool VAR_2)\n{", "int VAR_3, VAR_4;", "VAR_0->x++;", "if (VAR_1 == '\\n') {", "VAR_0->x = 0;", "VAR_0->y++;", "}", "do {", "VAR_4 = json_lexer[VAR_0->state][(uint8_t)VAR_1];", "VAR_3 = !TERMINAL_NEEDED_LOOKAHEAD(VAR_0->state, VAR_4);", "if (VAR_3) {", "qstring_append_chr(VAR_0->token, VAR_1);", "}", "switch (VAR_4) {", "case JSON_OPERATOR:\ncase JSON_ESCAPE:\ncase JSON_INTEGER:\ncase JSON_FLOAT:\ncase JSON_KEYWORD:\ncase JSON_STRING:\nVAR_0->emit(VAR_0, VAR_0->token, VAR_4, VAR_0->x, VAR_0->y);", "case JSON_SKIP:\nQDECREF(VAR_0->token);", "VAR_0->token = qstring_new();", "VAR_4 = IN_START;", "break;", "case IN_ERROR:\nQDECREF(VAR_0->token);", "VAR_0->token = qstring_new();", "VAR_4 = IN_START;", "return -EINVAL;", "default:\nbreak;", "}", "VAR_0->state = VAR_4;", "} while (!VAR_3 && !VAR_2);", "if (VAR_0->token->length > MAX_TOKEN_SIZE) {", "VAR_0->emit(VAR_0, VAR_0->token, VAR_0->state, VAR_0->x, VAR_0->y);", "QDECREF(VAR_0->token);", "VAR_0->token = qstring_new();", "VAR_0->state = IN_START;", "}", "return 0;", "}" ]

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

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

[ "static int VAR_0 qed_aio_write_alloc(QEDAIOCB *acb, size_t len)\n{", "BDRVQEDState *s = acb_to_s(acb);", "int ret;", "if (s->allocating_acb == NULL) {", "qed_cancel_need_check_timer(s);", "}", "if (s->allocating_acb != acb || s->allocating_write_reqs_plugged) {", "if (s->allocating_acb != NULL) {", "qemu_co_queue_wait(&s->allocating_write_reqs, NULL);", "assert(s->allocating_acb == NULL);", "}", "s->allocating_acb = acb;", "return -EAGAIN;", "}", "acb->cur_nclusters = qed_bytes_to_clusters(s,\nqed_offset_into_cluster(s, acb->cur_pos) + len);", "qemu_iovec_concat(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len);", "if (acb->flags & QED_AIOCB_ZERO) {", "if (acb->find_cluster_ret == QED_CLUSTER_ZERO) {", "return 0;", "}", "acb->cur_cluster = 1;", "} else {", "acb->cur_cluster = qed_alloc_clusters(s, acb->cur_nclusters);", "}", "if (qed_should_set_need_check(s)) {", "s->header.features |= QED_F_NEED_CHECK;", "ret = qed_write_header(s);", "if (ret < 0) {", "return ret;", "}", "}", "if (!(acb->flags & QED_AIOCB_ZERO)) {", "ret = qed_aio_write_cow(acb);", "if (ret < 0) {", "return ret;", "}", "}", "return qed_aio_write_l2_update(acb, acb->cur_cluster);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 13 ], [ 15 ], [ 17 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41, 43 ], [ 45 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0, QEMUSnapshotInfo *VAR_1)\n{", "BDRVQcow2State *s = VAR_0->opaque;", "QCowSnapshot *new_snapshot_list = NULL;", "QCowSnapshot *old_snapshot_list = NULL;", "QCowSnapshot sn1, *sn = &sn1;", "int VAR_2, VAR_3;", "uint64_t *l1_table = NULL;", "int64_t l1_table_offset;", "if (s->nb_snapshots >= QCOW_MAX_SNAPSHOTS) {", "return -EFBIG;", "}", "memset(sn, 0, sizeof(*sn));", "find_new_snapshot_id(VAR_0, VAR_1->id_str, sizeof(VAR_1->id_str));", "if (find_snapshot_by_id_and_name(VAR_0, VAR_1->id_str, NULL) >= 0) {", "return -EEXIST;", "}", "sn->id_str = g_strdup(VAR_1->id_str);", "sn->name = g_strdup(VAR_1->name);", "sn->disk_size = VAR_0->total_sectors * BDRV_SECTOR_SIZE;", "sn->vm_state_size = VAR_1->vm_state_size;", "sn->date_sec = VAR_1->date_sec;", "sn->date_nsec = VAR_1->date_nsec;", "sn->vm_clock_nsec = VAR_1->vm_clock_nsec;", "l1_table_offset = qcow2_alloc_clusters(VAR_0, s->l1_size * sizeof(uint64_t));", "if (l1_table_offset < 0) {", "VAR_3 = l1_table_offset;", "goto fail;", "}", "sn->l1_table_offset = l1_table_offset;", "sn->l1_size = s->l1_size;", "l1_table = g_try_new(uint64_t, s->l1_size);", "if (s->l1_size && l1_table == NULL) {", "VAR_3 = -ENOMEM;", "goto fail;", "}", "for(VAR_2 = 0; VAR_2 < s->l1_size; VAR_2++) {", "l1_table[VAR_2] = cpu_to_be64(s->l1_table[VAR_2]);", "}", "VAR_3 = qcow2_pre_write_overlap_check(VAR_0, 0, sn->l1_table_offset,\ns->l1_size * sizeof(uint64_t));", "if (VAR_3 < 0) {", "goto fail;", "}", "VAR_3 = bdrv_pwrite(VAR_0->file, sn->l1_table_offset, l1_table,\ns->l1_size * sizeof(uint64_t));", "if (VAR_3 < 0) {", "goto fail;", "}", "g_free(l1_table);", "l1_table = NULL;", "VAR_3 = qcow2_update_snapshot_refcount(VAR_0, s->l1_table_offset, s->l1_size, 1);", "if (VAR_3 < 0) {", "goto fail;", "}", "new_snapshot_list = g_new(QCowSnapshot, s->nb_snapshots + 1);", "if (s->snapshots) {", "memcpy(new_snapshot_list, s->snapshots,\ns->nb_snapshots * sizeof(QCowSnapshot));", "old_snapshot_list = s->snapshots;", "}", "s->snapshots = new_snapshot_list;", "s->snapshots[s->nb_snapshots++] = *sn;", "VAR_3 = qcow2_write_snapshots(VAR_0);", "if (VAR_3 < 0) {", "g_free(s->snapshots);", "s->snapshots = old_snapshot_list;", "s->nb_snapshots--;", "goto fail;", "}", "g_free(old_snapshot_list);", "qcow2_discard_clusters(VAR_0, qcow2_vm_state_offset(s),\nalign_offset(sn->vm_state_size, s->cluster_size)\n>> BDRV_SECTOR_BITS,\nQCOW2_DISCARD_NEVER, false);", "#ifdef DEBUG_ALLOC\n{", "BdrvCheckResult result = {0};", "qcow2_check_refcounts(VAR_0, &result, 0);", "}", "#endif\nreturn 0;", "fail:\ng_free(sn->id_str);", "g_free(sn->name);", "g_free(l1_table);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 35 ], [ 41 ], [ 43 ], [ 45 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 161 ], [ 163 ], [ 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 203, 205, 207, 209 ], [ 213, 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223, 225 ], [ 229, 231 ], [ 233 ], [ 235 ], [ 239 ], [ 241 ] ]

[ "static void FUNC_0(void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{", "int VAR_3;", "SuperIOConfig *superio_conf = VAR_0;", "DPRINTF(\"FUNC_0 address 0x%x val 0x%x \\n\", VAR_1, VAR_2);", "if (VAR_1 == 0x3f0) {", "superio_conf->index = VAR_2 & 0xff;", "} else {", "switch (superio_conf->index) {", "case 0x00 ... 0xdf:\ncase 0xe4:\ncase 0xe5:\ncase 0xe9 ... 0xed:\ncase 0xf3:\ncase 0xf5:\ncase 0xf7:\ncase 0xf9 ... 0xfb:\ncase 0xfd ... 0xff:\nVAR_3 = 0;", "break;", "default:\nVAR_3 = 1;", "if (VAR_3) {", "switch (superio_conf->index) {", "case 0xe7:\nif ((VAR_2 & 0xff) != 0xfe) {", "DPRINTF(\"chage uart 1 base. unsupported yet \\n\");", "}", "break;", "case 0xe8:\nif ((VAR_2 & 0xff) != 0xbe) {", "DPRINTF(\"chage uart 2 base. unsupported yet \\n\");", "}", "break;", "default:\nsuperio_conf->config[superio_conf->index] = VAR_2 & 0xff;", "}", "}", "}", "superio_conf->config[superio_conf->index] = VAR_2 & 0xff;", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, const char *VAR_1)\n{", "monitor_handle_command(VAR_1);", "if (!monitor_suspended)\nmonitor_start_input();", "else\nmonitor_suspended = 2;", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(PCIDevice *VAR_0)\n{", "VAR_0->bus->devices[VAR_0->devfn] = NULL;", "pci_config_free(VAR_0);", "if (memory_region_is_mapped(&VAR_0->bus_master_enable_region)) {", "memory_region_del_subregion(&VAR_0->bus_master_container_region,\n&VAR_0->bus_master_enable_region);", "}", "address_space_destroy(&VAR_0->bus_master_as);", "}" ]

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

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

[ "CPUState *FUNC_0 (target_phys_addr_t ram_bases[4],\ntarget_phys_addr_t ram_sizes[4],\nuint32_t sysclk, qemu_irq **picp,\nint do_init)\n{", "clk_setup_t clk_setup[PPC405CR_CLK_NB];", "qemu_irq dma_irqs[4];", "CPUState *env;", "qemu_irq *pic, *irqs;", "memset(clk_setup, 0, sizeof(clk_setup));", "env = ppc4xx_init(\"405cr\", &clk_setup[PPC405CR_CPU_CLK],\n&clk_setup[PPC405CR_TMR_CLK], sysclk);", "ppc4xx_plb_init(env);", "ppc4xx_pob_init(env);", "ppc4xx_opba_init(0xef600600);", "irqs = g_malloc0(sizeof(qemu_irq) * PPCUIC_OUTPUT_NB);", "irqs[PPCUIC_OUTPUT_INT] =\n((qemu_irq *)env->irq_inputs)[PPC40x_INPUT_INT];", "irqs[PPCUIC_OUTPUT_CINT] =\n((qemu_irq *)env->irq_inputs)[PPC40x_INPUT_CINT];", "pic = ppcuic_init(env, irqs, 0x0C0, 0, 1);", "*picp = pic;", "ppc4xx_sdram_init(env, pic[14], 1, ram_bases, ram_sizes, do_init);", "ppc405_ebc_init(env);", "dma_irqs[0] = pic[26];", "dma_irqs[1] = pic[25];", "dma_irqs[2] = pic[24];", "dma_irqs[3] = pic[23];", "ppc405_dma_init(env, dma_irqs);", "if (serial_hds[0] != NULL) {", "serial_mm_init(0xef600300, 0, pic[0], PPC_SERIAL_MM_BAUDBASE,\nserial_hds[0], 1, 1);", "}", "if (serial_hds[1] != NULL) {", "serial_mm_init(0xef600400, 0, pic[1], PPC_SERIAL_MM_BAUDBASE,\nserial_hds[1], 1, 1);", "}", "ppc405_i2c_init(0xef600500, pic[2]);", "ppc405_gpio_init(0xef600700);", "ppc405cr_cpc_init(env, clk_setup, sysclk);", "return env;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23, 25 ], [ 31 ], [ 35 ], [ 39 ], [ 43 ], [ 45, 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 59 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 97 ], [ 101 ], [ 105 ], [ 109 ], [ 111 ] ]

[ "int FUNC_0(NbdClientSession *VAR_0, int64_t VAR_1,\nint VAR_2)\n{", "struct nbd_request VAR_3 = { .type = NBD_CMD_TRIM };", "struct nbd_reply VAR_4;", "ssize_t ret;", "if (!(VAR_0->nbdflags & NBD_FLAG_SEND_TRIM)) {", "return 0;", "}", "VAR_3.from = VAR_1 * 512;", "VAR_3.len = VAR_2 * 512;", "nbd_coroutine_start(VAR_0, &VAR_3);", "ret = nbd_co_send_request(VAR_0, &VAR_3, NULL, 0);", "if (ret < 0) {", "VAR_4.error = -ret;", "} else {", "nbd_co_receive_reply(VAR_0, &VAR_3, &VAR_4, NULL, 0);", "}", "nbd_coroutine_end(VAR_0, &VAR_3);", "return -VAR_4.error;", "}" ]

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

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

[ "static void FUNC_0(SDHCIState *VAR_0)\n{", "unsigned int VAR_1, VAR_2, VAR_3;", "const uint16_t VAR_4 = VAR_0->blksize & 0x0fff;", "ADMADescr dscr;", "int VAR_5;", "for (VAR_5 = 0; VAR_5 < SDHC_ADMA_DESCS_PER_DELAY; ++VAR_5) {", "VAR_0->admaerr &= ~SDHC_ADMAERR_LENGTH_MISMATCH;", "get_adma_description(VAR_0, &dscr);", "DPRINT_L2(\"ADMA loop: addr=\" TARGET_FMT_plx \", len=%d, attr=%x\\VAR_1\",\ndscr.addr, dscr.VAR_3, dscr.attr);", "if ((dscr.attr & SDHC_ADMA_ATTR_VALID) == 0) {", "VAR_0->admaerr &= ~SDHC_ADMAERR_STATE_MASK;", "VAR_0->admaerr |= SDHC_ADMAERR_STATE_ST_FDS;", "if (VAR_0->errintstsen & SDHC_EISEN_ADMAERR) {", "VAR_0->errintsts |= SDHC_EIS_ADMAERR;", "VAR_0->norintsts |= SDHC_NIS_ERR;", "}", "sdhci_update_irq(VAR_0);", "return;", "}", "VAR_3 = dscr.VAR_3 ? dscr.VAR_3 : 65536;", "switch (dscr.attr & SDHC_ADMA_ATTR_ACT_MASK) {", "case SDHC_ADMA_ATTR_ACT_TRAN:\nif (VAR_0->trnmod & SDHC_TRNS_READ) {", "while (VAR_3) {", "if (VAR_0->data_count == 0) {", "for (VAR_1 = 0; VAR_1 < VAR_4; VAR_1++) {", "VAR_0->fifo_buffer[VAR_1] = sd_read_data(VAR_0->card);", "}", "}", "VAR_2 = VAR_0->data_count;", "if ((VAR_3 + VAR_2) < VAR_4) {", "VAR_0->data_count = VAR_3 + VAR_2;", "VAR_3 = 0;", "} else {", "VAR_0->data_count = VAR_4;", "VAR_3 -= VAR_4 - VAR_2;", "}", "dma_memory_write(&address_space_memory, dscr.addr,\n&VAR_0->fifo_buffer[VAR_2],\nVAR_0->data_count - VAR_2);", "dscr.addr += VAR_0->data_count - VAR_2;", "if (VAR_0->data_count == VAR_4) {", "VAR_0->data_count = 0;", "if (VAR_0->trnmod & SDHC_TRNS_BLK_CNT_EN) {", "VAR_0->blkcnt--;", "if (VAR_0->blkcnt == 0) {", "break;", "}", "}", "}", "}", "} else {", "while (VAR_3) {", "VAR_2 = VAR_0->data_count;", "if ((VAR_3 + VAR_2) < VAR_4) {", "VAR_0->data_count = VAR_3 + VAR_2;", "VAR_3 = 0;", "} else {", "VAR_0->data_count = VAR_4;", "VAR_3 -= VAR_4 - VAR_2;", "}", "dma_memory_read(&address_space_memory, dscr.addr,\n&VAR_0->fifo_buffer[VAR_2],\nVAR_0->data_count - VAR_2);", "dscr.addr += VAR_0->data_count - VAR_2;", "if (VAR_0->data_count == VAR_4) {", "for (VAR_1 = 0; VAR_1 < VAR_4; VAR_1++) {", "sd_write_data(VAR_0->card, VAR_0->fifo_buffer[VAR_1]);", "}", "VAR_0->data_count = 0;", "if (VAR_0->trnmod & SDHC_TRNS_BLK_CNT_EN) {", "VAR_0->blkcnt--;", "if (VAR_0->blkcnt == 0) {", "break;", "}", "}", "}", "}", "}", "VAR_0->admasysaddr += dscr.incr;", "break;", "case SDHC_ADMA_ATTR_ACT_LINK:\nVAR_0->admasysaddr = dscr.addr;", "DPRINT_L1(\"ADMA link: admasysaddr=0x%lx\\VAR_1\", VAR_0->admasysaddr);", "break;", "default:\nVAR_0->admasysaddr += dscr.incr;", "break;", "}", "if (dscr.attr & SDHC_ADMA_ATTR_INT) {", "DPRINT_L1(\"ADMA interrupt: admasysaddr=0x%lx\\VAR_1\", VAR_0->admasysaddr);", "if (VAR_0->norintstsen & SDHC_NISEN_DMA) {", "VAR_0->norintsts |= SDHC_NIS_DMA;", "}", "sdhci_update_irq(VAR_0);", "}", "if (((VAR_0->trnmod & SDHC_TRNS_BLK_CNT_EN) &&\n(VAR_0->blkcnt == 0)) || (dscr.attr & SDHC_ADMA_ATTR_END)) {", "DPRINT_L2(\"ADMA transfer completed\\VAR_1\");", "if (VAR_3 || ((dscr.attr & SDHC_ADMA_ATTR_END) &&\n(VAR_0->trnmod & SDHC_TRNS_BLK_CNT_EN) &&\nVAR_0->blkcnt != 0)) {", "ERRPRINT(\"SD/MMC host ADMA VAR_3 mismatch\\VAR_1\");", "VAR_0->admaerr |= SDHC_ADMAERR_LENGTH_MISMATCH |\nSDHC_ADMAERR_STATE_ST_TFR;", "if (VAR_0->errintstsen & SDHC_EISEN_ADMAERR) {", "ERRPRINT(\"Set ADMA error flag\\VAR_1\");", "VAR_0->errintsts |= SDHC_EIS_ADMAERR;", "VAR_0->norintsts |= SDHC_NIS_ERR;", "}", "sdhci_update_irq(VAR_0);", "}", "SDHCI_GET_CLASS(VAR_0)->end_data_transfer(VAR_0);", "return;", "}", "}", "timer_mod(VAR_0->transfer_timer,\nqemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + SDHC_TRANSFER_DELAY);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 33 ], [ 35 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 63 ], [ 65, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99, 101, 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 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 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 217 ], [ 219 ], [ 225, 227 ], [ 229 ], [ 231, 233, 235 ], [ 237 ], [ 239, 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 267 ], [ 273, 275 ], [ 277 ] ]

[ "static uint32_t FUNC_0(void *opaque, target_phys_addr_t addr)\n{", "struct omap_sysctl_s *VAR_0 = (struct omap_sysctl_s *) opaque;", "int VAR_1, VAR_2;", "int VAR_3;", "switch (addr) {", "case 0x030 ... 0x140:\nVAR_1 = (addr - 0x30) >> 2;", "VAR_2 = (addr - 0x30) & (4 - 1);", "VAR_3 = VAR_0->padconf[VAR_1];", "VAR_3 = (VAR_3 >> (VAR_2 * 8)) & 0xff;", "return VAR_3;", "default:\nbreak;", "}", "OMAP_BAD_REG(addr);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17, 19 ], [ 21 ], [ 25 ], [ 27 ], [ 31 ], [ 35, 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ] ]

[ "abi_ulong FUNC_0(abi_ulong start, abi_ulong size)\n{", "void *VAR_0, *VAR_1;", "abi_ulong addr;", "int VAR_2, VAR_3;", "if (start == 0) {", "start = mmap_next_start;", "} else {", "start &= qemu_host_page_mask;", "}", "size = HOST_PAGE_ALIGN(size);", "if (RESERVED_VA) {", "return mmap_find_vma_reserved(start, size);", "}", "addr = start;", "VAR_2 = VAR_3 = 0;", "VAR_1 = 0;", "for (;; VAR_1 = VAR_0) {", "VAR_0 = mmap(g2h(addr), size, PROT_NONE,\nMAP_ANONYMOUS|MAP_PRIVATE|MAP_NORESERVE, -1, 0);", "if (VAR_0 == MAP_FAILED) {", "return (abi_ulong)-1;", "}", "VAR_3 = (VAR_0 == VAR_1 ? VAR_3 + 1 : 0);", "if (h2g_valid(VAR_0 + size - 1)) {", "addr = h2g(VAR_0);", "if ((addr & ~TARGET_PAGE_MASK) == 0) {", "if (start == mmap_next_start && addr >= TASK_UNMAPPED_BASE) {", "mmap_next_start = addr + size;", "}", "return addr;", "}", "switch (VAR_3) {", "case 0:\naddr = TARGET_PAGE_ALIGN(addr);", "break;", "case 1:\naddr &= TARGET_PAGE_MASK;", "break;", "case 2:\naddr = 0;", "break;", "default:\naddr = -1;", "break;", "}", "} else {", "addr = (VAR_3 ? -1 : 0);", "}", "munmap(VAR_0, size);", "if (addr == -1ul) {", "return (abi_ulong)-1;", "} else if (addr == 0) {", "if (VAR_2) {", "return (abi_ulong)-1;", "}", "VAR_2 = 1;", "addr = (mmap_min_addr > TARGET_PAGE_SIZE\n? TARGET_PAGE_ALIGN(mmap_min_addr)\n: TARGET_PAGE_SIZE);", "} else if (VAR_2 && addr >= start) {", "return (abi_ulong)-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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 63, 65 ], [ 71 ], [ 73 ], [ 75 ], [ 83 ], [ 87 ], [ 89 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 111 ], [ 113, 121 ], [ 123 ], [ 125, 131 ], [ 133 ], [ 135, 139 ], [ 141 ], [ 143, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 159 ], [ 161 ], [ 167 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 191, 193, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ] ]

[ "static int FUNC_0(USBDevice *VAR_0, USBPacket *VAR_1)\n{", "assert(VAR_1->devep == 0);", "switch(VAR_0->setup_state) {", "case SETUP_STATE_ACK:\nif (VAR_0->setup_buf[0] & USB_DIR_IN) {", "VAR_0->setup_state = SETUP_STATE_IDLE;", "} else {", "}", "return 0;", "case SETUP_STATE_DATA:\nif (!(VAR_0->setup_buf[0] & USB_DIR_IN)) {", "int VAR_2 = VAR_0->setup_len - VAR_0->setup_index;", "if (VAR_2 > VAR_1->iov.size) {", "VAR_2 = VAR_1->iov.size;", "}", "usb_packet_copy(VAR_1, VAR_0->data_buf + VAR_0->setup_index, VAR_2);", "VAR_0->setup_index += VAR_2;", "if (VAR_0->setup_index >= VAR_0->setup_len)\nVAR_0->setup_state = SETUP_STATE_ACK;", "return VAR_2;", "}", "VAR_0->setup_state = SETUP_STATE_IDLE;", "return USB_RET_STALL;", "default:\nreturn USB_RET_STALL;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11, 13 ], [ 15 ], [ 19 ], [ 23 ], [ 25 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 61, 63 ], [ 65 ], [ 67 ] ]

[ "int FUNC_0(target_ulong VAR_0, uintptr_t VAR_1)\n{", "unsigned int VAR_2;", "PageDesc *p;", "target_ulong host_start, host_end, addr;", "mmap_lock();", "p = page_find(VAR_0 >> TARGET_PAGE_BITS);", "if (!p) {", "mmap_unlock();", "return 0;", "}", "if ((p->flags & PAGE_WRITE_ORG) && !(p->flags & PAGE_WRITE)) {", "host_start = VAR_0 & qemu_host_page_mask;", "host_end = host_start + qemu_host_page_size;", "VAR_2 = 0;", "for (addr = host_start ; addr < host_end ; addr += TARGET_PAGE_SIZE) {", "p = page_find(addr >> TARGET_PAGE_BITS);", "p->flags |= PAGE_WRITE;", "VAR_2 |= p->flags;", "if (tb_invalidate_phys_page(addr, VAR_1)) {", "mmap_unlock();", "return 2;", "}", "#ifdef DEBUG_TB_CHECK\ntb_invalidate_check(addr);", "#endif\n}", "mprotect((void *)g2h(host_start), qemu_host_page_size,\nVAR_2 & PAGE_BITS);", "mmap_unlock();", "return 1;", "}", "mmap_unlock();", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75, 77 ], [ 79, 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ] ]

[ "static void FUNC_0(Jpeg2000EncoderContext *VAR_0, Jpeg2000Tile *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;", "Jpeg2000CodingStyle *codsty = &VAR_0->codsty;", "for (VAR_3 = 0; VAR_3 < VAR_0->ncomponents; VAR_3++){", "Jpeg2000Component *comp = VAR_1->comp + VAR_3;", "for (VAR_4 = 0, VAR_7 = codsty->nreslevels-1; VAR_4 < codsty->nreslevels; VAR_4++, VAR_7--){", "Jpeg2000ResLevel *reslevel = comp->reslevel + VAR_4;", "for (VAR_2 = 0; VAR_2 < reslevel->num_precincts_x * reslevel->num_precincts_y; VAR_2++){", "for (VAR_5 = 0; VAR_5 < reslevel->nbands ; VAR_5++){", "int bandpos = VAR_5 + (VAR_4 > 0);", "Jpeg2000Band *band = reslevel->band + VAR_5;", "Jpeg2000Prec *prec = band->prec + VAR_2;", "for (VAR_6 = 0; VAR_6 < prec->nb_codeblocks_height * prec->nb_codeblocks_width; VAR_6++){", "Jpeg2000Cblk *cblk = prec->cblk + VAR_6;", "cblk->ninclpasses = getcut(cblk, VAR_0->lambda,\n(int64_t)dwt_norms[codsty->transform][bandpos][VAR_7] * (int64_t)band->i_stepsize >> 16);", "}", "}", "}", "}", "}", "}" ]

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

[ "uint64_t FUNC_0(void)\n{", "return blk_mig_bytes_total() - blk_mig_bytes_transferred();", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(Jpeg2000DecoderContext *VAR_0, int VAR_1)\n{", "int VAR_2;", "int VAR_3 = VAR_1 % VAR_0->numXtiles;", "int VAR_4 = VAR_1 / VAR_0->numXtiles;", "Jpeg2000Tile *tile = VAR_0->tile + VAR_1;", "if (!tile->comp)\nreturn AVERROR(ENOMEM);", "tile->coord[0][0] = av_clip(VAR_3 * VAR_0->tile_width + VAR_0->tile_offset_x, VAR_0->image_offset_x, VAR_0->width);", "tile->coord[0][1] = av_clip((VAR_3 + 1) * VAR_0->tile_width + VAR_0->tile_offset_x, VAR_0->image_offset_x, VAR_0->width);", "tile->coord[1][0] = av_clip(VAR_4 * VAR_0->tile_height + VAR_0->tile_offset_y, VAR_0->image_offset_y, VAR_0->height);", "tile->coord[1][1] = av_clip((VAR_4 + 1) * VAR_0->tile_height + VAR_0->tile_offset_y, VAR_0->image_offset_y, VAR_0->height);", "for (VAR_2 = 0; VAR_2 < VAR_0->ncomponents; VAR_2++) {", "Jpeg2000Component *comp = tile->comp + VAR_2;", "Jpeg2000CodingStyle *codsty = tile->codsty + VAR_2;", "Jpeg2000QuantStyle *qntsty = tile->qntsty + VAR_2;", "int ret;", "comp->coord_o[0][0] = tile->coord[0][0];", "comp->coord_o[0][1] = tile->coord[0][1];", "comp->coord_o[1][0] = tile->coord[1][0];", "comp->coord_o[1][1] = tile->coord[1][1];", "if (VAR_2) {", "comp->coord_o[0][0] /= VAR_0->cdx[VAR_2];", "comp->coord_o[0][1] /= VAR_0->cdx[VAR_2];", "comp->coord_o[1][0] /= VAR_0->cdy[VAR_2];", "comp->coord_o[1][1] /= VAR_0->cdy[VAR_2];", "}", "comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], VAR_0->reduction_factor);", "comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], VAR_0->reduction_factor);", "comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], VAR_0->reduction_factor);", "comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], VAR_0->reduction_factor);", "if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,\nVAR_0->cbps[VAR_2], VAR_0->cdx[VAR_2],\nVAR_0->cdy[VAR_2], VAR_0->avctx))\nreturn ret;", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "SRTContext *srt = VAR_0->priv_data;", "int VAR_2 = VAR_0->streams[0]->codec->codec_id != AV_CODEC_ID_SRT;", "srt->index++;", "if (VAR_2) {", "int64_t s = VAR_1->pts, e, d = VAR_1->duration;", "if (d <= 0)\nd = VAR_1->convergence_duration;", "if (s == AV_NOPTS_VALUE || d < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Insufficient timestamps.\\n\");", "return AVERROR(EINVAL);", "}", "e = s + d;", "avio_printf(VAR_0->pb, \"%d\\n%02d:%02d:%02d,%03d --> %02d:%02d:%02d,%03d\\n\",\nsrt->index,\n(int)(s / 3600000), (int)(s / 60000) % 60,\n(int)(s / 1000) % 60, (int)(s % 1000),\n(int)(e / 3600000), (int)(e / 60000) % 60,\n(int)(e / 1000) % 60, (int)(e % 1000));", "}", "avio_write(VAR_0->pb, VAR_1->data, VAR_1->size);", "if (VAR_2)\navio_write(VAR_0->pb, \"\\n\\n\", 2);", "avio_flush(VAR_0->pb);", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,\nconst AVFrame *VAR_2, int *VAR_3)\n{", "FlacEncodeContext *s;", "int VAR_4, VAR_5, VAR_6;", "s = VAR_0->priv_data;", "if (!VAR_2) {", "s->max_framesize = s->max_encoded_framesize;", "av_md5_final(s->md5ctx, s->md5sum);", "write_streaminfo(s, VAR_0->extradata);", "return 0;", "}", "if (VAR_2->nb_samples < s->VAR_2.blocksize) {", "s->max_framesize = ff_flac_get_max_frame_size(VAR_2->nb_samples,\ns->channels,\nVAR_0->bits_per_raw_sample);", "}", "init_frame(s, VAR_2->nb_samples);", "copy_samples(s, VAR_2->data[0]);", "channel_decorrelation(s);", "remove_wasted_bits(s);", "VAR_4 = encode_frame(s);", "if (VAR_4 < 0 || VAR_4 > s->max_framesize) {", "s->VAR_2.verbatim_only = 1;", "VAR_4 = encode_frame(s);", "if (VAR_4 < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Bad VAR_2 count\\n\");", "return VAR_4;", "}", "}", "if ((VAR_6 = ff_alloc_packet2(VAR_0, VAR_1, VAR_4)))\nreturn VAR_6;", "VAR_5 = write_frame(s, VAR_1);", "s->frame_count++;", "s->sample_count += VAR_2->nb_samples;", "if ((VAR_6 = update_md5_sum(s, VAR_2->data[0])) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Error updating MD5 checksum\\n\");", "return VAR_6;", "}", "if (VAR_5 > s->max_encoded_framesize)\ns->max_encoded_framesize = VAR_5;", "if (VAR_5 < s->min_framesize)\ns->min_framesize = VAR_5;", "VAR_1->pts = VAR_2->pts;", "VAR_1->duration = ff_samples_to_time_base(VAR_0, VAR_2->nb_samples);", "VAR_1->size = VAR_5;", "*VAR_3 = 1;", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 35 ], [ 37, 39, 41 ], [ 43 ], [ 47 ], [ 51 ], [ 55 ], [ 59 ], [ 63 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89, 91 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111, 113 ], [ 115, 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ] ]

[ "void FUNC_0(uint8_t *VAR_0, int VAR_1, int *VAR_2)\n{", "__asm__ volatile(\n\"movq %0, %%mm6 \\n\\t\"\n\"movq %1, %%mm4 \\n\\t\"\n\"movq %2, %%mm2 \\n\\t\"\n\"movq %3, %%mm1 \\n\\t\"\nVP3_LOOP_FILTER(%4)\n\"movq %%mm4, %1 \\n\\t\"\n\"movq %%mm3, %2 \\n\\t\"\n: \"+m\" (*(uint64_t*)(VAR_0 - 2*VAR_1)),\n\"+m\" (*(uint64_t*)(VAR_0 - 1*VAR_1)),\n\"+m\" (*(uint64_t*)(VAR_0 + 0*VAR_1)),\n\"+m\" (*(uint64_t*)(VAR_0 + 1*VAR_1))\n: \"m\"(*(uint64_t*)(VAR_2+129))\n);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "const uint8_t *VAR_6;", "uint8_t segment_type;", "int VAR_7;", "int VAR_8, VAR_9;", "av_dlog(VAR_0, \"PGS sub packet:\\n\");", "for (VAR_8 = 0; VAR_8 < VAR_5; VAR_8++) {", "av_dlog(VAR_0, \"%02x \", VAR_4[VAR_8]);", "if (VAR_8 % 16 == 15)\nav_dlog(VAR_0, \"\\n\");", "}", "if (VAR_8 & 15)\nav_dlog(VAR_0, \"\\n\");", "*VAR_2 = 0;", "if (VAR_5 < 3)\nreturn -1;", "VAR_6 = VAR_4 + VAR_5;", "while (VAR_4 < VAR_6) {", "segment_type = bytestream_get_byte(&VAR_4);", "VAR_7 = bytestream_get_be16(&VAR_4);", "av_dlog(VAR_0, \"Segment Length %d, Segment Type %x\\n\", VAR_7, segment_type);", "if (segment_type != DISPLAY_SEGMENT && VAR_7 > VAR_6 - VAR_4)\nbreak;", "switch (segment_type) {", "case PALETTE_SEGMENT:\nparse_palette_segment(VAR_0, VAR_4, VAR_7);", "break;", "case PICTURE_SEGMENT:\nparse_picture_segment(VAR_0, VAR_4, VAR_7);", "break;", "case PRESENTATION_SEGMENT:\nVAR_9 = parse_presentation_segment(VAR_0, VAR_4, VAR_7, VAR_3->pts);", "if (VAR_9 < 0)\nreturn VAR_9;", "break;", "case WINDOW_SEGMENT:\nbreak;", "case DISPLAY_SEGMENT:\n*VAR_2 = display_end_segment(VAR_0, VAR_1, VAR_4, VAR_7);", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unknown subtitle segment type 0x%x, length %d\\n\",\nsegment_type, VAR_7);", "break;", "}", "VAR_4 += VAR_7;", "}", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 39, 41 ], [ 45 ], [ 51, 53 ], [ 57 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 75, 77 ], [ 81 ], [ 83, 85 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95, 97 ], [ 99, 101 ], [ 103 ], [ 105, 123 ], [ 125, 127 ], [ 129 ], [ 131, 133, 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ] ]

[ "static int FUNC_0(MOVContext *VAR_0, AVIOContext *VAR_1,\nAVStream *VAR_2, MOVStreamContext *VAR_3)\n{", "if (VAR_2->codec->codec_type == AVMEDIA_TYPE_AUDIO &&\n!VAR_2->codec->sample_rate && VAR_3->time_scale > 1)\nVAR_2->codec->sample_rate = VAR_3->time_scale;", "switch (VAR_2->codec->codec_id) {", "#if CONFIG_DV_DEMUXER\ncase AV_CODEC_ID_DVAUDIO:\nVAR_0->dv_fctx = avformat_alloc_context();", "if (!VAR_0->dv_fctx) {", "av_log(VAR_0->fc, AV_LOG_ERROR, \"dv demux context alloc error\\n\");", "return AVERROR(ENOMEM);", "}", "VAR_0->dv_demux = avpriv_dv_init_demux(VAR_0->dv_fctx);", "if (!VAR_0->dv_demux) {", "av_log(VAR_0->fc, AV_LOG_ERROR, \"dv demux context init error\\n\");", "return AVERROR(ENOMEM);", "}", "VAR_3->dv_audio_container = 1;", "VAR_2->codec->codec_id = AV_CODEC_ID_PCM_S16LE;", "break;", "#endif\ncase AV_CODEC_ID_QCELP:\nVAR_2->codec->channels = 1;", "if (VAR_2->codec->codec_tag != MKTAG('Q','VAR_0','l','p'))\nVAR_2->codec->sample_rate = 8000;", "break;", "case AV_CODEC_ID_AMR_NB:\nVAR_2->codec->channels = 1;", "VAR_2->codec->sample_rate = 8000;", "break;", "case AV_CODEC_ID_AMR_WB:\nVAR_2->codec->channels = 1;", "VAR_2->codec->sample_rate = 16000;", "break;", "case AV_CODEC_ID_MP2:\ncase AV_CODEC_ID_MP3:\nVAR_2->codec->codec_type = AVMEDIA_TYPE_AUDIO;", "VAR_2->need_parsing = AVSTREAM_PARSE_FULL;", "break;", "case AV_CODEC_ID_GSM:\ncase AV_CODEC_ID_ADPCM_MS:\ncase AV_CODEC_ID_ADPCM_IMA_WAV:\ncase AV_CODEC_ID_ILBC:\nVAR_2->codec->block_align = VAR_3->bytes_per_frame;", "break;", "case AV_CODEC_ID_ALAC:\nif (VAR_2->codec->extradata_size == 36) {", "VAR_2->codec->channels = AV_RB8 (VAR_2->codec->extradata + 21);", "VAR_2->codec->sample_rate = AV_RB32(VAR_2->codec->extradata + 32);", "}", "break;", "case AV_CODEC_ID_VC1:\nVAR_2->need_parsing = AVSTREAM_PARSE_FULL;", "break;", "default:\nbreak;", "}", "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 ]

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

[ "void VAR_0 op_srli_T1 (void)\n{", "T1 = T1 >> PARAM1;", "RETURN();", "}" ]

[ 0, 1, 1, 0 ]

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

[ "static int FUNC_0(IVI45DecContext *VAR_0, AVCodecContext *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4;", "IVIPicConfig pic_conf;", "if (get_bits(&VAR_0->gb, 18) != 0x3FFF8) {", "av_log(VAR_1, AV_LOG_ERROR, \"Invalid picture start code!\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->prev_frame_type = VAR_0->frame_type;", "VAR_0->frame_type = get_bits(&VAR_0->gb, 3);", "if (VAR_0->frame_type == 7) {", "av_log(VAR_1, AV_LOG_ERROR, \"Invalid frame type: %d\\n\", VAR_0->frame_type);", "return AVERROR_INVALIDDATA;", "}", "#if IVI4_STREAM_ANALYSER\nif (VAR_0->frame_type == FRAMETYPE_BIDIR)\nVAR_0->has_b_frames = 1;", "#endif\nVAR_0->transp_status = get_bits1(&VAR_0->gb);", "#if IVI4_STREAM_ANALYSER\nif (VAR_0->transp_status) {", "VAR_0->has_transp = 1;", "}", "#endif\nif (get_bits1(&VAR_0->gb)) {", "av_log(VAR_1, AV_LOG_ERROR, \"Sync bit is set!\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->data_size = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 24) : 0;", "if (VAR_0->frame_type >= FRAMETYPE_NULL_FIRST) {", "av_dlog(VAR_1, \"Null frame encountered!\\n\");", "return 0;", "}", "if (get_bits1(&VAR_0->gb)) {", "skip_bits_long(&VAR_0->gb, 32);", "av_dlog(VAR_1, \"Password-protected clip!\\n\");", "}", "VAR_2 = get_bits(&VAR_0->gb, 3);", "if (VAR_2 == IVI4_PIC_SIZE_ESC) {", "pic_conf.pic_height = get_bits(&VAR_0->gb, 16);", "pic_conf.pic_width = get_bits(&VAR_0->gb, 16);", "} else {", "pic_conf.pic_height = ivi4_common_pic_sizes[VAR_2 * 2 + 1];", "pic_conf.pic_width = ivi4_common_pic_sizes[VAR_2 * 2 ];", "}", "if (get_bits1(&VAR_0->gb)) {", "pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&VAR_0->gb, 4));", "pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&VAR_0->gb, 4));", "#if IVI4_STREAM_ANALYSER\nVAR_0->uses_tiling = 1;", "#endif\n} else {", "pic_conf.tile_height = pic_conf.pic_height;", "pic_conf.tile_width = pic_conf.pic_width;", "}", "if (get_bits(&VAR_0->gb, 2)) {", "av_log(VAR_1, AV_LOG_ERROR, \"Only YVU9 picture format is supported!\\n\");", "return AVERROR_INVALIDDATA;", "}", "pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;", "pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;", "pic_conf.luma_bands = decode_plane_subdivision(&VAR_0->gb);", "if (pic_conf.luma_bands)\npic_conf.chroma_bands = decode_plane_subdivision(&VAR_0->gb);", "VAR_0->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;", "if (VAR_0->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {", "av_log(VAR_1, AV_LOG_ERROR, \"Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\\n\",\npic_conf.luma_bands, pic_conf.chroma_bands);", "return AVERROR_INVALIDDATA;", "}", "if (ivi_pic_config_cmp(&pic_conf, &VAR_0->pic_conf)) {", "if (ff_ivi_init_planes(VAR_0->planes, &pic_conf)) {", "av_log(VAR_1, AV_LOG_ERROR, \"Couldn't reallocate color planes!\\n\");", "return AVERROR(ENOMEM);", "}", "VAR_0->pic_conf = pic_conf;", "for (VAR_4 = 0; VAR_4 <= 2; VAR_4++) {", "for (VAR_3 = 0; VAR_3 < (!VAR_4 ? pic_conf.luma_bands : pic_conf.chroma_bands); VAR_3++) {", "VAR_0->planes[VAR_4].bands[VAR_3].mb_size = !VAR_4 ? (!VAR_0->is_scalable ? 16 : 8) : 4;", "VAR_0->planes[VAR_4].bands[VAR_3].blk_size = !VAR_4 ? 8 : 4;", "}", "}", "if (ff_ivi_init_tiles(VAR_0->planes, VAR_0->pic_conf.tile_width,\nVAR_0->pic_conf.tile_height)) {", "av_log(VAR_1, AV_LOG_ERROR,\n\"Couldn't reallocate internal structures!\\n\");", "return AVERROR(ENOMEM);", "}", "}", "VAR_0->frame_num = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 20) : 0;", "if (get_bits1(&VAR_0->gb))\nskip_bits(&VAR_0->gb, 8);", "if (ff_ivi_dec_huff_desc(&VAR_0->gb, get_bits1(&VAR_0->gb), IVI_MB_HUFF, &VAR_0->mb_vlc, VAR_1) ||\nff_ivi_dec_huff_desc(&VAR_0->gb, get_bits1(&VAR_0->gb), IVI_BLK_HUFF, &VAR_0->blk_vlc, VAR_1))\nreturn AVERROR_INVALIDDATA;", "VAR_0->rvmap_sel = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 3) : 8;", "VAR_0->in_imf = get_bits1(&VAR_0->gb);", "VAR_0->in_q = get_bits1(&VAR_0->gb);", "VAR_0->pic_glob_quant = get_bits(&VAR_0->gb, 5);", "VAR_0->unknown1 = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 3) : 0;", "VAR_0->checksum = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 16) : 0;", "while (get_bits1(&VAR_0->gb)) {", "av_dlog(VAR_1, \"Pic hdr extension encountered!\\n\");", "skip_bits(&VAR_0->gb, 8);", "}", "if (get_bits1(&VAR_0->gb)) {", "av_log(VAR_1, AV_LOG_ERROR, \"Bad blocks bits encountered!\\n\");", "}", "align_get_bits(&VAR_0->gb);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35, 37, 39 ], [ 41, 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 123 ], [ 125 ], [ 127 ], [ 129, 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 163 ], [ 166, 168 ], [ 170 ], [ 172 ], [ 174, 176 ], [ 178 ], [ 180 ], [ 186 ], [ 188 ], [ 190 ], [ 192 ], [ 194 ], [ 198 ], [ 204 ], [ 206 ], [ 208 ], [ 210 ], [ 212 ], [ 214 ], [ 218, 220 ], [ 222, 224 ], [ 226 ], [ 228 ], [ 230 ], [ 234 ], [ 240, 242 ], [ 248, 250, 252 ], [ 256 ], [ 260 ], [ 262 ], [ 266 ], [ 272 ], [ 276 ], [ 282 ], [ 284 ], [ 286 ], [ 288 ], [ 292 ], [ 294 ], [ 296 ], [ 300 ], [ 304 ], [ 306 ] ]

[ "void FUNC_0(uint8_t *VAR_0, int VAR_1, DCTELEM VAR_2[64])\n{", "LOAD_ZERO;", "vec_u8 t, vdst;", "vec_s16 vdst_16;", "vec_u8 vdst_mask = vec_mergeh(vec_splat_u8(-1), vec_lvsl(0, VAR_0));", "IDCT_START\nIDCT_1D(NOP, NOP)\nTRANSPOSE8(b0, b1, b2, b3, b4, b5, b6, b7);", "IDCT_1D(ADD8, SHIFT4)\n#define ADD(a)\\\nvdst = vec_ld(0, VAR_0);\\", "vdst_16 = (vec_s16)vec_perm(vdst, zero_u8v, vdst_mask);\\", "vdst_16 = vec_adds(a, vdst_16);\\", "t = vec_packsu(vdst_16, vdst_16);\\", "vec_ste((vec_u32)t, 0, (unsigned int *)VAR_0);\\", "vec_ste((vec_u32)t, 4, (unsigned int *)VAR_0);", "ADD(b0) VAR_0 += VAR_1;", "ADD(b1) VAR_0 += VAR_1;", "ADD(b2) VAR_0 += VAR_1;", "ADD(b3) VAR_0 += VAR_1;", "ADD(b4) VAR_0 += VAR_1;", "ADD(b5) VAR_0 += VAR_1;", "ADD(b6) VAR_0 += VAR_1;", "ADD(b7)\n}" ]

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

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

[ "static void FUNC_0(Visitor *VAR_0, const char *VAR_1,\nuint64_t *VAR_2, Error **VAR_3)\n{", "QObjectOutputVisitor *qov = to_qov(VAR_0);", "qobject_output_add(qov, VAR_1, qnum_from_int(*VAR_2));", "}" ]

[ 0, 0, 1, 0 ]

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

[ "static int FUNC_0(AVFormatContext *VAR_0, ASFPacket *VAR_1)\n{", "ASFContext *asf = VAR_0->priv_data;", "AVIOContext *pb = VAR_0->pb;", "int VAR_2;", "if (!VAR_1->data_size) {", "VAR_1->data_size = VAR_1->size_left = avio_rl32(pb);", "if (VAR_1->data_size <= 0)\nreturn AVERROR_INVALIDDATA;", "if ((VAR_2 = av_new_packet(&VAR_1->avpkt, VAR_1->data_size)) < 0)\nreturn VAR_2;", "} else", "avio_skip(pb, 4);", "VAR_1->dts = avio_rl32(pb);", "if (asf->rep_data_len && (asf->rep_data_len >= 8))\navio_skip(pb, asf->rep_data_len - 8);", "return 0;", "}" ]

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

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

[ "float64 FUNC_0(float64 a, float64 b, float64 c, int flags STATUS_PARAM)\n{", "flag aSign, bSign, cSign, zSign;", "int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;", "uint64_t aSig, bSig, cSig;", "flag pInf, pZero, pSign;", "uint64_t pSig0, pSig1, cSig0, cSig1, zSig0, zSig1;", "int VAR_0;", "flag signflip, infzero;", "a = float64_squash_input_denormal(a STATUS_VAR);", "b = float64_squash_input_denormal(b STATUS_VAR);", "c = float64_squash_input_denormal(c STATUS_VAR);", "aSig = extractFloat64Frac(a);", "aExp = extractFloat64Exp(a);", "aSign = extractFloat64Sign(a);", "bSig = extractFloat64Frac(b);", "bExp = extractFloat64Exp(b);", "bSign = extractFloat64Sign(b);", "cSig = extractFloat64Frac(c);", "cExp = extractFloat64Exp(c);", "cSign = extractFloat64Sign(c);", "infzero = ((aExp == 0 && aSig == 0 && bExp == 0x7ff && bSig == 0) ||\n(aExp == 0x7ff && aSig == 0 && bExp == 0 && bSig == 0));", "if (((aExp == 0x7ff) && aSig) ||\n((bExp == 0x7ff) && bSig) ||\n((cExp == 0x7ff) && cSig)) {", "return propagateFloat64MulAddNaN(a, b, c, infzero STATUS_VAR);", "}", "if (infzero) {", "float_raise(float_flag_invalid STATUS_VAR);", "return float64_default_nan;", "}", "if (flags & float_muladd_negate_c) {", "cSign ^= 1;", "}", "signflip = (flags & float_muladd_negate_result) ? 1 : 0;", "pSign = aSign ^ bSign;", "if (flags & float_muladd_negate_product) {", "pSign ^= 1;", "}", "pInf = (aExp == 0x7ff) || (bExp == 0x7ff);", "pZero = ((aExp | aSig) == 0) || ((bExp | bSig) == 0);", "if (cExp == 0x7ff) {", "if (pInf && (pSign ^ cSign)) {", "float_raise(float_flag_invalid STATUS_VAR);", "return float64_default_nan;", "}", "return packFloat64(cSign ^ signflip, 0x7ff, 0);", "}", "if (pInf) {", "return packFloat64(pSign ^ signflip, 0x7ff, 0);", "}", "if (pZero) {", "if (cExp == 0) {", "if (cSig == 0) {", "if (pSign == cSign) {", "zSign = pSign;", "} else if (STATUS(float_rounding_mode) == float_round_down) {", "zSign = 1;", "} else {", "zSign = 0;", "}", "return packFloat64(zSign ^ signflip, 0, 0);", "}", "if (STATUS(flush_to_zero)) {", "float_raise(float_flag_output_denormal STATUS_VAR);", "return packFloat64(cSign ^ signflip, 0, 0);", "}", "}", "return packFloat64(cSign ^ signflip, cExp, cSig);", "}", "if (aExp == 0) {", "normalizeFloat64Subnormal(aSig, &aExp, &aSig);", "}", "if (bExp == 0) {", "normalizeFloat64Subnormal(bSig, &bExp, &bSig);", "}", "pExp = aExp + bExp - 0x3fe;", "aSig = (aSig | LIT64(0x0010000000000000))<<10;", "bSig = (bSig | LIT64(0x0010000000000000))<<11;", "mul64To128(aSig, bSig, &pSig0, &pSig1);", "if ((int64_t)(pSig0 << 1) >= 0) {", "shortShift128Left(pSig0, pSig1, 1, &pSig0, &pSig1);", "pExp--;", "}", "zSign = pSign ^ signflip;", "if (cExp == 0) {", "if (!cSig) {", "shift128RightJamming(pSig0, pSig1, 64, &pSig0, &pSig1);", "return roundAndPackFloat64(zSign, pExp - 1,\npSig1 STATUS_VAR);", "}", "normalizeFloat64Subnormal(cSig, &cExp, &cSig);", "}", "cSig0 = cSig << (126 - 64 - 52);", "cSig1 = 0;", "cSig0 |= LIT64(0x4000000000000000);", "expDiff = pExp - cExp;", "if (pSign == cSign) {", "if (expDiff > 0) {", "shift128RightJamming(cSig0, cSig1, expDiff, &cSig0, &cSig1);", "zExp = pExp;", "} else if (expDiff < 0) {", "shift128RightJamming(pSig0, pSig1, -expDiff, &pSig0, &pSig1);", "zExp = cExp;", "} else {", "zExp = cExp;", "}", "add128(pSig0, pSig1, cSig0, cSig1, &zSig0, &zSig1);", "if ((int64_t)zSig0 < 0) {", "shift128RightJamming(zSig0, zSig1, 1, &zSig0, &zSig1);", "} else {", "zExp--;", "}", "shift128RightJamming(zSig0, zSig1, 64, &zSig0, &zSig1);", "return roundAndPackFloat64(zSign, zExp, zSig1 STATUS_VAR);", "} else {", "if (expDiff > 0) {", "shift128RightJamming(cSig0, cSig1, expDiff, &cSig0, &cSig1);", "sub128(pSig0, pSig1, cSig0, cSig1, &zSig0, &zSig1);", "zExp = pExp;", "} else if (expDiff < 0) {", "shift128RightJamming(pSig0, pSig1, -expDiff, &pSig0, &pSig1);", "sub128(cSig0, cSig1, pSig0, pSig1, &zSig0, &zSig1);", "zExp = cExp;", "zSign ^= 1;", "} else {", "zExp = pExp;", "if (lt128(cSig0, cSig1, pSig0, pSig1)) {", "sub128(pSig0, pSig1, cSig0, cSig1, &zSig0, &zSig1);", "} else if (lt128(pSig0, pSig1, cSig0, cSig1)) {", "sub128(cSig0, cSig1, pSig0, pSig1, &zSig0, &zSig1);", "zSign ^= 1;", "} else {", "zSign = signflip;", "if (STATUS(float_rounding_mode) == float_round_down) {", "zSign ^= 1;", "}", "return packFloat64(zSign, 0, 0);", "}", "}", "--zExp;", "if (zSig0) {", "VAR_0 = countLeadingZeros64(zSig0) - 1;", "shortShift128Left(zSig0, zSig1, VAR_0, &zSig0, &zSig1);", "if (zSig1) {", "zSig0 |= 1;", "}", "zExp -= VAR_0;", "} else {", "VAR_0 = countLeadingZeros64(zSig1) - 1;", "zSig0 = zSig1 << VAR_0;", "zExp -= (VAR_0 + 64);", "}", "return roundAndPackFloat64(zSign, zExp, zSig0 STATUS_VAR);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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 ], [ 47, 49 ], [ 63, 65, 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 233 ], [ 243 ], [ 245 ], [ 249 ], [ 251, 253 ], [ 255 ], [ 257 ], [ 259 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 279 ], [ 283 ], [ 287 ], [ 289 ], [ 291 ], [ 295 ], [ 297 ], [ 299 ], [ 303 ], [ 305 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ] ]

[ "static void FUNC_0(VGACommonState *VAR_0)\n{", "int VAR_1;", "int VAR_2;", "int VAR_3;", "int VAR_4;", "int VAR_5;", "int VAR_6;", "int VAR_7;", "int VAR_8;", "#if 0\nint div2, sldiv2;", "#endif\nint VAR_9;", "int VAR_10;", "const int VAR_11[] = {25175000, 28322000, 25175000, 25175000};", "int64_t chars_per_sec;", "struct vga_precise_retrace *VAR_12 = &VAR_0->retrace_info.precise;", "VAR_1 = VAR_0->cr[VGA_CRTC_H_TOTAL] + 5;", "VAR_2 = VAR_0->cr[VGA_CRTC_H_SYNC_START];", "VAR_3 = (VAR_0->cr[VGA_CRTC_H_SYNC_END] >> 5) & 3;", "VAR_4 = VAR_0->cr[VGA_CRTC_H_SYNC_END] & 0x1f;", "VAR_5 = (VAR_0->cr[VGA_CRTC_V_TOTAL] |\n(((VAR_0->cr[VGA_CRTC_OVERFLOW] & 1) |\n((VAR_0->cr[VGA_CRTC_OVERFLOW] >> 4) & 2)) << 8)) + 2;", "VAR_6 = VAR_0->cr[VGA_CRTC_V_SYNC_START] |\n((((VAR_0->cr[VGA_CRTC_OVERFLOW] >> 2) & 1) |\n((VAR_0->cr[VGA_CRTC_OVERFLOW] >> 6) & 2)) << 8);", "VAR_7 = VAR_0->cr[VGA_CRTC_V_SYNC_END] & 0xf;", "VAR_9 = (VAR_0->sr[VGA_SEQ_CLOCK_MODE] >> 3) & 1;", "VAR_10 = (VAR_0->msr >> 2) & 3;", "VAR_8 = (VAR_0->msr & 1) ? 8 : 9;", "chars_per_sec = VAR_11[VAR_10] / VAR_8;", "VAR_1 <<= VAR_9;", "VAR_12->total_chars = VAR_5 * VAR_1;", "if (VAR_12->freq) {", "VAR_12->ticks_per_char = NANOSECONDS_PER_SECOND / (VAR_12->total_chars * VAR_12->freq);", "} else {", "VAR_12->ticks_per_char = NANOSECONDS_PER_SECOND / chars_per_sec;", "}", "VAR_12->vstart = VAR_6;", "VAR_12->vend = VAR_12->vstart + VAR_7 + 1;", "VAR_12->hstart = VAR_2 + VAR_3;", "VAR_12->hend = VAR_12->hstart + VAR_4 + 1;", "VAR_12->htotal = VAR_1;", "#if 0\ndiv2 = (VAR_0->cr[VGA_CRTC_MODE] >> 2) & 1;", "sldiv2 = (VAR_0->cr[VGA_CRTC_MODE] >> 3) & 1;", "printf (\n\"hz=%f\\n\"\n\"htotal = %d\\n\"\n\"hretr_start = %d\\n\"\n\"hretr_skew = %d\\n\"\n\"hretr_end = %d\\n\"\n\"vtotal = %d\\n\"\n\"vretr_start = %d\\n\"\n\"vretr_end = %d\\n\"\n\"div2 = %d sldiv2 = %d\\n\"\n\"VAR_9 = %d\\n\"\n\"VAR_10 = %d %d\\n\"\n\"VAR_8 = %d\\n\"\n\"ticks/char = %\" PRId64 \"\\n\"\n\"\\n\",\n(double) NANOSECONDS_PER_SECOND / (VAR_12->ticks_per_char * VAR_12->total_chars),\nVAR_1,\nVAR_2,\nVAR_3,\nVAR_4,\nVAR_5,\nVAR_6,\nVAR_7,\ndiv2, sldiv2,\nVAR_9,\nVAR_10,\nVAR_11[VAR_10],\nVAR_8,\nVAR_12->ticks_per_char\n);", "#endif\n}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "qemu_log_mask(CPU_LOG_RESET, \"Watchdog timer expired.\\n\");", "watchdog_perform_action();", "switch (get_watchdog_action()) {", "case WDT_DEBUG:\ncase WDT_NONE:\ncase WDT_PAUSE:\nreturn;", "}", "wdt_diag288_reset(VAR_0);", "}" ]

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

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

[ "void FUNC_0(Monitor *VAR_0, const QObject *VAR_1)\n{", "QDict *qdict;", "int VAR_2;", "assert(qobject_type(VAR_1) == QTYPE_QDICT);", "qdict = qobject_to_qdict(VAR_1);", "VAR_2 = (int)qdict_get_int(qdict, \"VAR_2\");", "monitor_printf(VAR_0, \"OK id: %s root bus: %s, bus: %x VAR_2: %x.%x\\n\",\nqdict_get_str(qdict, \"id\"),\nqdict_get_str(qdict, \"root_bus\"),\n(int) qdict_get_int(qdict, \"bus\"),\nPCI_SLOT(VAR_2), PCI_FUNC(VAR_2));", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0, int VAR_1)\n{", "if (VAR_0->hflags & MIPS_HFLAG_BMASK) {", "int VAR_2 = VAR_0->hflags & MIPS_HFLAG_BMASK;", "VAR_0->hflags &= ~MIPS_HFLAG_BMASK;", "VAR_0->bstate = BS_BRANCH;", "save_cpu_state(VAR_0, 0);", "switch (VAR_2 & MIPS_HFLAG_BMASK_BASE) {", "case MIPS_HFLAG_FBNSLOT:\nMIPS_DEBUG(\"forbidden slot\");", "gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_1);", "break;", "case MIPS_HFLAG_B:\nMIPS_DEBUG(\"unconditional branch\");", "if (VAR_2 & MIPS_HFLAG_BX) {", "tcg_gen_xori_i32(hflags, hflags, MIPS_HFLAG_M16);", "}", "gen_goto_tb(VAR_0, 0, VAR_0->btarget);", "break;", "case MIPS_HFLAG_BL:\nMIPS_DEBUG(\"blikely branch taken\");", "gen_goto_tb(VAR_0, 0, VAR_0->btarget);", "break;", "case MIPS_HFLAG_BC:\nMIPS_DEBUG(\"conditional branch\");", "{", "TCGLabel *l1 = gen_new_label();", "tcg_gen_brcondi_tl(TCG_COND_NE, bcond, 0, l1);", "gen_goto_tb(VAR_0, 1, VAR_0->pc + VAR_1);", "gen_set_label(l1);", "gen_goto_tb(VAR_0, 0, VAR_0->btarget);", "}", "break;", "case MIPS_HFLAG_BR:\nMIPS_DEBUG(\"branch to register\");", "if (VAR_0->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) {", "TCGv t0 = tcg_temp_new();", "TCGv_i32 t1 = tcg_temp_new_i32();", "tcg_gen_andi_tl(t0, btarget, 0x1);", "tcg_gen_trunc_tl_i32(t1, t0);", "tcg_temp_free(t0);", "tcg_gen_andi_i32(hflags, hflags, ~(uint32_t)MIPS_HFLAG_M16);", "tcg_gen_shli_i32(t1, t1, MIPS_HFLAG_M16_SHIFT);", "tcg_gen_or_i32(hflags, hflags, t1);", "tcg_temp_free_i32(t1);", "tcg_gen_andi_tl(cpu_PC, btarget, ~(target_ulong)0x1);", "} else {", "tcg_gen_mov_tl(cpu_PC, btarget);", "}", "if (VAR_0->singlestep_enabled) {", "save_cpu_state(VAR_0, 0);", "gen_helper_0e0i(raise_exception, EXCP_DEBUG);", "}", "tcg_gen_exit_tb(0);", "break;", "default:\nMIPS_DEBUG(\"unknown branch\");", "break;", "}", "}", "}" ]

[ 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 29, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45, 49 ], [ 51 ], [ 53 ], [ 55, 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79, 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129, 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, uint8_t *VAR_1,\nint VAR_2, void *VAR_3)\n{", "FlacEncodeContext *s;", "const int16_t *VAR_4 = VAR_3;", "int VAR_5, VAR_6;", "s = VAR_0->priv_data;", "if (!VAR_3) {", "s->max_framesize = s->max_encoded_framesize;", "av_md5_final(s->md5ctx, s->md5sum);", "write_streaminfo(s, VAR_0->extradata);", "return 0;", "}", "if (VAR_0->frame_size < s->VAR_1.blocksize) {", "s->max_framesize = ff_flac_get_max_frame_size(VAR_0->frame_size,\ns->channels, 16);", "}", "init_frame(s);", "copy_samples(s, VAR_4);", "channel_decorrelation(s);", "VAR_5 = encode_frame(s);", "if (VAR_2 < VAR_5) {", "av_log(VAR_0, AV_LOG_ERROR, \"output buffer too small\\n\");", "return 0;", "}", "VAR_6 = write_frame(s, VAR_1, VAR_2);", "if (VAR_6 > s->max_framesize) {", "s->VAR_1.verbatim_only = 1;", "VAR_5 = encode_frame(s);", "if (VAR_2 < VAR_5) {", "av_log(VAR_0, AV_LOG_ERROR, \"output buffer too small\\n\");", "return 0;", "}", "VAR_6 = write_frame(s, VAR_1, VAR_2);", "}", "s->frame_count++;", "VAR_0->coded_frame->pts = s->sample_count;", "s->sample_count += VAR_0->frame_size;", "update_md5_sum(s, VAR_4);", "if (VAR_6 > s->max_encoded_framesize)\ns->max_encoded_framesize = VAR_6;", "if (VAR_6 < s->min_framesize)\ns->min_framesize = VAR_6;", "return VAR_6;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 47 ], [ 51 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109, 111 ], [ 115 ], [ 117 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "DNXHDContext *ctx = VAR_0->priv_data;", "ThreadFrame frame = { .f = VAR_1 };", "AVFrame *picture = VAR_1;", "int VAR_6 = 1;", "int VAR_7, VAR_8;", "ff_dlog(VAR_0, \"frame size %d\\n\", VAR_5);", "decode_coding_unit:\nif ((VAR_7 = dnxhd_decode_header(ctx, picture, VAR_4, VAR_5, VAR_6)) < 0)\nreturn VAR_7;", "if ((VAR_0->width || VAR_0->height) &&\n(ctx->width != VAR_0->width || ctx->height != VAR_0->height)) {", "av_log(VAR_0, AV_LOG_WARNING, \"frame size changed: %dx%d -> %dx%d\\n\",\nVAR_0->width, VAR_0->height, ctx->width, ctx->height);", "VAR_6 = 1;", "}", "if (VAR_0->pix_fmt != AV_PIX_FMT_NONE && VAR_0->pix_fmt != ctx->pix_fmt) {", "av_log(VAR_0, AV_LOG_WARNING, \"pix_fmt changed: %s -> %s\\n\",\nav_get_pix_fmt_name(VAR_0->pix_fmt), av_get_pix_fmt_name(ctx->pix_fmt));", "VAR_6 = 1;", "}", "VAR_0->pix_fmt = ctx->pix_fmt;", "VAR_7 = ff_set_dimensions(VAR_0, ctx->width, ctx->height);", "if (VAR_7 < 0)\nreturn VAR_7;", "if (VAR_6) {", "if ((VAR_7 = ff_thread_get_buffer(VAR_0, &frame, 0)) < 0)\nreturn VAR_7;", "picture->pict_type = AV_PICTURE_TYPE_I;", "picture->key_frame = 1;", "}", "ctx->VAR_5 = VAR_5 - 0x280;", "ctx->VAR_4 = VAR_4 + 0x280;", "VAR_0->execute2(VAR_0, dnxhd_decode_row, picture, NULL, ctx->mb_height);", "if (VAR_6 && picture->interlaced_frame) {", "VAR_4 += ctx->cid_table->coding_unit_size;", "VAR_5 -= ctx->cid_table->coding_unit_size;", "VAR_6 = 0;", "goto decode_coding_unit;", "}", "VAR_7 = 0;", "for (VAR_8 = 0; VAR_8 < VAR_0->thread_count; VAR_8++) {", "VAR_7 += ctx->rows[VAR_8].errors;", "ctx->rows[VAR_8].errors = 0;", "}", "if (VAR_7) {", "av_log(ctx->VAR_0, AV_LOG_ERROR, \"%d lines with errors\\n\", VAR_7);", "return AVERROR_INVALIDDATA;", "}", "*VAR_2 = 1;", "return VAR_3->size;", "}" ]

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

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

[ "static void FUNC_0(HYuvContext *VAR_0, int VAR_1){", "int VAR_2;", "VAR_1/=2;", "if(VAR_0->flags&CODEC_FLAG_PASS1){", "for(VAR_2=0; VAR_2<VAR_1; VAR_2++){", "VAR_0->stats[0][ VAR_0->temp[0][2*VAR_2 ] ]++;", "VAR_0->stats[0][ VAR_0->temp[0][2*VAR_2+1] ]++;", "}", "}else if(VAR_0->context){", "for(VAR_2=0; VAR_2<VAR_1; VAR_2++){", "VAR_0->stats[0][ VAR_0->temp[0][2*VAR_2 ] ]++;", "put_bits(&VAR_0->pb, VAR_0->len[0][ VAR_0->temp[0][2*VAR_2 ] ], VAR_0->bits[0][ VAR_0->temp[0][2*VAR_2 ] ]);", "VAR_0->stats[0][ VAR_0->temp[0][2*VAR_2+1] ]++;", "put_bits(&VAR_0->pb, VAR_0->len[0][ VAR_0->temp[0][2*VAR_2+1] ], VAR_0->bits[0][ VAR_0->temp[0][2*VAR_2+1] ]);", "}", "}else{", "for(VAR_2=0; VAR_2<VAR_1; VAR_2++){", "put_bits(&VAR_0->pb, VAR_0->len[0][ VAR_0->temp[0][2*VAR_2 ] ], VAR_0->bits[0][ VAR_0->temp[0][2*VAR_2 ] ]);", "put_bits(&VAR_0->pb, VAR_0->len[0][ VAR_0->temp[0][2*VAR_2+1] ], VAR_0->bits[0][ VAR_0->temp[0][2*VAR_2+1] ]);", "}", "}", "}" ]

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

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

[ "qemu_irq FUNC_0(qemu_irq irq)\n{", "qemu_irq_raise(irq);", "return qemu_allocate_irqs(qemu_notirq, irq, 1)[0];", "}" ]

[ 0, 0, 1, 0 ]

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

[ "static int FUNC_0(DCAContext *VAR_0)\n{", "int VAR_1 = get_bits_count(&VAR_0->gb);", "int VAR_2;", "int VAR_3;", "int VAR_4 = 0;", "int VAR_5 = 0;", "int VAR_6;", "int VAR_7;", "int VAR_8, VAR_9;", "if (get_bits_left(&VAR_0->gb) < 16)\nreturn -1;", "VAR_2 = get_bits(&VAR_0->gb, 9) + 1;", "skip_bits(&VAR_0->gb, 3);", "if (VAR_0->static_fields) {", "if (get_bits1(&VAR_0->gb))\nskip_bits(&VAR_0->gb, 4);", "if (get_bits1(&VAR_0->gb))\nskip_bits_long(&VAR_0->gb, 24);", "if (get_bits1(&VAR_0->gb)) {", "int VAR_10 = get_bits(&VAR_0->gb, 10) + 1;", "if (get_bits_left(&VAR_0->gb) < VAR_10 * 8)\nreturn -1;", "skip_bits_long(&VAR_0->gb, VAR_10 * 8);", "}", "skip_bits(&VAR_0->gb, 5);", "skip_bits(&VAR_0->gb, 4);", "VAR_3 = get_bits(&VAR_0->gb, 8) + 1;", "if (get_bits1(&VAR_0->gb)) {", "int VAR_11;", "int VAR_12 = 16;", "int VAR_13[7];", "if (VAR_3 > 2)\nVAR_4 = get_bits1(&VAR_0->gb);", "if (VAR_3 > 6)\nVAR_5 = get_bits1(&VAR_0->gb);", "if (get_bits1(&VAR_0->gb)) {", "VAR_12 = (get_bits(&VAR_0->gb, 2) + 1) << 2;", "skip_bits(&VAR_0->gb, VAR_12);", "}", "VAR_11 = get_bits(&VAR_0->gb, 3);", "for (VAR_8 = 0; VAR_8 < VAR_11; VAR_8++) {", "VAR_13[VAR_8] = dca_exss_mask2count(get_bits(&VAR_0->gb, VAR_12));", "}", "for (VAR_8 = 0; VAR_8 < VAR_11; VAR_8++) {", "int VAR_14 = get_bits(&VAR_0->gb, 5) + 1;", "if (get_bits_left(&VAR_0->gb) < 0)\nreturn -1;", "for (VAR_9 = 0; VAR_9 < VAR_13[VAR_8]; VAR_9++) {", "int VAR_15 = get_bits_long(&VAR_0->gb, VAR_14);", "int VAR_16 = av_popcount(VAR_15);", "skip_bits_long(&VAR_0->gb, VAR_16 * 5);", "}", "}", "} else {", "skip_bits(&VAR_0->gb, 3);", "}", "}", "VAR_6 = get_bits1(&VAR_0->gb);", "if (VAR_6)\nget_bits(&VAR_0->gb, 8);", "if (get_bits1(&VAR_0->gb))\nskip_bits(&VAR_0->gb, 5);", "if (VAR_6 && VAR_4)\nget_bits(&VAR_0->gb, 8);", "if (VAR_0->mix_metadata && get_bits1(&VAR_0->gb)) {", "skip_bits(&VAR_0->gb, 1);", "skip_bits(&VAR_0->gb, 6);", "if (get_bits(&VAR_0->gb, 2) != 3)\nskip_bits(&VAR_0->gb, 3);", "else\nskip_bits(&VAR_0->gb, 8);", "if (get_bits1(&VAR_0->gb))\nfor (VAR_8 = 0; VAR_8 < VAR_0->num_mix_configs; VAR_8++)", "skip_bits_long(&VAR_0->gb, VAR_0->mix_config_num_ch[VAR_8] * 6);", "else\nskip_bits_long(&VAR_0->gb, VAR_0->num_mix_configs * 6);", "for (VAR_8 = 0; VAR_8 < VAR_0->num_mix_configs; VAR_8++) {", "if (get_bits_left(&VAR_0->gb) < 0)\nreturn -1;", "dca_exss_skip_mix_coeffs(&VAR_0->gb, VAR_3, VAR_0->mix_config_num_ch[VAR_8]);", "if (VAR_5)\ndca_exss_skip_mix_coeffs(&VAR_0->gb, 6, VAR_0->mix_config_num_ch[VAR_8]);", "if (VAR_4)\ndca_exss_skip_mix_coeffs(&VAR_0->gb, 2, VAR_0->mix_config_num_ch[VAR_8]);", "}", "}", "switch (get_bits(&VAR_0->gb, 2)) {", "case 0: VAR_7 = get_bits(&VAR_0->gb, 12); break;", "case 1: VAR_7 = DCA_EXT_EXSS_XLL; break;", "case 2: VAR_7 = DCA_EXT_EXSS_LBR; break;", "case 3: VAR_7 = 0; break;", "}", "if (get_bits_left(&VAR_0->gb) < 0)\nreturn -1;", "if (get_bits_count(&VAR_0->gb) - VAR_1 > VAR_2 * 8) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Asset header size mismatch.\\n\");", "return -1;", "}", "skip_bits_long(&VAR_0->gb, VAR_1 + VAR_2 * 8 - get_bits_count(&VAR_0->gb));", "if (VAR_7 & DCA_EXT_EXSS_XLL)\nVAR_0->profile = FF_PROFILE_DTS_HD_MA;", "else if (VAR_7 & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |\nDCA_EXT_EXSS_XXCH))\nVAR_0->profile = FF_PROFILE_DTS_HD_HRA;", "if (!(VAR_7 & DCA_EXT_CORE))\nav_log(VAR_0->avctx, AV_LOG_WARNING, \"DTS core detection mismatch.\\n\");", "if ((VAR_7 & DCA_CORE_EXTS) != VAR_0->core_ext_mask)\nav_log(VAR_0->avctx, AV_LOG_WARNING,\n\"DTS extensions detection mismatch (%d, %d)\\n\",\nVAR_7 & DCA_CORE_EXTS, VAR_0->core_ext_mask);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 35 ], [ 37 ], [ 41 ], [ 43, 45 ], [ 47, 49 ], [ 53 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89, 91 ], [ 93, 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109 ], [ 113 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127, 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159, 161 ], [ 165, 167 ], [ 171, 173 ], [ 177 ], [ 179 ], [ 181 ], [ 185, 187 ], [ 189, 191 ], [ 195, 197 ], [ 199 ], [ 201, 203 ], [ 207 ], [ 209, 211 ], [ 213 ], [ 215, 217 ], [ 219, 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 247, 249 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 265, 267 ], [ 269, 271, 273 ], [ 277, 279 ], [ 281, 283, 285, 287 ], [ 291 ], [ 293 ] ]

[ "void FUNC_0(AACEncContext *VAR_0, SingleChannelElement *VAR_1,\nint VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7 = 0, VAR_8 = 0;", "int VAR_9 = -(15 + FFMIN(VAR_1->ics.max_sfb, MAX_LTP_LONG_SFB));", "float *VAR_10 = &VAR_0->scoefs[128*0], *VAR_11 = &VAR_0->scoefs[128*1];", "float *VAR_12 = &VAR_0->scoefs[128*2];", "const int VAR_13 = FFMIN(VAR_1->ics.max_sfb, MAX_LTP_LONG_SFB);", "if (VAR_1->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE) {", "if (VAR_1->ics.ltp.lag) {", "memset(&VAR_1->lcoeffs[0], 0.0f, 3072*sizeof(VAR_1->lcoeffs[0]));", "memset(&VAR_1->ics.ltp, 0, sizeof(LongTermPrediction));", "}", "return;", "}", "if (!VAR_1->ics.ltp.lag)\nreturn;", "for (VAR_3 = 0; VAR_3 < VAR_1->ics.num_windows; VAR_3 += VAR_1->ics.group_len[VAR_3]) {", "VAR_7 = 0;", "for (VAR_4 = 0; VAR_4 < VAR_1->ics.num_swb; VAR_4++) {", "int bits1 = 0, bits2 = 0;", "float dist1 = 0.0f, dist2 = 0.0f;", "if (VAR_3*16+VAR_4 > VAR_13) {", "VAR_7 += VAR_1->ics.swb_sizes[VAR_4];", "continue;", "}", "for (VAR_5 = 0; VAR_5 < VAR_1->ics.group_len[VAR_3]; VAR_5++) {", "int bits_tmp1, bits_tmp2;", "FFPsyBand *band = &VAR_0->psy.ch[VAR_0->cur_channel].psy_bands[(VAR_3+VAR_5)*16+VAR_4];", "for (VAR_6 = 0; VAR_6 < VAR_1->ics.swb_sizes[VAR_4]; VAR_6++)", "VAR_11[VAR_6] = VAR_1->coeffs[VAR_7+(VAR_3+VAR_5)*128+VAR_6] - VAR_1->lcoeffs[VAR_7+(VAR_3+VAR_5)*128+VAR_6];", "abs_pow34_v(VAR_10, &VAR_1->coeffs[VAR_7+(VAR_3+VAR_5)*128], VAR_1->ics.swb_sizes[VAR_4]);", "abs_pow34_v(VAR_12, VAR_11, VAR_1->ics.swb_sizes[VAR_4]);", "dist1 += quantize_band_cost(VAR_0, &VAR_1->coeffs[VAR_7+(VAR_3+VAR_5)*128], VAR_10, VAR_1->ics.swb_sizes[VAR_4],\nVAR_1->sf_idx[(VAR_3+VAR_5)*16+VAR_4], VAR_1->band_type[(VAR_3+VAR_5)*16+VAR_4],\nVAR_0->lambda/band->threshold, INFINITY, &bits_tmp1, NULL, 0);", "dist2 += quantize_band_cost(VAR_0, VAR_11, VAR_12, VAR_1->ics.swb_sizes[VAR_4],\nVAR_1->sf_idx[(VAR_3+VAR_5)*16+VAR_4],\nVAR_1->band_type[(VAR_3+VAR_5)*16+VAR_4],\nVAR_0->lambda/band->threshold, INFINITY, &bits_tmp2, NULL, 0);", "bits1 += bits_tmp1;", "bits2 += bits_tmp2;", "}", "if (dist2 < dist1 && bits2 < bits1) {", "for (VAR_5 = 0; VAR_5 < VAR_1->ics.group_len[VAR_3]; VAR_5++)", "for (VAR_6 = 0; VAR_6 < VAR_1->ics.swb_sizes[VAR_4]; VAR_6++)", "VAR_1->coeffs[VAR_7+(VAR_3+VAR_5)*128+VAR_6] -= VAR_1->lcoeffs[VAR_7+(VAR_3+VAR_5)*128+VAR_6];", "VAR_1->ics.ltp.used[VAR_3*16+VAR_4] = 1;", "VAR_9 += bits1 - bits2;", "VAR_8++;", "}", "VAR_7 += VAR_1->ics.swb_sizes[VAR_4];", "}", "}", "VAR_1->ics.ltp.present = !!VAR_8 && (VAR_9 >= 0);", "VAR_1->ics.predictor_present = !!VAR_1->ics.ltp.present;", "if (!VAR_1->ics.ltp.present && !!VAR_8) {", "for (VAR_3 = 0; VAR_3 < VAR_1->ics.num_windows; VAR_3 += VAR_1->ics.group_len[VAR_3]) {", "VAR_7 = 0;", "for (VAR_4 = 0; VAR_4 < VAR_1->ics.num_swb; VAR_4++) {", "if (VAR_1->ics.ltp.used[VAR_3*16+VAR_4]) {", "for (VAR_5 = 0; VAR_5 < VAR_1->ics.group_len[VAR_3]; VAR_5++) {", "for (VAR_6 = 0; VAR_6 < VAR_1->ics.swb_sizes[VAR_4]; VAR_6++) {", "VAR_1->coeffs[VAR_7+(VAR_3+VAR_5)*128+VAR_6] += VAR_1->lcoeffs[VAR_7+(VAR_3+VAR_5)*128+VAR_6];", "}", "}", "}", "VAR_7 += VAR_1->ics.swb_sizes[VAR_4];", "}", "}", "}", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "int VAR_1;", "TCGv EA;", "VAR_1 = rS(VAR_0->opcode);", "if ((VAR_0->opcode & 0x3) == 0x2) {", "#if defined(CONFIG_USER_ONLY)\ngen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);", "#else\nif (unlikely(VAR_0->mem_idx == 0)) {", "gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);", "return;", "}", "if (unlikely(VAR_1 & 1)) {", "gen_inval_exception(VAR_0, POWERPC_EXCP_INVAL_INVAL);", "return;", "}", "if (unlikely(VAR_0->le_mode)) {", "gen_exception_err(VAR_0, POWERPC_EXCP_ALIGN, POWERPC_EXCP_ALIGN_LE);", "return;", "}", "gen_set_access_type(VAR_0, ACCESS_INT);", "EA = tcg_temp_new();", "gen_addr_imm_index(VAR_0, EA, 0x03);", "gen_qemu_st64(VAR_0, cpu_gpr[VAR_1], EA);", "gen_addr_add(VAR_0, EA, EA, 8);", "gen_qemu_st64(VAR_0, cpu_gpr[VAR_1+1], EA);", "tcg_temp_free(EA);", "#endif\n} else {", "if (Rc(VAR_0->opcode)) {", "if (unlikely(rA(VAR_0->opcode) == 0)) {", "gen_inval_exception(VAR_0, POWERPC_EXCP_INVAL_INVAL);", "return;", "}", "}", "gen_set_access_type(VAR_0, ACCESS_INT);", "EA = tcg_temp_new();", "gen_addr_imm_index(VAR_0, EA, 0x03);", "gen_qemu_st64(VAR_0, cpu_gpr[VAR_1], EA);", "if (Rc(VAR_0->opcode))\ntcg_gen_mov_tl(cpu_gpr[rA(VAR_0->opcode)], EA);", "tcg_temp_free(EA);", "}", "}" ]

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

[ "static int FUNC_0(AVFormatContext *VAR_0,\nFourxmDemuxContext *VAR_1, uint8_t *VAR_2, int VAR_3,\nint VAR_4)\n{", "AVStream *st;", "if (VAR_3 != vtrk_SIZE || VAR_4 < VAR_3 + 8) {", "return AVERROR_INVALIDDATA;", "}", "st = avformat_new_stream(VAR_0, NULL);", "if (!st)\nreturn AVERROR(ENOMEM);", "avpriv_set_pts_info(st, 60, 1, VAR_1->fps);", "VAR_1->video_stream_index = st->index;", "st->codec->codec_type = AVMEDIA_TYPE_VIDEO;", "st->codec->codec_id = AV_CODEC_ID_4XM;", "st->codec->extradata_size = 4;", "st->codec->extradata = av_malloc(4);", "AV_WL32(st->codec->extradata, AV_RL32(VAR_2 + 16));", "st->codec->width = AV_RL32(VAR_2 + 36);", "st->codec->height = AV_RL32(VAR_2 + 40);", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 23 ], [ 25, 27 ], [ 31 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ] ]

[ "static void FUNC_0(test_data *VAR_0)\n{", "AcpiSdtTable *temp;", "int VAR_1;", "g_free(VAR_0->rsdt_tables_addr);", "for (VAR_1 = 0; VAR_1 < VAR_0->tables->len; ++VAR_1) {", "temp = &g_array_index(VAR_0->tables, AcpiSdtTable, VAR_1);", "g_free(temp->aml);", "if (temp->aml_file &&\n!temp->tmp_files_retain &&\ng_strstr_len(temp->aml_file, -1, \"aml-\")) {", "unlink(temp->aml_file);", "}", "g_free(temp->aml_file);", "g_free(temp->asl);", "if (temp->asl_file &&\n!temp->tmp_files_retain) {", "unlink(temp->asl_file);", "}", "g_free(temp->asl_file);", "}", "g_array_free(VAR_0->tables, false);", "}" ]

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

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

[ "static void FUNC_0(int VAR_0, uint8_t *VAR_1, unsigned VAR_2,\nunsigned VAR_3)\n{", "#define TOP_HBAR 1\n#define MID_HBAR 2\n#define BOT_HBAR 4\n#define LEFT_TOP_VBAR 8\n#define LEFT_BOT_VBAR 16\n#define RIGHT_TOP_VBAR 32\n#define RIGHT_BOT_VBAR 64\nstruct {", "int x, y, w, h;", "} VAR_4[] = {", "{ 1, 0, 5, 1 },", "{ 1, 6, 5, 1 },", "{ 1, 12, 5, 1 },", "{ 0, 1, 1, 5 },", "{ 0, 7, 1, 5 },", "{ 6, 1, 1, 5 },", "{ 6, 7, 1, 5 }", "};", "static const unsigned char VAR_5[10] = {", "TOP_HBAR |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,\nRIGHT_TOP_VBAR|RIGHT_BOT_VBAR,\nTOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR |RIGHT_TOP_VBAR,\nTOP_HBAR|MID_HBAR|BOT_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,\nMID_HBAR |LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,\nTOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_BOT_VBAR,\nTOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR |RIGHT_BOT_VBAR,\nTOP_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,\nTOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,\nTOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,\n};", "unsigned VAR_6 = VAR_5[VAR_0];", "int VAR_7;", "draw_rectangle(0, VAR_1, VAR_2, VAR_3, 0, 0, 8, 13);", "for (VAR_7 = 0; VAR_7 < FF_ARRAY_ELEMS(VAR_4); VAR_7++)", "if (VAR_6 & (1<<VAR_7))\ndraw_rectangle(255, VAR_1, VAR_2, VAR_3,\nVAR_4[VAR_7].x, VAR_4[VAR_7].y, VAR_4[VAR_7].w, VAR_4[VAR_7].h);", "}" ]

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

[ [ 1, 3, 5 ], [ 7, 9, 11, 13, 15, 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 ], [ 73 ], [ 75 ], [ 77, 79, 81 ], [ 83 ] ]

[ "static int FUNC_0(AVFilterGraph *VAR_0, AVClass *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4;", "int VAR_5 = 0, VAR_6 = 0;", "int VAR_7 = 0, VAR_8 = 0, VAR_9 = 0,\nVAR_10 = 0;", "for (VAR_2 = 0; VAR_2 < VAR_0->nb_filters; VAR_2++) {", "AVFilterContext *f = VAR_0->filters[VAR_2];", "if (formats_declared(f))\ncontinue;", "if (f->filter->FUNC_0)\nVAR_4 = filter_query_formats(f);", "else\nVAR_4 = ff_default_query_formats(f);", "if (VAR_4 < 0 && VAR_4 != AVERROR(EAGAIN))\nreturn VAR_4;", "VAR_7 += VAR_4 >= 0;", "}", "for (VAR_2 = 0; VAR_2 < VAR_0->nb_filters; VAR_2++) {", "AVFilterContext *filter = VAR_0->filters[VAR_2];", "for (VAR_3 = 0; VAR_3 < filter->nb_inputs; VAR_3++) {", "AVFilterLink *link = filter->inputs[VAR_3];", "int convert_needed = 0;", "if (!link)\ncontinue;", "#define MERGE_DISPATCH(field, statement) \\\nif (!(link->in_ ## field && link->out_ ## field)) { \\", "VAR_10++; \\", "} else if (link->in_ ## field == link->out_ ## field) { \\", "VAR_9++; \\", "} else { \\", "VAR_8++; \\", "statement \\\n}", "MERGE_DISPATCH(formats,\nif (!ff_merge_formats(link->in_formats, link->out_formats,\nlink->type))\nconvert_needed = 1;", ")\nif (link->type == AVMEDIA_TYPE_AUDIO) {", "MERGE_DISPATCH(channel_layouts,\nif (!ff_merge_channel_layouts(link->in_channel_layouts,\nlink->out_channel_layouts))\nconvert_needed = 1;", ")\nMERGE_DISPATCH(samplerates,\nif (!ff_merge_samplerates(link->in_samplerates,\nlink->out_samplerates))\nconvert_needed = 1;", ")\n}", "#undef MERGE_DISPATCH\nif (convert_needed) {", "AVFilterContext *convert;", "AVFilter *filter;", "AVFilterLink *inlink, *outlink;", "char scale_args[256];", "char inst_name[30];", "switch (link->type) {", "case AVMEDIA_TYPE_VIDEO:\nif (!(filter = avfilter_get_by_name(\"scale\"))) {", "av_log(VAR_1, AV_LOG_ERROR, \"'scale' filter \"\n\"not present, cannot convert pixel formats.\\n\");", "return AVERROR(EINVAL);", "}", "snprintf(inst_name, sizeof(inst_name), \"auto-inserted scaler %d\",\nVAR_5++);", "av_strlcpy(scale_args, \"0:0\", sizeof(scale_args));", "if (VAR_0->scale_sws_opts) {", "av_strlcat(scale_args, \":\", sizeof(scale_args));", "av_strlcat(scale_args, VAR_0->scale_sws_opts, sizeof(scale_args));", "}", "if ((VAR_4 = avfilter_graph_create_filter(&convert, filter,\ninst_name, scale_args, NULL,\nVAR_0)) < 0)\nreturn VAR_4;", "break;", "case AVMEDIA_TYPE_AUDIO:\nif (!(filter = avfilter_get_by_name(\"aresample\"))) {", "av_log(VAR_1, AV_LOG_ERROR, \"'aresample' filter \"\n\"not present, cannot convert audio formats.\\n\");", "return AVERROR(EINVAL);", "}", "snprintf(inst_name, sizeof(inst_name), \"auto-inserted resampler %d\",\nVAR_6++);", "scale_args[0] = '\\0';", "if (VAR_0->aresample_swr_opts)\nsnprintf(scale_args, sizeof(scale_args), \"%s\",\nVAR_0->aresample_swr_opts);", "if ((VAR_4 = avfilter_graph_create_filter(&convert, filter,\ninst_name, VAR_0->aresample_swr_opts,\nNULL, VAR_0)) < 0)\nreturn VAR_4;", "break;", "default:\nreturn AVERROR(EINVAL);", "}", "if ((VAR_4 = avfilter_insert_filter(link, convert, 0, 0)) < 0)\nreturn VAR_4;", "filter_query_formats(convert);", "inlink = convert->inputs[0];", "outlink = convert->outputs[0];", "if (!ff_merge_formats( inlink->in_formats, inlink->out_formats, inlink->type) ||\n!ff_merge_formats(outlink->in_formats, outlink->out_formats, outlink->type))\nVAR_4 |= AVERROR(ENOSYS);", "if (inlink->type == AVMEDIA_TYPE_AUDIO &&\n(!ff_merge_samplerates(inlink->in_samplerates,\ninlink->out_samplerates) ||\n!ff_merge_channel_layouts(inlink->in_channel_layouts,\ninlink->out_channel_layouts)))\nVAR_4 |= AVERROR(ENOSYS);", "if (outlink->type == AVMEDIA_TYPE_AUDIO &&\n(!ff_merge_samplerates(outlink->in_samplerates,\noutlink->out_samplerates) ||\n!ff_merge_channel_layouts(outlink->in_channel_layouts,\noutlink->out_channel_layouts)))\nVAR_4 |= AVERROR(ENOSYS);", "if (VAR_4 < 0) {", "av_log(VAR_1, AV_LOG_ERROR,\n\"Impossible to convert between the formats supported by the filter \"\n\"'%s' and the filter '%s'\\n\", link->src->name, link->dst->name);", "return VAR_4;", "}", "}", "}", "}", "av_log(VAR_0, AV_LOG_DEBUG, \"FUNC_0: \"\n\"%d queried, %d merged, %d already done, %d delayed\\n\",\nVAR_7, VAR_8, VAR_9, VAR_10);", "if (VAR_10) {", "AVBPrint bp;", "if (VAR_7 || VAR_8)\nreturn AVERROR(EAGAIN);", "av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);", "for (VAR_2 = 0; VAR_2 < VAR_0->nb_filters; VAR_2++)", "if (!formats_declared(VAR_0->filters[VAR_2]))\nav_bprintf(&bp, \"%s%s\", bp.len ? \", \" : \"\",\nVAR_0->filters[VAR_2]->name);", "av_log(VAR_0, AV_LOG_ERROR,\n\"The following filters could not choose their formats: %s\\n\"\n\"Consider inserting the (a)format filter near their input or \"\n\"output.\\n\", bp.str);", "return AVERROR(EIO);", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9, 11 ], [ 15 ], [ 17 ], [ 19, 21 ], [ 23, 25 ], [ 27, 29 ], [ 31, 33 ], [ 37 ], [ 39 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 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, 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 137 ], [ 139, 141 ], [ 143, 145 ], [ 147 ], [ 149 ], [ 153, 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169, 171, 173 ], [ 175 ], [ 177, 179 ], [ 181, 183 ], [ 185 ], [ 187 ], [ 191, 193 ], [ 195 ], [ 197, 199, 201 ], [ 203, 205, 207, 209 ], [ 211 ], [ 213, 215 ], [ 217 ], [ 221, 223 ], [ 227 ], [ 229 ], [ 231 ], [ 233, 235, 237 ], [ 239, 241, 243, 245, 247, 249 ], [ 251, 253, 255, 257, 259, 261 ], [ 265 ], [ 267, 269, 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 285, 287, 289 ], [ 291 ], [ 293 ], [ 297, 299 ], [ 301 ], [ 303 ], [ 305, 307, 309 ], [ 311, 313, 315, 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ] ]

[ "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[2][VAR_1];", "VAR_2[2][VAR_1] += VAR_2[3][VAR_1];", "}", "memset(VAR_2[3], 0, sizeof(VAR_2[3]));", "}" ]

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

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

[ "static int FUNC_0( H264Context *VAR_0) {", "int VAR_1;", "int VAR_2, VAR_3;", "VAR_2 = (VAR_0->left_cbp>>4)&0x03;", "VAR_3 = (VAR_0-> top_cbp>>4)&0x03;", "VAR_1 = 0;", "if( VAR_2 > 0 ) VAR_1++;", "if( VAR_3 > 0 ) VAR_1 += 2;", "if( get_cabac( &VAR_0->cabac, &VAR_0->cabac_state[77 + VAR_1] ) == 0 )\nreturn 0;", "VAR_1 = 4;", "if( VAR_2 == 2 ) VAR_1++;", "if( VAR_3 == 2 ) VAR_1 += 2;", "return 1 + get_cabac( &VAR_0->cabac, &VAR_0->cabac_state[77 + VAR_1] );", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "MP3Context *mp3 = VAR_0->priv_data;", "if (VAR_1 && VAR_1->data && VAR_1->size >= 4) {", "MPADecodeHeader c;", "int VAR_2 base;", "avpriv_mpegaudio_decode_header(&c, AV_RB32(VAR_1->data));", "if (!mp3->initial_bitrate)\nmp3->initial_bitrate = c.bit_rate;", "if ((c.bit_rate == 0) || (mp3->initial_bitrate != c.bit_rate))\nmp3->has_variable_bitrate = 1;", "#ifdef FILTER_VBR_HEADERS\nbase = 4 + xing_offtbl[c.lsf == 1][c.nb_channels == 1];", "if (base + 4 <= VAR_1->size) {", "uint32_t v = AV_RB32(VAR_1->data + base);", "if (MKBETAG('X','i','n','g') == v || MKBETAG('I','n','f','o') == v)\nreturn 0;", "}", "base = 4 + 32;", "if (base + 4 <= VAR_1->size && MKBETAG('V','B','R','I') == AV_RB32(VAR_1->data + base))\nreturn 0;", "#endif\nif (mp3->xing_offset)\nmp3_xing_add_frame(mp3, VAR_1);", "}", "return ff_raw_write_packet(VAR_0, VAR_1);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 21, 23 ], [ 25, 27 ], [ 31, 35 ], [ 39 ], [ 41 ], [ 45, 47 ], [ 49 ], [ 55 ], [ 59, 61 ], [ 63, 67, 69 ], [ 71 ], [ 75 ], [ 77 ] ]

[ "int FUNC_0(void)\n{", "#ifdef __AMIGAOS4__\nULONG result = 0;", "extern struct ExecIFace *IExec;", "IExec->GetCPUInfoTags(GCIT_VectorUnit, &result, TAG_DONE);", "if (result == VECTORTYPE_ALTIVEC) return 1;", "return 0;", "#else\n#ifdef SYS_DARWIN\nint sels[2] = {CTL_HW, HW_VECTORUNIT};", "int has_vu = 0;", "size_t len = sizeof(has_vu);", "int err;", "err = sysctl(sels, 2, &has_vu, &len, NULL, 0);", "if (err == 0) return (has_vu != 0);", "#else\n{", "signal (SIGILL, sigill_handler);", "if (sigsetjmp (jmpbuf, 1)) {", "signal (SIGILL, SIG_DFL);", "} else {", "canjump = 1;", "asm volatile (\"mtspr 256, %0\\n\\t\"\n\"vand %%v0, %%v0, %%v0\"\n:\n: \"r\" (-1));", "signal (SIGILL, SIG_DFL);", "return 1;", "}", "}", "#endif\nreturn 0;", "#endif\n}" ]

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

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

[ "static int FUNC_0(MpegEncContext *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "AVCodecContext *avctx = VAR_0->avctx;", "Mpeg1Context *s1 = (Mpeg1Context *) VAR_0;", "int VAR_3;", "if (VAR_0->picture_structure == PICT_FRAME)\nVAR_0->first_field = 0;", "else\nVAR_0->first_field ^= 1;", "if (VAR_0->first_field || VAR_0->picture_structure == PICT_FRAME) {", "AVFrameSideData *pan_scan;", "if ((VAR_3 = ff_mpv_frame_start(VAR_0, avctx)) < 0)\nreturn VAR_3;", "ff_mpeg_er_frame_start(VAR_0);", "VAR_0->current_picture_ptr->f->repeat_pict = 0;", "if (VAR_0->repeat_first_field) {", "if (VAR_0->progressive_sequence) {", "if (VAR_0->top_field_first)\nVAR_0->current_picture_ptr->f->repeat_pict = 4;", "else\nVAR_0->current_picture_ptr->f->repeat_pict = 2;", "} else if (VAR_0->progressive_frame) {", "VAR_0->current_picture_ptr->f->repeat_pict = 1;", "}", "}", "pan_scan = av_frame_new_side_data(VAR_0->current_picture_ptr->f,\nAV_FRAME_DATA_PANSCAN,\nsizeof(s1->pan_scan));", "if (!pan_scan)\nreturn AVERROR(ENOMEM);", "memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));", "if (s1->a53_caption) {", "AVFrameSideData *sd = av_frame_new_side_data(\nVAR_0->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,\ns1->a53_caption_size);", "if (sd)\nmemcpy(sd->data, s1->a53_caption, s1->a53_caption_size);", "av_freep(&s1->a53_caption);", "}", "if (s1->has_stereo3d) {", "AVStereo3D *stereo = av_stereo3d_create_side_data(VAR_0->current_picture_ptr->f);", "if (!stereo)\nreturn AVERROR(ENOMEM);", "*stereo = s1->stereo3d;", "s1->has_stereo3d = 0;", "}", "if (s1->has_afd) {", "AVFrameSideData *sd =\nav_frame_new_side_data(VAR_0->current_picture_ptr->f,\nAV_FRAME_DATA_AFD, 1);", "if (!sd)\nreturn AVERROR(ENOMEM);", "*sd->data = s1->afd;", "s1->has_afd = 0;", "}", "if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))\nff_thread_finish_setup(avctx);", "} else {", "int VAR_4;", "if (!VAR_0->current_picture_ptr) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"first field missing\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_0->avctx->hwaccel &&\n(VAR_0->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {", "if (VAR_0->avctx->hwaccel->end_frame(VAR_0->avctx) < 0)\nav_log(avctx, AV_LOG_ERROR,\n\"hardware accelerator failed to decode first field\\n\");", "}", "for (VAR_4 = 0; VAR_4 < 4; VAR_4++) {", "VAR_0->current_picture.f->data[VAR_4] = VAR_0->current_picture_ptr->f->data[VAR_4];", "if (VAR_0->picture_structure == PICT_BOTTOM_FIELD)\nVAR_0->current_picture.f->data[VAR_4] +=\nVAR_0->current_picture_ptr->f->linesize[VAR_4];", "}", "}", "if (avctx->hwaccel) {", "if ((VAR_3 = avctx->hwaccel->start_frame(avctx, VAR_1, VAR_2)) < 0)\nreturn VAR_3;", "}", "#if FF_API_XVMC\nFF_DISABLE_DEPRECATION_WARNINGS\nif (CONFIG_MPEG_XVMC_DECODER && VAR_0->avctx->xvmc_acceleration)\nif (ff_xvmc_field_start(VAR_0, avctx) < 0)\nreturn -1;", "FF_ENABLE_DEPRECATION_WARNINGS\n#endif\nreturn 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13, 15 ], [ 17, 19 ], [ 25 ], [ 27 ], [ 31, 33 ], [ 37 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67, 69, 71 ], [ 73, 75 ], [ 77 ], [ 81 ], [ 83, 85, 87 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119, 121, 123 ], [ 125, 127 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159, 161 ], [ 163, 165, 167 ], [ 169 ], [ 173 ], [ 175 ], [ 177, 179, 181 ], [ 183 ], [ 185 ], [ 189 ], [ 191, 193 ], [ 195 ], [ 199, 201, 207, 209, 211 ], [ 213, 215, 219 ], [ 221 ] ]

[ "static inline int FUNC_0(int VAR_0, int VAR_1)\n{", "int VAR_2 = VAR_0;", "asm (\"bound.w\\t%1, %0\\n\" : \"+VAR_2\" (VAR_2) : \"ri\" (VAR_1));", "return VAR_2;", "}" ]

[ 1, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(MpegEncContext *VAR_0)\n{", "VAR_0->full_pel[0] = VAR_0->full_pel[1] = 0;", "VAR_0->mpeg_f_code[0][0] = get_bits(&VAR_0->gb, 4);", "VAR_0->mpeg_f_code[0][1] = get_bits(&VAR_0->gb, 4);", "VAR_0->mpeg_f_code[1][0] = get_bits(&VAR_0->gb, 4);", "VAR_0->mpeg_f_code[1][1] = get_bits(&VAR_0->gb, 4);", "VAR_0->intra_dc_precision = get_bits(&VAR_0->gb, 2);", "VAR_0->picture_structure = get_bits(&VAR_0->gb, 2);", "VAR_0->top_field_first = get_bits1(&VAR_0->gb);", "VAR_0->frame_pred_frame_dct = get_bits1(&VAR_0->gb);", "VAR_0->concealment_motion_vectors = get_bits1(&VAR_0->gb);", "VAR_0->q_scale_type = get_bits1(&VAR_0->gb);", "VAR_0->intra_vlc_format = get_bits1(&VAR_0->gb);", "VAR_0->alternate_scan = get_bits1(&VAR_0->gb);", "VAR_0->repeat_first_field = get_bits1(&VAR_0->gb);", "VAR_0->chroma_420_type = get_bits1(&VAR_0->gb);", "VAR_0->progressive_frame = get_bits1(&VAR_0->gb);", "dprintf(\"intra_dc_precion=%d\\n\", VAR_0->intra_dc_precision);", "dprintf(\"picture_structure=%d\\n\", VAR_0->picture_structure);", "dprintf(\"conceal=%d\\n\", VAR_0->concealment_motion_vectors);", "dprintf(\"intra_vlc_format=%d\\n\", VAR_0->intra_vlc_format);", "dprintf(\"alternate_scan=%d\\n\", VAR_0->alternate_scan);", "dprintf(\"frame_pred_frame_dct=%d\\n\", VAR_0->frame_pred_frame_dct);", "}" ]

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

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

[ "static int FUNC_0(XenIOState *VAR_0,\nhwaddr VAR_1,\nram_addr_t VAR_2)\n{", "unsigned long VAR_3 = 0;", "int VAR_4 = 0;", "XenPhysmap *physmap = NULL;", "hwaddr phys_offset = 0;", "physmap = get_physmapping(VAR_0, VAR_1, VAR_2);", "if (physmap == NULL) {", "return -1;", "}", "phys_offset = physmap->phys_offset;", "VAR_2 = physmap->VAR_2;", "DPRINTF(\"unmapping vram to %\"HWADDR_PRIx\" - %\"HWADDR_PRIx\", from \",\n\"%\"HWADDR_PRIx\"\\n\", phys_offset, phys_offset + VAR_2, VAR_1);", "VAR_2 >>= TARGET_PAGE_BITS;", "VAR_1 >>= TARGET_PAGE_BITS;", "phys_offset >>= TARGET_PAGE_BITS;", "for (VAR_3 = 0; VAR_3 < VAR_2; VAR_3++) {", "unsigned long idx = VAR_1 + VAR_3;", "xen_pfn_t gpfn = phys_offset + VAR_3;", "VAR_4 = xc_domain_add_to_physmap(xen_xc, xen_domid, XENMAPSPACE_gmfn, idx, gpfn);", "if (VAR_4) {", "fprintf(stderr, \"add_to_physmap MFN %\"PRI_xen_pfn\" to PFN %\"\nPRI_xen_pfn\" failed: %d\\n\", idx, gpfn, VAR_4);", "return -VAR_4;", "}", "}", "QLIST_REMOVE(physmap, list);", "if (VAR_0->log_for_dirtybit == physmap) {", "VAR_0->log_for_dirtybit = NULL;", "}", "free(physmap);", "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, 0, 0 ]

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

[ "static int FUNC_0(AVProbeData *VAR_0)\n{", "uint32_t code= -1;", "int VAR_1=0, VAR_2=0, VAR_3=0, VAR_4=0, VAR_5=0, VAR_6=0, VAR_7=0, VAR_8=0;", "int VAR_9;", "uint32_t last = 0;", "for(VAR_9=0; VAR_9<VAR_0->buf_size; VAR_9++){", "code = (code<<8) + VAR_0->buf[VAR_9];", "if ((code & 0xffffff00) == 0x100) {", "switch(code){", "case SEQ_START_CODE: VAR_2++; break;", "case PICTURE_START_CODE: VAR_1++; break;", "case PACK_START_CODE: VAR_4++; break;", "case 0x1b6:\nVAR_7++; break;", "}", "if (code >= SLICE_START_CODE && code <= 0x1af) {", "if (last >= SLICE_START_CODE && last <= 0x1af) {", "if (code >= last) VAR_3++;", "else VAR_8++;", "}else{", "if (code == SLICE_START_CODE) VAR_3++;", "else VAR_8++;", "}", "}", "if ((code & 0x1f0) == VIDEO_ID) VAR_5++;", "else if((code & 0x1e0) == AUDIO_ID) VAR_6++;", "last = code;", "}", "}", "if(VAR_2 && VAR_2*9<=VAR_1*10 && VAR_1*9<=VAR_3*10 && !VAR_4 && !VAR_6 && !VAR_7 && VAR_3 > VAR_8) {", "if(VAR_5) return AVPROBE_SCORE_EXTENSION / 4;", "else return VAR_1>1 ? AVPROBE_SCORE_EXTENSION + 1 : AVPROBE_SCORE_EXTENSION / 2;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(OHCIState *VAR_0, DeviceState *VAR_1,\nint VAR_2, dma_addr_t VAR_3,\nchar *VAR_4, uint32_t VAR_5,\nAddressSpace *VAR_6, Error **VAR_7)\n{", "Error *err = NULL;", "int VAR_8;", "VAR_0->VAR_6 = VAR_6;", "if (usb_frame_time == 0) {", "#ifdef OHCI_TIME_WARP\nusb_frame_time = NANOSECONDS_PER_SECOND;", "usb_bit_time = NANOSECONDS_PER_SECOND / (USB_HZ / 1000);", "#else\nusb_frame_time = NANOSECONDS_PER_SECOND / 1000;", "if (NANOSECONDS_PER_SECOND >= USB_HZ) {", "usb_bit_time = NANOSECONDS_PER_SECOND / USB_HZ;", "} else {", "usb_bit_time = 1;", "#endif\ntrace_usb_ohci_init_time(usb_frame_time, usb_bit_time);", "VAR_0->VAR_2 = VAR_2;", "if (VAR_4) {", "USBPort *ports[OHCI_MAX_PORTS];", "for(VAR_8 = 0; VAR_8 < VAR_2; VAR_8++) {", "ports[VAR_8] = &VAR_0->rhport[VAR_8].port;", "usb_register_companion(VAR_4, ports, VAR_2,\nVAR_5, VAR_0, &ohci_port_ops,\nUSB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL,\n&err);", "if (err) {", "error_propagate(VAR_7, err);", "} else {", "usb_bus_new(&VAR_0->bus, sizeof(VAR_0->bus), &ohci_bus_ops, VAR_1);", "for (VAR_8 = 0; VAR_8 < VAR_2; VAR_8++) {", "usb_register_port(&VAR_0->bus, &VAR_0->rhport[VAR_8].port,\nVAR_0, VAR_8, &ohci_port_ops,\nUSB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);", "memory_region_init_io(&VAR_0->mem, OBJECT(VAR_1), &ohci_mem_ops,\nVAR_0, \"VAR_0\", 256);", "VAR_0->VAR_3 = VAR_3;", "VAR_0->name = object_get_typename(OBJECT(VAR_1));", "usb_packet_init(&VAR_0->usb_packet);", "VAR_0->async_td = 0;", "VAR_0->eof_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,\nohci_frame_boundary, VAR_0);" ]

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

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "dc->realize = isabus_fdc_realize;", "dc->fw_name = \"fdc\";", "dc->no_user = 1;", "dc->reset = fdctrl_external_reset_isa;", "dc->vmsd = &vmstate_isa_fdc;", "dc->props = isa_fdc_properties;", "set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);", "}" ]

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

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

[ "static int64_t FUNC_0(Monitor *mon)\n{", "int64_t n;", "char *VAR_0;", "int VAR_1;", "switch(*pch) {", "case '+':\nnext();", "n = FUNC_0(mon);", "break;", "case '-':\nnext();", "n = -FUNC_0(mon);", "break;", "case '~':\nnext();", "n = ~FUNC_0(mon);", "break;", "case '(':\nnext();", "n = expr_sum(mon);", "if (*pch != ')') {", "expr_error(mon, \"')' expected\");", "}", "next();", "break;", "case '\\'':\npch++;", "if (*pch == '\\0')\nexpr_error(mon, \"character constant expected\");", "n = *pch;", "pch++;", "if (*pch != '\\'')\nexpr_error(mon, \"missing terminating \\' character\");", "next();", "break;", "case '$':\n{", "char VAR_2[128], *VAR_3;", "target_long reg=0;", "pch++;", "VAR_3 = VAR_2;", "while ((*pch >= 'a' && *pch <= 'z') ||\n(*pch >= 'A' && *pch <= 'Z') ||\n(*pch >= '0' && *pch <= '9') ||\n*pch == '_' || *pch == '.') {", "if ((VAR_3 - VAR_2) < sizeof(VAR_2) - 1)\n*VAR_3++ = *pch;", "pch++;", "}", "while (qemu_isspace(*pch))\npch++;", "*VAR_3 = 0;", "VAR_1 = get_monitor_def(&reg, VAR_2);", "if (VAR_1 < 0)\nexpr_error(mon, \"unknown register\");", "n = reg;", "}", "break;", "case '\\0':\nexpr_error(mon, \"unexpected end of expression\");", "n = 0;", "break;", "default:\nerrno = 0;", "n = strtoull(pch, &VAR_0, 0);", "if (errno == ERANGE) {", "expr_error(mon, \"number too large\");", "}", "if (pch == VAR_0) {", "expr_error(mon, \"invalid char in expression\");", "}", "pch = VAR_0;", "while (qemu_isspace(*pch))\npch++;", "break;", "}", "return n;", "}" ]

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

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

[ "FUNC_0(void *VAR_0, target_phys_addr_t VAR_1, uint32_t VAR_2)\n{", "mst_irq_state *s = (mst_irq_state *) VAR_0;", "VAR_2 &= 0xffffffff;", "switch (VAR_1) {", "case MST_LEDDAT1:\ns->leddat1 = VAR_2;", "break;", "case MST_LEDDAT2:\ns->leddat2 = VAR_2;", "break;", "case MST_LEDCTRL:\ns->ledctrl = VAR_2;", "break;", "case MST_GPSWR:\ns->gpswr = VAR_2;", "break;", "case MST_MSCWR1:\ns->mscwr1 = VAR_2;", "break;", "case MST_MSCWR2:\ns->mscwr2 = VAR_2;", "break;", "case MST_MSCWR3:\ns->mscwr3 = VAR_2;", "break;", "case MST_MSCRD:\ns->mscrd = VAR_2;", "break;", "case MST_INTMSKENA:\ns->intmskena = (VAR_2 & 0xFEEFF);", "qemu_set_irq(s->parent, s->intsetclr & s->intmskena);", "break;", "case MST_INTSETCLR:\ns->intsetclr = (VAR_2 & 0xFEEFF);", "qemu_set_irq(s->parent, s->intsetclr & s->intmskena);", "break;", "case MST_PCMCIA0:\ns->pcmcia0 = (VAR_2 & 0x1f) | (s->pcmcia0 & ~0x1f);", "break;", "case MST_PCMCIA1:\ns->pcmcia1 = (VAR_2 & 0x1f) | (s->pcmcia1 & ~0x1f);", "break;", "default:\nprintf(\"Mainstone - FUNC_0: Bad register offset \"\n\"0x\" TARGET_FMT_plx \" \\n\", VAR_1);", "}", "}" ]

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

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

[ "static int FUNC_0(int VAR_0){", "if(VAR_0<60*12) return VAR_0*1001;", "else return ((const int[]){24,30,60,12,15,48})[VAR_0-60*12]*1000*12;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "void FUNC_0(Jpeg2000Component *VAR_0, Jpeg2000CodingStyle *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4;", "for (VAR_2 = 0;", "VAR_0->reslevel && VAR_2 < VAR_1->nreslevels;", "VAR_2++) {", "Jpeg2000ResLevel *reslevel = VAR_0->reslevel + VAR_2;", "for (VAR_3 = 0; VAR_3 < reslevel->nbands; VAR_3++) {", "Jpeg2000Band *band = reslevel->band + VAR_3;", "for (VAR_4 = 0; VAR_4 < reslevel->num_precincts_x * reslevel->num_precincts_y; VAR_4++) {", "Jpeg2000Prec *prec = band->prec + VAR_4;", "av_freep(&prec->zerobits);", "av_freep(&prec->cblkincl);", "av_freep(&prec->cblk);", "}", "av_freep(&band->prec);", "}", "av_freep(&reslevel->band);", "}", "ff_dwt_destroy(&VAR_0->dwt);", "av_freep(&VAR_0->reslevel);", "av_freep(&VAR_0->i_data);", "av_freep(&VAR_0->f_data);", "}" ]

[ 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 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ] ]

[ "static void FUNC_0(int VAR_0, const char **VAR_1)\n{", "vm_start();", "}" ]

[ 0, 0, 0 ]

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

[ "static inline void FUNC_0(TCGv VAR_0, int VAR_1)\n{", "if (VAR_1 > sizeof(CPUCRISState)) {", "fprintf(stderr, \"wrong load from env from off=%d\\n\", VAR_1);", "}", "tcg_gen_ld_tl(VAR_0, cpu_env, VAR_1);", "}" ]

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

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

[ "static const char *FUNC_0(const BlockDriverState *VAR_0)\n{", "BdrvChild *c;", "const char *VAR_1;", "QLIST_FOREACH(c, &VAR_0->parents, next_parent) {", "if (c->role->get_name) {", "VAR_1 = c->role->get_name(c);", "if (VAR_1 && *VAR_1) {", "return VAR_1;", "}", "}", "}", "return NULL;", "}" ]

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

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