Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "void FUNC_0(CPUS390XState *VAR_0)\n{", "CPUState *cs = CPU(s390_env_get_cpu(VAR_0));", "int VAR_1, VAR_2, VAR_3;", "target_siginfo_t info;", "target_ulong addr;", "while (1) {", "cpu_exec_start(cs);", "VAR_1 = cpu_s390x_exec(cs);", "cpu_exec_end(cs);", "switch (VAR_1) {", "case EXCP_INTERRUPT:\nbreak;", "case EXCP_SVC:\nVAR_2 = VAR_0->int_svc_code;", "if (!VAR_2) {", "VAR_2 = VAR_0->regs[1];", "}", "VAR_0->psw.addr += VAR_0->int_svc_ilen;", "VAR_0->regs[2] = do_syscall(VAR_0, VAR_2, VAR_0->regs[2], VAR_0->regs[3],\nVAR_0->regs[4], VAR_0->regs[5],\nVAR_0->regs[6], VAR_0->regs[7], 0, 0);", "break;", "case EXCP_DEBUG:\nVAR_3 = gdb_handlesig(cs, TARGET_SIGTRAP);", "if (VAR_3) {", "VAR_2 = TARGET_TRAP_BRKPT;", "goto do_signal_pc;", "}", "break;", "case EXCP_PGM:\nVAR_2 = VAR_0->int_pgm_code;", "switch (VAR_2) {", "case PGM_OPERATION:\ncase PGM_PRIVILEGED:\nVAR_3 = TARGET_SIGILL;", "VAR_2 = TARGET_ILL_ILLOPC;", "goto do_signal_pc;", "case PGM_PROTECTION:\ncase PGM_ADDRESSING:\nVAR_3 = TARGET_SIGSEGV;", "VAR_2 = TARGET_SEGV_MAPERR;", "addr = VAR_0->__excp_addr;", "goto do_signal;", "case PGM_EXECUTE:\ncase PGM_SPECIFICATION:\ncase PGM_SPECIAL_OP:\ncase PGM_OPERAND:\ndo_sigill_opn:\nVAR_3 = TARGET_SIGILL;", "VAR_2 = TARGET_ILL_ILLOPN;", "goto do_signal_pc;", "case PGM_FIXPT_OVERFLOW:\nVAR_3 = TARGET_SIGFPE;", "VAR_2 = TARGET_FPE_INTOVF;", "goto do_signal_pc;", "case PGM_FIXPT_DIVIDE:\nVAR_3 = TARGET_SIGFPE;", "VAR_2 = TARGET_FPE_INTDIV;", "goto do_signal_pc;", "case PGM_DATA:\nVAR_2 = (VAR_0->fpc >> 8) & 0xff;", "if (VAR_2 == 0xff) {", "goto do_sigill_opn;", "} else {", "if (VAR_2 & 0x80) {", "VAR_2 = TARGET_FPE_FLTINV;", "} else if (VAR_2 & 0x40) {", "VAR_2 = TARGET_FPE_FLTDIV;", "} else if (VAR_2 & 0x20) {", "VAR_2 = TARGET_FPE_FLTOVF;", "} else if (VAR_2 & 0x10) {", "VAR_2 = TARGET_FPE_FLTUND;", "} else if (VAR_2 & 0x08) {", "VAR_2 = TARGET_FPE_FLTRES;", "} else {", "goto do_sigill_opn;", "}", "VAR_3 = TARGET_SIGFPE;", "goto do_signal_pc;", "}", "default:\nfprintf(stderr, \"Unhandled program exception: %#x\\VAR_2\", VAR_2);", "cpu_dump_state(cs, stderr, fprintf, 0);", "exit(EXIT_FAILURE);", "}", "break;", "do_signal_pc:\naddr = VAR_0->psw.addr;", "do_signal:\ninfo.si_signo = VAR_3;", "info.si_errno = 0;", "info.si_code = VAR_2;", "info._sifields._sigfault._addr = addr;", "queue_signal(VAR_0, info.si_signo, &info);", "break;", "default:\nfprintf(stderr, \"Unhandled trap: 0x%x\\VAR_2\", VAR_1);", "cpu_dump_state(cs, stderr, fprintf, 0);", "exit(EXIT_FAILURE);", "}", "process_pending_signals (VAR_0);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25, 29 ], [ 33, 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47, 49, 51 ], [ 53 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77, 79, 81 ], [ 83 ], [ 85 ], [ 87, 89, 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101, 103, 105, 107, 109, 111 ], [ 113 ], [ 115 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 137, 139 ], [ 141 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 187, 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201, 203 ], [ 205, 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 221, 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ] ]

[ "Object *FUNC_0(Object *parent, const gchar *part)\n{", "ObjectProperty *prop = object_property_find(parent, part, NULL);", "if (prop == NULL) {", "return NULL;", "}", "if (object_property_is_link(prop)) {", "LinkProperty *lprop = prop->opaque;", "return *lprop->child;", "} else if (object_property_is_child(prop)) {", "return prop->opaque;", "} else {", "return NULL;", "}", "}" ]

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

