Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static int FUNC_0(void *VAR_0)\n{", "OHCIState *ohci = VAR_0;", "ohci_bus_start(ohci);", "return 0;", "}" ]

[ 1, 1, 1, 1, 0 ]

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

[ "FUNC_0(envlist_t *VAR_0)\n{", "struct envlist_entry *VAR_1;", "assert(VAR_0 != NULL);", "while (VAR_0->el_entries.lh_first != NULL) {", "VAR_1 = VAR_0->el_entries.lh_first;", "QLIST_REMOVE(VAR_1, ev_link);", "free((char *)VAR_1->ev_var);", "free(VAR_1);", "}", "free(VAR_0);", "}" ]

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

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

[ "static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{", "int64_t expect1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20 };", "int64_t expect2[] = { 32767, -32768, -32767 };", "int64_t expect3[] = { INT64_MAX, INT64_MIN };", "uint64_t expect4[] = { UINT64_MAX };", "Error *err = NULL;", "int64List *res = NULL;", "int64List *tail;", "Visitor *v;", "int64_t val;", "v = visitor_input_test_init(VAR_0, \"1,2,0,2-4,20,5-9,1-8\");", "check_ilist(v, expect1, ARRAY_SIZE(expect1));", "v = visitor_input_test_init(VAR_0, \"32767,-32768--32767\");", "check_ilist(v, expect2, ARRAY_SIZE(expect2));", "v = visitor_input_test_init(VAR_0,\n\"-9223372036854775808,9223372036854775807\");", "check_ilist(v, expect3, ARRAY_SIZE(expect3));", "v = visitor_input_test_init(VAR_0, \"18446744073709551615\");", "check_ulist(v, expect4, ARRAY_SIZE(expect4));", "v = visitor_input_test_init(VAR_0, \"\");", "visit_type_int64List(v, NULL, &res, &err);", "error_free_or_abort(&err);", "v = visitor_input_test_init(VAR_0, \"not an int list\");", "visit_type_int64List(v, NULL, &res, &err);", "error_free_or_abort(&err);", "g_assert(!res);", "v = visitor_input_test_init(VAR_0, \"0,2-3\");", "visit_type_int64(v, NULL, &tail->value, &error_abort);", "tail = (int64List *)visit_next_list(v, (GenericList *)tail, sizeof(*res));", "g_assert(tail);", "visit_type_int64(v, NULL, &tail->value, &error_abort);", "g_assert_cmpint(tail->value, ==, 2);", "tail = (int64List *)visit_next_list(v, (GenericList *)tail, sizeof(*res));", "g_assert(tail);", "visit_check_list(v, &err);", "error_free_or_abort(&err);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19, 20 ], [ 21 ], [ 22 ], [ 23 ], [ 25 ], [ 26 ], [ 27 ], [ 29 ], [ 30 ], [ 31 ], [ 32 ], [ 34 ], [ 36 ], [ 37 ], [ 38 ], [ 39 ], [ 40 ], [ 41 ], [ 42 ], [ 43 ], [ 44 ], [ 45 ] ]

[ "static void FUNC_0(QEMUFile *VAR_0, void *VAR_1, size_t VAR_2)\n{", "static const uint8_t VAR_3[1024];", "int VAR_4;", "while (VAR_2 > 0) {", "VAR_4 = MIN(sizeof(VAR_3), VAR_2);", "VAR_2 -= VAR_4;", "qemu_put_buffer(VAR_0, VAR_3, VAR_4);", "}", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0, const char *VAR_1)\n{", "BDRVQcowState *s = VAR_0->opaque;", "int VAR_2;", "for(VAR_2 = 0; VAR_2 < s->nb_snapshots; VAR_2++) {", "if (!strcmp(s->snapshots[VAR_2].VAR_1, VAR_1))\nreturn VAR_2;", "}", "return -1;", "}" ]

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

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

[ "static inline void FUNC_0(struct vmsvga_state_s *VAR_0,\nint VAR_1, int VAR_2, int VAR_3, int VAR_4)\n{", "DisplaySurface *surface = qemu_console_surface(VAR_0->vga.con);", "int VAR_5;", "int VAR_6;", "int VAR_7;", "int VAR_8;", "uint8_t *src;", "uint8_t *dst;", "if (VAR_1 < 0) {", "fprintf(stderr, \"%VAR_0: update VAR_1 was < 0 (%d)\\n\", __func__, VAR_1);", "VAR_3 += VAR_1;", "VAR_1 = 0;", "}", "if (VAR_3 < 0) {", "fprintf(stderr, \"%VAR_0: update VAR_3 was < 0 (%d)\\n\", __func__, VAR_3);", "VAR_3 = 0;", "}", "if (VAR_1 + VAR_3 > surface_width(surface)) {", "fprintf(stderr, \"%VAR_0: update VAR_7 too large VAR_1: %d, VAR_3: %d\\n\",\n__func__, VAR_1, VAR_3);", "VAR_1 = MIN(VAR_1, surface_width(surface));", "VAR_3 = surface_width(surface) - VAR_1;", "}", "if (VAR_2 < 0) {", "fprintf(stderr, \"%VAR_0: update VAR_2 was < 0 (%d)\\n\", __func__, VAR_2);", "VAR_4 += VAR_2;", "VAR_2 = 0;", "}", "if (VAR_4 < 0) {", "fprintf(stderr, \"%VAR_0: update VAR_4 was < 0 (%d)\\n\", __func__, VAR_4);", "VAR_4 = 0;", "}", "if (VAR_2 + VAR_4 > surface_height(surface)) {", "fprintf(stderr, \"%VAR_0: update height too large VAR_2: %d, VAR_4: %d\\n\",\n__func__, VAR_2, VAR_4);", "VAR_2 = MIN(VAR_2, surface_height(surface));", "VAR_4 = surface_height(surface) - VAR_2;", "}", "VAR_6 = surface_stride(surface);", "VAR_7 = surface_bytes_per_pixel(surface) * VAR_3;", "VAR_8 = surface_bytes_per_pixel(surface) * VAR_1 + VAR_6 * VAR_2;", "src = VAR_0->vga.vram_ptr + VAR_8;", "dst = surface_data(surface) + VAR_8;", "for (VAR_5 = VAR_4; VAR_5 > 0; VAR_5--, src += VAR_6, dst += VAR_6) {", "memcpy(dst, src, VAR_7);", "}", "dpy_gfx_update(VAR_0->vga.con, VAR_1, VAR_2, VAR_3, VAR_4);", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, int64_t VAR_1)\n{", "MatroskaDemuxContext *matroska = VAR_0->priv_data;", "EbmlList *seekhead_list = &matroska->seekhead;", "MatroskaSeekhead *seekhead = seekhead_list->elem;", "char *VAR_2;", "int64_t cues_start = -1, cues_end = -1, before_pos, bandwidth;", "int VAR_3;", "int VAR_4 = 0;", "for (VAR_3 = 0; VAR_3 < seekhead_list->nb_elem; VAR_3++)", "if (seekhead[VAR_3].id == MATROSKA_ID_CUES)\nbreak;", "if (VAR_3 >= seekhead_list->nb_elem) return -1;", "before_pos = avio_tell(matroska->ctx->pb);", "cues_start = seekhead[VAR_3].pos + matroska->segment_start;", "if (avio_seek(matroska->ctx->pb, cues_start, SEEK_SET) == cues_start) {", "uint64_t cues_length = 0, cues_id = 0, bytes_read = 0;", "bytes_read += ebml_read_num(matroska, matroska->ctx->pb, 4, &cues_id);", "bytes_read += ebml_read_length(matroska, matroska->ctx->pb, &cues_length);", "cues_end = cues_start + cues_length + bytes_read - 1;", "}", "avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);", "if (cues_start == -1 || cues_end == -1) return -1;", "matroska_parse_cues(matroska);", "av_dict_set_int(&VAR_0->streams[0]->metadata, CUES_START, cues_start, 0);", "av_dict_set_int(&VAR_0->streams[0]->metadata, CUES_END, cues_end, 0);", "if (cues_start <= VAR_1)\nav_dict_set_int(&VAR_0->streams[0]->metadata, INITIALIZATION_RANGE, cues_start - 1, 0);", "bandwidth = webm_dash_manifest_compute_bandwidth(VAR_0, cues_start);", "if (bandwidth < 0) return -1;", "av_dict_set_int(&VAR_0->streams[0]->metadata, BANDWIDTH, bandwidth, 0);", "av_dict_set_int(&VAR_0->streams[0]->metadata, CLUSTER_KEYFRAME, webm_clusters_start_with_keyframe(VAR_0), 0);", "VAR_2 = av_malloc_array(VAR_0->streams[0]->nb_index_entries, 20 * sizeof(char));", "if (!VAR_2) return -1;", "strcpy(VAR_2, \"\");", "for (VAR_3 = 0; VAR_3 < VAR_0->streams[0]->nb_index_entries; VAR_3++) {", "int ret = snprintf(VAR_2 + VAR_4, 20 * sizeof(char),\n\"%\" PRId64, VAR_0->streams[0]->index_entries[VAR_3].timestamp);", "if (ret <= 0 || (ret == 20 && VAR_3 == VAR_0->streams[0]->nb_index_entries - 1)) {", "av_log(VAR_0, AV_LOG_ERROR, \"timestamp too long.\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_4 += ret;", "if (VAR_3 != VAR_0->streams[0]->nb_index_entries - 1) {", "strncat(VAR_2, \",\", sizeof(char));", "VAR_4++;", "}", "}", "av_dict_set(&VAR_0->streams[0]->metadata, CUE_TIMESTAMPS, VAR_2, 0);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 23 ], [ 25, 27 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 65 ], [ 71 ], [ 77 ], [ 85, 87 ], [ 93 ], [ 95 ], [ 97 ], [ 103 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 128 ], [ 130 ], [ 132 ], [ 134 ], [ 136 ], [ 138 ], [ 140 ], [ 142 ], [ 144 ], [ 149 ], [ 151 ] ]

[ "int FUNC_0(AVAudioResampleContext *VAR_0, void **VAR_1,\nint VAR_2, int VAR_3, void **VAR_4,\nint VAR_5, int VAR_6)\n{", "AudioData input_buffer;", "AudioData output_buffer;", "AudioData *current_buffer;", "int VAR_7;", "if (VAR_0->in_buffer) {", "VAR_0->in_buffer->nb_samples = 0;", "ff_audio_data_set_channels(VAR_0->in_buffer,\nVAR_0->in_buffer->allocated_channels);", "}", "if (VAR_0->resample_out_buffer) {", "VAR_0->resample_out_buffer->nb_samples = 0;", "ff_audio_data_set_channels(VAR_0->resample_out_buffer,\nVAR_0->resample_out_buffer->allocated_channels);", "}", "if (VAR_0->out_buffer) {", "VAR_0->out_buffer->nb_samples = 0;", "ff_audio_data_set_channels(VAR_0->out_buffer,\nVAR_0->out_buffer->allocated_channels);", "}", "av_dlog(VAR_0, \"[start conversion]\\n\");", "if (VAR_1) {", "VAR_7 = ff_audio_data_init(&output_buffer, VAR_1, VAR_2,\nVAR_0->out_channels, VAR_3,\nVAR_0->out_sample_fmt, 0, \"VAR_1\");", "if (VAR_7 < 0)\nreturn VAR_7;", "output_buffer.nb_samples = 0;", "}", "if (VAR_4) {", "VAR_7 = ff_audio_data_init(&input_buffer, VAR_4, VAR_5,\nVAR_0->in_channels, VAR_6,\nVAR_0->in_sample_fmt, 1, \"VAR_4\");", "if (VAR_7 < 0)\nreturn VAR_7;", "current_buffer = &input_buffer;", "if (VAR_0->upmix_needed && !VAR_0->in_convert_needed && !VAR_0->resample_needed &&\n!VAR_0->out_convert_needed && VAR_1 && VAR_3 >= VAR_6) {", "av_dlog(VAR_0, \"[copy] %s to VAR_1\\n\", current_buffer->name);", "VAR_7 = ff_audio_data_copy(&output_buffer, current_buffer);", "if (VAR_7 < 0)\nreturn VAR_7;", "current_buffer = &output_buffer;", "} else if (VAR_0->mixing_needed || VAR_0->in_convert_needed) {", "if (VAR_0->in_convert_needed) {", "VAR_7 = ff_audio_data_realloc(VAR_0->in_buffer,\ncurrent_buffer->nb_samples);", "if (VAR_7 < 0)\nreturn VAR_7;", "av_dlog(VAR_0, \"[convert] %s to in_buffer\\n\", current_buffer->name);", "VAR_7 = ff_audio_convert(VAR_0->ac_in, VAR_0->in_buffer, current_buffer,\ncurrent_buffer->nb_samples);", "if (VAR_7 < 0)\nreturn VAR_7;", "} else {", "av_dlog(VAR_0, \"[copy] %s to in_buffer\\n\", current_buffer->name);", "VAR_7 = ff_audio_data_copy(VAR_0->in_buffer, current_buffer);", "if (VAR_7 < 0)\nreturn VAR_7;", "}", "ff_audio_data_set_channels(VAR_0->in_buffer, VAR_0->in_channels);", "if (VAR_0->downmix_needed) {", "av_dlog(VAR_0, \"[downmix] in_buffer\\n\");", "VAR_7 = ff_audio_mix(VAR_0->am, VAR_0->in_buffer);", "if (VAR_7 < 0)\nreturn VAR_7;", "}", "current_buffer = VAR_0->in_buffer;", "}", "} else {", "if (!VAR_0->resample_needed)\nreturn handle_buffered_output(VAR_0, VAR_1 ? &output_buffer : NULL,\nNULL);", "current_buffer = NULL;", "}", "if (VAR_0->resample_needed) {", "AudioData *resample_out;", "int VAR_8 = 0;", "if (!VAR_0->out_convert_needed && VAR_1 && VAR_3 > 0)\nresample_out = &output_buffer;", "else\nresample_out = VAR_0->resample_out_buffer;", "av_dlog(VAR_0, \"[resample] %s to %s\\n\", current_buffer->name,\nresample_out->name);", "VAR_7 = ff_audio_resample(VAR_0->resample, resample_out,\ncurrent_buffer, &VAR_8);", "if (VAR_7 < 0)\nreturn VAR_7;", "if (resample_out->nb_samples == 0) {", "av_dlog(VAR_0, \"[end conversion]\\n\");", "return 0;", "}", "current_buffer = resample_out;", "}", "if (VAR_0->upmix_needed) {", "av_dlog(VAR_0, \"[upmix] %s\\n\", current_buffer->name);", "VAR_7 = ff_audio_mix(VAR_0->am, current_buffer);", "if (VAR_7 < 0)\nreturn VAR_7;", "}", "if (current_buffer == &output_buffer) {", "av_dlog(VAR_0, \"[end conversion]\\n\");", "return current_buffer->nb_samples;", "}", "if (VAR_0->out_convert_needed) {", "if (VAR_1 && VAR_3 >= current_buffer->nb_samples) {", "av_dlog(VAR_0, \"[convert] %s to VAR_1\\n\", current_buffer->name);", "VAR_7 = ff_audio_convert(VAR_0->ac_out, &output_buffer, current_buffer,\ncurrent_buffer->nb_samples);", "if (VAR_7 < 0)\nreturn VAR_7;", "av_dlog(VAR_0, \"[end conversion]\\n\");", "return output_buffer.nb_samples;", "} else {", "VAR_7 = ff_audio_data_realloc(VAR_0->out_buffer,\ncurrent_buffer->nb_samples);", "if (VAR_7 < 0)\nreturn VAR_7;", "av_dlog(VAR_0, \"[convert] %s to out_buffer\\n\", current_buffer->name);", "VAR_7 = ff_audio_convert(VAR_0->ac_out, VAR_0->out_buffer,\ncurrent_buffer, current_buffer->nb_samples);", "if (VAR_7 < 0)\nreturn VAR_7;", "current_buffer = VAR_0->out_buffer;", "}", "}", "return handle_buffered_output(VAR_0, &output_buffer, current_buffer);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 53 ], [ 59 ], [ 61, 63, 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 77 ], [ 81, 83, 85 ], [ 87, 89 ], [ 91 ], [ 95, 97 ], [ 103 ], [ 105 ], [ 107, 109 ], [ 111 ], [ 113 ], [ 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 ], [ 173, 175, 177 ], [ 179 ], [ 181 ], [ 185 ], [ 187 ], [ 189 ], [ 193, 195 ], [ 197, 199 ], [ 201, 203 ], [ 205, 207 ], [ 209, 211 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 227 ], [ 229 ], [ 233 ], [ 235 ], [ 237 ], [ 239, 241 ], [ 243 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 259 ], [ 261 ], [ 265 ], [ 267, 269 ], [ 271, 273 ], [ 277 ], [ 279 ], [ 281 ], [ 283, 285 ], [ 287, 289 ], [ 291 ], [ 293, 295 ], [ 297, 299 ], [ 301 ], [ 303 ], [ 305 ], [ 309 ], [ 311 ] ]

[ "static ssize_t FUNC_0(VLANClientState *nc, const uint8_t *buf, size_t size_, int do_interrupt)\n{", "RTL8139State *s = DO_UPCAST(NICState, nc, nc)->opaque;", "int VAR_0 = size_;", "const uint8_t *VAR_1 = NULL;", "uint32_t packet_header = 0;", "uint8_t buf1[MIN_BUF_SIZE + VLAN_HLEN];", "static const uint8_t VAR_2[6] =\n{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };", "DEBUG_PRINT((\">>> RTL8139: received len=%d\\n\", VAR_0));", "if (!s->clock_enabled)\n{", "DEBUG_PRINT((\"RTL8139: stopped ==========================\\n\"));", "return -1;", "}", "if (!rtl8139_receiver_enabled(s))\n{", "DEBUG_PRINT((\"RTL8139: receiver disabled ================\\n\"));", "return -1;", "}", "if (s->RxConfig & AcceptAllPhys) {", "DEBUG_PRINT((\">>> RTL8139: packet received in promiscuous mode\\n\"));", "} else {", "if (!memcmp(buf, VAR_2, 6)) {", "if (!(s->RxConfig & AcceptBroadcast))\n{", "DEBUG_PRINT((\">>> RTL8139: broadcast packet rejected\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "packet_header |= RxBroadcast;", "DEBUG_PRINT((\">>> RTL8139: broadcast packet received\\n\"));", "++s->tally_counters.RxOkBrd;", "} else if (buf[0] & 0x01) {", "if (!(s->RxConfig & AcceptMulticast))\n{", "DEBUG_PRINT((\">>> RTL8139: multicast packet rejected\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "int VAR_3 = compute_mcast_idx(buf);", "if (!(s->mult[VAR_3 >> 3] & (1 << (VAR_3 & 7))))\n{", "DEBUG_PRINT((\">>> RTL8139: multicast address mismatch\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "packet_header |= RxMulticast;", "DEBUG_PRINT((\">>> RTL8139: multicast packet received\\n\"));", "++s->tally_counters.RxOkMul;", "} else if (s->phys[0] == buf[0] &&", "s->phys[1] == buf[1] &&\ns->phys[2] == buf[2] &&\ns->phys[3] == buf[3] &&\ns->phys[4] == buf[4] &&\ns->phys[5] == buf[5]) {", "if (!(s->RxConfig & AcceptMyPhys))\n{", "DEBUG_PRINT((\">>> RTL8139: rejecting physical address matching packet\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "packet_header |= RxPhysical;", "DEBUG_PRINT((\">>> RTL8139: physical address matching packet received\\n\"));", "++s->tally_counters.RxOkPhy;", "} else {", "DEBUG_PRINT((\">>> RTL8139: unknown packet\\n\"));", "++s->tally_counters.RxERR;", "return VAR_0;", "}", "}", "if (VAR_0 < MIN_BUF_SIZE + VLAN_HLEN) {", "memcpy(buf1, buf, VAR_0);", "memset(buf1 + VAR_0, 0, MIN_BUF_SIZE + VLAN_HLEN - VAR_0);", "buf = buf1;", "if (VAR_0 < MIN_BUF_SIZE) {", "VAR_0 = MIN_BUF_SIZE;", "}", "}", "if (rtl8139_cp_receiver_enabled(s))\n{", "DEBUG_PRINT((\"RTL8139: in C+ Rx mode ================\\n\"));", "#define CP_RX_OWN (1<<31)\n#define CP_RX_EOR (1<<30)\n#define CP_RX_BUFFER_SIZE_MASK ((1<<13) - 1)\n#define CP_RX_TAVA (1<<16)\n#define CP_RX_VLAN_TAG_MASK ((1<<16) - 1)\nint VAR_4 = s->currCPlusRxDesc;", "target_phys_addr_t cplus_rx_ring_desc;", "cplus_rx_ring_desc = rtl8139_addr64(s->RxRingAddrLO, s->RxRingAddrHI);", "cplus_rx_ring_desc += 16 * VAR_4;", "DEBUG_PRINT((\"RTL8139: +++ C+ mode reading RX VAR_4 %d from host memory at %08x %08x = %016\" PRIx64 \"\\n\",\nVAR_4, s->RxRingAddrHI, s->RxRingAddrLO, (uint64_t)cplus_rx_ring_desc));", "uint32_t val, rxdw0,rxdw1,rxbufLO,rxbufHI;", "cpu_physical_memory_read(cplus_rx_ring_desc, (uint8_t *)&val, 4);", "rxdw0 = le32_to_cpu(val);", "cpu_physical_memory_read(cplus_rx_ring_desc+4, (uint8_t *)&val, 4);", "rxdw1 = le32_to_cpu(val);", "cpu_physical_memory_read(cplus_rx_ring_desc+8, (uint8_t *)&val, 4);", "rxbufLO = le32_to_cpu(val);", "cpu_physical_memory_read(cplus_rx_ring_desc+12, (uint8_t *)&val, 4);", "rxbufHI = le32_to_cpu(val);", "DEBUG_PRINT((\"RTL8139: +++ C+ mode RX VAR_4 %d %08x %08x %08x %08x\\n\",\nVAR_4,\nrxdw0, rxdw1, rxbufLO, rxbufHI));", "if (!(rxdw0 & CP_RX_OWN))\n{", "DEBUG_PRINT((\"RTL8139: C+ Rx mode : VAR_4 %d is owned by host\\n\", VAR_4));", "s->IntrStatus |= RxOverflow;", "++s->RxMissed;", "++s->tally_counters.RxERR;", "++s->tally_counters.MissPkt;", "rtl8139_update_irq(s);", "return size_;", "}", "uint32_t rx_space = rxdw0 & CP_RX_BUFFER_SIZE_MASK;", "if (s->CpCmd & CPlusRxVLAN && be16_to_cpup((uint16_t *)\n&buf[ETHER_ADDR_LEN * 2]) == ETH_P_8021Q) {", "VAR_1 = &buf[ETHER_ADDR_LEN * 2];", "VAR_0 -= VLAN_HLEN;", "if (VAR_0 < MIN_BUF_SIZE) {", "VAR_0 = MIN_BUF_SIZE;", "}", "rxdw1 &= ~CP_RX_VLAN_TAG_MASK;", "rxdw1 |= CP_RX_TAVA | le16_to_cpup((uint16_t *)\n&VAR_1[ETHER_TYPE_LEN]);", "DEBUG_PRINT((\"RTL8139: C+ Rx mode : extracted vlan tag with tci: \"\n\"%u\\n\", be16_to_cpup((uint16_t *)\n&VAR_1[ETHER_TYPE_LEN])));", "} else {", "rxdw1 &= ~CP_RX_TAVA;", "}", "if (VAR_0+4 > rx_space)\n{", "DEBUG_PRINT((\"RTL8139: C+ Rx mode : VAR_4 %d VAR_0 %d received %d + 4\\n\",\nVAR_4, rx_space, VAR_0));", "s->IntrStatus |= RxOverflow;", "++s->RxMissed;", "++s->tally_counters.RxERR;", "++s->tally_counters.MissPkt;", "rtl8139_update_irq(s);", "return size_;", "}", "target_phys_addr_t rx_addr = rtl8139_addr64(rxbufLO, rxbufHI);", "if (VAR_1) {", "cpu_physical_memory_write(rx_addr, buf, 2 * ETHER_ADDR_LEN);", "cpu_physical_memory_write(rx_addr + 2 * ETHER_ADDR_LEN,\nbuf + 2 * ETHER_ADDR_LEN + VLAN_HLEN,\nVAR_0 - 2 * ETHER_ADDR_LEN);", "} else {", "cpu_physical_memory_write(rx_addr, buf, VAR_0);", "}", "if (s->CpCmd & CPlusRxChkSum)\n{", "}", "val = cpu_to_le32(crc32(0, buf, size_));", "cpu_physical_memory_write( rx_addr+VAR_0, (uint8_t *)&val, 4);", "#define CP_RX_STATUS_FS (1<<29)\n#define CP_RX_STATUS_LS (1<<28)\n#define CP_RX_STATUS_MAR (1<<26)\n#define CP_RX_STATUS_PAM (1<<25)\n#define CP_RX_STATUS_BAR (1<<24)\n#define CP_RX_STATUS_RUNT (1<<19)\n#define CP_RX_STATUS_CRC (1<<18)\n#define CP_RX_STATUS_IPF (1<<15)\n#define CP_RX_STATUS_UDPF (1<<14)\n#define CP_RX_STATUS_TCPF (1<<13)\nrxdw0 &= ~CP_RX_OWN;", "rxdw0 |= CP_RX_STATUS_FS;", "rxdw0 |= CP_RX_STATUS_LS;", "if (packet_header & RxBroadcast)\nrxdw0 |= CP_RX_STATUS_BAR;", "if (packet_header & RxMulticast)\nrxdw0 |= CP_RX_STATUS_MAR;", "if (packet_header & RxPhysical)\nrxdw0 |= CP_RX_STATUS_PAM;", "rxdw0 &= ~CP_RX_BUFFER_SIZE_MASK;", "rxdw0 |= (VAR_0+4);", "val = cpu_to_le32(rxdw0);", "cpu_physical_memory_write(cplus_rx_ring_desc, (uint8_t *)&val, 4);", "val = cpu_to_le32(rxdw1);", "cpu_physical_memory_write(cplus_rx_ring_desc+4, (uint8_t *)&val, 4);", "++s->tally_counters.RxOk;", "if (rxdw0 & CP_RX_EOR)\n{", "s->currCPlusRxDesc = 0;", "}", "else\n{", "++s->currCPlusRxDesc;", "}", "DEBUG_PRINT((\"RTL8139: done C+ Rx mode ----------------\\n\"));", "}", "else\n{", "DEBUG_PRINT((\"RTL8139: in ring Rx mode ================\\n\"));", "int VAR_5 = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr, s->RxBufferSize);", "if (VAR_5 != 0 && VAR_0 + 8 >= VAR_5)\n{", "DEBUG_PRINT((\"rx overflow: rx buffer length %d head 0x%04x read 0x%04x === available 0x%04x need 0x%04x\\n\",\ns->RxBufferSize, s->RxBufAddr, s->RxBufPtr, VAR_5, VAR_0 + 8));", "s->IntrStatus |= RxOverflow;", "++s->RxMissed;", "rtl8139_update_irq(s);", "return size_;", "}", "packet_header |= RxStatusOK;", "packet_header |= (((VAR_0+4) << 16) & 0xffff0000);", "uint32_t val = cpu_to_le32(packet_header);", "rtl8139_write_buffer(s, (uint8_t *)&val, 4);", "rtl8139_write_buffer(s, buf, VAR_0);", "val = cpu_to_le32(crc32(0, buf, VAR_0));", "rtl8139_write_buffer(s, (uint8_t *)&val, 4);", "s->RxBufAddr = MOD2((s->RxBufAddr + 3) & ~0x3, s->RxBufferSize);", "DEBUG_PRINT((\" received: rx buffer length %d head 0x%04x read 0x%04x\\n\",\ns->RxBufferSize, s->RxBufAddr, s->RxBufPtr));", "}", "s->IntrStatus |= RxOK;", "if (do_interrupt)\n{", "rtl8139_update_irq(s);", "}", "return 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, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 15 ], [ 19 ], [ 21, 23 ], [ 27 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 63 ], [ 67 ], [ 71 ], [ 73 ], [ 77, 79 ], [ 81 ], [ 87 ], [ 91 ], [ 93 ], [ 97 ], [ 101 ], [ 107 ], [ 111 ], [ 115, 117 ], [ 119 ], [ 125 ], [ 129 ], [ 131 ], [ 135 ], [ 139, 141 ], [ 143 ], [ 149 ], [ 153 ], [ 155 ], [ 159 ], [ 163 ], [ 169 ], [ 173 ], [ 175, 177, 179, 181, 183 ], [ 187, 189 ], [ 191 ], [ 197 ], [ 201 ], [ 203 ], [ 207 ], [ 211 ], [ 217 ], [ 221 ], [ 225 ], [ 231 ], [ 235 ], [ 237 ], [ 239 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 265, 267 ], [ 269 ], [ 279, 283, 287, 291, 295, 303 ], [ 305 ], [ 309 ], [ 311 ], [ 315, 317 ], [ 321 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 343, 345, 347 ], [ 351, 353 ], [ 355 ], [ 359 ], [ 361 ], [ 367 ], [ 369 ], [ 373 ], [ 375 ], [ 377 ], [ 381 ], [ 387, 389 ], [ 391 ], [ 393 ], [ 397 ], [ 399 ], [ 401 ], [ 405 ], [ 409, 411 ], [ 415, 417, 419 ], [ 421 ], [ 425 ], [ 427 ], [ 435, 437 ], [ 439, 441 ], [ 445 ], [ 447 ], [ 453 ], [ 455 ], [ 459 ], [ 461 ], [ 463 ], [ 467 ], [ 473 ], [ 475 ], [ 477, 479, 481 ], [ 483 ], [ 485 ], [ 487 ], [ 491, 493 ], [ 497 ], [ 503 ], [ 505 ], [ 511, 515, 519, 523, 527, 531, 535, 539, 543, 547, 553 ], [ 559 ], [ 565 ], [ 571, 573 ], [ 575, 577 ], [ 579, 581 ], [ 587 ], [ 589 ], [ 595 ], [ 597 ], [ 599 ], [ 601 ], [ 607 ], [ 613, 615 ], [ 617 ], [ 619 ], [ 621, 623 ], [ 625 ], [ 627 ], [ 631 ], [ 635 ], [ 637, 639 ], [ 641 ], [ 647 ], [ 655, 657 ], [ 659, 661 ], [ 665 ], [ 667 ], [ 669 ], [ 671 ], [ 673 ], [ 677 ], [ 681 ], [ 687 ], [ 691 ], [ 695 ], [ 701 ], [ 703 ], [ 709 ], [ 717, 719 ], [ 721 ], [ 725 ], [ 729, 731 ], [ 733 ], [ 735 ], [ 739 ], [ 741 ] ]

[ "static void FUNC_0(MadContext *VAR_0, int VAR_1)\n{", "MpegEncContext *s = &VAR_0->s;", "int VAR_2 = 0;", "int VAR_3, VAR_4;", "int VAR_5;", "if (VAR_1) {", "int VAR_6 = decode210(&s->gb);", "if (VAR_6 < 2) {", "VAR_2 = VAR_6 ? get_bits(&s->gb, 6) : 63;", "VAR_3 = decode_motion(&s->gb);", "VAR_4 = decode_motion(&s->gb);", "} else {", "VAR_2 = 0;", "}", "}", "for (VAR_5=0; VAR_5<6; VAR_5++) {", "if (VAR_2 & (1<<VAR_5)) {", "int VAR_7 = 2*decode_motion(&s->gb);", "comp_block(VAR_0, s->mb_x, s->mb_y, VAR_5, VAR_3, VAR_4, VAR_7);", "} else {", "s->dsp.clear_block(VAR_0->block);", "decode_block_intra(VAR_0, VAR_0->block);", "idct_put(VAR_0, VAR_0->block, s->mb_x, s->mb_y, VAR_5);", "}", "}", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, AVSubtitle *VAR_1, int *VAR_2)\n{", "DVBSubContext *ctx = VAR_0->priv_data;", "DVBSubRegionDisplay *display;", "DVBSubDisplayDefinition *display_def = ctx->display_definition;", "DVBSubRegion *region;", "AVSubtitleRect *rect;", "DVBSubCLUT *clut;", "uint32_t *clut_table;", "int VAR_3;", "int VAR_4=0, VAR_5=0;", "int VAR_6 = 0;", "if (display_def) {", "VAR_4 = display_def->x;", "VAR_5 = display_def->y;", "}", "if(VAR_1->num_rects) {", "avpriv_request_sample(ctx, \"Different Version of Segment asked Twice\");", "return AVERROR_PATCHWELCOME;", "}", "for (display = ctx->display_list; display; display = display->next) {", "region = get_region(ctx, display->region_id);", "if (region && region->dirty)\nVAR_1->num_rects++;", "}", "if(ctx->compute_edt == 0) {", "VAR_1->end_display_time = ctx->time_out * 1000;", "*VAR_2 = 1;", "} else if (ctx->prev_start != AV_NOPTS_VALUE) {", "VAR_1->end_display_time = av_rescale_q((VAR_1->pts - ctx->prev_start ), AV_TIME_BASE_Q, (AVRational){ 1, 1000 }) - 1;", "*VAR_2 = 1;", "}", "if (VAR_1->num_rects > 0) {", "VAR_1->rects = av_mallocz_array(sizeof(*VAR_1->rects), VAR_1->num_rects);", "if (!VAR_1->rects) {", "VAR_6 = AVERROR(ENOMEM);", "goto fail;", "}", "for (VAR_3 = 0; VAR_3 < VAR_1->num_rects; VAR_3++) {", "VAR_1->rects[VAR_3] = av_mallocz(sizeof(*VAR_1->rects[VAR_3]));", "if (!VAR_1->rects[VAR_3]) {", "VAR_6 = AVERROR(ENOMEM);", "goto fail;", "}", "}", "VAR_3 = 0;", "for (display = ctx->display_list; display; display = display->next) {", "region = get_region(ctx, display->region_id);", "if (!region)\ncontinue;", "if (!region->dirty)\ncontinue;", "rect = VAR_1->rects[VAR_3];", "rect->x = display->x_pos + VAR_4;", "rect->y = display->y_pos + VAR_5;", "rect->w = region->width;", "rect->h = region->height;", "rect->nb_colors = (1 << region->depth);", "rect->type = SUBTITLE_BITMAP;", "rect->linesize[0] = region->width;", "clut = get_clut(ctx, region->clut);", "if (!clut)\nclut = &default_clut;", "switch (region->depth) {", "case 2:\nclut_table = clut->clut4;", "break;", "case 8:\nclut_table = clut->clut256;", "break;", "case 4:\ndefault:\nclut_table = clut->clut16;", "break;", "}", "rect->data[1] = av_mallocz(AVPALETTE_SIZE);", "if (!rect->data[1]) {", "VAR_6 = AVERROR(ENOMEM);", "goto fail;", "}", "memcpy(rect->data[1], clut_table, (1 << region->depth) * sizeof(uint32_t));", "rect->data[0] = av_malloc(region->buf_size);", "if (!rect->data[0]) {", "VAR_6 = AVERROR(ENOMEM);", "goto fail;", "}", "memcpy(rect->data[0], region->pbuf, region->buf_size);", "if ((clut == &default_clut && ctx->compute_clut == -1) || ctx->compute_clut == 1)\ncompute_default_clut(rect, rect->w, rect->h);", "#if FF_API_AVPICTURE\nFF_DISABLE_DEPRECATION_WARNINGS\n{", "int j;", "for (j = 0; j < 4; j++) {", "rect->pict.data[j] = rect->data[j];", "rect->pict.linesize[j] = rect->linesize[j];", "}", "}", "FF_ENABLE_DEPRECATION_WARNINGS\n#endif\nVAR_3++;", "}", "}", "return 0;", "fail:\nif (VAR_1->rects) {", "for(VAR_3=0; VAR_3<VAR_1->num_rects; VAR_3++) {", "rect = VAR_1->rects[VAR_3];", "if (rect) {", "av_freep(&rect->data[0]);", "av_freep(&rect->data[1]);", "}", "av_freep(&VAR_1->rects[VAR_3]);", "}", "av_freep(&VAR_1->rects);", "}", "VAR_1->num_rects = 0;", "return VAR_6;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 111 ], [ 113 ], [ 117, 119 ], [ 123, 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 151, 153 ], [ 157 ], [ 159, 161 ], [ 163 ], [ 165, 167 ], [ 169 ], [ 171, 173, 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 209 ], [ 213, 215 ], [ 219, 221, 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237, 239, 243 ], [ 245 ], [ 247 ], [ 251 ], [ 253, 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ] ]

[ "static bool FUNC_0(arm_sysctl_state *s, unsigned int dcc,\nunsigned int function, unsigned int site,\nunsigned int position, unsigned int device,\nuint32_t *val)\n{", "if (dcc != 0 || position != 0 ||\n(site != SYS_CFG_SITE_MB && site != SYS_CFG_SITE_DB1)) {", "goto cfgctrl_unimp;", "}", "switch (function) {", "case SYS_CFG_VOLT:\nif (site == SYS_CFG_SITE_DB1 && device < s->db_num_vsensors) {", "*val = s->db_voltage[device];", "return true;", "}", "if (site == SYS_CFG_SITE_MB && device == 0) {", "*val = 3300000;", "return true;", "}", "break;", "case SYS_CFG_OSC:\nif (site == SYS_CFG_SITE_MB && device < sizeof(s->mb_clock)) {", "*val = s->mb_clock[device];", "return true;", "}", "if (site == SYS_CFG_SITE_DB1 && device < s->db_num_clocks) {", "*val = s->db_clock[device];", "return true;", "}", "break;", "default:\nbreak;", "}", "cfgctrl_unimp:\nqemu_log_mask(LOG_UNIMP,\n\"arm_sysctl: Unimplemented SYS_CFGCTRL read of function \"\n\"0x%x DCC 0x%x site 0x%x position 0x%x device 0x%x\\n\",\nfunction, dcc, site, position, device);", "return false;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 17, 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 87, 89, 91, 93, 95 ], [ 97 ], [ 99 ] ]

[ "static void FUNC_0(VC1Context *VAR_0, int *VAR_1, int *VAR_2, int *VAR_3, int VAR_4)\n{", "GetBitContext *gb = &VAR_0->s.gb;", "int VAR_5, VAR_6, VAR_7 = 0, VAR_8 = 0, VAR_9 = 0;", "VAR_5 = get_vlc2(gb, ff_vc1_ac_coeff_table[VAR_4].table, AC_VLC_BITS, 3);", "if (VAR_5 != vc1_ac_sizes[VAR_4] - 1) {", "VAR_7 = vc1_index_decode_table[VAR_4][VAR_5][0];", "VAR_8 = vc1_index_decode_table[VAR_4][VAR_5][1];", "VAR_9 = VAR_5 >= vc1_last_decode_table[VAR_4];", "if(get_bits1(gb))\nVAR_8 = -VAR_8;", "} else {", "VAR_6 = decode210(gb);", "if (VAR_6 != 2) {", "VAR_5 = get_vlc2(gb, ff_vc1_ac_coeff_table[VAR_4].table, AC_VLC_BITS, 3);", "VAR_7 = vc1_index_decode_table[VAR_4][VAR_5][0];", "VAR_8 = vc1_index_decode_table[VAR_4][VAR_5][1];", "VAR_9 = VAR_5 >= vc1_last_decode_table[VAR_4];", "if(VAR_6 == 0) {", "if(VAR_9)\nVAR_8 += vc1_last_delta_level_table[VAR_4][VAR_7];", "else\nVAR_8 += vc1_delta_level_table[VAR_4][VAR_7];", "} else {", "if(VAR_9)\nVAR_7 += vc1_last_delta_run_table[VAR_4][VAR_8] + 1;", "else\nVAR_7 += vc1_delta_run_table[VAR_4][VAR_8] + 1;", "}", "if(get_bits1(gb))\nVAR_8 = -VAR_8;", "} else {", "int VAR_10;", "VAR_9 = get_bits1(gb);", "if(VAR_0->s.esc3_level_length == 0) {", "if(VAR_0->pq < 8 || VAR_0->dquantfrm) {", "VAR_0->s.esc3_level_length = get_bits(gb, 3);", "if(!VAR_0->s.esc3_level_length)\nVAR_0->s.esc3_level_length = get_bits(gb, 2) + 8;", "} else {", "VAR_0->s.esc3_level_length = get_unary(gb, 1, 6) + 2;", "}", "VAR_0->s.esc3_run_length = 3 + get_bits(gb, 2);", "}", "VAR_7 = get_bits(gb, VAR_0->s.esc3_run_length);", "VAR_10 = get_bits1(gb);", "VAR_8 = get_bits(gb, VAR_0->s.esc3_level_length);", "if(VAR_10)\nVAR_8 = -VAR_8;", "}", "}", "*VAR_1 = VAR_9;", "*VAR_2 = VAR_7;", "*VAR_3 = VAR_8;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 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 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, const AVFrame *VAR_1,\nint VAR_2, int VAR_3, int VAR_4, int VAR_5,\nProresThreadData *VAR_6)\n{", "ProresContext *ctx = VAR_0->priv_data;", "int VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;", "const uint16_t *VAR_12;", "int VAR_13 = av_log2(VAR_5);", "int VAR_14[MAX_PLANES], pwidth;", "int VAR_15[MAX_PLANES], is_chroma[MAX_PLANES];", "const int VAR_16 = ctx->profile_info->VAR_16;", "const int VAR_17 = ctx->profile_info->VAR_17;", "int VAR_18, VAR_19, VAR_20;", "int VAR_21, VAR_22, VAR_23, VAR_24;", "int VAR_25[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];", "int VAR_26;", "uint16_t *qmat;", "int VAR_27[4], VAR_28;", "if (ctx->pictures_per_frame == 1)\nVAR_28 = 0;", "else\nVAR_28 = ctx->cur_picture_idx ^ !VAR_1->top_field_first;", "VAR_21 = VAR_3 + VAR_5;", "for (VAR_7 = 0; VAR_7 < ctx->num_planes; VAR_7++) {", "is_chroma[VAR_7] = (VAR_7 == 1 || VAR_7 == 2);", "VAR_15[VAR_7] = VAR_13 + 2;", "if (is_chroma[VAR_7])\nVAR_15[VAR_7] += ctx->chroma_factor - 3;", "if (!is_chroma[VAR_7] || ctx->chroma_factor == CFACTOR_Y444) {", "VAR_10 = VAR_3 << 4;", "VAR_11 = VAR_4 << 4;", "VAR_14[VAR_7] = 4;", "pwidth = VAR_0->width;", "} else {", "VAR_10 = VAR_3 << 3;", "VAR_11 = VAR_4 << 4;", "VAR_14[VAR_7] = 2;", "pwidth = VAR_0->width >> 1;", "}", "VAR_27[VAR_7] = VAR_1->VAR_27[VAR_7] * ctx->pictures_per_frame;", "VAR_12 = (const uint16_t*)(VAR_1->data[VAR_7] + VAR_11 * VAR_27[VAR_7] +\nVAR_28 * VAR_1->VAR_27[VAR_7]) + VAR_10;", "if (VAR_7 < 3) {", "get_slice_data(ctx, VAR_12, VAR_27[VAR_7], VAR_10, VAR_11,\npwidth, VAR_0->height / ctx->pictures_per_frame,\nVAR_6->blocks[VAR_7], VAR_6->emu_buf,\nVAR_5, VAR_14[VAR_7], is_chroma[VAR_7]);", "} else {", "get_alpha_data(ctx, VAR_12, VAR_27[VAR_7], VAR_10, VAR_11,\npwidth, VAR_0->height / ctx->pictures_per_frame,\nVAR_6->blocks[VAR_7], VAR_5, ctx->alpha_bits);", "}", "}", "for (VAR_8 = VAR_16; VAR_8 < VAR_17 + 2; VAR_8++) {", "VAR_6->nodes[VAR_2 + VAR_8].prev_node = -1;", "VAR_6->nodes[VAR_2 + VAR_8].quant = VAR_8;", "}", "for (VAR_8 = VAR_16; VAR_8 <= VAR_17; VAR_8++) {", "VAR_19 = 0;", "VAR_18 = 0;", "for (VAR_7 = 0; VAR_7 < ctx->num_planes - !!ctx->alpha_bits; VAR_7++) {", "VAR_19 += estimate_slice_plane(ctx, &VAR_18, VAR_7,\nVAR_12, VAR_27[VAR_7],\nVAR_5,\nVAR_14[VAR_7], VAR_15[VAR_7],\nctx->quants[VAR_8], VAR_6);", "}", "if (ctx->alpha_bits)\nVAR_19 += estimate_alpha_plane(ctx, &VAR_18, VAR_12, VAR_27[3],\nVAR_5, VAR_8, VAR_6->blocks[3]);", "if (VAR_19 > 65000 * 8) {", "VAR_18 = SCORE_LIMIT;", "break;", "}", "VAR_25[VAR_8] = VAR_19;", "slice_score[VAR_8] = VAR_18;", "}", "if (VAR_25[VAR_17] <= ctx->bits_per_mb * VAR_5) {", "VAR_25[VAR_17 + 1] = VAR_25[VAR_17];", "slice_score[VAR_17 + 1] = slice_score[VAR_17] + 1;", "VAR_26 = VAR_17;", "} else {", "for (VAR_8 = VAR_17 + 1; VAR_8 < 128; VAR_8++) {", "VAR_19 = 0;", "VAR_18 = 0;", "if (VAR_8 < MAX_STORED_Q) {", "qmat = ctx->quants[VAR_8];", "} else {", "qmat = VAR_6->custom_q;", "for (VAR_7 = 0; VAR_7 < 64; VAR_7++)", "qmat[VAR_7] = ctx->quant_mat[VAR_7] * VAR_8;", "}", "for (VAR_7 = 0; VAR_7 < ctx->num_planes - !!ctx->alpha_bits; VAR_7++) {", "VAR_19 += estimate_slice_plane(ctx, &VAR_18, VAR_7,\nVAR_12, VAR_27[VAR_7],\nVAR_5,\nVAR_14[VAR_7], VAR_15[VAR_7],\nqmat, VAR_6);", "}", "if (ctx->alpha_bits)\nVAR_19 += estimate_alpha_plane(ctx, &VAR_18, VAR_12, VAR_27[3],\nVAR_5, VAR_8, VAR_6->blocks[3]);", "if (VAR_19 <= ctx->bits_per_mb * VAR_5)\nbreak;", "}", "VAR_25[VAR_17 + 1] = VAR_19;", "slice_score[VAR_17 + 1] = VAR_18;", "VAR_26 = VAR_8;", "}", "VAR_6->nodes[VAR_2 + VAR_17 + 1].quant = VAR_26;", "VAR_20 = VAR_21 * ctx->bits_per_mb;", "for (VAR_9 = VAR_16; VAR_9 < VAR_17 + 2; VAR_9++) {", "VAR_22 = VAR_2 - TRELLIS_WIDTH + VAR_9;", "for (VAR_8 = VAR_16; VAR_8 < VAR_17 + 2; VAR_8++) {", "VAR_23 = VAR_2 + VAR_8;", "VAR_19 = VAR_6->nodes[VAR_22].VAR_19 + VAR_25[VAR_8];", "VAR_18 = slice_score[VAR_8];", "if (VAR_19 > VAR_20)\nVAR_18 = SCORE_LIMIT;", "if (VAR_6->nodes[VAR_22].score < SCORE_LIMIT && VAR_18 < SCORE_LIMIT)\nVAR_24 = VAR_6->nodes[VAR_22].score + VAR_18;", "else\nVAR_24 = SCORE_LIMIT;", "if (VAR_6->nodes[VAR_23].prev_node == -1 ||\nVAR_6->nodes[VAR_23].score >= VAR_24) {", "VAR_6->nodes[VAR_23].VAR_19 = VAR_19;", "VAR_6->nodes[VAR_23].score = VAR_24;", "VAR_6->nodes[VAR_23].prev_node = VAR_22;", "}", "}", "}", "VAR_18 = VAR_6->nodes[VAR_2 + VAR_16].score;", "VAR_9 = VAR_2 + VAR_16;", "for (VAR_8 = VAR_16 + 1; VAR_8 < VAR_17 + 2; VAR_8++) {", "if (VAR_6->nodes[VAR_2 + VAR_8].score <= VAR_18) {", "VAR_18 = VAR_6->nodes[VAR_2 + VAR_8].score;", "VAR_9 = VAR_2 + VAR_8;", "}", "}", "return VAR_9;", "}" ]

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

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

[ "static void FUNC_0(InputStream *VAR_0, const AVPacket *VAR_1, int VAR_2)\n{", "int VAR_3;", "int VAR_4 = 0;", "AVPacket avpkt;", "if (VAR_0->next_dts == AV_NOPTS_VALUE)\nVAR_0->next_dts = VAR_0->last_dts;", "if (!VAR_1) {", "av_init_packet(&avpkt);", "avpkt.data = NULL;", "avpkt.size = 0;", "} else {", "avpkt = *VAR_1;", "}", "if (VAR_1 && VAR_1->dts != AV_NOPTS_VALUE)\nVAR_0->next_dts = VAR_0->last_dts = av_rescale_q(VAR_1->dts, VAR_0->st->time_base, AV_TIME_BASE_Q);", "while (VAR_0->decoding_needed && (!VAR_1 || avpkt.size > 0)) {", "int VAR_8 = 0;", "int VAR_6 = 0;", "if (!VAR_4)\nVAR_0->last_dts = VAR_0->next_dts;", "switch (VAR_0->dec_ctx->codec_type) {", "case AVMEDIA_TYPE_AUDIO:\nVAR_8 = decode_audio (VAR_0, VAR_4 ? NULL : &avpkt, &VAR_6);", "break;", "case AVMEDIA_TYPE_VIDEO:\nVAR_8 = decode_video (VAR_0, VAR_4 ? NULL : &avpkt, &VAR_6);", "if (VAR_4 && !VAR_6)\n;", "else if (VAR_1 && VAR_1->duration)\nVAR_0->next_dts += av_rescale_q(VAR_1->duration, VAR_0->st->time_base, AV_TIME_BASE_Q);", "else if (VAR_0->st->avg_frame_rate.num)\nVAR_0->next_dts += av_rescale_q(1, av_inv_q(VAR_0->st->avg_frame_rate),\nAV_TIME_BASE_Q);", "else if (VAR_0->dec_ctx->framerate.num != 0) {", "int VAR_8 = VAR_0->st->parser ? VAR_0->st->parser->repeat_pict + 1 :\nVAR_0->dec_ctx->ticks_per_frame;", "VAR_0->next_dts += av_rescale_q(VAR_8, VAR_0->dec_ctx->framerate, AV_TIME_BASE_Q);", "}", "break;", "case AVMEDIA_TYPE_SUBTITLE:\nif (VAR_4)\nbreak;", "VAR_8 = transcode_subtitles(VAR_0, &avpkt, &VAR_6);", "break;", "default:\nreturn;", "}", "if (VAR_8 < 0) {", "av_log(NULL, AV_LOG_ERROR, \"Error while decoding stream #%d:%d\\n\",\nVAR_0->file_index, VAR_0->st->index);", "if (exit_on_error)\nexit_program(1);", "break;", "}", "if (!VAR_6)\nbreak;", "VAR_4 = 1;", "}", "if (!VAR_1 && VAR_0->decoding_needed && !VAR_2) {", "int VAR_8 = send_filter_eof(VAR_0);", "if (VAR_8 < 0) {", "av_log(NULL, AV_LOG_FATAL, \"Error marking filters as finished\\n\");", "exit_program(1);", "}", "}", "if (!VAR_0->decoding_needed) {", "VAR_0->last_dts = VAR_0->next_dts;", "switch (VAR_0->dec_ctx->codec_type) {", "case AVMEDIA_TYPE_AUDIO:\nVAR_0->next_dts += ((int64_t)AV_TIME_BASE * VAR_0->dec_ctx->frame_size) /\nVAR_0->dec_ctx->sample_rate;", "break;", "case AVMEDIA_TYPE_VIDEO:\nif (VAR_0->dec_ctx->framerate.num != 0) {", "int VAR_8 = VAR_0->st->parser ? VAR_0->st->parser->repeat_pict + 1 : VAR_0->dec_ctx->ticks_per_frame;", "VAR_0->next_dts += ((int64_t)AV_TIME_BASE *\nVAR_0->dec_ctx->framerate.den * VAR_8) /\nVAR_0->dec_ctx->framerate.num;", "}", "break;", "}", "}", "for (VAR_3 = 0; VAR_1 && VAR_3 < nb_output_streams; VAR_3++) {", "OutputStream *ost = output_streams[VAR_3];", "if (!check_output_constraints(VAR_0, ost) || ost->encoding_needed)\ncontinue;", "do_streamcopy(VAR_0, ost, VAR_1);", "}", "return;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13, 15 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37, 39 ], [ 45 ], [ 47 ], [ 49 ], [ 53, 55 ], [ 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 ], [ 115 ], [ 117, 119 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 131, 133 ], [ 137 ], [ 139 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 165 ], [ 167 ], [ 169 ], [ 171, 173, 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 185, 187, 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 205, 207 ], [ 211 ], [ 213 ], [ 217 ], [ 219 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0,const unsigned char *VAR_1,size_t VAR_2)\n{", "int VAR_3;", "int VAR_4,VAR_5,VAR_6;", "VAR_3 = is_adx(VAR_1,VAR_2);", "if (VAR_3==0) return 0;", "VAR_4 = VAR_1[7];", "VAR_5 = read_long(VAR_1+8);", "VAR_6 = read_long(VAR_1+12);", "VAR_0->sample_rate = VAR_5;", "VAR_0->VAR_4 = VAR_4;", "VAR_0->bit_rate = VAR_5*VAR_4*18*8/32;", "return VAR_3;", "}" ]

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

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

[ "uint32_t FUNC_0(PCIDevice *d,\nuint32_t address, int len)\n{", "uint32_t val;", "switch(len) {", "case 1:\nval = d->config[address];", "break;", "case 2:\nval = le16_to_cpu(*(uint16_t *)(d->config + address));", "break;", "default:\ncase 4:\nval = le32_to_cpu(*(uint32_t *)(d->config + address));", "break;", "}", "return val;", "}" ]

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

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

[ "static QDict *FUNC_0(QObject *input_obj, Error **errp)\n{", "const QDictEntry *VAR_0;", "int VAR_1 = 0;", "QDict *input_dict;", "if (qobject_type(input_obj) != QTYPE_QDICT) {", "error_set(errp, QERR_QMP_BAD_INPUT_OBJECT, \"object\");", "return NULL;", "}", "input_dict = qobject_to_qdict(input_obj);", "for (VAR_0 = qdict_first(input_dict); VAR_0; VAR_0 = qdict_next(input_dict, VAR_0)){", "const char *arg_name = qdict_entry_key(VAR_0);", "const QObject *arg_obj = qdict_entry_value(VAR_0);", "if (!strcmp(arg_name, \"execute\")) {", "if (qobject_type(arg_obj) != QTYPE_QSTRING) {", "error_set(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,\n\"execute\", \"string\");", "return NULL;", "}", "VAR_1 = 1;", "} else if (!strcmp(arg_name, \"arguments\")) {", "if (qobject_type(arg_obj) != QTYPE_QDICT) {", "error_set(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,\n\"arguments\", \"object\");", "return NULL;", "}", "} else {", "error_set(errp, QERR_QMP_EXTRA_MEMBER, arg_name);", "return NULL;", "}", "}", "if (!VAR_1) {", "error_set(errp, QERR_QMP_BAD_INPUT_OBJECT, \"execute\");", "return NULL;", "}", "return input_dict;", "}" ]

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

[ "static void FUNC_0(struct NetRxPkt *VAR_0,\nconst void *VAR_1,\nsize_t VAR_2)\n{", "struct virtio_net_hdr *VAR_3;", "bool isip4, isip6, istcp, isudp;", "uint8_t *data;", "int VAR_4;", "if (!net_rx_pkt_has_virt_hdr(VAR_0)) {", "return;", "}", "VAR_3 = net_rx_pkt_get_vhdr(VAR_0);", "if (!VMXNET_FLAG_IS_SET(VAR_3->flags, VIRTIO_NET_HDR_F_NEEDS_CSUM)) {", "return;", "}", "net_rx_pkt_get_protocols(VAR_0, &isip4, &isip6, &isudp, &istcp);", "if (!(isip4 || isip6) || !(istcp || isudp)) {", "return;", "}", "vmxnet3_dump_virt_hdr(VAR_3);", "if (VAR_2 < (VAR_3->csum_start + VAR_3->csum_offset + 2)) {", "VMW_PKPRN(\"packet VAR_4:%zu < csum_start(%d) + csum_offset(%d) + 2, \"\n\"cannot calculate checksum\",\nVAR_2, VAR_3->csum_start, VAR_3->csum_offset);", "return;", "}", "data = (uint8_t *)VAR_1 + VAR_3->csum_start;", "VAR_4 = VAR_2 - VAR_3->csum_start;", "stw_be_p(data + VAR_3->csum_offset, net_raw_checksum(data, VAR_4));", "VAR_3->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;", "VAR_3->flags |= VIRTIO_NET_HDR_F_DATA_VALID;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 53 ], [ 55, 57, 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ] ]

[ "int FUNC_0(AVCodecContext *VAR_0, PSContext *VAR_1, float VAR_2[2][38][64], float VAR_3[2][38][64], int VAR_4)\n{", "float VAR_5[91][32][2];", "float VAR_6[91][32][2];", "const int VAR_7 = 32;", "int VAR_8 = VAR_1->is34bands;", "VAR_4 += NR_BANDS[VAR_8] - 64;", "memset(VAR_1->delay+VAR_4, 0, (NR_BANDS[VAR_8] - VAR_4)*sizeof(VAR_1->delay[0]));", "if (VAR_4 < NR_ALLPASS_BANDS[VAR_8])\nmemset(VAR_1->ap_delay + VAR_4, 0, (NR_ALLPASS_BANDS[VAR_8] - VAR_4)*sizeof(VAR_1->ap_delay[0]));", "hybrid_analysis(VAR_5, VAR_1->in_buf, VAR_2, VAR_8, VAR_7);", "decorrelation(VAR_1, VAR_6, VAR_5, VAR_8);", "stereo_processing(VAR_1, VAR_5, VAR_6, VAR_8);", "hybrid_synthesis(VAR_2, VAR_5, VAR_8, VAR_7);", "hybrid_synthesis(VAR_3, VAR_6, VAR_8, VAR_7);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(EVRCContext *VAR_0, float *VAR_1, float VAR_2)\n{", "float *VAR_3;", "int VAR_4, VAR_5, VAR_6;", "int16_t t;", "VAR_4 = lrintf(fabs(VAR_2));", "t = (VAR_4 - VAR_2 + 0.5) * 8.0 + 0.5;", "if (t == 8) {", "t = 0;", "VAR_4--;", "}", "VAR_3 = VAR_1 - VAR_4 - 8;", "VAR_6 = t * (2 * 8 + 1);", "VAR_1[0] = 0.0;", "for (VAR_5 = 0; VAR_5 < 2 * 8 + 1; VAR_5++)", "VAR_1[0] += VAR_0->interpolation_coeffs[VAR_6 + VAR_5] * VAR_3[VAR_5];", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ] ]

[ "static av_always_inline void FUNC_0(int16_t *blk, int step, int shift, int rnd)\n{", "const int VAR_0 = 27246 * blk[3 * step] + 18405 * blk[5 * step];", "const int VAR_1 = 27246 * blk[5 * step] - 18405 * blk[3 * step];", "const int VAR_2 = 6393 * blk[7 * step] + 32139 * blk[1 * step];", "const int VAR_3 = 6393 * blk[1 * step] - 32139 * blk[7 * step];", "const unsigned VAR_4 = 5793U * (VAR_2 + VAR_0 + 0x800 >> 12);", "const unsigned VAR_5 = 5793U * (VAR_3 + VAR_1 + 0x800 >> 12);", "const unsigned VAR_6 = VAR_2 - VAR_0;", "const unsigned VAR_7 = VAR_3 - VAR_1;", "const unsigned VAR_8 = 17734 * blk[2 * step] - 42813 * blk[6 * step];", "const unsigned VAR_9 = 17734 * blk[6 * step] + 42814 * blk[2 * step];", "const unsigned VAR_10 = (blk[0 * step] - blk[4 * step]) * 32768 + rnd;", "const unsigned VAR_11 = (blk[0 * step] + blk[4 * step]) * 32768 + rnd;", "blk[0 * step] = (int)( VAR_4 + VAR_9 + VAR_11) >> shift;", "blk[1 * step] = (int)( VAR_6 + VAR_7 + VAR_8 + VAR_10) >> shift;", "blk[2 * step] = (int)( VAR_6 - VAR_7 - VAR_8 + VAR_10) >> shift;", "blk[3 * step] = (int)( VAR_5 - VAR_9 + VAR_11) >> shift;", "blk[4 * step] = (int)( -VAR_5 - VAR_9 + VAR_11) >> shift;", "blk[5 * step] = (int)(-(VAR_6 - VAR_7) - VAR_8 + VAR_10) >> shift;", "blk[6 * step] = (int)(-(VAR_6 + VAR_7) + VAR_8 + VAR_10) >> shift;", "blk[7 * step] = (int)( -VAR_4 + VAR_9 + VAR_11) >> shift;", "}" ]

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

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

[ "static int FUNC_0(RDMAContext *VAR_0)\n{", "VAR_0->pd = ibv_alloc_pd(VAR_0->verbs);", "if (!VAR_0->pd) {", "fprintf(stderr, \"failed to allocate protection domain\\n\");", "return -1;", "}", "VAR_0->comp_channel = ibv_create_comp_channel(VAR_0->verbs);", "if (!VAR_0->comp_channel) {", "fprintf(stderr, \"failed to allocate completion channel\\n\");", "goto err_alloc_pd_cq;", "}", "VAR_0->cq = ibv_create_cq(VAR_0->verbs, (RDMA_SIGNALED_SEND_MAX * 3),\nNULL, VAR_0->comp_channel, 0);", "if (!VAR_0->cq) {", "fprintf(stderr, \"failed to allocate completion queue\\n\");", "goto err_alloc_pd_cq;", "}", "return 0;", "err_alloc_pd_cq:\nif (VAR_0->pd) {", "ibv_dealloc_pd(VAR_0->pd);", "}", "if (VAR_0->comp_channel) {", "ibv_destroy_comp_channel(VAR_0->comp_channel);", "}", "VAR_0->pd = NULL;", "VAR_0->comp_channel = NULL;", "return -1;", "}" ]

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

[ [ 1, 3 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ] ]

[ "static void FUNC_0(Visitor *VAR_0, const char *VAR_1, int64_t *VAR_2,\nError **VAR_3)\n{", "QObjectInputVisitor *qiv = to_qiv(VAR_0);", "QObject *qobj = qobject_input_get_object(qiv, VAR_1, true, VAR_3);", "QInt *qint;", "if (!qobj) {", "return;", "}", "qint = qobject_to_qint(qobj);", "if (!qint) {", "error_setg(VAR_3, QERR_INVALID_PARAMETER_TYPE, VAR_1 ? VAR_1 : \"null\",\n\"integer\");", "return;", "}", "*VAR_2 = qint_get_int(qint);", "}" ]

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

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "dc->props = xlnx_zynqmp_props;", "dc->realize = xlnx_zynqmp_realize;", "}" ]

[ 0, 0, 0, 0, 0 ]

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6 ] ]

[ "static target_ulong FUNC_0(CPUPPCState *env, sPAPREnvironment *spapr,\ntarget_ulong opcode, target_ulong *args)\n{", "target_ulong reg = args[0];", "target_ulong *bufs = args + 1;", "target_ulong continue_token = args[7];", "VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);", "VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;", "unsigned VAR_0;", "uint8_t *lbuf, *p;", "int VAR_1, VAR_2;", "int VAR_3;", "dprintf(\"H_SEND_LOGICAL_LAN(0x\" TARGET_FMT_lx \", <bufs>, 0x\"\nTARGET_FMT_lx \")\\n\", reg, continue_token);", "if (!sdev) {", "return H_PARAMETER;", "}", "dprintf(\"rxbufs = %d\\n\", dev->rx_bufs);", "if (!dev->isopen) {", "return H_DROPPED;", "}", "if (continue_token) {", "return H_HARDWARE;", "}", "VAR_0 = 0;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {", "dprintf(\" buf desc: 0x\" TARGET_FMT_lx \"\\n\", bufs[VAR_1]);", "if (!(bufs[VAR_1] & VLAN_BD_VALID)) {", "break;", "}", "VAR_0 += VLAN_BD_LEN(bufs[VAR_1]);", "}", "VAR_2 = VAR_1;", "dprintf(\"FUNC_0() %d buffers, total length 0x%x\\n\",\nVAR_2, VAR_0);", "if (VAR_0 == 0) {", "return H_SUCCESS;", "}", "if (VAR_0 > MAX_PACKET_SIZE) {", "return H_RESOURCE;", "}", "lbuf = alloca(VAR_0);", "p = lbuf;", "for (VAR_1 = 0; VAR_1 < VAR_2; VAR_1++) {", "VAR_3 = spapr_tce_dma_read(sdev, VLAN_BD_ADDR(bufs[VAR_1]),\np, VLAN_BD_LEN(bufs[VAR_1]));", "if (VAR_3 < 0) {", "return VAR_3;", "}", "p += VLAN_BD_LEN(bufs[VAR_1]);", "}", "qemu_send_packet(&dev->nic->nc, lbuf, VAR_0);", "return H_SUCCESS;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81, 83 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 129 ], [ 133 ], [ 135 ] ]

[ "static ssize_t FUNC_0(NetClientState *nc, const uint8_t *buf, size_t size)\n{", "VirtIONet *n = qemu_get_nic_opaque(nc);", "VirtIONetQueue *q = virtio_net_get_subqueue(nc);", "VirtIODevice *vdev = VIRTIO_DEVICE(n);", "struct iovec VAR_0[VIRTQUEUE_MAX_SIZE];", "struct virtio_net_hdr_mrg_rxbuf VAR_1;", "unsigned VAR_2 = 0;", "size_t offset, i, guest_offset;", "if (!virtio_net_can_receive(nc)) {", "return -1;", "}", "if (!virtio_net_has_buffers(q, size + n->guest_hdr_len - n->host_hdr_len)) {", "return 0;", "}", "if (!receive_filter(n, buf, size))\nreturn size;", "offset = i = 0;", "while (offset < size) {", "VirtQueueElement elem;", "int VAR_3, VAR_4;", "const struct iovec *VAR_5 = elem.in_sg;", "VAR_4 = 0;", "if (virtqueue_pop(q->rx_vq, &elem) == 0) {", "if (i == 0)\nreturn -1;", "error_report(\"virtio-net unexpected empty queue: \"\n\"i %zd mergeable %d offset %zd, size %zd, \"\n\"guest hdr VAR_3 %zd, host hdr VAR_3 %zd \"\n\"guest features 0x%\" PRIx64,\ni, n->mergeable_rx_bufs, offset, size,\nn->guest_hdr_len, n->host_hdr_len,\nvdev->guest_features);", "exit(1);", "}", "if (elem.in_num < 1) {", "error_report(\"virtio-net receive queue contains no in buffers\");", "exit(1);", "}", "if (i == 0) {", "assert(offset == 0);", "if (n->mergeable_rx_bufs) {", "VAR_2 = iov_copy(VAR_0, ARRAY_SIZE(VAR_0),\nVAR_5, elem.in_num,\noffsetof(typeof(VAR_1), num_buffers),\nsizeof(VAR_1.num_buffers));", "}", "receive_header(n, VAR_5, elem.in_num, buf, size);", "offset = n->host_hdr_len;", "VAR_4 += n->guest_hdr_len;", "guest_offset = n->guest_hdr_len;", "} else {", "guest_offset = 0;", "}", "VAR_3 = iov_from_buf(VAR_5, elem.in_num, guest_offset,\nbuf + offset, size - offset);", "VAR_4 += VAR_3;", "offset += VAR_3;", "if (!n->mergeable_rx_bufs && offset < size) {", "#if 0\nerror_report(\"virtio-net truncated non-mergeable packet: \"\n\"i %zd mergeable %d offset %zd, size %zd, \"\n\"guest hdr VAR_3 %zd, host hdr VAR_3 %zd\",\ni, n->mergeable_rx_bufs,\noffset, size, n->guest_hdr_len, n->host_hdr_len);", "#endif\nreturn size;", "}", "virtqueue_fill(q->rx_vq, &elem, VAR_4, i++);", "}", "if (VAR_2) {", "virtio_stw_p(vdev, &VAR_1.num_buffers, i);", "iov_from_buf(VAR_0, VAR_2,\n0,\n&VAR_1.num_buffers, sizeof VAR_1.num_buffers);", "}", "virtqueue_flush(q->rx_vq, i);", "virtio_notify(vdev, q->rx_vq);", "return size;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 31 ], [ 33 ], [ 35 ], [ 39, 41 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 63 ], [ 65, 67 ], [ 69, 71, 73, 75, 77, 79, 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107, 109, 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 149 ], [ 151, 153, 155, 157, 159, 161 ], [ 163, 165 ], [ 167 ], [ 173 ], [ 175 ], [ 179 ], [ 181 ], [ 183, 185, 187 ], [ 189 ], [ 193 ], [ 195 ], [ 199 ], [ 201 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVIOContext *VAR_1, AVPacket *VAR_2, int VAR_3, int64_t VAR_4)\n{", "int VAR_5 = ffio_read_varlen(VAR_1);", "int VAR_6 = 0;", "int VAR_7 = 0;", "int VAR_8 = 0;", "int64_t channel_layout = 0;", "int VAR_9 = 0;", "int VAR_10 = 0;", "int VAR_11 = 0;", "int VAR_12, VAR_13;", "for (VAR_12=0; VAR_12<VAR_5; VAR_12++) {", "uint8_t name[256], str_value[256], type_str[256];", "int VAR_14;", "if (avio_tell(VAR_1) >= VAR_4)\nreturn AVERROR_INVALIDDATA;", "VAR_13 = get_str(VAR_1, name, sizeof(name));", "if (VAR_13 < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"get_str failed while reading sm data\\n\");", "return VAR_13;", "}", "VAR_14 = get_s(VAR_1);", "if (VAR_14 == -1) {", "get_str(VAR_1, str_value, sizeof(str_value));", "av_log(VAR_0, AV_LOG_WARNING, \"Unknown string %VAR_0 / %VAR_0\\n\", name, str_value);", "} else if (VAR_14 == -2) {", "uint8_t *dst = NULL;", "int64_t v64, value_len;", "get_str(VAR_1, type_str, sizeof(type_str));", "value_len = ffio_read_varlen(VAR_1);", "if (avio_tell(VAR_1) + value_len >= VAR_4)\nreturn AVERROR_INVALIDDATA;", "if (!strcmp(name, \"Palette\")) {", "dst = av_packet_new_side_data(VAR_2, AV_PKT_DATA_PALETTE, value_len);", "} else if (!strcmp(name, \"Extradata\")) {", "dst = av_packet_new_side_data(VAR_2, AV_PKT_DATA_NEW_EXTRADATA, value_len);", "} else if (sscanf(name, \"CodecSpecificSide%\"SCNd64\"\", &v64) == 1) {", "dst = av_packet_new_side_data(VAR_2, AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, value_len + 8);", "if(!dst)\nreturn AVERROR(ENOMEM);", "AV_WB64(dst, v64);", "dst += 8;", "} else if (!strcmp(name, \"ChannelLayout\") && value_len == 8) {", "channel_layout = avio_rl64(VAR_1);", "continue;", "} else {", "av_log(VAR_0, AV_LOG_WARNING, \"Unknown data %VAR_0 / %VAR_0\\n\", name, type_str);", "avio_skip(VAR_1, value_len);", "continue;", "}", "if(!dst)\nreturn AVERROR(ENOMEM);", "avio_read(VAR_1, dst, value_len);", "} else if (VAR_14 == -3) {", "VAR_14 = get_s(VAR_1);", "} else if (VAR_14 == -4) {", "VAR_14 = ffio_read_varlen(VAR_1);", "} else if (VAR_14 < -4) {", "get_s(VAR_1);", "} else {", "if (!strcmp(name, \"SkipStart\")) {", "VAR_6 = VAR_14;", "} else if (!strcmp(name, \"SkipEnd\")) {", "VAR_7 = VAR_14;", "} else if (!strcmp(name, \"Channels\")) {", "VAR_8 = VAR_14;", "} else if (!strcmp(name, \"SampleRate\")) {", "VAR_9 = VAR_14;", "} else if (!strcmp(name, \"Width\")) {", "VAR_10 = VAR_14;", "} else if (!strcmp(name, \"Height\")) {", "VAR_11 = VAR_14;", "} else {", "av_log(VAR_0, AV_LOG_WARNING, \"Unknown integer %VAR_0\\n\", name);", "}", "}", "}", "if (VAR_8 || channel_layout || VAR_9 || VAR_10 || VAR_11) {", "uint8_t *dst = av_packet_new_side_data(VAR_2, AV_PKT_DATA_PARAM_CHANGE, 28);", "if (!dst)\nreturn AVERROR(ENOMEM);", "bytestream_put_le32(&dst,\nAV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT*(!!VAR_8) +\nAV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT*(!!channel_layout) +\nAV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE*(!!VAR_9) +\nAV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS*(!!(VAR_10|VAR_11))\n);", "if (VAR_8)\nbytestream_put_le32(&dst, VAR_8);", "if (channel_layout)\nbytestream_put_le64(&dst, channel_layout);", "if (VAR_9)\nbytestream_put_le32(&dst, VAR_9);", "if (VAR_10 || VAR_11){", "bytestream_put_le32(&dst, VAR_10);", "bytestream_put_le32(&dst, VAR_11);", "}", "}", "if (VAR_6 || VAR_7) {", "uint8_t *dst = av_packet_new_side_data(VAR_2, AV_PKT_DATA_SKIP_SAMPLES, 10);", "if (!dst)\nreturn AVERROR(ENOMEM);", "AV_WL32(dst, VAR_6);", "AV_WL32(dst+4, VAR_7);", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 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 ], [ 163 ], [ 165 ], [ 167, 169 ], [ 171, 173, 175, 177, 179, 181 ], [ 183, 185 ], [ 187, 189 ], [ 191, 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ] ]

[ "static uint32_t FUNC_0(ePICContext *dc, int x, int y,\nconst uint32_t *curr_row,\nconst uint32_t *above_row)\n{", "uint32_t N, W, NW, pred;", "unsigned VAR_0;", "int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6;", "if (x && y) {", "W = curr_row[x - 1];", "N = above_row[x];", "NW = above_row[x - 1];", "VAR_1 = (N >> G_shift) & 0xFF;", "VAR_2 = (W >> G_shift) & 0xFF;", "VAR_3 = (NW >> G_shift) & 0xFF;", "VAR_5 = epic_decode_component_pred(dc, VAR_1, VAR_2, VAR_3);", "VAR_4 = VAR_5 + epic_decode_component_pred(dc,\n((N >> R_shift) & 0xFF) - VAR_1,\n((W >> R_shift) & 0xFF) - VAR_2,\n((NW >> R_shift) & 0xFF) - VAR_3);", "VAR_6 = VAR_5 + epic_decode_component_pred(dc,\n((N >> B_shift) & 0xFF) - VAR_1,\n((W >> B_shift) & 0xFF) - VAR_2,\n((NW >> B_shift) & 0xFF) - VAR_3);", "} else {", "if (x)\npred = curr_row[x - 1];", "else\npred = above_row[x];", "VAR_0 = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);", "VAR_4 = ((pred >> R_shift) & 0xFF) - TOSIGNED(VAR_0);", "VAR_0 = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);", "VAR_5 = ((pred >> G_shift) & 0xFF) - TOSIGNED(VAR_0);", "VAR_0 = ff_els_decode_unsigned(&dc->els_ctx, &dc->unsigned_rung);", "VAR_6 = ((pred >> B_shift) & 0xFF) - TOSIGNED(VAR_0);", "return (VAR_4 << R_shift) | (VAR_5 << G_shift) | (VAR_6 << B_shift);" ]

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

[ "static USBDevice *FUNC_0(int bus_num, int addr, const char *prod_name)\n{", "int VAR_0 = -1, VAR_1;", "USBDevice *d = NULL;", "USBHostDevice *dev;", "struct usbdevfs_connectinfo VAR_2;", "char VAR_3[1024];", "printf(\"husb: open device %d.%d\\n\", bus_num, addr);", "if (!usb_host_device_path) {", "perror(\"husb: USB Host Device Path not set\");", "goto fail;", "}", "snprintf(VAR_3, sizeof(VAR_3), \"%s/%03d/%03d\", usb_host_device_path,\nbus_num, addr);", "VAR_0 = open(VAR_3, O_RDWR | O_NONBLOCK);", "if (VAR_0 < 0) {", "perror(VAR_3);", "goto fail;", "}", "dprintf(\"husb: opened %s\\n\", VAR_3);", "d = usb_create(NULL , \"USB Host Device\");", "dev = DO_UPCAST(USBHostDevice, dev, d);", "dev->bus_num = bus_num;", "dev->addr = addr;", "dev->VAR_0 = VAR_0;", "dev->descr_len = read(VAR_0, dev->descr, sizeof(dev->descr));", "if (dev->descr_len <= 0) {", "perror(\"husb: reading device data failed\");", "goto fail;", "}", "#ifdef DEBUG\n{", "int x;", "printf(\"=== begin dumping device descriptor data ===\\n\");", "for (x = 0; x < dev->descr_len; x++)", "printf(\"%02x \", dev->descr[x]);", "printf(\"\\n=== end dumping device descriptor data ===\\n\");", "}", "#endif\nif (!usb_host_claim_interfaces(dev, -1))\ngoto fail;", "VAR_1 = ioctl(VAR_0, USBDEVFS_CONNECTINFO, &VAR_2);", "if (VAR_1 < 0) {", "perror(\"usb_host_device_open: USBDEVFS_CONNECTINFO\");", "goto fail;", "}", "printf(\"husb: grabbed usb device %d.%d\\n\", bus_num, addr);", "VAR_1 = usb_linux_update_endp_table(dev);", "if (VAR_1)\ngoto fail;", "if (VAR_2.slow)\ndev->dev.speed = USB_SPEED_LOW;", "else\ndev->dev.speed = USB_SPEED_HIGH;", "if (!prod_name || prod_name[0] == '\\0')\nsnprintf(dev->dev.devname, sizeof(dev->dev.devname),\n\"host:%d.%d\", bus_num, addr);", "else\npstrcpy(dev->dev.devname, sizeof(dev->dev.devname),\nprod_name);", "qemu_set_fd_handler(dev->VAR_0, NULL, async_complete, dev);", "hostdev_link(dev);", "qdev_init(&d->qdev);", "return (USBDevice *) dev;", "fail:\nif (d)\nqdev_free(&d->qdev);", "if (VAR_0 != -1)\nclose(VAR_0);", "return NULL;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91, 109, 111 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 131 ], [ 133, 135 ], [ 139, 141 ], [ 143, 145 ], [ 149, 151, 153 ], [ 155, 157, 159 ], [ 165 ], [ 169 ], [ 173 ], [ 175 ], [ 179, 181, 183 ], [ 185, 187 ], [ 189 ], [ 191 ] ]

[ "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_4;", "int VAR_5 = VAR_3->VAR_5;", "VP9Context *s = VAR_0->priv_data;", "int VAR_6, VAR_7, VAR_11, VAR_9;", "int VAR_10 = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&\n(!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map);", "AVFrame *f;", "if ((VAR_6 = decode_frame_header(VAR_0, VAR_4, VAR_5, &VAR_9)) < 0) {", "return VAR_6;", "} else if (VAR_6 == 0) {", "if (!s->s.refs[VAR_9].f->buf[0]) {", "av_log(VAR_0, AV_LOG_ERROR, \"Requested reference %d not available\\n\", VAR_9);", "return AVERROR_INVALIDDATA;", "}", "if ((VAR_6 = av_frame_ref(VAR_1, s->s.refs[VAR_9].f)) < 0)\nreturn VAR_6;", "((AVFrame *)VAR_1)->pts = VAR_3->pts;", "#if FF_API_PKT_PTS\nFF_DISABLE_DEPRECATION_WARNINGS\n((AVFrame *)VAR_1)->pkt_pts = VAR_3->pts;", "FF_ENABLE_DEPRECATION_WARNINGS\n#endif\n((AVFrame *)VAR_1)->pkt_dts = VAR_3->dts;", "for (VAR_7 = 0; VAR_7 < 8; VAR_7++) {", "if (s->next_refs[VAR_7].f->buf[0])\nff_thread_release_buffer(VAR_0, &s->next_refs[VAR_7]);", "if (s->s.refs[VAR_7].f->buf[0] &&\n(VAR_6 = ff_thread_ref_frame(&s->next_refs[VAR_7], &s->s.refs[VAR_7])) < 0)\nreturn VAR_6;", "}", "*VAR_2 = 1;", "return VAR_3->VAR_5;", "}", "VAR_4 += VAR_6;", "VAR_5 -= VAR_6;", "if (!VAR_10 || s->s.h.keyframe || s->s.h.intraonly) {", "if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0])\nvp9_frame_unref(VAR_0, &s->s.frames[REF_FRAME_SEGMAP]);", "if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&\n(VAR_6 = vp9_frame_ref(VAR_0, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)\nreturn VAR_6;", "}", "if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0])\nvp9_frame_unref(VAR_0, &s->s.frames[REF_FRAME_MVPAIR]);", "if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&\n(VAR_6 = vp9_frame_ref(VAR_0, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)\nreturn VAR_6;", "if (s->s.frames[CUR_FRAME].tf.f->buf[0])\nvp9_frame_unref(VAR_0, &s->s.frames[CUR_FRAME]);", "if ((VAR_6 = vp9_frame_alloc(VAR_0, &s->s.frames[CUR_FRAME])) < 0)\nreturn VAR_6;", "f = s->s.frames[CUR_FRAME].tf.f;", "f->key_frame = s->s.h.keyframe;", "f->pict_type = (s->s.h.keyframe || s->s.h.intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;", "if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] &&\n(s->s.frames[REF_FRAME_MVPAIR].tf.f->width != s->s.frames[CUR_FRAME].tf.f->width ||\ns->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) {", "vp9_frame_unref(VAR_0, &s->s.frames[REF_FRAME_SEGMAP]);", "}", "for (VAR_7 = 0; VAR_7 < 8; VAR_7++) {", "if (s->next_refs[VAR_7].f->buf[0])\nff_thread_release_buffer(VAR_0, &s->next_refs[VAR_7]);", "if (s->s.h.refreshrefmask & (1 << VAR_7)) {", "VAR_6 = ff_thread_ref_frame(&s->next_refs[VAR_7], &s->s.frames[CUR_FRAME].tf);", "} else if (s->s.refs[VAR_7].f->buf[0]) {", "VAR_6 = ff_thread_ref_frame(&s->next_refs[VAR_7], &s->s.refs[VAR_7]);", "}", "if (VAR_6 < 0)\nreturn VAR_6;", "}", "if (VAR_0->hwaccel) {", "VAR_6 = VAR_0->hwaccel->start_frame(VAR_0, NULL, 0);", "if (VAR_6 < 0)\nreturn VAR_6;", "VAR_6 = VAR_0->hwaccel->decode_slice(VAR_0, VAR_3->VAR_4, VAR_3->VAR_5);", "if (VAR_6 < 0)\nreturn VAR_6;", "VAR_6 = VAR_0->hwaccel->end_frame(VAR_0);", "if (VAR_6 < 0)\nreturn VAR_6;", "goto finish;", "}", "memset(s->above_partition_ctx, 0, s->cols);", "memset(s->above_skip_ctx, 0, s->cols);", "if (s->s.h.keyframe || s->s.h.intraonly) {", "memset(s->above_mode_ctx, DC_PRED, s->cols * 2);", "} else {", "memset(s->above_mode_ctx, NEARESTMV, s->cols);", "}", "memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);", "memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);", "memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);", "memset(s->above_segpred_ctx, 0, s->cols);", "s->pass = s->s.frames[CUR_FRAME].uses_2pass =\nVAR_0->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;", "if ((VAR_6 = update_block_buffers(VAR_0)) < 0) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Failed to allocate block buffers\\n\");", "return VAR_6;", "}", "if (s->s.h.refreshctx && s->s.h.parallelmode) {", "int VAR_11, VAR_11, VAR_12, VAR_13;", "for (VAR_7 = 0; VAR_7 < 4; VAR_7++) {", "for (VAR_11 = 0; VAR_11 < 2; VAR_11++)", "for (VAR_11 = 0; VAR_11 < 2; VAR_11++)", "for (VAR_12 = 0; VAR_12 < 6; VAR_12++)", "for (VAR_13 = 0; VAR_13 < 6; VAR_13++)", "memcpy(s->prob_ctx[s->s.h.framectxid].coef[VAR_7][VAR_11][VAR_11][VAR_12][VAR_13],\ns->prob.coef[VAR_7][VAR_11][VAR_11][VAR_12][VAR_13], 3);", "if (s->s.h.txfmmode == VAR_7)\nbreak;", "}", "s->prob_ctx[s->s.h.framectxid].p = s->prob.p;", "ff_thread_finish_setup(VAR_0);", "} else if (!s->s.h.refreshctx) {", "ff_thread_finish_setup(VAR_0);", "}", "#if HAVE_THREADS\nif (VAR_0->active_thread_type & FF_THREAD_SLICE) {", "for (VAR_7 = 0; VAR_7 < s->sb_rows; VAR_7++)", "atomic_store(&s->entries[VAR_7], 0);", "}", "#endif\ndo {", "for (VAR_7 = 0; VAR_7 < s->active_tile_cols; VAR_7++) {", "s->td[VAR_7].b = s->td[VAR_7].b_base;", "s->td[VAR_7].block = s->td[VAR_7].block_base;", "s->td[VAR_7].uvblock[0] = s->td[VAR_7].uvblock_base[0];", "s->td[VAR_7].uvblock[1] = s->td[VAR_7].uvblock_base[1];", "s->td[VAR_7].eob = s->td[VAR_7].eob_base;", "s->td[VAR_7].uveob[0] = s->td[VAR_7].uveob_base[0];", "s->td[VAR_7].uveob[1] = s->td[VAR_7].uveob_base[1];", "}", "#if HAVE_THREADS\nif (VAR_0->active_thread_type == FF_THREAD_SLICE) {", "int tile_row, tile_col;", "av_assert1(!s->pass);", "for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {", "for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {", "int64_t tile_size;", "if (tile_col == s->s.h.tiling.tile_cols - 1 &&\ntile_row == s->s.h.tiling.tile_rows - 1) {", "tile_size = VAR_5;", "} else {", "tile_size = AV_RB32(VAR_4);", "VAR_4 += 4;", "VAR_5 -= 4;", "}", "if (tile_size > VAR_5)\nreturn AVERROR_INVALIDDATA;", "VAR_6 = ff_vp56_init_range_decoder(&s->td[tile_col].c_b[tile_row], VAR_4, tile_size);", "if (VAR_6 < 0)\nreturn VAR_6;", "if (vp56_rac_get_prob_branchy(&s->td[tile_col].c_b[tile_row], 128))\nreturn AVERROR_INVALIDDATA;", "VAR_4 += tile_size;", "VAR_5 -= tile_size;", "}", "}", "ff_slice_thread_execute_with_mainfunc(VAR_0, decode_tiles_mt, loopfilter_proc, s->td, NULL, s->s.h.tiling.tile_cols);", "} else", "#endif\n{", "VAR_6 = decode_tiles(VAR_0, VAR_4, VAR_5);", "if (VAR_6 < 0)\nreturn VAR_6;", "}", "if (VAR_0->active_thread_type == FF_THREAD_SLICE)\nfor (VAR_7 = 1; VAR_7 < s->s.h.tiling.tile_cols; VAR_7++)", "for (VAR_11 = 0; VAR_11 < sizeof(s->td[VAR_7].counts) / sizeof(unsigned); VAR_11++)", "((unsigned *)&s->td[0].counts)[VAR_11] += ((unsigned *)&s->td[VAR_7].counts)[VAR_11];", "if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {", "ff_vp9_adapt_probs(s);", "ff_thread_finish_setup(VAR_0);", "}", "} while (s->pass++ == 1);", "ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);", "finish:\nfor (VAR_7 = 0; VAR_7 < 8; VAR_7++) {", "if (s->s.refs[VAR_7].f->buf[0])\nff_thread_release_buffer(VAR_0, &s->s.refs[VAR_7]);", "if (s->next_refs[VAR_7].f->buf[0] &&\n(VAR_6 = ff_thread_ref_frame(&s->s.refs[VAR_7], &s->next_refs[VAR_7])) < 0)\nreturn VAR_6;", "}", "if (!s->s.h.invisible) {", "if ((VAR_6 = av_frame_ref(VAR_1, s->s.frames[CUR_FRAME].tf.f)) < 0)\nreturn VAR_6;", "*VAR_2 = 1;", "}", "return VAR_3->VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15, 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 43, 45, 47 ], [ 49, 51, 53 ], [ 55 ], [ 57, 59 ], [ 61, 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83, 85 ], [ 87, 89, 91 ], [ 93 ], [ 95, 97 ], [ 99, 101, 103 ], [ 105, 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121, 123, 125 ], [ 127 ], [ 129 ], [ 135 ], [ 137, 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 159 ], [ 161 ], [ 163, 165 ], [ 167 ], [ 169, 171 ], [ 173 ], [ 175, 177 ], [ 179 ], [ 181 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 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 ], [ 261, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271, 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 297, 299 ], [ 301 ], [ 305 ], [ 309 ], [ 311 ], [ 313 ], [ 317, 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333, 335 ], [ 337 ], [ 339, 341 ], [ 343, 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 357 ], [ 359 ], [ 361, 363 ], [ 365 ], [ 367, 369 ], [ 371 ], [ 377, 379 ], [ 381 ], [ 383 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 401, 405 ], [ 407, 409 ], [ 411, 413, 415 ], [ 417 ], [ 421 ], [ 423, 425 ], [ 427 ], [ 429 ], [ 433 ], [ 435 ] ]

[ "static void FUNC_0(PassthruState *VAR_0,\nVSCMsgType VAR_1, uint32_t VAR_2,\nconst uint8_t *VAR_3, uint32_t VAR_4)\n{", "VSCMsgHeader scr_msg_header;", "scr_msg_header.VAR_1 = htonl(VAR_1);", "scr_msg_header.VAR_2 = htonl(VAR_2);", "scr_msg_header.VAR_4 = htonl(VAR_4);", "qemu_chr_fe_write(VAR_0->cs, (uint8_t *)&scr_msg_header, sizeof(VSCMsgHeader));", "qemu_chr_fe_write(VAR_0->cs, VAR_3, VAR_4);", "}" ]

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

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

[ "static int FUNC_0(void *VAR_0, int VAR_1)\n{", "KVMClockState *s = VAR_0;", "struct kvm_clock_data VAR_2;", "VAR_2.clock = s->clock;", "VAR_2.flags = 0;", "return kvm_vm_ioctl(kvm_state, KVM_SET_CLOCK, &VAR_2);", "}" ]

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

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

[ "static void FUNC_0(TCGContext *VAR_0, const TCGArg *VAR_1, bool VAR_2)\n{", "TCGReg datalo, datahi, addrlo, rbase;", "TCGReg addrhi __attribute__((unused));", "TCGMemOpIdx oi;", "TCGMemOp opc, s_bits;", "#ifdef CONFIG_SOFTMMU\nint mem_index;", "tcg_insn_unit *label_ptr;", "#endif\ndatalo = *VAR_1++;", "datahi = (TCG_TARGET_REG_BITS == 32 && VAR_2 ? *VAR_1++ : 0);", "addrlo = *VAR_1++;", "addrhi = (TCG_TARGET_REG_BITS < TARGET_LONG_BITS ? *VAR_1++ : 0);", "oi = *VAR_1++;", "opc = get_memop(oi);", "s_bits = opc & MO_SIZE;", "#ifdef CONFIG_SOFTMMU\nmem_index = get_mmuidx(oi);", "addrlo = tcg_out_tlb_read(VAR_0, s_bits, addrlo, addrhi, mem_index, false);", "label_ptr = VAR_0->code_ptr;", "tcg_out_bc_noaddr(VAR_0, BC | BI(7, CR_EQ) | BO_COND_FALSE | LK);", "rbase = TCG_REG_R3;", "#else\nrbase = GUEST_BASE ? TCG_GUEST_BASE_REG : 0;", "if (TCG_TARGET_REG_BITS > TARGET_LONG_BITS) {", "tcg_out_ext32u(VAR_0, TCG_REG_TMP1, addrlo);", "addrlo = TCG_REG_TMP1;", "}", "#endif\nif (TCG_TARGET_REG_BITS == 32 && s_bits == MO_64) {", "if (opc & MO_BSWAP) {", "tcg_out32(VAR_0, ADDI | TAI(TCG_REG_R0, addrlo, 4));", "tcg_out32(VAR_0, STWBRX | SAB(datalo, rbase, addrlo));", "tcg_out32(VAR_0, STWBRX | SAB(datahi, rbase, TCG_REG_R0));", "} else if (rbase != 0) {", "tcg_out32(VAR_0, ADDI | TAI(TCG_REG_R0, addrlo, 4));", "tcg_out32(VAR_0, STWX | SAB(datahi, rbase, addrlo));", "tcg_out32(VAR_0, STWX | SAB(datalo, rbase, TCG_REG_R0));", "} else {", "tcg_out32(VAR_0, STW | TAI(datahi, addrlo, 0));", "tcg_out32(VAR_0, STW | TAI(datalo, addrlo, 4));", "}", "} else {", "uint32_t insn = qemu_stx_opc[opc & (MO_BSWAP | MO_SIZE)];", "if (!HAVE_ISA_2_06 && insn == STDBRX) {", "tcg_out32(VAR_0, STWBRX | SAB(datalo, rbase, addrlo));", "tcg_out32(VAR_0, ADDI | TAI(TCG_REG_TMP1, addrlo, 4));", "tcg_out_shri64(VAR_0, TCG_REG_R0, datalo, 32);", "tcg_out32(VAR_0, STWBRX | SAB(TCG_REG_R0, rbase, TCG_REG_TMP1));", "} else {", "tcg_out32(VAR_0, insn | SAB(datalo, rbase, addrlo));", "}", "}", "#ifdef CONFIG_SOFTMMU\nadd_qemu_ldst_label(VAR_0, false, oi, datalo, datahi, addrlo, addrhi,\nVAR_0->code_ptr, label_ptr);", "#endif\n}" ]

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

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

[ "static int FUNC_0(AVSubtitle *VAR_0,\nconst uint8_t *VAR_1, int VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;", "int VAR_13, VAR_14, VAR_15 = 0;", "const uint8_t *VAR_16 = 0;", "uint8_t colormap[4], alpha[256];", "int VAR_17;", "int VAR_18;", "int VAR_19 = 0;", "if (VAR_2 < 10)\nreturn -1;", "VAR_0->rects = NULL;", "VAR_0->num_rects = 0;", "VAR_0->format = 0;", "VAR_0->start_display_time = 0;", "VAR_0->end_display_time = 0;", "if (AV_RB16(VAR_1) == 0) {", "VAR_13 = 1;", "VAR_14 = 4;", "VAR_3 = 6;", "} else {", "VAR_13 = 0;", "VAR_14 = 2;", "VAR_3 = 2;", "}", "VAR_3 = READ_OFFSET(VAR_1 + VAR_3);", "while ((VAR_3 + 2 + VAR_14) < VAR_2) {", "VAR_17 = AV_RB16(VAR_1 + VAR_3);", "VAR_12 = READ_OFFSET(VAR_1 + VAR_3 + 2);", "dprintf(NULL, \"VAR_3=0x%04x next=0x%04x VAR_17=%d\\n\",\nVAR_3, VAR_12, VAR_17);", "VAR_4 = VAR_3 + 2 + VAR_14;", "VAR_10 = -1;", "VAR_11 = -1;", "VAR_6 = VAR_7 = VAR_8 = VAR_9 = 0;", "while (VAR_4 < VAR_2) {", "VAR_5 = VAR_1[VAR_4++];", "dprintf(NULL, \"VAR_5=%02x\\n\", VAR_5);", "switch(VAR_5) {", "case 0x00:\nVAR_19 = 1;", "break;", "case 0x01:\nVAR_0->start_display_time = (VAR_17 << 10) / 90;", "break;", "case 0x02:\nVAR_0->end_display_time = (VAR_17 << 10) / 90;", "break;", "case 0x03:\nif ((VAR_2 - VAR_4) < 2)\ngoto fail;", "colormap[3] = VAR_1[VAR_4] >> 4;", "colormap[2] = VAR_1[VAR_4] & 0x0f;", "colormap[1] = VAR_1[VAR_4 + 1] >> 4;", "colormap[0] = VAR_1[VAR_4 + 1] & 0x0f;", "VAR_4 += 2;", "break;", "case 0x04:\nif ((VAR_2 - VAR_4) < 2)\ngoto fail;", "alpha[3] = VAR_1[VAR_4] >> 4;", "alpha[2] = VAR_1[VAR_4] & 0x0f;", "alpha[1] = VAR_1[VAR_4 + 1] >> 4;", "alpha[0] = VAR_1[VAR_4 + 1] & 0x0f;", "VAR_4 += 2;", "dprintf(NULL, \"alpha=%x%x%x%x\\n\", alpha[0],alpha[1],alpha[2],alpha[3]);", "break;", "case 0x05:\ncase 0x85:\nif ((VAR_2 - VAR_4) < 6)\ngoto fail;", "VAR_6 = (VAR_1[VAR_4] << 4) | (VAR_1[VAR_4 + 1] >> 4);", "VAR_8 = ((VAR_1[VAR_4 + 1] & 0x0f) << 8) | VAR_1[VAR_4 + 2];", "VAR_7 = (VAR_1[VAR_4 + 3] << 4) | (VAR_1[VAR_4 + 4] >> 4);", "VAR_9 = ((VAR_1[VAR_4 + 4] & 0x0f) << 8) | VAR_1[VAR_4 + 5];", "if (VAR_5 & 0x80)\nVAR_15 = 1;", "dprintf(NULL, \"VAR_6=%d VAR_8=%d VAR_7=%d VAR_9=%d\\n\", VAR_6, VAR_8, VAR_7, VAR_9);", "VAR_4 += 6;", "break;", "case 0x06:\nif ((VAR_2 - VAR_4) < 4)\ngoto fail;", "VAR_10 = AV_RB16(VAR_1 + VAR_4);", "VAR_11 = AV_RB16(VAR_1 + VAR_4 + 2);", "dprintf(NULL, \"VAR_10=0x%04x VAR_11=0x%04x\\n\", VAR_10, VAR_11);", "VAR_4 += 4;", "break;", "case 0x86:\nif ((VAR_2 - VAR_4) < 8)\ngoto fail;", "VAR_10 = AV_RB32(VAR_1 + VAR_4);", "VAR_11 = AV_RB32(VAR_1 + VAR_4 + 4);", "dprintf(NULL, \"VAR_10=0x%04x VAR_11=0x%04x\\n\", VAR_10, VAR_11);", "VAR_4 += 8;", "break;", "case 0x83:\nif ((VAR_2 - VAR_4) < 768)\ngoto fail;", "VAR_16 = VAR_1 + VAR_4;", "VAR_4 += 768;", "break;", "case 0x84:\nif ((VAR_2 - VAR_4) < 256)\ngoto fail;", "for (VAR_18 = 0; VAR_18 < 256; VAR_18++)", "alpha[VAR_18] = 0xFF - VAR_1[VAR_4+VAR_18];", "VAR_4 += 256;", "break;", "case 0xff:\ngoto the_end;", "default:\ndprintf(NULL, \"unrecognised subpicture command 0x%x\\n\", VAR_5);", "goto the_end;", "}", "}", "the_end:\nif (VAR_10 >= 0) {", "int VAR_20, VAR_21;", "uint8_t *bitmap;", "VAR_20 = VAR_8 - VAR_6 + 1;", "if (VAR_20 < 0)\nVAR_20 = 0;", "VAR_21 = VAR_9 - VAR_7;", "if (VAR_21 < 0)\nVAR_21 = 0;", "if (VAR_20 > 0 && VAR_21 > 0) {", "if (VAR_0->rects != NULL) {", "for (VAR_18 = 0; VAR_18 < VAR_0->num_rects; VAR_18++) {", "av_freep(&VAR_0->rects[VAR_18]->pict.data[0]);", "av_freep(&VAR_0->rects[VAR_18]->pict.data[1]);", "av_freep(&VAR_0->rects[VAR_18]);", "}", "av_freep(&VAR_0->rects);", "VAR_0->num_rects = 0;", "}", "bitmap = av_malloc(VAR_20 * VAR_21);", "VAR_0->rects = av_mallocz(sizeof(*VAR_0->rects));", "VAR_0->rects[0] = av_mallocz(sizeof(AVSubtitleRect));", "VAR_0->num_rects = 1;", "VAR_0->rects[0]->pict.data[0] = bitmap;", "decode_rle(bitmap, VAR_20 * 2, VAR_20, (VAR_21 + 1) / 2,\nVAR_1, VAR_10, VAR_2, VAR_15);", "decode_rle(bitmap + VAR_20, VAR_20 * 2, VAR_20, VAR_21 / 2,\nVAR_1, VAR_11, VAR_2, VAR_15);", "if (VAR_15) {", "if (VAR_16 == 0)\ngoto fail;", "VAR_0->rects[0]->pict.data[1] = av_malloc(256 * 4);", "VAR_0->rects[0]->nb_colors = 256;", "yuv_a_to_rgba(VAR_16, alpha, (uint32_t*)VAR_0->rects[0]->pict.data[1], 256);", "} else {", "VAR_0->rects[0]->pict.data[1] = av_malloc(4 * 4);", "VAR_0->rects[0]->nb_colors = 4;", "guess_palette((uint32_t*)VAR_0->rects[0]->pict.data[1],\ncolormap, alpha, 0xffff00);", "}", "VAR_0->rects[0]->x = VAR_6;", "VAR_0->rects[0]->y = VAR_7;", "VAR_0->rects[0]->VAR_20 = VAR_20;", "VAR_0->rects[0]->VAR_21 = VAR_21;", "VAR_0->rects[0]->type = SUBTITLE_BITMAP;", "VAR_0->rects[0]->pict.linesize[0] = VAR_20;", "}", "}", "if (VAR_12 == VAR_3)\nbreak;", "VAR_3 = VAR_12;", "}", "if (VAR_0->num_rects > 0)\nreturn VAR_19;", "fail:\nif (VAR_0->rects != NULL) {", "for (VAR_18 = 0; VAR_18 < VAR_0->num_rects; VAR_18++) {", "av_freep(&VAR_0->rects[VAR_18]->pict.data[0]);", "av_freep(&VAR_0->rects[VAR_18]->pict.data[1]);", "av_freep(&VAR_0->rects[VAR_18]);", "}", "av_freep(&VAR_0->rects);", "VAR_0->num_rects = 0;", "}", "return -1;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89, 93 ], [ 95 ], [ 97, 101 ], [ 103 ], [ 105, 109 ], [ 111 ], [ 113, 117, 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133, 137, 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155, 157, 159, 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171, 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181, 183, 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197, 199, 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 215, 219, 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229, 233, 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 247, 249 ], [ 251, 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261, 263 ], [ 265 ], [ 267 ], [ 273 ], [ 275, 277 ], [ 279 ], [ 281, 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317, 319 ], [ 321, 323 ], [ 325 ], [ 327, 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343, 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365, 367 ], [ 369 ], [ 371 ], [ 373, 375 ], [ 377, 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ] ]

[ "int FUNC_0(struct vaapi_context *VAR_0, VASurfaceID VAR_1)\n{", "VABufferID va_buffers[3];", "unsigned int VAR_2 = 0;", "vaUnmapBuffer(VAR_0->display, VAR_0->pic_param_buf_id);", "va_buffers[VAR_2++] = VAR_0->pic_param_buf_id;", "if (VAR_0->iq_matrix_buf_id) {", "vaUnmapBuffer(VAR_0->display, VAR_0->iq_matrix_buf_id);", "va_buffers[VAR_2++] = VAR_0->iq_matrix_buf_id;", "}", "if (VAR_0->bitplane_buf_id) {", "vaUnmapBuffer(VAR_0->display, VAR_0->bitplane_buf_id);", "va_buffers[VAR_2++] = VAR_0->bitplane_buf_id;", "}", "if (vaBeginPicture(VAR_0->display, VAR_0->context_id,\nVAR_1) != VA_STATUS_SUCCESS)\nreturn -1;", "if (vaRenderPicture(VAR_0->display, VAR_0->context_id,\nva_buffers, VAR_2) != VA_STATUS_SUCCESS)\nreturn -1;", "if (vaRenderPicture(VAR_0->display, VAR_0->context_id,\nVAR_0->slice_buf_ids,\nVAR_0->n_slice_buf_ids) != VA_STATUS_SUCCESS)\nreturn -1;", "if (vaEndPicture(VAR_0->display, VAR_0->context_id) != VA_STATUS_SUCCESS)\nreturn -1;", "}" ]

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

[ "static av_cold int FUNC_0(AVFormatContext *s)\n{", "XCBGrabContext *c = s->priv_data;", "int VAR_0, VAR_1;", "const xcb_setup_t *VAR_2;", "char *VAR_3 = s->filename[0] ? s->filename : NULL;", "const char *VAR_4 = strchr(s->filename, '+');", "if (VAR_4) {", "sscanf(VAR_4, \"%d,%d\", &c->x, &c->y);", "VAR_3 = av_strdup(s->filename);", "VAR_3[VAR_4 - s->filename] = '\\0';", "}", "c->conn = xcb_connect(VAR_3, &VAR_0);", "if (VAR_4)\nav_free(VAR_3);", "if ((VAR_1 = xcb_connection_has_error(c->conn))) {", "av_log(s, AV_LOG_ERROR, \"Cannot open display %s, error %d.\\n\",\ns->filename[0] ? VAR_3 : \"default\", VAR_1);", "return AVERROR(EIO);", "}", "VAR_2 = xcb_get_setup(c->conn);", "c->screen = get_screen(VAR_2, VAR_0);", "if (!c->screen) {", "av_log(s, AV_LOG_ERROR, \"The screen %d does not exist.\\n\",\nVAR_0);", "xcbgrab_read_close(s);", "return AVERROR(EIO);", "}", "VAR_1 = create_stream(s);", "if (VAR_1 < 0) {", "xcbgrab_read_close(s);", "return VAR_1;", "}", "#if CONFIG_LIBXCB_SHM\nif ((c->has_shm = check_shm(c->conn)))\nc->segment = xcb_generate_id(c->conn);", "#endif\n#if CONFIG_LIBXCB_XFIXES\nif (c->draw_mouse) {", "if (!(c->draw_mouse = check_xfixes(c->conn))) {", "av_log(s, AV_LOG_WARNING,\n\"XFixes not available, cannot draw the mouse.\\n\");", "}", "if (c->bpp < 24) {", "avpriv_report_missing_feature(s, \"%d bits per pixel screen\",\nc->bpp);", "c->draw_mouse = 0;", "}", "}", "#endif\nif (c->show_region)\nsetup_window(s);", "return 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 ]

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

[ "static int FUNC_0(AVCodecContext *VAR_0)\n{", "DDSContext *ctx = VAR_0->priv_data;", "GetByteContext *gbc = &ctx->gbc;", "char VAR_1[32];", "uint32_t flags, fourcc, gimp_tag;", "enum DDSDXGIFormat VAR_2;", "int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8;", "int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13;", "bytestream2_skip(gbc, 4 * 3);", "gimp_tag = bytestream2_get_le32(gbc);", "VAR_9 = gimp_tag == MKTAG('A', 'E', 'X', 'P');", "VAR_10 = gimp_tag == MKTAG('Y', 'C', 'G', '1');", "VAR_11 = gimp_tag == MKTAG('Y', 'C', 'G', '2');", "bytestream2_skip(gbc, 4 * 7);", "VAR_3 = bytestream2_get_le32(gbc);", "if (VAR_3 != 32) {", "av_log(VAR_0, AV_LOG_ERROR, \"Invalid pixel format header %d.\\n\", VAR_3);", "return AVERROR_INVALIDDATA;", "flags = bytestream2_get_le32(gbc);", "ctx->compressed = flags & DDPF_FOURCC;", "ctx->paletted = flags & DDPF_PALETTE;", "VAR_12 = flags & DDPF_NORMALMAP;", "fourcc = bytestream2_get_le32(gbc);", "VAR_4 = bytestream2_get_le32(gbc);", "VAR_5 = bytestream2_get_le32(gbc);", "VAR_6 = bytestream2_get_le32(gbc);", "VAR_7 = bytestream2_get_le32(gbc);", "VAR_8 = bytestream2_get_le32(gbc);", "bytestream2_skip(gbc, 4);", "bytestream2_skip(gbc, 4); 2", "bytestream2_skip(gbc, 4); 3", "bytestream2_skip(gbc, 4); 4", "bytestream2_skip(gbc, 4);", "av_get_codec_tag_string(VAR_1, sizeof(VAR_1), fourcc);", "av_log(VAR_0, AV_LOG_VERBOSE, \"fourcc %s VAR_4 %d \"\n\"VAR_5 0x%x VAR_6 0x%x VAR_7 0x%x VAR_8 0x%x\\n\", VAR_1, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8);", "if (gimp_tag) {", "av_get_codec_tag_string(VAR_1, sizeof(VAR_1), gimp_tag);", "av_log(VAR_0, AV_LOG_VERBOSE, \"and GIMP-DDS tag %s\\n\", VAR_1);", "if (ctx->compressed)\nVAR_0->pix_fmt = AV_PIX_FMT_RGBA;", "if (ctx->compressed) {", "switch (fourcc) {", "case MKTAG('D', 'X', 'T', '1'):\nctx->tex_ratio = 8;", "ctx->tex_funct = ctx->texdsp.dxt1a_block;", "break;", "case MKTAG('D', 'X', 'T', '2'):\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.dxt2_block;", "break;", "case MKTAG('D', 'X', 'T', '3'):\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.dxt3_block;", "break;", "case MKTAG('D', 'X', 'T', '4'):\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.dxt4_block;", "break;", "case MKTAG('D', 'X', 'T', '5'):\nctx->tex_ratio = 16;", "if (VAR_11)\nctx->tex_funct = ctx->texdsp.dxt5ys_block;", "else if (VAR_10)\nctx->tex_funct = ctx->texdsp.dxt5y_block;", "else\nctx->tex_funct = ctx->texdsp.dxt5_block;", "break;", "case MKTAG('R', 'X', 'G', 'B'):\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.dxt5_block;", "ctx->postproc = DDS_SWIZZLE_RXGB;", "VAR_12 = 0;", "break;", "case MKTAG('A', 'T', 'I', '1'):\ncase MKTAG('B', 'C', '4', 'U'):\nctx->tex_ratio = 8;", "ctx->tex_funct = ctx->texdsp.rgtc1u_block;", "break;", "case MKTAG('B', 'C', '4', 'S'):\nctx->tex_ratio = 8;", "ctx->tex_funct = ctx->texdsp.rgtc1s_block;", "break;", "case MKTAG('A', 'T', 'I', '2'):\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.dxn3dc_block;", "break;", "case MKTAG('B', 'C', '5', 'U'):\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.rgtc2u_block;", "break;", "case MKTAG('B', 'C', '5', 'S'):\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.rgtc2s_block;", "break;", "case MKTAG('U', 'Y', 'V', 'Y'):\nctx->compressed = 0;", "VAR_0->pix_fmt = AV_PIX_FMT_UYVY422;", "break;", "case MKTAG('Y', 'U', 'Y', '2'):\nctx->compressed = 0;", "VAR_0->pix_fmt = AV_PIX_FMT_YUYV422;", "break;", "case MKTAG('P', '8', ' ', ' '):\nctx->compressed = 0;", "ctx->paletted = 1;", "VAR_0->pix_fmt = AV_PIX_FMT_PAL8;", "break;", "case MKTAG('D', 'X', '1', '0'):\nVAR_2 = bytestream2_get_le32(gbc);", "bytestream2_skip(gbc, 4);", "bytestream2_skip(gbc, 4);", "VAR_13 = bytestream2_get_le32(gbc);", "bytestream2_skip(gbc, 4); 2", "if (VAR_13 != 0)\nav_log(VAR_0, AV_LOG_VERBOSE,\n\"Found VAR_13 of VAR_3 %d (ignored).\\n\", VAR_13);", "ctx->compressed = (VAR_2 >= 70) && (VAR_2 <= 84);", "av_log(VAR_0, AV_LOG_VERBOSE, \"DXGI format %d.\\n\", VAR_2);", "switch (VAR_2) {", "case DXGI_FORMAT_R16G16B16A16_TYPELESS:\ncase DXGI_FORMAT_R16G16B16A16_FLOAT:\ncase DXGI_FORMAT_R16G16B16A16_UNORM:\ncase DXGI_FORMAT_R16G16B16A16_UINT:\ncase DXGI_FORMAT_R16G16B16A16_SNORM:\ncase DXGI_FORMAT_R16G16B16A16_SINT:\nVAR_0->pix_fmt = AV_PIX_FMT_BGRA64;", "break;", "case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:\nVAR_0->colorspace = AVCOL_SPC_RGB;", "case DXGI_FORMAT_R8G8B8A8_TYPELESS:\ncase DXGI_FORMAT_R8G8B8A8_UNORM:\ncase DXGI_FORMAT_R8G8B8A8_UINT:\ncase DXGI_FORMAT_R8G8B8A8_SNORM:\ncase DXGI_FORMAT_R8G8B8A8_SINT:\nVAR_0->pix_fmt = AV_PIX_FMT_BGRA;", "break;", "case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:\nVAR_0->colorspace = AVCOL_SPC_RGB;", "case DXGI_FORMAT_B8G8R8A8_TYPELESS:\ncase DXGI_FORMAT_B8G8R8A8_UNORM:\nVAR_0->pix_fmt = AV_PIX_FMT_RGBA;", "break;", "case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:\nVAR_0->colorspace = AVCOL_SPC_RGB;", "case DXGI_FORMAT_B8G8R8X8_TYPELESS:\ncase DXGI_FORMAT_B8G8R8X8_UNORM:\nVAR_0->pix_fmt = AV_PIX_FMT_RGBA;", "break;", "case DXGI_FORMAT_B5G6R5_UNORM:\nVAR_0->pix_fmt = AV_PIX_FMT_RGB565LE;", "break;", "case DXGI_FORMAT_BC1_UNORM_SRGB:\nVAR_0->colorspace = AVCOL_SPC_RGB;", "case DXGI_FORMAT_BC1_TYPELESS:\ncase DXGI_FORMAT_BC1_UNORM:\nctx->tex_ratio = 8;", "ctx->tex_funct = ctx->texdsp.dxt1a_block;", "break;", "case DXGI_FORMAT_BC2_UNORM_SRGB:\nVAR_0->colorspace = AVCOL_SPC_RGB;", "case DXGI_FORMAT_BC2_TYPELESS:\ncase DXGI_FORMAT_BC2_UNORM:\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.dxt3_block;", "break;", "case DXGI_FORMAT_BC3_UNORM_SRGB:\nVAR_0->colorspace = AVCOL_SPC_RGB;", "case DXGI_FORMAT_BC3_TYPELESS:\ncase DXGI_FORMAT_BC3_UNORM:\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.dxt5_block;", "break;", "case DXGI_FORMAT_BC4_TYPELESS:\ncase DXGI_FORMAT_BC4_UNORM:\nctx->tex_ratio = 8;", "ctx->tex_funct = ctx->texdsp.rgtc1u_block;", "break;", "case DXGI_FORMAT_BC4_SNORM:\nctx->tex_ratio = 8;", "ctx->tex_funct = ctx->texdsp.rgtc1s_block;", "break;", "case DXGI_FORMAT_BC5_TYPELESS:\ncase DXGI_FORMAT_BC5_UNORM:\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.rgtc2u_block;", "break;", "case DXGI_FORMAT_BC5_SNORM:\nctx->tex_ratio = 16;", "ctx->tex_funct = ctx->texdsp.rgtc2s_block;", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR,\n\"Unsupported DXGI format %d.\\n\", VAR_2);", "return AVERROR_INVALIDDATA;", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unsupported %s fourcc.\\n\", VAR_1);", "return AVERROR_INVALIDDATA;", "} else if (ctx->paletted) {", "if (VAR_4 == 8) {", "VAR_0->pix_fmt = AV_PIX_FMT_PAL8;", "} else {", "av_log(VAR_0, AV_LOG_ERROR, \"Unsupported palette VAR_4 %d.\\n\", VAR_4);", "return AVERROR_INVALIDDATA;", "} else {", "if (VAR_4 == 8 && VAR_5 == 0xff && VAR_6 == 0 && VAR_7 == 0 && VAR_8 == 0)\nVAR_0->pix_fmt = AV_PIX_FMT_GRAY8;", "else if (VAR_4 == 16 && VAR_5 == 0xff && VAR_6 == 0 && VAR_7 == 0 && VAR_8 == 0xff00)\nVAR_0->pix_fmt = AV_PIX_FMT_YA8;", "else if (VAR_4 == 16 && VAR_5 == 0xffff && VAR_6 == 0 && VAR_7 == 0 && VAR_8 == 0)\nVAR_0->pix_fmt = AV_PIX_FMT_GRAY16LE;", "else if (VAR_4 == 16 && VAR_5 == 0xf800 && VAR_6 == 0x7e0 && VAR_7 == 0x1f && VAR_8 == 0)\nVAR_0->pix_fmt = AV_PIX_FMT_RGB565LE;", "else if (VAR_4 == 24 && VAR_5 == 0xff0000 && VAR_6 == 0xff00 && VAR_7 == 0xff && VAR_8 == 0)\nVAR_0->pix_fmt = AV_PIX_FMT_BGR24;", "else if (VAR_4 == 32 && VAR_5 == 0xff0000 && VAR_6 == 0xff00 && VAR_7 == 0xff && VAR_8 == 0)\nVAR_0->pix_fmt = AV_PIX_FMT_BGRA;", "else if (VAR_4 == 32 && VAR_5 == 0xff && VAR_6 == 0xff00 && VAR_7 == 0xff0000 && VAR_8 == 0)\nVAR_0->pix_fmt = AV_PIX_FMT_RGBA;", "else if (VAR_4 == 32 && VAR_5 == 0xff0000 && VAR_6 == 0xff00 && VAR_7 == 0xff && VAR_8 == 0xff000000)\nVAR_0->pix_fmt = AV_PIX_FMT_BGRA;", "else if (VAR_4 == 32 && VAR_5 == 0xff && VAR_6 == 0xff00 && VAR_7 == 0xff0000 && VAR_8 == 0xff000000)\nVAR_0->pix_fmt = AV_PIX_FMT_RGBA;", "else {", "av_log(VAR_0, AV_LOG_ERROR, \"Unknown pixel format \"\n\"[VAR_4 %d VAR_5 0x%x VAR_6 0x%x VAR_7 0x%x VAR_8 0x%x].\\n\", VAR_4, VAR_5, VAR_6, VAR_7, VAR_8);", "return AVERROR_INVALIDDATA;", "if (VAR_9)\nctx->postproc = DDS_ALPHA_EXP;", "else if (VAR_12)\nctx->postproc = DDS_NORMAL_MAP;", "else if (VAR_10 && !ctx->compressed)\nctx->postproc = DDS_RAW_YCOCG;", "else if (VAR_0->pix_fmt == AV_PIX_FMT_YA8)\nctx->postproc = DDS_SWAP_ALPHA;", "switch (VAR_4) {", "case MKTAG('A', '2', 'X', 'Y'):\nctx->postproc = DDS_SWIZZLE_A2XY;", "break;", "case MKTAG('x', 'G', 'B', 'R'):\nctx->postproc = DDS_SWIZZLE_XGBR;", "break;", "case MKTAG('x', 'R', 'B', 'G'):\nctx->postproc = DDS_SWIZZLE_XRBG;", "break;", "case MKTAG('R', 'B', 'x', 'G'):\nctx->postproc = DDS_SWIZZLE_RBXG;", "break;", "case MKTAG('R', 'G', 'x', 'B'):\nctx->postproc = DDS_SWIZZLE_RGXB;", "break;", "case MKTAG('R', 'x', 'B', 'G'):\nctx->postproc = DDS_SWIZZLE_RXBG;", "break;", "case MKTAG('x', 'G', 'x', 'R'):\nctx->postproc = DDS_SWIZZLE_XGXR;", "break;", "case MKTAG('A', '2', 'D', '5'):\nctx->postproc = DDS_NORMAL_MAP;", "break;", "return 0;" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 28 ], [ 29 ], [ 30 ], [ 31 ], [ 32 ], [ 33 ], [ 34 ], [ 35 ], [ 36 ], [ 37 ], [ 38, 39 ], [ 40 ], [ 41 ], [ 42 ], [ 43, 44 ], [ 45 ], [ 46 ], [ 47, 48 ], [ 49 ], [ 50 ], [ 51, 52 ], [ 53 ], [ 54 ], [ 55, 56 ], [ 57 ], [ 58 ], [ 59, 60 ], [ 61 ], [ 62 ], [ 63, 64 ], [ 65, 66 ], [ 67, 68 ], [ 69, 70 ], [ 71 ], [ 72, 73 ], [ 74 ], [ 77 ], [ 78 ], [ 79 ], [ 80, 81, 82 ], [ 83 ], [ 84 ], [ 85, 86 ], [ 87 ], [ 88 ], [ 89, 91 ], [ 92 ], [ 93 ], [ 94, 95 ], [ 96 ], [ 97 ], [ 98, 99 ], [ 100 ], [ 101 ], [ 102, 103 ], [ 104 ], [ 105 ], [ 106, 107 ], [ 108 ], [ 109 ], [ 110, 112 ], [ 113 ], [ 114 ], [ 115 ], [ 116, 118 ], [ 119 ], [ 120 ], [ 121 ], [ 122 ], [ 123, 124, 125 ], [ 127 ], [ 128 ], [ 129 ], [ 131, 132, 133, 134, 135, 136, 137 ], [ 138 ], [ 139, 140 ], [ 141, 142, 143, 144, 145, 146 ], [ 147 ], [ 148, 149 ], [ 150, 151, 152 ], [ 153 ], [ 154, 155 ], [ 156, 157, 158 ], [ 159 ], [ 160, 161 ], [ 162 ], [ 164, 165 ], [ 166, 167, 168 ], [ 169 ], [ 170 ], [ 171, 172 ], [ 173, 174, 175 ], [ 176 ], [ 177 ], [ 178, 179 ], [ 180, 181, 182 ], [ 183 ], [ 184 ], [ 185, 186, 187 ], [ 188 ], [ 189 ], [ 190, 191 ], [ 192 ], [ 193 ], [ 194, 195, 196 ], [ 197 ], [ 198 ], [ 199, 200 ], [ 201 ], [ 202 ], [ 203, 204, 205 ], [ 206 ], [ 207 ], [ 208, 209 ], [ 210 ], [ 211 ], [ 212 ], [ 213 ], [ 214 ], [ 215 ], [ 216 ], [ 217 ], [ 219, 220 ], [ 222, 223 ], [ 224, 225 ], [ 226, 227 ], [ 229, 230 ], [ 232, 233 ], [ 234, 235 ], [ 236, 237 ], [ 238, 239 ], [ 241 ], [ 242, 243 ], [ 244 ], [ 246, 247 ], [ 248, 249 ], [ 250, 251 ], [ 252, 253 ], [ 255 ], [ 256, 257 ], [ 258 ], [ 259, 260 ], [ 261 ], [ 262, 263 ], [ 264 ], [ 265, 266 ], [ 267 ], [ 268, 269 ], [ 270 ], [ 271, 272 ], [ 273 ], [ 274, 275 ], [ 276 ], [ 277, 278 ], [ 279 ], [ 280 ] ]

[ "static int FUNC_0(void *VAR_0, const AVOption *VAR_1, void *VAR_2, double VAR_3, int VAR_4, int64_t VAR_5)\n{", "if (VAR_1->max*VAR_4 < VAR_3*VAR_5 || VAR_1->min*VAR_4 > VAR_3*VAR_5) {", "av_log(VAR_0, AV_LOG_ERROR, \"Value %f for parameter '%s' out of range\\n\",\nVAR_3*VAR_5/VAR_4, VAR_1->name);", "return AVERROR(ERANGE);", "}", "switch (VAR_1->type) {", "case AV_OPT_TYPE_FLAGS:\ncase AV_OPT_TYPE_INT: *(int *)VAR_2= llrint(VAR_3/VAR_4)*VAR_5; break;", "case AV_OPT_TYPE_INT64: *(int64_t *)VAR_2= llrint(VAR_3/VAR_4)*VAR_5; break;", "case AV_OPT_TYPE_FLOAT: *(float *)VAR_2= VAR_3*VAR_5/VAR_4; break;", "case AV_OPT_TYPE_DOUBLE:*(double *)VAR_2= VAR_3*VAR_5/VAR_4; break;", "case AV_OPT_TYPE_RATIONAL:\nif ((int)VAR_3 == VAR_3) *(AVRational*)VAR_2= (AVRational){VAR_3*VAR_5, VAR_4};", "else *(AVRational*)VAR_2= av_d2q(VAR_3*VAR_5/VAR_4, 1<<24);", "break;", "default:\nreturn AVERROR(EINVAL);", "}", "return 0;", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque, hwaddr addr, unsigned size)\n{", "MIPSITUState *tag = (MIPSITUState *)opaque;", "uint64_t index = addr >> 3;", "uint64_t ret = 0;", "switch (index) {", "case 0 ... ITC_ADDRESSMAP_NUM:\nret = tag->ITCAddressMap[index];", "break;", "default:\nqemu_log_mask(LOG_GUEST_ERROR, \"Read 0x%\" PRIx64 \"\\n\", addr);", "break;", "}", "return ret;", "}" ]

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

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

[ "static int FUNC_0(RV34DecContext *VAR_0, int VAR_1, int VAR_2)\n{", "int VAR_3 = VAR_1 ? -VAR_0->mv_weight2 : VAR_0->mv_weight1;", "return (VAR_2 * VAR_3 + 0x2000) >> 14;", "}" ]

[ 0, 0, 1, 0 ]

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

[ "static void FUNC_0(uint8_t *VAR_0, int VAR_1, int VAR_2, const int *VAR_3)\n{", "PutBitContext pb;", "int VAR_4, VAR_5 = ~0, VAR_6 = VAR_2, VAR_7 = 0;", "init_put_bits(&pb, VAR_0, VAR_1 * 8);", "while (VAR_6 > 0) {", "VAR_4 = VAR_3[VAR_7++];", "VAR_5 = ~VAR_5;", "VAR_6 -= VAR_4;", "for (; VAR_4 > 16; VAR_4 -= 16)", "put_sbits(&pb, 16, VAR_5);", "if (VAR_4)\nput_sbits(&pb, VAR_4, VAR_5);", "}", "flush_put_bits(&pb);", "}" ]

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

[ "int FUNC_0(uint8_t *VAR_0[4], int VAR_1[4],\nint *VAR_2, int *VAR_3, enum PixelFormat *VAR_4,\nconst char *VAR_5, void *VAR_6)\n{", "AVInputFormat *iformat = NULL;", "AVFormatContext *format_ctx;", "AVCodec *codec;", "AVCodecContext *codec_ctx;", "AVFrame *frame;", "int VAR_7, VAR_8 = 0;", "AVPacket pkt;", "av_register_all();", "iformat = av_find_input_format(\"image2\");", "if ((VAR_8 = avformat_open_input(&format_ctx, VAR_5, iformat, NULL)) < 0) {", "av_log(VAR_6, AV_LOG_ERROR,\n\"Failed to open input file '%s'\\n\", VAR_5);", "return VAR_8;", "}", "codec_ctx = format_ctx->streams[0]->codec;", "codec = avcodec_find_decoder(codec_ctx->codec_id);", "if (!codec) {", "av_log(VAR_6, AV_LOG_ERROR, \"Failed to find codec\\n\");", "VAR_8 = AVERROR(EINVAL);", "goto end;", "}", "if ((VAR_8 = avcodec_open2(codec_ctx, codec, NULL)) < 0) {", "av_log(VAR_6, AV_LOG_ERROR, \"Failed to open codec\\n\");", "goto end;", "}", "if (!(frame = avcodec_alloc_frame()) ) {", "av_log(VAR_6, AV_LOG_ERROR, \"Failed to alloc frame\\n\");", "VAR_8 = AVERROR(ENOMEM);", "goto end;", "}", "VAR_8 = av_read_frame(format_ctx, &pkt);", "if (VAR_8 < 0) {", "av_log(VAR_6, AV_LOG_ERROR, \"Failed to read frame from file\\n\");", "goto end;", "}", "VAR_8 = avcodec_decode_video2(codec_ctx, frame, &VAR_7, &pkt);", "if (VAR_8 < 0 || !VAR_7) {", "av_log(VAR_6, AV_LOG_ERROR, \"Failed to decode image from file\\n\");", "goto end;", "}", "VAR_8 = 0;", "*VAR_2 = frame->width;", "*VAR_3 = frame->height;", "*VAR_4 = frame->format;", "if ((VAR_8 = av_image_alloc(VAR_0, VAR_1, *VAR_2, *VAR_3, *VAR_4, 16)) < 0)\ngoto end;", "VAR_8 = 0;", "av_image_copy(VAR_0, VAR_1, frame->VAR_0, frame->VAR_1, *VAR_4, *VAR_2, *VAR_3);", "end:\nif (codec_ctx)\navcodec_close(codec_ctx);", "if (format_ctx)\navformat_close_input(&format_ctx);", "av_freep(&frame);", "if (VAR_8 < 0)\nav_log(VAR_6, AV_LOG_ERROR, \"Error loading image file '%s'\\n\", VAR_5);", "return VAR_8;", "}" ]

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

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

[ "void FUNC_0(MpegEncContext *VAR_0)\n{", "H264Context *h = VAR_0->avctx->priv_data;", "struct vdpau_render_state *VAR_1;", "int VAR_2;", "VAR_1 = (struct vdpau_render_state *)VAR_0->current_picture_ptr->data[0];", "assert(VAR_1);", "VAR_1->info.h264.slice_count = h->slice_num;", "if (VAR_1->info.h264.slice_count < 1)\nreturn;", "for (VAR_2 = 0; VAR_2 < 2; ++VAR_2) {", "int VAR_3 = VAR_0->current_picture_ptr->field_poc[VAR_2];", "if (VAR_3 == INT_MAX)\nVAR_3 = 0;", "VAR_1->info.h264.field_order_cnt[VAR_2] = VAR_3;", "}", "VAR_1->info.h264.is_reference = (VAR_0->current_picture_ptr->reference & 3) ? VDP_TRUE : VDP_FALSE;", "VAR_1->info.h264.frame_num = h->frame_num;", "VAR_1->info.h264.field_pic_flag = VAR_0->picture_structure != PICT_FRAME;", "VAR_1->info.h264.bottom_field_flag = VAR_0->picture_structure == PICT_BOTTOM_FIELD;", "VAR_1->info.h264.num_ref_frames = h->sps.ref_frame_count;", "VAR_1->info.h264.mb_adaptive_frame_field_flag = h->sps.mb_aff && !VAR_1->info.h264.field_pic_flag;", "VAR_1->info.h264.constrained_intra_pred_flag = h->pps.constrained_intra_pred;", "VAR_1->info.h264.weighted_pred_flag = h->pps.weighted_pred;", "VAR_1->info.h264.weighted_bipred_idc = h->pps.weighted_bipred_idc;", "VAR_1->info.h264.frame_mbs_only_flag = h->sps.frame_mbs_only_flag;", "VAR_1->info.h264.transform_8x8_mode_flag = h->pps.transform_8x8_mode;", "VAR_1->info.h264.chroma_qp_index_offset = h->pps.chroma_qp_index_offset[0];", "VAR_1->info.h264.second_chroma_qp_index_offset = h->pps.chroma_qp_index_offset[1];", "VAR_1->info.h264.pic_init_qp_minus26 = h->pps.init_qp - 26;", "VAR_1->info.h264.num_ref_idx_l0_active_minus1 = h->pps.ref_count[0] - 1;", "VAR_1->info.h264.num_ref_idx_l1_active_minus1 = h->pps.ref_count[1] - 1;", "VAR_1->info.h264.log2_max_frame_num_minus4 = h->sps.log2_max_frame_num - 4;", "VAR_1->info.h264.pic_order_cnt_type = h->sps.poc_type;", "VAR_1->info.h264.log2_max_pic_order_cnt_lsb_minus4 = h->sps.log2_max_poc_lsb - 4;", "VAR_1->info.h264.delta_pic_order_always_zero_flag = h->sps.delta_pic_order_always_zero_flag;", "VAR_1->info.h264.direct_8x8_inference_flag = h->sps.direct_8x8_inference_flag;", "VAR_1->info.h264.entropy_coding_mode_flag = h->pps.cabac;", "VAR_1->info.h264.pic_order_present_flag = h->pps.pic_order_present;", "VAR_1->info.h264.deblocking_filter_control_present_flag = h->pps.deblocking_filter_parameters_present;", "VAR_1->info.h264.redundant_pic_cnt_present_flag = h->pps.redundant_pic_cnt_present;", "memcpy(VAR_1->info.h264.scaling_lists_4x4, h->pps.scaling_matrix4, sizeof(VAR_1->info.h264.scaling_lists_4x4));", "memcpy(VAR_1->info.h264.scaling_lists_8x8, h->pps.scaling_matrix8, sizeof(VAR_1->info.h264.scaling_lists_8x8));", "ff_draw_horiz_band(VAR_0, 0, VAR_0->avctx->height);", "VAR_1->bitstream_buffers_used = 0;", "}" ]

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

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

[ "static void FUNC_0(WriterContext *VAR_0, const char *VAR_1, long long int VAR_2)\n{", "flat_print_key_prefix(VAR_0);", "printf(\"%s=%lld\\n\", VAR_1, VAR_2);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "void FUNC_0(AVFifoBuffer *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "while (VAR_2 > 0) {", "int VAR_3 = FFMIN(VAR_0->end - VAR_0->wptr, VAR_2);", "memcpy(VAR_0->wptr, VAR_1, VAR_3);", "VAR_0->wptr += VAR_3;", "if (VAR_0->wptr >= VAR_0->end)\nVAR_0->wptr = VAR_0->buffer;", "VAR_1 += VAR_3;", "VAR_2 -= VAR_3;", "}", "}" ]

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

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

[ "static int FUNC_0(MpegTSContext *VAR_0, int VAR_1)\n{", "AVFormatContext *s = VAR_0->stream;", "uint8_t packet[TS_PACKET_SIZE];", "int VAR_2, VAR_3 = 0;", "if (avio_tell(s->pb) != VAR_0->last_pos) {", "int VAR_4;", "av_dlog(\"Skipping after seek\\n\");", "for (VAR_4 = 0; VAR_4 < NB_PID_MAX; VAR_4++) {", "if (VAR_0->pids[VAR_4] && VAR_0->pids[VAR_4]->type == MPEGTS_PES) {", "PESContext *pes = VAR_0->pids[VAR_4]->u.pes_filter.opaque;", "av_freep(&pes->buffer);", "VAR_0->pids[VAR_4]->last_cc = -1;", "pes->data_index = 0;", "pes->state = MPEGTS_SKIP;", "}", "}", "}", "VAR_0->stop_parse = 0;", "VAR_2 = 0;", "for(;;) {", "if (VAR_0->stop_parse>0)\nbreak;", "VAR_2++;", "if (VAR_1 != 0 && VAR_2 >= VAR_1)\nbreak;", "VAR_3 = read_packet(s, packet, VAR_0->raw_packet_size);", "if (VAR_3 != 0)\nbreak;", "VAR_3 = handle_packet(VAR_0, packet);", "if (VAR_3 != 0)\nbreak;", "}", "VAR_0->last_pos = avio_tell(s->pb);", "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 ]

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

[ "void FUNC_0( H264Context *VAR_0, int VAR_1, int VAR_2, uint8_t *VAR_3, uint8_t *VAR_4, uint8_t *VAR_5, unsigned int VAR_6, unsigned int VAR_7) {", "const int VAR_8= VAR_1 + VAR_2*VAR_0->mb_stride;", "const int VAR_9 = VAR_0->cur_pic.VAR_9[VAR_8];", "const int VAR_10 = IS_INTERLACED(VAR_9) ? 2 : 4;", "int VAR_11 = 0;", "av_unused int dir;", "int VAR_12 = !(CONFIG_GRAY && (VAR_0->flags&CODEC_FLAG_GRAY));", "int VAR_13 = 6 * (VAR_0->sps.bit_depth_luma - 8);", "int VAR_14 = VAR_0->slice_alpha_c0_offset - VAR_13;", "int VAR_15 = VAR_0->slice_beta_offset - VAR_13;", "if (FRAME_MBAFF(VAR_0)\n&& IS_INTERLACED(VAR_9^VAR_0->left_type[LTOP])\n&& VAR_0->left_type[LTOP]) {", "DECLARE_ALIGNED(8, int16_t, bS)[8];", "int VAR_16[2];", "int VAR_17[2];", "int VAR_18[2];", "int VAR_19, VAR_20, VAR_21;", "int VAR_28;", "VAR_11 = 1;", "if( IS_INTRA(VAR_9) ) {", "AV_WN64A(&bS[0], 0x0004000400040004ULL);", "AV_WN64A(&bS[4], 0x0004000400040004ULL);", "} else {", "static const uint8_t VAR_23[2][2][8]={", "{", "{3+4*0, 3+4*0, 3+4*0, 3+4*0, 3+4*1, 3+4*1, 3+4*1, 3+4*1},", "{3+4*2, 3+4*2, 3+4*2, 3+4*2, 3+4*3, 3+4*3, 3+4*3, 3+4*3},", "},{", "{3+4*0, 3+4*1, 3+4*2, 3+4*3, 3+4*0, 3+4*1, 3+4*2, 3+4*3},", "{3+4*0, 3+4*1, 3+4*2, 3+4*3, 3+4*0, 3+4*1, 3+4*2, 3+4*3},", "}", "};", "const uint8_t *VAR_24= VAR_23[MB_FIELD(VAR_0)][VAR_2&1];", "for( VAR_28 = 0; VAR_28 < 8; VAR_28++ ) {", "int VAR_25= MB_FIELD(VAR_0) ? VAR_28>>2 : VAR_28&1;", "int VAR_26 = VAR_0->left_mb_xy[LEFT(VAR_25)];", "int VAR_27= VAR_0->left_type[LEFT(VAR_25)];", "if( IS_INTRA( VAR_27 ) )\nbS[VAR_28] = 4;", "else{", "bS[VAR_28] = 1 + !!(VAR_0->non_zero_count_cache[12+8*(VAR_28>>1)] |\n((!VAR_0->pps.cabac && IS_8x8DCT(VAR_27)) ?\n(VAR_0->cbp_table[VAR_26] & (((MB_FIELD(VAR_0) ? (VAR_28&2) : (VAR_2&1)) ? 8 : 2) << 12))\n:\nVAR_0->non_zero_count[VAR_26][ VAR_24[VAR_28] ]));", "}", "}", "}", "VAR_19 = VAR_0->cur_pic.qscale_table[VAR_8];", "VAR_20 = VAR_0->cur_pic.qscale_table[VAR_0->left_mb_xy[0]];", "VAR_21 = VAR_0->cur_pic.qscale_table[VAR_0->left_mb_xy[1]];", "VAR_16[0] = ( VAR_19 + VAR_20 + 1 ) >> 1;", "VAR_17[0] = ( get_chroma_qp( VAR_0, 0, VAR_19 ) +\nget_chroma_qp( VAR_0, 0, VAR_20 ) + 1 ) >> 1;", "VAR_18[0] = ( get_chroma_qp( VAR_0, 1, VAR_19 ) +\nget_chroma_qp( VAR_0, 1, VAR_20 ) + 1 ) >> 1;", "VAR_16[1] = ( VAR_19 + VAR_21 + 1 ) >> 1;", "VAR_17[1] = ( get_chroma_qp( VAR_0, 0, VAR_19 ) +\nget_chroma_qp( VAR_0, 0, VAR_21 ) + 1 ) >> 1;", "VAR_18[1] = ( get_chroma_qp( VAR_0, 1, VAR_19 ) +\nget_chroma_qp( VAR_0, 1, VAR_21 ) + 1 ) >> 1;", "tprintf(VAR_0->avctx, \"filter mb:%d/%d MBAFF, QPy:%d/%d, QPb:%d/%d QPr:%d/%d ls:%d uvls:%d\", VAR_1, VAR_2, VAR_16[0], VAR_16[1], VAR_17[0], VAR_17[1], VAR_18[0], VAR_18[1], VAR_6, VAR_7);", "{ int VAR_28; for (VAR_28 = 0; VAR_28 < 8; VAR_28++) tprintf(VAR_0->avctx, \" bS[%d]:%d\", VAR_28, bS[VAR_28]); tprintf(VAR_0->avctx, \"\\n\"); }", "if (MB_FIELD(VAR_0)) {", "filter_mb_mbaff_edgev ( VAR_0, VAR_3 , VAR_6, bS , 1, VAR_16 [0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgev ( VAR_0, VAR_3 + 8* VAR_6, VAR_6, bS+4, 1, VAR_16 [1], VAR_14, VAR_15, 1 );", "if (VAR_12){", "if (CHROMA444(VAR_0)) {", "filter_mb_mbaff_edgev ( VAR_0, VAR_4, VAR_7, bS , 1, VAR_17[0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgev ( VAR_0, VAR_4 + 8*VAR_7, VAR_7, bS+4, 1, VAR_17[1], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgev ( VAR_0, VAR_5, VAR_7, bS , 1, VAR_18[0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgev ( VAR_0, VAR_5 + 8*VAR_7, VAR_7, bS+4, 1, VAR_18[1], VAR_14, VAR_15, 1 );", "} else if (CHROMA422(VAR_0)) {", "filter_mb_mbaff_edgecv(VAR_0, VAR_4, VAR_7, bS , 1, VAR_17[0], VAR_14, VAR_15, 1);", "filter_mb_mbaff_edgecv(VAR_0, VAR_4 + 8*VAR_7, VAR_7, bS+4, 1, VAR_17[1], VAR_14, VAR_15, 1);", "filter_mb_mbaff_edgecv(VAR_0, VAR_5, VAR_7, bS , 1, VAR_18[0], VAR_14, VAR_15, 1);", "filter_mb_mbaff_edgecv(VAR_0, VAR_5 + 8*VAR_7, VAR_7, bS+4, 1, VAR_18[1], VAR_14, VAR_15, 1);", "}else{", "filter_mb_mbaff_edgecv( VAR_0, VAR_4, VAR_7, bS , 1, VAR_17[0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgecv( VAR_0, VAR_4 + 4*VAR_7, VAR_7, bS+4, 1, VAR_17[1], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgecv( VAR_0, VAR_5, VAR_7, bS , 1, VAR_18[0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgecv( VAR_0, VAR_5 + 4*VAR_7, VAR_7, bS+4, 1, VAR_18[1], VAR_14, VAR_15, 1 );", "}", "}", "}else{", "filter_mb_mbaff_edgev ( VAR_0, VAR_3 , 2* VAR_6, bS , 2, VAR_16 [0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgev ( VAR_0, VAR_3 + VAR_6, 2* VAR_6, bS+1, 2, VAR_16 [1], VAR_14, VAR_15, 1 );", "if (VAR_12){", "if (CHROMA444(VAR_0)) {", "filter_mb_mbaff_edgev ( VAR_0, VAR_4, 2*VAR_7, bS , 2, VAR_17[0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgev ( VAR_0, VAR_4 + VAR_7, 2*VAR_7, bS+1, 2, VAR_17[1], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgev ( VAR_0, VAR_5, 2*VAR_7, bS , 2, VAR_18[0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgev ( VAR_0, VAR_5 + VAR_7, 2*VAR_7, bS+1, 2, VAR_18[1], VAR_14, VAR_15, 1 );", "}else{", "filter_mb_mbaff_edgecv( VAR_0, VAR_4, 2*VAR_7, bS , 2, VAR_17[0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgecv( VAR_0, VAR_4 + VAR_7, 2*VAR_7, bS+1, 2, VAR_17[1], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgecv( VAR_0, VAR_5, 2*VAR_7, bS , 2, VAR_18[0], VAR_14, VAR_15, 1 );", "filter_mb_mbaff_edgecv( VAR_0, VAR_5 + VAR_7, 2*VAR_7, bS+1, 2, VAR_18[1], VAR_14, VAR_15, 1 );", "}", "}", "}", "}", "#if CONFIG_SMALL\nfor( dir = 0; dir < 2; dir++ )", "filter_mb_dir(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, dir ? 0 : VAR_11, VAR_14, VAR_15, VAR_12, dir);", "#else\nfilter_mb_dir(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_14, VAR_15, VAR_12, 0);", "filter_mb_dir(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, 0, VAR_14, VAR_15, VAR_12, 1);", "#endif\n}" ]

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

[ "DIRAC_PIXOP(put, ff_put, mmx)\nDIRAC_PIXOP(avg, ff_avg, mmx)\nDIRAC_PIXOP(avg, ff_avg, mmxext)\nvoid ff_put_dirac_pixels16_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)\n{", "if (h&3)\nff_put_dirac_pixels16_c(dst, src, stride, h);", "else\nff_put_pixels16_sse2(dst, src[0], stride, h);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static CharDriverState *FUNC_0(const char *id,\nChardevBackend *backend,\nChardevReturn *ret,\nError **errp)\n{", "const char *VAR_0 = backend->u.spicevmc->VAR_0;", "const char **VAR_1 = spice_server_char_device_recognized_subtypes();", "for (; *VAR_1 != NULL; ++VAR_1) {", "if (strcmp(VAR_0, *VAR_1) == 0) {", "break;", "}", "}", "if (*VAR_1 == NULL) {", "fprintf(stderr, \"spice-qemu-char: unsupported VAR_0: %s\\n\", VAR_0);", "print_allowed_subtypes();", "return NULL;", "}", "return chr_open(VAR_0, spice_vmc_set_fe_open);", "}" ]

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

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

[ "void FUNC_0(PcGuestInfo *VAR_0, AcpiBuildTables *VAR_1)\n{", "GArray *table_offsets;", "unsigned VAR_2, VAR_3, VAR_4;", "AcpiCpuInfo cpu;", "AcpiPmInfo pm;", "AcpiMiscInfo misc;", "AcpiMcfgInfo mcfg;", "PcPciInfo pci;", "uint8_t *u;", "acpi_get_cpu_info(&cpu);", "acpi_get_pm_info(&pm);", "acpi_get_dsdt(&misc);", "acpi_get_hotplug_info(&misc);", "acpi_get_misc_info(&misc);", "acpi_get_pci_info(&pci);", "table_offsets = g_array_new(false, true ,\nsizeof(uint32_t));", "ACPI_BUILD_DPRINTF(3, \"init ACPI VAR_1\\n\");", "bios_linker_loader_alloc(VAR_1->linker, ACPI_BUILD_TABLE_FILE,\n64 ,\nfalse );", "VAR_2 = VAR_1->table_data->len;", "build_facs(VAR_1->table_data, VAR_1->linker, VAR_0);", "VAR_3 = VAR_1->table_data->len;", "build_dsdt(VAR_1->table_data, VAR_1->linker, &misc);", "acpi_add_table(table_offsets, VAR_1->table_data);", "build_fadt(VAR_1->table_data, VAR_1->linker, &pm, VAR_2, VAR_3);", "acpi_add_table(table_offsets, VAR_1->table_data);", "build_ssdt(VAR_1->table_data, VAR_1->linker, &cpu, &pm, &misc, &pci,\nVAR_0);", "acpi_add_table(table_offsets, VAR_1->table_data);", "build_madt(VAR_1->table_data, VAR_1->linker, &cpu, VAR_0);", "acpi_add_table(table_offsets, VAR_1->table_data);", "if (misc.has_hpet) {", "build_hpet(VAR_1->table_data, VAR_1->linker);", "}", "if (VAR_0->numa_nodes) {", "acpi_add_table(table_offsets, VAR_1->table_data);", "build_srat(VAR_1->table_data, VAR_1->linker, &cpu, VAR_0);", "}", "if (acpi_get_mcfg(&mcfg)) {", "acpi_add_table(table_offsets, VAR_1->table_data);", "build_mcfg_q35(VAR_1->table_data, VAR_1->linker, &mcfg);", "}", "for (u = acpi_table_first(); u; u = acpi_table_next(u)) {", "unsigned len = acpi_table_len(u);", "acpi_add_table(table_offsets, VAR_1->table_data);", "g_array_append_vals(VAR_1->table_data, u, len);", "}", "VAR_4 = VAR_1->table_data->len;", "build_rsdt(VAR_1->table_data, VAR_1->linker, table_offsets);", "build_rsdp(VAR_1->rsdp, VAR_1->linker, VAR_4);", "acpi_align_size(VAR_1->table_data, 0x1000);", "acpi_align_size(VAR_1->linker, 0x1000);", "g_array_free(table_offsets, true);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37, 39 ], [ 41 ], [ 45, 47, 49 ], [ 63 ], [ 65 ], [ 71 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 87, 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 135 ], [ 141 ], [ 143 ], [ 149 ], [ 163 ], [ 167 ], [ 173 ], [ 175 ] ]

[ "static uint32_t FUNC_0(void *opaque, uint32_t addr)\n{", "addr &= 0xff;", "if (addr == 0) {", "return platform_fixed_ioport_readb(opaque, XEN_PLATFORM_IOPORT);", "} else {", "return ~0u;", "}", "}" ]

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

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

[ "static ssize_t FUNC_0(FsContext *ctx, const char *path,\nconst char *name, void *value, size_t size)\n{", "char VAR_0[PATH_MAX];", "return lgetxattr(rpath(ctx, path, VAR_0), MAP_ACL_ACCESS, value, size);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "void FUNC_0(GAState *VAR_0, GACommandState *VAR_1)\n{", "if (vss_init(true)) {", "ga_command_state_add(VAR_1, NULL, guest_fsfreeze_cleanup);", "}", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "int FUNC_0(FFVAContext *VAR_0)\n{", "VABufferID *slice_buf_ids;", "VABufferID slice_param_buf_id, slice_data_buf_id;", "if (VAR_0->slice_count == 0)\nreturn 0;", "slice_buf_ids =\nav_fast_realloc(VAR_0->slice_buf_ids,\n&VAR_0->slice_buf_ids_alloc,\n(VAR_0->n_slice_buf_ids + 2) * sizeof(slice_buf_ids[0]));", "if (!slice_buf_ids)\nreturn -1;", "VAR_0->slice_buf_ids = slice_buf_ids;", "slice_param_buf_id = 0;", "if (vaCreateBuffer(VAR_0->display, VAR_0->context_id,\nVASliceParameterBufferType,\nVAR_0->slice_param_size,\nVAR_0->slice_count, VAR_0->slice_params,\n&slice_param_buf_id) != VA_STATUS_SUCCESS)\nreturn -1;", "VAR_0->slice_count = 0;", "slice_data_buf_id = 0;", "if (vaCreateBuffer(VAR_0->display, VAR_0->context_id,\nVASliceDataBufferType,\nVAR_0->slice_data_size,\n1, (void *)VAR_0->slice_data,\n&slice_data_buf_id) != VA_STATUS_SUCCESS)\nreturn -1;", "VAR_0->slice_data = NULL;", "VAR_0->slice_data_size = 0;", "slice_buf_ids[VAR_0->n_slice_buf_ids++] = slice_param_buf_id;", "slice_buf_ids[VAR_0->n_slice_buf_ids++] = slice_data_buf_id;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "TCGv t0;", "int VAR_1;", "if (VAR_0->imm5 == 7) {", "LOG_DIS(\"scall\\n\");", "} else if (VAR_0->imm5 == 2) {", "LOG_DIS(\"break\\n\");", "} else {", "cpu_abort(VAR_0->env, \"invalid opcode\\n\");", "}", "t0 = tcg_temp_new();", "VAR_1 = gen_new_label();", "if (VAR_0->imm5 == 7) {", "tcg_gen_movi_tl(cpu_pc, VAR_0->pc);", "t_gen_raise_exception(VAR_0, EXCP_SYSTEMCALL);", "} else {", "tcg_gen_movi_tl(cpu_pc, VAR_0->pc);", "t_gen_raise_exception(VAR_0, EXCP_BREAKPOINT);", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "CPUState *env;", "SLAVIO_INTCTLState *s = VAR_0;", "uint32_t pending = s->intregm_pending;", "unsigned int VAR_1, VAR_2, VAR_3 = 0;", "pending &= ~s->intregm_disabled;", "if (pending && !(s->intregm_disabled & 0x80000000)) {", "for (VAR_1 = 0; VAR_1 < 32; VAR_1++) {", "if (pending & (1 << VAR_1)) {", "if (VAR_3 < s->intbit_to_level[VAR_1])\nVAR_3 = s->intbit_to_level[VAR_1];", "}", "}", "env = s->cpu_envs[s->target_cpu];", "if (!env) {", "DPRINTF(\"No CPU %d, not triggered (pending %x)\\n\", s->target_cpu, pending);", "}", "else {", "if (env->halted)\nenv->halted = 0;", "if (env->interrupt_index == 0) {", "DPRINTF(\"Triggered CPU %d pil %d\\n\", s->target_cpu, VAR_3);", "#ifdef DEBUG_IRQ_COUNT\ns->irq_count[VAR_3]++;", "#endif\nenv->interrupt_index = TT_EXTINT | VAR_3;", "cpu_interrupt(env, CPU_INTERRUPT_HARD);", "}", "else\nDPRINTF(\"Not triggered (pending %x), pending exception %x\\n\", pending, env->interrupt_index);", "}", "}", "else\nDPRINTF(\"Not triggered (pending %x), disabled %x\\n\", pending, s->intregm_disabled);", "for (VAR_1 = 0; VAR_1 < MAX_CPUS; VAR_1++) {", "VAR_3 = 0;", "env = s->cpu_envs[VAR_1];", "if (!env)\ncontinue;", "for (VAR_2 = 17; VAR_2 < 32; VAR_2++) {", "if (s->intreg_pending[VAR_1] & (1 << VAR_2)) {", "if (VAR_3 < VAR_2 - 16)\nVAR_3 = VAR_2 - 16;", "}", "}", "if (VAR_3 > 0) {", "if (env->halted)\nenv->halted = 0;", "if (env->interrupt_index == 0) {", "DPRINTF(\"Triggered softint %d for cpu %d (pending %x)\\n\", VAR_3, VAR_1, pending);", "#ifdef DEBUG_IRQ_COUNT\ns->irq_count[VAR_3]++;", "#endif\nenv->interrupt_index = TT_EXTINT | VAR_3;", "cpu_interrupt(env, CPU_INTERRUPT_HARD);", "}", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 19 ], [ 21 ], [ 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 ], [ 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 ] ]

[ "static int FUNC_0(PCIDevice *VAR_0, bool VAR_1)\n{", "int VAR_2;", "char *VAR_3;", "void *VAR_4;", "char VAR_5[32];", "const VMStateDescription *VAR_6;", "if (!VAR_0->romfile)\nreturn 0;", "if (strlen(VAR_0->romfile) == 0)\nreturn 0;", "if (!VAR_0->rom_bar) {", "int VAR_7 = pci_get_word(VAR_0->config + PCI_CLASS_DEVICE);", "if (VAR_7 == 0x0300) {", "rom_add_vga(VAR_0->romfile);", "} else {", "rom_add_option(VAR_0->romfile, -1);", "}", "return 0;", "}", "VAR_3 = qemu_find_file(QEMU_FILE_TYPE_BIOS, VAR_0->romfile);", "if (VAR_3 == NULL) {", "VAR_3 = g_strdup(VAR_0->romfile);", "}", "VAR_2 = get_image_size(VAR_3);", "if (VAR_2 < 0) {", "error_report(\"%s: failed to find romfile \\\"%s\\\"\",\n__FUNCTION__, VAR_0->romfile);", "g_free(VAR_3);", "return -1;", "}", "if (VAR_2 & (VAR_2 - 1)) {", "VAR_2 = 1 << qemu_fls(VAR_2);", "}", "VAR_6 = qdev_get_vmsd(DEVICE(VAR_0));", "if (VAR_6) {", "snprintf(VAR_5, sizeof(VAR_5), \"%s.rom\", VAR_6->VAR_5);", "} else {", "snprintf(VAR_5, sizeof(VAR_5), \"%s.rom\", object_get_typename(OBJECT(VAR_0)));", "}", "VAR_0->has_rom = true;", "memory_region_init_ram(&VAR_0->rom, VAR_5, VAR_2);", "vmstate_register_ram(&VAR_0->rom, &VAR_0->qdev);", "VAR_4 = memory_region_get_ram_ptr(&VAR_0->rom);", "load_image(VAR_3, VAR_4);", "g_free(VAR_3);", "if (VAR_1) {", "pci_patch_ids(VAR_0, VAR_4, VAR_2);", "}", "qemu_put_ram_ptr(VAR_4);", "pci_register_bar(VAR_0, PCI_ROM_SLOT, 0, &VAR_0->rom);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17, 19 ], [ 21, 23 ], [ 27 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 119 ], [ 121 ], [ 125 ], [ 129 ], [ 133 ], [ 135 ] ]

[ "static char *FUNC_0(int VAR_0,\nchar *VAR_1, char VAR_2,\nconst char *VAR_3,\nchar **VAR_4, Error **VAR_5)\n{", "int VAR_6;", "char *VAR_7;", "*VAR_4 = NULL;", "if (VAR_2 != '\\0') {", "for (VAR_7 = VAR_1; *VAR_7; ++VAR_7) {", "if (*VAR_7 == VAR_2) {", "break;", "}", "if (*VAR_7 == '\\\\' && VAR_7[1] != '\\0') {", "VAR_7++;", "}", "}", "if (*VAR_7 == VAR_2) {", "*VAR_4 = VAR_7 + 1;", "*VAR_7 = '\\0';", "}", "}", "VAR_6 = strlen(VAR_1);", "if (VAR_6 >= VAR_0) {", "error_setg(VAR_5, \"%s too long\", VAR_3);", "return NULL;", "} else if (VAR_6 == 0) {", "error_setg(VAR_5, \"%s too short\", VAR_3);", "return NULL;", "}", "return 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 ]

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

[ "static int FUNC_0(VncState *VAR_0, uint8_t *VAR_1, size_t VAR_2)\n{", "int VAR_3 = read_u32(VAR_1, 0);", "if (VAR_3 != VAR_0->vd->subauth) {", "VNC_DEBUG(\"Rejecting VAR_3 %d\\n\", VAR_3);", "vnc_write_u8(VAR_0, 0);", "vnc_flush(VAR_0);", "vnc_client_error(VAR_0);", "} else {", "VNC_DEBUG(\"Accepting VAR_3 %d, setting up TLS for handshake\\n\", VAR_3);", "vnc_write_u8(VAR_0, 1);", "vnc_flush(VAR_0);", "if (vnc_tls_client_setup(VAR_0, NEED_X509_AUTH(VAR_0)) < 0) {", "VNC_DEBUG(\"Failed to setup TLS\\n\");", "return 0;", "}", "VNC_DEBUG(\"Start TLS VeNCrypt handshake process\\n\");", "if (vnc_start_vencrypt_handshake(VAR_0) < 0) {", "VNC_DEBUG(\"Failed to start TLS handshake\\n\");", "return 0;", "}", "}", "return 0;", "}" ]

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

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

[ "int64_t FUNC_0(const char *nptr, char **end)\n{", "return do_strtosz(nptr, end, 'B', 1000);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,\nuint64_t **VAR_2)\n{", "BDRVQcow2State *s = VAR_0->opaque;", "int VAR_3;", "VAR_3 = qcow2_cache_get(VAR_0, s->l2_table_cache, VAR_1, (void**) VAR_2);", "return VAR_3;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0)\n{", "MJpegDecodeContext *s = VAR_0->priv_data;", "MpegEncContext s2;", "s->VAR_0 = VAR_0;", "memset(&s2, 0, sizeof(MpegEncContext));", "s2.flags= VAR_0->flags;", "s2.VAR_0= VAR_0;", "s2.width = 8;", "s2.height = 8;", "if (MPV_common_init(&s2) < 0)\nreturn -1;", "s->scantable= s2.intra_scantable;", "s->idct_put= s2.idct_put;", "MPV_common_end(&s2);", "s->mpeg_enc_ctx_allocated = 0;", "s->buffer_size = 102400;", "s->buffer = av_malloc(s->buffer_size);", "if (!s->buffer)\nreturn -1;", "s->start_code = -1;", "s->first_picture = 1;", "s->org_width = VAR_0->width;", "s->org_height = VAR_0->height;", "build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);", "build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);", "build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);", "build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);", "if (VAR_0->flags & CODEC_FLAG_EXTERN_HUFF)\n{", "printf(\"mjpeg: using external huffman table\\n\");", "init_get_bits(&s->gb, VAR_0->extradata, VAR_0->extradata_size);", "mjpeg_decode_dht(s);", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 89 ], [ 91 ] ]

[ "static int FUNC_0(PCIDevice *VAR_0)\n{", "PCIVGAState *d = DO_UPCAST(PCIVGAState, VAR_0, VAR_0);", "VGACommonState *s = &d->vga;", "vga_common_init(s);", "vga_init(s, pci_address_space(VAR_0), pci_address_space_io(VAR_0), true);", "s->con = graphic_console_init(s->update, s->invalidate,\ns->screen_dump, s->text_update, s);", "pci_register_bar(&d->VAR_0, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->vram);", "if (d->flags & (1 << PCI_VGA_FLAG_ENABLE_MMIO)) {", "memory_region_init(&d->mmio, \"vga.mmio\", 4096);", "memory_region_init_io(&d->ioport, &pci_vga_ioport_ops, d,\n\"vga ioports remapped\", PCI_VGA_IOPORT_SIZE);", "memory_region_init_io(&d->bochs, &pci_vga_bochs_ops, d,\n\"bochs dispi interface\", PCI_VGA_BOCHS_SIZE);", "memory_region_add_subregion(&d->mmio, PCI_VGA_IOPORT_OFFSET,\n&d->ioport);", "memory_region_add_subregion(&d->mmio, PCI_VGA_BOCHS_OFFSET,\n&d->bochs);", "pci_register_bar(&d->VAR_0, 2, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio);", "}", "if (!VAR_0->rom_bar) {", "vga_init_vbe(s, pci_address_space(VAR_0));", "}", "return 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 ], [ 19, 21 ], [ 27 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41, 43 ], [ 47, 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 61 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ] ]

[ "static int FUNC_0(I2CSlave *VAR_0)\n{", "printf(\"%VAR_0: recv not supported!!!\\n\", __FUNCTION__);", "return -1;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0 (WAVEFORMATEX *VAR_0, audsettings_t *VAR_1)\n{", "memset (VAR_0, 0, sizeof (*VAR_0));", "VAR_0->wFormatTag = WAVE_FORMAT_PCM;", "VAR_0->nChannels = VAR_1->nchannels;", "VAR_0->nSamplesPerSec = VAR_1->freq;", "VAR_0->nAvgBytesPerSec = VAR_1->freq << (VAR_1->nchannels == 2);", "VAR_0->nBlockAlign = 1 << (VAR_1->nchannels == 2);", "VAR_0->cbSize = 0;", "switch (VAR_1->fmt) {", "case AUD_FMT_S8:\ncase AUD_FMT_U8:\nVAR_0->wBitsPerSample = 8;", "break;", "case AUD_FMT_S16:\ncase AUD_FMT_U16:\nVAR_0->wBitsPerSample = 16;", "VAR_0->nAvgBytesPerSec <<= 1;", "VAR_0->nBlockAlign <<= 1;", "break;", "case AUD_FMT_S32:\ncase AUD_FMT_U32:\nVAR_0->wBitsPerSample = 32;", "VAR_0->nAvgBytesPerSec <<= 2;", "VAR_0->nBlockAlign <<= 2;", "break;", "default:\ndolog (\"Internal logic error: Bad audio format %d\\n\", VAR_1->freq);", "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 ]

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

[ "static BlockDriverAIOCB *FUNC_0(BlockDriverState *bs,\nint64_t sector_num, QEMUIOVector *qiov, int nb_sectors,\nBlockDriverCompletionFunc *cb, void *opaque)\n{", "return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(Monitor *VAR_0, QEMUFile *VAR_1, int VAR_2)\n{", "BlkMigDevState *bmds;", "int VAR_3 = 0;", "QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {", "if (mig_save_device_dirty(VAR_0, VAR_1, bmds, VAR_2) == 0) {", "VAR_3 = 1;", "break;", "}", "}", "return VAR_3;", "}" ]

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

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

[ "float64 FUNC_0( float64 a STATUS_PARAM )\n{", "flag aSign;", "int16 aExp, zExp;", "bits64 aSig, zSig, doubleZSig;", "bits64 rem0, rem1, term0, term1;", "aSig = extractFloat64Frac( a );", "aExp = extractFloat64Exp( a );", "aSign = extractFloat64Sign( a );", "if ( aExp == 0x7FF ) {", "if ( aSig ) return propagateFloat64NaN( a, a STATUS_VAR );", "if ( ! aSign ) return a;", "float_raise( float_flag_invalid STATUS_VAR);", "return float64_default_nan;", "}", "if ( aSign ) {", "if ( ( aExp | aSig ) == 0 ) return a;", "float_raise( float_flag_invalid STATUS_VAR);", "return float64_default_nan;", "}", "if ( aExp == 0 ) {", "if ( aSig == 0 ) return 0;", "normalizeFloat64Subnormal( aSig, &aExp, &aSig );", "}", "zExp = ( ( aExp - 0x3FF )>>1 ) + 0x3FE;", "aSig |= LIT64( 0x0010000000000000 );", "zSig = estimateSqrt32( aExp, aSig>>21 );", "aSig <<= 9 - ( aExp & 1 );", "zSig = estimateDiv128To64( aSig, 0, zSig<<32 ) + ( zSig<<30 );", "if ( ( zSig & 0x1FF ) <= 5 ) {", "doubleZSig = zSig<<1;", "mul64To128( zSig, zSig, &term0, &term1 );", "sub128( aSig, 0, term0, term1, &rem0, &rem1 );", "while ( (sbits64) rem0 < 0 ) {", "--zSig;", "doubleZSig -= 2;", "add128( rem0, rem1, zSig>>63, doubleZSig | 1, &rem0, &rem1 );", "}", "zSig |= ( ( rem0 | rem1 ) != 0 );", "}", "return roundAndPackFloat64( 0, zExp, zSig 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 ]

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

[ "static int FUNC_0(struct qemu_alarm_timer *VAR_0)\n{", "struct sigevent VAR_1;", "timer_t host_timer;", "struct sigaction VAR_2;", "sigfillset(&VAR_2.sa_mask);", "VAR_2.sa_flags = 0;", "VAR_2.sa_handler = host_alarm_handler;", "sigaction(SIGALRM, &VAR_2, NULL);", "memset(&VAR_1, 0, sizeof(VAR_1));", "VAR_1.sigev_value.sival_int = 0;", "VAR_1.sigev_notify = SIGEV_SIGNAL;", "#ifdef SIGEV_THREAD_ID\nif (qemu_signalfd_available()) {", "VAR_1.sigev_notify = SIGEV_THREAD_ID;", "VAR_1._sigev_un._tid = qemu_get_thread_id();", "}", "#endif\nVAR_1.sigev_signo = SIGALRM;", "if (timer_create(CLOCK_REALTIME, &VAR_1, &host_timer)) {", "perror(\"timer_create\");", "return -1;", "}", "VAR_0->timer = host_timer;", "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 ]

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

[ "void FUNC_0(SysBusDeviceInfo *VAR_0)\n{", "VAR_0->qdev.init = sysbus_device_init;", "VAR_0->qdev.bus_type = BUS_TYPE_SYSTEM;", "assert(VAR_0->qdev.size >= sizeof(SysBusDevice));", "qdev_register(&VAR_0->qdev);", "}" ]

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

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

[ "int FUNC_0(QEMUTimer *VAR_0, int64_t VAR_1)\n{", "if (!VAR_0)\nreturn 0;", "return (VAR_0->expire_time <= VAR_1);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static int FUNC_0(CodedBitstreamContext *VAR_0, BitstreamContext *VAR_1,\nconst char *VAR_2, int32_t *VAR_3,\nint32_t VAR_4, int32_t VAR_5)\n{", "int32_t value;", "int VAR_6;", "if (VAR_0->trace_enable) {", "char VAR_7[65];", "uint32_t v;", "unsigned int VAR_8;", "int VAR_9, VAR_10;", "VAR_6 = bitstream_tell(VAR_1);", "for (VAR_9 = 0; VAR_9 < 32; VAR_9++) {", "VAR_8 = bitstream_read_bit(VAR_1);", "VAR_7[VAR_9] = VAR_8 ? '1' : '0';", "if (VAR_8)\nbreak;", "}", "if (VAR_9 >= 32) {", "av_log(VAR_0->log_ctx, AV_LOG_ERROR, \"Invalid se-golomb \"\n\"code found while reading %s: \"\n\"more than 31 zeroes.\\n\", VAR_2);", "return AVERROR_INVALIDDATA;", "}", "v = 1;", "for (VAR_10 = 0; VAR_10 < VAR_9; VAR_10++) {", "VAR_8 = bitstream_read_bit(VAR_1);", "VAR_7[VAR_9 + VAR_10 + 1] = VAR_8 ? '1' : '0';", "v = v << 1 | VAR_8;", "}", "VAR_7[VAR_9 + VAR_10 + 1] = 0;", "if (v & 1)\nvalue = -(int32_t)(v / 2);", "else\nvalue = v / 2;", "ff_cbs_trace_syntax_element(VAR_0, VAR_6, VAR_2, VAR_7, value);", "} else {", "value = get_se_golomb_long(VAR_1);", "}", "if (value < VAR_4 || value > VAR_5) {", "av_log(VAR_0->log_ctx, AV_LOG_ERROR, \"%s out of range: \"\n\"%\"PRId32\", but must be in [%\"PRId32\",%\"PRId32\"].\\n\",\nVAR_2, value, VAR_4, VAR_5);", "return AVERROR_INVALIDDATA;", "}", "*VAR_3 = value;", "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 ]

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

[ "void FUNC_0(CPUX86State *VAR_0, uint32_t VAR_1,\nuint32_t *VAR_2, uint32_t *VAR_3,\nuint32_t *VAR_4, uint32_t *VAR_5)\n{", "if (VAR_1 & 0x80000000) {", "if (VAR_1 > VAR_0->cpuid_xlevel)\nVAR_1 = VAR_0->cpuid_level;", "} else {", "if (VAR_1 > VAR_0->cpuid_level)\nVAR_1 = VAR_0->cpuid_level;", "}", "switch(VAR_1) {", "case 0:\n*VAR_2 = VAR_0->cpuid_level;", "*VAR_3 = VAR_0->cpuid_vendor1;", "*VAR_5 = VAR_0->cpuid_vendor2;", "*VAR_4 = VAR_0->cpuid_vendor3;", "if (kvm_enabled())\nhost_cpuid(0, NULL, VAR_3, VAR_4, VAR_5);", "break;", "case 1:\n*VAR_2 = VAR_0->cpuid_version;", "*VAR_3 = (VAR_0->cpuid_apic_id << 24) | 8 << 8;", "*VAR_4 = VAR_0->cpuid_ext_features;", "*VAR_5 = VAR_0->cpuid_features;", "if (kvm_enabled())\n*VAR_4 |= (1 << 31);", "break;", "case 2:\n*VAR_2 = 1;", "*VAR_3 = 0;", "*VAR_4 = 0;", "*VAR_5 = 0x2c307d;", "break;", "case 4:\nswitch (*VAR_4) {", "case 0:\n*VAR_2 = 0x0000121;", "*VAR_3 = 0x1c0003f;", "*VAR_4 = 0x000003f;", "*VAR_5 = 0x0000001;", "break;", "case 1:\n*VAR_2 = 0x0000122;", "*VAR_3 = 0x1c0003f;", "*VAR_4 = 0x000003f;", "*VAR_5 = 0x0000001;", "break;", "case 2:\n*VAR_2 = 0x0000143;", "*VAR_3 = 0x3c0003f;", "*VAR_4 = 0x0000fff;", "*VAR_5 = 0x0000001;", "break;", "default:\n*VAR_2 = 0;", "*VAR_3 = 0;", "*VAR_4 = 0;", "*VAR_5 = 0;", "break;", "}", "break;", "case 5:\n*VAR_2 = 0;", "*VAR_3 = 0;", "*VAR_4 = CPUID_MWAIT_EMX | CPUID_MWAIT_IBE;", "*VAR_5 = 0;", "break;", "case 6:\n*VAR_2 = 0;", "*VAR_3 = 0;", "*VAR_4 = 0;", "*VAR_5 = 0;", "break;", "case 9:\n*VAR_2 = 0;", "*VAR_3 = 0;", "*VAR_4 = 0;", "*VAR_5 = 0;", "break;", "case 0xA:\n*VAR_2 = 0;", "*VAR_3 = 0;", "*VAR_4 = 0;", "*VAR_5 = 0;", "break;", "case 0x80000000:\n*VAR_2 = VAR_0->cpuid_xlevel;", "*VAR_3 = VAR_0->cpuid_vendor1;", "*VAR_5 = VAR_0->cpuid_vendor2;", "*VAR_4 = VAR_0->cpuid_vendor3;", "break;", "case 0x80000001:\n*VAR_2 = VAR_0->cpuid_features;", "*VAR_3 = 0;", "*VAR_4 = VAR_0->cpuid_ext3_features;", "*VAR_5 = VAR_0->cpuid_ext2_features;", "if (kvm_enabled()) {", "uint32_t h_eax, h_edx;", "host_cpuid(0x80000001, &h_eax, NULL, NULL, &h_edx);", "if ((h_edx & 0x20000000) == 0 )\n*VAR_5 &= ~0x20000000;", "if ((h_edx & 0x00000800) == 0)\n*VAR_5 &= ~0x00000800;", "if ((h_edx & 0x00100000) == 0)\n*VAR_5 &= ~0x00100000;", "*VAR_4 &= ~4UL;", "*VAR_5 = ~0xc0000000;", "}", "break;", "case 0x80000002:\ncase 0x80000003:\ncase 0x80000004:\n*VAR_2 = VAR_0->cpuid_model[(VAR_1 - 0x80000002) * 4 + 0];", "*VAR_3 = VAR_0->cpuid_model[(VAR_1 - 0x80000002) * 4 + 1];", "*VAR_4 = VAR_0->cpuid_model[(VAR_1 - 0x80000002) * 4 + 2];", "*VAR_5 = VAR_0->cpuid_model[(VAR_1 - 0x80000002) * 4 + 3];", "break;", "case 0x80000005:\n*VAR_2 = 0x01ff01ff;", "*VAR_3 = 0x01ff01ff;", "*VAR_4 = 0x40020140;", "*VAR_5 = 0x40020140;", "break;", "case 0x80000006:\n*VAR_2 = 0;", "*VAR_3 = 0x42004200;", "*VAR_4 = 0x02008140;", "*VAR_5 = 0;", "break;", "case 0x80000008:\nif (VAR_0->cpuid_ext2_features & CPUID_EXT2_LM) {", "#if defined(USE_KQEMU)\n*VAR_2 = 0x00003020;", "#else\n*VAR_2 = 0x00003028;", "#endif\n} else {", "#if defined(USE_KQEMU)\n*VAR_2 = 0x00000020;", "#else\nif (VAR_0->cpuid_features & CPUID_PSE36)\n*VAR_2 = 0x00000024;", "else\n*VAR_2 = 0x00000020;", "#endif\n}", "*VAR_3 = 0;", "*VAR_4 = 0;", "*VAR_5 = 0;", "break;", "case 0x8000000A:\n*VAR_2 = 0x00000001;", "*VAR_3 = 0x00000010;", "*VAR_4 = 0;", "*VAR_5 = 0;", "break;", "default:\n*VAR_2 = 0;", "*VAR_3 = 0;", "*VAR_4 = 0;", "*VAR_5 = 0;", "break;", "}", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 11 ], [ 13, 15 ], [ 17 ], [ 19, 21 ], [ 23 ], [ 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 49, 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 69, 71 ], [ 73 ], [ 75, 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89, 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107, 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131, 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149, 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177, 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205, 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217, 219 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 235 ], [ 245, 247 ], [ 251, 253 ], [ 257, 259 ], [ 269 ], [ 273 ], [ 275 ], [ 277 ], [ 279, 281, 283, 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295, 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309, 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323, 329 ], [ 333, 335 ], [ 337, 341 ], [ 343, 345 ], [ 347, 349 ], [ 351, 353, 355 ], [ 357, 359 ], [ 361, 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373, 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385, 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ] ]

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

[ 0, 0, 0 ]

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

[ "static always_inline int FUNC_0 (mmu_ctx_t *ctx, int is_64b,\ntarget_ulong pte0, target_ulong pte1,\nint h, int rw)\n{", "target_ulong ptem, mmask;", "int VAR_0, VAR_1, VAR_2, VAR_3;", "VAR_0 = 0;", "VAR_1 = -1;", "#if defined(TARGET_PPC64)\nif (is_64b) {", "VAR_3 = pte64_is_valid(pte0);", "VAR_2 = (pte0 >> 1) & 1;", "} else", "#endif\n{", "VAR_3 = pte_is_valid(pte0);", "VAR_2 = (pte0 >> 6) & 1;", "}", "if (VAR_3 && h == VAR_2) {", "#if defined(TARGET_PPC64)\nif (is_64b) {", "ptem = pte0 & PTE64_PTEM_MASK;", "mmask = PTE64_CHECK_MASK;", "} else", "#endif\n{", "ptem = pte0 & PTE_PTEM_MASK;", "mmask = PTE_CHECK_MASK;", "}", "if (ptem == ctx->ptem) {", "if (ctx->raddr != (target_ulong)-1) {", "if ((ctx->raddr & mmask) != (pte1 & mmask)) {", "if (loglevel != 0)\nfprintf(logfile, \"Bad RPN/WIMG/PP\\n\");", "return -3;", "}", "}", "if (ctx->key == 0) {", "VAR_0 = PAGE_READ;", "if ((pte1 & 0x00000003) != 0x3)\nVAR_0 |= PAGE_WRITE;", "} else {", "switch (pte1 & 0x00000003) {", "case 0x0:\nVAR_0 = 0;", "break;", "case 0x1:\ncase 0x3:\nVAR_0 = PAGE_READ;", "break;", "case 0x2:\nVAR_0 = PAGE_READ | PAGE_WRITE;", "break;", "}", "}", "ctx->raddr = pte1;", "ctx->prot = VAR_0;", "if ((rw == 0 && (VAR_0 & PAGE_READ)) ||\n(rw == 1 && (VAR_0 & PAGE_WRITE))) {", "#if defined (DEBUG_MMU)\nif (loglevel != 0)\nfprintf(logfile, \"PTE VAR_0 granted !\\n\");", "#endif\nVAR_1 = 0;", "} else {", "#if defined (DEBUG_MMU)\nif (loglevel != 0)\nfprintf(logfile, \"PTE VAR_0 rejected\\n\");", "#endif\nVAR_1 = -2;", "}", "}", "}", "return VAR_1;", "}" ]

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

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

[ "void FUNC_0(const char *VAR_0, Error **VAR_1)\n{", "BlockJob *job = find_block_job(VAR_0);", "if (!job) {", "error_set(VAR_1, QERR_BLOCK_JOB_NOT_ACTIVE, VAR_0);", "return;", "}", "trace_qmp_block_job_resume(job);", "block_job_resume(job);", "}" ]

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

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

[ "int FUNC_0 (SWVoiceOut *VAR_0, void *VAR_1, int VAR_2)\n{", "int VAR_3;", "if (!VAR_0) {", "return VAR_2;", "}", "if (!VAR_0->hw->enabled) {", "dolog (\"Writing to disabled voice %s\\n\", SW_NAME (VAR_0));", "return 0;", "}", "VAR_3 = VAR_0->hw->pcm_ops->write (VAR_0, VAR_1, VAR_2);", "return VAR_3;", "}" ]

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

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

[ "static void FUNC_0(target_phys_addr_t VAR_0, unsigned VAR_1)\n{", "RomResetData *rrd = qemu_malloc(sizeof *rrd);", "rrd->data = qemu_malloc(VAR_1);", "cpu_physical_memory_read(VAR_0, rrd->data, VAR_1);", "rrd->VAR_0 = VAR_0;", "rrd->VAR_1 = VAR_1;", "qemu_register_reset(option_rom_reset, rrd);", "}" ]

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

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

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

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

[ [ 1, 3 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 27 ] ]

[ "static void FUNC_0(Monitor *VAR_0, const char *VAR_1, void *VAR_2)\n{", "monitor_suspend(VAR_0);", "handle_user_command(VAR_0, VAR_1);", "monitor_resume(VAR_0);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(MpegEncContext *VAR_0,\nDCTELEM *VAR_1, int VAR_2, int VAR_3)\n{", "int VAR_4, VAR_5, VAR_6;", "const UINT16 *VAR_7;", "if(VAR_0->alternate_scan) VAR_6= 64;", "else VAR_6= VAR_0->block_last_index[VAR_2]+1;", "if (VAR_0->mb_intra) {", "if (VAR_2 < 4)\nVAR_1[0] = VAR_1[0] * VAR_0->y_dc_scale;", "else\nVAR_1[0] = VAR_1[0] * VAR_0->c_dc_scale;", "VAR_7 = VAR_0->intra_matrix;", "for(VAR_4=1;VAR_4<VAR_6;VAR_4++) {", "int VAR_9= zigzag_direct[VAR_4];", "VAR_5 = VAR_1[VAR_9];", "if (VAR_5) {", "if (VAR_5 < 0) {", "VAR_5 = -VAR_5;", "VAR_5 = (int)(VAR_5 * VAR_3 * VAR_7[VAR_9]) >> 3;", "VAR_5 = (VAR_5 - 1) | 1;", "VAR_5 = -VAR_5;", "} else {", "VAR_5 = (int)(VAR_5 * VAR_3 * VAR_7[VAR_9]) >> 3;", "VAR_5 = (VAR_5 - 1) | 1;", "}", "#ifdef PARANOID\nif (VAR_5 < -2048 || VAR_5 > 2047)\nfprintf(stderr, \"unquant error %d %d\\VAR_2\", VAR_4, VAR_5);", "#endif\nVAR_1[VAR_9] = VAR_5;", "}", "}", "} else {", "VAR_4 = 0;", "VAR_7 = VAR_0->non_intra_matrix;", "for(;VAR_4<VAR_6;VAR_4++) {", "int VAR_9= zigzag_direct[VAR_4];", "VAR_5 = VAR_1[VAR_9];", "if (VAR_5) {", "if (VAR_5 < 0) {", "VAR_5 = -VAR_5;", "VAR_5 = (((VAR_5 << 1) + 1) * VAR_3 *\n((int) (VAR_7[VAR_9]))) >> 4;", "VAR_5 = (VAR_5 - 1) | 1;", "VAR_5 = -VAR_5;", "} else {", "VAR_5 = (((VAR_5 << 1) + 1) * VAR_3 *\n((int) (VAR_7[VAR_9]))) >> 4;", "VAR_5 = (VAR_5 - 1) | 1;", "}", "#ifdef PARANOID\nif (VAR_5 < -2048 || VAR_5 > 2047)\nfprintf(stderr, \"unquant error %d %d\\VAR_2\", VAR_4, VAR_5);", "#endif\nVAR_1[VAR_9] = VAR_5;", "}", "}", "}", "}" ]

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

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

[ "static void FUNC_0(Object *VAR_0, struct Visitor *VAR_1,\nvoid *VAR_2, const char *VAR_3, Error **VAR_4)\n{", "Error *err = NULL;", "VirtIOBalloon *s = VAR_2;", "int VAR_5;", "if (!s->stats_last_update) {", "error_setg(VAR_4, \"guest hasn't updated any stats yet\");", "return;", "}", "visit_start_struct(VAR_1, NULL, \"guest-stats\", VAR_3, 0, &err);", "if (err) {", "goto out;", "}", "visit_type_int(VAR_1, &s->stats_last_update, \"last-update\", &err);", "visit_start_struct(VAR_1, NULL, NULL, \"stats\", 0, &err);", "if (err) {", "goto out_end;", "}", "for (VAR_5 = 0; VAR_5 < VIRTIO_BALLOON_S_NR; VAR_5++) {", "visit_type_int64(VAR_1, (int64_t *) &s->stats[VAR_5], balloon_stat_names[VAR_5],\n&err);", "}", "visit_end_struct(VAR_1, &err);", "out_end:\nvisit_end_struct(VAR_1, &err);", "out:\nerror_propagate(VAR_4, err);", "}" ]

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

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

[ "void FUNC_0(const cmdinfo_t *VAR_0)\n{", "cmdtab = g_realloc(cmdtab, ++ncmds * sizeof(*cmdtab));", "cmdtab[ncmds - 1] = *VAR_0;", "qsort(cmdtab, ncmds, sizeof(*cmdtab), compare_cmdname);", "}" ]

[ 0, 1, 0, 0, 0 ]

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

[ "static void FUNC_0(Object *VAR_0)\n{", "X86CPU *cpu = X86_CPU(VAR_0);", "CPUX86State *env = &cpu->env;", "KVMState *s = kvm_state;", "cpu->max_features = true;", "if (kvm_enabled()) {", "X86CPUDefinition host_cpudef = { };", "uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;", "host_vendor_fms(host_cpudef.vendor, &host_cpudef.family,\n&host_cpudef.model, &host_cpudef.stepping);", "cpu_x86_fill_model_id(host_cpudef.model_id);", "x86_cpu_load_def(cpu, &host_cpudef, &error_abort);", "env->cpuid_min_level =\nkvm_arch_get_supported_cpuid(s, 0x0, 0, R_EAX);", "env->cpuid_min_xlevel =\nkvm_arch_get_supported_cpuid(s, 0x80000000, 0, R_EAX);", "env->cpuid_min_xlevel2 =\nkvm_arch_get_supported_cpuid(s, 0xC0000000, 0, R_EAX);", "if (lmce_supported()) {", "object_property_set_bool(OBJECT(cpu), true, \"lmce\", &error_abort);", "}", "} else {", "object_property_set_str(OBJECT(cpu), CPUID_VENDOR_AMD,\n\"vendor\", &error_abort);", "object_property_set_int(OBJECT(cpu), 6, \"family\", &error_abort);", "object_property_set_int(OBJECT(cpu), 6, \"model\", &error_abort);", "object_property_set_int(OBJECT(cpu), 3, \"stepping\", &error_abort);", "object_property_set_str(OBJECT(cpu),\n\"QEMU TCG CPU version \" QEMU_HW_VERSION,\n\"model-id\", &error_abort);", "}", "object_property_set_bool(OBJECT(cpu), true, \"pmu\", &error_abort);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 31, 33 ], [ 37 ], [ 41 ], [ 45, 47 ], [ 49, 51 ], [ 53, 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79, 81 ], [ 83 ], [ 87 ], [ 89 ] ]

[ "static int FUNC_0(VFIOGroup *VAR_0, const char *VAR_1, VFIODevice *VAR_2)\n{", "struct vfio_device_info VAR_3 = { .argsz = sizeof(VAR_3) };", "struct vfio_region_info VAR_4 = { .argsz = sizeof(VAR_4) };", "int VAR_5, VAR_6;", "VAR_5 = ioctl(VAR_0->fd, VFIO_GROUP_GET_DEVICE_FD, VAR_1);", "if (VAR_5 < 0) {", "error_report(\"vfio: error getting device %s from VAR_0 %d: %m\\n\",\nVAR_1, VAR_0->groupid);", "error_report(\"Verify all devices in VAR_0 %d are bound to vfio-pci \"\n\"or pci-stub and not already in use\\n\", VAR_0->groupid);", "return VAR_5;", "}", "VAR_2->fd = VAR_5;", "VAR_2->VAR_0 = VAR_0;", "QLIST_INSERT_HEAD(&VAR_0->device_list, VAR_2, next);", "VAR_5 = ioctl(VAR_2->fd, VFIO_DEVICE_GET_INFO, &VAR_3);", "if (VAR_5) {", "error_report(\"vfio: error getting device info: %m\\n\");", "goto error;", "}", "DPRINTF(\"Device %s flags: %u, regions: %u, irgs: %u\\n\", VAR_1,\nVAR_3.flags, VAR_3.num_regions, VAR_3.num_irqs);", "if (!(VAR_3.flags & VFIO_DEVICE_FLAGS_PCI)) {", "error_report(\"vfio: Um, this isn't a PCI device\\n\");", "goto error;", "}", "VAR_2->reset_works = !!(VAR_3.flags & VFIO_DEVICE_FLAGS_RESET);", "if (!VAR_2->reset_works) {", "error_report(\"Warning, device %s does not support reset\\n\", VAR_1);", "}", "if (VAR_3.num_regions != VFIO_PCI_NUM_REGIONS) {", "error_report(\"vfio: unexpected number of io regions %u\\n\",\nVAR_3.num_regions);", "goto error;", "}", "if (VAR_3.num_irqs != VFIO_PCI_NUM_IRQS) {", "error_report(\"vfio: unexpected number of irqs %u\\n\", VAR_3.num_irqs);", "goto error;", "}", "for (VAR_6 = VFIO_PCI_BAR0_REGION_INDEX; VAR_6 < VFIO_PCI_ROM_REGION_INDEX; VAR_6++) {", "VAR_4.index = VAR_6;", "VAR_5 = ioctl(VAR_2->fd, VFIO_DEVICE_GET_REGION_INFO, &VAR_4);", "if (VAR_5) {", "error_report(\"vfio: Error getting region %d info: %m\\n\", VAR_6);", "goto error;", "}", "DPRINTF(\"Device %s region %d:\\n\", VAR_1, VAR_6);", "DPRINTF(\" size: 0x%lx, offset: 0x%lx, flags: 0x%lx\\n\",\n(unsigned long)VAR_4.size, (unsigned long)VAR_4.offset,\n(unsigned long)VAR_4.flags);", "VAR_2->bars[VAR_6].flags = VAR_4.flags;", "VAR_2->bars[VAR_6].size = VAR_4.size;", "VAR_2->bars[VAR_6].fd_offset = VAR_4.offset;", "VAR_2->bars[VAR_6].fd = VAR_2->fd;", "VAR_2->bars[VAR_6].nr = VAR_6;", "}", "VAR_4.index = VFIO_PCI_ROM_REGION_INDEX;", "VAR_5 = ioctl(VAR_2->fd, VFIO_DEVICE_GET_REGION_INFO, &VAR_4);", "if (VAR_5) {", "error_report(\"vfio: Error getting ROM info: %m\\n\");", "goto error;", "}", "DPRINTF(\"Device %s ROM:\\n\", VAR_1);", "DPRINTF(\" size: 0x%lx, offset: 0x%lx, flags: 0x%lx\\n\",\n(unsigned long)VAR_4.size, (unsigned long)VAR_4.offset,\n(unsigned long)VAR_4.flags);", "VAR_2->rom_size = VAR_4.size;", "VAR_2->rom_offset = VAR_4.offset;", "VAR_4.index = VFIO_PCI_CONFIG_REGION_INDEX;", "VAR_5 = ioctl(VAR_2->fd, VFIO_DEVICE_GET_REGION_INFO, &VAR_4);", "if (VAR_5) {", "error_report(\"vfio: Error getting config info: %m\\n\");", "goto error;", "}", "DPRINTF(\"Device %s config:\\n\", VAR_1);", "DPRINTF(\" size: 0x%lx, offset: 0x%lx, flags: 0x%lx\\n\",\n(unsigned long)VAR_4.size, (unsigned long)VAR_4.offset,\n(unsigned long)VAR_4.flags);", "VAR_2->config_size = VAR_4.size;", "VAR_2->config_offset = VAR_4.offset;", "error:\nif (VAR_5) {", "QLIST_REMOVE(VAR_2, next);", "VAR_2->VAR_0 = NULL;", "close(VAR_2->fd);", "}", "return VAR_5;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17, 19 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53, 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121, 123, 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 143 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159 ], [ 161, 163, 165 ], [ 169 ], [ 171 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 193, 195, 197 ], [ 201 ], [ 203 ], [ 207, 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ] ]

[ "static int FUNC_0(const char **VAR_0, AVFilterInOut **VAR_1,\nAVFilterInOut **VAR_2, AVClass *VAR_3)\n{", "int VAR_4 = 0;", "while(**VAR_0 == '[') {", "char *VAR_5 = parse_link_name(VAR_0, VAR_3);", "AVFilterInOut *match;", "if(!VAR_5)\nreturn -1;", "match = extract_inout(VAR_5, VAR_2);", "if(match) {", "if(match->type != LinkTypeOut) {", "av_log(VAR_3, AV_LOG_ERROR,\n\"Label \\\"%s\\\" appears twice as input!\\n\", match->VAR_5);", "return -1;", "}", "} else {", "match = av_mallocz(sizeof(AVFilterInOut));", "match->VAR_5 = VAR_5;", "match->type = LinkTypeIn;", "match->pad_idx = VAR_4;", "}", "insert_inout(VAR_1, match);", "*VAR_0 += consume_whitespace(*VAR_0);", "VAR_4++;", "}", "return VAR_4;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 19, 21 ], [ 27 ], [ 31 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 48 ], [ 52 ], [ 54 ], [ 56 ], [ 58 ], [ 60 ], [ 64 ], [ 68 ], [ 70 ], [ 72 ], [ 76 ], [ 78 ] ]

[ "static BlockBackend *FUNC_0(const char *file, QDict *bs_opts,\nError **errp)\n{", "const char *VAR_0;", "int VAR_1 = 0;", "int VAR_2, VAR_3;", "BlockBackend *blk;", "BlockDriverState *bs;", "ThrottleConfig cfg;", "int VAR_4 = 0;", "Error *error = NULL;", "QemuOpts *opts;", "const char *VAR_5;", "bool has_driver_specific_opts;", "BlockdevDetectZeroesOptions detect_zeroes =\nBLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;", "const char *VAR_6 = NULL;", "VAR_5 = qdict_get_try_str(bs_opts, \"VAR_5\");", "opts = qemu_opts_create(&qemu_common_drive_opts, VAR_5, 1, &error);", "if (error) {", "error_propagate(errp, error);", "goto err_no_opts;", "}", "qemu_opts_absorb_qdict(opts, bs_opts, &error);", "if (error) {", "error_propagate(errp, error);", "goto early_err;", "}", "if (VAR_5) {", "qdict_del(bs_opts, \"VAR_5\");", "}", "has_driver_specific_opts = !!qdict_size(bs_opts);", "VAR_4 = qemu_opt_get_bool(opts, \"VAR_4\", 0);", "account_invalid = qemu_opt_get_bool(opts, \"stats-account-invalid\", true);", "account_failed = qemu_opt_get_bool(opts, \"stats-account-failed\", true);", "extract_common_blockdev_options(opts, &VAR_1, &VAR_6, &cfg,\n&detect_zeroes, &error);", "if (error) {", "error_propagate(errp, error);", "goto early_err;", "}", "if ((VAR_0 = qemu_opt_get(opts, \"format\")) != NULL) {", "if (is_help_option(VAR_0)) {", "error_printf(\"Supported formats:\");", "bdrv_iterate_format(bdrv_format_print, NULL);", "error_printf(\"\\n\");", "goto early_err;", "}", "if (qdict_haskey(bs_opts, \"driver\")) {", "error_setg(errp, \"Cannot specify both 'driver' and 'format'\");", "goto early_err;", "}", "qdict_put(bs_opts, \"driver\", qstring_from_str(VAR_0));", "}", "VAR_3 = BLOCKDEV_ON_ERROR_ENOSPC;", "if ((VAR_0 = qemu_opt_get(opts, \"werror\")) != NULL) {", "VAR_3 = parse_block_error_action(VAR_0, 0, &error);", "if (error) {", "error_propagate(errp, error);", "goto early_err;", "}", "}", "VAR_2 = BLOCKDEV_ON_ERROR_REPORT;", "if ((VAR_0 = qemu_opt_get(opts, \"rerror\")) != NULL) {", "VAR_2 = parse_block_error_action(VAR_0, 1, &error);", "if (error) {", "error_propagate(errp, error);", "goto early_err;", "}", "}", "if (VAR_4) {", "VAR_1 &= ~BDRV_O_CACHE_MASK;", "VAR_1 |= (BDRV_O_SNAPSHOT|BDRV_O_CACHE_WB|BDRV_O_NO_FLUSH);", "}", "if ((!file || !*file) && !has_driver_specific_opts) {", "BlockBackendRootState *blk_rs;", "blk = blk_new(qemu_opts_id(opts), errp);", "if (!blk) {", "goto early_err;", "}", "blk_rs = blk_get_root_state(blk);", "blk_rs->open_flags = VAR_1;", "blk_rs->read_only = !(VAR_1 & BDRV_O_RDWR);", "blk_rs->detect_zeroes = detect_zeroes;", "if (throttle_enabled(&cfg)) {", "if (!VAR_6) {", "VAR_6 = blk_name(blk);", "}", "blk_rs->throttle_group = g_strdup(VAR_6);", "blk_rs->throttle_state = throttle_group_incref(VAR_6);", "blk_rs->throttle_state->cfg = cfg;", "}", "QDECREF(bs_opts);", "} else {", "if (file && !*file) {", "file = NULL;", "}", "blk = blk_new_open(qemu_opts_id(opts), file, NULL, bs_opts, VAR_1,\nerrp);", "if (!blk) {", "goto err_no_bs_opts;", "}", "bs = blk_bs(blk);", "bs->detect_zeroes = detect_zeroes;", "if (throttle_enabled(&cfg)) {", "if (!VAR_6) {", "VAR_6 = blk_name(blk);", "}", "bdrv_io_limits_enable(bs, VAR_6);", "bdrv_set_io_limits(bs, &cfg);", "}", "if (bdrv_key_required(bs)) {", "autostart = 0;", "}", "block_acct_init(blk_get_stats(blk), account_invalid, account_failed);", "}", "blk_set_on_error(blk, VAR_2, VAR_3);", "err_no_bs_opts:\nqemu_opts_del(opts);", "return blk;", "early_err:\nqemu_opts_del(opts);", "err_no_opts:\nQDECREF(bs_opts);", "return NULL;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 14 ], [ 16 ], [ 18 ], [ 20 ], [ 22 ], [ 24 ], [ 26 ], [ 28 ], [ 30, 32 ], [ 34 ], [ 42 ], [ 44 ], [ 46 ], [ 48 ], [ 50 ], [ 52 ], [ 56 ], [ 58 ], [ 60 ], [ 62 ], [ 64 ], [ 68 ], [ 70 ], [ 72 ], [ 76 ], [ 82 ], [ 86 ], [ 88 ], [ 92, 94 ], [ 96 ], [ 98 ], [ 100 ], [ 102 ], [ 106 ], [ 108 ], [ 110 ], [ 112 ], [ 114 ], [ 116 ], [ 118 ], [ 122 ], [ 124 ], [ 126 ], [ 128 ], [ 130 ], [ 132 ], [ 136 ], [ 138 ], [ 140 ], [ 142 ], [ 144 ], [ 146 ], [ 148 ], [ 150 ], [ 154 ], [ 156 ], [ 158 ], [ 160 ], [ 162 ], [ 164 ], [ 166 ], [ 168 ], [ 172 ], [ 176 ], [ 178 ], [ 180 ], [ 186 ], [ 188 ], [ 192 ], [ 194 ], [ 196 ], [ 198 ], [ 202 ], [ 204 ], [ 206 ], [ 208 ], [ 212 ], [ 214 ], [ 216 ], [ 218 ], [ 220 ], [ 222 ], [ 224 ], [ 226 ], [ 230 ], [ 232 ], [ 234 ], [ 236 ], [ 238 ], [ 242, 244 ], [ 246 ], [ 248 ], [ 250 ], [ 252 ], [ 256 ], [ 262 ], [ 264 ], [ 266 ], [ 268 ], [ 270 ], [ 272 ], [ 274 ], [ 278 ], [ 280 ], [ 282 ], [ 286 ], [ 288 ], [ 292 ], [ 296, 298 ], [ 300 ], [ 304, 306 ], [ 308, 310 ], [ 312 ], [ 314 ] ]

[ "static int FUNC_0(FilterGraph *VAR_0, InputFilter *VAR_1,\nAVFilterInOut *VAR_2)\n{", "AVFilterContext *last_filter;", "const AVFilter *VAR_3 = avfilter_get_by_name(\"buffer\");", "InputStream *ist = VAR_1->ist;", "InputFile *f = input_files[ist->file_index];", "AVRational tb = ist->framerate.num ? av_inv_q(ist->framerate) :\nist->st->time_base;", "AVRational fr = ist->framerate;", "AVRational sar;", "AVBPrint args;", "char VAR_4[255];", "int VAR_5, VAR_6 = 0;", "int64_t tsoffset = 0;", "AVBufferSrcParameters *par = av_buffersrc_parameters_alloc();", "if (!par)\nreturn AVERROR(ENOMEM);", "memset(par, 0, sizeof(*par));", "par->format = AV_PIX_FMT_NONE;", "if (ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {", "av_log(NULL, AV_LOG_ERROR, \"Cannot connect video filter to audio input\\n\");", "return AVERROR(EINVAL);", "}", "if (!fr.num)\nfr = av_guess_frame_rate(input_files[ist->file_index]->ctx, ist->st, NULL);", "if (ist->dec_ctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {", "VAR_5 = sub2video_prepare(ist);", "if (VAR_5 < 0)\nreturn VAR_5;", "}", "sar = ist->st->sample_aspect_ratio.num ?\nist->st->sample_aspect_ratio :\nist->dec_ctx->sample_aspect_ratio;", "if(!sar.den)\nsar = (AVRational){0,1};", "av_bprint_init(&args, 0, 1);", "av_bprintf(&args,\n\"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:\"\n\"pixel_aspect=%d/%d:sws_param=flags=%d\", ist->resample_width,\nist->resample_height,\nist->hwaccel_retrieve_data ? ist->hwaccel_retrieved_pix_fmt : ist->resample_pix_fmt,\ntb.num, tb.den, sar.num, sar.den,\nSWS_BILINEAR + ((ist->dec_ctx->flags&AV_CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));", "if (fr.num && fr.den)\nav_bprintf(&args, \":frame_rate=%d/%d\", fr.num, fr.den);", "snprintf(VAR_4, sizeof(VAR_4), \"graph %d input from stream %d:%d\", VAR_0->index,\nist->file_index, ist->st->index);", "if ((VAR_5 = avfilter_graph_create_filter(&VAR_1->filter, VAR_3, VAR_4,\nargs.str, NULL, VAR_0->graph)) < 0)\nreturn VAR_5;", "par->hw_frames_ctx = ist->hw_frames_ctx;", "VAR_5 = av_buffersrc_parameters_set(VAR_1->filter, par);", "if (VAR_5 < 0)\nreturn VAR_5;", "av_freep(&par);", "last_filter = VAR_1->filter;", "if (ist->autorotate) {", "double VAR_7 = get_rotation(ist->st);", "if (fabs(VAR_7 - 90) < 1.0) {", "VAR_5 = insert_filter(&last_filter, &VAR_6, \"transpose\", \"clock\");", "} else if (fabs(VAR_7 - 180) < 1.0) {", "VAR_5 = insert_filter(&last_filter, &VAR_6, \"hflip\", NULL);", "if (VAR_5 < 0)\nreturn VAR_5;", "VAR_5 = insert_filter(&last_filter, &VAR_6, \"vflip\", NULL);", "} else if (fabs(VAR_7 - 270) < 1.0) {", "VAR_5 = insert_filter(&last_filter, &VAR_6, \"transpose\", \"cclock\");", "} else if (fabs(VAR_7) > 1.0) {", "char VAR_8[64];", "snprintf(VAR_8, sizeof(VAR_8), \"%f*PI/180\", VAR_7);", "VAR_5 = insert_filter(&last_filter, &VAR_6, \"rotate\", VAR_8);", "}", "if (VAR_5 < 0)\nreturn VAR_5;", "}", "if (ist->framerate.num) {", "AVFilterContext *setpts;", "snprintf(VAR_4, sizeof(VAR_4), \"force CFR for input from stream %d:%d\",\nist->file_index, ist->st->index);", "if ((VAR_5 = avfilter_graph_create_filter(&setpts,\navfilter_get_by_name(\"setpts\"),\nVAR_4, \"N\", NULL,\nVAR_0->graph)) < 0)\nreturn VAR_5;", "if ((VAR_5 = avfilter_link(last_filter, 0, setpts, 0)) < 0)\nreturn VAR_5;", "last_filter = setpts;", "}", "if (do_deinterlace) {", "AVFilterContext *yadif;", "snprintf(VAR_4, sizeof(VAR_4), \"deinterlace input from stream %d:%d\",\nist->file_index, ist->st->index);", "if ((VAR_5 = avfilter_graph_create_filter(&yadif,\navfilter_get_by_name(\"yadif\"),\nVAR_4, \"\", NULL,\nVAR_0->graph)) < 0)\nreturn VAR_5;", "if ((VAR_5 = avfilter_link(last_filter, 0, yadif, 0)) < 0)\nreturn VAR_5;", "last_filter = yadif;", "}", "snprintf(VAR_4, sizeof(VAR_4), \"trim for input stream %d:%d\",\nist->file_index, ist->st->index);", "if (copy_ts) {", "tsoffset = f->start_time == AV_NOPTS_VALUE ? 0 : f->start_time;", "if (!start_at_zero && f->ctx->start_time != AV_NOPTS_VALUE)\ntsoffset += f->ctx->start_time;", "}", "VAR_5 = insert_trim(((f->start_time == AV_NOPTS_VALUE) || !f->accurate_seek) ?\nAV_NOPTS_VALUE : tsoffset, f->recording_time,\n&last_filter, &VAR_6, VAR_4);", "if (VAR_5 < 0)\nreturn VAR_5;", "if ((VAR_5 = avfilter_link(last_filter, 0, VAR_2->filter_ctx, VAR_2->VAR_6)) < 0)\nreturn VAR_5;", "return 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, 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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15, 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55, 57 ], [ 61 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 73, 75, 77 ], [ 79, 81 ], [ 83 ], [ 85, 87, 89, 91, 93, 95, 97 ], [ 99, 101 ], [ 103, 105 ], [ 111, 113, 115 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165, 167 ], [ 169 ], [ 173 ], [ 175 ], [ 179, 181 ], [ 183, 185, 187, 189, 191 ], [ 195, 197 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 213, 215 ], [ 217, 219, 221, 223, 225 ], [ 229, 231 ], [ 235 ], [ 237 ], [ 241, 243 ], [ 245 ], [ 247 ], [ 249, 251 ], [ 253 ], [ 255, 257, 259 ], [ 261, 263 ], [ 267, 269 ], [ 271 ], [ 273 ] ]

[ "static void FUNC_0(OutputStream *VAR_0, int VAR_1)\n{", "AVCodecContext *enc;", "int VAR_2;", "double VAR_3, VAR_4, VAR_5;", "if (!vstats_file) {", "vstats_file = fopen(vstats_filename, \"w\");", "if (!vstats_file) {", "perror(\"fopen\");", "exit(1);", "}", "}", "enc = VAR_0->st->codec;", "if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {", "VAR_2 = VAR_0->VAR_2;", "fprintf(vstats_file, \"frame= %5d q= %2.1f \", VAR_2, enc->coded_frame->quality / (float)FF_QP2LAMBDA);", "if (enc->flags&CODEC_FLAG_PSNR)\nfprintf(vstats_file, \"PSNR= %6.2f \", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));", "fprintf(vstats_file,\"f_size= %6d \", VAR_1);", "VAR_3 = VAR_0->sync_opts * av_q2d(enc->time_base);", "if (VAR_3 < 0.01)\nVAR_3 = 0.01;", "VAR_4 = (VAR_1 * 8) / av_q2d(enc->time_base) / 1000.0;", "VAR_5 = (double)(video_size * 8) / VAR_3 / 1000.0;", "fprintf(vstats_file, \"s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s \",\n(double)video_size / 1024, VAR_3, VAR_4, VAR_5);", "fprintf(vstats_file, \"type= %c\\n\", av_get_picture_type_char(enc->coded_frame->pict_type));", "}", "}" ]

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

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

[ "void FUNC_0(VP8Context *VAR_0, uint8_t *VAR_1[3], VP8Macroblock *VAR_2,\nint VAR_3, int VAR_4)\n{", "AVCodecContext *avctx = VAR_0->avctx;", "int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;", "if (!(avctx->flags & CODEC_FLAG_EMU_EDGE && !VAR_4) && (VAR_0->deblock_filter || !VAR_4))\nxchg_mb_border(VAR_0->top_border[VAR_3+1], VAR_1[0], VAR_1[1], VAR_1[2],\nVAR_0->VAR_11, VAR_0->uvlinesize, VAR_3, VAR_4, VAR_0->mb_width,\nVAR_0->filter.simple, 1);", "if (VAR_2->VAR_7 < MODE_I4x4) {", "if (avctx->flags & CODEC_FLAG_EMU_EDGE) {", "VAR_7 = check_intra_pred8x8_mode_emuedge(VAR_2->VAR_7, VAR_3, VAR_4);", "} else {", "VAR_7 = check_intra_pred8x8_mode(VAR_2->VAR_7, VAR_3, VAR_4);", "}", "VAR_0->hpc.pred16x16[VAR_7](VAR_1[0], VAR_0->VAR_11);", "} else {", "uint8_t *ptr = VAR_1[0];", "uint8_t *intra4x4 = VAR_0->intra4x4_pred_mode_mb;", "uint8_t tr_top[4] = { 127, 127, 127, 127 };", "uint8_t *tr_right = ptr - VAR_0->VAR_11 + 16;", "if (VAR_3 == VAR_0->mb_width-1) {", "VAR_9 = tr_right[-1]*0x01010101;", "tr_right = (uint8_t *)&VAR_9;", "}", "if (VAR_2->skip)\nAV_ZERO128(VAR_0->non_zero_count_cache);", "for (VAR_6 = 0; VAR_6 < 4; VAR_6++) {", "uint8_t *topright = ptr + 4 - VAR_0->VAR_11;", "for (VAR_5 = 0; VAR_5 < 4; VAR_5++) {", "int VAR_10 = 0, VAR_11 = VAR_0->VAR_11;", "uint8_t *VAR_1 = ptr+4*VAR_5;", "DECLARE_ALIGNED(4, uint8_t, copy_dst)[5*8];", "if ((VAR_6 == 0 || VAR_5 == 3) && VAR_4 == 0 && avctx->flags & CODEC_FLAG_EMU_EDGE) {", "topright = tr_top;", "} else if (VAR_5 == 3)", "topright = tr_right;", "if (avctx->flags & CODEC_FLAG_EMU_EDGE) {", "VAR_7 = check_intra_pred4x4_mode_emuedge(intra4x4[VAR_5], VAR_3 + VAR_5, VAR_4 + VAR_6, &VAR_10);", "if (VAR_10) {", "VAR_1 = copy_dst + 12;", "VAR_11 = 8;", "if (!(VAR_4 + VAR_6)) {", "copy_dst[3] = 127U;", "* (uint32_t *) (copy_dst + 4) = 127U * 0x01010101U;", "} else {", "* (uint32_t *) (copy_dst + 4) = * (uint32_t *) (ptr+4*VAR_5-VAR_0->VAR_11);", "if (!(VAR_3 + VAR_5)) {", "copy_dst[3] = 129U;", "} else {", "copy_dst[3] = ptr[4*VAR_5-VAR_0->VAR_11-1];", "}", "}", "if (!(VAR_3 + VAR_5)) {", "copy_dst[11] =\ncopy_dst[19] =\ncopy_dst[27] =\ncopy_dst[35] = 129U;", "} else {", "copy_dst[11] = ptr[4*VAR_5 -1];", "copy_dst[19] = ptr[4*VAR_5+VAR_0->VAR_11 -1];", "copy_dst[27] = ptr[4*VAR_5+VAR_0->VAR_11*2-1];", "copy_dst[35] = ptr[4*VAR_5+VAR_0->VAR_11*3-1];", "}", "}", "} else {", "VAR_7 = intra4x4[VAR_5];", "}", "VAR_0->hpc.pred4x4[VAR_7](VAR_1, topright, VAR_11);", "if (VAR_10) {", "* (uint32_t *) (ptr+4*VAR_5) = * (uint32_t *) (copy_dst + 12);", "* (uint32_t *) (ptr+4*VAR_5+VAR_0->VAR_11) = * (uint32_t *) (copy_dst + 20);", "* (uint32_t *) (ptr+4*VAR_5+VAR_0->VAR_11*2) = * (uint32_t *) (copy_dst + 28);", "* (uint32_t *) (ptr+4*VAR_5+VAR_0->VAR_11*3) = * (uint32_t *) (copy_dst + 36);", "}", "VAR_8 = VAR_0->non_zero_count_cache[VAR_6][VAR_5];", "if (VAR_8) {", "if (VAR_8 == 1)\nVAR_0->vp8dsp.vp8_idct_dc_add(ptr+4*VAR_5, VAR_0->block[VAR_6][VAR_5], VAR_0->VAR_11);", "else\nVAR_0->vp8dsp.vp8_idct_add(ptr+4*VAR_5, VAR_0->block[VAR_6][VAR_5], VAR_0->VAR_11);", "}", "topright += 4;", "}", "ptr += 4*VAR_0->VAR_11;", "intra4x4 += 4;", "}", "}", "if (avctx->flags & CODEC_FLAG_EMU_EDGE) {", "VAR_7 = check_intra_pred8x8_mode_emuedge(VAR_0->chroma_pred_mode, VAR_3, VAR_4);", "} else {", "VAR_7 = check_intra_pred8x8_mode(VAR_0->chroma_pred_mode, VAR_3, VAR_4);", "}", "VAR_0->hpc.pred8x8[VAR_7](VAR_1[1], VAR_0->uvlinesize);", "VAR_0->hpc.pred8x8[VAR_7](VAR_1[2], VAR_0->uvlinesize);", "if (!(avctx->flags & CODEC_FLAG_EMU_EDGE && !VAR_4) && (VAR_0->deblock_filter || !VAR_4))\nxchg_mb_border(VAR_0->top_border[VAR_3+1], VAR_1[0], VAR_1[1], VAR_1[2],\nVAR_0->VAR_11, VAR_0->uvlinesize, VAR_3, VAR_4, VAR_0->mb_width,\nVAR_0->filter.simple, 0);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 17, 19, 21, 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 55 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73, 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137, 139, 141, 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 183 ], [ 185, 187 ], [ 189, 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 227, 229, 231, 233 ], [ 235 ] ]

[ "Aml *FUNC_0(void)\n{", "Aml *var = aml_bundle(0x11 , AML_BUFFER);", "return var;", "}" ]

[ 1, 0, 0, 0 ]

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

[ "static hwaddr FUNC_0(PowerPCCPU *cpu, hwaddr hash,\nppc_slb_t *slb, target_ulong ptem,\nppc_hash_pte64_t *pte)\n{", "CPUPPCState *env = &cpu->env;", "int VAR_0;", "uint64_t token;", "target_ulong pte0, pte1;", "target_ulong pte_index;", "pte_index = (hash & env->htab_mask) * HPTES_PER_GROUP;", "token = ppc_hash64_start_access(cpu, pte_index);", "if (!token) {", "return -1;", "}", "for (VAR_0 = 0; VAR_0 < HPTES_PER_GROUP; VAR_0++) {", "pte0 = ppc_hash64_load_hpte0(cpu, token, VAR_0);", "pte1 = ppc_hash64_load_hpte1(cpu, token, VAR_0);", "if (HPTE64_V_COMPARE(pte0, ptem)) {", "unsigned pshift = hpte_page_shift(slb->sps, pte0, pte1);", "if (pshift == 0) {", "continue;", "}", "pte->pte0 = pte0;", "pte->pte1 = pte1;", "ppc_hash64_stop_access(cpu, token);", "return (pte_index + VAR_0) * HASH_PTE_SIZE_64;", "}", "}", "ppc_hash64_stop_access(cpu, token);", "return -1;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 41 ], [ 43 ], [ 59 ], [ 61 ], [ 63 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 91 ], [ 93 ] ]

[ "static int FUNC_0(PCIQXLDevice *VAR_0)\n{", "uint8_t* config = VAR_0->pci.config;", "uint32_t pci_device_rev;", "uint32_t io_size;", "VAR_0->mode = QXL_MODE_UNDEFINED;", "VAR_0->generation = 1;", "VAR_0->num_memslots = NUM_MEMSLOTS;", "qemu_mutex_init(&VAR_0->track_lock);", "qemu_mutex_init(&VAR_0->async_lock);", "VAR_0->current_async = QXL_UNDEFINED_IO;", "VAR_0->guest_bug = 0;", "switch (VAR_0->revision) {", "case 1:\npci_device_rev = QXL_REVISION_STABLE_V04;", "io_size = 8;", "break;", "case 2:\npci_device_rev = QXL_REVISION_STABLE_V06;", "io_size = 16;", "break;", "case 3:\npci_device_rev = QXL_REVISION_STABLE_V10;", "io_size = 32;", "break;", "#if SPICE_SERVER_VERSION >= 0x000b01 && \\\ndefined(CONFIG_QXL_IO_MONITORS_CONFIG_ASYNC)\ncase 4:\npci_device_rev = QXL_REVISION_STABLE_V12;", "io_size = msb_mask(QXL_IO_RANGE_SIZE * 2 - 1);", "break;", "#endif\ndefault:\nerror_report(\"Invalid revision %d for VAR_0 device (max %d)\",\nVAR_0->revision, QXL_DEFAULT_REVISION);", "return -1;", "}", "pci_set_byte(&config[PCI_REVISION_ID], pci_device_rev);", "pci_set_byte(&config[PCI_INTERRUPT_PIN], 1);", "VAR_0->rom_size = qxl_rom_size();", "memory_region_init_ram(&VAR_0->rom_bar, \"VAR_0.vrom\", VAR_0->rom_size);", "vmstate_register_ram(&VAR_0->rom_bar, &VAR_0->pci.qdev);", "init_qxl_rom(VAR_0);", "init_qxl_ram(VAR_0);", "VAR_0->guest_surfaces.cmds = g_new0(QXLPHYSICAL, VAR_0->ssd.num_surfaces);", "memory_region_init_ram(&VAR_0->vram_bar, \"VAR_0.vram\", VAR_0->vram_size);", "vmstate_register_ram(&VAR_0->vram_bar, &VAR_0->pci.qdev);", "memory_region_init_alias(&VAR_0->vram32_bar, \"VAR_0.vram32\", &VAR_0->vram_bar,\n0, VAR_0->vram32_size);", "memory_region_init_io(&VAR_0->io_bar, &qxl_io_ops, VAR_0,\n\"VAR_0-ioports\", io_size);", "if (VAR_0->id == 0) {", "vga_dirty_log_start(&VAR_0->vga);", "}", "memory_region_set_flush_coalesced(&VAR_0->io_bar);", "pci_register_bar(&VAR_0->pci, QXL_IO_RANGE_INDEX,\nPCI_BASE_ADDRESS_SPACE_IO, &VAR_0->io_bar);", "pci_register_bar(&VAR_0->pci, QXL_ROM_RANGE_INDEX,\nPCI_BASE_ADDRESS_SPACE_MEMORY, &VAR_0->rom_bar);", "pci_register_bar(&VAR_0->pci, QXL_RAM_RANGE_INDEX,\nPCI_BASE_ADDRESS_SPACE_MEMORY, &VAR_0->vga.vram);", "pci_register_bar(&VAR_0->pci, QXL_VRAM_RANGE_INDEX,\nPCI_BASE_ADDRESS_SPACE_MEMORY, &VAR_0->vram32_bar);", "if (VAR_0->vram32_size < VAR_0->vram_size) {", "pci_register_bar(&VAR_0->pci, QXL_VRAM64_RANGE_INDEX,\nPCI_BASE_ADDRESS_SPACE_MEMORY |\nPCI_BASE_ADDRESS_MEM_TYPE_64 |\nPCI_BASE_ADDRESS_MEM_PREFETCH,\n&VAR_0->vram_bar);", "}", "dprint(VAR_0, 1, \"ram/%s: %d MB [region 0]\\n\",\nVAR_0->id == 0 ? \"pri\" : \"sec\",\nVAR_0->vga.vram_size / (1024*1024));", "dprint(VAR_0, 1, \"vram/32: %d MB [region 1]\\n\",\nVAR_0->vram32_size / (1024*1024));", "dprint(VAR_0, 1, \"vram/64: %d MB %s\\n\",\nVAR_0->vram_size / (1024*1024),\nVAR_0->vram32_size < VAR_0->vram_size ? \"[region 4]\" : \"[unmapped]\");", "VAR_0->ssd.VAR_0.base.sif = &qxl_interface.base;", "VAR_0->ssd.VAR_0.id = VAR_0->id;", "qemu_spice_add_interface(&VAR_0->ssd.VAR_0.base);", "qemu_add_vm_change_state_handler(qxl_vm_change_state_handler, VAR_0);", "init_pipe_signaling(VAR_0);", "qxl_reset_state(VAR_0);", "VAR_0->update_area_bh = qemu_bh_new(qxl_render_update_area_bh, VAR_0);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 57, 59, 61, 63 ], [ 65 ], [ 67 ], [ 69, 71, 73, 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107, 109 ], [ 113, 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 129, 131 ], [ 135, 137 ], [ 141, 143 ], [ 147, 149 ], [ 153 ], [ 163, 165, 167, 169, 171 ], [ 173 ], [ 179, 181, 183 ], [ 185, 187 ], [ 189, 191, 193 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 213 ], [ 217 ], [ 219 ] ]

[ "static void FUNC_0(DumpState *VAR_0, Error **VAR_1)\n{", "DiskDumpHeader64 *dh = NULL;", "KdumpSubHeader64 *kh = NULL;", "size_t size;", "uint32_t block_size;", "uint32_t sub_hdr_size;", "uint32_t bitmap_blocks;", "uint32_t status = 0;", "uint64_t offset_note;", "Error *local_err = NULL;", "size = sizeof(DiskDumpHeader64);", "dh = g_malloc0(size);", "strncpy(dh->signature, KDUMP_SIGNATURE, strlen(KDUMP_SIGNATURE));", "dh->header_version = cpu_to_dump32(VAR_0, 6);", "block_size = VAR_0->dump_info.page_size;", "dh->block_size = cpu_to_dump32(VAR_0, block_size);", "sub_hdr_size = sizeof(struct KdumpSubHeader64) + VAR_0->note_size;", "sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);", "dh->sub_hdr_size = cpu_to_dump32(VAR_0, sub_hdr_size);", "dh->max_mapnr = cpu_to_dump32(VAR_0, MIN(VAR_0->max_mapnr, UINT_MAX));", "dh->nr_cpus = cpu_to_dump32(VAR_0, VAR_0->nr_cpus);", "bitmap_blocks = DIV_ROUND_UP(VAR_0->len_dump_bitmap, block_size) * 2;", "dh->bitmap_blocks = cpu_to_dump32(VAR_0, bitmap_blocks);", "strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));", "if (VAR_0->flag_compress & DUMP_DH_COMPRESSED_ZLIB) {", "status |= DUMP_DH_COMPRESSED_ZLIB;", "#ifdef CONFIG_LZO\nif (VAR_0->flag_compress & DUMP_DH_COMPRESSED_LZO) {", "status |= DUMP_DH_COMPRESSED_LZO;", "#endif\n#ifdef CONFIG_SNAPPY\nif (VAR_0->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) {", "status |= DUMP_DH_COMPRESSED_SNAPPY;", "#endif\ndh->status = cpu_to_dump32(VAR_0, status);", "if (write_buffer(VAR_0->fd, 0, dh, size) < 0) {", "error_setg(VAR_1, \"dump: failed to write disk dump header\");", "goto out;", "size = sizeof(KdumpSubHeader64);", "kh = g_malloc0(size);", "kh->max_mapnr_64 = cpu_to_dump64(VAR_0, VAR_0->max_mapnr);", "kh->phys_base = cpu_to_dump64(VAR_0, VAR_0->dump_info.phys_base);", "kh->dump_level = cpu_to_dump32(VAR_0, DUMP_LEVEL);", "offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;", "kh->offset_note = cpu_to_dump64(VAR_0, offset_note);", "kh->note_size = cpu_to_dump64(VAR_0, VAR_0->note_size);", "if (write_buffer(VAR_0->fd, DISKDUMP_HEADER_BLOCKS *\nblock_size, kh, size) < 0) {", "error_setg(VAR_1, \"dump: failed to write kdump sub header\");", "goto out;", "VAR_0->note_buf = g_malloc0(VAR_0->note_size);", "VAR_0->note_buf_offset = 0;", "write_elf64_notes(buf_write_note, VAR_0, &local_err);", "if (local_err) {", "error_propagate(VAR_1, local_err);", "goto out;", "if (write_buffer(VAR_0->fd, offset_note, VAR_0->note_buf,\nVAR_0->note_size) < 0) {", "error_setg(VAR_1, \"dump: failed to write notes\");", "goto out;", "VAR_0->offset_dump_bitmap = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size) *\nblock_size;", "VAR_0->offset_page = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size + bitmap_blocks) *\nblock_size;", "out:\ng_free(dh);", "g_free(kh);", "g_free(VAR_0->note_buf);" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 28 ], [ 29 ], [ 30, 31 ], [ 32 ], [ 33, 34, 35 ], [ 36 ], [ 37, 38 ], [ 39 ], [ 40 ], [ 41 ], [ 43 ], [ 44 ], [ 46 ], [ 47 ], [ 48 ], [ 49 ], [ 50 ], [ 51 ], [ 52, 53 ], [ 54 ], [ 55 ], [ 57 ], [ 58 ], [ 60 ], [ 61 ], [ 62 ], [ 63 ], [ 64, 65 ], [ 66 ], [ 67 ], [ 69, 70 ], [ 72, 73 ], [ 74, 75 ], [ 76 ], [ 77 ] ]

[ "static void FUNC_0(void)\n{", "QOSState *qs;", "struct VAR_0 VAR_0;", "uint32_t ns;", "uint64_t ret;", "time_t t1, t2;", "qs = qtest_spapr_boot(\"-machine pseries\");", "g_assert(qs != NULL);", "t1 = time(NULL);", "ret = qrtas_get_time_of_day(qs->alloc, &VAR_0, &ns);", "g_assert_cmpint(ret, ==, 0);", "t2 = mktimegm(&VAR_0);", "g_assert(t2 - t1 < 5);", "qtest_shutdown(qs);", "}" ]

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

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

[ "int FUNC_0(QemuOptsList *VAR_0, const char *VAR_1,\nconst char *VAR_2, const char *VAR_3)\n{", "QemuOpts *opts;", "opts = qemu_opts_create(VAR_0, VAR_1, 1);", "if (opts == NULL) {", "return -1;", "}", "return qemu_opt_set(opts, VAR_2, VAR_3);", "}" ]

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

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

[ "static int FUNC_0(HTTPContext *VAR_0, const char *VAR_1, const char *VAR_2)\n{", "int VAR_3 = 4 + strlen(VAR_2) + strlen(VAR_1);", "int VAR_4 = !VAR_0->icy_metadata_headers;", "int VAR_5;", "if (VAR_0->icy_metadata_headers)\nVAR_3 += strlen(VAR_0->icy_metadata_headers);", "if ((VAR_5 = av_reallocp(&VAR_0->icy_metadata_headers, VAR_3)) < 0)\nreturn VAR_5;", "av_strlcatf(VAR_0->icy_metadata_headers, VAR_3, \"%VAR_0: %VAR_0\\n\", VAR_1, VAR_2);", "return 0;", "}" ]

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

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

[ "static av_cold void FUNC_0(void){", "static int VAR_0 = 0;", "if (!VAR_0) {", "int VAR_1;", "VAR_0 = 1;", "init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,\n&chroma_dc_coeff_token_len [0], 1, 1,\n&chroma_dc_coeff_token_bits[0], 1, 1, 1);", "for(VAR_1=0; VAR_1<4; VAR_1++){", "init_vlc(&coeff_token_vlc[VAR_1], COEFF_TOKEN_VLC_BITS, 4*17,\n&coeff_token_len [VAR_1][0], 1, 1,\n&coeff_token_bits[VAR_1][0], 1, 1, 1);", "}", "for(VAR_1=0; VAR_1<3; VAR_1++){", "init_vlc(&chroma_dc_total_zeros_vlc[VAR_1], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,\n&chroma_dc_total_zeros_len [VAR_1][0], 1, 1,\n&chroma_dc_total_zeros_bits[VAR_1][0], 1, 1, 1);", "}", "for(VAR_1=0; VAR_1<15; VAR_1++){", "init_vlc(&total_zeros_vlc[VAR_1], TOTAL_ZEROS_VLC_BITS, 16,\n&total_zeros_len [VAR_1][0], 1, 1,\n&total_zeros_bits[VAR_1][0], 1, 1, 1);", "}", "for(VAR_1=0; VAR_1<6; VAR_1++){", "init_vlc(&run_vlc[VAR_1], RUN_VLC_BITS, 7,\n&run_len [VAR_1][0], 1, 1,\n&run_bits[VAR_1][0], 1, 1, 1);", "}", "init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,\n&run_len [6][0], 1, 1,\n&run_bits[6][0], 1, 1, 1);", "}", "}" ]

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

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

[ "static USBDevice *FUNC_0(USBBus *bus, const char *filename)\n{", "USBDevice *dev;", "CharDriverState *cdrv;", "uint32_t vendorid = 0, productid = 0;", "char VAR_0[32];", "static int VAR_1;", "while (*filename && *filename != ':') {", "const char *VAR_2;", "char *VAR_3;", "if (strstart(filename, \"vendorid=\", &VAR_2)) {", "vendorid = strtol(VAR_2, &VAR_3, 16);", "if (VAR_3 == VAR_2 || (*VAR_3 && *VAR_3 != ',' && *VAR_3 != ':')) {", "error_report(\"bogus vendor ID %s\", VAR_2);", "return NULL;", "}", "filename = VAR_3;", "} else if (strstart(filename, \"productid=\", &VAR_2)) {", "productid = strtol(VAR_2, &VAR_3, 16);", "if (VAR_3 == VAR_2 || (*VAR_3 && *VAR_3 != ',' && *VAR_3 != ':')) {", "error_report(\"bogus product ID %s\", VAR_2);", "return NULL;", "}", "filename = VAR_3;", "} else {", "error_report(\"unrecognized serial USB option %s\", filename);", "return NULL;", "}", "while(*filename == ',')\nfilename++;", "}", "if (!*filename) {", "error_report(\"character device specification needed\");", "return NULL;", "}", "filename++;", "snprintf(VAR_0, sizeof(VAR_0), \"usbserial%d\", VAR_1++);", "cdrv = qemu_chr_new(VAR_0, filename, NULL);", "if (!cdrv)\nreturn NULL;", "dev = usb_create(bus, \"usb-serial\");", "qdev_prop_set_chr(&dev->qdev, \"chardev\", cdrv);", "if (vendorid)\nqdev_prop_set_uint16(&dev->qdev, \"vendorid\", vendorid);", "if (productid)\nqdev_prop_set_uint16(&dev->qdev, \"productid\", productid);", "qdev_init_nofail(&dev->qdev);", "return dev;", "}" ]

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