[ "static void *FUNC_0(QEMUFile *VAR_0, SCSIRequest *VAR_1)\n{", "SCSIBus *bus = VAR_1->bus;", "VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);", "VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);", "VirtIOSCSIReq *req;", "uint32_t n;", "req = g_malloc(sizeof(*req));", "qemu_get_be32s(VAR_0, &n);", "assert(n < vs->conf.num_queues);", "qemu_get_buffer(VAR_0, (unsigned char *)&req->elem, sizeof(req->elem));", "#ifdef NDEBUG\n#error building with NDEBUG is not supported\n#endif\nassert(req->elem.in_num <= ARRAY_SIZE(req->elem.in_sg));", "assert(req->elem.out_num <= ARRAY_SIZE(req->elem.out_sg));", "virtio_scsi_parse_req(s, vs->cmd_vqs[n], req);", "scsi_req_ref(VAR_1);", "req->VAR_1 = VAR_1;", "if (req->VAR_1->cmd.mode != SCSI_XFER_NONE) {", "int VAR_2 =\n(req->elem.in_num > 1 ? SCSI_XFER_FROM_DEV : SCSI_XFER_TO_DEV);", "assert(req->VAR_1->cmd.mode == VAR_2);", "}", "return req;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 33, 35, 37, 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53, 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ] ]

[ "static void FUNC_0(PhysPageMap *VAR_0)\n{", "while (VAR_0->sections_nb > 0) {", "MemoryRegionSection *section = &VAR_0->sections[--VAR_0->sections_nb];", "phys_section_destroy(section->mr);", "}", "g_free(VAR_0->sections);", "g_free(VAR_0->nodes);", "g_free(VAR_0);", "}" ]

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

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

[ "static void FUNC_0(ByteIOContext *VAR_0)\n{", "int VAR_1;", "if (VAR_0->eof_reached)\nreturn;", "if(VAR_0->update_checksum){", "if(VAR_0->buf_end > VAR_0->checksum_ptr)\nVAR_0->checksum= VAR_0->update_checksum(VAR_0->checksum, VAR_0->checksum_ptr, VAR_0->buf_end - VAR_0->checksum_ptr);", "VAR_0->checksum_ptr= VAR_0->buffer;", "}", "VAR_1 = VAR_0->read_packet(VAR_0->opaque, VAR_0->buffer, VAR_0->buffer_size);", "if (VAR_1 <= 0) {", "VAR_0->eof_reached = 1;", "if(VAR_1<0)\nVAR_0->error= VAR_1;", "} else {", "VAR_0->pos += VAR_1;", "VAR_0->buf_ptr = VAR_0->buffer;", "VAR_0->buf_end = VAR_0->buffer + VAR_1;", "}", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, uint8_t *VAR_1,\nint VAR_2, void *VAR_3)\n{", "ADXContext *c = VAR_0->priv_data;", "const int16_t *VAR_4 = VAR_3;", "uint8_t *dst = VAR_1;", "int VAR_5;", "if (!c->header_parsed) {", "int VAR_6 = adx_encode_header(VAR_0, dst, VAR_2);", "dst += VAR_6;", "c->header_parsed = 1;", "}", "for (VAR_5 = 0; VAR_5 < VAR_0->channels; VAR_5++) {", "adx_encode(c, dst, VAR_4 + VAR_5, &c->prev[VAR_5], VAR_0->channels);", "dst += BLOCK_SIZE;", "}", "return dst - VAR_1;", "}" ]

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

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

[ "static int FUNC_0(AVCodecParserContext *VAR_0, AVCodecContext *VAR_1,\nconst uint8_t **VAR_2, int *VAR_3,\nconst uint8_t *VAR_4, int VAR_5)\n{", "BMPParseContext *bpc = VAR_0->priv_data;", "uint64_t state = bpc->pc.state64;", "int VAR_6 = END_NOT_FOUND;", "int VAR_7 = 0;", "*VAR_3 = 0;", "restart:\nif (bpc->pc.frame_start_found <= 2+4+4) {", "for (; VAR_7 < VAR_5; VAR_7++) {", "state = (state << 8) | VAR_4[VAR_7];", "if (bpc->pc.frame_start_found == 0) {", "if ((state >> 48) == (('B' << 8) | 'M')) {", "bpc->fsize = av_bswap32(state >> 16);", "bpc->pc.frame_start_found = 1;", "}", "} else if (bpc->pc.frame_start_found == 2+4+4) {", "unsigned VAR_8 = av_bswap32(state);", "if (VAR_8 < 12 || VAR_8 > 200) {", "bpc->pc.frame_start_found = 0;", "continue;", "}", "bpc->pc.frame_start_found++;", "bpc->remaining_size = bpc->fsize + VAR_7 - 17;", "if (bpc->pc.index + VAR_7 > 17) {", "VAR_6 = VAR_7 - 17;", "state = 0;", "break;", "} else {", "bpc->pc.state64 = 0;", "goto restart;", "}", "} else if (bpc->pc.frame_start_found)", "bpc->pc.frame_start_found++;", "}", "bpc->pc.state64 = state;", "} else {", "if (bpc->remaining_size) {", "VAR_7 = FFMIN(bpc->remaining_size, VAR_5);", "bpc->remaining_size -= VAR_7;", "if (bpc->remaining_size)\ngoto flush;", "bpc->pc.frame_start_found = 0;", "goto restart;", "}", "}", "flush:\nif (ff_combine_frame(&bpc->pc, VAR_6, &VAR_4, &VAR_5) < 0)\nreturn VAR_5;", "if (VAR_6 != END_NOT_FOUND && VAR_6 < 0)\nbpc->pc.frame_start_found = FFMAX(bpc->pc.frame_start_found - VAR_7 - 1, 0);", "else\nbpc->pc.frame_start_found = 0;", "*VAR_2 = VAR_4;", "*VAR_3 = VAR_5;", "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 ]

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

[ "static int FUNC_0(AVFormatContext *VAR_0, int VAR_1, int64_t VAR_2, int VAR_3)\n{", "AVIContext *avi = VAR_0->priv_data;", "AVStream *st;", "int VAR_4, VAR_5;", "int64_t pos;", "AVIStream *ast;", "if (!avi->index_loaded) {", "avi_load_index(VAR_0);", "avi->index_loaded = 1;", "}", "assert(VAR_1>= 0);", "st = VAR_0->streams[VAR_1];", "ast= st->priv_data;", "VAR_5= av_index_search_timestamp(st, VAR_2 * FFMAX(ast->sample_size, 1), VAR_3);", "if(VAR_5<0)\nreturn -1;", "pos = st->index_entries[VAR_5].pos;", "VAR_2 = st->index_entries[VAR_5].VAR_2 / FFMAX(ast->sample_size, 1);", "av_dlog(VAR_0, \"XX %\"PRId64\" %d %\"PRId64\"\\n\",\nVAR_2, VAR_5, st->index_entries[VAR_5].VAR_2);", "if (CONFIG_DV_DEMUXER && avi->dv_demux) {", "assert(VAR_1 == 0);", "ff_dv_offset_reset(avi->dv_demux, VAR_2);", "avio_seek(VAR_0->pb, pos, SEEK_SET);", "avi->VAR_1= -1;", "return 0;", "}", "for(VAR_4 = 0; VAR_4 < VAR_0->nb_streams; VAR_4++) {", "AVStream *st2 = VAR_0->streams[VAR_4];", "AVIStream *ast2 = st2->priv_data;", "ast2->packet_size=\nast2->remaining= 0;", "if (ast2->sub_ctx) {", "seek_subtitle(st, st2, VAR_2);", "continue;", "}", "if (st2->nb_index_entries <= 0)\ncontinue;", "assert((int64_t)st2->time_base.num*ast2->rate == (int64_t)st2->time_base.den*ast2->scale);", "VAR_5 = av_index_search_timestamp(\nst2,\nav_rescale_q(VAR_2, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),\nVAR_3 | AVSEEK_FLAG_BACKWARD);", "if(VAR_5<0)\nVAR_5=0;", "if(!avi->non_interleaved){", "while(VAR_5>0 && st2->index_entries[VAR_5].pos > pos)\nVAR_5--;", "while(VAR_5+1 < st2->nb_index_entries && st2->index_entries[VAR_5].pos < pos)\nVAR_5++;", "}", "av_dlog(VAR_0, \"%\"PRId64\" %d %\"PRId64\"\\n\",\nVAR_2, VAR_5, st2->index_entries[VAR_5].VAR_2);", "ast2->frame_offset = st2->index_entries[VAR_5].VAR_2;", "}", "avio_seek(VAR_0->pb, pos, SEEK_SET);", "avi->VAR_1= -1;", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 45 ], [ 47 ], [ 51, 53 ], [ 57 ], [ 65 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 95, 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111, 113 ], [ 119 ], [ 121, 123, 125, 127 ], [ 129, 131 ], [ 135 ], [ 137, 139 ], [ 141, 143 ], [ 145 ], [ 149, 151 ], [ 155 ], [ 157 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ] ]

[ "static int FUNC_0(const char *VAR_0, const char *VAR_1)\n{", "int VAR_2;", "char *VAR_3;", "char VAR_4[16];", "av_strlcpy(VAR_4, VAR_1, sizeof(VAR_4));", "VAR_3 = strchr(VAR_4, ':');", "if (!VAR_3) {", "fprintf(stderr,\n\"Invalid value '%s' for option '%s', required syntax is 'index:value'\\n\",\nVAR_1, VAR_0);", "ffmpeg_exit(1);", "}", "*VAR_3++ = '\\0';", "VAR_2 = parse_number_or_die(VAR_0, VAR_4, OPT_INT, 0, INT_MAX);", "streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, VAR_2+1);", "streamid_map[VAR_2] = parse_number_or_die(VAR_0, VAR_3, OPT_INT, 0, INT_MAX);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(const uint8_t *VAR_0, int32_t VAR_1,\nuint8_t *VAR_2, int32_t VAR_3,\nint32_t VAR_4, uint8_t VAR_5)\n{", "uint32_t multiple8_cnt;", "for (multiple8_cnt = 2; multiple8_cnt--;) {", "avc_luma_midv_qrt_8w_msa(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4,\nVAR_5);", "VAR_0 += 8;", "VAR_2 += 8;", "}", "}" ]

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

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

[ "static void FUNC_0(yuv2rgb32_1)(SwsContext *c, const uint16_t *buf0,\nconst uint16_t *ubuf0, const uint16_t *ubuf1,\nconst uint16_t *vbuf0, const uint16_t *vbuf1,\nconst uint16_t *abuf0, uint8_t *dest,\nint dstW, int uvalpha, enum PixelFormat dstFormat,\nint flags, int y)\n{", "const uint16_t *VAR_0= buf0;", "if (uvalpha < 2048) {", "if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {", "__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1(%%REGBP, %5)\nYSCALEYUV2RGB1_ALPHA(%%REGBP)\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (abuf0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither)\n);", "} else {", "__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1(%%REGBP, %5)\n\"pcmpeqd %%mm7, %%mm7 \\n\\t\"\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (VAR_0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither)\n);", "}", "} else {", "if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {", "__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1b(%%REGBP, %5)\nYSCALEYUV2RGB1_ALPHA(%%REGBP)\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (abuf0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither)\n);", "} else {", "__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1b(%%REGBP, %5)\n\"pcmpeqd %%mm7, %%mm7 \\n\\t\"\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (VAR_0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither)\n);", "}", "}", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2, uint8_t *VAR_3, int VAR_4){", "HYuvContext *s = VAR_0->priv_data;", "const int VAR_5= s->VAR_5;", "const int VAR_6= s->VAR_5>>1;", "const int VAR_7= s->VAR_7;", "int VAR_8, VAR_9, VAR_10;", "AVFrame * const p= &s->picture;", "AVFrame *picture = VAR_1;", "*VAR_2 = 0;", "if (VAR_4 == 0)\nreturn 0;", "bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)VAR_3, VAR_4/4);", "init_get_bits(&s->gb, s->bitstream_buffer, VAR_4);", "p->reference= 0;", "if(VAR_0->get_buffer(VAR_0, p) < 0){", "fprintf(stderr, \"get_buffer() failed\\n\");", "return -1;", "}", "VAR_8= s->interlaced ? p->linesize[0]*2 : p->linesize[0];", "VAR_9= s->interlaced ? p->linesize[1]*2 : p->linesize[1];", "VAR_10= s->interlaced ? p->linesize[2]*2 : p->linesize[2];", "s->last_slice_end= 0;", "if(s->bitstream_bpp<24){", "int VAR_19, VAR_12;", "int VAR_13, VAR_14, VAR_15;", "int VAR_16, VAR_17, VAR_18;", "if(s->yuy2){", "p->VAR_1[0][3]= get_bits(&s->gb, 8);", "p->VAR_1[0][2]= get_bits(&s->gb, 8);", "p->VAR_1[0][1]= get_bits(&s->gb, 8);", "p->VAR_1[0][0]= get_bits(&s->gb, 8);", "fprintf(stderr, \"YUY2 output isnt implemenetd yet\\n\");", "return -1;", "}else{", "VAR_15= p->VAR_1[2][0]= get_bits(&s->gb, 8);", "VAR_13= p->VAR_1[0][1]= get_bits(&s->gb, 8);", "VAR_14= p->VAR_1[1][0]= get_bits(&s->gb, 8);", "p->VAR_1[0][0]= get_bits(&s->gb, 8);", "switch(s->predictor){", "case LEFT:\ncase PLANE:\ndecode_422_bitstream(s, VAR_5-2);", "VAR_13= add_left_prediction(p->VAR_1[0] + 2, s->temp[0], VAR_5-2, VAR_13);", "if(!(s->flags&CODEC_FLAG_GRAY)){", "VAR_14= add_left_prediction(p->VAR_1[1] + 1, s->temp[1], VAR_6-1, VAR_14);", "VAR_15= add_left_prediction(p->VAR_1[2] + 1, s->temp[2], VAR_6-1, VAR_15);", "}", "for(VAR_12=VAR_19=1; VAR_19<s->VAR_7; VAR_19++,VAR_12++){", "uint8_t *ydst, *udst, *vdst;", "if(s->bitstream_bpp==12){", "decode_gray_bitstream(s, VAR_5);", "ydst= p->VAR_1[0] + p->linesize[0]*VAR_19;", "VAR_13= add_left_prediction(ydst, s->temp[0], VAR_5, VAR_13);", "if(s->predictor == PLANE){", "if(VAR_19>s->interlaced)\ns->dsp.add_bytes(ydst, ydst - VAR_8, VAR_5);", "}", "VAR_19++;", "if(VAR_19>=s->VAR_7) break;", "}", "draw_slice(s, VAR_19);", "ydst= p->VAR_1[0] + p->linesize[0]*VAR_19;", "udst= p->VAR_1[1] + p->linesize[1]*VAR_12;", "vdst= p->VAR_1[2] + p->linesize[2]*VAR_12;", "decode_422_bitstream(s, VAR_5);", "VAR_13= add_left_prediction(ydst, s->temp[0], VAR_5, VAR_13);", "if(!(s->flags&CODEC_FLAG_GRAY)){", "VAR_14= add_left_prediction(udst, s->temp[1], VAR_6, VAR_14);", "VAR_15= add_left_prediction(vdst, s->temp[2], VAR_6, VAR_15);", "}", "if(s->predictor == PLANE){", "if(VAR_12>s->interlaced){", "s->dsp.add_bytes(ydst, ydst - VAR_8, VAR_5);", "if(!(s->flags&CODEC_FLAG_GRAY)){", "s->dsp.add_bytes(udst, udst - VAR_9, VAR_6);", "s->dsp.add_bytes(vdst, vdst - VAR_10, VAR_6);", "}", "}", "}", "}", "draw_slice(s, VAR_7);", "break;", "case MEDIAN:\ndecode_422_bitstream(s, VAR_5-2);", "VAR_13= add_left_prediction(p->VAR_1[0] + 2, s->temp[0], VAR_5-2, VAR_13);", "if(!(s->flags&CODEC_FLAG_GRAY)){", "VAR_14= add_left_prediction(p->VAR_1[1] + 1, s->temp[1], VAR_6-1, VAR_14);", "VAR_15= add_left_prediction(p->VAR_1[2] + 1, s->temp[2], VAR_6-1, VAR_15);", "}", "VAR_12=VAR_19=1;", "if(s->interlaced){", "decode_422_bitstream(s, VAR_5);", "VAR_13= add_left_prediction(p->VAR_1[0] + p->linesize[0], s->temp[0], VAR_5, VAR_13);", "if(!(s->flags&CODEC_FLAG_GRAY)){", "VAR_14= add_left_prediction(p->VAR_1[1] + p->linesize[2], s->temp[1], VAR_6, VAR_14);", "VAR_15= add_left_prediction(p->VAR_1[2] + p->linesize[1], s->temp[2], VAR_6, VAR_15);", "}", "VAR_19++; VAR_12++;", "}", "decode_422_bitstream(s, 4);", "VAR_13= add_left_prediction(p->VAR_1[0] + VAR_8, s->temp[0], 4, VAR_13);", "if(!(s->flags&CODEC_FLAG_GRAY)){", "VAR_14= add_left_prediction(p->VAR_1[1] + VAR_9, s->temp[1], 2, VAR_14);", "VAR_15= add_left_prediction(p->VAR_1[2] + VAR_10, s->temp[2], 2, VAR_15);", "}", "VAR_16= p->VAR_1[0][3];", "decode_422_bitstream(s, VAR_5-4);", "add_median_prediction(p->VAR_1[0] + VAR_8+4, p->VAR_1[0]+4, s->temp[0], VAR_5-4, &VAR_13, &VAR_16);", "if(!(s->flags&CODEC_FLAG_GRAY)){", "VAR_17= p->VAR_1[1][1];", "VAR_18= p->VAR_1[2][1];", "add_median_prediction(p->VAR_1[1] + VAR_9+2, p->VAR_1[1]+2, s->temp[1], VAR_6-2, &VAR_14, &VAR_17);", "add_median_prediction(p->VAR_1[2] + VAR_10+2, p->VAR_1[2]+2, s->temp[2], VAR_6-2, &VAR_15, &VAR_18);", "}", "VAR_19++; VAR_12++;", "for(; VAR_19<VAR_7; VAR_19++,VAR_12++){", "uint8_t *ydst, *udst, *vdst;", "if(s->bitstream_bpp==12){", "while(2*VAR_12 > VAR_19){", "decode_gray_bitstream(s, VAR_5);", "ydst= p->VAR_1[0] + p->linesize[0]*VAR_19;", "add_median_prediction(ydst, ydst - VAR_8, s->temp[0], VAR_5, &VAR_13, &VAR_16);", "VAR_19++;", "}", "if(VAR_19>=VAR_7) break;", "}", "draw_slice(s, VAR_19);", "decode_422_bitstream(s, VAR_5);", "ydst= p->VAR_1[0] + p->linesize[0]*VAR_19;", "udst= p->VAR_1[1] + p->linesize[1]*VAR_12;", "vdst= p->VAR_1[2] + p->linesize[2]*VAR_12;", "add_median_prediction(ydst, ydst - VAR_8, s->temp[0], VAR_5, &VAR_13, &VAR_16);", "if(!(s->flags&CODEC_FLAG_GRAY)){", "add_median_prediction(udst, udst - VAR_9, s->temp[1], VAR_6, &VAR_14, &VAR_17);", "add_median_prediction(vdst, vdst - VAR_10, s->temp[2], VAR_6, &VAR_15, &VAR_18);", "}", "}", "draw_slice(s, VAR_7);", "break;", "}", "}", "}else{", "int VAR_19;", "int VAR_19, VAR_20, VAR_21;", "const int VAR_22= (VAR_7-1)*p->linesize[0];", "if(s->bitstream_bpp==32){", "p->VAR_1[0][VAR_22+3]= get_bits(&s->gb, 8);", "VAR_19= p->VAR_1[0][VAR_22+2]= get_bits(&s->gb, 8);", "VAR_20= p->VAR_1[0][VAR_22+1]= get_bits(&s->gb, 8);", "VAR_21= p->VAR_1[0][VAR_22+0]= get_bits(&s->gb, 8);", "}else{", "VAR_19= p->VAR_1[0][VAR_22+2]= get_bits(&s->gb, 8);", "VAR_20= p->VAR_1[0][VAR_22+1]= get_bits(&s->gb, 8);", "VAR_21= p->VAR_1[0][VAR_22+0]= get_bits(&s->gb, 8);", "skip_bits(&s->gb, 8);", "}", "if(s->bgr32){", "switch(s->predictor){", "case LEFT:\ncase PLANE:\ndecode_bgr_bitstream(s, VAR_5-1);", "add_left_prediction_bgr32(p->VAR_1[0] + VAR_22+4, s->temp[0], VAR_5-1, &VAR_19, &VAR_20, &VAR_21);", "for(VAR_19=s->VAR_7-2; VAR_19>=0; VAR_19--){", "decode_bgr_bitstream(s, VAR_5);", "add_left_prediction_bgr32(p->VAR_1[0] + p->linesize[0]*VAR_19, s->temp[0], VAR_5, &VAR_19, &VAR_20, &VAR_21);", "if(s->predictor == PLANE){", "if((VAR_19&s->interlaced)==0){", "s->dsp.add_bytes(p->VAR_1[0] + p->linesize[0]*VAR_19,\np->VAR_1[0] + p->linesize[0]*VAR_19 + VAR_8, VAR_8);", "}", "}", "}", "draw_slice(s, VAR_7);", "break;", "default:\nfprintf(stderr, \"prediction type not supported!\\n\");", "}", "}else{", "fprintf(stderr, \"BGR24 output isnt implemenetd yet\\n\");", "return -1;", "}", "}", "emms_c();", "*picture= *p;", "VAR_0->release_buffer(VAR_0, p);", "*VAR_2 = sizeof(AVFrame);", "return (get_bits_count(&s->gb)+7)>>3;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 27, 29 ], [ 33 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107, 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 137 ], [ 141 ], [ 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 227 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 293 ], [ 295 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 321 ], [ 325 ], [ 327 ], [ 329 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 389 ], [ 391 ], [ 393, 395, 397 ], [ 399 ], [ 403 ], [ 405 ], [ 409 ], [ 411 ], [ 413 ], [ 415, 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429, 431 ], [ 433 ], [ 435 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 451 ], [ 455 ], [ 459 ], [ 463 ], [ 465 ] ]

[ "static QemuOpts *FUNC_0(QemuOptsList *list, const char *params,\nint permit_abbrev, bool defaults)\n{", "const char *VAR_0;", "char VAR_1[1024], *VAR_2 = NULL;", "const char *VAR_3;", "QemuOpts *opts;", "Error *local_err = NULL;", "assert(!permit_abbrev || list->implied_opt_name);", "VAR_0 = permit_abbrev ? list->implied_opt_name : NULL;", "if (strncmp(params, \"VAR_2=\", 3) == 0) {", "get_opt_value(VAR_1, sizeof(VAR_1), params+3);", "VAR_2 = VAR_1;", "} else if ((VAR_3 = strstr(params, \",VAR_2=\")) != NULL) {", "get_opt_value(VAR_1, sizeof(VAR_1), VAR_3+4);", "VAR_2 = VAR_1;", "}", "opts = qemu_opts_create(list, VAR_2, !defaults, &local_err);", "if (opts == NULL) {", "if (error_is_set(&local_err)) {", "qerror_report_err(local_err);", "error_free(local_err);", "}", "return NULL;", "}", "if (opts_do_parse(opts, params, VAR_0, defaults) != 0) {", "qemu_opts_del(opts);", "return NULL;", "}", "return opts;", "}" ]

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

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

[ 0, 0, 0, 0, 0 ]

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

[ "int VAR_0 avcodec_decode_audio4(AVCodecContext *avctx,\nAVFrame *frame,\nint *got_frame_ptr,\nAVPacket *avpkt)\n{", "int planar, channels;", "int ret = 0;", "*got_frame_ptr = 0;", "avctx->pkt = avpkt;", "if (!avpkt->data && avpkt->size) {", "av_log(avctx, AV_LOG_ERROR, \"invalid packet: NULL data, size != 0\\n\");", "return AVERROR(EINVAL);", "}", "apply_param_change(avctx, avpkt);", "if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size) {", "ret = avctx->codec->decode(avctx, frame, got_frame_ptr, avpkt);", "if (ret >= 0 && *got_frame_ptr) {", "avctx->frame_number++;", "frame->pkt_dts = avpkt->dts;", "if (frame->format == AV_SAMPLE_FMT_NONE)\nframe->format = avctx->sample_fmt;", "}", "}", "planar = av_sample_fmt_is_planar(frame->format);", "channels = av_get_channel_layout_nb_channels(frame->channel_layout);", "if (!(planar && channels > AV_NUM_DATA_POINTERS))\nframe->extended_data = frame->data;", "return ret;", "}" ]

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

[ [ 1, 2, 3, 4, 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20, 21 ], [ 22 ], [ 23 ], [ 27 ], [ 28 ], [ 29, 30 ], [ 31 ], [ 32 ] ]

[ "int FUNC_0(Jpeg2000Component *VAR_0, Jpeg2000CodingStyle *VAR_1, Jpeg2000QuantStyle *VAR_2, int VAR_3, int VAR_4, int VAR_5)\n{", "int VAR_6, VAR_7, VAR_8 = 0, VAR_9, VAR_10, VAR_11, VAR_12 = 1;", "if (VAR_9=ff_j2k_dwt_init(&VAR_0->dwt, VAR_0->coord, VAR_1->nreslevels-1, VAR_1->transform))\nreturn VAR_9;", "for (VAR_10 = 0; VAR_10 < 2; VAR_10++)", "VAR_12 *= VAR_0->coord[VAR_10][1] - VAR_0->coord[VAR_10][0];", "VAR_0->data = av_malloc(VAR_12 * sizeof(int));", "if (!VAR_0->data)\nreturn AVERROR(ENOMEM);", "VAR_0->reslevel = av_malloc(VAR_1->nreslevels * sizeof(Jpeg2000ResLevel));", "if (!VAR_0->reslevel)\nreturn AVERROR(ENOMEM);", "for (VAR_6 = 0; VAR_6 < VAR_1->nreslevels; VAR_6++) {", "int declvl = VAR_1->nreslevels - VAR_6;", "Jpeg2000ResLevel *reslevel = VAR_0->reslevel + VAR_6;", "for (VAR_10 = 0; VAR_10 < 2; VAR_10++)", "for (VAR_11 = 0; VAR_11 < 2; VAR_11++)", "reslevel->coord[VAR_10][VAR_11] =\nff_jpeg2000_ceildivpow2(VAR_0->coord[VAR_10][VAR_11], declvl - 1);", "if (VAR_6 == 0)\nreslevel->nbands = 1;", "else\nreslevel->nbands = 3;", "if (reslevel->coord[0][1] == reslevel->coord[0][0])\nreslevel->num_precincts_x = 0;", "else\nreslevel->num_precincts_x = ff_jpeg2000_ceildivpow2(reslevel->coord[0][1], VAR_1->log2_prec_width)\n- (reslevel->coord[0][0] >> VAR_1->log2_prec_width);", "if (reslevel->coord[1][1] == reslevel->coord[1][0])\nreslevel->num_precincts_y = 0;", "else\nreslevel->num_precincts_y = ff_jpeg2000_ceildivpow2(reslevel->coord[1][1], VAR_1->log2_prec_height)\n- (reslevel->coord[1][0] >> VAR_1->log2_prec_height);", "reslevel->band = av_malloc(reslevel->nbands * sizeof(Jpeg2000Band));", "if (!reslevel->band)\nreturn AVERROR(ENOMEM);", "for (VAR_7 = 0; VAR_7 < reslevel->nbands; VAR_7++, VAR_8++) {", "Jpeg2000Band *band = reslevel->band + VAR_7;", "int cblkno, precx, precy, precno;", "int x0, y0, x1, y1;", "int xi0, yi0, xi1, yi1;", "int cblkperprecw, cblkperprech;", "if (VAR_2->quantsty != JPEG2000_QSTY_NONE) {", "static const uint8_t lut_gain[2][4] = {{0, 0, 0, 0}, {0, 1, 1, 2}};", "int numbps;", "numbps = VAR_3 + lut_gain[VAR_1->transform][VAR_7 + VAR_6>0];", "band->stepsize = SHL(2048 + VAR_2->mant[VAR_8], 2 + numbps - VAR_2->expn[VAR_8]);", "} else", "band->stepsize = 1 << 13;", "if (VAR_6 == 0) {", "band->codeblock_width = 1 << FFMIN(VAR_1->log2_cblk_width, VAR_1->log2_prec_width-1);", "band->codeblock_height = 1 << FFMIN(VAR_1->log2_cblk_height, VAR_1->log2_prec_height-1);", "for (VAR_10 = 0; VAR_10 < 2; VAR_10++)", "for (VAR_11 = 0; VAR_11 < 2; VAR_11++)", "band->coord[VAR_10][VAR_11] = ff_jpeg2000_ceildivpow2(VAR_0->coord[VAR_10][VAR_11], declvl-1);", "} else{", "band->codeblock_width = 1 << FFMIN(VAR_1->log2_cblk_width, VAR_1->log2_prec_width);", "band->codeblock_height = 1 << FFMIN(VAR_1->log2_cblk_height, VAR_1->log2_prec_height);", "for (VAR_10 = 0; VAR_10 < 2; VAR_10++)", "for (VAR_11 = 0; VAR_11 < 2; VAR_11++)", "band->coord[VAR_10][VAR_11] = ff_jpeg2000_ceildivpow2(VAR_0->coord[VAR_10][VAR_11] - (((VAR_7+1>>VAR_10)&1) << declvl-1), declvl);", "}", "band->cblknx = ff_jpeg2000_ceildiv(band->coord[0][1], band->codeblock_width) - band->coord[0][0] / band->codeblock_width;", "band->cblkny = ff_jpeg2000_ceildiv(band->coord[1][1], band->codeblock_height) - band->coord[1][0] / band->codeblock_height;", "for (VAR_11 = 0; VAR_11 < 2; VAR_11++)", "band->coord[0][VAR_11] = ff_jpeg2000_ceildiv(band->coord[0][VAR_11], VAR_4);", "for (VAR_11 = 0; VAR_11 < 2; VAR_11++)", "band->coord[1][VAR_11] = ff_jpeg2000_ceildiv(band->coord[1][VAR_11], VAR_5);", "band->cblknx = ff_jpeg2000_ceildiv(band->cblknx, VAR_4);", "band->cblkny = ff_jpeg2000_ceildiv(band->cblkny, VAR_5);", "band->cblk = av_malloc(sizeof(Jpeg2000Cblk) * band->cblknx * band->cblkny);", "if (!band->cblk)\nreturn AVERROR(ENOMEM);", "band->prec = av_malloc(sizeof(Jpeg2000Cblk) * reslevel->num_precincts_x * reslevel->num_precincts_y);", "if (!band->prec)\nreturn AVERROR(ENOMEM);", "for (cblkno = 0; cblkno < band->cblknx * band->cblkny; cblkno++) {", "Jpeg2000Cblk *cblk = band->cblk + cblkno;", "cblk->zero = 0;", "cblk->lblock = 3;", "cblk->length = 0;", "cblk->lengthinc = 0;", "cblk->npasses = 0;", "}", "y0 = band->coord[1][0];", "y1 = ((band->coord[1][0] + (1<<VAR_1->log2_prec_height)) & ~((1<<VAR_1->log2_prec_height)-1)) - y0;", "yi0 = 0;", "yi1 = ff_jpeg2000_ceildivpow2(y1 - y0, VAR_1->log2_cblk_height) << VAR_1->log2_cblk_height;", "yi1 = FFMIN(yi1, band->cblkny);", "cblkperprech = 1<<(VAR_1->log2_prec_height - VAR_1->log2_cblk_height);", "for (precy = 0, precno = 0; precy < reslevel->num_precincts_y; precy++) {", "for (precx = 0; precx < reslevel->num_precincts_x; precx++, precno++) {", "band->prec[precno].yi0 = yi0;", "band->prec[precno].yi1 = yi1;", "}", "yi1 += cblkperprech;", "yi0 = yi1 - cblkperprech;", "yi1 = FFMIN(yi1, band->cblkny);", "}", "x0 = band->coord[0][0];", "x1 = ((band->coord[0][0] + (1<<VAR_1->log2_prec_width)) & ~((1<<VAR_1->log2_prec_width)-1)) - x0;", "xi0 = 0;", "xi1 = ff_jpeg2000_ceildivpow2(x1 - x0, VAR_1->log2_cblk_width) << VAR_1->log2_cblk_width;", "xi1 = FFMIN(xi1, band->cblknx);", "cblkperprecw = 1<<(VAR_1->log2_prec_width - VAR_1->log2_cblk_width);", "for (precx = 0, precno = 0; precx < reslevel->num_precincts_x; precx++) {", "for (precy = 0; precy < reslevel->num_precincts_y; precy++, precno = 0) {", "Jpeg2000Prec *prec = band->prec + precno;", "prec->xi0 = xi0;", "prec->xi1 = xi1;", "prec->cblkincl = ff_j2k_tag_tree_init(prec->xi1 - prec->xi0,\nprec->yi1 - prec->yi0);", "prec->zerobits = ff_j2k_tag_tree_init(prec->xi1 - prec->xi0,\nprec->yi1 - prec->yi0);", "if (!prec->cblkincl || !prec->zerobits)\nreturn AVERROR(ENOMEM);", "}", "xi1 += cblkperprecw;", "xi0 = xi1 - cblkperprecw;", "xi1 = FFMIN(xi1, band->cblknx);", "}", "}", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9, 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45, 47 ], [ 51, 53 ], [ 55, 57 ], [ 61, 63 ], [ 65, 67, 69 ], [ 73, 75 ], [ 77, 79, 81 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 167 ], [ 169 ], [ 173 ], [ 175, 177 ], [ 179 ], [ 181, 183 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259, 261 ], [ 263, 265 ], [ 267, 269 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ] ]

[ "static int FUNC_0(CPUState *VAR_0, DisasContext *VAR_1, uint32_t VAR_2)\n{", "TCGv tmp, tmp2;", "uint32_t rd = (VAR_2 >> 12) & 0xf;", "uint32_t cp = (VAR_2 >> 8) & 0xf;", "if (IS_USER(VAR_1)) {", "return 1;", "}", "if (VAR_2 & ARM_CP_RW_BIT) {", "if (!VAR_0->cp[cp].cp_read)\nreturn 1;", "gen_set_pc_im(VAR_1->pc);", "tmp = new_tmp();", "tmp2 = tcg_const_i32(VAR_2);", "gen_helper_get_cp(tmp, cpu_env, tmp2);", "tcg_temp_free(tmp2);", "store_reg(VAR_1, rd, tmp);", "} else {", "if (!VAR_0->cp[cp].cp_write)\nreturn 1;", "gen_set_pc_im(VAR_1->pc);", "tmp = load_reg(VAR_1, rd);", "tmp2 = tcg_const_i32(VAR_2);", "gen_helper_set_cp(cpu_env, tmp2, tmp);", "tcg_temp_free(tmp2);", "dead_tmp(tmp);", "}", "return 0;", "}" ]

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "AVStream *st;", "int VAR_2, VAR_3, VAR_4;", "av_init_packet(VAR_1);", "for(;;) {", "st = VAR_0->cur_st;", "if (st) {", "if (!st->need_parsing || !st->parser) {", "*VAR_1 = st->cur_pkt; st->cur_pkt.data= NULL;", "compute_pkt_fields(VAR_0, st, NULL, VAR_1);", "VAR_0->cur_st = NULL;", "if ((VAR_0->iformat->flags & AVFMT_GENERIC_INDEX) &&\n(VAR_1->flags & AV_PKT_FLAG_KEY) && VAR_1->dts != AV_NOPTS_VALUE) {", "ff_reduce_index(VAR_0, st->index);", "av_add_index_entry(st, VAR_1->pos, VAR_1->dts, 0, 0, AVINDEX_KEYFRAME);", "}", "break;", "} else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {", "VAR_2 = av_parser_parse2(st->parser, st->codec, &VAR_1->data, &VAR_1->size,\nst->cur_ptr, st->cur_len,\nst->cur_pkt.pts, st->cur_pkt.dts,\nst->cur_pkt.pos);", "st->cur_pkt.pts = AV_NOPTS_VALUE;", "st->cur_pkt.dts = AV_NOPTS_VALUE;", "st->cur_ptr += VAR_2;", "st->cur_len -= VAR_2;", "if (VAR_1->size) {", "got_packet:\nVAR_1->duration = 0;", "VAR_1->stream_index = st->index;", "VAR_1->pts = st->parser->pts;", "VAR_1->dts = st->parser->dts;", "VAR_1->pos = st->parser->pos;", "if(VAR_1->data == st->cur_pkt.data && VAR_1->size == st->cur_pkt.size){", "VAR_0->cur_st = NULL;", "VAR_1->destruct= st->cur_pkt.destruct;", "st->cur_pkt.destruct= NULL;", "st->cur_pkt.data = NULL;", "assert(st->cur_len == 0);", "}else{", "VAR_1->destruct = NULL;", "}", "compute_pkt_fields(VAR_0, st, st->parser, VAR_1);", "if((VAR_0->iformat->flags & AVFMT_GENERIC_INDEX) && VAR_1->flags & AV_PKT_FLAG_KEY){", "int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? VAR_1->pos : st->parser->frame_offset;", "ff_reduce_index(VAR_0, st->index);", "av_add_index_entry(st, pos, VAR_1->dts,\n0, 0, AVINDEX_KEYFRAME);", "}", "break;", "}", "} else {", "av_free_packet(&st->cur_pkt);", "VAR_0->cur_st = NULL;", "}", "} else {", "AVPacket cur_pkt;", "VAR_3 = av_read_packet(VAR_0, &cur_pkt);", "if (VAR_3 < 0) {", "if (VAR_3 == AVERROR(EAGAIN))\nreturn VAR_3;", "for(VAR_4 = 0; VAR_4 < VAR_0->nb_streams; VAR_4++) {", "st = VAR_0->streams[VAR_4];", "if (st->parser && st->need_parsing) {", "av_parser_parse2(st->parser, st->codec,\n&VAR_1->data, &VAR_1->size,\nNULL, 0,\nAV_NOPTS_VALUE, AV_NOPTS_VALUE,\nAV_NOPTS_VALUE);", "if (VAR_1->size)\ngoto got_packet;", "}", "}", "return VAR_3;", "}", "st = VAR_0->streams[cur_pkt.stream_index];", "st->cur_pkt= cur_pkt;", "if(st->cur_pkt.pts != AV_NOPTS_VALUE &&\nst->cur_pkt.dts != AV_NOPTS_VALUE &&\nst->cur_pkt.pts < st->cur_pkt.dts){", "av_log(VAR_0, AV_LOG_WARNING, \"Invalid timestamps stream=%d, pts=%\"PRId64\", dts=%\"PRId64\", size=%d\\n\",\nst->cur_pkt.stream_index,\nst->cur_pkt.pts,\nst->cur_pkt.dts,\nst->cur_pkt.size);", "}", "if(VAR_0->debug & FF_FDEBUG_TS)\nav_log(VAR_0, AV_LOG_DEBUG, \"av_read_packet stream=%d, pts=%\"PRId64\", dts=%\"PRId64\", size=%d, duration=%d, flags=%d\\n\",\nst->cur_pkt.stream_index,\nst->cur_pkt.pts,\nst->cur_pkt.dts,\nst->cur_pkt.size,\nst->cur_pkt.duration,\nst->cur_pkt.flags);", "VAR_0->cur_st = st;", "st->cur_ptr = st->cur_pkt.data;", "st->cur_len = st->cur_pkt.size;", "if (st->need_parsing && !st->parser && !(VAR_0->flags & AVFMT_FLAG_NOPARSE)) {", "st->parser = av_parser_init(st->codec->codec_id);", "if (!st->parser) {", "av_log(VAR_0, AV_LOG_WARNING, \"parser not found for codec \"\n\"%VAR_0, packets or times may be invalid.\\n\",\navcodec_get_name(st->codec->codec_id));", "st->need_parsing = AVSTREAM_PARSE_NONE;", "}else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){", "st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;", "}else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){", "st->parser->flags |= PARSER_FLAG_ONCE;", "}", "}", "}", "}", "if(VAR_0->debug & FF_FDEBUG_TS)\nav_log(VAR_0, AV_LOG_DEBUG, \"FUNC_0 stream=%d, pts=%\"PRId64\", dts=%\"PRId64\", size=%d, duration=%d, flags=%d\\n\",\nVAR_1->stream_index,\nVAR_1->pts,\nVAR_1->dts,\nVAR_1->size,\nVAR_1->duration,\nVAR_1->flags);", "return 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51, 53, 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113, 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145, 147 ], [ 151 ], [ 153 ], [ 155 ], [ 157, 159, 161, 163, 165 ], [ 167, 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 187, 189, 191 ], [ 193, 195, 197, 199, 201 ], [ 207 ], [ 211, 213, 215, 217, 219, 221, 223, 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241, 243, 245 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267, 269, 271, 273, 275, 277, 279, 281 ], [ 285 ], [ 287 ] ]

[ "void FUNC_0(CoRwlock *VAR_0)\n{", "assert(qemu_in_coroutine());", "if (VAR_0->writer) {", "VAR_0->writer = false;", "qemu_co_queue_restart_all(&VAR_0->queue);", "} else {", "VAR_0->reader--;", "assert(VAR_0->reader >= 0);", "if (!VAR_0->reader) {", "qemu_co_queue_next(&VAR_0->queue);", "}", "}", "}" ]

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

[ "void FUNC_0 (void)\n{", "T1 = T0;", "T0 += xer_ca;", "if (likely(!((T1 ^ (-1)) & (T1 ^ T0) & (1 << 31)))) {", "xer_ov = 0;", "} else {", "xer_so = 1;", "xer_ov = 1;", "}", "if (likely(T0 >= T1)) {", "xer_ca = 0;", "} else {", "xer_ca = 1;", "}", "}" ]

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

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

[ "void FUNC_0(IDEState *VAR_0)\n{", "int VAR_1, VAR_2, VAR_3;", "#ifdef DEBUG_IDE_ATAPI\nprintf(\"reply: tx_size=%d elem_tx_size=%d index=%d\\n\",\nVAR_0->packet_transfer_size,\nVAR_0->elementary_transfer_size,\nVAR_0->io_buffer_index);", "#endif\nif (VAR_0->packet_transfer_size <= 0) {", "ide_atapi_cmd_ok(VAR_0);", "ide_set_irq(VAR_0->bus);", "#ifdef DEBUG_IDE_ATAPI\nprintf(\"status=0x%x\\n\", VAR_0->status);", "#endif\n} else {", "if (VAR_0->lba != -1 && VAR_0->io_buffer_index >= VAR_0->cd_sector_size) {", "VAR_3 = cd_read_sector(VAR_0, VAR_0->lba, VAR_0->io_buffer, VAR_0->cd_sector_size);", "if (VAR_3 < 0) {", "ide_atapi_io_error(VAR_0, VAR_3);", "return;", "}", "VAR_0->lba++;", "VAR_0->io_buffer_index = 0;", "}", "if (VAR_0->elementary_transfer_size > 0) {", "VAR_2 = VAR_0->cd_sector_size - VAR_0->io_buffer_index;", "if (VAR_2 > VAR_0->elementary_transfer_size)\nVAR_2 = VAR_0->elementary_transfer_size;", "VAR_0->packet_transfer_size -= VAR_2;", "VAR_0->elementary_transfer_size -= VAR_2;", "VAR_0->io_buffer_index += VAR_2;", "ide_transfer_start(VAR_0, VAR_0->io_buffer + VAR_0->io_buffer_index - VAR_2,\nVAR_2, FUNC_0);", "} else {", "VAR_0->nsector = (VAR_0->nsector & ~7) | ATAPI_INT_REASON_IO;", "VAR_1 = atapi_byte_count_limit(VAR_0);", "#ifdef DEBUG_IDE_ATAPI\nprintf(\"VAR_1=%d\\n\", VAR_1);", "#endif\nVAR_2 = VAR_0->packet_transfer_size;", "if (VAR_2 > VAR_1) {", "if (VAR_1 & 1)\nVAR_1--;", "VAR_2 = VAR_1;", "}", "VAR_0->lcyl = VAR_2;", "VAR_0->hcyl = VAR_2 >> 8;", "VAR_0->elementary_transfer_size = VAR_2;", "if (VAR_0->lba != -1) {", "if (VAR_2 > (VAR_0->cd_sector_size - VAR_0->io_buffer_index))\nVAR_2 = (VAR_0->cd_sector_size - VAR_0->io_buffer_index);", "}", "VAR_0->packet_transfer_size -= VAR_2;", "VAR_0->elementary_transfer_size -= VAR_2;", "VAR_0->io_buffer_index += VAR_2;", "ide_transfer_start(VAR_0, VAR_0->io_buffer + VAR_0->io_buffer_index - VAR_2,\nVAR_2, FUNC_0);", "ide_set_irq(VAR_0->bus);", "#ifdef DEBUG_IDE_ATAPI\nprintf(\"status=0x%x\\n\", VAR_0->status);", "#endif\n}", "}", "}" ]

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

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

[ "static int FUNC_0(MLPDecodeContext *VAR_0, GetBitContext *VAR_1,\nunsigned int VAR_2, unsigned int VAR_3,\nunsigned int VAR_4)\n{", "SubStream *s = &VAR_0->substream[VAR_2];", "FilterParams *fp = &s->channel_params[VAR_3].filter_params[VAR_4];", "const int VAR_5 = VAR_4 ? MAX_IIR_ORDER : MAX_FIR_ORDER;", "const char VAR_6 = VAR_4 ? 'I' : 'F';", "int VAR_7, VAR_8;", "av_assert0(VAR_4 < 2);", "if (VAR_0->filter_changed[VAR_3][VAR_4]++ > 1) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Filters may change only once per access unit.\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_8 = get_bits(VAR_1, 4);", "if (VAR_8 > VAR_5) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"%cIR VAR_4 VAR_8 %d is greater than maximum %d.\\n\",\nVAR_6, VAR_8, VAR_5);", "return AVERROR_INVALIDDATA;", "}", "fp->VAR_8 = VAR_8;", "if (VAR_8 > 0) {", "int32_t *fcoeff = s->channel_params[VAR_3].coeff[VAR_4];", "int VAR_9, VAR_10;", "fp->shift = get_bits(VAR_1, 4);", "VAR_9 = get_bits(VAR_1, 5);", "VAR_10 = get_bits(VAR_1, 3);", "if (VAR_9 < 1 || VAR_9 > 16) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"%cIR VAR_4 VAR_9 must be between 1 and 16.\\n\",\nVAR_6);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_9 + VAR_10 > 16) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Sum of VAR_9 and VAR_10 for %cIR VAR_4 must be 16 or less.\\n\",\nVAR_6);", "return AVERROR_INVALIDDATA;", "}", "for (VAR_7 = 0; VAR_7 < VAR_8; VAR_7++)", "fcoeff[VAR_7] = get_sbits(VAR_1, VAR_9) * (1 << VAR_10);", "if (get_bits1(VAR_1)) {", "int VAR_11, VAR_12;", "if (VAR_4 == FIR) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"FIR VAR_4 has state data specified.\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_11 = get_bits(VAR_1, 4);", "VAR_12 = get_bits(VAR_1, 4);", "for (VAR_7 = 0; VAR_7 < VAR_8; VAR_7++)", "fp->state[VAR_7] = VAR_11 ? get_sbits(VAR_1, VAR_11) << VAR_12 : 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, 1, 0, 0, 0, 0 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41, 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73, 75, 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 87, 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ] ]

[ "static int FUNC_0(AVFilterLink *VAR_0, AVFilterBufferRef *VAR_1)\n{", "IlContext *il = VAR_0->dst->priv;", "AVFilterLink *outlink = VAR_0->dst->outputs[0];", "AVFilterBufferRef *out;", "int VAR_2;", "out = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);", "if (!out) {", "avfilter_unref_bufferp(&VAR_1);", "return AVERROR(ENOMEM);", "}", "avfilter_copy_buffer_ref_props(out, VAR_1);", "interleave(out->data[0], VAR_1->data[0],\nil->width, VAR_0->h,\nout->linesize[0], VAR_1->linesize[0],\nil->luma_mode, il->luma_swap);", "if (il->nb_planes > 2) {", "interleave(out->data[1], VAR_1->data[1],\nil->chroma_width, il->chroma_height,\nout->linesize[1], VAR_1->linesize[1],\nil->chroma_mode, il->chroma_swap);", "interleave(out->data[2], VAR_1->data[2],\nil->chroma_width, il->chroma_height,\nout->linesize[2], VAR_1->linesize[2],\nil->chroma_mode, il->chroma_swap);", "}", "if (il->nb_planes == 2 && il->nb_planes == 4) {", "int VAR_3 = il->nb_planes - 1;", "interleave(out->data[VAR_3], VAR_1->data[VAR_3],\nil->width, VAR_0->h,\nout->linesize[VAR_3], VAR_1->linesize[VAR_3],\nil->alpha_mode, il->alpha_swap);", "}", "VAR_2 = ff_filter_frame(outlink, out);", "avfilter_unref_bufferp(&VAR_1);", "return VAR_2;", "}" ]

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

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

[ "FUNC_0(WmallDecodeCtx *VAR_0)\n{", "int VAR_1, VAR_2, VAR_3;", "VAR_0->lpc_order = get_bits(&VAR_0->gb, 5) + 1;", "VAR_0->lpc_scaling = get_bits(&VAR_0->gb, 4);", "VAR_0->lpc_intbits = get_bits(&VAR_0->gb, 3) + 1;", "VAR_3 = VAR_0->lpc_scaling + VAR_0->lpc_intbits;", "for(VAR_1 = 0; VAR_1 < VAR_0->num_channels; VAR_1++) {", "for(VAR_2 = 0; VAR_2 < VAR_0->lpc_order; VAR_2++) {", "VAR_0->lpc_coefs[VAR_1][VAR_2] = get_sbits(&VAR_0->gb, VAR_3);", "}", "}", "}" ]

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

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

[ "static double FUNC_0(AVFilterContext *VAR_0, AVFrame *VAR_1, AVFrame *VAR_2)\n{", "FrameRateContext *s = VAR_0->priv;", "double VAR_3 = 0;", "ff_dlog(VAR_0, \"FUNC_0()\\n\");", "if (VAR_1->height == VAR_2->height &&\nVAR_1->width == VAR_2->width) {", "int64_t sad;", "double VAR_4, VAR_5;", "ff_dlog(VAR_0, \"FUNC_0() process\\n\");", "if (s->bitdepth == 8)\nsad = scene_sad8(s, VAR_1->data[0], VAR_1->linesize[0], VAR_2->data[0], VAR_2->linesize[0], VAR_1->height);", "else\nsad = scene_sad16(s, (const uint16_t*)VAR_1->data[0], VAR_1->linesize[0] >> 1, (const uint16_t*)VAR_2->data[0], VAR_2->linesize[0] >> 1, VAR_1->height);", "VAR_4 = (double)sad * 100.0 / (VAR_1->height * VAR_1->width) / (1 << s->bitdepth);", "VAR_5 = fabs(VAR_4 - s->prev_mafd);", "VAR_3 = av_clipf(FFMIN(VAR_4, VAR_5), 0, 100.0);", "s->prev_mafd = VAR_4;", "}", "ff_dlog(VAR_0, \"FUNC_0() result is:%f\\n\", VAR_3);", "return VAR_3;", "}" ]

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

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

[ "int FUNC_0(int VAR_0,char* VAR_1[]){", "int VAR_2, VAR_3;", "uint64_t sse=0;", "uint64_t dev;", "FILE *f[2];", "uint8_t buf[2][SIZE];", "uint64_t psnr;", "int VAR_4= VAR_0<4 ? 1 : atoi(VAR_1[3]);", "int64_t max= (1<<(8*VAR_4))-1;", "int VAR_5= VAR_0<5 ? 0 : atoi(VAR_1[4]);", "int VAR_6 = VAR_0<6 ? 0 : atoi(VAR_1[5]);", "if(VAR_0<3){", "printf(\"tiny_psnr <file1> <file2> [<elem size> [<VAR_5> [<skip bytes>]]]\\n\");", "printf(\"For WAV files use the following:\\n\");", "printf(\"./tiny_psnr file1.wav file2.wav 2 0 44 to skip the header.\\n\");", "return -1;", "}", "f[0]= fopen(VAR_1[1], \"rb\");", "f[1]= fopen(VAR_1[2], \"rb\");", "if(!f[0] || !f[1]){", "fprintf(stderr, \"Could not open input files.\\n\");", "return -1;", "}", "fseek(f[VAR_5<0], VAR_5 < 0 ? -VAR_5 : VAR_5, SEEK_SET);", "fseek(f[0],VAR_6,SEEK_CUR);", "fseek(f[1],VAR_6,SEEK_CUR);", "for(VAR_2=0;;){", "if( fread(buf[0], SIZE, 1, f[0]) != 1) break;", "if( fread(buf[1], SIZE, 1, f[1]) != 1) break;", "for(VAR_3=0; VAR_3<SIZE; VAR_2++,VAR_3++){", "int64_t a= buf[0][VAR_3];", "int64_t b= buf[1][VAR_3];", "if(VAR_4==2){", "a= (int16_t)(a | (buf[0][++VAR_3]<<8));", "b= (int16_t)(b | (buf[1][ VAR_3]<<8));", "}", "sse += (a-b) * (a-b);", "}", "}", "if(!VAR_2) VAR_2=1;", "dev= int_sqrt( ((sse/VAR_2)*F*F) + (((sse%VAR_2)*F*F) + VAR_2/2)/VAR_2 );", "if(sse)\npsnr= ((2*log16(max<<16) + log16(VAR_2) - log16(sse))*284619LL*F + (1<<31)) / (1LL<<32);", "else\npsnr= 100*F-1;", "printf(\"stddev:%3d.%02d PSNR:%2d.%02d bytes:%d\\n\",\n(int)(dev/F), (int)(dev%F),\n(int)(psnr/F), (int)(psnr%F),\nVAR_2*VAR_4);", "return 0;", "}" ]

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

[ [ 1 ], [ 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99, 101 ], [ 105, 107, 109, 111 ], [ 113 ], [ 115 ] ]

[ "StrongARMState *FUNC_0(MemoryRegion *sysmem,\nunsigned int sdram_size, const char *rev)\n{", "StrongARMState *s;", "int VAR_0;", "s = g_new0(StrongARMState, 1);", "if (!rev) {", "rev = \"sa1110-b5\";", "}", "if (strncmp(rev, \"sa1110\", 6)) {", "error_report(\"Machine requires a SA1110 processor.\");", "exit(1);", "}", "s->cpu = ARM_CPU(cpu_generic_init(TYPE_ARM_CPU, rev));", "if (!s->cpu) {", "error_report(\"Unable to find CPU definition\");", "exit(1);", "}", "memory_region_allocate_system_memory(&s->sdram, NULL, \"strongarm.sdram\",\nsdram_size);", "memory_region_add_subregion(sysmem, SA_SDCS0, &s->sdram);", "s->pic = sysbus_create_varargs(\"strongarm_pic\", 0x90050000,\nqdev_get_gpio_in(DEVICE(s->cpu), ARM_CPU_IRQ),\nqdev_get_gpio_in(DEVICE(s->cpu), ARM_CPU_FIQ),\nNULL);", "sysbus_create_varargs(\"pxa25x-timer\", 0x90000000,\nqdev_get_gpio_in(s->pic, SA_PIC_OSTC0),\nqdev_get_gpio_in(s->pic, SA_PIC_OSTC1),\nqdev_get_gpio_in(s->pic, SA_PIC_OSTC2),\nqdev_get_gpio_in(s->pic, SA_PIC_OSTC3),\nNULL);", "sysbus_create_simple(TYPE_STRONGARM_RTC, 0x90010000,\nqdev_get_gpio_in(s->pic, SA_PIC_RTC_ALARM));", "s->gpio = strongarm_gpio_init(0x90040000, s->pic);", "s->ppc = sysbus_create_varargs(TYPE_STRONGARM_PPC, 0x90060000, NULL);", "for (VAR_0 = 0; sa_serial[VAR_0].io_base; VAR_0++) {", "DeviceState *dev = qdev_create(NULL, TYPE_STRONGARM_UART);", "qdev_prop_set_chr(dev, \"chardev\", serial_hds[VAR_0]);", "qdev_init_nofail(dev);", "sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0,\nsa_serial[VAR_0].io_base);", "sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0,\nqdev_get_gpio_in(s->pic, sa_serial[VAR_0].irq));", "}", "s->ssp = sysbus_create_varargs(TYPE_STRONGARM_SSP, 0x80070000,\nqdev_get_gpio_in(s->pic, SA_PIC_SSP), NULL);", "s->ssp_bus = (SSIBus *)qdev_get_child_bus(s->ssp, \"ssi\");", "return s;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 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 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49, 51 ], [ 53 ], [ 57, 59, 61, 63 ], [ 67, 69, 71, 73, 75, 77 ], [ 81, 83 ], [ 87 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 107, 109 ], [ 111 ], [ 115, 117 ], [ 119 ], [ 123 ], [ 125 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, int VAR_1)\n{", "struct VAR_2 *VAR_2 = VAR_0->priv_data;", "struct ogg_stream *VAR_3 = VAR_2->streams + VAR_1;", "AVStream *st = VAR_0->streams[VAR_1];", "struct oggcelt_private *VAR_4 = VAR_3->private;", "uint8_t *p = VAR_3->buf + VAR_3->pstart;", "if (VAR_3->psize == 60 &&\n!memcmp(p, ff_celt_codec.magic, ff_celt_codec.magicsize)) {", "uint32_t version, sample_rate, nb_channels;", "uint32_t overlap, extra_headers;", "VAR_4 = av_malloc(sizeof(struct oggcelt_private));", "if (!VAR_4)\nreturn AVERROR(ENOMEM);", "if (ff_alloc_extradata(st->codecpar, 2 * sizeof(uint32_t)) < 0) {", "av_free(VAR_4);", "return AVERROR(ENOMEM);", "}", "version = AV_RL32(p + 28);", "sample_rate = AV_RL32(p + 36);", "nb_channels = AV_RL32(p + 40);", "overlap = AV_RL32(p + 48);", "extra_headers = AV_RL32(p + 56);", "st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;", "st->codecpar->codec_id = AV_CODEC_ID_CELT;", "st->codecpar->sample_rate = sample_rate;", "st->codecpar->channels = nb_channels;", "if (sample_rate)\navpriv_set_pts_info(st, 64, 1, sample_rate);", "VAR_4->extra_headers_left = 1 + extra_headers;", "av_free(VAR_3->private);", "VAR_3->private = VAR_4;", "AV_WL32(st->codecpar->extradata + 0, overlap);", "AV_WL32(st->codecpar->extradata + 4, version);", "return 1;", "} else if (VAR_4 && VAR_4->extra_headers_left) {", "ff_vorbis_stream_comment(VAR_0, st, p, VAR_3->psize);", "VAR_4->extra_headers_left--;", "return 1;", "} else {", "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, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

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

[ "static abi_long FUNC_0(int fd, struct target_msghdr *msgp,\nint flags, int send)\n{", "abi_long ret, len;", "struct msghdr VAR_0;", "int VAR_1;", "struct iovec *VAR_2;", "abi_ulong target_vec;", "if (msgp->msg_name) {", "VAR_0.msg_namelen = tswap32(msgp->msg_namelen);", "VAR_0.msg_name = alloca(VAR_0.msg_namelen+1);", "ret = target_to_host_sockaddr(fd, VAR_0.msg_name,\ntswapal(msgp->msg_name),\nVAR_0.msg_namelen);", "if (ret) {", "goto out2;", "}", "} else {", "VAR_0.msg_name = NULL;", "VAR_0.msg_namelen = 0;", "}", "VAR_0.msg_controllen = 2 * tswapal(msgp->msg_controllen);", "VAR_0.msg_control = alloca(VAR_0.msg_controllen);", "VAR_0.msg_flags = tswap32(msgp->msg_flags);", "VAR_1 = tswapal(msgp->msg_iovlen);", "target_vec = tswapal(msgp->msg_iov);", "VAR_2 = lock_iovec(send ? VERIFY_READ : VERIFY_WRITE,\ntarget_vec, VAR_1, send);", "if (VAR_2 == NULL) {", "ret = -host_to_target_errno(errno);", "goto out2;", "}", "VAR_0.msg_iovlen = VAR_1;", "VAR_0.msg_iov = VAR_2;", "if (send) {", "if (fd_trans_target_to_host_data(fd)) {", "ret = fd_trans_target_to_host_data(fd)(VAR_0.msg_iov->iov_base,\nVAR_0.msg_iov->iov_len);", "} else {", "ret = target_to_host_cmsg(&VAR_0, msgp);", "}", "if (ret == 0) {", "ret = get_errno(safe_sendmsg(fd, &VAR_0, flags));", "}", "} else {", "ret = get_errno(safe_recvmsg(fd, &VAR_0, flags));", "if (!is_error(ret)) {", "len = ret;", "if (fd_trans_host_to_target_data(fd)) {", "ret = fd_trans_host_to_target_data(fd)(VAR_0.msg_iov->iov_base,\nlen);", "} else {", "ret = host_to_target_cmsg(msgp, &VAR_0);", "}", "if (!is_error(ret)) {", "msgp->msg_namelen = tswap32(VAR_0.msg_namelen);", "if (VAR_0.msg_name != NULL) {", "ret = host_to_target_sockaddr(tswapal(msgp->msg_name),\nVAR_0.msg_name, VAR_0.msg_namelen);", "if (ret) {", "goto out;", "}", "}", "ret = len;", "}", "}", "}", "out:\nunlock_iovec(VAR_2, target_vec, VAR_1, !send);", "out2:\nreturn ret;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25, 27, 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 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 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 145, 147 ], [ 149, 151 ], [ 153 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, GetBitContext *VAR_1,\nint VAR_2, int *VAR_3)\n{", "int VAR_4 = 0, VAR_5 = 0;", "unsigned int VAR_6;", "for(;;){", "VAR_6 = get_vlc2(VAR_1, ccitt_vlc[VAR_4].table, 9, 2);", "VAR_5 += VAR_6;", "if(VAR_6 < 64){", "VAR_2 -= VAR_5;", "*VAR_3++ = VAR_5;", "if(VAR_2 <= 0){", "if(!VAR_2)\nbreak;", "VAR_3[-1] = 0;", "av_log(VAR_0, AV_LOG_ERROR, \"Run went out of bounds\\n\");", "return -1;", "}", "VAR_5 = 0;", "VAR_4 = !VAR_4;", "}else if((int)VAR_6 == -1){", "av_log(VAR_0, AV_LOG_ERROR, \"Incorrect code\\n\");", "return -1;", "}", "}", "*VAR_3++ = 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 ]

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

[ "static int FUNC_0(Jpeg2000DecoderContext *VAR_0, int VAR_1, Jpeg2000QuantStyle *VAR_2)\n{", "int VAR_3, VAR_4;", "if (VAR_0->buf_end - VAR_0->buf < 1)\nreturn AVERROR(EINVAL);", "VAR_4 = bytestream_get_byte(&VAR_0->buf);", "VAR_2->nguardbits = VAR_4 >> 5;", "VAR_2->quantsty = VAR_4 & 0x1f;", "if (VAR_2->quantsty == JPEG2000_QSTY_NONE) {", "VAR_1 -= 3;", "if (VAR_0->buf_end - VAR_0->buf < VAR_1 || 32*3 < VAR_1)\nreturn AVERROR(EINVAL);", "for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++)", "VAR_2->expn[VAR_3] = bytestream_get_byte(&VAR_0->buf) >> 3;", "} else if (VAR_2->quantsty == JPEG2000_QSTY_SI) {", "if (VAR_0->buf_end - VAR_0->buf < 2)\nreturn AVERROR(EINVAL);", "VAR_4 = bytestream_get_be16(&VAR_0->buf);", "VAR_2->expn[0] = VAR_4 >> 11;", "VAR_2->mant[0] = VAR_4 & 0x7ff;", "for (VAR_3 = 1; VAR_3 < 32 * 3; VAR_3++) {", "int VAR_5 = FFMAX(0, VAR_2->expn[0] - (VAR_3 - 1) / 3);", "VAR_2->expn[VAR_3] = VAR_5;", "VAR_2->mant[VAR_3] = VAR_2->mant[0];", "}", "} else {", "VAR_1 = (VAR_1 - 3) >> 1;", "if (VAR_0->buf_end - VAR_0->buf < 2 * VAR_1 || 32*3 < VAR_1)\nreturn AVERROR(EINVAL);", "for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++) {", "VAR_4 = bytestream_get_be16(&VAR_0->buf);", "VAR_2->expn[VAR_3] = VAR_4 >> 11;", "VAR_2->mant[VAR_3] = VAR_4 & 0x7ff;", "}", "}", "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 ], [ 9, 11 ], [ 15 ], [ 19 ], [ 21 ], [ 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 ] ]

[ "void FUNC_0(void *VAR_0, int VAR_1)\n{", "#ifdef TARGET_I386\nuint32_t old = ((CPUX86State*)VAR_0)->regs[R_EAX];", "uint32_t *value = (uint32_t*)((CPUX86State*)VAR_0)->regs[R_ECX];", "DPRINTF(\"commpage: compare_and_swap32(%x,new,%p)\\n\", old, value);", "if(value && old == tswap32(*value))\n{", "uint32_t new = ((CPUX86State*)VAR_0)->regs[R_EDX];", "*value = tswap32(new);", "((CPUX86State*)VAR_0)->eflags |= 0x40;", "}", "else\n{", "((CPUX86State*)VAR_0)->regs[R_EAX] = tswap32(*value);", "((CPUX86State*)VAR_0)->eflags &= ~0x40;", "}", "#else\nqerror(\"FUNC_0 unimplemented\");", "#endif\n}" ]

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

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

[ "static void FUNC_0(vorbis_enc_residue *VAR_0, vorbis_enc_context *VAR_1)\n{", "int VAR_2;", "assert(VAR_0->type == 2);", "VAR_0->maxes = av_mallocz(sizeof(float[2]) * VAR_0->classifications);", "for (VAR_2 = 0; VAR_2 < VAR_0->classifications; VAR_2++) {", "int j;", "vorbis_enc_codebook * cb;", "for (j = 0; j < 8; j++)", "if (VAR_0->books[VAR_2][j] != -1)\nbreak;", "if (j == 8)\ncontinue;", "cb = &VAR_1->codebooks[VAR_0->books[VAR_2][j]];", "assert(cb->ndimentions >= 2);", "assert(cb->lookup);", "for (j = 0; j < cb->nentries; j++) {", "float a;", "if (!cb->lens[j])\ncontinue;", "a = fabs(cb->dimentions[j * cb->ndimentions]);", "if (a > VAR_0->maxes[VAR_2][0])\nVAR_0->maxes[VAR_2][0] = a;", "a = fabs(cb->dimentions[j * cb->ndimentions + 1]);", "if (a > VAR_0->maxes[VAR_2][1])\nVAR_0->maxes[VAR_2][1] = a;", "}", "}", "for (VAR_2 = 0; VAR_2 < VAR_0->classifications; VAR_2++) {", "VAR_0->maxes[VAR_2][0] += 0.8;", "VAR_0->maxes[VAR_2][1] += 0.8;", "}", "}" ]

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

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

[ "BlockDriverState *FUNC_0(void)\n{", "bool not_found = true;", "BlockDriverState *bs;", "BdrvNextIterator *it = NULL;", "while (not_found && (it = bdrv_next(it, &bs))) {", "AioContext *ctx = bdrv_get_aio_context(bs);", "aio_context_acquire(ctx);", "not_found = !bdrv_can_snapshot(bs);", "aio_context_release(ctx);", "}", "return bs;", "}" ]

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

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

[ "static av_cold int FUNC_0(int16_t **outFilter, int32_t **filterPos,\nint *outFilterSize, int xInc, int srcW,\nint dstW, int filterAlign, int one,\nint flags, int cpu_flags,\nSwsVector *srcFilter, SwsVector *dstFilter,\ndouble param[2], int is_horizontal)\n{", "int VAR_8;", "int VAR_1;", "int VAR_2;", "int VAR_3;", "int64_t *filter = NULL;", "int64_t *filter2 = NULL;", "const int64_t VAR_4 = 1LL << 54;", "int VAR_5 = -1;", "emms_c();", "FF_ALLOC_OR_GOTO(NULL, *filterPos, (dstW + 3) * sizeof(**filterPos), fail);", "if (FFABS(xInc - 0x10000) < 10) {", "int VAR_8;", "VAR_1 = 1;", "FF_ALLOCZ_OR_GOTO(NULL, filter,\ndstW * sizeof(*filter) * VAR_1, fail);", "for (VAR_8 = 0; VAR_8 < dstW; VAR_8++) {", "filter[VAR_8 * VAR_1] = VAR_4;", "(*filterPos)[VAR_8] = VAR_8;", "}", "} else if (flags & SWS_POINT) {", "int VAR_8;", "int VAR_8;", "VAR_1 = 1;", "FF_ALLOC_OR_GOTO(NULL, filter,\ndstW * sizeof(*filter) * VAR_1, fail);", "VAR_8 = xInc / 2 - 0x8000;", "for (VAR_8 = 0; VAR_8 < dstW; VAR_8++) {", "int VAR_10 = (VAR_8 - ((VAR_1 - 1) << 15) + (1 << 15)) >> 16;", "(*filterPos)[VAR_8] = VAR_10;", "filter[VAR_8] = VAR_4;", "VAR_8 += xInc;", "}", "} else if ((xInc <= (1 << 16) && (flags & SWS_AREA)) ||", "(flags & SWS_FAST_BILINEAR)) {", "int VAR_8;", "int VAR_8;", "VAR_1 = 2;", "FF_ALLOC_OR_GOTO(NULL, filter,\ndstW * sizeof(*filter) * VAR_1, fail);", "VAR_8 = xInc / 2 - 0x8000;", "for (VAR_8 = 0; VAR_8 < dstW; VAR_8++) {", "int VAR_10 = (VAR_8 - ((VAR_1 - 1) << 15) + (1 << 15)) >> 16;", "int VAR_18;", "(*filterPos)[VAR_8] = VAR_10;", "/ linear interpolate / area averaging\nfor (VAR_18 = 0; VAR_18 < VAR_1; VAR_18++) {", "int64_t coeff = VAR_4 - FFABS((VAR_10 << 16) - VAR_8) *\n(VAR_4 >> 16);", "if (coeff < 0)\ncoeff = 0;", "filter[VAR_8 * VAR_1 + VAR_18] = coeff;", "VAR_10++;", "}", "VAR_8 += xInc;", "}", "} else {", "int64_t VAR_8;", "int VAR_9;", "if (flags & SWS_BICUBIC)\nVAR_9 = 4;", "else if (flags & SWS_X)\nVAR_9 = 8;", "else if (flags & SWS_AREA)\nVAR_9 = 1;", "else if (flags & SWS_GAUSS)\nVAR_9 = 8;", "else if (flags & SWS_LANCZOS)\nVAR_9 = param[0] != SWS_PARAM_DEFAULT ? ceil(2 * param[0]) : 6;", "else if (flags & SWS_SINC)\nVAR_9 = 20;", "else if (flags & SWS_SPLINE)\nVAR_9 = 20;", "else if (flags & SWS_BILINEAR)\nVAR_9 = 2;", "else {", "VAR_9 = 0;", "assert(0);", "}", "if (xInc <= 1 << 16)\nVAR_1 = 1 + VAR_9;", "else\nVAR_1 = 1 + (VAR_9 * srcW + dstW - 1) / dstW;", "VAR_1 = FFMIN(VAR_1, srcW - 2);", "VAR_1 = FFMAX(VAR_1, 1);", "FF_ALLOC_OR_GOTO(NULL, filter,\ndstW * sizeof(*filter) * VAR_1, fail);", "VAR_8 = xInc - 0x10000;", "for (VAR_8 = 0; VAR_8 < dstW; VAR_8++) {", "int VAR_10 = (VAR_8 - ((VAR_1 - 2) << 16)) / (1 << 17);", "int VAR_18;", "(*filterPos)[VAR_8] = VAR_10;", "for (VAR_18 = 0; VAR_18 < VAR_1; VAR_18++) {", "int64_t d = (FFABS(((int64_t)VAR_10 << 17) - VAR_8)) << 13;", "double VAR_10;", "int64_t coeff;", "if (xInc > 1 << 16)\nd = d * dstW / srcW;", "VAR_10 = d * (1.0 / (1 << 30));", "if (flags & SWS_BICUBIC) {", "int64_t B = (param[0] != SWS_PARAM_DEFAULT ? param[0] : 0) * (1 << 24);", "int64_t C = (param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6) * (1 << 24);", "if (d >= 1LL << 31) {", "coeff = 0.0;", "} else {", "int64_t dd = (d * d) >> 30;", "int64_t ddd = (dd * d) >> 30;", "if (d < 1LL << 30)\ncoeff = (12 * (1 << 24) - 9 * B - 6 * C) * ddd +\n(-18 * (1 << 24) + 12 * B + 6 * C) * dd +\n(6 * (1 << 24) - 2 * B) * (1 << 30);", "else\ncoeff = (-B - 6 * C) * ddd +\n(6 * B + 30 * C) * dd +\n(-12 * B - 48 * C) * d +\n(8 * B + 24 * C) * (1 << 30);", "}", "coeff *= VAR_4 >> (30 + 24);", "}", "#if 0\nelse if (flags & SWS_X) {", "double VAR_14 = param ? param * 0.01 : 0.3;", "coeff = d ? sin(d * M_PI) / (d * M_PI) : 1.0;", "coeff *= pow(2.0, -VAR_14 * d * d);", "}", "#endif\nelse if (flags & SWS_X) {", "double VAR_11 = param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0;", "double VAR_12;", "if (VAR_10 < 1.0)\nVAR_12 = cos(VAR_10 * M_PI);", "else\nVAR_12 = -1.0;", "if (VAR_12 < 0.0)\nVAR_12 = -pow(-VAR_12, VAR_11);", "else\nVAR_12 = pow(VAR_12, VAR_11);", "coeff = (VAR_12 * 0.5 + 0.5) * VAR_4;", "} else if (flags & SWS_AREA) {", "int64_t d2 = d - (1 << 29);", "if (d2 * xInc < -(1LL << (29 + 16)))\ncoeff = 1.0 * (1LL << (30 + 16));", "else if (d2 * xInc < (1LL << (29 + 16)))\ncoeff = -d2 * xInc + (1LL << (29 + 16));", "else\ncoeff = 0.0;", "coeff *= VAR_4 >> (30 + 16);", "} else if (flags & SWS_GAUSS) {", "double VAR_14 = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;", "coeff = (pow(2.0, -VAR_14 * VAR_10 * VAR_10)) * VAR_4;", "} else if (flags & SWS_SINC) {", "coeff = (d ? sin(VAR_10 * M_PI) / (VAR_10 * M_PI) : 1.0) * VAR_4;", "} else if (flags & SWS_LANCZOS) {", "double VAR_14 = param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;", "coeff = (d ? sin(VAR_10 * M_PI) * sin(VAR_10 * M_PI / VAR_14) /\n(VAR_10 * VAR_10 * M_PI * M_PI / VAR_14) : 1.0) * VAR_4;", "if (VAR_10 > VAR_14)\ncoeff = 0;", "} else if (flags & SWS_BILINEAR) {", "coeff = (1 << 30) - d;", "if (coeff < 0)\ncoeff = 0;", "coeff *= VAR_4 >> 30;", "} else if (flags & SWS_SPLINE) {", "double VAR_14 = -2.196152422706632;", "coeff = getSplineCoeff(1.0, 0.0, VAR_14, -VAR_14 - 1.0, VAR_10) * VAR_4;", "} else {", "coeff = 0.0;", "assert(0);", "}", "filter[VAR_8 * VAR_1 + VAR_18] = coeff;", "VAR_10++;", "}", "VAR_8 += 2 * xInc;", "}", "}", "assert(VAR_1 > 0);", "VAR_2 = VAR_1;", "if (srcFilter)\nVAR_2 += srcFilter->length - 1;", "if (dstFilter)\nVAR_2 += dstFilter->length - 1;", "assert(VAR_2 > 0);", "FF_ALLOCZ_OR_GOTO(NULL, filter2, VAR_2 * dstW * sizeof(*filter2), fail);", "for (VAR_8 = 0; VAR_8 < dstW; VAR_8++) {", "int VAR_18, VAR_19;", "if (srcFilter) {", "for (VAR_19 = 0; VAR_19 < srcFilter->length; VAR_19++) {", "for (VAR_18 = 0; VAR_18 < VAR_1; VAR_18++)", "filter2[VAR_8 * VAR_2 + VAR_19 + VAR_18] +=\nsrcFilter->coeff[VAR_19] * filter[VAR_8 * VAR_1 + VAR_18];", "}", "} else {", "for (VAR_18 = 0; VAR_18 < VAR_1; VAR_18++)", "filter2[VAR_8 * VAR_2 + VAR_18] = filter[VAR_8 * VAR_1 + VAR_18];", "}", "(*filterPos)[VAR_8] += (VAR_1 - 1) / 2 - (VAR_2 - 1) / 2;", "}", "av_freep(&filter);", "VAR_3 = 0;", "for (VAR_8 = dstW - 1; VAR_8 >= 0; VAR_8--) {", "int VAR_15 = VAR_2;", "int VAR_18;", "int64_t cutOff = 0.0;", "for (VAR_18 = 0; VAR_18 < VAR_2; VAR_18++) {", "int VAR_19;", "cutOff += FFABS(filter2[VAR_8 * VAR_2]);", "if (cutOff > SWS_MAX_REDUCE_CUTOFF * VAR_4)\nbreak;", "if (VAR_8 < dstW - 1 && (*filterPos)[VAR_8] >= (*filterPos)[VAR_8 + 1])\nbreak;", "for (VAR_19 = 1; VAR_19 < VAR_2; VAR_19++)", "filter2[VAR_8 * VAR_2 + VAR_19 - 1] = filter2[VAR_8 * VAR_2 + VAR_19];", "filter2[VAR_8 * VAR_2 + VAR_19 - 1] = 0;", "(*filterPos)[VAR_8]++;", "}", "cutOff = 0;", "for (VAR_18 = VAR_2 - 1; VAR_18 > 0; VAR_18--) {", "cutOff += FFABS(filter2[VAR_8 * VAR_2 + VAR_18]);", "if (cutOff > SWS_MAX_REDUCE_CUTOFF * VAR_4)\nbreak;", "VAR_15--;", "}", "if (VAR_15 > VAR_3)\nVAR_3 = VAR_15;", "}", "if (HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) {", "if (VAR_3 < 5)\nfilterAlign = 4;", "if (VAR_3 < 3)\nfilterAlign = 1;", "}", "if (INLINE_MMX(cpu_flags)) {", "if (VAR_3 == 1 && filterAlign == 2)\nfilterAlign = 1;", "}", "assert(VAR_3 > 0);", "VAR_1 = (VAR_3 + (filterAlign - 1)) & (~(filterAlign - 1));", "assert(VAR_1 > 0);", "filter = av_malloc(VAR_1 * dstW * sizeof(*filter));", "if (VAR_1 >= MAX_FILTER_SIZE * 16 /\n((flags & SWS_ACCURATE_RND) ? APCK_SIZE : 16) || !filter)\ngoto fail;", "*outFilterSize = VAR_1;", "if (flags & SWS_PRINT_INFO)\nav_log(NULL, AV_LOG_VERBOSE,\n\"SwScaler: reducing / aligning filtersize %d -> %d\\n\",\nVAR_2, VAR_1);", "for (VAR_8 = 0; VAR_8 < dstW; VAR_8++) {", "int VAR_18;", "for (VAR_18 = 0; VAR_18 < VAR_1; VAR_18++) {", "if (VAR_18 >= VAR_2)\nfilter[VAR_8 * VAR_1 + VAR_18] = 0;", "else\nfilter[VAR_8 * VAR_1 + VAR_18] = filter2[VAR_8 * VAR_2 + VAR_18];", "if ((flags & SWS_BITEXACT) && VAR_18 >= VAR_3)\nfilter[VAR_8 * VAR_1 + VAR_18] = 0;", "}", "}", "if (is_horizontal) {", "for (VAR_8 = 0; VAR_8 < dstW; VAR_8++) {", "int VAR_18;", "if ((*filterPos)[VAR_8] < 0) {", "to compensate for filterPos\nfor (VAR_18 = 1; VAR_18 < VAR_1; VAR_18++) {", "int left = FFMAX(VAR_18 + (*filterPos)[VAR_8], 0);", "filter[VAR_8 * VAR_1 + left] += filter[VAR_8 * VAR_1 + VAR_18];", "filter[VAR_8 * VAR_1 + VAR_18] = 0;", "}", "(*filterPos)[VAR_8] = 0;", "}", "if ((*filterPos)[VAR_8] + VAR_1 > srcW) {", "int VAR_16 = (*filterPos)[VAR_8] + VAR_1 - srcW;", "for (VAR_18 = VAR_1 - 2; VAR_18 >= 0; VAR_18--) {", "int VAR_17 = FFMIN(VAR_18 + VAR_16, VAR_1 - 1);", "filter[VAR_8 * VAR_1 + VAR_17] += filter[VAR_8 * VAR_1 + VAR_18];", "filter[VAR_8 * VAR_1 + VAR_18] = 0;", "}", "(*filterPos)[VAR_8] = srcW - VAR_1;", "}", "}", "}", "FF_ALLOCZ_OR_GOTO(NULL, *outFilter,\n*outFilterSize * (dstW + 3) * sizeof(int16_t), fail);", "for (VAR_8 = 0; VAR_8 < dstW; VAR_8++) {", "int VAR_18;", "int64_t error = 0;", "int64_t sum = 0;", "for (VAR_18 = 0; VAR_18 < VAR_1; VAR_18++) {", "sum += filter[VAR_8 * VAR_1 + VAR_18];", "}", "sum = (sum + one / 2) / one;", "for (VAR_18 = 0; VAR_18 < *outFilterSize; VAR_18++) {", "int64_t v = filter[VAR_8 * VAR_1 + VAR_18] + error;", "int VAR_18 = ROUNDED_DIV(v, sum);", "(*outFilter)[VAR_8 * (*outFilterSize) + VAR_18] = VAR_18;", "error = v - VAR_18 * sum;", "}", "}", "(*filterPos)[dstW + 0] =\n(*filterPos)[dstW + 1] =\n(*filterPos)[dstW + 2] = (*filterPos)[dstW - 1];", "for (VAR_8 = 0; VAR_8 < *outFilterSize; VAR_8++) {", "int VAR_19 = (dstW - 1) * (*outFilterSize) + VAR_8;", "(*outFilter)[VAR_19 + 1 * (*outFilterSize)] =\n(*outFilter)[VAR_19 + 2 * (*outFilterSize)] =\n(*outFilter)[VAR_19 + 3 * (*outFilterSize)] = (*outFilter)[VAR_19];", "}", "VAR_5 = 0;", "fail:\nav_free(filter);", "av_free(filter2);", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49, 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103, 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121, 123 ], [ 125, 127 ], [ 129, 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 151, 153 ], [ 155, 157 ], [ 159, 161 ], [ 163, 165 ], [ 167, 169 ], [ 171, 173 ], [ 175, 177 ], [ 179, 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 193, 195 ], [ 197, 199 ], [ 203 ], [ 205 ], [ 209, 211 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 235, 237 ], [ 239 ], [ 243 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 263, 265, 267, 269 ], [ 271, 273, 275, 277, 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287, 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299, 301 ], [ 303 ], [ 305 ], [ 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 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 413 ], [ 415 ], [ 417, 419 ], [ 421, 423 ], [ 425 ], [ 427 ], [ 431 ], [ 433 ], [ 437 ], [ 439 ], [ 441 ], [ 443, 445 ], [ 447 ], [ 449 ], [ 451 ], [ 453 ], [ 455 ], [ 461 ], [ 463 ], [ 465 ], [ 473 ], [ 475 ], [ 477 ], [ 479 ], [ 481 ], [ 487 ], [ 489 ], [ 491 ], [ 495, 497 ], [ 505, 507 ], [ 513 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 525 ], [ 529 ], [ 531 ], [ 535, 537 ], [ 539 ], [ 541 ], [ 545, 547 ], [ 549 ], [ 553 ], [ 557, 559 ], [ 569, 571 ], [ 573 ], [ 577 ], [ 581, 583 ], [ 585 ], [ 589 ], [ 591 ], [ 593 ], [ 595 ], [ 597, 599, 601 ], [ 603 ], [ 607, 609, 611, 613 ], [ 617 ], [ 619 ], [ 623 ], [ 625, 627 ], [ 629, 631 ], [ 633, 635 ], [ 637 ], [ 639 ], [ 649 ], [ 651 ], [ 653 ], [ 655 ], [ 657, 659 ], [ 661 ], [ 663 ], [ 665 ], [ 667 ], [ 669 ], [ 671 ], [ 675 ], [ 677 ], [ 681 ], [ 683 ], [ 685 ], [ 687 ], [ 689 ], [ 691 ], [ 693 ], [ 695 ], [ 697 ], [ 705, 707 ], [ 713 ], [ 715 ], [ 717 ], [ 719 ], [ 723 ], [ 725 ], [ 727 ], [ 729 ], [ 731 ], [ 733 ], [ 735 ], [ 737 ], [ 739 ], [ 741 ], [ 743 ], [ 747, 749, 751 ], [ 755 ], [ 757 ], [ 759, 761, 763 ], [ 765 ], [ 769 ], [ 773, 775 ], [ 777 ], [ 779 ], [ 781 ] ]

[ "int FUNC_0(VLC *VAR_0, int VAR_1, int VAR_2,\nconst void *VAR_3, int VAR_4, int VAR_5,\nconst void *VAR_6, int VAR_7, int VAR_8,\nconst void *VAR_9, int VAR_10, int VAR_11,\nint VAR_12)\n{", "VLCcode *buf;", "int VAR_13, VAR_14, VAR_15;", "VAR_0->VAR_3 = VAR_1;", "if (VAR_12 & INIT_VLC_USE_NEW_STATIC) {", "VLC dyn_vlc = *VAR_0;", "if (VAR_0->table_size)\nreturn 0;", "VAR_15 = FUNC_0(&dyn_vlc, VAR_1, VAR_2,\nVAR_3, VAR_4, VAR_5,\nVAR_6, VAR_7, VAR_8,\nVAR_9, VAR_10, VAR_11,\nVAR_12 & ~INIT_VLC_USE_NEW_STATIC);", "av_assert0(VAR_15 >= 0);", "av_assert0(dyn_vlc.table_size <= VAR_0->table_allocated);", "if (dyn_vlc.table_size < VAR_0->table_allocated)\nav_log(NULL, AV_LOG_ERROR, \"needed %d had %d\\n\", dyn_vlc.table_size, VAR_0->table_allocated);", "memcpy(VAR_0->table, dyn_vlc.table, dyn_vlc.table_size * sizeof(*VAR_0->table));", "VAR_0->table_size = dyn_vlc.table_size;", "ff_free_vlc(&dyn_vlc);", "return 0;", "} else {", "VAR_0->table = NULL;", "VAR_0->table_allocated = 0;", "VAR_0->table_size = 0;", "}", "av_dlog(NULL, \"build table VAR_2=%d\\n\", VAR_2);", "buf = av_malloc((VAR_2 + 1) * sizeof(VLCcode));", "av_assert0(VAR_11 <= 2 || !VAR_9);", "VAR_14 = 0;", "#define COPY(condition)\\\nfor (VAR_13 = 0; VAR_13 < VAR_2; VAR_13++) { \\", "GET_DATA(buf[VAR_14].VAR_3, VAR_3, VAR_13, VAR_4, VAR_5); \\", "if (!(condition)) \\\ncontinue; \\", "if (buf[VAR_14].VAR_3 > 3*VAR_1 || buf[VAR_14].VAR_3>32) { \\", "av_log(NULL, AV_LOG_ERROR, \"Too long VLC (%d) in init_vlc\\n\", buf[VAR_14].VAR_3);\\", "av_free(buf); \\", "return -1; \\", "} \\", "GET_DATA(buf[VAR_14].code, VAR_6, VAR_13, VAR_7, VAR_8); \\", "if (buf[VAR_14].code >= (1LL<<buf[VAR_14].VAR_3)) { \\", "av_log(NULL, AV_LOG_ERROR, \"Invalid code in init_vlc\\n\"); \\", "av_free(buf); \\", "return -1; \\", "} \\", "if (VAR_12 & INIT_VLC_LE) \\\nbuf[VAR_14].code = bitswap_32(buf[VAR_14].code); \\", "else \\\nbuf[VAR_14].code <<= 32 - buf[VAR_14].VAR_3; \\", "if (VAR_9) \\\nGET_DATA(buf[VAR_14].symbol, VAR_9, VAR_13, VAR_10, VAR_11) \\\nelse \\\nbuf[VAR_14].symbol = VAR_13; \\", "VAR_14++; \\", "}", "COPY(buf[VAR_14].VAR_3 > VAR_1);", "qsort(buf, VAR_14, sizeof(VLCcode), compare_vlcspec);", "COPY(buf[VAR_14].VAR_3 && buf[VAR_14].VAR_3 <= VAR_1);", "VAR_2 = VAR_14;", "VAR_15 = build_table(VAR_0, VAR_1, VAR_2, buf, VAR_12);", "av_free(buf);", "if (VAR_15 < 0) {", "av_freep(&VAR_0->table);", "return VAR_15;", "}", "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, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 33, 35, 37, 39, 41 ], [ 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 75 ], [ 81 ], [ 83 ], [ 85, 87 ], [ 89 ], [ 91, 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117, 119 ], [ 121, 123 ], [ 125, 127, 129, 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ] ]

[ "static uint64_t FUNC_0(void *opaque, hwaddr addr,\nunsigned size)\n{", "MacIONVRAMState *s = opaque;", "uint32_t value;", "addr = (addr >> s->it_shift) & (s->size - 1);", "value = s->data[addr];", "NVR_DPRINTF(\"readb addr %04x val %x\\n\", (int)addr, value);", "return value;", "}" ]

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

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

[ "void FUNC_0(v7m_msr)(CPUARMState *env, uint32_t reg, uint32_t val)\n{", "ARMCPU *cpu = arm_env_get_cpu(env);", "switch (reg) {", "case 0:\nxpsr_write(env, val, 0xf8000000);", "break;", "case 1:\nxpsr_write(env, val, 0xf8000000);", "break;", "case 2:\nxpsr_write(env, val, 0xfe00fc00);", "break;", "case 3:\nxpsr_write(env, val, 0xfe00fc00);", "break;", "case 5:\nbreak;", "case 6:\nxpsr_write(env, val, 0x0600fc00);", "break;", "case 7:\nxpsr_write(env, val, 0x0600fc00);", "break;", "case 8:\nif (env->v7m.current_sp)\nenv->v7m.other_sp = val;", "else\nenv->regs[13] = val;", "break;", "case 9:\nif (env->v7m.current_sp)\nenv->regs[13] = val;", "else\nenv->v7m.other_sp = val;", "break;", "case 16:\nif (val & 1) {", "env->daif |= PSTATE_I;", "} else {", "env->daif &= ~PSTATE_I;", "}", "break;", "case 17:\nenv->v7m.basepri = val & 0xff;", "break;", "case 18:\nval &= 0xff;", "if (val != 0 && (val < env->v7m.basepri || env->v7m.basepri == 0))\nenv->v7m.basepri = val;", "break;", "case 19:\nif (val & 1) {", "env->daif |= PSTATE_F;", "} else {", "env->daif &= ~PSTATE_F;", "}", "break;", "case 20:\nenv->v7m.control = val & 3;", "switch_v7m_sp(env, (val & 2) != 0);", "break;", "default:\ncpu_abort(CPU(cpu), \"Unimplemented system register write (%d)\\n\", reg);", "return;", "}", "}" ]

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

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

[ "AVRational FUNC_0(double d, int max)\n{", "AVRational a;", "int VAR_0;", "int64_t den;", "if (isnan(d))\nreturn (AVRational) { 0,0 };", "if (fabs(d) > INT_MAX + 3LL)\nreturn (AVRational) { d < 0 ? -1 : 1, 0 };", "frexp(d, &VAR_0);", "VAR_0 = FFMAX(VAR_0-1, 0);", "den = 1LL << (61 - VAR_0);", "av_reduce(&a.num, &a.den, floor(d * den + 0.5), den, max);", "if ((!a.num || !a.den) && d && max>0 && max<INT_MAX)\nav_reduce(&a.num, &a.den, floor(d * den + 0.5), den, INT_MAX);", "return a;", "}" ]

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

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

[ "static unsigned FUNC_0(GetByteContext *VAR_0, int VAR_1, int VAR_2)\n{", "switch (VAR_1) {", "case TIFF_BYTE : return bytestream2_get_byteu(VAR_0);", "case TIFF_SHORT: return tget_short(VAR_0, VAR_2);", "case TIFF_LONG : return tget_long(VAR_0, VAR_2);", "default : return UINT_MAX;", "}", "}" ]

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

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

[ "PCIDevice *FUNC_0(PCIBus *bus, NICInfo *nd, int devfn)\n{", "PCNetState *d;", "uint8_t *pci_conf;", "#if 0\nprintf(\"sizeof(RMD)=%d, sizeof(TMD)=%d\\n\",\nsizeof(struct pcnet_RMD), sizeof(struct pcnet_TMD));", "#endif\nd = (PCNetState *)pci_register_device(bus, \"PCNet\", sizeof(PCNetState),\ndevfn, NULL, NULL);", "pci_conf = d->dev.config;", "pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_AMD);", "pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_AMD_LANCE);", "*(uint16_t *)&pci_conf[0x04] = cpu_to_le16(0x0007);", "*(uint16_t *)&pci_conf[0x06] = cpu_to_le16(0x0280);", "pci_conf[0x08] = 0x10;", "pci_conf[0x09] = 0x00;", "pci_config_set_class(pci_conf, PCI_CLASS_NETWORK_ETHERNET);", "pci_conf[0x0e] = 0x00;", "*(uint32_t *)&pci_conf[0x10] = cpu_to_le32(0x00000001);", "*(uint32_t *)&pci_conf[0x14] = cpu_to_le32(0x00000000);", "pci_conf[0x3d] = 1;", "pci_conf[0x3e] = 0x06;", "pci_conf[0x3f] = 0xff;", "d->mmio_index =\ncpu_register_io_memory(0, pcnet_mmio_read, pcnet_mmio_write, d);", "pci_register_io_region((PCIDevice *)d, 0, PCNET_IOPORT_SIZE,\nPCI_ADDRESS_SPACE_IO, pcnet_ioport_map);", "pci_register_io_region((PCIDevice *)d, 1, PCNET_PNPMMIO_SIZE,\nPCI_ADDRESS_SPACE_MEM, pcnet_mmio_map);", "d->irq = d->dev.irq[0];", "d->phys_mem_read = pci_physical_memory_read;", "d->phys_mem_write = pci_physical_memory_write;", "d->pci_dev = &d->dev;", "pcnet_common_init(d, nd);", "return (PCIDevice *)d;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11, 13, 15 ], [ 17, 21, 23 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 65, 67 ], [ 71, 73 ], [ 77, 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ] ]

[ "void FUNC_0(AioContext *VAR_0)\n{", "smp_mb();", "if (!VAR_0->dispatching) {", "event_notifier_set(&VAR_0->notifier);", "}", "}" ]

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

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

[ "static void FUNC_0(tb_page_addr_t VAR_0,\nuintptr_t VAR_1, void *VAR_2)\n{", "TranslationBlock *tb;", "PageDesc *p;", "int VAR_3;", "#ifdef TARGET_HAS_PRECISE_SMC\nTranslationBlock *current_tb = NULL;", "CPUState *cpu = current_cpu;", "CPUArchState *env = NULL;", "int current_tb_modified = 0;", "target_ulong current_pc = 0;", "target_ulong current_cs_base = 0;", "int current_flags = 0;", "#endif\nVAR_0 &= TARGET_PAGE_MASK;", "p = page_find(VAR_0 >> TARGET_PAGE_BITS);", "if (!p) {", "return;", "}", "tb = p->first_tb;", "#ifdef TARGET_HAS_PRECISE_SMC\nif (tb && VAR_1 != 0) {", "current_tb = tb_find_pc(VAR_1);", "}", "if (cpu != NULL) {", "env = cpu->env_ptr;", "}", "#endif\nwhile (tb != NULL) {", "VAR_3 = (uintptr_t)tb & 3;", "tb = (TranslationBlock *)((uintptr_t)tb & ~3);", "#ifdef TARGET_HAS_PRECISE_SMC\nif (current_tb == tb &&\n(current_tb->cflags & CF_COUNT_MASK) != 1) {", "current_tb_modified = 1;", "cpu_restore_state_from_tb(current_tb, env, VAR_1);", "cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,\n&current_flags);", "}", "#endif\ntb_phys_invalidate(tb, VAR_0);", "tb = tb->page_next[VAR_3];", "}", "p->first_tb = NULL;", "#ifdef TARGET_HAS_PRECISE_SMC\nif (current_tb_modified) {", "cpu->current_tb = NULL;", "tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);", "cpu_resume_from_signal(env, VAR_2);", "}", "#endif\n}" ]

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

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

[ "static int FUNC_0(PayloadContext *VAR_0, const uint8_t *VAR_1)\n{", "int VAR_2, VAR_3, VAR_4;", "GetBitContext getbitcontext;", "VAR_2 = AV_RB16(VAR_1);", "if (VAR_2 > RTP_MAX_PACKET_LENGTH)\nreturn -1;", "VAR_0->au_headers_length_bytes = (VAR_2 + 7) / 8;", "VAR_1 += 2;", "init_get_bits(&getbitcontext, VAR_1, VAR_0->au_headers_length_bytes * 8);", "VAR_3 = VAR_0->sizelength + VAR_0->indexlength;", "if (VAR_3 <= 0 || (VAR_2 % VAR_3 != 0))\nreturn -1;", "VAR_0->nb_au_headers = VAR_2 / VAR_3;", "if (!VAR_0->au_headers || VAR_0->au_headers_allocated < VAR_0->nb_au_headers) {", "av_free(VAR_0->au_headers);", "VAR_0->au_headers = av_malloc(sizeof(struct AUHeaders) * VAR_0->nb_au_headers);", "if (!VAR_0->au_headers)\nreturn AVERROR(ENOMEM);", "VAR_0->au_headers_allocated = VAR_0->nb_au_headers;", "}", "VAR_0->au_headers[0].size = 0;", "VAR_0->au_headers[0].index = 0;", "for (VAR_4 = 0; VAR_4 < VAR_0->nb_au_headers; ++VAR_4) {", "VAR_0->au_headers[0].size += get_bits_long(&getbitcontext, VAR_0->sizelength);", "VAR_0->au_headers[0].index = get_bits_long(&getbitcontext, VAR_0->indexlength);", "}", "VAR_0->nb_au_headers = 1;", "return 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 ], [ 15 ], [ 19, 21 ], [ 25 ], [ 31 ], [ 35 ], [ 41 ], [ 43, 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 91 ], [ 93 ] ]

[ "static inline void FUNC_0(palToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, int width, uint32_t *pal)\n{", "int VAR_0;", "assert(src1 == src2);", "for(VAR_0=0; VAR_0<width; VAR_0++)", "{", "int p= pal[src1[VAR_0]];", "dstU[VAR_0]= p>>8;", "dstV[VAR_0]= p>>16;", "}", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque, target_phys_addr_t offset,\nunsigned size)\n{", "pl011_state *s = (pl011_state *)opaque;", "uint32_t c;", "if (offset >= 0xfe0 && offset < 0x1000) {", "return s->id[(offset - 0xfe0) >> 2];", "}", "switch (offset >> 2) {", "case 0:\ns->flags &= ~PL011_FLAG_RXFF;", "c = s->read_fifo[s->read_pos];", "if (s->read_count > 0) {", "s->read_count--;", "if (++s->read_pos == 16)\ns->read_pos = 0;", "}", "if (s->read_count == 0) {", "s->flags |= PL011_FLAG_RXFE;", "}", "if (s->read_count == s->read_trigger - 1)\ns->int_level &= ~ PL011_INT_RX;", "pl011_update(s);", "qemu_chr_accept_input(s->chr);", "return c;", "case 1:\nreturn 0;", "case 6:\nreturn s->flags;", "case 8:\nreturn s->ilpr;", "case 9:\nreturn s->ibrd;", "case 10:\nreturn s->fbrd;", "case 11:\nreturn s->lcr;", "case 12:\nreturn s->cr;", "case 13:\nreturn s->ifl;", "case 14:\nreturn s->int_enabled;", "case 15:\nreturn s->int_level;", "case 16:\nreturn s->int_level & s->int_enabled;", "case 18:\nreturn s->dmacr;", "default:\nhw_error(\"FUNC_0: Bad offset %x\\n\", (int)offset);", "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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

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

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "icp_pit_state *s = (icp_pit_state *)VAR_0;", "int VAR_4;", "VAR_4 = VAR_1 >> 8;", "if (VAR_4 > 2) {", "qemu_log_mask(LOG_GUEST_ERROR, \"%s: Bad timer %d\\VAR_4\", __func__, VAR_4);", "}", "arm_timer_write(s->timer[VAR_4], VAR_1 & 0xff, VAR_2);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 20 ], [ 24 ], [ 26 ] ]

[ "static void FUNC_0(AVCodecContext *VAR_0, TargaContext *VAR_1, const uint8_t *VAR_2, uint8_t *VAR_3, int VAR_4, int VAR_5, int VAR_6, int VAR_7)\n{", "int VAR_8, VAR_9, VAR_10;", "int VAR_11 = (VAR_7 + 1) >> 3;", "int VAR_12, VAR_13;", "int VAR_14;", "VAR_14 = VAR_6 - VAR_4 * VAR_11;", "VAR_9 = VAR_10 = 0;", "while(VAR_10 < VAR_5){", "VAR_12 = *VAR_2++;", "VAR_13 = (VAR_12 & 0x7F) + 1;", "VAR_12 &= 0x80;", "if((VAR_9 + VAR_13 > VAR_4) && (VAR_9 + VAR_13 + 1 > (VAR_5 - VAR_10) * VAR_4)){", "av_log(VAR_0, AV_LOG_ERROR, \"Packet went out of bounds: position (%VAR_8,%VAR_8) size %VAR_8\\n\", VAR_9, VAR_10, VAR_13);", "return;", "}", "for(VAR_8 = 0; VAR_8 < VAR_13; VAR_8++){", "switch(VAR_11){", "case 1:\n*VAR_3 = *VAR_2;", "break;", "case 2:\n*((uint16_t*)VAR_3) = AV_RL16(VAR_2);", "break;", "case 3:\nVAR_3[0] = VAR_2[0];", "VAR_3[1] = VAR_2[1];", "VAR_3[2] = VAR_2[2];", "break;", "case 4:\n*((uint32_t*)VAR_3) = AV_RL32(VAR_2);", "break;", "}", "VAR_3 += VAR_11;", "if(!VAR_12)\nVAR_2 += VAR_11;", "VAR_9++;", "if(VAR_9 == VAR_4){", "VAR_9 = 0;", "VAR_10++;", "VAR_3 += VAR_14;", "}", "}", "if(VAR_12)\nVAR_2 += VAR_11;", "}", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "AascContext *s = VAR_0->priv_data;", "int VAR_6, VAR_7, VAR_8, VAR_9;", "s->frame.reference = 3;", "s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;", "if (VAR_0->reget_buffer(VAR_0, &s->frame)) {", "av_log(VAR_0, AV_LOG_ERROR, \"reget_buffer() failed\\n\");", "return -1;", "VAR_6 = AV_RL32(VAR_4);", "VAR_4 += 4;", "VAR_5 -= 4;", "VAR_9 = VAR_0->bits_per_coded_sample / 8;", "switch (VAR_0->codec_tag) {", "case MKTAG('A', 'A', 'S', '4'):\nbytestream2_init(&s->gb, VAR_4 - 4, VAR_5 + 4);", "ff_msrle_decode(VAR_0, (AVPicture*)&s->frame, 8, &s->gb);", "break;", "case MKTAG('A', 'A', 'S', 'C'):\nswitch(VAR_6){", "case 0:\nVAR_8 = (VAR_0->width * VAR_9 + VAR_9) & ~VAR_9;", "for(VAR_7 = VAR_0->height - 1; VAR_7 >= 0; VAR_7--){", "if(VAR_0->width * VAR_9 > VAR_5){", "av_log(VAR_0, AV_LOG_ERROR, \"Next line is beyond buffer bounds\\n\");", "break;", "memcpy(s->frame.VAR_1[0] + VAR_7*s->frame.linesize[0], VAR_4, VAR_0->width * VAR_9);", "VAR_4 += VAR_8;", "VAR_5 -= VAR_8;", "break;", "case 1:\nbytestream2_init(&s->gb, VAR_4, VAR_5);", "ff_msrle_decode(VAR_0, (AVPicture*)&s->frame, 8, &s->gb);", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unknown compression type %d\\n\", VAR_6);", "return -1;", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unknown FourCC: %X\\n\", VAR_0->codec_tag);", "return -1;", "if (VAR_0->pix_fmt == AV_PIX_FMT_PAL8)\nmemcpy(s->frame.VAR_1[1], s->palette, s->palette_size);", "*VAR_2 = sizeof(AVFrame);", "*(AVFrame*)VAR_1 = s->frame;", "return VAR_5;" ]

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

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

[ "int FUNC_0(BlockDriverState *VAR_0, int VAR_1, int64_t VAR_2,\nint64_t VAR_3)\n{", "int VAR_4 = qcow2_check_metadata_overlap(VAR_0, VAR_1, VAR_2, VAR_3);", "if (VAR_4 < 0) {", "return VAR_4;", "} else if (VAR_4 > 0) {", "int VAR_5 = ffs(VAR_4) - 1;", "char *VAR_6;", "assert(VAR_5 < QCOW2_OL_MAX_BITNR);", "fprintf(stderr, \"qcow2: Preventing invalid write on metadata (overlaps \"\n\"with %s); image marked as corrupt.\\n\",", "metadata_ol_names[VAR_5]);", "VAR_6 = g_strdup_printf(\"Prevented %s overwrite\",\nmetadata_ol_names[VAR_5]);", "qapi_event_send_block_image_corrupted(bdrv_get_device_name(VAR_0),\nVAR_6,\ntrue,\nVAR_2,\ntrue,\nVAR_3,\ntrue,\n&error_abort);", "g_free(VAR_6);", "qcow2_mark_corrupt(VAR_0);", "VAR_0->drv = NULL;", "return -EIO;", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,\nError **VAR_3)\n{", "BDRVDMGState *s = VAR_0->opaque;", "uint64_t info_begin, info_end, last_in_offset, last_out_offset;", "uint32_t count, tmp;", "uint32_t max_compressed_size = 1, max_sectors_per_chunk = 1, i;", "int64_t offset;", "int VAR_4;", "VAR_0->read_only = 1;", "s->n_chunks = 0;", "s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;", "offset = bdrv_getlength(VAR_0->file);", "if (offset < 0) {", "VAR_4 = offset;", "offset -= 0x1d8;", "VAR_4 = read_uint64(VAR_0, offset, &info_begin);", "if (VAR_4 < 0) {", "} else if (info_begin == 0) {", "VAR_4 = read_uint32(VAR_0, info_begin, &tmp);", "if (VAR_4 < 0) {", "} else if (tmp != 0x100) {", "VAR_4 = read_uint32(VAR_0, info_begin + 4, &count);", "if (VAR_4 < 0) {", "} else if (count == 0) {", "info_end = info_begin + count;", "offset = info_begin + 0x100;", "last_in_offset = last_out_offset = 0;", "while (offset < info_end) {", "uint32_t type;", "VAR_4 = read_uint32(VAR_0, offset, &count);", "if (VAR_4 < 0) {", "} else if (count == 0) {", "offset += 4;", "VAR_4 = read_uint32(VAR_0, offset, &type);", "if (VAR_4 < 0) {", "if (type == 0x6d697368 && count >= 244) {", "size_t new_size;", "uint32_t chunk_count;", "offset += 4;", "offset += 200;", "chunk_count = (count - 204) / 40;", "new_size = sizeof(uint64_t) * (s->n_chunks + chunk_count);", "s->types = g_realloc(s->types, new_size / 2);", "s->offsets = g_realloc(s->offsets, new_size);", "s->lengths = g_realloc(s->lengths, new_size);", "s->sectors = g_realloc(s->sectors, new_size);", "s->sectorcounts = g_realloc(s->sectorcounts, new_size);", "for (i = s->n_chunks; i < s->n_chunks + chunk_count; i++) {", "VAR_4 = read_uint32(VAR_0, offset, &s->types[i]);", "if (VAR_4 < 0) {", "offset += 4;", "if (s->types[i] != 0x80000005 && s->types[i] != 1 &&\ns->types[i] != 2) {", "if (s->types[i] == 0xffffffff && i > 0) {", "last_in_offset = s->offsets[i - 1] + s->lengths[i - 1];", "last_out_offset = s->sectors[i - 1] +\ns->sectorcounts[i - 1];", "chunk_count--;", "i--;", "offset += 36;", "continue;", "offset += 4;", "VAR_4 = read_uint64(VAR_0, offset, &s->sectors[i]);", "if (VAR_4 < 0) {", "s->sectors[i] += last_out_offset;", "offset += 8;", "VAR_4 = read_uint64(VAR_0, offset, &s->sectorcounts[i]);", "if (VAR_4 < 0) {", "offset += 8;", "if (s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {", "error_report(\"sector count %\" PRIu64 \" for chunk %u is \"\n\"larger than max (%u)\",\ns->sectorcounts[i], i, DMG_SECTORCOUNTS_MAX);", "VAR_4 = read_uint64(VAR_0, offset, &s->offsets[i]);", "if (VAR_4 < 0) {", "s->offsets[i] += last_in_offset;", "offset += 8;", "VAR_4 = read_uint64(VAR_0, offset, &s->lengths[i]);", "if (VAR_4 < 0) {", "offset += 8;", "if (s->lengths[i] > max_compressed_size) {", "max_compressed_size = s->lengths[i];", "if (s->sectorcounts[i] > max_sectors_per_chunk) {", "max_sectors_per_chunk = s->sectorcounts[i];", "s->n_chunks += chunk_count;", "s->compressed_chunk = g_malloc(max_compressed_size + 1);", "s->uncompressed_chunk = g_malloc(512 * max_sectors_per_chunk);", "if (inflateInit(&s->zstream) != Z_OK) {", "s->current_chunk = s->n_chunks;", "qemu_co_mutex_init(&s->lock);", "return 0;", "fail:\ng_free(s->types);", "g_free(s->offsets);", "g_free(s->lengths);", "g_free(s->sectors);", "g_free(s->sectorcounts);", "g_free(s->compressed_chunk);", "g_free(s->uncompressed_chunk);", "return VAR_4;" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ], [ 18 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 28 ], [ 30 ], [ 31 ], [ 32 ], [ 33 ], [ 34 ], [ 35 ], [ 36 ], [ 37 ], [ 38 ], [ 39 ], [ 40 ], [ 41 ], [ 42 ], [ 43 ], [ 44 ], [ 45 ], [ 46 ], [ 47 ], [ 48 ], [ 49 ], [ 50 ], [ 51 ], [ 52 ], [ 53 ], [ 54 ], [ 55, 56 ], [ 57 ], [ 58 ], [ 59, 60 ], [ 61 ], [ 62 ], [ 63 ], [ 64 ], [ 65 ], [ 66 ], [ 67 ], [ 68 ], [ 69 ], [ 70 ], [ 71 ], [ 72 ], [ 73 ], [ 74, 75, 76 ], [ 77 ], [ 78 ], [ 79 ], [ 80 ], [ 81 ], [ 82 ], [ 83 ], [ 84 ], [ 85 ], [ 86 ], [ 87 ], [ 88 ], [ 90 ], [ 91 ], [ 92 ], [ 93 ], [ 94 ], [ 95 ], [ 96, 97 ], [ 98 ], [ 99 ], [ 100 ], [ 101 ], [ 102 ], [ 103 ], [ 104 ] ]

[ "int FUNC_0(MJpegDecodeContext *VAR_0)\n{", "int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6;", "VAR_0->cur_scan = 0;", "VAR_0->upscale_h = VAR_0->upscale_v = 0;", "VAR_1 = get_bits(&VAR_0->gb, 16);", "VAR_0->bits = get_bits(&VAR_0->gb, 8);", "if (VAR_0->pegasus_rct)\nVAR_0->bits = 9;", "if (VAR_0->bits == 9 && !VAR_0->pegasus_rct)\nVAR_0->rct = 1;", "if (VAR_0->bits != 8 && !VAR_0->lossless) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"only 8 bits/component accepted\\n\");", "return -1;", "}", "if(VAR_0->lossless && VAR_0->avctx->lowres){", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"lowres is not possible with lossless jpeg\\n\");", "return -1;", "}", "VAR_5 = get_bits(&VAR_0->gb, 16);", "VAR_4 = get_bits(&VAR_0->gb, 16);", "if (VAR_0->interlaced && VAR_0->VAR_4 == VAR_4 && VAR_0->VAR_5 == VAR_5 + 1)\nVAR_5= VAR_0->VAR_5;", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"sof0: picture: %dx%d\\n\", VAR_4, VAR_5);", "if (av_image_check_size(VAR_4, VAR_5, 0, VAR_0->avctx))\nreturn AVERROR_INVALIDDATA;", "VAR_2 = get_bits(&VAR_0->gb, 8);", "if (VAR_2 <= 0 ||\nVAR_2 > MAX_COMPONENTS)\nreturn -1;", "if (VAR_0->interlaced && (VAR_0->bottom_field == !VAR_0->interlace_polarity)) {", "if (VAR_2 != VAR_0->VAR_2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_2 changing in interlaced picture\\n\");", "return AVERROR_INVALIDDATA;", "}", "}", "if (VAR_0->ls && !(VAR_0->bits <= 8 || VAR_2 == 1)) {", "av_log_missing_feature(VAR_0->avctx,\n\"For JPEG-LS anything except <= 8 bits/component\"\n\" or 16-bit gray\", 0);", "return AVERROR_PATCHWELCOME;", "}", "VAR_0->VAR_2 = VAR_2;", "VAR_0->h_max = 1;", "VAR_0->v_max = 1;", "memset(VAR_0->h_count, 0, sizeof(VAR_0->h_count));", "memset(VAR_0->v_count, 0, sizeof(VAR_0->v_count));", "for (VAR_3 = 0; VAR_3 < VAR_2; VAR_3++) {", "VAR_0->component_id[VAR_3] = get_bits(&VAR_0->gb, 8) - 1;", "VAR_0->h_count[VAR_3] = get_bits(&VAR_0->gb, 4);", "VAR_0->v_count[VAR_3] = get_bits(&VAR_0->gb, 4);", "if (VAR_0->h_count[VAR_3] > VAR_0->h_max)\nVAR_0->h_max = VAR_0->h_count[VAR_3];", "if (VAR_0->v_count[VAR_3] > VAR_0->v_max)\nVAR_0->v_max = VAR_0->v_count[VAR_3];", "if (!VAR_0->h_count[VAR_3] || !VAR_0->v_count[VAR_3]) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"h/v_count is 0\\n\");", "return -1;", "}", "VAR_0->quant_index[VAR_3] = get_bits(&VAR_0->gb, 8);", "if (VAR_0->quant_index[VAR_3] >= 4)\nreturn AVERROR_INVALIDDATA;", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"component %d %d:%d id: %d quant:%d\\n\",\nVAR_3, VAR_0->h_count[VAR_3], VAR_0->v_count[VAR_3],\nVAR_0->component_id[VAR_3], VAR_0->quant_index[VAR_3]);", "}", "if (VAR_0->ls && (VAR_0->h_max > 1 || VAR_0->v_max > 1)) {", "av_log_missing_feature(VAR_0->avctx, \"Subsampling in JPEG-LS\", 0);", "return AVERROR_PATCHWELCOME;", "}", "if (VAR_0->v_max == 1 && VAR_0->h_max == 1 && VAR_0->lossless==1 && VAR_2==3)\nVAR_0->rgb = 1;", "if (VAR_4 != VAR_0->VAR_4 || VAR_5 != VAR_0->VAR_5) {", "av_freep(&VAR_0->qscale_table);", "VAR_0->VAR_4 = VAR_4;", "VAR_0->VAR_5 = VAR_5;", "VAR_0->interlaced = 0;", "if (VAR_0->first_picture &&\nVAR_0->org_height != 0 &&\nVAR_0->VAR_5 < ((VAR_0->org_height * 3) / 4)) {", "VAR_0->interlaced = 1;", "VAR_0->bottom_field = VAR_0->interlace_polarity;", "VAR_0->picture_ptr->interlaced_frame = 1;", "VAR_0->picture_ptr->top_field_first = !VAR_0->interlace_polarity;", "VAR_5 *= 2;", "}", "avcodec_set_dimensions(VAR_0->avctx, VAR_4, VAR_5);", "VAR_0->qscale_table = av_mallocz((VAR_0->VAR_4 + 15) / 16);", "VAR_0->first_picture = 0;", "}", "if (VAR_0->interlaced && (VAR_0->bottom_field == !VAR_0->interlace_polarity)) {", "if (VAR_0->progressive) {", "av_log_ask_for_sample(VAR_0->avctx, \"progressively coded interlaced pictures not supported\\n\");", "return AVERROR_INVALIDDATA;", "}", "} else{", "VAR_6 = (VAR_0->h_count[0] << 28) | (VAR_0->v_count[0] << 24) |\n(VAR_0->h_count[1] << 20) | (VAR_0->v_count[1] << 16) |\n(VAR_0->h_count[2] << 12) | (VAR_0->v_count[2] << 8) |\n(VAR_0->h_count[3] << 4) | VAR_0->v_count[3];", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"pix fmt id %x\\n\", VAR_6);", "if (!(VAR_6 & 0xD0D0D0D0))\nVAR_6 -= (VAR_6 & 0xF0F0F0F0) >> 1;", "if (!(VAR_6 & 0x0D0D0D0D))\nVAR_6 -= (VAR_6 & 0x0F0F0F0F) >> 1;", "switch (VAR_6) {", "case 0x11111100:\nif (VAR_0->rgb)\nVAR_0->avctx->pix_fmt = AV_PIX_FMT_BGR24;", "else {", "if (VAR_0->component_id[0] == 'Q' && VAR_0->component_id[1] == 'F' && VAR_0->component_id[2] == 'A') {", "VAR_0->avctx->pix_fmt = AV_PIX_FMT_GBR24P;", "} else {", "VAR_0->avctx->pix_fmt = VAR_0->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;", "VAR_0->avctx->color_range = VAR_0->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;", "}", "}", "av_assert0(VAR_0->VAR_2 == 3);", "break;", "case 0x12121100:\ncase 0x22122100:\nVAR_0->avctx->pix_fmt = VAR_0->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;", "VAR_0->avctx->color_range = VAR_0->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;", "VAR_0->upscale_v = 2;", "VAR_0->upscale_h = (VAR_6 == 0x22122100);", "VAR_0->chroma_height = VAR_0->VAR_5;", "break;", "case 0x21211100:\ncase 0x22211200:\nVAR_0->avctx->pix_fmt = VAR_0->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;", "VAR_0->avctx->color_range = VAR_0->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;", "VAR_0->upscale_v = (VAR_6 == 0x22211200);", "VAR_0->upscale_h = 2;", "VAR_0->chroma_height = VAR_0->VAR_5;", "break;", "case 0x22221100:\nVAR_0->avctx->pix_fmt = VAR_0->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;", "VAR_0->avctx->color_range = VAR_0->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;", "VAR_0->upscale_v = 2;", "VAR_0->upscale_h = 2;", "VAR_0->chroma_height = VAR_0->VAR_5 / 2;", "break;", "case 0x11000000:\nif(VAR_0->bits <= 8)\nVAR_0->avctx->pix_fmt = AV_PIX_FMT_GRAY8;", "else\nVAR_0->avctx->pix_fmt = AV_PIX_FMT_GRAY16;", "break;", "case 0x12111100:\ncase 0x22211100:\ncase 0x22112100:\nVAR_0->avctx->pix_fmt = VAR_0->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;", "VAR_0->avctx->color_range = VAR_0->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;", "VAR_0->upscale_h = (VAR_6 == 0x22211100) * 2 + (VAR_6 == 0x22112100);", "VAR_0->chroma_height = VAR_0->VAR_5 / 2;", "break;", "case 0x21111100:\nVAR_0->avctx->pix_fmt = VAR_0->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;", "VAR_0->avctx->color_range = VAR_0->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;", "break;", "case 0x22121100:\ncase 0x22111200:\nVAR_0->avctx->pix_fmt = VAR_0->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;", "VAR_0->avctx->color_range = VAR_0->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;", "VAR_0->upscale_v = (VAR_6 == 0x22121100) + 1;", "break;", "case 0x22111100:\nVAR_0->avctx->pix_fmt = VAR_0->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;", "VAR_0->avctx->color_range = VAR_0->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;", "break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Unhandled pixel format 0x%x\\n\", VAR_6);", "return AVERROR_PATCHWELCOME;", "}", "if ((VAR_0->upscale_h || VAR_0->upscale_v) && VAR_0->avctx->lowres) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"lowres not supported for weird subsampling\\n\");", "return AVERROR_PATCHWELCOME;", "}", "if (VAR_0->ls) {", "VAR_0->upscale_h = VAR_0->upscale_v = 0;", "if (VAR_0->VAR_2 > 1)\nVAR_0->avctx->pix_fmt = AV_PIX_FMT_RGB24;", "else if (VAR_0->bits <= 8)\nVAR_0->avctx->pix_fmt = AV_PIX_FMT_GRAY8;", "else\nVAR_0->avctx->pix_fmt = AV_PIX_FMT_GRAY16;", "}", "if (VAR_0->picture_ptr->data[0])\nVAR_0->avctx->release_buffer(VAR_0->avctx, VAR_0->picture_ptr);", "if (VAR_0->avctx->get_buffer(VAR_0->avctx, VAR_0->picture_ptr) < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"get_buffer() failed\\n\");", "return -1;", "}", "VAR_0->picture_ptr->pict_type = AV_PICTURE_TYPE_I;", "VAR_0->picture_ptr->key_frame = 1;", "VAR_0->got_picture = 1;", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++)", "VAR_0->linesize[VAR_3] = VAR_0->picture_ptr->linesize[VAR_3] << VAR_0->interlaced;", "av_dlog(VAR_0->avctx, \"%d %d %d %d %d %d\\n\",\nVAR_0->VAR_4, VAR_0->VAR_5, VAR_0->linesize[0], VAR_0->linesize[1],\nVAR_0->interlaced, VAR_0->avctx->VAR_5);", "if (VAR_1 != (8 + (3 * VAR_2)))\nav_log(VAR_0->avctx, AV_LOG_DEBUG, \"decode_sof0: error, VAR_1(%d) mismatch\\n\", VAR_1);", "}", "if (VAR_0->progressive) {", "int VAR_7 = (VAR_4 + VAR_0->h_max * 8 - 1) / (VAR_0->h_max * 8);", "int VAR_8 = (VAR_5 + VAR_0->v_max * 8 - 1) / (VAR_0->v_max * 8);", "for (VAR_3 = 0; VAR_3 < VAR_0->VAR_2; VAR_3++) {", "int size = VAR_7 * VAR_8 * VAR_0->h_count[VAR_3] * VAR_0->v_count[VAR_3];", "av_freep(&VAR_0->blocks[VAR_3]);", "av_freep(&VAR_0->last_nnz[VAR_3]);", "VAR_0->blocks[VAR_3] = av_malloc(size * sizeof(**VAR_0->blocks));", "VAR_0->last_nnz[VAR_3] = av_mallocz(size * sizeof(**VAR_0->last_nnz));", "VAR_0->block_stride[VAR_3] = VAR_7 * VAR_0->h_count[VAR_3];", "}", "memset(VAR_0->coefs_finished, 0, sizeof(VAR_0->coefs_finished));", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 27, 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 61, 63 ], [ 67 ], [ 69, 71 ], [ 75 ], [ 77, 79, 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97, 99, 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 129, 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147, 149 ], [ 151, 153, 155 ], [ 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171, 173 ], [ 181 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ], [ 197, 199, 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 217 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 243, 245, 247, 249 ], [ 251 ], [ 257, 259 ], [ 261, 263 ], [ 267 ], [ 269, 271, 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295, 297, 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311, 313, 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327, 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341, 343, 345 ], [ 347, 349 ], [ 351 ], [ 353, 355, 357, 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369, 371 ], [ 373 ], [ 375 ], [ 377, 379, 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389, 391 ], [ 393 ], [ 395 ], [ 397, 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417, 419 ], [ 421, 423 ], [ 425, 427 ], [ 429 ], [ 433, 435 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 449 ], [ 451 ], [ 455 ], [ 457 ], [ 461, 463, 465 ], [ 469, 471 ], [ 473 ], [ 479 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 491 ], [ 493 ], [ 495 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505 ], [ 507 ] ]

[ "void FUNC_0(BlockDriverState *VAR_0, BlockdevOnError VAR_1,\nBlockdevOnError VAR_2)\n{", "VAR_0->VAR_1 = VAR_1;", "VAR_0->VAR_2 = VAR_2;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(const char *VAR_0, test_data *VAR_1)\n{", "char *VAR_2;", "uint8_t signature_low;", "uint8_t signature_high;", "uint16_t signature;", "int VAR_3;", "const char *VAR_4 = \"\";", "if (!g_strcmp0(VAR_1->machine, MACHINE_Q35)) {", "VAR_4 = \",id=hd -VAR_4 ide-hd,drive=hd\";", "}", "VAR_2 = g_strdup_printf(\"-net none -display none %s -drive file=%s%s,\",\nVAR_0 ? VAR_0 : \"\", disk, VAR_4);", "qtest_start(VAR_2);", "#define TEST_DELAY (1 * G_USEC_PER_SEC / 10)\n#define TEST_CYCLES MAX((60 * G_USEC_PER_SEC / TEST_DELAY), 1)\nfor (VAR_3 = 0; VAR_3 < TEST_CYCLES; ++VAR_3) {", "signature_low = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET);", "signature_high = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET + 1);", "signature = (signature_high << 8) | signature_low;", "if (signature == SIGNATURE) {", "break;", "}", "g_usleep(TEST_DELAY);", "}", "g_assert_cmphex(signature, ==, SIGNATURE);", "test_acpi_rsdp_address(VAR_1);", "test_acpi_rsdp_table(VAR_1);", "test_acpi_rsdt_table(VAR_1);", "test_acpi_fadt_table(VAR_1);", "test_acpi_facs_table(VAR_1);", "test_acpi_dsdt_table(VAR_1);", "test_acpi_ssdt_tables(VAR_1);", "if (iasl) {", "test_acpi_asl(VAR_1);", "}", "qtest_quit(global_qtest);", "g_free(VAR_2);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 31 ], [ 37, 39, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ] ]

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint32_t VAR_2)\n{", "Rocker *r = VAR_0;", "if (rocker_addr_is_desc_reg(r, VAR_1)) {", "unsigned VAR_3 = ROCKER_RING_INDEX(VAR_1);", "unsigned VAR_4 = VAR_1 & ROCKER_DMA_DESC_MASK;", "switch (VAR_4) {", "case ROCKER_DMA_DESC_ADDR_OFFSET:\nr->lower32 = (uint64_t)VAR_2;", "break;", "case ROCKER_DMA_DESC_ADDR_OFFSET + 4:\ndesc_ring_set_base_addr(r->rings[VAR_3],\n((uint64_t)VAR_2) << 32 | r->lower32);", "r->lower32 = 0;", "break;", "case ROCKER_DMA_DESC_SIZE_OFFSET:\ndesc_ring_set_size(r->rings[VAR_3], VAR_2);", "break;", "case ROCKER_DMA_DESC_HEAD_OFFSET:\nif (desc_ring_set_head(r->rings[VAR_3], VAR_2)) {", "rocker_msix_irq(r, desc_ring_get_msix_vector(r->rings[VAR_3]));", "}", "break;", "case ROCKER_DMA_DESC_CTRL_OFFSET:\ndesc_ring_set_ctrl(r->rings[VAR_3], VAR_2);", "break;", "case ROCKER_DMA_DESC_CREDITS_OFFSET:\nif (desc_ring_ret_credits(r->rings[VAR_3], VAR_2)) {", "rocker_msix_irq(r, desc_ring_get_msix_vector(r->rings[VAR_3]));", "}", "break;", "default:\nDPRINTF(\"not implemented dma reg write(l) VAR_1=0x\" TARGET_FMT_plx\n\" VAR_2=0x%08x (ring %d, VAR_1=0x%02x)\\n\",\nVAR_1, VAR_2, VAR_3, VAR_4);", "break;", "}", "return;", "}", "switch (VAR_1) {", "case ROCKER_TEST_REG:\nr->test_reg = VAR_2;", "break;", "case ROCKER_TEST_REG64:\ncase ROCKER_TEST_DMA_ADDR:\ncase ROCKER_PORT_PHYS_ENABLE:\nr->lower32 = (uint64_t)VAR_2;", "break;", "case ROCKER_TEST_REG64 + 4:\nr->test_reg64 = ((uint64_t)VAR_2) << 32 | r->lower32;", "r->lower32 = 0;", "break;", "case ROCKER_TEST_IRQ:\nrocker_msix_irq(r, VAR_2);", "break;", "case ROCKER_TEST_DMA_SIZE:\nr->test_dma_size = VAR_2;", "break;", "case ROCKER_TEST_DMA_ADDR + 4:\nr->test_dma_addr = ((uint64_t)VAR_2) << 32 | r->lower32;", "r->lower32 = 0;", "break;", "case ROCKER_TEST_DMA_CTRL:\nrocker_test_dma_ctrl(r, VAR_2);", "break;", "case ROCKER_CONTROL:\nrocker_control(r, VAR_2);", "break;", "case ROCKER_PORT_PHYS_ENABLE + 4:\nrocker_port_phys_enable_write(r, ((uint64_t)VAR_2) << 32 | r->lower32);", "r->lower32 = 0;", "break;", "default:\nDPRINTF(\"not implemented write(l) VAR_1=0x\" TARGET_FMT_plx\n\" VAR_2=0x%08x\\n\", VAR_1, VAR_2);", "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 ]

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

[ "FUNC_0(GArray *VAR_0, GArray *VAR_1, GArray *VAR_2)\n{", "AcpiRsdtDescriptorRev1 *rsdt;", "size_t rsdt_len;", "int VAR_3;", "const int VAR_4 = (sizeof(uint32_t) * VAR_2->len);", "rsdt_len = sizeof(*rsdt) + VAR_4;", "rsdt = acpi_data_push(VAR_0, rsdt_len);", "memcpy(rsdt->table_offset_entry, VAR_2->data, VAR_4);", "for (VAR_3 = 0; VAR_3 < VAR_2->len; ++VAR_3) {", "bios_linker_loader_add_pointer(VAR_1,\nACPI_BUILD_TABLE_FILE,\nACPI_BUILD_TABLE_FILE,\nVAR_0, &rsdt->table_offset_entry[VAR_3],\nsizeof(uint32_t));", "}", "build_header(VAR_1, VAR_0,\n(void *)rsdt, \"RSDT\", rsdt_len, 1, NULL, NULL);", "}" ]

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

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

[ "int FUNC_0(NbdClientSession *VAR_0, int64_t VAR_1,\nint VAR_2, QEMUIOVector *VAR_3)\n{", "int VAR_4 = 0;", "int VAR_5;", "while (VAR_2 > NBD_MAX_SECTORS) {", "VAR_5 = nbd_co_writev_1(VAR_0, VAR_1,\nNBD_MAX_SECTORS, VAR_3, VAR_4);", "if (VAR_5 < 0) {", "return VAR_5;", "}", "VAR_4 += NBD_MAX_SECTORS * 512;", "VAR_1 += NBD_MAX_SECTORS;", "VAR_2 -= NBD_MAX_SECTORS;", "}", "return nbd_co_writev_1(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4);", "}" ]

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

[ "static int FUNC_0(SCSIDiskReq *VAR_0, uint8_t *VAR_1)\n{", "SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, VAR_0->req.dev);", "uint64_t nb_sectors;", "bool dbd;", "int VAR_2, VAR_3, VAR_4, VAR_5;", "uint8_t *p;", "uint8_t dev_specific_param;", "dbd = (VAR_0->req.cmd.buf[1] & 0x8) != 0;", "VAR_2 = VAR_0->req.cmd.buf[2] & 0x3f;", "VAR_5 = (VAR_0->req.cmd.buf[2] & 0xc0) >> 6;", "DPRINTF(\"Mode Sense(%d) (VAR_2 %d, xfer %zd, VAR_5 %d)\\n\",\n(VAR_0->req.cmd.buf[0] == MODE_SENSE) ? 6 : 10, VAR_2, VAR_0->req.cmd.xfer, VAR_5);", "memset(VAR_1, 0, VAR_0->req.cmd.xfer);", "p = VAR_1;", "if (s->qdev.type == TYPE_DISK) {", "dev_specific_param = s->features & (1 << SCSI_DISK_F_DPOFUA) ? 0x10 : 0;", "if (bdrv_is_read_only(s->qdev.conf.bs)) {", "dev_specific_param |= 0x80;", "}", "} else {", "dev_specific_param = 0x00;", "dbd = true;", "}", "if (VAR_0->req.cmd.buf[0] == MODE_SENSE) {", "p[1] = 0;", "p[2] = dev_specific_param;", "p[3] = 0;", "p += 4;", "} else {", "p[2] = 0;", "p[3] = dev_specific_param;", "p[6] = p[7] = 0;", "p += 8;", "}", "bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);", "if (!dbd && nb_sectors) {", "if (VAR_0->req.cmd.buf[0] == MODE_SENSE) {", "VAR_1[3] = 8;", "} else {", "VAR_1[7] = 8;", "}", "nb_sectors /= (s->qdev.blocksize / 512);", "if (nb_sectors > 0xffffff) {", "nb_sectors = 0;", "}", "p[0] = 0;", "p[1] = (nb_sectors >> 16) & 0xff;", "p[2] = (nb_sectors >> 8) & 0xff;", "p[3] = nb_sectors & 0xff;", "p[4] = 0;", "p[5] = 0;", "p[6] = s->qdev.blocksize >> 8;", "p[7] = 0;", "p += 8;", "}", "if (VAR_5 == 3) {", "scsi_check_condition(VAR_0, SENSE_CODE(SAVING_PARAMS_NOT_SUPPORTED));", "return -1;", "}", "if (VAR_2 == 0x3f) {", "for (VAR_2 = 0; VAR_2 <= 0x3e; VAR_2++) {", "mode_sense_page(s, VAR_2, &p, VAR_5);", "}", "} else {", "VAR_4 = mode_sense_page(s, VAR_2, &p, VAR_5);", "if (VAR_4 == -1) {", "return -1;", "}", "}", "VAR_3 = p - VAR_1;", "if (VAR_0->req.cmd.buf[0] == MODE_SENSE) {", "VAR_1[0] = VAR_3 - 1;", "} else {", "VAR_1[0] = ((VAR_3 - 2) >> 8) & 0xff;", "VAR_1[1] = (VAR_3 - 2) & 0xff;", "}", "return VAR_3;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 127 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 161 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ] ]

[ "static void FUNC_0(QemuOpts *VAR_0, ChardevBackend *VAR_1,\nError **VAR_2)\n{", "const char *VAR_3 = qemu_opt_get(VAR_0, \"path\");", "ChardevHostdev *dev;", "if (VAR_3 == NULL) {", "error_setg(VAR_2, \"chardev: pipe: no VAR_3 path given\");", "return;", "}", "dev = VAR_1->u.pipe = g_new0(ChardevHostdev, 1);", "qemu_chr_parse_common(VAR_0, qapi_ChardevHostdev_base(dev));", "dev->VAR_3 = g_strdup(VAR_3);", "}" ]

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

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

[ "static int FUNC_0(MOVContext *VAR_0, ByteIOContext *VAR_1, MOVAtom VAR_2)\n{", "AVStream *st = VAR_0->fc->streams[VAR_0->fc->nb_streams-1];", "MOVStreamContext *sc = st->priv_data;", "unsigned int VAR_3, VAR_4;", "int64_t duration=0;", "int64_t total_sample_count=0;", "get_byte(VAR_1);", "get_be24(VAR_1);", "VAR_4 = get_be32(VAR_1);", "dprintf(VAR_0->fc, \"track[%VAR_3].stts.VAR_4 = %VAR_3\\n\", VAR_0->fc->nb_streams-1, VAR_4);", "if(VAR_4 >= UINT_MAX / sizeof(*sc->stts_data))\nreturn -1;", "sc->stts_data = av_malloc(VAR_4 * sizeof(*sc->stts_data));", "if (!sc->stts_data)\nreturn AVERROR(ENOMEM);", "sc->stts_count = VAR_4;", "for(VAR_3=0; VAR_3<VAR_4; VAR_3++) {", "int VAR_5;", "int VAR_6;", "VAR_6=get_be32(VAR_1);", "VAR_5 = get_be32(VAR_1);", "sc->stts_data[VAR_3].count= VAR_6;", "sc->stts_data[VAR_3].duration= VAR_5;", "dprintf(VAR_0->fc, \"VAR_6=%d, VAR_5=%d\\n\",VAR_6,VAR_5);", "duration+=(int64_t)VAR_5*VAR_6;", "total_sample_count+=VAR_6;", "}", "st->nb_frames= total_sample_count;", "if(duration)\nst->duration= duration;", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 29, 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ] ]

[ "static void FUNC_0(struct HCIInfo *VAR_0,\nconst uint8_t *VAR_1, int VAR_2)\n{", "struct bt_hci_s *VAR_3 = hci_from_info(VAR_0);", "uint16_t handle;", "int VAR_4;", "if (VAR_2 < 3)\nreturn;", "handle = acl_handle((VAR_1[1] << 8) | VAR_1[0]);", "VAR_4 = VAR_1[2];", "VAR_2 -= 3;", "if (bt_hci_handle_bad(VAR_3, handle)) {", "fprintf(stderr, \"%s: invalid SCO handle %03x\\n\",\n__FUNCTION__, handle);", "return;", "}", "if (VAR_4 > VAR_2) {", "fprintf(stderr, \"%s: SCO packet too short (%iB < %iB)\\n\",\n__FUNCTION__, VAR_2, VAR_4);", "return;", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15, 17 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 65 ] ]

[ "static void FUNC_0(ARMCPU *VAR_0)\n{", "CPUARMState *env = &VAR_0->env;", "uint32_t type;", "uint32_t xpsr;", "bool ufault = false;", "bool return_to_sp_process = false;", "bool return_to_handler = false;", "bool rettobase = false;", "assert(arm_v7m_is_handler_mode(env));", "type = env->regs[15];", "if (env->thumb) {", "type |= 1;", "}", "qemu_log_mask(CPU_LOG_INT, \"Exception return: magic PC %\" PRIx32\n\" previous exception %d\\n\",\ntype, env->v7m.exception);", "if (extract32(type, 5, 23) != extract32(-1, 5, 23)) {", "qemu_log_mask(LOG_GUEST_ERROR, \"M profile: zero high bits in exception \"\n\"exit PC value 0x%\" PRIx32 \" are UNPREDICTABLE\\n\", type);", "}", "if (env->v7m.exception != ARMV7M_EXCP_NMI) {", "if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {", "int VAR_1 = type & 1;", "if (armv7m_nvic_raw_execution_priority(env->nvic) >= 0) {", "env->v7m.faultmask[VAR_1] = 0;", "}", "} else {", "env->v7m.faultmask[M_REG_NS] = 0;", "}", "}", "switch (armv7m_nvic_complete_irq(env->nvic, env->v7m.exception)) {", "case -1:\nufault = true;", "break;", "case 0:\nbreak;", "case 1:\nrettobase = true;", "break;", "default:\ng_assert_not_reached();", "}", "switch (type & 0xf) {", "case 1:\nreturn_to_handler = true;", "break;", "case 13:\nreturn_to_sp_process = true;", "case 9:\nif (!rettobase &&\n!(env->v7m.ccr[env->v7m.secure] & R_V7M_CCR_NONBASETHRDENA_MASK)) {", "ufault = true;", "}", "break;", "default:\nufault = true;", "}", "if (ufault) {", "env->v7m.cfsr |= R_V7M_CFSR_INVPC_MASK;", "armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE);", "v7m_exception_taken(VAR_0, type | 0xf0000000);", "qemu_log_mask(CPU_LOG_INT, \"...taking UsageFault on existing \"\n\"stackframe: failed exception return integrity check\\n\");", "return;", "}", "switch_v7m_sp(env, return_to_sp_process);", "env->regs[0] = v7m_pop(env);", "env->regs[1] = v7m_pop(env);", "env->regs[2] = v7m_pop(env);", "env->regs[3] = v7m_pop(env);", "env->regs[12] = v7m_pop(env);", "env->regs[14] = v7m_pop(env);", "env->regs[15] = v7m_pop(env);", "if (env->regs[15] & 1) {", "qemu_log_mask(LOG_GUEST_ERROR,\n\"M profile return from interrupt with misaligned \"\n\"PC is UNPREDICTABLE\\n\");", "env->regs[15] &= ~1U;", "}", "xpsr = v7m_pop(env);", "xpsr_write(env, xpsr, ~XPSR_SPREALIGN);", "if (xpsr & XPSR_SPREALIGN) {", "env->regs[13] |= 4;", "}", "if (return_to_handler != arm_v7m_is_handler_mode(env)) {", "armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE);", "env->v7m.cfsr |= R_V7M_CFSR_INVPC_MASK;", "v7m_push_stack(VAR_0);", "v7m_exception_taken(VAR_0, type | 0xf0000000);", "qemu_log_mask(CPU_LOG_INT, \"...taking UsageFault on new stackframe: \"\n\"failed exception return integrity check\\n\");", "return;", "}", "qemu_log_mask(CPU_LOG_INT, \"...successful exception return\\n\");", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 31 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59, 61, 63 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 77 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113, 117 ], [ 119 ], [ 121, 125 ], [ 127, 137 ], [ 139 ], [ 141, 143 ], [ 145 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 157, 159 ], [ 163, 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177 ], [ 179 ], [ 183 ], [ 191 ], [ 193 ], [ 195 ], [ 197, 199 ], [ 201 ], [ 203 ], [ 209 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229, 231, 233 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 253 ], [ 255 ], [ 257 ], [ 269 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281, 283 ], [ 285 ], [ 287 ], [ 293 ], [ 295 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, BdrvCheckResult *VAR_1,\nuint16_t *VAR_2, int VAR_3, int64_t VAR_4,\nint VAR_5)\n{", "BDRVQcowState *s = VAR_0->opaque;", "uint64_t *l2_table, l2_entry;", "uint64_t next_contiguous_offset = 0;", "int VAR_6, VAR_7, VAR_8;", "VAR_7 = s->VAR_7 * sizeof(uint64_t);", "l2_table = g_malloc(VAR_7);", "if (bdrv_pread(VAR_0->file, VAR_4, l2_table, VAR_7) != VAR_7)\ngoto fail;", "for(VAR_6 = 0; VAR_6 < s->VAR_7; VAR_6++) {", "l2_entry = be64_to_cpu(l2_table[VAR_6]);", "switch (qcow2_get_cluster_type(l2_entry)) {", "case QCOW2_CLUSTER_COMPRESSED:\nif (l2_entry & QCOW_OFLAG_COPIED) {", "fprintf(stderr, \"ERROR: cluster %\" PRId64 \": \"\n\"copied flag must never be set for compressed \"\n\"clusters\\n\", l2_entry >> s->cluster_bits);", "l2_entry &= ~QCOW_OFLAG_COPIED;", "VAR_1->corruptions++;", "}", "VAR_8 = ((l2_entry >> s->csize_shift) &\ns->csize_mask) + 1;", "l2_entry &= s->cluster_offset_mask;", "inc_refcounts(VAR_0, VAR_1, VAR_2, VAR_3,\nl2_entry & ~511, VAR_8 * 512);", "if (VAR_5 & CHECK_FRAG_INFO) {", "VAR_1->bfi.allocated_clusters++;", "VAR_1->bfi.compressed_clusters++;", "VAR_1->bfi.fragmented_clusters++;", "}", "break;", "case QCOW2_CLUSTER_ZERO:\nif ((l2_entry & L2E_OFFSET_MASK) == 0) {", "break;", "}", "case QCOW2_CLUSTER_NORMAL:\n{", "uint64_t offset = l2_entry & L2E_OFFSET_MASK;", "if (VAR_5 & CHECK_FRAG_INFO) {", "VAR_1->bfi.allocated_clusters++;", "if (next_contiguous_offset &&\noffset != next_contiguous_offset) {", "VAR_1->bfi.fragmented_clusters++;", "}", "next_contiguous_offset = offset + s->cluster_size;", "}", "inc_refcounts(VAR_0, VAR_1, VAR_2,VAR_3,\noffset, s->cluster_size);", "if (offset_into_cluster(s, offset)) {", "fprintf(stderr, \"ERROR offset=%\" PRIx64 \": Cluster is not \"\n\"properly aligned; L2 entry corrupted.\\n\", offset);", "VAR_1->corruptions++;", "}", "break;", "}", "case QCOW2_CLUSTER_UNALLOCATED:\nbreak;", "default:\nabort();", "}", "}", "g_free(l2_table);", "return 0;", "fail:\nfprintf(stderr, \"ERROR: I/O error in FUNC_0\\n\");", "g_free(l2_table);", "return -EIO;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 35 ], [ 37 ], [ 41 ], [ 43, 47 ], [ 49, 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 65, 67 ], [ 69 ], [ 71, 73 ], [ 77 ], [ 79 ], [ 81 ], [ 95 ], [ 97 ], [ 99 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 115, 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 143, 145 ], [ 151 ], [ 153, 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 167, 169 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 189, 191 ], [ 193 ], [ 195 ], [ 197 ] ]

[ "static inline void FUNC_0(int VAR_0)\n{", "switch (VAR_0) {", "case 0:\ngen_helper_fcmpq(cpu_env);", "break;", "case 1:\ngen_helper_fcmpq_fcc1(cpu_env);", "break;", "case 2:\ngen_helper_fcmpq_fcc2(cpu_env);", "break;", "case 3:\ngen_helper_fcmpq_fcc3(cpu_env);", "break;", "}", "}" ]

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

[ "static int FUNC_0(FsContext *VAR_0, V9fsFidOpenState *VAR_1)\n{", "return closedir(VAR_1->dir);", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(void *VAR_0)\n{", "NE2000State *s = VAR_0;", "int VAR_1, VAR_2, VAR_3;", "if (s->cmd & E8390_STOP)\nreturn 0;", "VAR_2 = s->curpag << 8;", "VAR_3 = s->VAR_3 << 8;", "if (VAR_2 < VAR_3)\nVAR_1 = VAR_3 - VAR_2;", "else\nVAR_1 = (s->stop - s->start) - (VAR_2 - VAR_3);", "if (VAR_1 < (MAX_ETH_FRAME_SIZE + 4))\nreturn 0;", "return MAX_ETH_FRAME_SIZE;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "const char *VAR_0 = \" xxxx \\t abc\";", "char VAR_1 = 'X';", "const char *VAR_2 = &VAR_1;", "int64_t res = 999;", "int VAR_3;", "VAR_3 = qemu_strtoll(VAR_0, &VAR_2, 0, &res);", "g_assert_cmpint(VAR_3, ==, 0);", "g_assert(VAR_2 == VAR_0);", "}" ]

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

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

[ "static int FUNC_0(VC9Context *VAR_0)\n{", "int VAR_1;", "#if HAS_ADVANCED_PROFILE\nif (VAR_0->profile > PROFILE_MAIN)\n{", "VAR_0->s.ac_pred = get_bits(&VAR_0->s.gb, 1);", "if (VAR_0->postprocflag) VAR_0->postproc = get_bits(&VAR_0->s.gb, 1);", "if (VAR_0->overlap && VAR_0->pq<9)\n{", "VAR_0->condover = get_bits(&VAR_0->s.gb, 1);", "if (VAR_0->condover)\n{", "VAR_0->condover = 2+get_bits(&VAR_0->s.gb, 1);", "if (VAR_0->condover == 3)\n{", "VAR_1 = bitplane_decoding(&VAR_0->over_flags_plane, VAR_0);", "if (VAR_1 < 0) return -1;", "# if TRACE\nav_log(VAR_0->s.avctx, AV_LOG_DEBUG, \"Overflags plane encoding: \"\n\"Imode: %i, Invert: %i\\n\", VAR_1>>1, VAR_1&1);", "# endif\n}", "}", "}", "}", "#endif\nreturn 0;", "}" ]

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

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

[ "void FUNC_0(Visitor *VAR_0, int *VAR_1, const char *VAR_2[],\nconst char *VAR_3, const char *VAR_4, Error **VAR_5)\n{", "if (!error_is_set(VAR_5)) {", "VAR_0->type_enum(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5);", "}", "}" ]

[ 0, 1, 1, 0, 0 ]

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

[ "static AVStream *FUNC_0(AVFormatContext *s, AVStream *next_st,\nAVPacket *pkt)\n{", "AVIStream *ast, *next_ast = next_st->priv_data;", "int64_t ts, next_ts, ts_min = INT64_MAX;", "AVStream *st, *sub_st = NULL;", "int VAR_0;", "next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base,\nAV_TIME_BASE_Q);", "for (VAR_0=0; VAR_0<s->nb_streams; VAR_0++) {", "st = s->streams[VAR_0];", "ast = st->priv_data;", "if (st->discard < AVDISCARD_ALL && ast->sub_pkt.data) {", "ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q);", "if (ts <= next_ts && ts < ts_min) {", "ts_min = ts;", "sub_st = st;", "}", "}", "}", "if (sub_st) {", "ast = sub_st->priv_data;", "*pkt = ast->sub_pkt;", "pkt->stream_index = sub_st->index;", "if (av_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0)\nast->sub_pkt.data = NULL;", "}", "return sub_st;", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0, QemuConsole *VAR_1,\nInputEvent *VAR_2)\n{", "KBDState *s = (KBDState *)VAR_0;", "int VAR_3, VAR_4;", "VAR_3 = qemu_input_key_value_to_qcode(VAR_2->u.key.data->key);", "if (VAR_3 >= ARRAY_SIZE(qcode_to_adb_keycode)) {", "return;", "}", "VAR_4 = qcode_to_adb_keycode[VAR_3];", "if (VAR_4 == NO_KEY) {", "ADB_DPRINTF(\"Ignoring NO_KEY\\n\");", "return;", "}", "if (VAR_2->u.key.data->down == false) {", "VAR_4 = VAR_4 | 0x80;", "}", "adb_kbd_put_keycode(s, VAR_4);", "}" ]

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

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

[ "void FUNC_0(DSPContext* VAR_0, AVCodecContext *VAR_1)\n{", "mm_flags = mm_support();", "if (VAR_1->dsp_mask) {", "if (VAR_1->dsp_mask & FF_MM_FORCE)\nmm_flags |= (VAR_1->dsp_mask & 0xffff);", "else\nmm_flags &= ~(VAR_1->dsp_mask & 0xffff);", "}", "#if 0\nav_log(VAR_1, AV_LOG_INFO, \"libavcodec: CPU flags:\");", "if (mm_flags & MM_MMX)\nav_log(VAR_1, AV_LOG_INFO, \" mmx\");", "if (mm_flags & MM_MMXEXT)\nav_log(VAR_1, AV_LOG_INFO, \" mmxext\");", "if (mm_flags & MM_3DNOW)\nav_log(VAR_1, AV_LOG_INFO, \" 3dnow\");", "if (mm_flags & MM_SSE)\nav_log(VAR_1, AV_LOG_INFO, \" sse\");", "if (mm_flags & MM_SSE2)\nav_log(VAR_1, AV_LOG_INFO, \" sse2\");", "av_log(VAR_1, AV_LOG_INFO, \"\\n\");", "#endif\nif (mm_flags & MM_MMX) {", "const int VAR_2= VAR_1->VAR_2;", "if(VAR_1->lowres==0){", "if(VAR_2==FF_IDCT_AUTO || VAR_2==FF_IDCT_SIMPLEMMX){", "VAR_0->idct_put= ff_simple_idct_put_mmx;", "VAR_0->idct_add= ff_simple_idct_add_mmx;", "VAR_0->idct = ff_simple_idct_mmx;", "VAR_0->idct_permutation_type= FF_SIMPLE_IDCT_PERM;", "#ifdef CONFIG_GPL\n}else if(VAR_2==FF_IDCT_LIBMPEG2MMX){", "if(mm_flags & MM_MMXEXT){", "VAR_0->idct_put= ff_libmpeg2mmx2_idct_put;", "VAR_0->idct_add= ff_libmpeg2mmx2_idct_add;", "VAR_0->idct = ff_mmxext_idct;", "}else{", "VAR_0->idct_put= ff_libmpeg2mmx_idct_put;", "VAR_0->idct_add= ff_libmpeg2mmx_idct_add;", "VAR_0->idct = ff_mmx_idct;", "}", "VAR_0->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;", "#endif\n}else if((ENABLE_VP3_DECODER || ENABLE_VP5_DECODER || ENABLE_VP6_DECODER || ENABLE_THEORA_DECODER) &&", "VAR_2==FF_IDCT_VP3){", "if(mm_flags & MM_SSE2){", "VAR_0->idct_put= ff_vp3_idct_put_sse2;", "VAR_0->idct_add= ff_vp3_idct_add_sse2;", "VAR_0->idct = ff_vp3_idct_sse2;", "VAR_0->idct_permutation_type= FF_TRANSPOSE_IDCT_PERM;", "}else{", "VAR_0->idct_put= ff_vp3_idct_put_mmx;", "VAR_0->idct_add= ff_vp3_idct_add_mmx;", "VAR_0->idct = ff_vp3_idct_mmx;", "VAR_0->idct_permutation_type= FF_PARTTRANS_IDCT_PERM;", "}", "}else if(VAR_2==FF_IDCT_CAVS){", "VAR_0->idct_permutation_type= FF_TRANSPOSE_IDCT_PERM;", "}else if(VAR_2==FF_IDCT_XVIDMMX){", "if(mm_flags & MM_SSE2){", "VAR_0->idct_put= ff_idct_xvid_sse2_put;", "VAR_0->idct_add= ff_idct_xvid_sse2_add;", "VAR_0->idct = ff_idct_xvid_sse2;", "VAR_0->idct_permutation_type= FF_SSE2_IDCT_PERM;", "}else if(mm_flags & MM_MMXEXT){", "VAR_0->idct_put= ff_idct_xvid_mmx2_put;", "VAR_0->idct_add= ff_idct_xvid_mmx2_add;", "VAR_0->idct = ff_idct_xvid_mmx2;", "}else{", "VAR_0->idct_put= ff_idct_xvid_mmx_put;", "VAR_0->idct_add= ff_idct_xvid_mmx_add;", "VAR_0->idct = ff_idct_xvid_mmx;", "}", "}", "}", "VAR_0->put_pixels_clamped = put_pixels_clamped_mmx;", "VAR_0->put_signed_pixels_clamped = put_signed_pixels_clamped_mmx;", "VAR_0->add_pixels_clamped = add_pixels_clamped_mmx;", "VAR_0->clear_blocks = clear_blocks_mmx;", "#define SET_HPEL_FUNCS(PFX, IDX, SIZE, CPU) \\\nVAR_0->PFX ## _pixels_tab[IDX][0] = PFX ## _pixels ## SIZE ## _ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][1] = PFX ## _pixels ## SIZE ## _x2_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][2] = PFX ## _pixels ## SIZE ## _y2_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][3] = PFX ## _pixels ## SIZE ## _xy2_ ## CPU\nSET_HPEL_FUNCS(put, 0, 16, mmx);", "SET_HPEL_FUNCS(put_no_rnd, 0, 16, mmx);", "SET_HPEL_FUNCS(avg, 0, 16, mmx);", "SET_HPEL_FUNCS(avg_no_rnd, 0, 16, mmx);", "SET_HPEL_FUNCS(put, 1, 8, mmx);", "SET_HPEL_FUNCS(put_no_rnd, 1, 8, mmx);", "SET_HPEL_FUNCS(avg, 1, 8, mmx);", "SET_HPEL_FUNCS(avg_no_rnd, 1, 8, mmx);", "VAR_0->gmc= gmc_mmx;", "VAR_0->add_bytes= add_bytes_mmx;", "VAR_0->add_bytes_l2= add_bytes_l2_mmx;", "VAR_0->draw_edges = draw_edges_mmx;", "if (ENABLE_ANY_H263) {", "VAR_0->h263_v_loop_filter= h263_v_loop_filter_mmx;", "VAR_0->h263_h_loop_filter= h263_h_loop_filter_mmx;", "}", "if ((ENABLE_VP3_DECODER || ENABLE_THEORA_DECODER) &&\n!(VAR_1->flags & CODEC_FLAG_BITEXACT)) {", "VAR_0->vp3_v_loop_filter= ff_vp3_v_loop_filter_mmx;", "VAR_0->vp3_h_loop_filter= ff_vp3_h_loop_filter_mmx;", "}", "VAR_0->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_mmx_rnd;", "VAR_0->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_mmx;", "VAR_0->put_no_rnd_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_mmx_nornd;", "VAR_0->h264_idct_dc_add=\nVAR_0->h264_idct_add= ff_h264_idct_add_mmx;", "VAR_0->h264_idct8_dc_add=\nVAR_0->h264_idct8_add= ff_h264_idct8_add_mmx;", "if (mm_flags & MM_SSE2)\nVAR_0->h264_idct8_add= ff_h264_idct8_add_sse2;", "if (mm_flags & MM_MMXEXT) {", "VAR_0->prefetch = prefetch_mmx2;", "VAR_0->put_pixels_tab[0][1] = put_pixels16_x2_mmx2;", "VAR_0->put_pixels_tab[0][2] = put_pixels16_y2_mmx2;", "VAR_0->avg_pixels_tab[0][0] = avg_pixels16_mmx2;", "VAR_0->avg_pixels_tab[0][1] = avg_pixels16_x2_mmx2;", "VAR_0->avg_pixels_tab[0][2] = avg_pixels16_y2_mmx2;", "VAR_0->put_pixels_tab[1][1] = put_pixels8_x2_mmx2;", "VAR_0->put_pixels_tab[1][2] = put_pixels8_y2_mmx2;", "VAR_0->avg_pixels_tab[1][0] = avg_pixels8_mmx2;", "VAR_0->avg_pixels_tab[1][1] = avg_pixels8_x2_mmx2;", "VAR_0->avg_pixels_tab[1][2] = avg_pixels8_y2_mmx2;", "VAR_0->h264_idct_dc_add= ff_h264_idct_dc_add_mmx2;", "VAR_0->h264_idct8_dc_add= ff_h264_idct8_dc_add_mmx2;", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->put_no_rnd_pixels_tab[0][1] = put_no_rnd_pixels16_x2_mmx2;", "VAR_0->put_no_rnd_pixels_tab[0][2] = put_no_rnd_pixels16_y2_mmx2;", "VAR_0->put_no_rnd_pixels_tab[1][1] = put_no_rnd_pixels8_x2_mmx2;", "VAR_0->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_mmx2;", "VAR_0->avg_pixels_tab[0][3] = avg_pixels16_xy2_mmx2;", "VAR_0->avg_pixels_tab[1][3] = avg_pixels8_xy2_mmx2;", "}", "#define SET_QPEL_FUNCS(PFX, IDX, SIZE, CPU) \\\nVAR_0->PFX ## _pixels_tab[IDX][ 0] = PFX ## SIZE ## _mc00_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 1] = PFX ## SIZE ## _mc10_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 2] = PFX ## SIZE ## _mc20_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 3] = PFX ## SIZE ## _mc30_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 4] = PFX ## SIZE ## _mc01_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 5] = PFX ## SIZE ## _mc11_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 6] = PFX ## SIZE ## _mc21_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 7] = PFX ## SIZE ## _mc31_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 8] = PFX ## SIZE ## _mc02_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][ 9] = PFX ## SIZE ## _mc12_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][10] = PFX ## SIZE ## _mc22_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][11] = PFX ## SIZE ## _mc32_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][12] = PFX ## SIZE ## _mc03_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][13] = PFX ## SIZE ## _mc13_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][14] = PFX ## SIZE ## _mc23_ ## CPU; \\", "VAR_0->PFX ## _pixels_tab[IDX][15] = PFX ## SIZE ## _mc33_ ## CPU\nSET_QPEL_FUNCS(put_qpel, 0, 16, mmx2);", "SET_QPEL_FUNCS(put_qpel, 1, 8, mmx2);", "SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, mmx2);", "SET_QPEL_FUNCS(put_no_rnd_qpel, 1, 8, mmx2);", "SET_QPEL_FUNCS(avg_qpel, 0, 16, mmx2);", "SET_QPEL_FUNCS(avg_qpel, 1, 8, mmx2);", "SET_QPEL_FUNCS(put_h264_qpel, 0, 16, mmx2);", "SET_QPEL_FUNCS(put_h264_qpel, 1, 8, mmx2);", "SET_QPEL_FUNCS(put_h264_qpel, 2, 4, mmx2);", "SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, mmx2);", "SET_QPEL_FUNCS(avg_h264_qpel, 1, 8, mmx2);", "SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, mmx2);", "SET_QPEL_FUNCS(put_2tap_qpel, 0, 16, mmx2);", "SET_QPEL_FUNCS(put_2tap_qpel, 1, 8, mmx2);", "SET_QPEL_FUNCS(avg_2tap_qpel, 0, 16, mmx2);", "SET_QPEL_FUNCS(avg_2tap_qpel, 1, 8, mmx2);", "VAR_0->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_mmx2_rnd;", "VAR_0->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_mmx2;", "VAR_0->avg_h264_chroma_pixels_tab[2]= avg_h264_chroma_mc2_mmx2;", "VAR_0->put_h264_chroma_pixels_tab[2]= put_h264_chroma_mc2_mmx2;", "VAR_0->h264_v_loop_filter_luma= h264_v_loop_filter_luma_mmx2;", "VAR_0->h264_h_loop_filter_luma= h264_h_loop_filter_luma_mmx2;", "VAR_0->h264_v_loop_filter_chroma= h264_v_loop_filter_chroma_mmx2;", "VAR_0->h264_h_loop_filter_chroma= h264_h_loop_filter_chroma_mmx2;", "VAR_0->h264_v_loop_filter_chroma_intra= h264_v_loop_filter_chroma_intra_mmx2;", "VAR_0->h264_h_loop_filter_chroma_intra= h264_h_loop_filter_chroma_intra_mmx2;", "VAR_0->h264_loop_filter_strength= h264_loop_filter_strength_mmx2;", "VAR_0->weight_h264_pixels_tab[0]= ff_h264_weight_16x16_mmx2;", "VAR_0->weight_h264_pixels_tab[1]= ff_h264_weight_16x8_mmx2;", "VAR_0->weight_h264_pixels_tab[2]= ff_h264_weight_8x16_mmx2;", "VAR_0->weight_h264_pixels_tab[3]= ff_h264_weight_8x8_mmx2;", "VAR_0->weight_h264_pixels_tab[4]= ff_h264_weight_8x4_mmx2;", "VAR_0->weight_h264_pixels_tab[5]= ff_h264_weight_4x8_mmx2;", "VAR_0->weight_h264_pixels_tab[6]= ff_h264_weight_4x4_mmx2;", "VAR_0->weight_h264_pixels_tab[7]= ff_h264_weight_4x2_mmx2;", "VAR_0->biweight_h264_pixels_tab[0]= ff_h264_biweight_16x16_mmx2;", "VAR_0->biweight_h264_pixels_tab[1]= ff_h264_biweight_16x8_mmx2;", "VAR_0->biweight_h264_pixels_tab[2]= ff_h264_biweight_8x16_mmx2;", "VAR_0->biweight_h264_pixels_tab[3]= ff_h264_biweight_8x8_mmx2;", "VAR_0->biweight_h264_pixels_tab[4]= ff_h264_biweight_8x4_mmx2;", "VAR_0->biweight_h264_pixels_tab[5]= ff_h264_biweight_4x8_mmx2;", "VAR_0->biweight_h264_pixels_tab[6]= ff_h264_biweight_4x4_mmx2;", "VAR_0->biweight_h264_pixels_tab[7]= ff_h264_biweight_4x2_mmx2;", "if (ENABLE_CAVS_DECODER)\nff_cavsdsp_init_mmx2(VAR_0, VAR_1);", "if (ENABLE_VC1_DECODER || ENABLE_WMV3_DECODER)\nff_vc1dsp_init_mmx(VAR_0, VAR_1);", "VAR_0->add_png_paeth_prediction= add_png_paeth_prediction_mmx2;", "} else if (mm_flags & MM_3DNOW) {", "VAR_0->prefetch = prefetch_3dnow;", "VAR_0->put_pixels_tab[0][1] = put_pixels16_x2_3dnow;", "VAR_0->put_pixels_tab[0][2] = put_pixels16_y2_3dnow;", "VAR_0->avg_pixels_tab[0][0] = avg_pixels16_3dnow;", "VAR_0->avg_pixels_tab[0][1] = avg_pixels16_x2_3dnow;", "VAR_0->avg_pixels_tab[0][2] = avg_pixels16_y2_3dnow;", "VAR_0->put_pixels_tab[1][1] = put_pixels8_x2_3dnow;", "VAR_0->put_pixels_tab[1][2] = put_pixels8_y2_3dnow;", "VAR_0->avg_pixels_tab[1][0] = avg_pixels8_3dnow;", "VAR_0->avg_pixels_tab[1][1] = avg_pixels8_x2_3dnow;", "VAR_0->avg_pixels_tab[1][2] = avg_pixels8_y2_3dnow;", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->put_no_rnd_pixels_tab[0][1] = put_no_rnd_pixels16_x2_3dnow;", "VAR_0->put_no_rnd_pixels_tab[0][2] = put_no_rnd_pixels16_y2_3dnow;", "VAR_0->put_no_rnd_pixels_tab[1][1] = put_no_rnd_pixels8_x2_3dnow;", "VAR_0->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_3dnow;", "VAR_0->avg_pixels_tab[0][3] = avg_pixels16_xy2_3dnow;", "VAR_0->avg_pixels_tab[1][3] = avg_pixels8_xy2_3dnow;", "}", "SET_QPEL_FUNCS(put_qpel, 0, 16, 3dnow);", "SET_QPEL_FUNCS(put_qpel, 1, 8, 3dnow);", "SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, 3dnow);", "SET_QPEL_FUNCS(put_no_rnd_qpel, 1, 8, 3dnow);", "SET_QPEL_FUNCS(avg_qpel, 0, 16, 3dnow);", "SET_QPEL_FUNCS(avg_qpel, 1, 8, 3dnow);", "SET_QPEL_FUNCS(put_h264_qpel, 0, 16, 3dnow);", "SET_QPEL_FUNCS(put_h264_qpel, 1, 8, 3dnow);", "SET_QPEL_FUNCS(put_h264_qpel, 2, 4, 3dnow);", "SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, 3dnow);", "SET_QPEL_FUNCS(avg_h264_qpel, 1, 8, 3dnow);", "SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, 3dnow);", "SET_QPEL_FUNCS(put_2tap_qpel, 0, 16, 3dnow);", "SET_QPEL_FUNCS(put_2tap_qpel, 1, 8, 3dnow);", "SET_QPEL_FUNCS(avg_2tap_qpel, 0, 16, 3dnow);", "SET_QPEL_FUNCS(avg_2tap_qpel, 1, 8, 3dnow);", "VAR_0->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_3dnow_rnd;", "VAR_0->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_3dnow;", "if (ENABLE_CAVS_DECODER)\nff_cavsdsp_init_3dnow(VAR_0, VAR_1);", "}", "#define H264_QPEL_FUNCS(x, y, CPU)\\\nVAR_0->put_h264_qpel_pixels_tab[0][x+y*4] = put_h264_qpel16_mc##x##y##_##CPU;\\", "VAR_0->put_h264_qpel_pixels_tab[1][x+y*4] = put_h264_qpel8_mc##x##y##_##CPU;\\", "VAR_0->avg_h264_qpel_pixels_tab[0][x+y*4] = avg_h264_qpel16_mc##x##y##_##CPU;\\", "VAR_0->avg_h264_qpel_pixels_tab[1][x+y*4] = avg_h264_qpel8_mc##x##y##_##CPU;", "if((mm_flags & MM_SSE2) && !(mm_flags & MM_3DNOW)){", "H264_QPEL_FUNCS(0, 0, sse2);", "}", "if(mm_flags & MM_SSE2){", "H264_QPEL_FUNCS(0, 1, sse2);", "H264_QPEL_FUNCS(0, 2, sse2);", "H264_QPEL_FUNCS(0, 3, sse2);", "H264_QPEL_FUNCS(1, 1, sse2);", "H264_QPEL_FUNCS(1, 2, sse2);", "H264_QPEL_FUNCS(1, 3, sse2);", "H264_QPEL_FUNCS(2, 1, sse2);", "H264_QPEL_FUNCS(2, 2, sse2);", "H264_QPEL_FUNCS(2, 3, sse2);", "H264_QPEL_FUNCS(3, 1, sse2);", "H264_QPEL_FUNCS(3, 2, sse2);", "H264_QPEL_FUNCS(3, 3, sse2);", "}", "#ifdef HAVE_SSSE3\nif(mm_flags & MM_SSSE3){", "H264_QPEL_FUNCS(1, 0, ssse3);", "H264_QPEL_FUNCS(1, 1, ssse3);", "H264_QPEL_FUNCS(1, 2, ssse3);", "H264_QPEL_FUNCS(1, 3, ssse3);", "H264_QPEL_FUNCS(2, 0, ssse3);", "H264_QPEL_FUNCS(2, 1, ssse3);", "H264_QPEL_FUNCS(2, 2, ssse3);", "H264_QPEL_FUNCS(2, 3, ssse3);", "H264_QPEL_FUNCS(3, 0, ssse3);", "H264_QPEL_FUNCS(3, 1, ssse3);", "H264_QPEL_FUNCS(3, 2, ssse3);", "H264_QPEL_FUNCS(3, 3, ssse3);", "VAR_0->put_no_rnd_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_ssse3_nornd;", "VAR_0->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_ssse3_rnd;", "VAR_0->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_ssse3_rnd;", "VAR_0->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_ssse3;", "VAR_0->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_ssse3;", "VAR_0->add_png_paeth_prediction= add_png_paeth_prediction_ssse3;", "}", "#endif\n#ifdef CONFIG_SNOW_DECODER\nif(mm_flags & MM_SSE2 & 0){", "VAR_0->horizontal_compose97i = ff_snow_horizontal_compose97i_sse2;", "#ifdef HAVE_7REGS\nVAR_0->vertical_compose97i = ff_snow_vertical_compose97i_sse2;", "#endif\nVAR_0->inner_add_yblock = ff_snow_inner_add_yblock_sse2;", "}", "else{", "if(mm_flags & MM_MMXEXT){", "VAR_0->horizontal_compose97i = ff_snow_horizontal_compose97i_mmx;", "#ifdef HAVE_7REGS\nVAR_0->vertical_compose97i = ff_snow_vertical_compose97i_mmx;", "#endif\n}", "VAR_0->inner_add_yblock = ff_snow_inner_add_yblock_mmx;", "}", "#endif\nif(mm_flags & MM_3DNOW){", "VAR_0->vorbis_inverse_coupling = vorbis_inverse_coupling_3dnow;", "VAR_0->vector_fmul = vector_fmul_3dnow;", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->float_to_int16 = float_to_int16_3dnow;", "VAR_0->float_to_int16_interleave = float_to_int16_interleave_3dnow;", "}", "}", "if(mm_flags & MM_3DNOWEXT){", "VAR_0->vector_fmul_reverse = vector_fmul_reverse_3dnow2;", "VAR_0->vector_fmul_window = vector_fmul_window_3dnow2;", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->float_to_int16_interleave = float_to_int16_interleave_3dn2;", "}", "}", "if(mm_flags & MM_SSE){", "VAR_0->vorbis_inverse_coupling = vorbis_inverse_coupling_sse;", "VAR_0->ac3_downmix = ac3_downmix_sse;", "VAR_0->vector_fmul = vector_fmul_sse;", "VAR_0->vector_fmul_reverse = vector_fmul_reverse_sse;", "VAR_0->vector_fmul_add_add = vector_fmul_add_add_sse;", "VAR_0->vector_fmul_window = vector_fmul_window_sse;", "VAR_0->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_sse;", "VAR_0->float_to_int16 = float_to_int16_sse;", "VAR_0->float_to_int16_interleave = float_to_int16_interleave_sse;", "}", "if(mm_flags & MM_3DNOW)\nVAR_0->vector_fmul_add_add = vector_fmul_add_add_3dnow;", "if(mm_flags & MM_SSE2){", "VAR_0->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_sse2;", "VAR_0->float_to_int16 = float_to_int16_sse2;", "VAR_0->float_to_int16_interleave = float_to_int16_interleave_sse2;", "VAR_0->add_int16 = add_int16_sse2;", "VAR_0->sub_int16 = sub_int16_sse2;", "VAR_0->scalarproduct_int16 = scalarproduct_int16_sse2;", "}", "}", "if (ENABLE_ENCODERS)\ndsputilenc_init_mmx(VAR_0, VAR_1);", "#if 0\nget_pixels = just_return;", "put_pixels_clamped = just_return;", "add_pixels_clamped = just_return;", "pix_abs16x16 = just_return;", "pix_abs16x16_x2 = just_return;", "pix_abs16x16_y2 = just_return;", "pix_abs16x16_xy2 = just_return;", "put_pixels_tab[0] = just_return;", "put_pixels_tab[1] = just_return;", "put_pixels_tab[2] = just_return;", "put_pixels_tab[3] = just_return;", "put_no_rnd_pixels_tab[0] = just_return;", "put_no_rnd_pixels_tab[1] = just_return;", "put_no_rnd_pixels_tab[2] = just_return;", "put_no_rnd_pixels_tab[3] = just_return;", "avg_pixels_tab[0] = just_return;", "avg_pixels_tab[1] = just_return;", "avg_pixels_tab[2] = just_return;", "avg_pixels_tab[3] = just_return;", "avg_no_rnd_pixels_tab[0] = just_return;", "avg_no_rnd_pixels_tab[1] = just_return;", "avg_no_rnd_pixels_tab[2] = just_return;", "avg_no_rnd_pixels_tab[3] = just_return;", "#endif\n}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 33 ], [ 35, 37 ], [ 39, 41 ], [ 43, 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 ], [ 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 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 181, 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 207 ], [ 209 ], [ 213 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225, 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 243, 245 ], [ 247, 249 ], [ 251, 253 ], [ 257 ], [ 259 ], [ 263 ], [ 265 ], [ 269 ], [ 271 ], [ 273 ], [ 277 ], [ 279 ], [ 283 ], [ 285 ], [ 287 ], [ 291 ], [ 293 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 315, 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347, 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 449, 451 ], [ 455, 457 ], [ 461 ], [ 463 ], [ 465 ], [ 469 ], [ 471 ], [ 475 ], [ 477 ], [ 479 ], [ 483 ], [ 485 ], [ 489 ], [ 491 ], [ 493 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505 ], [ 507 ], [ 509 ], [ 511 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 537 ], [ 539 ], [ 543 ], [ 545 ], [ 547 ], [ 549 ], [ 553 ], [ 555 ], [ 559, 561 ], [ 563 ], [ 569, 571 ], [ 573 ], [ 575 ], [ 577 ], [ 579 ], [ 591 ], [ 593 ], [ 595 ], [ 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ], [ 609 ], [ 611 ], [ 613 ], [ 615 ], [ 617 ], [ 619 ], [ 621 ], [ 623, 625 ], [ 627 ], [ 629 ], [ 631 ], [ 633 ], [ 635 ], [ 637 ], [ 639 ], [ 641 ], [ 643 ], [ 645 ], [ 647 ], [ 649 ], [ 651 ], [ 653 ], [ 655 ], [ 657 ], [ 659 ], [ 661 ], [ 663 ], [ 665, 669, 671 ], [ 673 ], [ 675, 677 ], [ 679, 681 ], [ 683 ], [ 685 ], [ 687 ], [ 689 ], [ 691, 693 ], [ 695, 697 ], [ 699 ], [ 701 ], [ 703, 707 ], [ 709 ], [ 711 ], [ 713 ], [ 715 ], [ 717 ], [ 719 ], [ 721 ], [ 723 ], [ 725 ], [ 727 ], [ 729 ], [ 731 ], [ 733 ], [ 735 ], [ 737 ], [ 739 ], [ 741 ], [ 743 ], [ 745 ], [ 747 ], [ 749 ], [ 751 ], [ 753 ], [ 755 ], [ 757 ], [ 759, 761 ], [ 763 ], [ 765 ], [ 767 ], [ 769 ], [ 771 ], [ 773 ], [ 775 ], [ 777 ], [ 779 ], [ 783, 785 ], [ 789, 793 ], [ 795 ], [ 797 ], [ 801 ], [ 803 ], [ 805 ], [ 807 ], [ 811 ], [ 813 ], [ 815 ], [ 817 ], [ 821 ], [ 823 ], [ 825 ], [ 827 ], [ 831 ], [ 833 ], [ 835 ], [ 837 ], [ 841 ], [ 843 ], [ 845 ], [ 847 ], [ 855, 857 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "struct IscsiTask *VAR_1 = VAR_0;", "VAR_1->complete = 1;", "if (VAR_1->co) {", "qemu_coroutine_enter(VAR_1->co, NULL);", "}", "}" ]

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

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

[ "int FUNC_0(void)\n{", "return shutdown_requested;", "}" ]

[ 1, 0, 0 ]

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

[ "static inline void FUNC_0(rgb15ToY)(uint8_t *dst, uint8_t *src, int width)\n{", "int VAR_0;", "for(VAR_0=0; VAR_0<width; VAR_0++)", "{", "int d= ((uint16_t*)src)[VAR_0];", "int r= d&0x1F;", "int g= (d>>5)&0x1F;", "int b= (d>>10)&0x1F;", "dst[VAR_0]= ((RY*r + GY*g + BY*b)>>(RGB2YUV_SHIFT-3)) + 16;", "}", "}" ]

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

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

[ "static int FUNC_0(target_phys_addr_t VAR_0, target_phys_addr_t VAR_1,\nunsigned VAR_2,\nunsigned VAR_3)\n{", "KVMState *s = kvm_state;", "KVMSlot *mem = kvm_lookup_slot(s, VAR_0);", "if (mem == NULL) {", "dprintf(\"invalid parameters %llx-%llx\\n\", VAR_0, VAR_1);", "return -EINVAL;", "}", "VAR_2 = (mem->VAR_2 & ~VAR_3) | VAR_2;", "if (VAR_2 == mem->VAR_2)\nreturn 0;", "mem->VAR_2 = VAR_2;", "return kvm_set_user_memory_region(s, mem);", "}" ]

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

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

[ "static void FUNC_0(uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,\nlong width, long height,\nlong lumStride, long chromStride, long srcStride)\n{", "long VAR_0;", "const long VAR_1= -((-width)>>1);", "for (VAR_0=0; VAR_0<height; VAR_0++) {", "FUNC_0(extract_even)(src+1, ydst, width);", "if(VAR_0&1) {", "FUNC_0(extract_even2avg)(src-srcStride, src, udst, vdst, VAR_1);", "udst+= chromStride;", "vdst+= chromStride;", "}", "src += srcStride;", "ydst+= lumStride;", "}", "#if COMPILE_TEMPLATE_MMX\n__asm__(\nEMMS\" \\n\\t\"\nSFENCE\" \\n\\t\"\n::: \"memory\"\n);", "#endif\n}" ]

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

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

[ "static int FUNC_0(SwsContext *VAR_0, const uint8_t* VAR_18[], int VAR_2[], int VAR_3,\nint VAR_4, uint8_t* VAR_5[], int VAR_6[])\n{", "const uint8_t *VAR_7= VAR_18[0];", "uint8_t *VAR_18= VAR_5[0];", "uint8_t *VAR_18= VAR_5[1];", "uint8_t *VAR_18= VAR_5[2];", "int VAR_8;", "void (*VAR_9) (const uint8_t *VAR_18, int VAR_18, uint8_t *VAR_18, uint8_t *VAR_18, uint8_t *VAR_18, int VAR_18, int VAR_18, int32_t *VAR_18);", "void (*VAR_17)(const uint8_t *VAR_18, int VAR_18, uint8_t *VAR_18, uint8_t *VAR_18, uint8_t *VAR_18, int VAR_18, int VAR_18, int32_t *VAR_18);", "switch(VAR_0->srcFormat) {", "#define CASE(pixfmt, prefix) \\\ncase pixfmt: VAR_9 = bayer_##prefix##_to_yv12_copy; \\", "VAR_17 = bayer_##prefix##_to_yv12_interpolate; \\", "break;", "CASE(AV_PIX_FMT_BAYER_BGGR8, bggr8)\nCASE(AV_PIX_FMT_BAYER_BGGR16LE, bggr16le)\nCASE(AV_PIX_FMT_BAYER_BGGR16BE, bggr16be)\nCASE(AV_PIX_FMT_BAYER_RGGB8, rggb8)\nCASE(AV_PIX_FMT_BAYER_RGGB16LE, rggb16le)\nCASE(AV_PIX_FMT_BAYER_RGGB16BE, rggb16be)\nCASE(AV_PIX_FMT_BAYER_GBRG8, gbrg8)\nCASE(AV_PIX_FMT_BAYER_GBRG16LE, gbrg16le)\nCASE(AV_PIX_FMT_BAYER_GBRG16BE, gbrg16be)\nCASE(AV_PIX_FMT_BAYER_GRBG8, grbg8)\nCASE(AV_PIX_FMT_BAYER_GRBG16LE, grbg16le)\nCASE(AV_PIX_FMT_BAYER_GRBG16BE, grbg16be)\n#undef CASE\ndefault: return 0;", "}", "VAR_9(VAR_7, VAR_2[0], VAR_18, VAR_18, VAR_18, VAR_6[0], VAR_0->srcW, VAR_0->input_rgb2yuv_table);", "VAR_7 += 2 * VAR_2[0];", "VAR_18 += 2 * VAR_6[0];", "VAR_18 += VAR_6[1];", "VAR_18 += VAR_6[1];", "for (VAR_8 = 2; VAR_8 < VAR_4 - 2; VAR_8 += 2) {", "VAR_17(VAR_7, VAR_2[0], VAR_18, VAR_18, VAR_18, VAR_6[0], VAR_0->srcW, VAR_0->input_rgb2yuv_table);", "VAR_7 += 2 * VAR_2[0];", "VAR_18 += 2 * VAR_6[0];", "VAR_18 += VAR_6[1];", "VAR_18 += VAR_6[1];", "}", "VAR_9(VAR_7, VAR_2[0], VAR_18, VAR_18, VAR_18, VAR_6[0], VAR_0->srcW, VAR_0->input_rgb2yuv_table);", "return VAR_4;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nVAAPIEncodePicture *VAR_1)\n{", "VAAPIEncodeContext *ctx = VAR_0->priv_data;", "VAEncSequenceParameterBufferH264 *vseq = ctx->codec_sequence_params;", "VAEncPictureParameterBufferH264 *vpic = VAR_1->codec_picture_params;", "VAAPIEncodeH264Context *priv = ctx->priv_data;", "int VAR_2;", "if (VAR_1->type == PICTURE_TYPE_IDR) {", "av_assert0(VAR_1->display_order == VAR_1->encode_order);", "vpic->frame_num = 0;", "priv->next_frame_num = 1;", "priv->cpb_delay = 0;", "} else {", "vpic->frame_num = priv->next_frame_num;", "if (VAR_1->type != PICTURE_TYPE_B) {", "++priv->next_frame_num;", "}", "++priv->cpb_delay;", "}", "priv->dpb_delay = VAR_1->display_order - VAR_1->encode_order + 1;", "vpic->frame_num = vpic->frame_num &\n((1 << (4 + vseq->seq_fields.bits.log2_max_frame_num_minus4)) - 1);", "vpic->CurrPic.picture_id = VAR_1->recon_surface;", "vpic->CurrPic.frame_idx = vpic->frame_num;", "vpic->CurrPic.flags = 0;", "vpic->CurrPic.TopFieldOrderCnt = VAR_1->display_order;", "vpic->CurrPic.BottomFieldOrderCnt = VAR_1->display_order;", "for (VAR_2 = 0; VAR_2 < VAR_1->nb_refs; VAR_2++) {", "VAAPIEncodePicture *ref = VAR_1->refs[VAR_2];", "av_assert0(ref && ref->encode_order < VAR_1->encode_order);", "vpic->ReferenceFrames[VAR_2].picture_id = ref->recon_surface;", "vpic->ReferenceFrames[VAR_2].frame_idx = ref->encode_order;", "vpic->ReferenceFrames[VAR_2].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;", "vpic->ReferenceFrames[VAR_2].TopFieldOrderCnt = ref->display_order;", "vpic->ReferenceFrames[VAR_2].BottomFieldOrderCnt = ref->display_order;", "}", "for (; VAR_2 < FF_ARRAY_ELEMS(vpic->ReferenceFrames); VAR_2++) {", "vpic->ReferenceFrames[VAR_2].picture_id = VA_INVALID_ID;", "vpic->ReferenceFrames[VAR_2].flags = VA_PICTURE_H264_INVALID;", "}", "vpic->coded_buf = VAR_1->output_buffer;", "vpic->pic_fields.bits.idr_pic_flag = (VAR_1->type == PICTURE_TYPE_IDR);", "vpic->pic_fields.bits.reference_pic_flag = (VAR_1->type != PICTURE_TYPE_B);", "VAR_1->nb_slices = 1;", "return 0;", "}" ]

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

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

[ "static inline int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1)\n{", "uint64_t offset = sizeof(struct cow_header_v2) + VAR_1 / 8;", "uint8_t bitmap;", "if (bdrv_pread(VAR_0->file, offset, &bitmap, sizeof(bitmap)) !=\nsizeof(bitmap)) {", "return -errno;", "}", "return !!(bitmap & (1 << (VAR_1 % 8)));", "}" ]

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

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

[ "bool FUNC_0(const char *file)\n{", "pthread_t thread;", "pthread_attr_t attr;", "sigset_t set, oldset;", "int VAR_0;", "pthread_attr_init(&attr);", "pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);", "sigfillset(&set);", "pthread_sigmask(SIG_SETMASK, &set, &oldset);", "VAR_0 = pthread_create(&thread, &attr, writeout_thread, NULL);", "pthread_sigmask(SIG_SETMASK, &oldset, NULL);", "if (VAR_0 != 0) {", "return false;", "}", "atexit(st_flush_trace_buffer);", "st_set_trace_file(file);", "return true;", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "LibQuviContext *qc = VAR_0->priv_data;", "if (qc->fmtctx)\navformat_close_input(&qc->fmtctx);", "return 0;", "}" ]

[ 1, 1, 1, 1, 0 ]

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "AspeedSoCClass *sc = ASPEED_SOC_CLASS(VAR_0);", "sc->info = (AspeedSoCInfo *) VAR_1;", "dc->realize = aspeed_soc_realize;", "}" ]

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

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

[ "static int FUNC_0(FFStream *VAR_0, uint8_t **VAR_1,\nstruct in_addr VAR_2)\n{", "AVFormatContext *avc;", "AVStream avs[MAX_STREAMS];", "int VAR_3;", "avc = avformat_alloc_context();", "if (avc == NULL) {", "return -1;", "}", "av_metadata_set2(&avc->metadata, \"title\",\nVAR_0->title[0] ? VAR_0->title : \"No Title\", 0);", "avc->nb_streams = VAR_0->nb_streams;", "if (VAR_0->is_multicast) {", "snprintf(avc->filename, 1024, \"rtp:\ninet_ntoa(VAR_0->multicast_ip),\nVAR_0->multicast_port, VAR_0->multicast_ttl);", "} else {", "snprintf(avc->filename, 1024, \"rtp:\n}", "for(VAR_3 = 0; VAR_3 < VAR_0->nb_streams; VAR_3++) {", "avc->streams[VAR_3] = &avs[VAR_3];", "avc->streams[VAR_3]->codec = VAR_0->streams[VAR_3]->codec;", "}", "*VAR_1 = av_mallocz(2048);", "avf_sdp_create(&avc, 1, *VAR_1, 2048);", "av_free(avc);", "return strlen(*VAR_1);", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{", "DVDSubContext *ctx = VAR_0->priv_data;", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "AVSubtitle *sub = VAR_1;", "int VAR_6;", "if (ctx->VAR_4) {", "int VAR_7 = append_to_cached_buf(VAR_0, VAR_4, VAR_5);", "if (VAR_7 < 0) {", "*VAR_2 = 0;", "return VAR_7;", "}", "VAR_4 = ctx->VAR_4;", "VAR_5 = ctx->VAR_5;", "}", "VAR_6 = decode_dvd_subtitles(ctx, sub, VAR_4, VAR_5);", "if (VAR_6 == AVERROR(EAGAIN)) {", "*VAR_2 = 0;", "return append_to_cached_buf(VAR_0, VAR_4, VAR_5);", "}", "if (VAR_6 < 0) {", "no_subtitle:\nreset_rects(sub);", "*VAR_2 = 0;", "return VAR_5;", "}", "if (!VAR_6 && find_smallest_bounding_rectangle(sub) == 0)\ngoto no_subtitle;", "if (ctx->forced_subs_only && !(sub->rects[0]->flags & AV_SUBTITLE_FLAG_FORCED))\ngoto no_subtitle;", "#if defined(DEBUG)\n{", "char ppm_name[32];", "snprintf(ppm_name, sizeof(ppm_name), \"/tmp/%05d.ppm\", ctx->sub_id++);", "av_dlog(NULL, \"start=%d ms end =%d ms\\n\",\nsub->start_display_time,\nsub->end_display_time);", "ppm_save(ppm_name, sub->rects[0]->pict.VAR_1[0],\nsub->rects[0]->w, sub->rects[0]->h, (uint32_t*) sub->rects[0]->pict.VAR_1[1]);", "}", "#endif\nav_freep(&ctx->VAR_4);", "ctx->VAR_5 = 0;", "*VAR_2 = 1;", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 73, 75 ], [ 79, 81 ], [ 83 ], [ 87 ], [ 89, 91, 93 ], [ 95, 97 ], [ 99 ], [ 101, 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ] ]

[ "static void FUNC_0(MachineState *VAR_0)\n{", "CPUPPCState *env = NULL;", "uint16_t cmos_checksum;", "PowerPCCPU *cpu;", "DeviceState *dev;", "SysBusDevice *pcihost;", "Nvram *m48t59 = NULL;", "PCIBus *pci_bus;", "ISABus *isa_bus;", "void *VAR_1;", "int VAR_2;", "uint32_t kernel_base = 0, initrd_base = 0;", "long VAR_3 = 0, VAR_4 = 0;", "char VAR_5;", "if (!VAR_0->cpu_model) {", "VAR_0->cpu_model = \"604\";", "}", "cpu = POWERPC_CPU(cpu_generic_init(TYPE_POWERPC_CPU, VAR_0->cpu_model));", "if (!cpu) {", "error_report(\"could not initialize CPU '%s'\",\nVAR_0->cpu_model);", "exit(1);", "}", "env = &cpu->env;", "if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {", "error_report(\"only 6xx bus is supported on this VAR_0\");", "exit(1);", "}", "if (env->flags & POWERPC_FLAG_RTC_CLK) {", "cpu_ppc_tb_init(env, 7812500UL);", "} else {", "cpu_ppc_tb_init(env, 100UL * 1000UL * 1000UL);", "}", "qemu_register_reset(ppc_prep_reset, cpu);", "dev = qdev_create(NULL, \"raven-pcihost\");", "if (!bios_name) {", "bios_name = BIOS_FILENAME;", "}", "qdev_prop_set_string(dev, \"bios-name\", bios_name);", "qdev_prop_set_uint32(dev, \"elf-VAR_0\", PPC_ELF_MACHINE);", "pcihost = SYS_BUS_DEVICE(dev);", "object_property_add_child(qdev_get_machine(), \"raven\", OBJECT(dev), NULL);", "qdev_init_nofail(dev);", "pci_bus = PCI_BUS(qdev_get_child_bus(dev, \"pci.0\"));", "if (!pci_bus) {", "error_report(\"could not create PCI host controller\");", "exit(1);", "}", "dev = DEVICE(pci_create_simple(pci_bus, PCI_DEVFN(11, 0), \"i82378\"));", "qdev_connect_gpio_out(dev, 0,\ncpu->env.irq_inputs[PPC6xx_INPUT_INT]);", "sysbus_connect_irq(pcihost, 0, qdev_get_gpio_in(dev, 15));", "sysbus_connect_irq(pcihost, 1, qdev_get_gpio_in(dev, 13));", "sysbus_connect_irq(pcihost, 2, qdev_get_gpio_in(dev, 15));", "sysbus_connect_irq(pcihost, 3, qdev_get_gpio_in(dev, 13));", "isa_bus = ISA_BUS(qdev_get_child_bus(dev, \"isa.0\"));", "dev = DEVICE(isa_create(isa_bus, \"rs6000-mc\"));", "qdev_prop_set_uint32(dev, \"ram-size\", VAR_0->ram_size);", "qdev_init_nofail(dev);", "cmos_checksum = 0x6aa9;", "qbus_walk_children(BUS(isa_bus), prep_set_cmos_checksum, NULL, NULL, NULL,\n&cmos_checksum);", "if (defaults_enabled()) {", "isa_create_simple(isa_bus, \"i8042\");", "m48t59 = NVRAM(isa_create_simple(isa_bus, \"isa-m48t59\"));", "dev = DEVICE(isa_create(isa_bus, \"cs4231a\"));", "qdev_prop_set_uint32(dev, \"iobase\", 0x830);", "qdev_prop_set_uint32(dev, \"irq\", 10);", "qdev_init_nofail(dev);", "dev = DEVICE(isa_create(isa_bus, \"pc87312\"));", "qdev_prop_set_uint32(dev, \"config\", 12);", "qdev_init_nofail(dev);", "dev = DEVICE(isa_create(isa_bus, \"prep-systemio\"));", "qdev_prop_set_uint32(dev, \"ibm-planar-id\", 0xfc);", "qdev_prop_set_uint32(dev, \"equipment\", 0xc0);", "qdev_init_nofail(dev);", "pci_create_simple(pci_bus, PCI_DEVFN(1, 0), \"lsi53c810\");", "pci_vga_init(pci_bus);", "for (VAR_2 = 0; VAR_2 < nb_nics; VAR_2++) {", "pci_nic_init_nofail(&nd_table[VAR_2], pci_bus, \"pcnet\",\nVAR_2 == 0 ? \"3\" : NULL);", "}", "}", "VAR_1 = fw_cfg_init_mem(CFG_ADDR, CFG_ADDR + 2);", "if (VAR_0->kernel_filename) {", "kernel_base = KERNEL_LOAD_ADDR;", "VAR_3 = load_image_targphys(VAR_0->kernel_filename,\nkernel_base,\nVAR_0->ram_size - kernel_base);", "if (VAR_3 < 0) {", "error_report(\"could not load kernel '%s'\",\nVAR_0->kernel_filename);", "exit(1);", "}", "fw_cfg_add_i32(VAR_1, FW_CFG_KERNEL_ADDR, kernel_base);", "fw_cfg_add_i32(VAR_1, FW_CFG_KERNEL_SIZE, VAR_3);", "if (VAR_0->initrd_filename) {", "initrd_base = INITRD_LOAD_ADDR;", "VAR_4 = load_image_targphys(VAR_0->initrd_filename,\ninitrd_base,\nVAR_0->ram_size - initrd_base);", "if (VAR_4 < 0) {", "error_report(\"could not load initial ram disk '%s'\",\nVAR_0->initrd_filename);", "exit(1);", "}", "fw_cfg_add_i32(VAR_1, FW_CFG_INITRD_ADDR, initrd_base);", "fw_cfg_add_i32(VAR_1, FW_CFG_INITRD_SIZE, VAR_4);", "}", "if (VAR_0->kernel_cmdline && *VAR_0->kernel_cmdline) {", "fw_cfg_add_i32(VAR_1, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR);", "pstrcpy_targphys(\"cmdline\", CMDLINE_ADDR, TARGET_PAGE_SIZE,\nVAR_0->kernel_cmdline);", "fw_cfg_add_string(VAR_1, FW_CFG_CMDLINE_DATA,\nVAR_0->kernel_cmdline);", "fw_cfg_add_i32(VAR_1, FW_CFG_CMDLINE_SIZE,\nstrlen(VAR_0->kernel_cmdline) + 1);", "}", "VAR_5 = 'm';", "} else {", "VAR_5 = VAR_0->boot_order[0];", "}", "fw_cfg_add_i16(VAR_1, FW_CFG_MAX_CPUS, (uint16_t)max_cpus);", "fw_cfg_add_i64(VAR_1, FW_CFG_RAM_SIZE, (uint64_t)VAR_0->ram_size);", "fw_cfg_add_i16(VAR_1, FW_CFG_MACHINE_ID, ARCH_PREP);", "fw_cfg_add_i16(VAR_1, FW_CFG_PPC_WIDTH, graphic_width);", "fw_cfg_add_i16(VAR_1, FW_CFG_PPC_HEIGHT, graphic_height);", "fw_cfg_add_i16(VAR_1, FW_CFG_PPC_DEPTH, graphic_depth);", "fw_cfg_add_i32(VAR_1, FW_CFG_PPC_IS_KVM, kvm_enabled());", "if (kvm_enabled()) {", "#ifdef CONFIG_KVM\nuint8_t *hypercall;", "fw_cfg_add_i32(VAR_1, FW_CFG_PPC_TBFREQ, kvmppc_get_tbfreq());", "hypercall = g_malloc(16);", "kvmppc_get_hypercall(env, hypercall, 16);", "fw_cfg_add_bytes(VAR_1, FW_CFG_PPC_KVM_HC, hypercall, 16);", "fw_cfg_add_i32(VAR_1, FW_CFG_PPC_KVM_PID, getpid());", "#endif\n} else {", "fw_cfg_add_i32(VAR_1, FW_CFG_PPC_TBFREQ, NANOSECONDS_PER_SECOND);", "}", "fw_cfg_add_i16(VAR_1, FW_CFG_BOOT_DEVICE, VAR_5);", "qemu_register_boot_set(fw_cfg_boot_set, VAR_1);", "if (m48t59) {", "PPC_NVRAM_set_params(m48t59, NVRAM_SIZE, \"PREP\", ram_size,\nVAR_5,\nkernel_base, VAR_3,\nVAR_0->kernel_cmdline,\ninitrd_base, VAR_4,\n0,\ngraphic_width, graphic_height, graphic_depth);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 117 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 137 ], [ 139 ], [ 141 ], [ 147 ], [ 149, 151 ], [ 157 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 193 ], [ 199 ], [ 203 ], [ 205, 207 ], [ 209 ], [ 211 ], [ 217 ], [ 221 ], [ 225 ], [ 227, 229, 231 ], [ 233 ], [ 235, 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 249 ], [ 251 ], [ 253, 255, 257 ], [ 259 ], [ 261, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279, 281 ], [ 283, 285 ], [ 287, 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 303 ], [ 305 ], [ 307 ], [ 311 ], [ 313 ], [ 315 ], [ 319 ], [ 321 ], [ 323, 325 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339, 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 355 ], [ 357, 359, 361, 363, 365, 369, 371 ], [ 373 ], [ 375 ] ]

[ "static void *FUNC_0(target_phys_addr_t VAR_0, uint32_t VAR_1, qemu_irq VAR_2)\n{", "DeviceState *dev;", "SysBusDevice *s;", "dev = qdev_create(NULL, \"iommu\");", "qdev_prop_set_uint32(dev, \"VAR_1\", VAR_1);", "qdev_init(dev);", "s = sysbus_from_qdev(dev);", "sysbus_connect_irq(s, 0, VAR_2);", "sysbus_mmio_map(s, 0, VAR_0);", "return s;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "const char *VAR_0 = \"\";", "uint64_t res = 999;", "int VAR_1;", "VAR_1 = qemu_strtoull(VAR_0, NULL, 0, &res);", "g_assert_cmpint(VAR_1, ==, 0);", "g_assert_cmpint(res, ==, 0);", "}" ]

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

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

[ "static inline void FUNC_0(hcscale_fast)(SwsContext *c, int16_t *dst1, int16_t *dst2,\nint dstWidth, const uint8_t *src1,\nconst uint8_t *src2, int srcW, int xInc)\n{", "int32_t *filterPos = c->hChrFilterPos;", "int16_t *filter = c->hChrFilter;", "void *VAR_0= c->chrMmx2FilterCode;", "int VAR_1;", "#if defined(PIC)\nDECLARE_ALIGNED(8, uint64_t, ebxsave);", "#endif\n__asm__ volatile(\n#if defined(PIC)\n\"mov %%\"REG_b\", %7 \\n\\t\"\n#endif\n\"pxor %%mm7, %%mm7 \\n\\t\"\n\"mov %0, %%\"REG_c\" \\n\\t\"\n\"mov %1, %%\"REG_D\" \\n\\t\"\n\"mov %2, %%\"REG_d\" \\n\\t\"\n\"mov %3, %%\"REG_b\" \\n\\t\"\n\"xor %%\"REG_a\", %%\"REG_a\" \\n\\t\"\nPREFETCH\" (%%\"REG_c\") \\n\\t\"\nPREFETCH\" 32(%%\"REG_c\") \\n\\t\"\nPREFETCH\" 64(%%\"REG_c\") \\n\\t\"\nCALL_MMX2_FILTER_CODE\nCALL_MMX2_FILTER_CODE\nCALL_MMX2_FILTER_CODE\nCALL_MMX2_FILTER_CODE\n\"xor %%\"REG_a\", %%\"REG_a\" \\n\\t\"\n\"mov %5, %%\"REG_c\" \\n\\t\"\n\"mov %6, %%\"REG_D\" \\n\\t\"\nPREFETCH\" (%%\"REG_c\") \\n\\t\"\nPREFETCH\" 32(%%\"REG_c\") \\n\\t\"\nPREFETCH\" 64(%%\"REG_c\") \\n\\t\"\nCALL_MMX2_FILTER_CODE\nCALL_MMX2_FILTER_CODE\nCALL_MMX2_FILTER_CODE\nCALL_MMX2_FILTER_CODE\n#if defined(PIC)\n\"mov %7, %%\"REG_b\" \\n\\t\"\n#endif\n:: \"m\" (src1), \"m\" (dst1), \"m\" (filter), \"m\" (filterPos),\n\"m\" (VAR_0), \"m\" (src2), \"m\"(dst2)\n#if defined(PIC)\n,\"m\" (ebxsave)\n#endif\n: \"%\"REG_a, \"%\"REG_c, \"%\"REG_d, \"%\"REG_S, \"%\"REG_D\n#if !defined(PIC)\n,\"%\"REG_b\n#endif\n);", "for (VAR_1=dstWidth-1; (VAR_1*xInc)>>16 >=srcW-1; VAR_1--) {", "dst1[VAR_1] = src1[srcW-1]*128;", "dst2[VAR_1] = src2[srcW-1]*128;", "}", "}" ]

[ 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, 47, 49, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 75, 77, 79, 81, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ] ]

[ "static void FUNC_0(Object *VAR_0, Visitor *VAR_1, Property *VAR_2,\nconst char *(*VAR_3)(void *VAR_7),\nconst char *VAR_5, Error **VAR_6)\n{", "DeviceState *dev = DEVICE(VAR_0);", "void **VAR_7 = qdev_get_prop_ptr(dev, VAR_2);", "char *VAR_7;", "VAR_7 = (char *) (*VAR_7 ? VAR_3(*VAR_7) : \"\");", "visit_type_str(VAR_1, &VAR_7, VAR_5, VAR_6);", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,\nunsigned int size)\n{", "LedState *s = opaque;", "uint8_t val;", "val = s->segments;", "trace_jazz_led_read(addr, val);", "return val;", "}" ]

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

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

[ "float32 FUNC_0(ucf64_divs)(float32 a, float32 b, CPUUniCore32State *env)\n{", "return float32_div(a, b, &env->ucf64.fp_status);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(VAR_0);", "sc->realize = scsi_generic_realize;", "sc->unrealize = scsi_unrealize;", "sc->alloc_req = scsi_new_request;", "sc->parse_cdb = scsi_generic_parse_cdb;", "dc->fw_name = \"disk\";", "dc->desc = \"pass through generic scsi device (/dev/sg*)\";", "dc->reset = scsi_generic_reset;", "dc->props = scsi_generic_properties;", "dc->vmsd = &vmstate_scsi_device;", "}" ]

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

[ "FUNC_0(VAR_0)\n{", "int VAR_1;", "QList *qlist;", "qlist = qlist_new();", "for (VAR_1 = 0; VAR_1 < 42; VAR_1++)", "qlist_append(qlist, qint_from_int(VAR_1));", "QDECREF(qlist);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "VncState *vs = VAR_0;", "long VAR_2;", "buffer_reserve(&vs->input, 4096);", "#ifdef CONFIG_VNC_TLS\nif (vs->tls_session) {", "VAR_2 = gnutls_read(vs->tls_session, buffer_end(&vs->input), 4096);", "if (VAR_2 < 0) {", "if (VAR_2 == GNUTLS_E_AGAIN)\nerrno = EAGAIN;", "else\nerrno = EIO;", "VAR_2 = -1;", "}", "} else", "#endif\nVAR_2 = recv(vs->csock, buffer_end(&vs->input), 4096, 0);", "VAR_2 = vnc_client_io_error(vs, VAR_2, socket_error());", "if (!VAR_2)\nreturn;", "vs->input.offset += VAR_2;", "while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {", "size_t len = vs->read_handler_expect;", "int VAR_2;", "VAR_2 = vs->read_handler(vs, vs->input.buffer, len);", "if (vs->csock == -1)\nreturn;", "if (!VAR_2) {", "memmove(vs->input.buffer, vs->input.buffer + len, (vs->input.offset - len));", "vs->input.offset -= len;", "} else {", "vs->read_handler_expect = VAR_2;", "}", "}", "}" ]

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

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

[ "FUNC_0(e5500)(ObjectClass *oc, void *data)\n{", "DeviceClass *dc = DEVICE_CLASS(oc);", "PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);", "dc->desc = \"e5500 core\";", "pcc->init_proc = init_proc_e5500;", "pcc->check_pow = check_pow_none;", "pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |\nPPC_WRTEE | PPC_RFDI | PPC_RFMCI |\nPPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |\nPPC_CACHE_DCBZ | PPC_CACHE_DCBA |\nPPC_FLOAT | PPC_FLOAT_FRES |\nPPC_FLOAT_FRSQRTE | PPC_FLOAT_FSEL |\nPPC_FLOAT_STFIWX | PPC_WAIT |\nPPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC |\nPPC_64B | PPC_POPCNTB | PPC_POPCNTWD;", "pcc->insns_flags2 = PPC2_BOOKE206 | PPC2_PRCNTL | PPC2_PERM_ISA206;", "pcc->msr_mask = (1ull << MSR_CM) |\n(1ull << MSR_GS) |\n(1ull << MSR_UCLE) |\n(1ull << MSR_CE) |\n(1ull << MSR_EE) |\n(1ull << MSR_PR) |\n(1ull << MSR_FP) |\n(1ull << MSR_ME) |\n(1ull << MSR_FE0) |\n(1ull << MSR_DE) |\n(1ull << MSR_FE1) |\n(1ull << MSR_IR) |\n(1ull << MSR_DR) |\n(1ull << MSR_PX) |\n(1ull << MSR_RI);", "pcc->mmu_model = POWERPC_MMU_BOOKE206;", "pcc->excp_model = POWERPC_EXCP_BOOKE;", "pcc->bus_model = PPC_FLAGS_INPUT_BookE;", "pcc->bfd_mach = bfd_mach_ppc_e500;", "pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |\nPOWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;", "}" ]

[ 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 ], [ 75 ], [ 77, 79 ], [ 81 ] ]

[ "void FUNC_0(AVMD5 *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "const uint8_t *VAR_3;", "int VAR_4;", "VAR_4 = VAR_0->VAR_2 & 63;", "VAR_0->VAR_2 += VAR_2;", "if (VAR_4) {", "int VAR_5 = FFMIN(VAR_2, 64 - VAR_4);", "memcpy(VAR_0->block + VAR_4, VAR_1, VAR_5);", "VAR_1 += VAR_5;", "VAR_2 -= VAR_5;", "if (VAR_4 + VAR_5 < 64)\nreturn;", "body(VAR_0->ABCD, (uint32_t *)VAR_0->block);", "}", "VAR_3 = VAR_1 + (VAR_2 & ~63);", "if (HAVE_BIGENDIAN || (!HAVE_FAST_UNALIGNED && ((intptr_t)VAR_1 & 3))) {", "while (VAR_1 < VAR_3) {", "memcpy(VAR_0->block, VAR_1, 64);", "body(VAR_0->ABCD, (uint32_t *) VAR_0->block);", "VAR_1 += 64;", "}", "} else {", "while (VAR_1 < VAR_3) {", "body(VAR_0->ABCD, (uint32_t *)VAR_1);", "VAR_1 += 64;", "}", "}", "VAR_2 &= 63;", "if (VAR_2 > 0)\nmemcpy(VAR_0->block, VAR_1, VAR_2);", "}" ]

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

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

[ "int FUNC_0()\n{", "int VAR_0, VAR_1;", "int VAR_2, VAR_3;", "int VAR_4;", "int VAR_5, VAR_6;", "int VAR_7, VAR_8;", "int VAR_9;", "VAR_2 = 0x05;", "VAR_3 = 0xB4CB;", "VAR_1 = 0xFF06;", "VAR_0 = 0xCB00;", "VAR_7 = 0x04;", "VAR_8 = 0x947438CB;", "__asm\n(\"mthi %2, $ac1\\n\\t\"\n\"mtlo %3, $ac1\\n\\t\"\n\"maq_s.w.phr $ac1, %4, %5\\n\\t\"\n\"mfhi %0, $ac1\\n\\t\"\n\"mflo %1, $ac1\\n\\t\"\n: \"=r\"(VAR_5), \"=r\"(VAR_6)\n: \"r\"(VAR_2), \"r\"(VAR_3), \"r\"(VAR_1), \"r\"(VAR_0)\n);", "assert(VAR_7 == VAR_5);", "assert(VAR_8 == VAR_6);", "VAR_2 = 0x06;", "VAR_3 = 0xB4CB;", "VAR_1 = 0x8000;", "VAR_0 = 0x8000;", "VAR_7 = 0x6;", "VAR_8 = 0x8000b4ca;", "VAR_9 = 1;", "__asm\n(\"mthi %3, $ac1\\n\\t\"\n\"mtlo %4, $ac1\\n\\t\"\n\"maq_s.w.phr $ac1, %5, %6\\n\\t\"\n\"mfhi %0, $ac1\\n\\t\"\n\"mflo %1, $ac1\\n\\t\"\n\"rddsp %2\\n\\t\"\n: \"=r\"(VAR_5), \"=r\"(VAR_6), \"=r\"(VAR_4)\n: \"r\"(VAR_2), \"r\"(VAR_3), \"r\"(VAR_1), \"r\"(VAR_0)\n);", "assert(VAR_7 == VAR_5);", "assert(VAR_8 == VAR_6);", "assert(((VAR_4 >> 17) & 0x01) == VAR_9);", "return 0;", "}" ]

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

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

[ "int FUNC_0(IDEState *VAR_0, BlockDriverState *VAR_1, IDEDriveKind VAR_2,\nconst char *VAR_3, const char *VAR_4)\n{", "int VAR_5, VAR_6, VAR_7;", "uint64_t nb_sectors;", "VAR_0->VAR_1 = VAR_1;", "VAR_0->drive_kind = VAR_2;", "bdrv_get_geometry(VAR_1, &nb_sectors);", "bdrv_guess_geometry(VAR_1, &VAR_5, &VAR_6, &VAR_7);", "if (VAR_5 < 1 || VAR_5 > 16383) {", "error_report(\"cyls must be between 1 and 16383\");", "return -1;", "}", "if (VAR_6 < 1 || VAR_6 > 16) {", "error_report(\"VAR_6 must be between 1 and 16\");", "return -1;", "}", "if (VAR_7 < 1 || VAR_7 > 63) {", "error_report(\"VAR_7 must be between 1 and 63\");", "return -1;", "}", "VAR_0->VAR_5 = VAR_5;", "VAR_0->VAR_6 = VAR_6;", "VAR_0->sectors = VAR_7;", "VAR_0->nb_sectors = nb_sectors;", "VAR_0->smart_enabled = 1;", "VAR_0->smart_autosave = 1;", "VAR_0->smart_errors = 0;", "VAR_0->smart_selftest_count = 0;", "if (VAR_2 == IDE_CD) {", "bdrv_set_dev_ops(VAR_1, &ide_cd_block_ops, VAR_0);", "bdrv_set_buffer_alignment(VAR_1, 2048);", "} else {", "if (!bdrv_is_inserted(VAR_0->VAR_1)) {", "error_report(\"Device needs media, but drive is empty\");", "return -1;", "}", "if (bdrv_is_read_only(VAR_1)) {", "error_report(\"Can't use a read-only drive\");", "return -1;", "}", "}", "if (VAR_4) {", "strncpy(VAR_0->drive_serial_str, VAR_4, sizeof(VAR_0->drive_serial_str));", "} else {", "snprintf(VAR_0->drive_serial_str, sizeof(VAR_0->drive_serial_str),\n\"QM%05d\", VAR_0->drive_serial);", "}", "if (VAR_3) {", "pstrcpy(VAR_0->VAR_3, sizeof(VAR_0->VAR_3), VAR_3);", "} else {", "pstrcpy(VAR_0->VAR_3, sizeof(VAR_0->VAR_3), QEMU_VERSION);", "}", "ide_reset(VAR_0);", "bdrv_iostatus_enable(VAR_1);", "return 0;", "}" ]

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

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

[ "int FUNC_0(SubchDev *VAR_0, QEMUFile *VAR_1)\n{", "SubchDev *old_s;", "Error *err = NULL;", "uint16_t old_schid = VAR_0->schid;", "uint16_t old_devno = VAR_0->devno;", "int VAR_2;", "VAR_0->cssid = qemu_get_byte(VAR_1);", "VAR_0->ssid = qemu_get_byte(VAR_1);", "VAR_0->schid = qemu_get_be16(VAR_1);", "VAR_0->devno = qemu_get_be16(VAR_1);", "if (VAR_0->devno != old_devno) {", "error_setg(&err, \"%x != %x\", old_devno, VAR_0->devno);", "error_append_hint(&err, \"Devno mismatch, tried to load wrong section!\"\n\" Likely reason: some sequences of plug and unplug\"\n\" can break migration for machine versions prior to\"\n\" 2.7 (known design flaw).\\n\");", "error_report_err(err);", "return -EINVAL;", "}", "if (old_schid != VAR_0->schid) {", "old_s = channel_subsys.css[VAR_0->cssid]->sch_set[VAR_0->ssid]->sch[old_schid];", "if (old_s == VAR_0) {", "css_subch_assign(VAR_0->cssid, VAR_0->ssid, old_schid, VAR_0->devno, NULL);", "}", "css_subch_assign(VAR_0->cssid, VAR_0->ssid, VAR_0->schid, VAR_0->devno, VAR_0);", "}", "VAR_0->thinint_active = qemu_get_byte(VAR_1);", "VAR_0->curr_status.pmcw.intparm = qemu_get_be32(VAR_1);", "VAR_0->curr_status.pmcw.flags = qemu_get_be16(VAR_1);", "VAR_0->curr_status.pmcw.devno = qemu_get_be16(VAR_1);", "VAR_0->curr_status.pmcw.lpm = qemu_get_byte(VAR_1);", "VAR_0->curr_status.pmcw.pnom = qemu_get_byte(VAR_1);", "VAR_0->curr_status.pmcw.lpum = qemu_get_byte(VAR_1);", "VAR_0->curr_status.pmcw.pim = qemu_get_byte(VAR_1);", "VAR_0->curr_status.pmcw.mbi = qemu_get_be16(VAR_1);", "VAR_0->curr_status.pmcw.pom = qemu_get_byte(VAR_1);", "VAR_0->curr_status.pmcw.pam = qemu_get_byte(VAR_1);", "qemu_get_buffer(VAR_1, VAR_0->curr_status.pmcw.chpid, 8);", "VAR_0->curr_status.pmcw.chars = qemu_get_be32(VAR_1);", "VAR_0->curr_status.scsw.flags = qemu_get_be16(VAR_1);", "VAR_0->curr_status.scsw.ctrl = qemu_get_be16(VAR_1);", "VAR_0->curr_status.scsw.cpa = qemu_get_be32(VAR_1);", "VAR_0->curr_status.scsw.dstat = qemu_get_byte(VAR_1);", "VAR_0->curr_status.scsw.cstat = qemu_get_byte(VAR_1);", "VAR_0->curr_status.scsw.count = qemu_get_be16(VAR_1);", "VAR_0->curr_status.mba = qemu_get_be64(VAR_1);", "qemu_get_buffer(VAR_1, VAR_0->curr_status.mda, 4);", "qemu_get_buffer(VAR_1, VAR_0->sense_data, 32);", "VAR_0->channel_prog = qemu_get_be64(VAR_1);", "VAR_0->last_cmd.cmd_code = qemu_get_byte(VAR_1);", "VAR_0->last_cmd.flags = qemu_get_byte(VAR_1);", "VAR_0->last_cmd.count = qemu_get_be16(VAR_1);", "VAR_0->last_cmd.cda = qemu_get_be32(VAR_1);", "VAR_0->last_cmd_valid = qemu_get_byte(VAR_1);", "VAR_0->id.reserved = qemu_get_byte(VAR_1);", "VAR_0->id.cu_type = qemu_get_be16(VAR_1);", "VAR_0->id.cu_model = qemu_get_byte(VAR_1);", "VAR_0->id.dev_type = qemu_get_be16(VAR_1);", "VAR_0->id.dev_model = qemu_get_byte(VAR_1);", "VAR_0->id.unused = qemu_get_byte(VAR_1);", "for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(VAR_0->id.ciw); VAR_2++) {", "VAR_0->id.ciw[VAR_2].type = qemu_get_byte(VAR_1);", "VAR_0->id.ciw[VAR_2].command = qemu_get_byte(VAR_1);", "VAR_0->id.ciw[VAR_2].count = qemu_get_be16(VAR_1);", "}", "VAR_0->ccw_fmt_1 = qemu_get_byte(VAR_1);", "VAR_0->ccw_no_data_cnt = qemu_get_byte(VAR_1);", "if (VAR_0->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ENA) {", "if (VAR_0->ssid) {", "channel_subsys.max_ssid = MAX_SSID;", "}", "if (VAR_0->cssid != channel_subsys.default_cssid) {", "channel_subsys.max_cssid = MAX_CSSID;", "}", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 31 ], [ 33, 35, 37, 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ] ]