Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "int FUNC_0(AVFilterContext *VAR_0)\n{", "enum AVMediaType VAR_1 = VAR_0->inputs [0] ? VAR_0->inputs [0]->VAR_1 :\nVAR_0->outputs[0] ? VAR_0->outputs[0]->VAR_1 :\nAVMEDIA_TYPE_VIDEO;", "avfilter_set_common_formats(VAR_0, avfilter_all_formats(VAR_1));", "return 0;", "}" ]

[ 0, 1, 0, 0, 0 ]

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

[ "static void FUNC_0(MemoryListener *VAR_0,\nMemoryRegionSection *VAR_1)\n{", "struct vhost_dev *VAR_2 = container_of(VAR_0, struct vhost_dev,\nmemory_listener);", "hwaddr start_addr = VAR_1->offset_within_address_space;", "hwaddr end_addr = start_addr + VAR_1->size;", "vhost_sync_dirty_bitmap(VAR_2, VAR_1, start_addr, end_addr);", "}" ]

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

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

[ "static void FUNC_0(PutBitContext * VAR_0, codebook_t * VAR_1) {", "int VAR_2;", "int VAR_3 = 0;", "put_bits(VAR_0, 24, 0x564342);", "put_bits(VAR_0, 16, VAR_1->ndimentions);", "put_bits(VAR_0, 24, VAR_1->nentries);", "for (VAR_2 = 1; VAR_2 < VAR_1->nentries; VAR_2++) if (VAR_1->entries[VAR_2].VAR_4 < VAR_1->entries[VAR_2-1].VAR_4) break;", "if (VAR_2 == VAR_1->nentries) VAR_3 = 1;", "put_bits(VAR_0, 1, VAR_3);", "if (VAR_3) {", "int VAR_4 = VAR_1->entries[0].VAR_4;", "put_bits(VAR_0, 5, VAR_4);", "VAR_2 = 0;", "while (VAR_2 < VAR_1->nentries) {", "int VAR_5;", "for (VAR_5 = 0; VAR_5+VAR_2 < VAR_1->nentries; VAR_5++) if (VAR_1->entries[VAR_5+VAR_2].VAR_4 != VAR_4) break;", "put_bits(VAR_0, ilog(VAR_1->nentries - VAR_2), VAR_5);", "VAR_2 += VAR_5;", "VAR_4++;", "}", "} else {", "int VAR_6 = 0;", "for (VAR_2 = 0; VAR_2 < VAR_1->nentries; VAR_2++) if (!VAR_1->entries[VAR_2].VAR_4) break;", "if (VAR_2 != VAR_1->nentries) VAR_6 = 1;", "put_bits(VAR_0, 1, VAR_6);", "for (VAR_2 = 0; VAR_2 < VAR_1->nentries; VAR_2++) {", "if (VAR_6) put_bits(VAR_0, 1, !!VAR_1->entries[VAR_2].VAR_4);", "if (VAR_1->entries[VAR_2].VAR_4) put_bits(VAR_0, 5, VAR_1->entries[VAR_2].VAR_4 - 1);", "}", "}", "put_bits(VAR_0, 4, VAR_1->lookup);", "if (VAR_1->lookup) {", "int VAR_7 = cb_lookup_vals(VAR_1->lookup, VAR_1->ndimentions, VAR_1->nentries);", "int VAR_8 = ilog(VAR_1->quantlist[0]);", "for (VAR_2 = 1; VAR_2 < VAR_7; VAR_2++) VAR_8 = FFMAX(VAR_8, ilog(VAR_1->quantlist[VAR_2]));", "put_float(VAR_0, VAR_1->min);", "put_float(VAR_0, VAR_1->delta);", "put_bits(VAR_0, 4, VAR_8 - 1);", "put_bits(VAR_0, 1, VAR_1->seq_p);", "for (VAR_2 = 0; VAR_2 < VAR_7; VAR_2++) put_bits(VAR_0, VAR_8, VAR_1->quantlist[VAR_2]);", "}", "}" ]

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

[ [ 1 ], [ 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 85 ], [ 87 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ] ]

[ "static int FUNC_0(QEMUFile *VAR_0, BlkMigDevState *VAR_1,\nint VAR_2)\n{", "BlkMigBlock *blk;", "int64_t total_sectors = VAR_1->total_sectors;", "int64_t sector;", "int VAR_3;", "int VAR_4 = -EIO;", "for (sector = VAR_1->cur_dirty; sector < VAR_1->total_sectors;) {", "blk_mig_lock();", "if (bmds_aio_inflight(VAR_1, sector)) {", "blk_mig_unlock();", "bdrv_drain_all();", "} else {", "blk_mig_unlock();", "}", "if (bdrv_get_dirty(VAR_1->bs, VAR_1->dirty_bitmap, sector)) {", "if (total_sectors - sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {", "VAR_3 = total_sectors - sector;", "} else {", "VAR_3 = BDRV_SECTORS_PER_DIRTY_CHUNK;", "}", "blk = g_new(BlkMigBlock, 1);", "blk->buf = g_malloc(BLOCK_SIZE);", "blk->VAR_1 = VAR_1;", "blk->sector = sector;", "blk->VAR_3 = VAR_3;", "if (VAR_2) {", "blk->iov.iov_base = blk->buf;", "blk->iov.iov_len = VAR_3 * BDRV_SECTOR_SIZE;", "qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);", "blk->aiocb = bdrv_aio_readv(VAR_1->bs, sector, &blk->qiov,\nVAR_3, blk_mig_read_cb, blk);", "blk_mig_lock();", "block_mig_state.submitted++;", "bmds_set_aio_inflight(VAR_1, sector, VAR_3, 1);", "blk_mig_unlock();", "} else {", "VAR_4 = bdrv_read(VAR_1->bs, sector, blk->buf, VAR_3);", "if (VAR_4 < 0) {", "goto error;", "}", "blk_send(VAR_0, blk);", "g_free(blk->buf);", "g_free(blk);", "}", "bdrv_reset_dirty(VAR_1->bs, sector, VAR_3);", "break;", "}", "sector += BDRV_SECTORS_PER_DIRTY_CHUNK;", "VAR_1->cur_dirty = sector;", "}", "return (VAR_1->cur_dirty >= VAR_1->total_sectors);", "error:\nDPRINTF(\"Error reading sector %\" PRId64 \"\\n\", sector);", "g_free(blk->buf);", "g_free(blk);", "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, 1, 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 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71, 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 125, 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ] ]

[ "void FUNC_0(BusState *VAR_0)\n{", "DeviceState *dev;", "while ((dev = QLIST_FIRST(&VAR_0->children)) != NULL) {", "qdev_free(dev);", "}", "if (VAR_0->parent) {", "QLIST_REMOVE(VAR_0, sibling);", "VAR_0->parent->num_child_bus--;", "}", "if (VAR_0->qdev_allocated) {", "qemu_free(VAR_0);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 24 ], [ 26 ], [ 28 ], [ 30 ] ]

[ "static void FUNC_0(CinepakEncContext *VAR_0, AVPicture *VAR_1, int *VAR_2, strip_info *VAR_3)\n{", "int VAR_4, VAR_5, VAR_6, VAR_7 = VAR_0->pix_fmt == AV_PIX_FMT_YUV420P ? 6 : 4;", "for(VAR_4 = VAR_6 = 0; VAR_6 < 4; VAR_6 += 2) {", "for(VAR_5 = 0; VAR_5 < 4; VAR_5 += 2, VAR_4++) {", "VAR_1->data[0][VAR_5 + VAR_6*VAR_1->linesize[0]] = VAR_3->v4_codebook[VAR_2[VAR_4]*VAR_7];", "VAR_1->data[0][VAR_5+1 + VAR_6*VAR_1->linesize[0]] = VAR_3->v4_codebook[VAR_2[VAR_4]*VAR_7+1];", "VAR_1->data[0][VAR_5 + (VAR_6+1)*VAR_1->linesize[0]] = VAR_3->v4_codebook[VAR_2[VAR_4]*VAR_7+2];", "VAR_1->data[0][VAR_5+1 + (VAR_6+1)*VAR_1->linesize[0]] = VAR_3->v4_codebook[VAR_2[VAR_4]*VAR_7+3];", "if(VAR_0->pix_fmt == AV_PIX_FMT_YUV420P) {", "VAR_1->data[1][(VAR_5>>1) + (VAR_6>>1)*VAR_1->linesize[1]] = VAR_3->v4_codebook[VAR_2[VAR_4]*VAR_7+4];", "VAR_1->data[2][(VAR_5>>1) + (VAR_6>>1)*VAR_1->linesize[2]] = VAR_3->v4_codebook[VAR_2[VAR_4]*VAR_7+5];", "}", "}", "}", "}" ]

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

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

[ "static const TPMDriverOps *FUNC_0(enum TpmType type)\n{", "int VAR_0;", "for (VAR_0 = 0; VAR_0 < TPM_MAX_DRIVERS && be_drivers[VAR_0] != NULL; VAR_0++) {", "if (be_drivers[VAR_0]->type == type) {", "return be_drivers[VAR_0];", "}", "}", "return NULL;", "}" ]

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

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

[ "static int FUNC_0(FICContext *VAR_0, GetBitContext *VAR_1,\nuint8_t *VAR_2, int VAR_3, int16_t *VAR_4, int *VAR_5)\n{", "int VAR_6, VAR_7;", "if (get_bits1(VAR_1)) {", "*VAR_5 = 1;", "return 0;", "}", "memset(VAR_4, 0, sizeof(*VAR_4) * 64);", "VAR_7 = get_bits(VAR_1, 7);", "if (VAR_7 > 64)\nreturn AVERROR_INVALIDDATA;", "for (VAR_6 = 0; VAR_6 < VAR_7; VAR_6++)", "VAR_4[ff_zigzag_direct[VAR_6]] = get_se_golomb(VAR_1) *\nVAR_0->qmat[ff_zigzag_direct[VAR_6]];", "fic_idct_put(VAR_2, VAR_3, VAR_4);", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 27 ], [ 29, 31 ], [ 35 ], [ 37, 39 ], [ 43 ], [ 47 ], [ 49 ] ]

[ "static inline void FUNC_0(yuv2yuv1)(int16_t *lumSrc, int16_t *chrSrc,\nuint8_t *dest, uint8_t *uDest, uint8_t *vDest, long dstW, long chrDstW)\n{", "#ifdef HAVE_MMX\nif(uDest != NULL)\n{", "asm volatile(\nYSCALEYUV2YV121\n:: \"r\" (chrSrc + chrDstW), \"r\" (uDest + chrDstW),\n\"g\" (-chrDstW)\n: \"%\"REG_a\n);", "asm volatile(\nYSCALEYUV2YV121\n:: \"r\" (chrSrc + 2048 + chrDstW), \"r\" (vDest + chrDstW),\n\"g\" (-chrDstW)\n: \"%\"REG_a\n);", "}", "asm volatile(\nYSCALEYUV2YV121\n:: \"r\" (lumSrc + dstW), \"r\" (dest + dstW),\n\"g\" (-dstW)\n: \"%\"REG_a\n);", "#else\nint VAR_0;", "for(VAR_0=0; VAR_0<dstW; VAR_0++)", "{", "int val= lumSrc[VAR_0]>>7;", "if(val&256){", "if(val<0) val=0;", "else val=255;", "}", "dest[VAR_0]= val;", "}", "if(uDest != NULL)\nfor(VAR_0=0; VAR_0<chrDstW; VAR_0++)", "{", "int u=chrSrc[VAR_0]>>7;", "int v=chrSrc[VAR_0 + 2048]>>7;", "if((u|v)&256){", "if(u<0) u=0;", "else if (u>255) u=255;", "if(v<0) v=0;", "else if (v>255) v=255;", "}", "uDest[VAR_0]= u;", "vDest[VAR_0]= v;", "}", "#endif\n}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0)\n{", "XanContext *s = VAR_0->priv_data;", "uint8_t *ybuf, *prev_buf, *src = s->scratch_buffer;", "unsigned VAR_1, VAR_2;", "int VAR_3, VAR_4;", "int VAR_5, VAR_6;", "int VAR_7;", "VAR_1 = bytestream2_get_le32(&s->gb);", "VAR_2 = bytestream2_get_le32(&s->gb);", "if ((VAR_7 = xan_decode_chroma(VAR_0, VAR_1)) != 0)\nreturn VAR_7;", "if (VAR_2 >= (s->gb.buffer_end - s->gb.buffer_start)) {", "av_log(VAR_0, AV_LOG_WARNING, \"Ignoring invalid correction block position\\n\");", "VAR_2 = 0;", "}", "bytestream2_seek(&s->gb, 12, SEEK_SET);", "VAR_7 = xan_unpack_luma(s, src, s->buffer_size >> 1);", "if (VAR_7) {", "av_log(VAR_0, AV_LOG_ERROR, \"Luma decoding failed\\n\");", "return VAR_7;", "}", "ybuf = s->y_buffer;", "VAR_4 = *src++;", "ybuf[0] = VAR_4 << 1;", "for (VAR_6 = 1; VAR_6 < VAR_0->width - 1; VAR_6 += 2) {", "VAR_3 = (VAR_4 + *src++) & 0x1F;", "ybuf[VAR_6] = VAR_4 + VAR_3;", "ybuf[VAR_6+1] = VAR_3 << 1;", "VAR_4 = VAR_3;", "}", "ybuf[VAR_6] = VAR_4 << 1;", "prev_buf = ybuf;", "ybuf += VAR_0->width;", "for (VAR_5 = 1; VAR_5 < VAR_0->height; VAR_5++) {", "VAR_4 = ((prev_buf[0] >> 1) + *src++) & 0x1F;", "ybuf[0] = VAR_4 << 1;", "for (VAR_6 = 1; VAR_6 < VAR_0->width - 1; VAR_6 += 2) {", "VAR_3 = ((prev_buf[VAR_6 + 1] >> 1) + *src++) & 0x1F;", "ybuf[VAR_6] = VAR_4 + VAR_3;", "ybuf[VAR_6+1] = VAR_3 << 1;", "VAR_4 = VAR_3;", "}", "ybuf[VAR_6] = VAR_4 << 1;", "prev_buf = ybuf;", "ybuf += VAR_0->width;", "}", "if (VAR_2) {", "int VAR_8;", "bytestream2_seek(&s->gb, 8 + VAR_2, SEEK_SET);", "VAR_8 = xan_unpack(s, s->scratch_buffer, s->buffer_size);", "if (VAR_8 < 0)\nVAR_8 = 0;", "for (VAR_5 = 0; VAR_5 < VAR_8; VAR_5++)", "s->y_buffer[VAR_5*2+1] = (s->y_buffer[VAR_5*2+1] + (s->scratch_buffer[VAR_5] << 1)) & 0x3F;", "}", "src = s->y_buffer;", "ybuf = s->pic.data[0];", "for (VAR_6 = 0; VAR_6 < VAR_0->height; VAR_6++) {", "for (VAR_5 = 0; VAR_5 < VAR_0->width; VAR_5++)", "ybuf[VAR_5] = (src[VAR_5] << 2) | (src[VAR_5] >> 3);", "src += VAR_0->width;", "ybuf += s->pic.linesize[0];", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,\nuint8_t *VAR_2, int VAR_3)\n{", "BDRVRawState *s = VAR_0->opaque;", "int VAR_4, VAR_5, VAR_6, VAR_7;", "VAR_7 = 0;", "if (s->aligned_buf != NULL) {", "if (VAR_1 & 0x1ff) {", "VAR_6 = VAR_1 & 0x1ff;", "VAR_4 = (VAR_6 + VAR_3 + 0x1ff) & ~0x1ff;", "if (VAR_4 > ALIGNED_BUFFER_SIZE)\nVAR_4 = ALIGNED_BUFFER_SIZE;", "VAR_5 = raw_pread_aligned(VAR_0, VAR_1 - VAR_6, s->aligned_buf, VAR_4);", "if (VAR_5 < 0)\nreturn VAR_5;", "VAR_4 = 512 - VAR_6;", "if (VAR_4 > VAR_3)\nVAR_4 = VAR_3;", "memcpy(VAR_2, s->aligned_buf + VAR_6, VAR_4);", "VAR_2 += VAR_4;", "VAR_1 += VAR_4;", "VAR_3 -= VAR_4;", "VAR_7 += VAR_4;", "if (VAR_3 == 0)\nreturn VAR_7;", "}", "if (VAR_3 & 0x1ff || (uintptr_t) VAR_2 & 0x1ff) {", "while (VAR_3) {", "VAR_4 = (VAR_3 + 0x1ff) & ~0x1ff;", "if (VAR_4 > ALIGNED_BUFFER_SIZE)\nVAR_4 = ALIGNED_BUFFER_SIZE;", "VAR_5 = raw_pread_aligned(VAR_0, VAR_1, s->aligned_buf, VAR_4);", "if (VAR_5 < 0)\nreturn VAR_5;", "VAR_4 = VAR_5;", "if (VAR_4 > VAR_3)\nVAR_4 = VAR_3;", "memcpy(VAR_2, s->aligned_buf, VAR_4);", "VAR_2 += VAR_4;", "VAR_1 += VAR_4;", "VAR_3 -= VAR_4;", "VAR_7 += VAR_4;", "}", "return VAR_7;", "}", "}", "return raw_pread_aligned(VAR_0, VAR_1, VAR_2, VAR_3) + VAR_7;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 21 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37, 39 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 77 ], [ 81 ], [ 83, 85 ], [ 89 ], [ 91, 93 ], [ 97 ], [ 99, 101 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ] ]

[ "static av_always_inline int FUNC_0(uint8_t *p, ptrdiff_t stride,\nint E, int I)\n{", "LOAD_PIXELS\nreturn simple_limit(p, stride, E) &&\nFFABS(p3 - p2) <= I &&\nFFABS(p2 - p1) <= I &&\nFFABS(p1 - p0) <= I &&\nFFABS(q3 - q2) <= I &&\nFFABS(q2 - q1) <= I &&\nFFABS(q1 - q0) <= I;", "}" ]

[ 1, 1, 0 ]

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

[ "static int FUNC_0(CmvContext *VAR_0, const uint8_t *VAR_1, const uint8_t *VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6;", "if(VAR_2 - VAR_1 < 16) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"truncated header\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->width = AV_RL16(&VAR_1[4]);", "VAR_0->height = AV_RL16(&VAR_1[6]);", "VAR_6 = ff_set_dimensions(VAR_0->avctx, VAR_0->width, VAR_0->height);", "if (VAR_6 < 0)\nreturn VAR_6;", "VAR_0->avctx->time_base.num = 1;", "VAR_0->avctx->time_base.den = AV_RL16(&VAR_1[10]);", "VAR_3 = AV_RL16(&VAR_1[12]);", "VAR_4 = AV_RL16(&VAR_1[14]);", "VAR_1 += 16;", "for (VAR_5=VAR_3; VAR_5<VAR_3+VAR_4 && VAR_5<AVPALETTE_COUNT && VAR_2 - VAR_1 >= 3; VAR_5++) {", "VAR_0->palette[VAR_5] = AV_RB24(VAR_1);", "VAR_1 += 3;", "}", "return 0;", "}" ]

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

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

[ "void FUNC_0(AVFormatContext *VAR_0)\n{", "int VAR_1;", "if (!VAR_0)\nreturn;", "av_opt_free(VAR_0);", "if (VAR_0->iformat && VAR_0->iformat->priv_class && VAR_0->priv_data)\nav_opt_free(VAR_0->priv_data);", "if (VAR_0->oformat && VAR_0->oformat->priv_class && VAR_0->priv_data)\nav_opt_free(VAR_0->priv_data);", "for (VAR_1 = VAR_0->nb_streams - 1; VAR_1 >= 0; VAR_1--) {", "ff_free_stream(VAR_0, VAR_0->streams[VAR_1]);", "}", "for (VAR_1 = VAR_0->nb_programs - 1; VAR_1 >= 0; VAR_1--) {", "av_dict_free(&VAR_0->programs[VAR_1]->metadata);", "av_freep(&VAR_0->programs[VAR_1]->stream_index);", "av_freep(&VAR_0->programs[VAR_1]);", "}", "av_freep(&VAR_0->programs);", "av_freep(&VAR_0->priv_data);", "while (VAR_0->nb_chapters--) {", "av_dict_free(&VAR_0->chapters[VAR_0->nb_chapters]->metadata);", "av_freep(&VAR_0->chapters[VAR_0->nb_chapters]);", "}", "av_freep(&VAR_0->chapters);", "av_dict_free(&VAR_0->metadata);", "av_freep(&VAR_0->streams);", "av_freep(&VAR_0->internal);", "av_free(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 ]

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

[ "static void FUNC_0(IPMIBmcSim *VAR_0,\nuint8_t *VAR_1, unsigned int VAR_2,\nuint8_t *VAR_3, unsigned int *VAR_4,\nunsigned int VAR_5)\n{", "unsigned int VAR_6;", "uint16_t nextrec;", "struct ipmi_sdr_header *VAR_7;", "IPMI_CHECK_CMD_LEN(8);", "if (VAR_1[6]) {", "IPMI_CHECK_RESERVATION(2, VAR_0->sdr.reservation);", "}", "VAR_6 = 0;", "if (sdr_find_entry(&VAR_0->sdr, VAR_1[4] | (VAR_1[5] << 8),\n&VAR_6, &nextrec)) {", "VAR_3[2] = IPMI_CC_REQ_ENTRY_NOT_PRESENT;", "return;", "}", "VAR_7 = (struct ipmi_sdr_header *) &VAR_0->sdr.sdr[VAR_6];", "if (VAR_1[6] > ipmi_sdr_length(VAR_7)) {", "VAR_3[2] = IPMI_CC_PARM_OUT_OF_RANGE;", "return;", "}", "IPMI_ADD_RSP_DATA(nextrec & 0xff);", "IPMI_ADD_RSP_DATA((nextrec >> 8) & 0xff);", "if (VAR_1[7] == 0xff) {", "VAR_1[7] = ipmi_sdr_length(VAR_7) - VAR_1[6];", "}", "if ((VAR_1[7] + *VAR_4) > VAR_5) {", "VAR_3[2] = IPMI_CC_CANNOT_RETURN_REQ_NUM_BYTES;", "return;", "}", "memcpy(VAR_3 + *VAR_4, VAR_0->sdr.sdr + VAR_6 + VAR_1[6], VAR_1[7]);", "*VAR_4 += VAR_1[7];", "}" ]

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

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

[ "static float FUNC_0(struct AACEncContext *VAR_0,\nPutBitContext *VAR_1, const float *VAR_2,\nconst float *VAR_3, int VAR_4, int VAR_5,\nint VAR_6, const float VAR_7, const float VAR_8,\nint *VAR_9)\n{", "av_assert0(0);", "return 0;", "}" ]

[ 1, 0, 0, 0 ]

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

[ "static int FUNC_0(MemoryRegionSection *VAR_0)\n{", "KVMState *s = kvm_state;", "unsigned long VAR_1, VAR_2 = 0;", "KVMDirtyLog d;", "KVMSlot *mem;", "int VAR_3 = 0;", "hwaddr start_addr = VAR_0->offset_within_address_space;", "hwaddr end_addr = start_addr + int128_get64(VAR_0->VAR_1);", "d.dirty_bitmap = NULL;", "while (start_addr < end_addr) {", "mem = kvm_lookup_overlapping_slot(s, start_addr, end_addr);", "if (mem == NULL) {", "break;", "}", "VAR_1 = ALIGN(((mem->memory_size) >> TARGET_PAGE_BITS),\n64) / 8;", "if (!d.dirty_bitmap) {", "d.dirty_bitmap = g_malloc(VAR_1);", "} else if (VAR_1 > VAR_2) {", "d.dirty_bitmap = g_realloc(d.dirty_bitmap, VAR_1);", "}", "VAR_2 = VAR_1;", "memset(d.dirty_bitmap, 0, VAR_2);", "d.slot = mem->slot;", "if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {", "DPRINTF(\"ioctl failed %d\\n\", errno);", "VAR_3 = -1;", "break;", "}", "kvm_get_dirty_pages_log_range(VAR_0, d.dirty_bitmap);", "start_addr = mem->start_addr + mem->memory_size;", "}", "g_free(d.dirty_bitmap);", "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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ] ]

[ "av_cold void FUNC_0(H264PredContext *h, int codec_id,\nconst int bit_depth,\nconst int chroma_format_idc)\n{", "#undef FUNC\n#undef FUNCC\n#define FUNC(a, depth) a ## _ ## depth\n#define FUNCC(a, depth) a ## _ ## depth ## _c\n#define FUNCD(a) a ## _c\n#define H264_PRED(depth) \\\nif(codec_id != AV_CODEC_ID_RV40){\\", "if(codec_id == AV_CODEC_ID_VP8) {\\", "h->pred4x4[VERT_PRED ]= FUNCD(pred4x4_vertical_vp8);\\", "h->pred4x4[HOR_PRED ]= FUNCD(pred4x4_horizontal_vp8);\\", "} else {\\", "h->pred4x4[VERT_PRED ]= FUNCC(pred4x4_vertical , depth);\\", "h->pred4x4[HOR_PRED ]= FUNCC(pred4x4_horizontal , depth);\\", "}\\", "h->pred4x4[DC_PRED ]= FUNCC(pred4x4_dc , depth);\\", "if(codec_id == AV_CODEC_ID_SVQ3)\\\nh->pred4x4[DIAG_DOWN_LEFT_PRED ]= FUNCD(pred4x4_down_left_svq3);\\", "else\\\nh->pred4x4[DIAG_DOWN_LEFT_PRED ]= FUNCC(pred4x4_down_left , depth);\\", "h->pred4x4[DIAG_DOWN_RIGHT_PRED]= FUNCC(pred4x4_down_right , depth);\\", "h->pred4x4[VERT_RIGHT_PRED ]= FUNCC(pred4x4_vertical_right , depth);\\", "h->pred4x4[HOR_DOWN_PRED ]= FUNCC(pred4x4_horizontal_down , depth);\\", "if (codec_id == AV_CODEC_ID_VP8) {\\", "h->pred4x4[VERT_LEFT_PRED ]= FUNCD(pred4x4_vertical_left_vp8);\\", "} else\\", "h->pred4x4[VERT_LEFT_PRED ]= FUNCC(pred4x4_vertical_left , depth);\\", "h->pred4x4[HOR_UP_PRED ]= FUNCC(pred4x4_horizontal_up , depth);\\", "if(codec_id != AV_CODEC_ID_VP8) {\\", "h->pred4x4[LEFT_DC_PRED ]= FUNCC(pred4x4_left_dc , depth);\\", "h->pred4x4[TOP_DC_PRED ]= FUNCC(pred4x4_top_dc , depth);\\", "h->pred4x4[DC_128_PRED ]= FUNCC(pred4x4_128_dc , depth);\\", "} else {\\", "h->pred4x4[TM_VP8_PRED ]= FUNCD(pred4x4_tm_vp8);\\", "h->pred4x4[DC_127_PRED ]= FUNCC(pred4x4_127_dc , depth);\\", "h->pred4x4[DC_129_PRED ]= FUNCC(pred4x4_129_dc , depth);\\", "h->pred4x4[VERT_VP8_PRED ]= FUNCC(pred4x4_vertical , depth);\\", "h->pred4x4[HOR_VP8_PRED ]= FUNCC(pred4x4_horizontal , depth);\\", "}\\", "}else{\\", "h->pred4x4[VERT_PRED ]= FUNCC(pred4x4_vertical , depth);\\", "h->pred4x4[HOR_PRED ]= FUNCC(pred4x4_horizontal , depth);\\", "h->pred4x4[DC_PRED ]= FUNCC(pred4x4_dc , depth);\\", "h->pred4x4[DIAG_DOWN_LEFT_PRED ]= FUNCD(pred4x4_down_left_rv40);\\", "h->pred4x4[DIAG_DOWN_RIGHT_PRED]= FUNCC(pred4x4_down_right , depth);\\", "h->pred4x4[VERT_RIGHT_PRED ]= FUNCC(pred4x4_vertical_right , depth);\\", "h->pred4x4[HOR_DOWN_PRED ]= FUNCC(pred4x4_horizontal_down , depth);\\", "h->pred4x4[VERT_LEFT_PRED ]= FUNCD(pred4x4_vertical_left_rv40);\\", "h->pred4x4[HOR_UP_PRED ]= FUNCD(pred4x4_horizontal_up_rv40);\\", "h->pred4x4[LEFT_DC_PRED ]= FUNCC(pred4x4_left_dc , depth);\\", "h->pred4x4[TOP_DC_PRED ]= FUNCC(pred4x4_top_dc , depth);\\", "h->pred4x4[DC_128_PRED ]= FUNCC(pred4x4_128_dc , depth);\\", "h->pred4x4[DIAG_DOWN_LEFT_PRED_RV40_NODOWN]= FUNCD(pred4x4_down_left_rv40_nodown);\\", "h->pred4x4[HOR_UP_PRED_RV40_NODOWN]= FUNCD(pred4x4_horizontal_up_rv40_nodown);\\", "h->pred4x4[VERT_LEFT_PRED_RV40_NODOWN]= FUNCD(pred4x4_vertical_left_rv40_nodown);\\", "}\\", "\\\nh->pred8x8l[VERT_PRED ]= FUNCC(pred8x8l_vertical , depth);\\", "h->pred8x8l[HOR_PRED ]= FUNCC(pred8x8l_horizontal , depth);\\", "h->pred8x8l[DC_PRED ]= FUNCC(pred8x8l_dc , depth);\\", "h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= FUNCC(pred8x8l_down_left , depth);\\", "h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= FUNCC(pred8x8l_down_right , depth);\\", "h->pred8x8l[VERT_RIGHT_PRED ]= FUNCC(pred8x8l_vertical_right , depth);\\", "h->pred8x8l[HOR_DOWN_PRED ]= FUNCC(pred8x8l_horizontal_down , depth);\\", "h->pred8x8l[VERT_LEFT_PRED ]= FUNCC(pred8x8l_vertical_left , depth);\\", "h->pred8x8l[HOR_UP_PRED ]= FUNCC(pred8x8l_horizontal_up , depth);\\", "h->pred8x8l[LEFT_DC_PRED ]= FUNCC(pred8x8l_left_dc , depth);\\", "h->pred8x8l[TOP_DC_PRED ]= FUNCC(pred8x8l_top_dc , depth);\\", "h->pred8x8l[DC_128_PRED ]= FUNCC(pred8x8l_128_dc , depth);\\", "\\\nif (chroma_format_idc <= 1) {\\", "h->pred8x8[VERT_PRED8x8 ]= FUNCC(pred8x8_vertical , depth);\\", "h->pred8x8[HOR_PRED8x8 ]= FUNCC(pred8x8_horizontal , depth);\\", "} else {\\", "h->pred8x8[VERT_PRED8x8 ]= FUNCC(pred8x16_vertical , depth);\\", "h->pred8x8[HOR_PRED8x8 ]= FUNCC(pred8x16_horizontal , depth);\\", "}\\", "if (codec_id != AV_CODEC_ID_VP8) {\\", "if (chroma_format_idc <= 1) {\\", "h->pred8x8[PLANE_PRED8x8]= FUNCC(pred8x8_plane , depth);\\", "} else {\\", "h->pred8x8[PLANE_PRED8x8]= FUNCC(pred8x16_plane , depth);\\", "}\\", "} else\\", "h->pred8x8[PLANE_PRED8x8]= FUNCD(pred8x8_tm_vp8);\\", "if(codec_id != AV_CODEC_ID_RV40 && codec_id != AV_CODEC_ID_VP8){\\", "if (chroma_format_idc <= 1) {\\", "h->pred8x8[DC_PRED8x8 ]= FUNCC(pred8x8_dc , depth);\\", "h->pred8x8[LEFT_DC_PRED8x8]= FUNCC(pred8x8_left_dc , depth);\\", "h->pred8x8[TOP_DC_PRED8x8 ]= FUNCC(pred8x8_top_dc , depth);\\", "h->pred8x8[ALZHEIMER_DC_L0T_PRED8x8 ]= FUNC(pred8x8_mad_cow_dc_l0t, depth);\\", "h->pred8x8[ALZHEIMER_DC_0LT_PRED8x8 ]= FUNC(pred8x8_mad_cow_dc_0lt, depth);\\", "h->pred8x8[ALZHEIMER_DC_L00_PRED8x8 ]= FUNC(pred8x8_mad_cow_dc_l00, depth);\\", "h->pred8x8[ALZHEIMER_DC_0L0_PRED8x8 ]= FUNC(pred8x8_mad_cow_dc_0l0, depth);\\", "} else {\\", "h->pred8x8[DC_PRED8x8 ]= FUNCC(pred8x16_dc , depth);\\", "h->pred8x8[LEFT_DC_PRED8x8]= FUNCC(pred8x16_left_dc , depth);\\", "h->pred8x8[TOP_DC_PRED8x8 ]= FUNCC(pred8x16_top_dc , depth);\\", "h->pred8x8[ALZHEIMER_DC_L0T_PRED8x8 ]= FUNC(pred8x16_mad_cow_dc_l0t, depth);\\", "h->pred8x8[ALZHEIMER_DC_0LT_PRED8x8 ]= FUNC(pred8x16_mad_cow_dc_0lt, depth);\\", "h->pred8x8[ALZHEIMER_DC_L00_PRED8x8 ]= FUNC(pred8x16_mad_cow_dc_l00, depth);\\", "h->pred8x8[ALZHEIMER_DC_0L0_PRED8x8 ]= FUNC(pred8x16_mad_cow_dc_0l0, depth);\\", "}\\", "}else{\\", "h->pred8x8[DC_PRED8x8 ]= FUNCD(pred8x8_dc_rv40);\\", "h->pred8x8[LEFT_DC_PRED8x8]= FUNCD(pred8x8_left_dc_rv40);\\", "h->pred8x8[TOP_DC_PRED8x8 ]= FUNCD(pred8x8_top_dc_rv40);\\", "if (codec_id == AV_CODEC_ID_VP8) {\\", "h->pred8x8[DC_127_PRED8x8]= FUNCC(pred8x8_127_dc , depth);\\", "h->pred8x8[DC_129_PRED8x8]= FUNCC(pred8x8_129_dc , depth);\\", "}\\", "}\\", "if (chroma_format_idc <= 1) {\\", "h->pred8x8[DC_128_PRED8x8 ]= FUNCC(pred8x8_128_dc , depth);\\", "} else {\\", "h->pred8x8[DC_128_PRED8x8 ]= FUNCC(pred8x16_128_dc , depth);\\", "}\\", "\\\nh->pred16x16[DC_PRED8x8 ]= FUNCC(pred16x16_dc , depth);\\", "h->pred16x16[VERT_PRED8x8 ]= FUNCC(pred16x16_vertical , depth);\\", "h->pred16x16[HOR_PRED8x8 ]= FUNCC(pred16x16_horizontal , depth);\\", "switch(codec_id){\\", "case AV_CODEC_ID_SVQ3:\\\nh->pred16x16[PLANE_PRED8x8 ]= FUNCD(pred16x16_plane_svq3);\\", "break;\\", "case AV_CODEC_ID_RV40:\\\nh->pred16x16[PLANE_PRED8x8 ]= FUNCD(pred16x16_plane_rv40);\\", "break;\\", "case AV_CODEC_ID_VP8:\\\nh->pred16x16[PLANE_PRED8x8 ]= FUNCD(pred16x16_tm_vp8);\\", "h->pred16x16[DC_127_PRED8x8]= FUNCC(pred16x16_127_dc , depth);\\", "h->pred16x16[DC_129_PRED8x8]= FUNCC(pred16x16_129_dc , depth);\\", "break;\\", "default:\\\nh->pred16x16[PLANE_PRED8x8 ]= FUNCC(pred16x16_plane , depth);\\", "break;\\", "}\\", "h->pred16x16[LEFT_DC_PRED8x8]= FUNCC(pred16x16_left_dc , depth);\\", "h->pred16x16[TOP_DC_PRED8x8 ]= FUNCC(pred16x16_top_dc , depth);\\", "h->pred16x16[DC_128_PRED8x8 ]= FUNCC(pred16x16_128_dc , depth);\\", "\\\n\\\nh->pred4x4_add [VERT_PRED ]= FUNCC(pred4x4_vertical_add , depth);\\", "h->pred4x4_add [ HOR_PRED ]= FUNCC(pred4x4_horizontal_add , depth);\\", "h->pred8x8l_add [VERT_PRED ]= FUNCC(pred8x8l_vertical_add , depth);\\", "h->pred8x8l_add [ HOR_PRED ]= FUNCC(pred8x8l_horizontal_add , depth);\\", "if (chroma_format_idc <= 1) {\\", "h->pred8x8_add [VERT_PRED8x8]= FUNCC(pred8x8_vertical_add , depth);\\", "h->pred8x8_add [ HOR_PRED8x8]= FUNCC(pred8x8_horizontal_add , depth);\\", "} else {\\", "h->pred8x8_add [VERT_PRED8x8]= FUNCC(pred8x16_vertical_add , depth);\\", "h->pred8x8_add [ HOR_PRED8x8]= FUNCC(pred8x16_horizontal_add , depth);\\", "}\\", "h->pred16x16_add[VERT_PRED8x8]= FUNCC(pred16x16_vertical_add , depth);\\", "h->pred16x16_add[ HOR_PRED8x8]= FUNCC(pred16x16_horizontal_add , depth);\\", "switch (bit_depth) {", "case 9:\nH264_PRED(9)\nbreak;", "case 10:\nH264_PRED(10)\nbreak;", "default:\nH264_PRED(8)\nbreak;", "}", "if (ARCH_ARM) ff_h264_pred_init_arm(h, codec_id, bit_depth, chroma_format_idc);", "if (ARCH_X86) ff_h264_pred_init_x86(h, codec_id, bit_depth, chroma_format_idc);", "}" ]

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

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

[ "FUNC_0(int VAR_0)\n{", "received_sigterm = VAR_0;", "received_nb_signals++;", "term_exit_sigsafe();", "if(received_nb_signals > 3)\nexit_program(123);", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "QVirtioPCIDevice *dev;", "QPCIBus *bus;", "QVirtQueuePCI *vqpci;", "QGuestAllocator *alloc;", "QVirtioBlkReq req;", "void *VAR_0;", "uint64_t req_addr;", "uint64_t capacity;", "uint32_t features;", "uint32_t free_head;", "uint8_t status;", "char *VAR_1;", "bus = pci_test_start();", "alloc = pc_alloc_init();", "dev = virtio_blk_pci_init(bus, PCI_SLOT);", "qpci_msix_enable(dev->pdev);", "qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);", "VAR_0 = dev->VAR_0 + VIRTIO_PCI_CONFIG_OFF(true);", "capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev,\n(uint64_t)(uintptr_t)VAR_0);", "g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);", "features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);", "features = features & ~(QVIRTIO_F_BAD_FEATURE |\n(1u << VIRTIO_RING_F_INDIRECT_DESC) |\n(1u << VIRTIO_F_NOTIFY_ON_EMPTY) |\n(1u << VIRTIO_BLK_F_SCSI));", "qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);", "vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,\nalloc, 0);", "qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);", "qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);", "req.type = VIRTIO_BLK_T_OUT;", "req.ioprio = 1;", "req.sector = 0;", "req.VAR_1 = g_malloc0(512);", "strcpy(req.VAR_1, \"TEST\");", "req_addr = virtio_blk_request(alloc, &req, 512);", "g_free(req.VAR_1);", "free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);", "qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);", "qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);", "qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);", "qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,\nQVIRTIO_BLK_TIMEOUT_US);", "req.type = VIRTIO_BLK_T_OUT;", "req.ioprio = 1;", "req.sector = 1;", "req.VAR_1 = g_malloc0(512);", "strcpy(req.VAR_1, \"TEST\");", "req_addr = virtio_blk_request(alloc, &req, 512);", "g_free(req.VAR_1);", "qvirtqueue_set_used_event(&vqpci->vq, 2);", "free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);", "qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);", "qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);", "qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);", "status = qvirtio_wait_status_byte_no_isr(&qvirtio_pci, &dev->vdev,\n&vqpci->vq, req_addr + 528,\nQVIRTIO_BLK_TIMEOUT_US);", "g_assert_cmpint(status, ==, 0);", "guest_free(alloc, req_addr);", "req.type = VIRTIO_BLK_T_IN;", "req.ioprio = 1;", "req.sector = 1;", "req.VAR_1 = g_malloc0(512);", "req_addr = virtio_blk_request(alloc, &req, 512);", "g_free(req.VAR_1);", "free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);", "qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, true, true);", "qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);", "qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);", "qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,\nQVIRTIO_BLK_TIMEOUT_US);", "status = readb(req_addr + 528);", "g_assert_cmpint(status, ==, 0);", "VAR_1 = g_malloc0(512);", "memread(req_addr + 16, VAR_1, 512);", "g_assert_cmpstr(VAR_1, ==, \"TEST\");", "g_free(VAR_1);", "guest_free(alloc, req_addr);", "guest_free(alloc, vqpci->vq.desc);", "pc_alloc_uninit(alloc);", "qpci_msix_disable(dev->pdev);", "qvirtio_pci_device_disable(dev);", "g_free(dev);", "qpci_free_pc(bus);", "test_end();", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 43 ], [ 49 ], [ 53, 55 ], [ 57 ], [ 61 ], [ 63, 65, 67, 69 ], [ 71 ], [ 75, 77 ], [ 79 ], [ 83 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119, 121 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 143 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 163, 165, 167 ], [ 169 ], [ 173 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 193 ], [ 197 ], [ 199 ], [ 201 ], [ 205 ], [ 209, 211 ], [ 215 ], [ 217 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 231 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ] ]

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

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

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

[ "int FUNC_0(BlockDriverState *VAR_0)\n{", "if (VAR_0->drv->FUNC_0 == NULL) {", "return -ENOTSUP;", "}", "return VAR_0->drv->FUNC_0(VAR_0);", "}" ]

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

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

[ "static always_inline void FUNC_0(DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,\nint add_ca, int compute_ca, int compute_ov)\n{", "TCGv t0, t1;", "if ((!compute_ca && !compute_ov) ||\n(!TCGV_EQUAL(ret,arg1) && !TCGV_EQUAL(ret, arg2))) {", "t0 = ret;", "t0 = tcg_temp_local_new();", "}", "if (add_ca) {", "t1 = tcg_temp_local_new();", "tcg_gen_andi_tl(t1, cpu_xer, (1 << XER_CA));", "tcg_gen_shri_tl(t1, t1, XER_CA);", "}", "if (compute_ca && compute_ov) {", "tcg_gen_andi_tl(cpu_xer, cpu_xer, ~((1 << XER_CA) | (1 << XER_OV)));", "} else if (compute_ca) {", "tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_CA));", "} else if (compute_ov) {", "tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));", "}", "tcg_gen_add_tl(t0, arg1, arg2);", "if (compute_ca) {", "gen_op_arith_compute_ca(ctx, t0, arg1, 0);", "}", "if (add_ca) {", "tcg_gen_add_tl(t0, t0, t1);", "gen_op_arith_compute_ca(ctx, t0, t1, 0);", "tcg_temp_free(t1);", "}", "if (compute_ov) {", "gen_op_arith_compute_ov(ctx, t0, arg1, arg2, 0);", "}", "if (unlikely(Rc(ctx->opcode) != 0))\ngen_set_Rc0(ctx, t0);", "if (!TCGV_EQUAL(t0, ret)) {", "tcg_gen_mov_tl(ret, t0);", "tcg_temp_free(t0);", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11, 13 ], [ 15 ], [ 18 ], [ 20 ], [ 24 ], [ 26 ], [ 28 ], [ 30 ], [ 34 ], [ 38 ], [ 42 ], [ 44 ], [ 48 ], [ 50 ], [ 54 ], [ 56 ], [ 60 ], [ 64 ], [ 66 ], [ 68 ], [ 70 ], [ 72 ], [ 74 ], [ 76 ], [ 78 ], [ 80 ], [ 82 ], [ 84 ], [ 88, 90 ], [ 94 ], [ 96 ], [ 98 ], [ 100 ], [ 102 ] ]

[ "static void FUNC_0(gconstpointer VAR_0)\n{", "const TestData *VAR_1 = VAR_0;", "QPCIBus *bus;", "QPCIDevice *dev;", "int VAR_2;", "static struct {", "uint32_t start;", "uint32_t end;", "} VAR_3[] = {", "{ 0, 0 },", "{ 0xF0000, 0xFFFFF },", "{ 0xC0000, 0xC3FFF },", "{ 0xC4000, 0xC7FFF },", "{ 0xC8000, 0xCBFFF },", "{ 0xCC000, 0xCFFFF },", "{ 0xD0000, 0xD3FFF },", "{ 0xD4000, 0xD7FFF },", "{ 0xD8000, 0xDBFFF },", "{ 0xDC000, 0xDFFFF },", "{ 0xE0000, 0xE3FFF },", "{ 0xE4000, 0xE7FFF },", "{ 0xE8000, 0xEBFFF },", "{ 0xEC000, 0xEFFFF },", "};", "bus = test_start_get_bus(VAR_1);", "dev = qpci_device_find(bus, QPCI_DEVFN(0, 0));", "g_assert(dev != NULL);", "for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(VAR_3); VAR_2++) {", "if (VAR_3[VAR_2].start == VAR_3[VAR_2].end) {", "continue;", "}", "g_test_message(\"Checking area 0x%05x..0x%05x\",\nVAR_3[VAR_2].start, VAR_3[VAR_2].end);", "pam_set(dev, VAR_2, PAM_RE);", "g_assert(verify_area(VAR_3[VAR_2].start, VAR_3[VAR_2].end, 0));", "pam_set(dev, VAR_2, PAM_RE | PAM_WE);", "write_area(VAR_3[VAR_2].start, VAR_3[VAR_2].end, 0x42);", "#ifndef BROKEN\npam_set(dev, VAR_2, PAM_WE);", "g_assert(!verify_area(VAR_3[VAR_2].start, VAR_3[VAR_2].end, 0x42));", "#endif\ng_assert(verify_area(VAR_3[VAR_2].start, VAR_3[VAR_2].end, 0x42));", "write_area(VAR_3[VAR_2].start, VAR_3[VAR_2].end, 0x82);", "#ifndef BROKEN\ng_assert(!verify_area(VAR_3[VAR_2].start, VAR_3[VAR_2].end, 0x82));", "pam_set(dev, VAR_2, PAM_RE | PAM_WE);", "#endif\ng_assert(verify_area(VAR_3[VAR_2].start, VAR_3[VAR_2].end, 0x82));", "pam_set(dev, VAR_2, 0);", "g_assert(!verify_area(VAR_3[VAR_2].start, VAR_3[VAR_2].end, 0x82));", "}", "qtest_end();", "}" ]

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

[ [ 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 ], [ 36 ], [ 38 ], [ 40 ], [ 42 ], [ 43, 46 ], [ 48 ], [ 49, 51 ], [ 53 ], [ 54, 57 ], [ 59 ], [ 60, 62 ], [ 64 ], [ 66 ], [ 67 ], [ 68 ], [ 69 ] ]

[ "static uint64_t FUNC_0(BlockDriverState *bs,\nuint64_t offset,\nint n_start, int n_end,\nint *num)\n{", "BDRVQcowState *s = bs->opaque;", "int VAR_0, VAR_1;", "uint64_t l2_offset, *l2_table, cluster_offset;", "int VAR_2, VAR_3, VAR_4 = 0;", "uint64_t start_sect;", "VAR_1 = get_cluster_table(bs, offset, &l2_table, &l2_offset, &VAR_0);", "if (VAR_1 == 0)\nreturn 0;", "VAR_3 = size_to_clusters(s, n_end << 9);", "if (VAR_3 > s->l2_size - VAR_0)\nVAR_3 = s->l2_size - VAR_0;", "cluster_offset = be64_to_cpu(l2_table[VAR_0]);", "if (cluster_offset & QCOW_OFLAG_COPIED) {", "VAR_3 = count_contiguous_clusters(VAR_3, s->cluster_size,\n&l2_table[VAR_0], 0);", "VAR_2 = VAR_3 << (s->cluster_bits - 9);", "if (VAR_2 > n_end)\nVAR_2 = n_end;", "cluster_offset &= ~QCOW_OFLAG_COPIED;", "goto out;", "}", "if (cluster_offset & QCOW_OFLAG_COMPRESSED)\nVAR_3 = 1;", "while (VAR_4 < VAR_3) {", "int VAR_5;", "VAR_4 += count_contiguous_free_clusters(VAR_3 - VAR_4,\n&l2_table[VAR_0 + VAR_4]);", "cluster_offset = be64_to_cpu(l2_table[VAR_0 + VAR_4]);", "if ((cluster_offset & QCOW_OFLAG_COPIED) ||\n(cluster_offset & QCOW_OFLAG_COMPRESSED))\nbreak;", "VAR_5 = count_contiguous_clusters(VAR_3 - VAR_4, s->cluster_size,\n&l2_table[VAR_0 + VAR_4], 0);", "if (VAR_5)\nfree_any_clusters(bs, cluster_offset, VAR_5);", "VAR_4 += VAR_5;", "if(be64_to_cpu(l2_table[VAR_0 + VAR_4]))\nbreak;", "}", "VAR_3 = VAR_4;", "cluster_offset = alloc_clusters(bs, VAR_3 * s->cluster_size);", "VAR_2 = VAR_3 << (s->cluster_bits - 9);", "if (VAR_2 > n_end)\nVAR_2 = n_end;", "start_sect = (offset & ~(s->cluster_size - 1)) >> 9;", "if (n_start) {", "VAR_1 = copy_sectors(bs, start_sect, cluster_offset, 0, n_start);", "if (VAR_1 < 0)\nreturn 0;", "}", "if (VAR_2 & (s->cluster_sectors - 1)) {", "uint64_t end = VAR_2 & ~(uint64_t)(s->cluster_sectors - 1);", "VAR_1 = copy_sectors(bs, start_sect + end,\ncluster_offset + (end << 9),\nVAR_2 - end,\ns->cluster_sectors);", "if (VAR_1 < 0)\nreturn 0;", "}", "for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++)", "l2_table[VAR_0 + VAR_4] = cpu_to_be64((cluster_offset +\n(VAR_4 << s->cluster_bits)) |\nQCOW_OFLAG_COPIED);", "if (bdrv_pwrite(s->hd,\nl2_offset + VAR_0 * sizeof(uint64_t),\nl2_table + VAR_0,\nVAR_3 * sizeof(uint64_t)) !=\nVAR_3 * sizeof(uint64_t))\nreturn 0;", "out:\n*num = VAR_2 - n_start;", "return cluster_offset;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25, 27 ], [ 31 ], [ 35, 37 ], [ 41 ], [ 49 ], [ 51, 53 ], [ 57 ], [ 59, 61 ], [ 65 ], [ 69 ], [ 71 ], [ 79, 81 ], [ 89 ], [ 91 ], [ 93, 95 ], [ 99 ], [ 103, 105, 107 ], [ 111, 113 ], [ 117, 119 ], [ 123 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 141 ], [ 151 ], [ 153, 155 ], [ 163 ], [ 165 ], [ 167 ], [ 169, 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181, 183, 185, 187 ], [ 189, 191 ], [ 193 ], [ 201 ], [ 203, 205, 207 ], [ 211, 213, 215, 217, 219, 221 ], [ 225, 227 ], [ 231 ], [ 233 ] ]

[ "void FUNC_0(BlockDriverState *VAR_0)\n{", "assert(!VAR_0->io_limits_enabled);", "throttle_init(&VAR_0->throttle_state,\nbdrv_get_aio_context(VAR_0),\nQEMU_CLOCK_VIRTUAL,\nbdrv_throttle_read_timer_cb,\nbdrv_throttle_write_timer_cb,\nVAR_0);", "VAR_0->io_limits_enabled = true;", "}" ]

[ 0, 0, 1, 0, 0 ]

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{", "TTAContext *c = VAR_0->priv_data;", "AVStream *st = VAR_0->streams[0];", "int VAR_2, VAR_3;", "if (c->currentframe > c->totalframes)\nreturn -1;", "VAR_2 = st->index_entries[c->currentframe].VAR_2;", "VAR_3 = av_get_packet(VAR_0->pb, VAR_1, VAR_2);", "VAR_1->dts = st->index_entries[c->currentframe++].timestamp;", "return VAR_3;", "}" ]

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

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

[ "static void FUNC_0(VideoState *VAR_0, int64_t VAR_1, int VAR_2)\n{", "VAR_0->seek_pos = VAR_1;", "VAR_0->seek_req = 1;", "VAR_0->seek_flags = VAR_2 < 0 ? AVSEEK_FLAG_BACKWARD : 0;", "}" ]

[ 0, 1, 1, 1, 0 ]

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

[ "void FUNC_0(QEMUFile *VAR_0, uint64_t VAR_1)\n{", "int VAR_2 = 0;", "if (VAR_0->ops->before_ram_iterate) {", "VAR_2 = VAR_0->ops->before_ram_iterate(VAR_0, VAR_0->opaque, VAR_1);", "if (VAR_2 < 0) {", "qemu_file_set_error(VAR_0, VAR_2);", "}", "}", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0)\n{", "sPAPRTCETable *tcet = SPAPR_TCE_TABLE(VAR_0);", "size_t table_size = tcet->nb_table * sizeof(uint64_t);", "memset(tcet->table, 0, table_size);", "}" ]

[ 0, 0, 0, 1, 0 ]

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

[ "static int FUNC_0(MJpegDecodeContext *VAR_0)\n{", "int VAR_1, VAR_2, VAR_3;", "VAR_1 = get_bits(&VAR_0->gb, 16);", "if (VAR_1 < 5)\nreturn AVERROR_INVALIDDATA;", "if (8 * VAR_1 > get_bits_left(&VAR_0->gb))\nreturn AVERROR_INVALIDDATA;", "VAR_2 = get_bits_long(&VAR_0->gb, 32);", "VAR_2 = av_be2ne32(VAR_2);", "VAR_1 -= 6;", "if (VAR_0->avctx->debug & FF_DEBUG_STARTCODE)\nav_log(VAR_0->avctx, AV_LOG_DEBUG, \"APPx %8X\\n\", VAR_2);", "if (VAR_2 == AV_RL32(\"AVI1\")) {", "VAR_0->buggy_avid = 1;", "VAR_3 = get_bits(&VAR_0->gb, 8); VAR_1--;", "av_log(VAR_0->avctx, AV_LOG_DEBUG, \"polarity %d\\n\", VAR_3);", "#if 0\nskip_bits(&VAR_0->gb, 8);", "skip_bits(&VAR_0->gb, 32);", "skip_bits(&VAR_0->gb, 32);", "VAR_1 -= 10;", "#endif\ngoto out;", "}", "if (VAR_2 == AV_RL32(\"JFIF\")) {", "int VAR_4, VAR_5, VAR_6, VAR_7;", "skip_bits(&VAR_0->gb, 8);", "VAR_6 = get_bits(&VAR_0->gb, 8);", "VAR_7 = get_bits(&VAR_0->gb, 8);", "skip_bits(&VAR_0->gb, 8);", "VAR_0->avctx->sample_aspect_ratio.num = get_bits(&VAR_0->gb, 16);", "VAR_0->avctx->sample_aspect_ratio.den = get_bits(&VAR_0->gb, 16);", "if (VAR_0->avctx->debug & FF_DEBUG_PICT_INFO)\nav_log(VAR_0->avctx, AV_LOG_INFO,\n\"mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\\n\",\nVAR_6, VAR_7,\nVAR_0->avctx->sample_aspect_ratio.num,\nVAR_0->avctx->sample_aspect_ratio.den);", "VAR_4 = get_bits(&VAR_0->gb, 8);", "VAR_5 = get_bits(&VAR_0->gb, 8);", "if (VAR_4 && VAR_5) {", "if (VAR_1 -10 - (VAR_4 * VAR_5 * 3) > 0)\nVAR_1 -= VAR_4 * VAR_5 * 3;", "}", "VAR_1 -= 10;", "goto out;", "}", "if (VAR_2 == AV_RL32(\"Adob\") && (get_bits(&VAR_0->gb, 8) == 'e')) {", "if (VAR_0->avctx->debug & FF_DEBUG_PICT_INFO)\nav_log(VAR_0->avctx, AV_LOG_INFO, \"mjpeg: Adobe header found\\n\");", "skip_bits(&VAR_0->gb, 16);", "skip_bits(&VAR_0->gb, 16);", "skip_bits(&VAR_0->gb, 16);", "skip_bits(&VAR_0->gb, 8);", "VAR_1 -= 7;", "goto out;", "}", "if (VAR_2 == AV_RL32(\"LJIF\")) {", "if (VAR_0->avctx->debug & FF_DEBUG_PICT_INFO)\nav_log(VAR_0->avctx, AV_LOG_INFO,\n\"Pegasus lossless jpeg header found\\n\");", "skip_bits(&VAR_0->gb, 16);", "skip_bits(&VAR_0->gb, 16);", "skip_bits(&VAR_0->gb, 16);", "skip_bits(&VAR_0->gb, 16);", "switch (get_bits(&VAR_0->gb, 8)) {", "case 1:\nVAR_0->rgb = 1;", "VAR_0->pegasus_rct = 0;", "break;", "case 2:\nVAR_0->rgb = 1;", "VAR_0->pegasus_rct = 1;", "break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"unknown colorspace\\n\");", "}", "VAR_1 -= 9;", "goto out;", "}", "if ((VAR_0->start_code == APP1) && (VAR_1 > (0x28 - 8))) {", "VAR_2 = get_bits_long(&VAR_0->gb, 32);", "VAR_2 = av_be2ne32(VAR_2);", "VAR_1 -= 4;", "if (VAR_2 == AV_RL32(\"mjpg\")) {", "#if 0\nskip_bits(&VAR_0->gb, 32);", "skip_bits(&VAR_0->gb, 32);", "skip_bits(&VAR_0->gb, 32);", "skip_bits(&VAR_0->gb, 32);", "skip_bits(&VAR_0->gb, 32);", "skip_bits(&VAR_0->gb, 32);", "skip_bits(&VAR_0->gb, 32);", "skip_bits(&VAR_0->gb, 32);", "#endif\nif (VAR_0->avctx->debug & FF_DEBUG_PICT_INFO)\nav_log(VAR_0->avctx, AV_LOG_INFO, \"mjpeg: Apple MJPEG-A header found\\n\");", "}", "}", "out:\nif (VAR_1 < 0)\nav_log(VAR_0->avctx, AV_LOG_ERROR,\n\"mjpeg: error, decode_app parser read over the end\\n\");", "while (--VAR_1 > 0)\nskip_bits(&VAR_0->gb, 8);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11, 13 ], [ 15, 17 ], [ 21 ], [ 23 ], [ 25 ], [ 29, 31 ], [ 41 ], [ 57 ], [ 59 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 105, 107, 109, 111, 113, 115 ], [ 119 ], [ 121 ], [ 123 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141 ], [ 143, 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 165, 167, 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181, 183 ], [ 185 ], [ 187 ], [ 189, 191 ], [ 193 ], [ 195 ], [ 197, 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225, 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243, 245, 247 ], [ 249 ], [ 251 ], [ 255, 259, 261, 263 ], [ 265, 267 ], [ 271 ], [ 273 ] ]

[ "static int FUNC_0(AVFilterContext *VAR_0, AVFilterBufferRef *VAR_1,\nint VAR_2, int VAR_3)\n{", "DrawTextContext *dtext = VAR_0->priv;", "uint32_t code = 0, prev_code = 0;", "int VAR_4 = 0, VAR_5 = 0, VAR_6 = 0, VAR_7;", "int VAR_8;", "char *VAR_9 = dtext->VAR_9;", "uint8_t *p;", "int VAR_10 = 0, VAR_11;", "int VAR_12 = 32000, VAR_13 = -32000;", "FT_Vector delta;", "Glyph *glyph = NULL, *prev_glyph = NULL;", "Glyph dummy = { 0 };", "time_t now = time(0);", "struct tm VAR_14;", "uint8_t *buf = dtext->expanded_text;", "int VAR_15 = dtext->expanded_text_size;", "if(dtext->basetime != AV_NOPTS_VALUE)\nnow= VAR_1->pts*av_q2d(VAR_0->inputs[0]->time_base) + dtext->basetime/1000000;", "if (!buf) {", "VAR_15 = 2*strlen(dtext->VAR_9)+1;", "buf = av_malloc(VAR_15);", "}", "#if HAVE_LOCALTIME_R\nlocaltime_r(&now, &VAR_14);", "#else\nif(strchr(dtext->VAR_9, '%'))\nVAR_14= *localtime(&now);", "#endif\ndo {", "*buf = 1;", "if (strftime(buf, VAR_15, dtext->VAR_9, &VAR_14) != 0 || *buf == 0)\nbreak;", "VAR_15 *= 2;", "} while ((buf = av_realloc(buf, VAR_15)));", "if (!buf)\nreturn AVERROR(ENOMEM);", "VAR_9 = dtext->expanded_text = buf;", "dtext->expanded_text_size = VAR_15;", "if ((VAR_11 = strlen(VAR_9)) > dtext->nb_positions) {", "if (!(dtext->positions =\nav_realloc(dtext->positions, VAR_11*sizeof(*dtext->positions))))\nreturn AVERROR(ENOMEM);", "dtext->nb_positions = VAR_11;", "}", "VAR_4 = dtext->VAR_4;", "VAR_5 = dtext->VAR_5;", "for (VAR_6 = 0, p = VAR_9; *p; VAR_6++) {", "GET_UTF8(code, *p++, continue;);", "dummy.code = code;", "glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);", "if (!glyph)\nload_glyph(VAR_0, &glyph, code);", "VAR_12 = FFMIN(glyph->bbox.yMin, VAR_12);", "VAR_13 = FFMAX(glyph->bbox.yMax, VAR_13);", "}", "VAR_8 = VAR_13 - VAR_12;", "glyph = NULL;", "for (VAR_6 = 0, p = VAR_9; *p; VAR_6++) {", "GET_UTF8(code, *p++, continue;);", "if (prev_code == '\\r' && code == '\\n')\ncontinue;", "prev_code = code;", "if (is_newline(code)) {", "VAR_10 = FFMAX(VAR_10, VAR_4 - dtext->VAR_4);", "VAR_5 += VAR_8;", "VAR_4 = dtext->VAR_4;", "continue;", "}", "prev_glyph = glyph;", "dummy.code = code;", "glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);", "if (dtext->use_kerning && prev_glyph && glyph->code) {", "FT_Get_Kerning(dtext->face, prev_glyph->code, glyph->code,\nft_kerning_default, &delta);", "VAR_4 += delta.VAR_4 >> 6;", "}", "if (VAR_4 + glyph->bbox.xMax >= VAR_2) {", "VAR_10 = FFMAX(VAR_10, VAR_4 - dtext->VAR_4);", "VAR_5 += VAR_8;", "VAR_4 = dtext->VAR_4;", "}", "dtext->positions[VAR_6].VAR_4 = VAR_4 + glyph->bitmap_left;", "dtext->positions[VAR_6].VAR_5 = VAR_5 - glyph->bitmap_top + VAR_13;", "if (code == '\\t') VAR_4 = (VAR_4 / dtext->tabsize + 1)*dtext->tabsize;", "else VAR_4 += glyph->advance;", "}", "VAR_10 = FFMIN(VAR_2 - dtext->VAR_4 - 1, FFMAX(VAR_10, VAR_4 - dtext->VAR_4));", "VAR_5 = FFMIN(VAR_5 + VAR_8, VAR_3 - 1);", "if (dtext->draw_box)\ndrawbox(VAR_1, dtext->VAR_4, dtext->VAR_5, VAR_10, VAR_5-dtext->VAR_5,\ndtext->box_line, dtext->pixel_step, dtext->boxcolor_rgba,\ndtext->hsub, dtext->vsub, dtext->is_packed_rgb, dtext->rgba_map);", "if (dtext->shadowx || dtext->shadowy) {", "if ((VAR_7 = draw_glyphs(dtext, VAR_1, VAR_2, VAR_3, dtext->shadowcolor_rgba,\ndtext->shadowcolor, dtext->shadowx, dtext->shadowy)) < 0)\nreturn VAR_7;", "}", "if ((VAR_7 = draw_glyphs(dtext, VAR_1, VAR_2, VAR_3, dtext->fontcolor_rgba,\ndtext->fontcolor, 0, 0)) < 0)\nreturn VAR_7;", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41, 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57, 59 ], [ 61, 63, 65 ], [ 67, 71 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 81 ], [ 85, 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97, 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 115 ], [ 117 ], [ 123 ], [ 125 ], [ 127, 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 145 ], [ 147 ], [ 149 ], [ 155, 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 179 ], [ 181 ], [ 183 ], [ 189 ], [ 191, 193 ], [ 195 ], [ 197 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 227 ], [ 229 ], [ 235, 237, 239, 241 ], [ 245 ], [ 247, 249, 251 ], [ 253 ], [ 257, 259, 261 ], [ 265 ], [ 267 ] ]

[ "void VAR_0 op_subfme_64 (void)\n{", "T0 = ~T0 + xer_ca - 1;", "if (likely((uint64_t)T0 != (uint64_t)-1))\nxer_ca = 1;", "RETURN();", "}" ]

[ 0, 0, 1, 1, 0 ]

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

[ "void FUNC_0(const char *VAR_0, int64_t VAR_1, int64_t VAR_2,\nint64_t VAR_3, int64_t VAR_4, int64_t VAR_5,\nint64_t VAR_6, Error **VAR_7)\n{", "ThrottleConfig cfg;", "BlockDriverState *bs;", "bs = bdrv_find(VAR_0);", "if (!bs) {", "error_set(VAR_7, QERR_DEVICE_NOT_FOUND, VAR_0);", "return;", "}", "memset(&cfg, 0, sizeof(cfg));", "cfg.buckets[THROTTLE_BPS_TOTAL].avg = VAR_1;", "cfg.buckets[THROTTLE_BPS_READ].avg = VAR_2;", "cfg.buckets[THROTTLE_BPS_WRITE].avg = VAR_3;", "cfg.buckets[THROTTLE_OPS_TOTAL].avg = VAR_4;", "cfg.buckets[THROTTLE_OPS_READ].avg = VAR_5;", "cfg.buckets[THROTTLE_OPS_WRITE].avg = VAR_6;", "cfg.buckets[THROTTLE_BPS_TOTAL].max = 0;", "cfg.buckets[THROTTLE_BPS_READ].max = 0;", "cfg.buckets[THROTTLE_BPS_WRITE].max = 0;", "cfg.buckets[THROTTLE_OPS_TOTAL].max = 0;", "cfg.buckets[THROTTLE_OPS_READ].max = 0;", "cfg.buckets[THROTTLE_OPS_WRITE].max = 0;", "cfg.op_size = 0;", "if (!check_throttle_config(&cfg, VAR_7)) {", "return;", "}", "if (!bs->io_limits_enabled && throttle_enabled(&cfg)) {", "bdrv_io_limits_enable(bs);", "} else if (bs->io_limits_enabled && !throttle_enabled(&cfg)) {", "bdrv_io_limits_disable(bs);", "}", "if (bs->io_limits_enabled) {", "bdrv_set_io_limits(bs, &cfg);", "}", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ] ]

[ "static inline void FUNC_0(uint8_t *VAR_0, ptrdiff_t VAR_1,\nconst uint8_t *VAR_2)\n{", "int VAR_3, VAR_4;", "uint32_t colors[4];", "uint16_t color0 = AV_RL16(VAR_2 + 8);", "uint16_t color1 = AV_RL16(VAR_2 + 10);", "uint32_t code = AV_RL32(VAR_2 + 12);", "extract_color(colors, color0, color1, 1, 0);", "for (VAR_4 = 0; VAR_4 < 4; VAR_4++) {", "const uint16_t VAR_5 = AV_RL16(VAR_2 + 2 * VAR_4);", "uint8_t alpha_values[4];", "alpha_values[0] = ((VAR_5 >> 0) & 0x0F) * 17;", "alpha_values[1] = ((VAR_5 >> 4) & 0x0F) * 17;", "alpha_values[2] = ((VAR_5 >> 8) & 0x0F) * 17;", "alpha_values[3] = ((VAR_5 >> 12) & 0x0F) * 17;", "for (VAR_3 = 0; VAR_3 < 4; VAR_3++) {", "uint8_t alpha = alpha_values[VAR_3];", "uint32_t pixel = colors[code & 3] | (alpha << 24);", "code >>= 2;", "AV_WL32(VAR_0 + VAR_3 * 4, pixel);", "}", "VAR_0 += VAR_1;", "}", "}" ]

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

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

[ "void FUNC_0(TCGContext *VAR_0)\n{", "tcg_pool_reset(VAR_0);", "VAR_0->nb_temps = VAR_0->nb_globals;", "memset(VAR_0->free_temps, 0, sizeof(VAR_0->free_temps));", "VAR_0->nb_labels = 0;", "VAR_0->current_frame_offset = VAR_0->frame_start;", "#ifdef CONFIG_DEBUG_TCG\nVAR_0->goto_tb_issue_mask = 0;", "#endif\nVAR_0->gen_op_buf[0].next = 1;", "VAR_0->gen_op_buf[0].prev = 0;", "VAR_0->gen_next_op_idx = 1;", "}" ]

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

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

[ "static int FUNC_0(MpegEncContext *VAR_0, int VAR_1)\n{", "int VAR_2;", "if (VAR_1) {", "for (VAR_2 = 0; VAR_2 < MAX_PICTURE_COUNT; VAR_2++) {", "if (VAR_0->picture[VAR_2].f.data[0] == NULL)\nreturn VAR_2;", "}", "} else {", "for (VAR_2 = 0; VAR_2 < MAX_PICTURE_COUNT; VAR_2++) {", "if (pic_is_unused(VAR_0, &VAR_0->picture[VAR_2]))\nreturn VAR_2;", "}", "}", "av_log(VAR_0->avctx, AV_LOG_FATAL,\n\"Internal error, picture buffer overflow\\n\");", "abort();", "return -1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13, 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 33, 35 ], [ 59 ], [ 61 ], [ 63 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,\nconst AVFrame *VAR_2, int *VAR_3)\n{", "int VAR_4, VAR_5, VAR_6, VAR_7 = !!VAR_1->data;", "struct xvid_context *VAR_8 = VAR_0->priv_data;", "AVFrame *p = VAR_0->coded_frame;", "int VAR_9 = (VAR_0->width + 15) / 16;", "int VAR_10 = (VAR_0->height + 15) / 16;", "char *VAR_11;", "xvid_enc_frame_t xvid_enc_frame = { 0 };", "xvid_enc_stats_t xvid_enc_stats = { 0 };", "if ((VAR_6 = ff_alloc_packet2(VAR_0, VAR_1, VAR_9*VAR_10*MAX_MB_BYTES + FF_MIN_BUFFER_SIZE)) < 0)\nreturn VAR_6;", "xvid_enc_frame.version = XVID_VERSION;", "xvid_enc_stats.version = XVID_VERSION;", "xvid_enc_frame.bitstream = VAR_1->data;", "xvid_enc_frame.length = VAR_1->size;", "if (VAR_0->pix_fmt != AV_PIX_FMT_YUV420P) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Xvid: Color spaces other than 420P not supported\\n\");", "return AVERROR(EINVAL);", "}", "xvid_enc_frame.input.csp = XVID_CSP_PLANAR;", "for (VAR_5 = 0; VAR_5 < 4; VAR_5++) {", "xvid_enc_frame.input.plane[VAR_5] = VAR_2->data[VAR_5];", "xvid_enc_frame.input.stride[VAR_5] = VAR_2->linesize[VAR_5];", "}", "xvid_enc_frame.vop_flags = VAR_8->vop_flags;", "xvid_enc_frame.vol_flags = VAR_8->vol_flags;", "xvid_enc_frame.motion = VAR_8->me_flags;", "xvid_enc_frame.type =\nVAR_2->pict_type == AV_PICTURE_TYPE_I ? XVID_TYPE_IVOP :\nVAR_2->pict_type == AV_PICTURE_TYPE_P ? XVID_TYPE_PVOP :\nVAR_2->pict_type == AV_PICTURE_TYPE_B ? XVID_TYPE_BVOP :\nXVID_TYPE_AUTO;", "if (VAR_0->sample_aspect_ratio.num < 0 || VAR_0->sample_aspect_ratio.num > 255 ||\nVAR_0->sample_aspect_ratio.den < 0 || VAR_0->sample_aspect_ratio.den > 255) {", "av_log(VAR_0, AV_LOG_WARNING,\n\"Invalid pixel aspect ratio %VAR_5/%VAR_5, limit is 255/255 reducing\\n\",\nVAR_0->sample_aspect_ratio.num, VAR_0->sample_aspect_ratio.den);", "av_reduce(&VAR_0->sample_aspect_ratio.num, &VAR_0->sample_aspect_ratio.den,\nVAR_0->sample_aspect_ratio.num, VAR_0->sample_aspect_ratio.den, 255);", "}", "xvid_enc_frame.par = XVID_PAR_EXT;", "xvid_enc_frame.par_width = VAR_0->sample_aspect_ratio.num;", "xvid_enc_frame.par_height = VAR_0->sample_aspect_ratio.den;", "if (VAR_8->qscale)\nxvid_enc_frame.quant = VAR_2->quality / FF_QP2LAMBDA;", "else\nxvid_enc_frame.quant = 0;", "xvid_enc_frame.quant_intra_matrix = VAR_8->intra_matrix;", "xvid_enc_frame.quant_inter_matrix = VAR_8->inter_matrix;", "VAR_4 = xvid_encore(VAR_8->encoder_handle, XVID_ENC_ENCODE,\n&xvid_enc_frame, &xvid_enc_stats);", "VAR_0->stats_out = NULL;", "if (VAR_8->twopassbuffer) {", "VAR_11 = VAR_8->old_twopassbuffer;", "VAR_8->old_twopassbuffer = VAR_8->twopassbuffer;", "VAR_8->twopassbuffer = VAR_11;", "VAR_8->twopassbuffer[0] = 0;", "if (VAR_8->old_twopassbuffer[0] != 0) {", "VAR_0->stats_out = VAR_8->old_twopassbuffer;", "}", "}", "if (VAR_4 > 0) {", "*VAR_3 = 1;", "p->quality = xvid_enc_stats.quant * FF_QP2LAMBDA;", "if (xvid_enc_stats.type == XVID_TYPE_PVOP)\np->pict_type = AV_PICTURE_TYPE_P;", "else if (xvid_enc_stats.type == XVID_TYPE_BVOP)\np->pict_type = AV_PICTURE_TYPE_B;", "else if (xvid_enc_stats.type == XVID_TYPE_SVOP)\np->pict_type = AV_PICTURE_TYPE_S;", "else\np->pict_type = AV_PICTURE_TYPE_I;", "if (xvid_enc_frame.out_flags & XVID_KEYFRAME) {", "p->key_frame = 1;", "VAR_1->flags |= AV_PKT_FLAG_KEY;", "if (VAR_8->quicktime_format)\nreturn xvid_strip_vol_header(VAR_0, VAR_1,\nxvid_enc_stats.hlength, VAR_4);", "} else", "p->key_frame = 0;", "VAR_1->size = VAR_4;", "return 0;", "} else {", "if (!VAR_7)\nav_free_packet(VAR_1);", "if (!VAR_4)\nreturn 0;", "av_log(VAR_0, AV_LOG_ERROR,\n\"Xvid: Encoding Error Occurred: %VAR_5\\n\", VAR_4);", "return AVERROR_EXTERNAL;", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 35 ], [ 37 ], [ 43 ], [ 45 ], [ 51 ], [ 53, 55 ], [ 57 ], [ 59 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 87, 89, 91, 93 ], [ 99, 101 ], [ 103, 105, 107 ], [ 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 125, 127 ], [ 129, 131 ], [ 137 ], [ 139 ], [ 145, 147 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 181 ], [ 183, 185 ], [ 187, 189 ], [ 191, 193 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205, 207, 209 ], [ 211 ], [ 213 ], [ 217 ], [ 221 ], [ 223 ], [ 225, 227 ], [ 229, 231 ], [ 233, 235 ], [ 237 ], [ 239 ], [ 241 ] ]

[ "static void FUNC_0 (fdctrl_t *VAR_0, uint32_t VAR_1)\n{", "fdrive_t *cur_drv;", "int VAR_2;", "if (!(VAR_0->dor & FD_DOR_nRESET)) {", "FLOPPY_DPRINTF(\"Floppy controller in RESET state !\\n\");", "return;", "}", "if (!(VAR_0->msr & FD_MSR_RQM) || (VAR_0->msr & FD_MSR_DIO)) {", "FLOPPY_ERROR(\"controller not ready for writing\\n\");", "return;", "}", "VAR_0->dsr &= ~FD_DSR_PWRDOWN;", "if (VAR_0->msr & FD_MSR_NONDMA) {", "VAR_0->fifo[VAR_0->data_pos++] = VAR_1;", "if (VAR_0->data_pos % FD_SECTOR_LEN == (FD_SECTOR_LEN - 1) ||\nVAR_0->data_pos == VAR_0->data_len) {", "cur_drv = get_cur_drv(VAR_0);", "if (bdrv_write(cur_drv->bs, fd_sector(cur_drv), VAR_0->fifo, 1) < 0) {", "FLOPPY_ERROR(\"writing sector %d\\n\", fd_sector(cur_drv));", "return;", "}", "if (!fdctrl_seek_to_next_sect(VAR_0, cur_drv)) {", "FLOPPY_DPRINTF(\"error seeking to next sector %d\\n\",\nfd_sector(cur_drv));", "return;", "}", "}", "if (VAR_0->data_pos == VAR_0->data_len)\nfdctrl_stop_transfer(VAR_0, FD_SR0_SEEK, 0x00, 0x00);", "return;", "}", "if (VAR_0->data_pos == 0) {", "VAR_2 = command_to_handler[VAR_1 & 0xff];", "FLOPPY_DPRINTF(\"%s command\\n\", handlers[VAR_2].name);", "VAR_0->data_len = handlers[VAR_2].parameters + 1;", "}", "FLOPPY_DPRINTF(\"%s: %02x\\n\", __func__, VAR_1);", "VAR_0->fifo[VAR_0->data_pos++] = VAR_1;", "if (VAR_0->data_pos == VAR_0->data_len) {", "if (VAR_0->data_state & FD_STATE_FORMAT) {", "fdctrl_format_sector(VAR_0);", "return;", "}", "VAR_2 = command_to_handler[VAR_0->fifo[0] & 0xff];", "FLOPPY_DPRINTF(\"treat %s command\\n\", handlers[VAR_2].name);", "(*handlers[VAR_2].handler)(VAR_0, handlers[VAR_2].direction);", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ] ]

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

[ 0, 0, 0 ]

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

[ "static int FUNC_0(BlockDriverState *VAR_0,\nuint64_t VAR_1,\nuint32_t VAR_2,\nuint32_t VAR_3,\nuint32_t VAR_4,\nbool VAR_5,\nVHDXImageType VAR_6,\nuint64_t *VAR_7)\n{", "int VAR_8 = 0;", "uint32_t offset = 0;", "void *VAR_9 = NULL;", "uint64_t bat_file_offset;", "uint32_t bat_length;", "BDRVVHDXState *s = NULL;", "VHDXRegionTableHeader *region_table;", "VHDXRegionTableEntry *rt_bat;", "VHDXRegionTableEntry *rt_metadata;", "assert(VAR_7 != NULL);", "s = g_malloc0(sizeof(BDRVVHDXState));", "s->chunk_ratio = (VHDX_MAX_SECTORS_PER_BLOCK) *\n(uint64_t) VAR_3 / (uint64_t) VAR_2;", "s->sectors_per_block = VAR_2 / VAR_3;", "s->virtual_disk_size = VAR_1;", "s->VAR_2 = VAR_2;", "s->logical_sector_size = VAR_3;", "vhdx_set_shift_bits(s);", "vhdx_calc_bat_entries(s);", "VAR_9 = g_malloc0(VHDX_HEADER_BLOCK_SIZE);", "region_table = VAR_9;", "offset += sizeof(VHDXRegionTableHeader);", "rt_bat = VAR_9 + offset;", "offset += sizeof(VHDXRegionTableEntry);", "rt_metadata = VAR_9 + offset;", "region_table->signature = VHDX_REGION_SIGNATURE;", "region_table->entry_count = 2;", "rt_bat->guid = bat_guid;", "rt_bat->length = ROUND_UP(s->bat_entries * sizeof(VHDXBatEntry), MiB);", "rt_bat->file_offset = ROUND_UP(VHDX_HEADER_SECTION_END + VAR_4, MiB);", "s->bat_offset = rt_bat->file_offset;", "rt_metadata->guid = metadata_guid;", "rt_metadata->file_offset = ROUND_UP(rt_bat->file_offset + rt_bat->length,\nMiB);", "rt_metadata->length = 1 * MiB;", "*VAR_7 = rt_metadata->file_offset;", "bat_file_offset = rt_bat->file_offset;", "bat_length = rt_bat->length;", "vhdx_region_header_le_export(region_table);", "vhdx_region_entry_le_export(rt_bat);", "vhdx_region_entry_le_export(rt_metadata);", "vhdx_update_checksum(VAR_9, VHDX_HEADER_BLOCK_SIZE,\noffsetof(VHDXRegionTableHeader, checksum));", "VAR_8 = vhdx_create_bat(VAR_0, s, VAR_1, VAR_6, VAR_5,\nbat_file_offset, bat_length);", "if (VAR_8 < 0) {", "goto exit;", "}", "VAR_8 = bdrv_pwrite(VAR_0, VHDX_REGION_TABLE_OFFSET, VAR_9,\nVHDX_HEADER_BLOCK_SIZE);", "if (VAR_8 < 0) {", "goto exit;", "}", "VAR_8 = bdrv_pwrite(VAR_0, VHDX_REGION_TABLE2_OFFSET, VAR_9,\nVHDX_HEADER_BLOCK_SIZE);", "if (VAR_8 < 0) {", "goto exit;", "}", "exit:\ng_free(s);", "g_free(VAR_9);", "return VAR_8;", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13, 15, 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 47 ], [ 51, 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 71 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 159 ], [ 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 185 ], [ 191, 193 ], [ 195 ], [ 197 ], [ 199 ] ]

[ "FUNC_0(struct iscsi_context *VAR_0, int VAR_1,\nvoid *VAR_2, void *VAR_3)\n{", "IscsiAIOCB *acb = VAR_3;", "if (acb->canceled != 0) {", "qemu_aio_release(acb);", "scsi_free_scsi_task(acb->task);", "acb->task = NULL;", "return;", "}", "acb->VAR_1 = 0;", "if (VAR_1 < 0) {", "error_report(\"Failed to unmap data on iSCSI lun. %s\",\niscsi_get_error(VAR_0));", "acb->VAR_1 = -EIO;", "}", "iscsi_schedule_bh(acb);", "scsi_free_scsi_task(acb->task);", "acb->task = NULL;", "}" ]

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

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

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

[ 1, 0 ]

[ [ 1, 3 ], [ 5 ] ]

[ "int FUNC_0(MpegEncContext *VAR_0, int VAR_1)\n{", "int VAR_2;", "int VAR_3, VAR_4;", "if (VAR_0->pict_type == AV_PICTURE_TYPE_I) {", "if (!(VAR_0->avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)) {", "if (VAR_0->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT)\nmpeg4_encode_visual_object_header(VAR_0);", "if (VAR_0->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || VAR_1 == 0)\nmpeg4_encode_vol_header(VAR_0, 0, 0);", "}", "if (!(VAR_0->workaround_bugs & FF_BUG_MS))\nmpeg4_encode_gop_header(VAR_0);", "}", "VAR_0->partitioned_frame = VAR_0->data_partitioning && VAR_0->pict_type != AV_PICTURE_TYPE_B;", "put_bits(&VAR_0->pb, 16, 0);", "put_bits(&VAR_0->pb, 16, VOP_STARTCODE);", "put_bits(&VAR_0->pb, 2, VAR_0->pict_type - 1);", "VAR_3 = FFUDIV(VAR_0->time, VAR_0->avctx->time_base.den);", "VAR_4 = FFUMOD(VAR_0->time, VAR_0->avctx->time_base.den);", "VAR_2 = VAR_3 - VAR_0->last_time_base;", "av_assert0(VAR_2 >= 0);", "if (VAR_2 > 3600) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_2 %d too large\\n\", VAR_2);", "return AVERROR(EINVAL);", "}", "while (VAR_2--)\nput_bits(&VAR_0->pb, 1, 1);", "put_bits(&VAR_0->pb, 1, 0);", "put_bits(&VAR_0->pb, 1, 1);", "put_bits(&VAR_0->pb, VAR_0->time_increment_bits, VAR_4);", "put_bits(&VAR_0->pb, 1, 1);", "put_bits(&VAR_0->pb, 1, 1);", "if (VAR_0->pict_type == AV_PICTURE_TYPE_P) {", "put_bits(&VAR_0->pb, 1, VAR_0->no_rounding);", "}", "put_bits(&VAR_0->pb, 3, 0);", "if (!VAR_0->progressive_sequence) {", "put_bits(&VAR_0->pb, 1, VAR_0->current_picture_ptr->f->top_field_first);", "put_bits(&VAR_0->pb, 1, VAR_0->alternate_scan);", "}", "put_bits(&VAR_0->pb, 5, VAR_0->qscale);", "if (VAR_0->pict_type != AV_PICTURE_TYPE_I)\nput_bits(&VAR_0->pb, 3, VAR_0->f_code);", "if (VAR_0->pict_type == AV_PICTURE_TYPE_B)\nput_bits(&VAR_0->pb, 3, VAR_0->b_code);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15, 17 ], [ 19, 21 ], [ 23 ], [ 25, 27 ], [ 29 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65, 67 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 103 ], [ 107, 109 ], [ 111, 113 ], [ 117 ], [ 119 ] ]

[ "static int FUNC_0(RangeCoder *VAR_0, int16_t *VAR_1, int VAR_2){", "int VAR_3;", "int VAR_4=0;", "uint8_t state[CONTEXT_SIZE];", "memset(state, 128, sizeof(state));", "for(VAR_3=0; VAR_4<128 ; VAR_3++){", "int VAR_5= get_symbol(VAR_0, state, 0) + 1;", "if(VAR_5 + VAR_4 > 128) return -1;", "while(VAR_5--){", "VAR_1[VAR_4] = VAR_2*VAR_3;", "VAR_4++;", "}", "}", "for(VAR_4=1; VAR_4<128; VAR_4++){", "VAR_1[256-VAR_4]= -VAR_1[VAR_4];", "}", "VAR_1[128]= -VAR_1[127];", "return 2*VAR_3 - 1;", "}" ]

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

[ [ 1 ], [ 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ] ]

[ "static int FUNC_0(const char *VAR_0)\n{", "int VAR_1, VAR_2, VAR_3;", "char *VAR_4, *VAR_5 = av_strdup(VAR_0);", "if (!VAR_5)\nreturn AVERROR(ENOMEM);", "for (VAR_2 = 0, VAR_4 = VAR_5; *VAR_4; VAR_4++)", "if (*VAR_4 == ',')\nVAR_2++;", "VAR_2++;", "read_intervals = av_malloc(VAR_2 * sizeof(*read_intervals));", "if (!read_intervals) {", "VAR_1 = AVERROR(ENOMEM);", "goto end;", "}", "read_intervals_nb = VAR_2;", "VAR_4 = VAR_5;", "for (VAR_3 = 0; VAR_3 < VAR_2; VAR_3++) {", "char *VAR_6 = strchr(VAR_4, ',');", "if (VAR_6)\n*VAR_6++ = 0;", "read_intervals[VAR_3].id = VAR_3;", "VAR_1 = parse_read_interval(VAR_4, &read_intervals[VAR_3]);", "if (VAR_1 < 0) {", "av_log(NULL, AV_LOG_ERROR, \"Error parsing read interval #%d '%s'\\VAR_2\",\nVAR_3, VAR_4);", "goto end;", "}", "av_log(NULL, AV_LOG_VERBOSE, \"Parsed log interval \");", "log_read_interval(&read_intervals[VAR_3], NULL, AV_LOG_VERBOSE);", "VAR_4 = VAR_6;", "av_assert0(VAR_3 <= read_intervals_nb);", "}", "av_assert0(VAR_3 == read_intervals_nb);", "end:\nav_free(VAR_5);", "return VAR_1;", "}" ]

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

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

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "PCIDeviceClass *k = PCI_DEVICE_CLASS(VAR_0);", "k->no_hotplug = 1;", "k->init = piix4_pm_initfn;", "k->config_write = pm_write_config;", "k->vendor_id = PCI_VENDOR_ID_INTEL;", "k->device_id = PCI_DEVICE_ID_INTEL_82371AB_3;", "k->revision = 0x03;", "k->class_id = PCI_CLASS_BRIDGE_OTHER;", "dc->desc = \"PM\";", "dc->no_user = 1;", "dc->vmsd = &vmstate_acpi;", "dc->props = piix4_pm_properties;", "}" ]

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

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

[ "static void FUNC_0(int VAR_0, struct target_sigaction *VAR_1,\ntarget_siginfo_t *VAR_2,\ntarget_sigset_t *VAR_3, CPUARMState *VAR_4)\n{", "struct rt_sigframe_v1 *VAR_5;", "abi_ulong frame_addr = get_sigframe(VAR_1, VAR_4, sizeof(*VAR_5));", "struct target_sigaltstack VAR_6;", "int VAR_7;", "abi_ulong info_addr, uc_addr;", "if (!lock_user_struct(VERIFY_WRITE, VAR_5, frame_addr, 0))\nreturn ;", "info_addr = frame_addr + offsetof(struct rt_sigframe_v1, VAR_2);", "__put_user(info_addr, &VAR_5->pinfo);", "uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);", "__put_user(uc_addr, &VAR_5->puc);", "copy_siginfo_to_user(&VAR_5->VAR_2, VAR_2);", "memset(&VAR_5->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));", "memset(&VAR_6, 0, sizeof(VAR_6));", "__put_user(target_sigaltstack_used.ss_sp, &VAR_6.ss_sp);", "__put_user(target_sigaltstack_used.ss_size, &VAR_6.ss_size);", "__put_user(sas_ss_flags(get_sp_from_cpustate(VAR_4)), &VAR_6.ss_flags);", "memcpy(&VAR_5->uc.tuc_stack, &VAR_6, sizeof(VAR_6));", "setup_sigcontext(&VAR_5->uc.tuc_mcontext, VAR_4, VAR_3->sig[0]);", "for(VAR_7 = 0; VAR_7 < TARGET_NSIG_WORDS; VAR_7++) {", "if (__put_user(VAR_3->sig[VAR_7], &VAR_5->uc.tuc_sigmask.sig[VAR_7]))\ngoto end;", "}", "setup_return(VAR_4, VAR_1, &VAR_5->retcode, frame_addr, VAR_0,\nframe_addr + offsetof(struct rt_sigframe_v1, retcode));", "VAR_4->regs[1] = info_addr;", "VAR_4->regs[2] = uc_addr;", "end:\nunlock_user_struct(VAR_5, frame_addr, 1);", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21, 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 41 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 69, 71 ], [ 75 ], [ 77 ], [ 81, 83 ], [ 85 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{", "const uint8_t *VAR_4 = VAR_3->data;", "int VAR_5 = VAR_3->size;", "ALACContext *alac = VAR_0->priv_data;", "int VAR_6;", "unsigned int VAR_7;", "int VAR_8;", "unsigned int VAR_9;", "int VAR_10;", "uint8_t interlacing_shift;", "uint8_t interlacing_leftweight;", "int VAR_11, VAR_12;", "if (!VAR_4 || !VAR_5)\nreturn -1;", "init_get_bits(&alac->gb, VAR_4, VAR_5 * 8);", "VAR_6 = get_bits(&alac->gb, 3) + 1;", "if (VAR_6 != VAR_0->VAR_6) {", "av_log(VAR_0, AV_LOG_ERROR, \"frame header channel count mismatch\\n\");", "return AVERROR_INVALIDDATA;", "}", "skip_bits(&alac->gb, 4);", "skip_bits(&alac->gb, 12);", "VAR_8 = get_bits1(&alac->gb);", "alac->extra_bits = get_bits(&alac->gb, 2) << 3;", "VAR_10 = get_bits1(&alac->gb);", "if (VAR_8) {", "VAR_7 = get_bits_long(&alac->gb, 32);", "if(VAR_7 > alac->setinfo_max_samples_per_frame){", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_7 %d > %d\\n\", VAR_7, alac->setinfo_max_samples_per_frame);", "return -1;", "}", "} else", "VAR_7 = alac->setinfo_max_samples_per_frame;", "alac->bytespersample = VAR_6 * av_get_bytes_per_sample(VAR_0->sample_fmt);", "if(VAR_7 > *VAR_2 / alac->bytespersample){", "av_log(VAR_0, AV_LOG_ERROR, \"sample buffer too small\\n\");", "return -1;", "}", "*VAR_2 = VAR_7 * alac->bytespersample;", "VAR_9 = alac->setinfo_sample_size - alac->extra_bits + VAR_6 - 1;", "if (VAR_9 > MIN_CACHE_BITS) {", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_9 too big (%d)\\n\", VAR_9);", "return -1;", "}", "if (!VAR_10) {", "int16_t predictor_coef_table[MAX_CHANNELS][32];", "int VAR_13[MAX_CHANNELS];", "int VAR_14[MAX_CHANNELS];", "int VAR_15[MAX_CHANNELS];", "int VAR_16[MAX_CHANNELS];", "interlacing_shift = get_bits(&alac->gb, 8);", "interlacing_leftweight = get_bits(&alac->gb, 8);", "for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) {", "VAR_14[VAR_12] = get_bits(&alac->gb, 4);", "VAR_15[VAR_12] = get_bits(&alac->gb, 4);", "VAR_16[VAR_12] = get_bits(&alac->gb, 3);", "VAR_13[VAR_12] = get_bits(&alac->gb, 5);", "for (VAR_11 = 0; VAR_11 < VAR_13[VAR_12]; VAR_11++)", "predictor_coef_table[VAR_12][VAR_11] = (int16_t)get_bits(&alac->gb, 16);", "}", "if (alac->extra_bits) {", "for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) {", "for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++)", "alac->extra_bits_buffer[VAR_12][VAR_11] = get_bits(&alac->gb, alac->extra_bits);", "}", "}", "for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) {", "bastardized_rice_decompress(alac,\nalac->predicterror_buffer[VAR_12],\nVAR_7,\nVAR_9,\nalac->setinfo_rice_initialhistory,\nalac->setinfo_rice_kmodifier,\nVAR_16[VAR_12] * alac->setinfo_rice_historymult / 4,\n(1 << alac->setinfo_rice_kmodifier) - 1);", "if (VAR_14[VAR_12] == 0) {", "predictor_decompress_fir_adapt(alac->predicterror_buffer[VAR_12],\nalac->outputsamples_buffer[VAR_12],\nVAR_7,\nVAR_9,\npredictor_coef_table[VAR_12],\nVAR_13[VAR_12],\nVAR_15[VAR_12]);", "} else {", "av_log(VAR_0, AV_LOG_ERROR, \"FIXME: unhandled prediction type: %VAR_11\\n\", VAR_14[VAR_12]);", "}", "}", "} else {", "for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) {", "for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) {", "alac->outputsamples_buffer[VAR_12][VAR_11] = get_sbits_long(&alac->gb,\nalac->setinfo_sample_size);", "}", "}", "alac->extra_bits = 0;", "interlacing_shift = 0;", "interlacing_leftweight = 0;", "}", "if (get_bits(&alac->gb, 3) != 7)\nav_log(VAR_0, AV_LOG_ERROR, \"Error : Wrong End Of Frame\\n\");", "if (VAR_6 == 2 && interlacing_leftweight) {", "decorrelate_stereo(alac->outputsamples_buffer, VAR_7,\ninterlacing_shift, interlacing_leftweight);", "}", "if (alac->extra_bits) {", "append_extra_bits(alac->outputsamples_buffer, alac->extra_bits_buffer,\nalac->extra_bits, alac->numchannels, VAR_7);", "}", "switch(alac->setinfo_sample_size) {", "case 16:\nif (VAR_6 == 2) {", "interleave_stereo_16(alac->outputsamples_buffer, VAR_1,\nVAR_7);", "} else {", "for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) {", "((int16_t*)VAR_1)[VAR_11] = alac->outputsamples_buffer[0][VAR_11];", "}", "}", "break;", "case 24:\nif (VAR_6 == 2) {", "interleave_stereo_24(alac->outputsamples_buffer, VAR_1,\nVAR_7);", "} else {", "for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++)", "((int32_t *)VAR_1)[VAR_11] = alac->outputsamples_buffer[0][VAR_11] << 8;", "}", "break;", "}", "if (VAR_5 * 8 - get_bits_count(&alac->gb) > 8)\nav_log(VAR_0, AV_LOG_ERROR, \"Error : %d bits left\\n\", VAR_5 * 8 - get_bits_count(&alac->gb));", "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 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 37, 39 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 65 ], [ 69 ], [ 75 ], [ 79 ], [ 85 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 163 ], [ 167 ], [ 169 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197, 199, 201, 203, 205, 207, 209, 211 ], [ 215 ], [ 219, 221, 223, 225, 227, 229, 231 ], [ 233 ], [ 235 ], [ 249 ], [ 251 ], [ 253 ], [ 257 ], [ 259 ], [ 261, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277, 279 ], [ 283 ], [ 285, 287 ], [ 289 ], [ 293 ], [ 295, 297 ], [ 299 ], [ 303 ], [ 305, 307 ], [ 309, 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325, 327 ], [ 329, 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 347, 349 ], [ 353 ], [ 355 ] ]

[ "static int FUNC_0(BlockBackend *VAR_0, int64_t VAR_1,\nint64_t VAR_2, int VAR_3, int64_t *VAR_4)\n{", "Coroutine *co;", "CoWriteZeroes data = {", ".VAR_0 = VAR_0,\n.VAR_1 = VAR_1,\n.VAR_2 = VAR_2,\n.VAR_4 = VAR_4,\n.VAR_3 = VAR_3,\n.done = false,\n};", "if (VAR_2 >> BDRV_SECTOR_BITS > INT_MAX) {", "return -ERANGE;", "}", "co = qemu_coroutine_create(co_pwrite_zeroes_entry);", "qemu_coroutine_enter(co, &data);", "while (!data.done) {", "aio_poll(blk_get_aio_context(VAR_0), true);", "}", "if (data.ret < 0) {", "return data.ret;", "} else {", "return 1;", "}", "}" ]

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

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

[ "static void FUNC_0(target_phys_addr_t VAR_0)\n{", "DeviceState *dev;", "SysBusDevice *s;", "dev = qdev_create(NULL, \"macio_idreg\");", "qdev_init(dev);", "s = sysbus_from_qdev(dev);", "sysbus_mmio_map(s, 0, VAR_0);", "cpu_physical_memory_write_rom(VAR_0, idreg_data, sizeof(idreg_data));", "}" ]

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

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

[ "static void FUNC_0 (fdctrl_t *VAR_0, int VAR_1)\n{", "fdrive_t *cur_drv;", "uint8_t kh, kt, ks;", "int VAR_2;", "VAR_0->cur_drv = VAR_0->fifo[1] & 1;", "cur_drv = get_cur_drv(VAR_0);", "kt = VAR_0->fifo[2];", "kh = VAR_0->fifo[3];", "ks = VAR_0->fifo[4];", "FLOPPY_DPRINTF(\"Start transfer at %d %d %02x %02x (%d)\\n\",\nVAR_0->cur_drv, kh, kt, ks,\n_fd_sector(kh, kt, ks, cur_drv->last_sect));", "VAR_2 = 0;", "switch (fd_seek(cur_drv, kh, kt, ks, VAR_0->config & 0x40)) {", "case 2:\nfdctrl_stop_transfer(VAR_0, 0x40, 0x00, 0x00);", "VAR_0->fifo[3] = kt;", "VAR_0->fifo[4] = kh;", "VAR_0->fifo[5] = ks;", "return;", "case 3:\nfdctrl_stop_transfer(VAR_0, 0x40, 0x80, 0x00);", "VAR_0->fifo[3] = kt;", "VAR_0->fifo[4] = kh;", "VAR_0->fifo[5] = ks;", "return;", "case 4:\nfdctrl_stop_transfer(VAR_0, 0x40, 0x00, 0x00);", "VAR_0->fifo[3] = kt;", "VAR_0->fifo[4] = kh;", "VAR_0->fifo[5] = ks;", "return;", "case 1:\nVAR_2 = 1;", "break;", "default:\nbreak;", "}", "VAR_0->data_dir = VAR_1;", "VAR_0->data_pos = 0;", "FD_SET_STATE(VAR_0->data_state, FD_STATE_DATA);", "if (VAR_0->fifo[0] & 0x80)\nVAR_0->data_state |= FD_STATE_MULTI;", "else\nVAR_0->data_state &= ~FD_STATE_MULTI;", "if (VAR_2)\nVAR_0->data_state |= FD_STATE_SEEK;", "else\nVAR_0->data_state &= ~FD_STATE_SEEK;", "if (VAR_0->fifo[5] == 00) {", "VAR_0->data_len = VAR_0->fifo[8];", "} else {", "int VAR_3;", "VAR_0->data_len = 128 << VAR_0->fifo[5];", "VAR_3 = (cur_drv->last_sect - ks + 1);", "if (VAR_0->fifo[0] & 0x80)\nVAR_3 += cur_drv->last_sect;", "VAR_0->data_len *= VAR_3;", "}", "VAR_0->eot = VAR_0->fifo[6];", "if (VAR_0->dma_en) {", "int VAR_4;", "VAR_4 = DMA_get_channel_mode(VAR_0->dma_chann);", "VAR_4 = (VAR_4 >> 2) & 3;", "FLOPPY_DPRINTF(\"VAR_4=%d VAR_1=%d (%d - %d)\\n\",\nVAR_4, VAR_1,\n(128 << VAR_0->fifo[5]) *\n(cur_drv->last_sect - ks + 1), VAR_0->data_len);", "if (((VAR_1 == FD_DIR_SCANE || VAR_1 == FD_DIR_SCANL ||\nVAR_1 == FD_DIR_SCANH) && VAR_4 == 0) ||\n(VAR_1 == FD_DIR_WRITE && VAR_4 == 2) ||\n(VAR_1 == FD_DIR_READ && VAR_4 == 1)) {", "VAR_0->state |= FD_CTRL_BUSY;", "DMA_hold_DREQ(VAR_0->dma_chann);", "DMA_schedule(VAR_0->dma_chann);", "return;", "} else {", "FLOPPY_ERROR(\"VAR_4=%d VAR_1=%d\\n\", VAR_4, VAR_1);", "}", "}", "FLOPPY_DPRINTF(\"start non-DMA transfer\\n\");", "fdctrl_raise_irq(VAR_0, 0x00);", "return;", "}" ]

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

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

[ "int FUNC_0(QemuOpts *VAR_0, CharDriverState **VAR_1)\n{", "CharDriverState *chr;", "chr = g_malloc0(sizeof(CharDriverState));", "chr->chr_write = msmouse_chr_write;", "chr->chr_close = msmouse_chr_close;", "qemu_add_mouse_event_handler(msmouse_event, chr, 0, \"QEMU Microsoft Mouse\");", "*VAR_1 = chr;", "return 0;", "}" ]

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

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

[ "static char *FUNC_0(AVIOContext *VAR_0, int VAR_1)\n{", "int VAR_2;", "char *VAR_3 = av_malloc(VAR_1 + 1);", "if (!VAR_3)\nreturn NULL;", "VAR_2 = avio_get_str(VAR_0, VAR_1, VAR_3, VAR_1 + 1);", "if (VAR_2 < VAR_1)\navio_skip(VAR_0, VAR_1 - VAR_2);", "return VAR_3;", "}" ]

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

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

[ "static char *FUNC_0(char *VAR_0, int VAR_1)\n{", "time_t ti;", "char *VAR_2;", "ti = time(NULL);", "VAR_2 = ctime(&ti);", "av_strlcpy(VAR_0, VAR_2, VAR_1);", "VAR_2 = VAR_0 + strlen(VAR_2) - 1;", "if (*VAR_2 == '\\n')\n*VAR_2 = '\\0';", "return VAR_0;", "}" ]

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

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

[ "void FUNC_0(MpegEncContext *VAR_0, int (*VAR_1)[64],\nVAR_2 (*qmat16)[2][64],\nconst VAR_2 *VAR_3,\nint VAR_4, int VAR_5, int VAR_6, int VAR_7)\n{", "FDCTDSPContext *fdsp = &VAR_0->fdsp;", "int VAR_8;", "int VAR_9 = 0;", "for (VAR_8 = VAR_5; VAR_8 <= VAR_6; VAR_8++) {", "int VAR_10;", "int VAR_11;", "if (VAR_0->q_scale_type) VAR_11 = ff_mpeg2_non_linear_qscale[VAR_8];", "else VAR_11 = VAR_8 << 1;", "if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||\n#if CONFIG_FAANDCT\nfdsp->fdct == ff_faandct ||\n#endif\nfdsp->fdct == ff_jpeg_fdct_islow_10) {", "for (VAR_10 = 0; VAR_10 < 64; VAR_10++) {", "const int VAR_13 = VAR_0->idsp.idct_permutation[VAR_10];", "int64_t den = (int64_t) VAR_11 * VAR_3[VAR_13];", "VAR_1[VAR_8][VAR_10] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);", "}", "} else if (fdsp->fdct == ff_fdct_ifast) {", "for (VAR_10 = 0; VAR_10 < 64; VAR_10++) {", "const int VAR_13 = VAR_0->idsp.idct_permutation[VAR_10];", "int64_t den = ff_aanscales[VAR_10] * (int64_t) VAR_11 * VAR_3[VAR_13];", "VAR_1[VAR_8][VAR_10] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);", "}", "} else {", "for (VAR_10 = 0; VAR_10 < 64; VAR_10++) {", "const int VAR_13 = VAR_0->idsp.idct_permutation[VAR_10];", "int64_t den = (int64_t) VAR_11 * VAR_3[VAR_13];", "VAR_1[VAR_8][VAR_10] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);", "qmat16[VAR_8][0][VAR_10] = (2 << QMAT_SHIFT_MMX) / den;", "if (qmat16[VAR_8][0][VAR_10] == 0 ||\nqmat16[VAR_8][0][VAR_10] == 128 * 256)\nqmat16[VAR_8][0][VAR_10] = 128 * 256 - 1;", "qmat16[VAR_8][1][VAR_10] =\nROUNDED_DIV(VAR_4 << (16 - QUANT_BIAS_SHIFT),\nqmat16[VAR_8][0][VAR_10]);", "}", "}", "for (VAR_10 = VAR_7; VAR_10 < 64; VAR_10++) {", "int64_t max = 8191;", "if (fdsp->fdct == ff_fdct_ifast) {", "max = (8191LL * ff_aanscales[VAR_10]) >> 14;", "}", "while (((max * VAR_1[VAR_8][VAR_10]) >> VAR_9) > INT_MAX) {", "VAR_9++;", "}", "}", "}", "if (VAR_9) {", "av_log(NULL, AV_LOG_INFO,\n\"Warning, QMAT_SHIFT is larger than %d, overflows possible\\n\",\nQMAT_SHIFT - VAR_9);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 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 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 107 ], [ 113 ], [ 117, 119, 121 ], [ 123, 125, 127 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157, 159, 161 ], [ 163 ], [ 165 ] ]

[ "static void __attribute__((constructor)) FUNC_0(void)\n{", "if (!g_thread_supported()) {", "g_thread_init(NULL);", "}", "coroutine_cond = g_cond_new();", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 8 ], [ 14 ], [ 18 ], [ 20 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "Error *local_err = NULL;", "MigrationIncomingState *mis = VAR_0;", "cpu_synchronize_all_post_init();", "qemu_announce_self();", "bdrv_invalidate_cache_all(&local_err);", "if (local_err) {", "error_report_err(local_err);", "}", "trace_loadvm_postcopy_handle_run_cpu_sync();", "cpu_synchronize_all_post_init();", "trace_loadvm_postcopy_handle_run_vmstart();", "if (autostart) {", "vm_start();", "} else {", "runstate_set(RUN_STATE_PAUSED);", "}", "qemu_bh_delete(mis->bh);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 17 ], [ 21 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 43 ], [ 47 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ] ]

[ "static BlockDriverAIOCB *FUNC_0(BlockDriverState *bs,\nint64_t sector_num,\nQEMUIOVector *qiov,\nint nb_sectors,\nBlockDriverCompletionFunc *cb,\nvoid *opaque,\nint is_write)\n{", "BlockDriverAIOCBSync *acb;", "acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);", "acb->is_write = is_write;", "acb->qiov = qiov;", "acb->bounce = qemu_blockalign(bs, qiov->size);", "acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);", "if (is_write) {", "qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);", "acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);", "} else {", "acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);", "}", "qemu_bh_schedule(acb->bh);", "return &acb->common;", "}" ]

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

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

[ "static int FUNC_0(VncDisplay *VAR_0,\nSocketAddress *VAR_1,\nconst char *VAR_2,\nQIOChannelSocket ***VAR_3,\nguint **VAR_4,\nsize_t *VAR_5,\nError **VAR_6)\n{", "QIODNSResolver *resolver = qio_dns_resolver_get_instance();", "SocketAddress **rawaddrs = NULL;", "size_t nrawaddrs = 0;", "Error *listenerr = NULL;", "bool listening = false;", "size_t i;", "if (qio_dns_resolver_lookup_sync(resolver, VAR_1, &nrawaddrs,\n&rawaddrs, VAR_6) < 0) {", "return -1;", "}", "for (i = 0; i < nrawaddrs; i++) {", "QIOChannelSocket *sioc = qio_channel_socket_new();", "qio_channel_set_name(QIO_CHANNEL(sioc), VAR_2);", "if (qio_channel_socket_listen_sync(\nsioc, rawaddrs[i], listenerr == NULL ? &listenerr : NULL) < 0) {", "continue;", "}", "listening = true;", "(*VAR_5)++;", "*VAR_3 = g_renew(QIOChannelSocket *, *VAR_3, *VAR_5);", "*VAR_4 = g_renew(guint, *VAR_4, *VAR_5);", "(*VAR_3)[*VAR_5 - 1] = sioc;", "(*VAR_4)[*VAR_5 - 1] = 0;", "}", "for (i = 0; i < nrawaddrs; i++) {", "qapi_free_SocketAddress(rawaddrs[i]);", "}", "g_free(rawaddrs);", "if (listenerr) {", "if (!listening) {", "error_propagate(VAR_6, listenerr);", "return -1;", "} else {", "error_free(listenerr);", "}", "}", "for (i = 0; i < *VAR_5; i++) {", "(*VAR_4)[i] = qio_channel_add_watch(\nQIO_CHANNEL((*VAR_3)[i]),\nG_IO_IN, vnc_listen_io, VAR_0, NULL);", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13, 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 47 ], [ 49, 51 ], [ 54 ], [ 56 ], [ 58 ], [ 60 ], [ 62 ], [ 64 ], [ 68 ], [ 70 ], [ 72 ], [ 76 ], [ 78 ], [ 80 ], [ 82 ], [ 86 ], [ 88 ], [ 90 ], [ 92 ], [ 94 ], [ 96 ], [ 98 ], [ 100 ], [ 104 ], [ 106, 108, 110 ], [ 112 ], [ 116 ], [ 118 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "COOKContext *q = avctx->priv_data;", "const uint8_t *VAR_0 = avctx->extradata;", "const uint8_t *VAR_1 = VAR_0 + avctx->VAR_2;", "int VAR_2 = avctx->VAR_2;", "int VAR_3 = 0;", "unsigned int VAR_4 = 0;", "int VAR_5;", "int VAR_6;", "q->avctx = avctx;", "if (VAR_2 < 8) {", "av_log(avctx, AV_LOG_ERROR, \"Necessary extradata missing!\\n\");", "return AVERROR_INVALIDDATA;", "}", "av_log(avctx, AV_LOG_DEBUG, \"codecdata_length=%d\\n\", avctx->VAR_2);", "if (!avctx->channels) {", "av_log(avctx, AV_LOG_ERROR, \"Invalid number of channels\\n\");", "return AVERROR_INVALIDDATA;", "}", "av_lfg_init(&q->random_state, 0);", "ff_audiodsp_init(&q->adsp);", "while (VAR_0 < VAR_1) {", "if (VAR_2 >= 8) {", "q->subpacket[VAR_3].cookversion = bytestream_get_be32(&VAR_0);", "VAR_5 = bytestream_get_be16(&VAR_0);", "q->subpacket[VAR_3].subbands = bytestream_get_be16(&VAR_0);", "VAR_2 -= 8;", "}", "if (VAR_2 >= 8) {", "bytestream_get_be32(&VAR_0);", "q->subpacket[VAR_3].js_subband_start = bytestream_get_be16(&VAR_0);", "q->subpacket[VAR_3].js_vlc_bits = bytestream_get_be16(&VAR_0);", "VAR_2 -= 8;", "}", "q->subpacket[VAR_3].samples_per_channel = VAR_5 / avctx->channels;", "q->subpacket[VAR_3].bits_per_subpacket = avctx->block_align * 8;", "q->subpacket[VAR_3].log2_numvector_size = 5;", "q->subpacket[VAR_3].total_subbands = q->subpacket[VAR_3].subbands;", "q->subpacket[VAR_3].num_channels = 1;", "av_log(avctx, AV_LOG_DEBUG, \"subpacket[%i].cookversion=%x\\n\", VAR_3,\nq->subpacket[VAR_3].cookversion);", "q->subpacket[VAR_3].joint_stereo = 0;", "switch (q->subpacket[VAR_3].cookversion) {", "case MONO:\nif (avctx->channels != 1) {", "avpriv_request_sample(avctx, \"Container channels != 1\");", "return AVERROR_PATCHWELCOME;", "}", "av_log(avctx, AV_LOG_DEBUG, \"MONO\\n\");", "break;", "case STEREO:\nif (avctx->channels != 1) {", "q->subpacket[VAR_3].bits_per_subpdiv = 1;", "q->subpacket[VAR_3].num_channels = 2;", "}", "av_log(avctx, AV_LOG_DEBUG, \"STEREO\\n\");", "break;", "case JOINT_STEREO:\nif (avctx->channels != 2) {", "avpriv_request_sample(avctx, \"Container channels != 2\");", "return AVERROR_PATCHWELCOME;", "}", "av_log(avctx, AV_LOG_DEBUG, \"JOINT_STEREO\\n\");", "if (avctx->VAR_2 >= 16) {", "q->subpacket[VAR_3].total_subbands = q->subpacket[VAR_3].subbands +\nq->subpacket[VAR_3].js_subband_start;", "q->subpacket[VAR_3].joint_stereo = 1;", "q->subpacket[VAR_3].num_channels = 2;", "}", "if (q->subpacket[VAR_3].samples_per_channel > 256) {", "q->subpacket[VAR_3].log2_numvector_size = 6;", "}", "if (q->subpacket[VAR_3].samples_per_channel > 512) {", "q->subpacket[VAR_3].log2_numvector_size = 7;", "}", "break;", "case MC_COOK:\nav_log(avctx, AV_LOG_DEBUG, \"MULTI_CHANNEL\\n\");", "if (VAR_2 >= 4)\nVAR_4 |= q->subpacket[VAR_3].VAR_4 = bytestream_get_be32(&VAR_0);", "if (av_get_channel_layout_nb_channels(q->subpacket[VAR_3].VAR_4) > 1) {", "q->subpacket[VAR_3].total_subbands = q->subpacket[VAR_3].subbands +\nq->subpacket[VAR_3].js_subband_start;", "q->subpacket[VAR_3].joint_stereo = 1;", "q->subpacket[VAR_3].num_channels = 2;", "q->subpacket[VAR_3].samples_per_channel = VAR_5 >> 1;", "if (q->subpacket[VAR_3].samples_per_channel > 256) {", "q->subpacket[VAR_3].log2_numvector_size = 6;", "}", "if (q->subpacket[VAR_3].samples_per_channel > 512) {", "q->subpacket[VAR_3].log2_numvector_size = 7;", "}", "} else", "q->subpacket[VAR_3].samples_per_channel = VAR_5;", "break;", "default:\navpriv_request_sample(avctx, \"Cook version %d\",\nq->subpacket[VAR_3].cookversion);", "return AVERROR_PATCHWELCOME;", "}", "if (VAR_3 > 1 && q->subpacket[VAR_3].samples_per_channel != q->samples_per_channel) {", "av_log(avctx, AV_LOG_ERROR, \"different number of samples per channel!\\n\");", "return AVERROR_INVALIDDATA;", "} else", "q->samples_per_channel = q->subpacket[0].samples_per_channel;", "q->subpacket[VAR_3].numvector_size = (1 << q->subpacket[VAR_3].log2_numvector_size);", "if (q->subpacket[VAR_3].total_subbands > 53) {", "avpriv_request_sample(avctx, \"total_subbands > 53\");", "return AVERROR_PATCHWELCOME;", "}", "if ((q->subpacket[VAR_3].js_vlc_bits > 6) ||\n(q->subpacket[VAR_3].js_vlc_bits < 2 * q->subpacket[VAR_3].joint_stereo)) {", "av_log(avctx, AV_LOG_ERROR, \"js_vlc_bits = %d, only >= %d and <= 6 allowed!\\n\",\nq->subpacket[VAR_3].js_vlc_bits, 2 * q->subpacket[VAR_3].joint_stereo);", "return AVERROR_INVALIDDATA;", "}", "if (q->subpacket[VAR_3].subbands > 50) {", "avpriv_request_sample(avctx, \"subbands > 50\");", "return AVERROR_PATCHWELCOME;", "}", "q->subpacket[VAR_3].gains1.now = q->subpacket[VAR_3].gain_1;", "q->subpacket[VAR_3].gains1.previous = q->subpacket[VAR_3].gain_2;", "q->subpacket[VAR_3].gains2.now = q->subpacket[VAR_3].gain_3;", "q->subpacket[VAR_3].gains2.previous = q->subpacket[VAR_3].gain_4;", "q->num_subpackets++;", "VAR_3++;", "if (VAR_3 > MAX_SUBPACKETS) {", "avpriv_request_sample(avctx, \"subpackets > %d\", MAX_SUBPACKETS);", "return AVERROR_PATCHWELCOME;", "}", "}", "init_pow2table();", "init_gain_table(q);", "init_cplscales_table(q);", "if ((VAR_6 = init_cook_vlc_tables(q)))\nreturn VAR_6;", "if (avctx->block_align >= UINT_MAX / 2)\nreturn AVERROR(EINVAL);", "q->decoded_bytes_buffer =\nav_mallocz(avctx->block_align\n+ DECODE_BYTES_PAD1(avctx->block_align)\n+ AV_INPUT_BUFFER_PADDING_SIZE);", "if (!q->decoded_bytes_buffer)\nreturn AVERROR(ENOMEM);", "if ((VAR_6 = init_cook_mlt(q)))\nreturn VAR_6;", "if (1) {", "q->scalar_dequant = scalar_dequant_float;", "q->decouple = decouple_float;", "q->imlt_window = imlt_window_float;", "q->interpolate = interpolate_float;", "q->saturate_output = saturate_output_float;", "}", "if (q->samples_per_channel != 256 && q->samples_per_channel != 512 &&\nq->samples_per_channel != 1024) {", "avpriv_request_sample(avctx, \"samples_per_channel = %d\",\nq->samples_per_channel);", "return AVERROR_PATCHWELCOME;", "}", "avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;", "if (VAR_4)\navctx->channel_layout = VAR_4;", "else\navctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;", "#ifdef DEBUG\ndump_cook_context(q);", "#endif\nreturn 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 53 ], [ 57 ], [ 61 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 95 ], [ 97 ], [ 103 ], [ 105 ], [ 107 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137, 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189, 191 ], [ 193, 195 ], [ 199 ], [ 201, 203 ], [ 205 ], [ 207 ], [ 209 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 231 ], [ 233, 235, 237 ], [ 239 ], [ 241 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 261 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 277, 279 ], [ 281, 283 ], [ 285 ], [ 287 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 325 ], [ 327 ], [ 329 ], [ 333, 335 ], [ 341, 343 ], [ 353, 355, 357, 359 ], [ 361, 363 ], [ 369, 371 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 395, 397 ], [ 399, 401 ], [ 403 ], [ 405 ], [ 409 ], [ 411, 413 ], [ 415, 417 ], [ 421, 423 ], [ 425, 427 ], [ 429 ] ]

[ "static void FUNC_0(HotplugHandler *VAR_0,\nDeviceState *VAR_1, Error **VAR_2)\n{", "int VAR_3;", "CPUState *cs;", "CPUArchId *cpu_slot;", "X86CPUTopoInfo topo;", "X86CPU *cpu = X86_CPU(VAR_1);", "PCMachineState *pcms = PC_MACHINE(VAR_0);", "if (cpu->apic_id == UNASSIGNED_APIC_ID) {", "int VAR_4 = (max_cpus - 1) / smp_threads / smp_cores;", "if (cpu->socket_id < 0) {", "error_setg(VAR_2, \"CPU socket-id is not set\");", "} else if (cpu->socket_id > VAR_4) {", "error_setg(VAR_2, \"Invalid CPU socket-id: %u must be in range 0:%u\",\ncpu->socket_id, VAR_4);", "if (cpu->core_id < 0) {", "error_setg(VAR_2, \"CPU core-id is not set\");", "} else if (cpu->core_id > (smp_cores - 1)) {", "error_setg(VAR_2, \"Invalid CPU core-id: %u must be in range 0:%u\",\ncpu->core_id, smp_cores - 1);", "if (cpu->thread_id < 0) {", "error_setg(VAR_2, \"CPU thread-id is not set\");", "} else if (cpu->thread_id > (smp_threads - 1)) {", "error_setg(VAR_2, \"Invalid CPU thread-id: %u must be in range 0:%u\",\ncpu->thread_id, smp_threads - 1);", "topo.pkg_id = cpu->socket_id;", "topo.core_id = cpu->core_id;", "topo.smt_id = cpu->thread_id;", "cpu->apic_id = apicid_from_topo_ids(smp_cores, smp_threads, &topo);", "cpu_slot = pc_find_cpu_slot(MACHINE(pcms), cpu->apic_id, &VAR_3);", "if (!cpu_slot) {", "MachineState *ms = MACHINE(pcms);", "x86_topo_ids_from_apicid(cpu->apic_id, smp_cores, smp_threads, &topo);", "error_setg(VAR_2, \"Invalid CPU [socket: %u, core: %u, thread: %u] with\"\n\" APIC ID %\" PRIu32 \", valid index range 0:%d\",\ntopo.pkg_id, topo.core_id, topo.smt_id, cpu->apic_id,\nms->possible_cpus->len - 1);", "if (cpu_slot->cpu) {", "error_setg(VAR_2, \"CPU[%d] with APIC ID %\" PRIu32 \" exists\",\nVAR_3, cpu->apic_id);", "x86_topo_ids_from_apicid(cpu->apic_id, smp_cores, smp_threads, &topo);", "if (cpu->socket_id != -1 && cpu->socket_id != topo.pkg_id) {", "error_setg(VAR_2, \"property socket-id: %u doesn't match set apic-id:\"\n\" 0x%x (socket-id: %u)\", cpu->socket_id, cpu->apic_id, topo.pkg_id);", "cpu->socket_id = topo.pkg_id;", "if (cpu->core_id != -1 && cpu->core_id != topo.core_id) {", "error_setg(VAR_2, \"property core-id: %u doesn't match set apic-id:\"\n\" 0x%x (core-id: %u)\", cpu->core_id, cpu->apic_id, topo.core_id);", "cpu->core_id = topo.core_id;", "if (cpu->thread_id != -1 && cpu->thread_id != topo.smt_id) {", "error_setg(VAR_2, \"property thread-id: %u doesn't match set apic-id:\"\n\" 0x%x (thread-id: %u)\", cpu->thread_id, cpu->apic_id, topo.smt_id);", "cpu->thread_id = topo.smt_id;", "cs = CPU(cpu);", "cs->cpu_index = VAR_3;", "numa_cpu_pre_plug(cpu_slot, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

[ [ 1, 2, 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 11 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16, 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 ], [ 49 ], [ 50 ], [ 51, 52 ], [ 53 ], [ 54 ], [ 55, 56 ], [ 57 ], [ 58 ], [ 59, 60 ], [ 61 ], [ 62 ], [ 63 ], [ 64 ] ]

[ "void FUNC_0(CPUARMState *VAR_0)\n{", "uint32_t id;", "id = VAR_0->cp15.c0_cpuid;", "memset(VAR_0, 0, offsetof(CPUARMState, breakpoints));", "if (id)\ncpu_reset_model_id(VAR_0, id);", "#if defined (CONFIG_USER_ONLY)\nVAR_0->uncached_cpsr = ARM_CPU_MODE_USR;", "VAR_0->vfp.xregs[ARM_VFP_FPEXC] = 1 << 30;", "#else\nVAR_0->uncached_cpsr = ARM_CPU_MODE_SVC | CPSR_A | CPSR_F | CPSR_I;", "if (IS_M(VAR_0))\nVAR_0->uncached_cpsr &= ~CPSR_I;", "VAR_0->vfp.xregs[ARM_VFP_FPEXC] = 0;", "VAR_0->cp15.c2_base_mask = 0xffffc000u;", "#endif\nVAR_0->regs[15] = 0;", "tlb_flush(VAR_0, 1);" ]

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

[ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6, 7 ], [ 8, 9 ], [ 10 ], [ 11, 13 ], [ 16, 17 ], [ 18 ], [ 19 ], [ 20, 21 ], [ 22 ] ]

[ "static int VAR_0 bdrv_co_do_readv(BlockDriverState *bs,\nint64_t sector_num, int nb_sectors, QEMUIOVector *qiov)\n{", "BlockDriver *drv = bs->drv;", "BdrvTrackedRequest req;", "int ret;", "if (!drv) {", "return -ENOMEDIUM;", "if (bdrv_check_request(bs, sector_num, nb_sectors)) {", "return -EIO;", "if (bs->io_limits_enabled) {", "bdrv_io_limits_intercept(bs, false, nb_sectors);", "tracked_request_begin(&req, bs, sector_num, nb_sectors, false);", "ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);", "tracked_request_end(&req);", "return ret;" ]

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

[ [ 1, 2, 3 ], [ 4 ], [ 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ], [ 12 ], [ 13 ], [ 14 ], [ 15 ], [ 16 ], [ 17 ] ]

[ "static inline void FUNC_0(unsigned int VAR_0)\n{", "register unsigned int VAR_1 asm(\"$r10\") = VAR_0;", "asm (\"ftagi\\t[%0]\\n\" : : \"r\" (VAR_1) );", "}" ]

[ 1, 0, 0, 0 ]

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

[ "abi_long FUNC_0(abi_ulong start, abi_ulong len, int prot,\nint flags, int fd, abi_ulong offset)\n{", "abi_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len;", "mmap_lock();", "#ifdef DEBUG_MMAP\n{", "printf(\"mmap: start=0x\" TARGET_ABI_FMT_lx\n\" len=0x\" TARGET_ABI_FMT_lx \" prot=%c%c%c flags=\",\nstart, len,\nprot & PROT_READ ? 'r' : '-',\nprot & PROT_WRITE ? 'w' : '-',\nprot & PROT_EXEC ? 'x' : '-');", "if (flags & MAP_FIXED)\nprintf(\"MAP_FIXED \");", "if (flags & MAP_ANONYMOUS)\nprintf(\"MAP_ANON \");", "switch(flags & MAP_TYPE) {", "case MAP_PRIVATE:\nprintf(\"MAP_PRIVATE \");", "break;", "case MAP_SHARED:\nprintf(\"MAP_SHARED \");", "break;", "default:\nprintf(\"[MAP_TYPE=0x%x] \", flags & MAP_TYPE);", "break;", "}", "printf(\"fd=%d offset=\" TARGET_ABI_FMT_lx \"\\n\", fd, offset);", "}", "#endif\nif (offset & ~TARGET_PAGE_MASK) {", "errno = EINVAL;", "goto fail;", "}", "len = TARGET_PAGE_ALIGN(len);", "if (len == 0)\ngoto the_end;", "real_start = start & qemu_host_page_mask;", "host_offset = offset & qemu_host_page_mask;", "if (!(flags & MAP_FIXED)) {", "host_len = len + offset - host_offset;", "host_len = HOST_PAGE_ALIGN(host_len);", "start = mmap_find_vma(real_start, host_len);", "if (start == (abi_ulong)-1) {", "errno = ENOMEM;", "goto fail;", "}", "}", "if ((qemu_real_host_page_size < TARGET_PAGE_SIZE)\n&& !(flags & MAP_ANONYMOUS)) {", "struct stat VAR_0;", "if (fstat (fd, &VAR_0) == -1)\ngoto fail;", "if (offset + len > VAR_0.st_size) {", "len = REAL_HOST_PAGE_ALIGN(VAR_0.st_size - offset);", "}", "}", "if (!(flags & MAP_FIXED)) {", "unsigned long VAR_1;", "void *VAR_3;", "host_len = len + offset - host_offset;", "host_len = HOST_PAGE_ALIGN(host_len);", "VAR_3 = mmap(g2h(start), host_len, prot,\nflags | MAP_FIXED | MAP_ANONYMOUS, -1, 0);", "if (VAR_3 == MAP_FAILED)\ngoto fail;", "VAR_1 = (unsigned long)VAR_3;", "if (!(flags & MAP_ANONYMOUS)) {", "VAR_3 = mmap(g2h(start), len, prot,\nflags | MAP_FIXED, fd, host_offset);", "if (VAR_3 == MAP_FAILED) {", "munmap(g2h(start), host_len);", "goto fail;", "}", "VAR_1 += offset - host_offset;", "}", "start = h2g(VAR_1);", "} else {", "if (start & ~TARGET_PAGE_MASK) {", "errno = EINVAL;", "goto fail;", "}", "end = start + len;", "real_end = HOST_PAGE_ALIGN(end);", "if ((unsigned long)start + len - 1 > (abi_ulong) -1) {", "errno = EINVAL;", "goto fail;", "}", "if (!(flags & MAP_ANONYMOUS) &&\n(offset & ~qemu_host_page_mask) != (start & ~qemu_host_page_mask)) {", "if ((flags & MAP_TYPE) == MAP_SHARED &&\n(prot & PROT_WRITE)) {", "errno = EINVAL;", "goto fail;", "}", "retaddr = FUNC_0(start, len, prot | PROT_WRITE,\nMAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,\n-1, 0);", "if (retaddr == -1)\ngoto fail;", "if (pread(fd, g2h(start), len, offset) == -1)\ngoto fail;", "if (!(prot & PROT_WRITE)) {", "ret = target_mprotect(start, len, prot);", "assert(ret == 0);", "}", "goto the_end;", "}", "if (start > real_start) {", "if (real_end == real_start + qemu_host_page_size) {", "ret = mmap_frag(real_start, start, end,\nprot, flags, fd, offset);", "if (ret == -1)\ngoto fail;", "goto the_end1;", "}", "ret = mmap_frag(real_start, start, real_start + qemu_host_page_size,\nprot, flags, fd, offset);", "if (ret == -1)\ngoto fail;", "real_start += qemu_host_page_size;", "}", "if (end < real_end) {", "ret = mmap_frag(real_end - qemu_host_page_size,\nreal_end - qemu_host_page_size, end,\nprot, flags, fd,\noffset + real_end - qemu_host_page_size - start);", "if (ret == -1)\ngoto fail;", "real_end -= qemu_host_page_size;", "}", "if (real_start < real_end) {", "void *VAR_3;", "unsigned long VAR_3;", "if (flags & MAP_ANONYMOUS)\nVAR_3 = 0;", "else\nVAR_3 = offset + real_start - start;", "VAR_3 = mmap(g2h(real_start), real_end - real_start,\nprot, flags, fd, VAR_3);", "if (VAR_3 == MAP_FAILED)\ngoto fail;", "}", "}", "the_end1:\npage_set_flags(start, start + len, prot | PAGE_VALID);", "the_end:\n#ifdef DEBUG_MMAP\nprintf(\"ret=0x\" TARGET_ABI_FMT_lx \"\\n\", start);", "page_dump(stdout);", "printf(\"\\n\");", "#endif\ntb_invalidate_phys_range(start, start + len);", "mmap_unlock();", "return start;", "fail:\nmmap_unlock();", "return -1;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13, 15 ], [ 17, 19, 21, 23, 25, 27 ], [ 29, 31 ], [ 33, 35 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63, 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 137, 139 ], [ 141 ], [ 145, 147 ], [ 153 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 189, 191 ], [ 193, 195 ], [ 199 ], [ 201 ], [ 203, 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 261, 263 ], [ 269, 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279, 281, 283 ], [ 285, 287 ], [ 289, 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 309 ], [ 311 ], [ 315, 317 ], [ 319, 321 ], [ 323 ], [ 325 ], [ 327, 329 ], [ 331, 333 ], [ 335 ], [ 337 ], [ 341 ], [ 343, 345, 347, 349 ], [ 351, 353 ], [ 355 ], [ 357 ], [ 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 ] ]

[ "int FUNC_0(CPUState *VAR_0, struct kvm_sw_breakpoint *VAR_1)\n{", "return -EINVAL;", "}" ]

[ 1, 1, 0 ]

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

[ "static bool FUNC_0(BDRVSheepdogState *s)\n{", "int VAR_0, VAR_1 = 0, VAR_2 = 0;", "Error *local_err = NULL;", "int VAR_3 = 0;", "bool result = true;", "SheepdogInode *inode = &s->inode;", "VAR_0 = connect_to_sdog(s, &local_err);", "if (VAR_0 < 0) {", "error_report_err(local_err);", "return false;", "}", "VAR_2 = count_data_objs(inode);", "while (VAR_1 < VAR_2) {", "int VAR_4, VAR_5;", "while (VAR_1 < VAR_2 && !inode->data_vdi_id[VAR_1]) {", "VAR_1++;", "}", "VAR_4 = VAR_1;", "VAR_5 = 0;", "while (VAR_1 < VAR_2 && VAR_5 < NR_BATCHED_DISCARD) {", "if (inode->data_vdi_id[VAR_1]) {", "inode->data_vdi_id[VAR_1] = 0;", "VAR_5++;", "}", "VAR_1++;", "}", "VAR_3 = write_object(VAR_0, s->bs,\n(char *)&inode->data_vdi_id[VAR_4],\nvid_to_vdi_oid(s->inode.vdi_id), inode->nr_copies,\n(VAR_1 - VAR_4) * sizeof(uint32_t),\noffsetof(struct SheepdogInode,\ndata_vdi_id[VAR_4]),\nfalse, s->cache_flags);", "if (VAR_3 < 0) {", "error_report(\"failed to discard snapshot inode.\");", "result = false;", "goto out;", "}", "}", "out:\nclosesocket(VAR_0);", "return result;", "}" ]

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

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

[ "static int FUNC_0(VFIODevice *VAR_0)\n{", "VFIOINTp *intp, *tmp;", "int VAR_1, VAR_2 = -1;", "VFIOPlatformDevice *vdev =\ncontainer_of(VAR_0, VFIOPlatformDevice, VAR_0);", "if (!(VAR_0->flags & VFIO_DEVICE_FLAGS_PLATFORM)) {", "error_report(\"vfio: Um, this isn't a platform device\");", "return VAR_2;", "}", "vdev->regions = g_new0(VFIORegion *, VAR_0->num_regions);", "for (VAR_1 = 0; VAR_1 < VAR_0->num_regions; VAR_1++) {", "struct vfio_region_info reg_info = { .argsz = sizeof(reg_info) };", "VFIORegion *ptr;", "vdev->regions[VAR_1] = g_malloc0(sizeof(VFIORegion));", "ptr = vdev->regions[VAR_1];", "reg_info.index = VAR_1;", "VAR_2 = ioctl(VAR_0->fd, VFIO_DEVICE_GET_REGION_INFO, &reg_info);", "if (VAR_2) {", "error_report(\"vfio: Error getting region %d info: %m\", VAR_1);", "goto reg_error;", "}", "ptr->flags = reg_info.flags;", "ptr->size = reg_info.size;", "ptr->fd_offset = reg_info.offset;", "ptr->nr = VAR_1;", "ptr->VAR_0 = VAR_0;", "trace_vfio_platform_populate_regions(ptr->nr,\n(unsigned long)ptr->flags,\n(unsigned long)ptr->size,\nptr->VAR_0->fd,\n(unsigned long)ptr->fd_offset);", "}", "vdev->mmap_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,\nvfio_intp_mmap_enable, vdev);", "QSIMPLEQ_INIT(&vdev->pending_intp_queue);", "for (VAR_1 = 0; VAR_1 < VAR_0->num_irqs; VAR_1++) {", "struct vfio_irq_info irq = { .argsz = sizeof(irq) };", "irq.index = VAR_1;", "VAR_2 = ioctl(VAR_0->fd, VFIO_DEVICE_GET_IRQ_INFO, &irq);", "if (VAR_2) {", "error_printf(\"vfio: error getting device %s irq info\",\nVAR_0->name);", "goto irq_err;", "} else {", "trace_vfio_platform_populate_interrupts(irq.index,\nirq.count,\nirq.flags);", "intp = vfio_init_intp(VAR_0, irq);", "if (!intp) {", "error_report(\"vfio: Error installing IRQ %d up\", VAR_1);", "goto irq_err;", "}", "}", "}", "return 0;", "irq_err:\ntimer_del(vdev->mmap_timer);", "QLIST_FOREACH_SAFE(intp, &vdev->intp_list, next, tmp) {", "QLIST_REMOVE(intp, next);", "g_free(intp);", "}", "reg_error:\nfor (VAR_1 = 0; VAR_1 < VAR_0->num_regions; VAR_1++) {", "g_free(vdev->regions[VAR_1]);", "}", "g_free(vdev->regions);", "return VAR_2;", "}" ]

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

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

[ "static int FUNC_0(H264Context *VAR_0, int VAR_1)\n{", "MpegEncContext *const s = &VAR_0->s;", "AVCodecContext *const avctx = s->avctx;", "H264Context *hx;", "int VAR_2;", "if (s->avctx->hwaccel ||\ns->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)\nreturn 0;", "if (VAR_1 == 1) {", "return decode_slice(avctx, &VAR_0);", "} else {", "for (VAR_2 = 1; VAR_2 < VAR_1; VAR_2++) {", "hx = VAR_0->thread_context[VAR_2];", "hx->s.err_recognition = avctx->err_recognition;", "hx->s.error_count = 0;", "hx->x264_build = VAR_0->x264_build;", "}", "avctx->execute(avctx, decode_slice, VAR_0->thread_context,\nNULL, VAR_1, sizeof(void *));", "hx = VAR_0->thread_context[VAR_1 - 1];", "s->mb_x = hx->s.mb_x;", "s->mb_y = hx->s.mb_y;", "s->droppable = hx->s.droppable;", "s->picture_structure = hx->s.picture_structure;", "for (VAR_2 = 1; VAR_2 < VAR_1; VAR_2++)", "VAR_0->s.error_count += VAR_0->thread_context[VAR_2]->s.error_count;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15, 17, 19 ], [ 21 ], [ 23 ], [ 25 ], [ 28 ], [ 30 ], [ 32 ], [ 34 ], [ 36 ], [ 38 ], [ 42, 44 ], [ 50 ], [ 52 ], [ 54 ], [ 56 ], [ 58 ], [ 60 ], [ 62 ], [ 64 ], [ 68 ], [ 70 ] ]

[ "void FUNC_0(PCMCIASocket *VAR_0)\n{", "struct pcmcia_socket_entry_s *VAR_1;", "VAR_1 = g_malloc(sizeof(struct pcmcia_socket_entry_s));", "VAR_1->VAR_0 = VAR_0;", "VAR_1->next = pcmcia_sockets;", "pcmcia_sockets = VAR_1;", "}" ]

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

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

[ "static void FUNC_0(SnowContext *VAR_0, SubBand *VAR_1, DWTELEM *VAR_2, DWTELEM *VAR_3, int VAR_4, int VAR_5){", "encode_subband_c0run(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5);", "}" ]

[ 1, 1, 0 ]

[ [ 1 ], [ 7 ], [ 11 ] ]

[ "static void FUNC_0(ESPState *VAR_0)\n{", "uint8_t buf[32];", "int VAR_1;", "if (VAR_0->dma && !VAR_0->dma_enabled) {", "VAR_0->dma_cb = FUNC_0;", "return;", "}", "VAR_1 = get_cmd(VAR_0, buf);", "if (VAR_1) {", "do_busid_cmd(VAR_0, buf, 0);", "}", "}" ]

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

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

[ "static void FUNC_0(HotplugHandler *VAR_0, DeviceState *VAR_1,\nuint32_t VAR_2, Error **VAR_3)\n{", "Error *local_err = NULL;", "sPAPRMachineState *ms = SPAPR_MACHINE(VAR_0);", "PCDIMMDevice *dimm = PC_DIMM(VAR_1);", "PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);", "MemoryRegion *mr = ddc->get_memory_region(dimm);", "uint64_t align = memory_region_get_alignment(mr);", "uint64_t size = memory_region_size(mr);", "uint64_t addr;", "if (size % SPAPR_MEMORY_BLOCK_SIZE) {", "error_setg(&local_err, \"Hotplugged memory size must be a multiple of \"\n\"%lld MB\", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE);", "goto out;", "}", "pc_dimm_memory_plug(VAR_1, &ms->hotplug_memory, mr, align, &local_err);", "if (local_err) {", "goto out;", "}", "addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err);", "if (local_err) {", "pc_dimm_memory_unplug(VAR_1, &ms->hotplug_memory, mr);", "goto out;", "}", "spapr_add_lmbs(VAR_1, addr, size, VAR_2, &error_abort);", "out:\nerror_propagate(VAR_3, local_err);", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,\nconst AVFrame *VAR_2, int *VAR_3)\n{", "A64Context *c = VAR_0->priv_data;", "AVFrame *const p = (AVFrame *) & c->picture;", "int VAR_4;", "int VAR_5, VAR_6;", "int VAR_7;", "int VAR_8;", "int VAR_9, VAR_10;", "uint8_t *buf;", "int *VAR_11 = c->mc_charmap;", "uint8_t *colram = c->mc_colram;", "uint8_t *charset = c->mc_charset;", "int *VAR_12 = c->mc_meta_charset;", "int *VAR_13 = c->mc_best_cb;", "int VAR_14 = 0x800 * (INTERLACED + 1);", "int VAR_15 = 0x100 * c->mc_use_5col;", "int VAR_16;", "if(CROP_SCREENS) {", "VAR_7 = FFMIN(VAR_0->height,C64YRES) >> 3;", "VAR_8 = FFMIN(VAR_0->width ,C64XRES) >> 3;", "VAR_16 = VAR_8 * VAR_7;", "} else {", "VAR_7 = C64YRES >> 3;", "VAR_8 = C64XRES >> 3;", "VAR_16 = 0x400;", "}", "if (!VAR_2) {", "if (!c->mc_lifetime) return 0;", "if (!c->mc_frame_counter) {", "c->mc_lifetime = 0;", "}", "else c->mc_lifetime = c->mc_frame_counter;", "} else {", "if (c->mc_frame_counter < c->mc_lifetime) {", "*p = *VAR_2;", "p->pict_type = AV_PICTURE_TYPE_I;", "p->key_frame = 1;", "to_meta_with_crop(VAR_0, p, VAR_12 + 32000 * c->mc_frame_counter);", "c->mc_frame_counter++;", "if (c->next_pts == AV_NOPTS_VALUE)\nc->next_pts = VAR_2->pts;", "return 0;", "}", "}", "if (c->mc_frame_counter == c->mc_lifetime) {", "VAR_9 = 0;", "if (c->mc_lifetime) {", "VAR_9 = VAR_14 + c->mc_lifetime*(VAR_16 + VAR_15);", "if ((VAR_10 = ff_alloc_packet(VAR_1, VAR_9)) < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"Error getting output packet of size %d.\\n\", VAR_9);", "return VAR_10;", "}", "buf = VAR_1->data;", "ff_init_elbg(VAR_12, 32, 1000 * c->mc_lifetime, VAR_13, CHARSET_CHARS, 50, VAR_11, &c->randctx);", "ff_do_elbg (VAR_12, 32, 1000 * c->mc_lifetime, VAR_13, CHARSET_CHARS, 50, VAR_11, &c->randctx);", "render_charset(VAR_0, charset, colram);", "memcpy(buf, charset, VAR_14);", "buf += VAR_14;", "charset += VAR_14;", "}", "for (VAR_4 = 0; VAR_4 < c->mc_lifetime; VAR_4++) {", "for (VAR_6 = 0; VAR_6 < VAR_7; VAR_6++) {", "for (VAR_5 = 0; VAR_5 < VAR_8; VAR_5++) {", "buf[VAR_6 * VAR_8 + VAR_5] = VAR_11[VAR_6 * VAR_8 + VAR_5];", "}", "}", "buf += VAR_16;", "VAR_9 += VAR_16;", "if (c->mc_use_5col) {", "a64_compress_colram(buf, VAR_11, colram);", "buf += VAR_15;", "VAR_9 += VAR_15;", "}", "VAR_11 += 1000;", "}", "AV_WB32(VAR_0->extradata + 4, c->mc_frame_counter);", "AV_WB32(VAR_0->extradata + 8, VAR_14);", "AV_WB32(VAR_0->extradata + 12, VAR_16 + VAR_15);", "c->mc_frame_counter = 0;", "VAR_1->pts = VAR_1->dts = c->next_pts;", "c->next_pts = AV_NOPTS_VALUE;", "VAR_1->size = VAR_9;", "VAR_1->flags |= AV_PKT_FLAG_KEY;", "*VAR_3 = !!VAR_9;", "}", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 71 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107, 109 ], [ 113 ], [ 115 ], [ 117 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 147 ], [ 149 ], [ 155 ], [ 161 ], [ 167 ], [ 169 ], [ 171 ], [ 177 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 193 ], [ 195 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ], [ 227 ], [ 233 ], [ 237 ], [ 239 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ] ]

[ "static av_always_inline void FUNC_0(MpegEncContext *s,\nuint8_t *dest_y, uint8_t *dest_cb,\nuint8_t *dest_cr, int dir,\nuint8_t **ref_picture,\nop_pixels_func (*pix_op)[4],\nqpel_mc_func (*qpix_op)[16], int is_mpeg12)\n{", "int VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6;", "int VAR_7, VAR_8, VAR_9;", "uint8_t *ptr, *dest;", "VAR_7 = s->VAR_7;", "VAR_8 = s->VAR_8;", "prefetch_motion(s, ref_picture, dir);", "if(!is_mpeg12 && s->obmc && s->pict_type != AV_PICTURE_TYPE_B){", "LOCAL_ALIGNED_8(int16_t, mv_cache, [4], [4][2]);", "Picture *cur_frame = &s->current_picture;", "const int VAR_10= s->VAR_7 + s->VAR_8*s->mb_stride;", "const int VAR_11= s->b8_stride;", "const int VAR_12= VAR_7*2 + VAR_8*2*VAR_11;", "av_assert2(!s->mb_skipped);", "AV_COPY32(mv_cache[1][1], cur_frame->motion_val[0][VAR_12 ]);", "AV_COPY32(mv_cache[1][2], cur_frame->motion_val[0][VAR_12 + 1]);", "AV_COPY32(mv_cache[2][1], cur_frame->motion_val[0][VAR_12 + VAR_11 ]);", "AV_COPY32(mv_cache[2][2], cur_frame->motion_val[0][VAR_12 + VAR_11 + 1]);", "AV_COPY32(mv_cache[3][1], cur_frame->motion_val[0][VAR_12 + VAR_11 ]);", "AV_COPY32(mv_cache[3][2], cur_frame->motion_val[0][VAR_12 + VAR_11 + 1]);", "if (VAR_8 == 0 || IS_INTRA(cur_frame->mb_type[VAR_10 - s->mb_stride])) {", "AV_COPY32(mv_cache[0][1], mv_cache[1][1]);", "AV_COPY32(mv_cache[0][2], mv_cache[1][2]);", "}else{", "AV_COPY32(mv_cache[0][1], cur_frame->motion_val[0][VAR_12 - VAR_11 ]);", "AV_COPY32(mv_cache[0][2], cur_frame->motion_val[0][VAR_12 - VAR_11 + 1]);", "}", "if (VAR_7 == 0 || IS_INTRA(cur_frame->mb_type[VAR_10 - 1])) {", "AV_COPY32(mv_cache[1][0], mv_cache[1][1]);", "AV_COPY32(mv_cache[2][0], mv_cache[2][1]);", "}else{", "AV_COPY32(mv_cache[1][0], cur_frame->motion_val[0][VAR_12 - 1]);", "AV_COPY32(mv_cache[2][0], cur_frame->motion_val[0][VAR_12 - 1 + VAR_11]);", "}", "if (VAR_7 + 1 >= s->mb_width || IS_INTRA(cur_frame->mb_type[VAR_10 + 1])) {", "AV_COPY32(mv_cache[1][3], mv_cache[1][2]);", "AV_COPY32(mv_cache[2][3], mv_cache[2][2]);", "}else{", "AV_COPY32(mv_cache[1][3], cur_frame->motion_val[0][VAR_12 + 2]);", "AV_COPY32(mv_cache[2][3], cur_frame->motion_val[0][VAR_12 + 2 + VAR_11]);", "}", "VAR_1 = 0;", "VAR_2 = 0;", "for(VAR_9=0;VAR_9<4;VAR_9++) {", "const int VAR_13= (VAR_9&1)+1;", "const int VAR_14= (VAR_9>>1)+1;", "int16_t mv[5][2]= {", "{mv_cache[VAR_14][VAR_13 ][0], mv_cache[VAR_14][VAR_13 ][1]},", "{mv_cache[VAR_14-1][VAR_13][0], mv_cache[VAR_14-1][VAR_13][1]},", "{mv_cache[VAR_14][VAR_13-1][0], mv_cache[VAR_14][VAR_13-1][1]},", "{mv_cache[VAR_14][VAR_13+1][0], mv_cache[VAR_14][VAR_13+1][1]},", "{mv_cache[VAR_14+1][VAR_13][0], mv_cache[VAR_14+1][VAR_13][1]}};", "obmc_motion(s, dest_y + ((VAR_9 & 1) * 8) + (VAR_9 >> 1) * 8 * s->linesize,\nref_picture[0],\nVAR_7 * 16 + (VAR_9 & 1) * 8, VAR_8 * 16 + (VAR_9 >>1) * 8,\npix_op[1],\nmv);", "VAR_1 += mv[0][0];", "VAR_2 += mv[0][1];", "}", "if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))\nchroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], VAR_1, VAR_2);", "return;", "}", "switch(s->mv_type) {", "case MV_TYPE_16X16:\nif(s->mcsel){", "if(s->real_sprite_warping_points==1){", "gmc1_motion(s, dest_y, dest_cb, dest_cr,\nref_picture);", "}else{", "gmc_motion(s, dest_y, dest_cb, dest_cr,\nref_picture);", "}", "}else if(!is_mpeg12 && s->quarter_sample){", "qpel_motion(s, dest_y, dest_cb, dest_cr,\n0, 0, 0,\nref_picture, pix_op, qpix_op,\ns->mv[dir][0][0], s->mv[dir][0][1], 16);", "} else if (!is_mpeg12 && (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) &&", "s->mspel && s->codec_id == AV_CODEC_ID_WMV2) {", "ff_mspel_motion(s, dest_y, dest_cb, dest_cr,\nref_picture, pix_op,\ns->mv[dir][0][0], s->mv[dir][0][1], 16);", "}else", "{", "mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,\nref_picture, pix_op,\ns->mv[dir][0][0], s->mv[dir][0][1], 16, VAR_8);", "}", "break;", "case MV_TYPE_8X8:\nif (!is_mpeg12) {", "VAR_1 = 0;", "VAR_2 = 0;", "if(s->quarter_sample){", "for(VAR_9=0;VAR_9<4;VAR_9++) {", "VAR_5 = s->mv[dir][VAR_9][0];", "VAR_6 = s->mv[dir][VAR_9][1];", "VAR_0 = ((VAR_6 & 3) << 2) | (VAR_5 & 3);", "VAR_3 = VAR_7 * 16 + (VAR_5 >> 2) + (VAR_9 & 1) * 8;", "VAR_4 = VAR_8 * 16 + (VAR_6 >> 2) + (VAR_9 >>1) * 8;", "VAR_3 = av_clip(VAR_3, -16, s->width);", "if (VAR_3 == s->width)\nVAR_0 &= ~3;", "VAR_4 = av_clip(VAR_4, -16, s->height);", "if (VAR_4 == s->height)\nVAR_0 &= ~12;", "ptr = ref_picture[0] + (VAR_4 * s->linesize) + (VAR_3);", "if(s->flags&CODEC_FLAG_EMU_EDGE){", "if( (unsigned)VAR_3 > FFMAX(s->h_edge_pos - (VAR_5&3) - 8, 0)\n|| (unsigned)VAR_4 > FFMAX(s->v_edge_pos - (VAR_6&3) - 8, 0)){", "s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,\ns->linesize, 9, 9,\nVAR_3, VAR_4,\ns->h_edge_pos, s->v_edge_pos);", "ptr= s->edge_emu_buffer;", "}", "}", "dest = dest_y + ((VAR_9 & 1) * 8) + (VAR_9 >> 1) * 8 * s->linesize;", "qpix_op[1][VAR_0](dest, ptr, s->linesize);", "VAR_1 += s->mv[dir][VAR_9][0]/2;", "VAR_2 += s->mv[dir][VAR_9][1]/2;", "}", "}else{", "for(VAR_9=0;VAR_9<4;VAR_9++) {", "hpel_motion(s, dest_y + ((VAR_9 & 1) * 8) + (VAR_9 >> 1) * 8 * s->linesize,\nref_picture[0],\nVAR_7 * 16 + (VAR_9 & 1) * 8, VAR_8 * 16 + (VAR_9 >>1) * 8,\npix_op[1],\ns->mv[dir][VAR_9][0], s->mv[dir][VAR_9][1]);", "VAR_1 += s->mv[dir][VAR_9][0];", "VAR_2 += s->mv[dir][VAR_9][1];", "}", "}", "if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))\nchroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], VAR_1, VAR_2);", "}", "break;", "case MV_TYPE_FIELD:\nif (s->picture_structure == PICT_FRAME) {", "if(!is_mpeg12 && s->quarter_sample){", "for(VAR_9=0; VAR_9<2; VAR_9++){", "qpel_motion(s, dest_y, dest_cb, dest_cr,\n1, VAR_9, s->field_select[dir][VAR_9],\nref_picture, pix_op, qpix_op,\ns->mv[dir][VAR_9][0], s->mv[dir][VAR_9][1], 8);", "}", "}else{", "mpeg_motion_field(s, dest_y, dest_cb, dest_cr,\n0, s->field_select[dir][0],\nref_picture, pix_op,\ns->mv[dir][0][0], s->mv[dir][0][1], 8, VAR_8);", "mpeg_motion_field(s, dest_y, dest_cb, dest_cr,\n1, s->field_select[dir][1],\nref_picture, pix_op,\ns->mv[dir][1][0], s->mv[dir][1][1], 8, VAR_8);", "}", "} else {", "if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){", "ref_picture = s->current_picture_ptr->f.data;", "}", "mpeg_motion(s, dest_y, dest_cb, dest_cr,\ns->field_select[dir][0],\nref_picture, pix_op,\ns->mv[dir][0][0], s->mv[dir][0][1], 16, VAR_8>>1);", "}", "break;", "case MV_TYPE_16X8:\nfor(VAR_9=0; VAR_9<2; VAR_9++){", "uint8_t ** ref2picture;", "if(s->picture_structure == s->field_select[dir][VAR_9] + 1\n|| s->pict_type == AV_PICTURE_TYPE_B || s->first_field){", "ref2picture= ref_picture;", "}else{", "ref2picture = s->current_picture_ptr->f.data;", "}", "mpeg_motion(s, dest_y, dest_cb, dest_cr,\ns->field_select[dir][VAR_9],\nref2picture, pix_op,\ns->mv[dir][VAR_9][0], s->mv[dir][VAR_9][1] + 16*VAR_9, 8, VAR_8>>1);", "dest_y += 16*s->linesize;", "dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;", "dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;", "}", "break;", "case MV_TYPE_DMV:\nif(s->picture_structure == PICT_FRAME){", "for(VAR_9=0; VAR_9<2; VAR_9++){", "int VAR_15;", "for(VAR_15=0; VAR_15<2; VAR_15++){", "mpeg_motion_field(s, dest_y, dest_cb, dest_cr,\nVAR_15, VAR_15^VAR_9, ref_picture, pix_op,\ns->mv[dir][2*VAR_9 + VAR_15][0],\ns->mv[dir][2*VAR_9 + VAR_15][1], 8, VAR_8);", "}", "pix_op = s->hdsp.avg_pixels_tab;", "}", "}else{", "for(VAR_9=0; VAR_9<2; VAR_9++){", "mpeg_motion(s, dest_y, dest_cb, dest_cr,\ns->picture_structure != VAR_9+1,\nref_picture, pix_op,\ns->mv[dir][2*VAR_9][0],s->mv[dir][2*VAR_9][1],16, VAR_8>>1);", "pix_op=s->hdsp.avg_pixels_tab;", "if(!s->first_field){", "ref_picture = s->current_picture_ptr->f.data;", "}", "}", "}", "break;", "default: av_assert2(0);", "}", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 141, 143, 145, 147, 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159, 161 ], [ 165 ], [ 167 ], [ 171 ], [ 173, 175 ], [ 177 ], [ 179, 181 ], [ 183 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 193, 195, 197, 199 ], [ 201 ], [ 203 ], [ 205, 207, 209 ], [ 211 ], [ 213 ], [ 215, 217, 219 ], [ 221 ], [ 223 ], [ 225, 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 243 ], [ 245 ], [ 247 ], [ 253 ], [ 255, 257 ], [ 259 ], [ 261, 263 ], [ 267 ], [ 269 ], [ 271, 273 ], [ 275, 277, 279, 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305, 307, 309, 311, 313 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 327, 329 ], [ 331 ], [ 333 ], [ 335, 337 ], [ 339 ], [ 341 ], [ 343, 345, 347, 349 ], [ 351 ], [ 353 ], [ 357, 359, 361, 363 ], [ 367, 369, 371, 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 387, 389, 391, 393 ], [ 395 ], [ 397 ], [ 399, 401 ], [ 403 ], [ 407, 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 421, 423, 425, 427 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 441, 443 ], [ 445 ], [ 447 ], [ 449 ], [ 451, 453, 455, 457 ], [ 459 ], [ 461 ], [ 463 ], [ 465 ], [ 467 ], [ 469, 471, 473, 475 ], [ 481 ], [ 487 ], [ 489 ], [ 491 ], [ 493 ], [ 495 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ] ]

[ "void FUNC_0 (CPUPPCState *VAR_0, int VAR_1, target_ulong VAR_2)\n{", "LOG_MMU(\"%s: reg=%d \" TARGET_FMT_lx \" \" TARGET_FMT_lx \"\\n\", __func__,\nVAR_1, VAR_2, VAR_0->sr[VAR_1]);", "#if defined(TARGET_PPC64)\nif (VAR_0->mmu_model & POWERPC_MMU_64) {", "uint64_t rb = 0, rs = 0;", "rb |= ((uint32_t)VAR_1 & 0xf) << 28;", "rb |= 1 << 27;", "rb |= (uint32_t)VAR_1;", "rs |= (VAR_2 & 0xfffffff) << 12;", "rs |= ((VAR_2 >> 27) & 0xf) << 9;", "ppc_store_slb(VAR_0, rb, rs);", "} else", "#endif\nif (VAR_0->sr[VAR_1] != VAR_2) {", "VAR_0->sr[VAR_1] = VAR_2;", "#if !defined(FLUSH_ALL_TLBS) && 0\n{", "target_ulong page, end;", "page = (16 << 20) * VAR_1;", "end = page + (16 << 20);", "for (; page != end; page += TARGET_PAGE_SIZE)", "tlb_flush_page(VAR_0, page);", "}", "#else\ntlb_flush(VAR_0, 1);", "#endif\n}", "}" ]

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

[ [ 1, 3 ], [ 5, 7 ], [ 9, 11 ], [ 13 ], [ 19 ], [ 23 ], [ 27 ], [ 33 ], [ 37 ], [ 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 55, 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73, 75 ], [ 77, 79 ], [ 81 ] ]

[ "int FUNC_0(H264Context *VAR_0) {", "MpegEncContext * const s = &VAR_0->s;", "int VAR_1;", "int VAR_2, VAR_3, VAR_4 = 0;", "int VAR_5= VAR_0->pps.transform_8x8_mode;", "int VAR_6 = VAR_0->sps.chroma_format_idc == 1 || VAR_0->sps.chroma_format_idc == 2;", "const int VAR_7 = VAR_0->VAR_7;", "VAR_1 = VAR_0->VAR_1 = s->mb_x + s->mb_y*s->mb_stride;", "tprintf(s->avctx, \"pic:%d mb:%d/%d\\n\", VAR_0->frame_num, s->mb_x, s->mb_y);", "if( VAR_0->slice_type_nos != AV_PICTURE_TYPE_I ) {", "int VAR_8;", "if( FRAME_MBAFF && (s->mb_y&1)==1 && VAR_0->prev_mb_skipped )\nVAR_8 = VAR_0->next_mb_skipped;", "else\nVAR_8 = decode_cabac_mb_skip( VAR_0, s->mb_x, s->mb_y );", "if( VAR_8 ) {", "if( FRAME_MBAFF && (s->mb_y&1)==0 ){", "s->current_picture.f.VAR_2[VAR_1] = MB_TYPE_SKIP;", "VAR_0->next_mb_skipped = decode_cabac_mb_skip( VAR_0, s->mb_x, s->mb_y+1 );", "if(!VAR_0->next_mb_skipped)\nVAR_0->mb_mbaff = VAR_0->mb_field_decoding_flag = decode_cabac_field_decoding_flag(VAR_0);", "}", "decode_mb_skip(VAR_0);", "VAR_0->cbp_table[VAR_1] = 0;", "VAR_0->chroma_pred_mode_table[VAR_1] = 0;", "VAR_0->last_qscale_diff = 0;", "return 0;", "}", "}", "if(FRAME_MBAFF){", "if( (s->mb_y&1) == 0 )\nVAR_0->mb_mbaff =\nVAR_0->mb_field_decoding_flag = decode_cabac_field_decoding_flag(VAR_0);", "}", "VAR_0->prev_mb_skipped = 0;", "fill_decode_neighbors(VAR_0, -(MB_FIELD));", "if( VAR_0->slice_type_nos == AV_PICTURE_TYPE_B ) {", "int VAR_25 = 0;", "assert(VAR_0->slice_type_nos == AV_PICTURE_TYPE_B);", "if( !IS_DIRECT( VAR_0->left_type[LTOP]-1 ) )\nVAR_25++;", "if( !IS_DIRECT( VAR_0->top_type-1 ) )\nVAR_25++;", "if( !get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[27+VAR_25] ) ){", "VAR_2= 0;", "}else if( !get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[27+3] ) ) {", "VAR_2= 1 + get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[27+5] );", "}else{", "int VAR_10;", "VAR_10 = get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[27+4] ) << 3;", "VAR_10+= get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[27+5] ) << 2;", "VAR_10+= get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[27+5] ) << 1;", "VAR_10+= get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[27+5] );", "if( VAR_10 < 8 ){", "VAR_2= VAR_10 + 3;", "}else if( VAR_10 == 13 ){", "VAR_2= decode_cabac_intra_mb_type(VAR_0, 32, 0);", "goto decode_intra_mb;", "}else if( VAR_10 == 14 ){", "VAR_2= 11;", "}else if( VAR_10 == 15 ){", "VAR_2= 22;", "}else{", "VAR_10= ( VAR_10<<1 ) + get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[27+5] );", "VAR_2= VAR_10 - 4;", "}", "}", "VAR_3= b_mb_type_info[VAR_2].VAR_3;", "VAR_2= b_mb_type_info[VAR_2].type;", "} else if( VAR_0->slice_type_nos == AV_PICTURE_TYPE_P ) {", "if( get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[14] ) == 0 ) {", "if( get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[15] ) == 0 ) {", "VAR_2= 3 * get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[16] );", "} else {", "VAR_2= 2 - get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[17] );", "}", "VAR_3= p_mb_type_info[VAR_2].VAR_3;", "VAR_2= p_mb_type_info[VAR_2].type;", "} else {", "VAR_2= decode_cabac_intra_mb_type(VAR_0, 17, 0);", "goto decode_intra_mb;", "}", "} else {", "VAR_2= decode_cabac_intra_mb_type(VAR_0, 3, 1);", "if(VAR_0->slice_type == AV_PICTURE_TYPE_SI && VAR_2)\nVAR_2--;", "assert(VAR_0->slice_type_nos == AV_PICTURE_TYPE_I);", "decode_intra_mb:\nVAR_3 = 0;", "VAR_4= i_mb_type_info[VAR_2].VAR_4;", "VAR_0->intra16x16_pred_mode= i_mb_type_info[VAR_2].VAR_15;", "VAR_2= i_mb_type_info[VAR_2].type;", "}", "if(MB_FIELD)\nVAR_2 |= MB_TYPE_INTERLACED;", "VAR_0->slice_table[ VAR_1 ]= VAR_0->slice_num;", "if(IS_INTRA_PCM(VAR_2)) {", "static const uint16_t VAR_11[4] = {256,384,512,768};", "const int VAR_12 = VAR_11[VAR_0->sps.chroma_format_idc]*VAR_0->sps.bit_depth_luma >> 3;", "const uint8_t *VAR_13;", "VAR_13= VAR_0->cabac.bytestream;", "if(VAR_0->cabac.low&0x1) VAR_13--;", "if(CABAC_BITS==16){", "if(VAR_0->cabac.low&0x1FF) VAR_13--;", "}", "memcpy(VAR_0->mb, VAR_13, VAR_12); VAR_13+=VAR_12;", "ff_init_cabac_decoder(&VAR_0->cabac, VAR_13, VAR_0->cabac.bytestream_end - VAR_13);", "VAR_0->cbp_table[VAR_1] = 0xf7ef;", "VAR_0->chroma_pred_mode_table[VAR_1] = 0;", "s->current_picture.f.qscale_table[VAR_1] = 0;", "memset(VAR_0->non_zero_count[VAR_1], 16, 48);", "s->current_picture.f.VAR_2[VAR_1] = VAR_2;", "VAR_0->last_qscale_diff = 0;", "return 0;", "}", "if(MB_MBAFF){", "VAR_0->ref_count[0] <<= 1;", "VAR_0->ref_count[1] <<= 1;", "}", "fill_decode_caches(VAR_0, VAR_2);", "if( IS_INTRA( VAR_2 ) ) {", "int VAR_29, VAR_15;", "if( IS_INTRA4x4( VAR_2 ) ) {", "if( VAR_5 && get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[399 + VAR_0->neighbor_transform_size] ) ) {", "VAR_2 |= MB_TYPE_8x8DCT;", "for( VAR_29 = 0; VAR_29 < 16; VAR_29+=4 ) {", "int VAR_18 = pred_intra_mode( VAR_0, VAR_29 );", "int VAR_17 = decode_cabac_mb_intra4x4_pred_mode( VAR_0, VAR_18 );", "fill_rectangle( &VAR_0->intra4x4_pred_mode_cache[ scan8[VAR_29] ], 2, 2, 8, VAR_17, 1 );", "}", "} else {", "for( VAR_29 = 0; VAR_29 < 16; VAR_29++ ) {", "int VAR_18 = pred_intra_mode( VAR_0, VAR_29 );", "VAR_0->intra4x4_pred_mode_cache[ scan8[VAR_29] ] = decode_cabac_mb_intra4x4_pred_mode( VAR_0, VAR_18 );", "}", "}", "write_back_intra_pred_mode(VAR_0);", "if( ff_h264_check_intra4x4_pred_mode(VAR_0) < 0 ) return -1;", "} else {", "VAR_0->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( VAR_0, VAR_0->intra16x16_pred_mode, 0 );", "if( VAR_0->intra16x16_pred_mode < 0 ) return -1;", "}", "if(VAR_6){", "VAR_0->chroma_pred_mode_table[VAR_1] =\nVAR_15 = decode_cabac_mb_chroma_pre_mode( VAR_0 );", "VAR_15= ff_h264_check_intra_pred_mode( VAR_0, VAR_15, 1 );", "if( VAR_15 < 0 ) return -1;", "VAR_0->chroma_pred_mode= VAR_15;", "} else {", "VAR_0->chroma_pred_mode= DC_128_PRED8x8;", "}", "} else if( VAR_3 == 4 ) {", "int VAR_29, VAR_18, VAR_19[4], VAR_22, VAR_21[2][4];", "if( VAR_0->slice_type_nos == AV_PICTURE_TYPE_B ) {", "for( VAR_29 = 0; VAR_29 < 4; VAR_29++ ) {", "VAR_0->sub_mb_type[VAR_29] = decode_cabac_b_mb_sub_type( VAR_0 );", "VAR_19[VAR_29]= b_sub_mb_type_info[ VAR_0->sub_mb_type[VAR_29] ].VAR_3;", "VAR_0->sub_mb_type[VAR_29]= b_sub_mb_type_info[ VAR_0->sub_mb_type[VAR_29] ].type;", "}", "if( IS_DIRECT(VAR_0->sub_mb_type[0] | VAR_0->sub_mb_type[1] |\nVAR_0->sub_mb_type[2] | VAR_0->sub_mb_type[3]) ) {", "ff_h264_pred_direct_motion(VAR_0, &VAR_2);", "VAR_0->ref_cache[0][scan8[4]] =\nVAR_0->ref_cache[1][scan8[4]] =\nVAR_0->ref_cache[0][scan8[12]] =\nVAR_0->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;", "for( VAR_29 = 0; VAR_29 < 4; VAR_29++ )", "fill_rectangle( &VAR_0->direct_cache[scan8[4*VAR_29]], 2, 2, 8, (VAR_0->sub_mb_type[VAR_29]>>1)&0xFF, 1 );", "}", "} else {", "for( VAR_29 = 0; VAR_29 < 4; VAR_29++ ) {", "VAR_0->sub_mb_type[VAR_29] = decode_cabac_p_mb_sub_type( VAR_0 );", "VAR_19[VAR_29]= p_sub_mb_type_info[ VAR_0->sub_mb_type[VAR_29] ].VAR_3;", "VAR_0->sub_mb_type[VAR_29]= p_sub_mb_type_info[ VAR_0->sub_mb_type[VAR_29] ].type;", "}", "}", "for( VAR_22 = 0; VAR_22 < VAR_0->list_count; VAR_22++ ) {", "for( VAR_29 = 0; VAR_29 < 4; VAR_29++ ) {", "if(IS_DIRECT(VAR_0->sub_mb_type[VAR_29])) continue;", "if(IS_DIR(VAR_0->sub_mb_type[VAR_29], 0, VAR_22)){", "if( VAR_0->ref_count[VAR_22] > 1 ){", "VAR_21[VAR_22][VAR_29] = decode_cabac_mb_ref( VAR_0, VAR_22, 4*VAR_29 );", "if(VAR_21[VAR_22][VAR_29] >= (unsigned)VAR_0->ref_count[VAR_22]){", "av_log(s->avctx, AV_LOG_ERROR, \"Reference %d >= %d\\n\", VAR_21[VAR_22][VAR_29], VAR_0->ref_count[VAR_22]);", "}", "}else", "VAR_21[VAR_22][VAR_29] = 0;", "} else {", "VAR_21[VAR_22][VAR_29] = -1;", "}", "VAR_0->ref_cache[VAR_22][ scan8[4*VAR_29]+1 ]=\nVAR_0->ref_cache[VAR_22][ scan8[4*VAR_29]+8 ]=VAR_0->ref_cache[VAR_22][ scan8[4*VAR_29]+9 ]= VAR_21[VAR_22][VAR_29];", "}", "}", "if(VAR_5)\nVAR_5 = get_dct8x8_allowed(VAR_0);", "for(VAR_22=0; VAR_22<VAR_0->list_count; VAR_22++){", "for(VAR_29=0; VAR_29<4; VAR_29++){", "VAR_0->ref_cache[VAR_22][ scan8[4*VAR_29] ]=VAR_0->ref_cache[VAR_22][ scan8[4*VAR_29]+1 ];", "if(IS_DIRECT(VAR_0->sub_mb_type[VAR_29])){", "fill_rectangle(VAR_0->mvd_cache[VAR_22][scan8[4*VAR_29]], 2, 2, 8, 0, 2);", "continue;", "}", "if(IS_DIR(VAR_0->sub_mb_type[VAR_29], 0, VAR_22) && !IS_DIRECT(VAR_0->sub_mb_type[VAR_29])){", "const int sub_mb_type= VAR_0->sub_mb_type[VAR_29];", "const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;", "for(VAR_18=0; VAR_18<VAR_19[VAR_29]; VAR_18++){", "int mpx, mpy;", "int mx, my;", "const int VAR_29= 4*VAR_29 + block_width*VAR_18;", "int16_t (* mv_cache)[2]= &VAR_0->mv_cache[VAR_22][ scan8[VAR_29] ];", "uint8_t (* mvd_cache)[2]= &VAR_0->mvd_cache[VAR_22][ scan8[VAR_29] ];", "pred_motion(VAR_0, VAR_29, block_width, VAR_22, VAR_0->ref_cache[VAR_22][ scan8[VAR_29] ], &mx, &my);", "DECODE_CABAC_MB_MVD( VAR_0, VAR_22, VAR_29)\ntprintf(s->avctx, \"final mv:%d %d\\n\", mx, my);", "if(IS_SUB_8X8(sub_mb_type)){", "mv_cache[ 1 ][0]=\nmv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;", "mv_cache[ 1 ][1]=\nmv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;", "mvd_cache[ 1 ][0]=\nmvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;", "mvd_cache[ 1 ][1]=\nmvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;", "}else if(IS_SUB_8X4(sub_mb_type)){", "mv_cache[ 1 ][0]= mx;", "mv_cache[ 1 ][1]= my;", "mvd_cache[ 1 ][0]= mpx;", "mvd_cache[ 1 ][1]= mpy;", "}else if(IS_SUB_4X8(sub_mb_type)){", "mv_cache[ 8 ][0]= mx;", "mv_cache[ 8 ][1]= my;", "mvd_cache[ 8 ][0]= mpx;", "mvd_cache[ 8 ][1]= mpy;", "}", "mv_cache[ 0 ][0]= mx;", "mv_cache[ 0 ][1]= my;", "mvd_cache[ 0 ][0]= mpx;", "mvd_cache[ 0 ][1]= mpy;", "}", "}else{", "fill_rectangle(VAR_0->mv_cache [VAR_22][ scan8[4*VAR_29] ], 2, 2, 8, 0, 4);", "fill_rectangle(VAR_0->mvd_cache[VAR_22][ scan8[4*VAR_29] ], 2, 2, 8, 0, 2);", "}", "}", "}", "} else if( IS_DIRECT(VAR_2) ) {", "ff_h264_pred_direct_motion(VAR_0, &VAR_2);", "fill_rectangle(VAR_0->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);", "fill_rectangle(VAR_0->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);", "VAR_5 &= VAR_0->sps.direct_8x8_inference_flag;", "} else {", "int VAR_22, VAR_29;", "if(IS_16X16(VAR_2)){", "for(VAR_22=0; VAR_22<VAR_0->list_count; VAR_22++){", "if(IS_DIR(VAR_2, 0, VAR_22)){", "int VAR_21;", "if(VAR_0->ref_count[VAR_22] > 1){", "VAR_21= decode_cabac_mb_ref(VAR_0, VAR_22, 0);", "if(VAR_21 >= (unsigned)VAR_0->ref_count[VAR_22]){", "av_log(s->avctx, AV_LOG_ERROR, \"Reference %d >= %d\\n\", VAR_21, VAR_0->ref_count[VAR_22]);", "}", "}else", "VAR_21=0;", "fill_rectangle(&VAR_0->ref_cache[VAR_22][ scan8[0] ], 4, 4, 8, VAR_21, 1);", "}", "}", "for(VAR_22=0; VAR_22<VAR_0->list_count; VAR_22++){", "if(IS_DIR(VAR_2, 0, VAR_22)){", "int mx,my,mpx,mpy;", "pred_motion(VAR_0, 0, 4, VAR_22, VAR_0->ref_cache[VAR_22][ scan8[0] ], &mx, &my);", "DECODE_CABAC_MB_MVD( VAR_0, VAR_22, 0)\ntprintf(s->avctx, \"final mv:%d %d\\n\", mx, my);", "fill_rectangle(VAR_0->mvd_cache[VAR_22][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);", "fill_rectangle(VAR_0->mv_cache[VAR_22][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);", "}", "}", "}", "else if(IS_16X8(VAR_2)){", "for(VAR_22=0; VAR_22<VAR_0->list_count; VAR_22++){", "for(VAR_29=0; VAR_29<2; VAR_29++){", "if(IS_DIR(VAR_2, VAR_29, VAR_22)){", "int VAR_21;", "if(VAR_0->ref_count[VAR_22] > 1){", "VAR_21= decode_cabac_mb_ref( VAR_0, VAR_22, 8*VAR_29 );", "if(VAR_21 >= (unsigned)VAR_0->ref_count[VAR_22]){", "av_log(s->avctx, AV_LOG_ERROR, \"Reference %d >= %d\\n\", VAR_21, VAR_0->ref_count[VAR_22]);", "}", "}else", "VAR_21=0;", "fill_rectangle(&VAR_0->ref_cache[VAR_22][ scan8[0] + 16*VAR_29 ], 4, 2, 8, VAR_21, 1);", "}else", "fill_rectangle(&VAR_0->ref_cache[VAR_22][ scan8[0] + 16*VAR_29 ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);", "}", "}", "for(VAR_22=0; VAR_22<VAR_0->list_count; VAR_22++){", "for(VAR_29=0; VAR_29<2; VAR_29++){", "if(IS_DIR(VAR_2, VAR_29, VAR_22)){", "int mx,my,mpx,mpy;", "pred_16x8_motion(VAR_0, 8*VAR_29, VAR_22, VAR_0->ref_cache[VAR_22][scan8[0] + 16*VAR_29], &mx, &my);", "DECODE_CABAC_MB_MVD( VAR_0, VAR_22, 8*VAR_29)\ntprintf(s->avctx, \"final mv:%d %d\\n\", mx, my);", "fill_rectangle(VAR_0->mvd_cache[VAR_22][ scan8[0] + 16*VAR_29 ], 4, 2, 8, pack8to16(mpx,mpy), 2);", "fill_rectangle(VAR_0->mv_cache[VAR_22][ scan8[0] + 16*VAR_29 ], 4, 2, 8, pack16to32(mx,my), 4);", "}else{", "fill_rectangle(VAR_0->mvd_cache[VAR_22][ scan8[0] + 16*VAR_29 ], 4, 2, 8, 0, 2);", "fill_rectangle(VAR_0-> mv_cache[VAR_22][ scan8[0] + 16*VAR_29 ], 4, 2, 8, 0, 4);", "}", "}", "}", "}else{", "assert(IS_8X16(VAR_2));", "for(VAR_22=0; VAR_22<VAR_0->list_count; VAR_22++){", "for(VAR_29=0; VAR_29<2; VAR_29++){", "if(IS_DIR(VAR_2, VAR_29, VAR_22)){", "int VAR_21;", "if(VAR_0->ref_count[VAR_22] > 1){", "VAR_21= decode_cabac_mb_ref( VAR_0, VAR_22, 4*VAR_29 );", "if(VAR_21 >= (unsigned)VAR_0->ref_count[VAR_22]){", "av_log(s->avctx, AV_LOG_ERROR, \"Reference %d >= %d\\n\", VAR_21, VAR_0->ref_count[VAR_22]);", "}", "}else", "VAR_21=0;", "fill_rectangle(&VAR_0->ref_cache[VAR_22][ scan8[0] + 2*VAR_29 ], 2, 4, 8, VAR_21, 1);", "}else", "fill_rectangle(&VAR_0->ref_cache[VAR_22][ scan8[0] + 2*VAR_29 ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);", "}", "}", "for(VAR_22=0; VAR_22<VAR_0->list_count; VAR_22++){", "for(VAR_29=0; VAR_29<2; VAR_29++){", "if(IS_DIR(VAR_2, VAR_29, VAR_22)){", "int mx,my,mpx,mpy;", "pred_8x16_motion(VAR_0, VAR_29*4, VAR_22, VAR_0->ref_cache[VAR_22][ scan8[0] + 2*VAR_29 ], &mx, &my);", "DECODE_CABAC_MB_MVD( VAR_0, VAR_22, 4*VAR_29)\ntprintf(s->avctx, \"final mv:%d %d\\n\", mx, my);", "fill_rectangle(VAR_0->mvd_cache[VAR_22][ scan8[0] + 2*VAR_29 ], 2, 4, 8, pack8to16(mpx,mpy), 2);", "fill_rectangle(VAR_0->mv_cache[VAR_22][ scan8[0] + 2*VAR_29 ], 2, 4, 8, pack16to32(mx,my), 4);", "}else{", "fill_rectangle(VAR_0->mvd_cache[VAR_22][ scan8[0] + 2*VAR_29 ], 2, 4, 8, 0, 2);", "fill_rectangle(VAR_0-> mv_cache[VAR_22][ scan8[0] + 2*VAR_29 ], 2, 4, 8, 0, 4);", "}", "}", "}", "}", "}", "if( IS_INTER( VAR_2 ) ) {", "VAR_0->chroma_pred_mode_table[VAR_1] = 0;", "write_back_motion( VAR_0, VAR_2 );", "}", "if( !IS_INTRA16x16( VAR_2 ) ) {", "VAR_4 = decode_cabac_mb_cbp_luma( VAR_0 );", "if(VAR_6)\nVAR_4 |= decode_cabac_mb_cbp_chroma( VAR_0 ) << 4;", "}", "VAR_0->cbp_table[VAR_1] = VAR_0->VAR_4 = VAR_4;", "if( VAR_5 && (VAR_4&15) && !IS_INTRA( VAR_2 ) ) {", "VAR_2 |= MB_TYPE_8x8DCT * get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[399 + VAR_0->neighbor_transform_size] );", "}", "if (CHROMA444 && IS_8x8DCT(VAR_2)){", "int VAR_29;", "uint8_t *nnz_cache = VAR_0->non_zero_count_cache;", "for (VAR_29 = 0; VAR_29 < 2; VAR_29++){", "if (VAR_0->left_type[LEFT(VAR_29)] && !IS_8x8DCT(VAR_0->left_type[LEFT(VAR_29)])){", "nnz_cache[3+8* 1 + 2*8*VAR_29]=\nnnz_cache[3+8* 2 + 2*8*VAR_29]=\nnnz_cache[3+8* 6 + 2*8*VAR_29]=\nnnz_cache[3+8* 7 + 2*8*VAR_29]=\nnnz_cache[3+8*11 + 2*8*VAR_29]=\nnnz_cache[3+8*12 + 2*8*VAR_29]= IS_INTRA(VAR_2) ? 64 : 0;", "}", "}", "if (VAR_0->top_type && !IS_8x8DCT(VAR_0->top_type)){", "uint32_t top_empty = CABAC && !IS_INTRA(VAR_2) ? 0 : 0x40404040;", "AV_WN32A(&nnz_cache[4+8* 0], top_empty);", "AV_WN32A(&nnz_cache[4+8* 5], top_empty);", "AV_WN32A(&nnz_cache[4+8*10], top_empty);", "}", "}", "s->current_picture.f.VAR_2[VAR_1] = VAR_2;", "if( VAR_4 || IS_INTRA16x16( VAR_2 ) ) {", "const uint8_t *VAR_22, *scan8x8;", "const uint32_t *VAR_23;", "if(IS_INTERLACED(VAR_2)){", "scan8x8= s->qscale ? VAR_0->field_scan8x8 : VAR_0->field_scan8x8_q0;", "VAR_22= s->qscale ? VAR_0->field_scan : VAR_0->field_scan_q0;", "}else{", "scan8x8= s->qscale ? VAR_0->zigzag_scan8x8 : VAR_0->zigzag_scan8x8_q0;", "VAR_22= s->qscale ? VAR_0->zigzag_scan : VAR_0->zigzag_scan_q0;", "}", "if(get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[60 + (VAR_0->last_qscale_diff != 0)])){", "int VAR_24 = 1;", "int VAR_25= 2;", "const int VAR_25 = 51 + 6*(VAR_0->sps.bit_depth_luma-8);", "while( get_cabac_noinline( &VAR_0->cabac, &VAR_0->cabac_state[60 + VAR_25] ) ) {", "VAR_25= 3;", "VAR_24++;", "if(VAR_24 > 2*VAR_25){", "av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"cabac decode of qscale diff failed at %d %d\\n\", s->mb_x, s->mb_y);", "}", "}", "if( VAR_24&0x01 )\nVAR_24= (VAR_24 + 1)>>1 ;", "else\nVAR_24= -((VAR_24 + 1)>>1);", "VAR_0->last_qscale_diff = VAR_24;", "s->qscale += VAR_24;", "if(((unsigned)s->qscale) > VAR_25){", "if(s->qscale<0) s->qscale+= VAR_25+1;", "else s->qscale-= VAR_25+1;", "}", "VAR_0->chroma_qp[0] = get_chroma_qp(VAR_0, 0, s->qscale);", "VAR_0->chroma_qp[1] = get_chroma_qp(VAR_0, 1, s->qscale);", "}else", "VAR_0->last_qscale_diff=0;", "decode_cabac_luma_residual(VAR_0, VAR_22, scan8x8, VAR_7, VAR_2, VAR_4, 0);", "if(CHROMA444){", "decode_cabac_luma_residual(VAR_0, VAR_22, scan8x8, VAR_7, VAR_2, VAR_4, 1);", "decode_cabac_luma_residual(VAR_0, VAR_22, scan8x8, VAR_7, VAR_2, VAR_4, 2);", "} else if (CHROMA422) {", "if( VAR_4&0x30 ){", "int VAR_29;", "for( VAR_29 = 0; VAR_29 < 2; VAR_29++ ) {", "decode_cabac_residual_dc_422(VAR_0, VAR_0->mb + ((256 + 16*16*VAR_29) << VAR_7), 3,\nCHROMA_DC_BLOCK_INDEX + VAR_29,\nchroma422_dc_scan, 8);", "}", "}", "if( VAR_4&0x20 ) {", "int VAR_29, VAR_29, VAR_27;", "for( VAR_29 = 0; VAR_29 < 2; VAR_29++ ) {", "DCTELEM *mb = VAR_0->mb + (16*(16 + 16*VAR_29) << VAR_7);", "VAR_23 = VAR_0->dequant4_coeff[VAR_29+1+(IS_INTRA( VAR_2 ) ? 0:3)][VAR_0->chroma_qp[VAR_29]];", "for (VAR_27 = 0; VAR_27 < 2; VAR_27++) {", "for (VAR_29 = 0; VAR_29 < 4; VAR_29++) {", "const int VAR_29 = 16 + 16 * VAR_29 + 8*VAR_27 + VAR_29;", "decode_cabac_residual_nondc(VAR_0, mb, 4, VAR_29, VAR_22 + 1, VAR_23, 15);", "mb += 16<<VAR_7;", "}", "}", "}", "} else {", "fill_rectangle(&VAR_0->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);", "fill_rectangle(&VAR_0->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);", "}", "} else {", "if( VAR_4&0x30 ){", "int VAR_29;", "for( VAR_29 = 0; VAR_29 < 2; VAR_29++ ) {", "decode_cabac_residual_dc(VAR_0, VAR_0->mb + ((256 + 16*16*VAR_29) << VAR_7), 3, CHROMA_DC_BLOCK_INDEX+VAR_29, chroma_dc_scan, 4);", "}", "}", "if( VAR_4&0x20 ) {", "int VAR_29, VAR_29;", "for( VAR_29 = 0; VAR_29 < 2; VAR_29++ ) {", "VAR_23 = VAR_0->dequant4_coeff[VAR_29+1+(IS_INTRA( VAR_2 ) ? 0:3)][VAR_0->chroma_qp[VAR_29]];", "for( VAR_29 = 0; VAR_29 < 4; VAR_29++ ) {", "const int VAR_29 = 16 + 16 * VAR_29 + VAR_29;", "decode_cabac_residual_nondc(VAR_0, VAR_0->mb + (16*VAR_29 << VAR_7), 4, VAR_29, VAR_22 + 1, VAR_23, 15);", "}", "}", "} else {", "fill_rectangle(&VAR_0->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);", "fill_rectangle(&VAR_0->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);", "}", "}", "} else {", "fill_rectangle(&VAR_0->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);", "fill_rectangle(&VAR_0->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);", "fill_rectangle(&VAR_0->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);", "VAR_0->last_qscale_diff = 0;", "}", "s->current_picture.f.qscale_table[VAR_1] = s->qscale;", "write_back_non_zero_count(VAR_0);", "if(MB_MBAFF){", "VAR_0->ref_count[0] >>= 1;", "VAR_0->ref_count[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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 29, 31 ], [ 33, 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79, 81 ], [ 83 ], [ 87 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 103, 105 ], [ 107, 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 175 ], [ 177 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201, 203 ], [ 205 ], [ 207, 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219, 221 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 261 ], [ 265 ], [ 271 ], [ 273 ], [ 277 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 303 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357, 359 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393, 395 ], [ 397 ], [ 399, 401, 403, 405 ], [ 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ], [ 446 ], [ 448 ], [ 450 ], [ 452 ], [ 454 ], [ 456 ], [ 458, 460 ], [ 462 ], [ 464 ], [ 468, 470 ], [ 474 ], [ 476 ], [ 478 ], [ 480 ], [ 482 ], [ 484 ], [ 486 ], [ 490 ], [ 492 ], [ 494 ], [ 496 ], [ 498 ], [ 500 ], [ 502 ], [ 504 ], [ 506 ], [ 508 ], [ 510, 512 ], [ 516 ], [ 518, 520 ], [ 522, 524 ], [ 528, 530 ], [ 532, 534 ], [ 536 ], [ 538 ], [ 540 ], [ 544 ], [ 546 ], [ 548 ], [ 550 ], [ 552 ], [ 556 ], [ 558 ], [ 560 ], [ 562 ], [ 564 ], [ 568 ], [ 570 ], [ 572 ], [ 574 ], [ 576 ], [ 578 ], [ 580 ], [ 582 ], [ 584 ], [ 586 ], [ 588 ], [ 590 ], [ 592 ], [ 594 ], [ 596 ], [ 598 ], [ 600 ], [ 602 ], [ 604 ], [ 606 ], [ 608 ], [ 610 ], [ 612 ], [ 614 ], [ 617 ], [ 619 ], [ 621 ], [ 623 ], [ 625 ], [ 627 ], [ 629 ], [ 631 ], [ 633 ], [ 635 ], [ 637, 639 ], [ 643 ], [ 645 ], [ 647 ], [ 649 ], [ 651 ], [ 653 ], [ 655 ], [ 657 ], [ 659 ], [ 661 ], [ 663 ], [ 665 ], [ 667 ], [ 669 ], [ 672 ], [ 674 ], [ 676 ], [ 678 ], [ 680 ], [ 682 ], [ 684 ], [ 686 ], [ 688 ], [ 690 ], [ 692 ], [ 694 ], [ 696 ], [ 698, 700 ], [ 704 ], [ 706 ], [ 708 ], [ 710 ], [ 712 ], [ 714 ], [ 716 ], [ 718 ], [ 720 ], [ 722 ], [ 724 ], [ 726 ], [ 728 ], [ 730 ], [ 732 ], [ 734 ], [ 736 ], [ 738 ], [ 741 ], [ 743 ], [ 745 ], [ 747 ], [ 749 ], [ 751 ], [ 753 ], [ 755 ], [ 757 ], [ 759 ], [ 761 ], [ 763 ], [ 765 ], [ 767, 771 ], [ 773 ], [ 775 ], [ 777 ], [ 779 ], [ 781 ], [ 783 ], [ 785 ], [ 787 ], [ 789 ], [ 791 ], [ 795 ], [ 797 ], [ 799 ], [ 801 ], [ 805 ], [ 807 ], [ 809, 811 ], [ 813 ], [ 817 ], [ 821 ], [ 823 ], [ 825 ], [ 833 ], [ 835 ], [ 837 ], [ 839 ], [ 841 ], [ 843, 845, 847, 849, 851, 853 ], [ 855 ], [ 857 ], [ 859 ], [ 861 ], [ 863 ], [ 865 ], [ 867 ], [ 869 ], [ 871 ], [ 873 ], [ 877 ], [ 879 ], [ 881 ], [ 885 ], [ 887 ], [ 889 ], [ 891 ], [ 893 ], [ 895 ], [ 897 ], [ 903 ], [ 905 ], [ 907 ], [ 909 ], [ 913 ], [ 915 ], [ 917 ], [ 919 ], [ 921 ], [ 924 ], [ 926 ], [ 930, 932 ], [ 934, 936 ], [ 938 ], [ 940 ], [ 942 ], [ 944 ], [ 946 ], [ 948 ], [ 950 ], [ 952 ], [ 954 ], [ 956 ], [ 960 ], [ 962 ], [ 964 ], [ 966 ], [ 968 ], [ 970 ], [ 972 ], [ 974 ], [ 978, 980, 982 ], [ 984 ], [ 986 ], [ 990 ], [ 992 ], [ 994 ], [ 996 ], [ 998 ], [ 1000 ], [ 1002 ], [ 1004 ], [ 1008 ], [ 1010 ], [ 1012 ], [ 1014 ], [ 1016 ], [ 1018 ], [ 1020 ], [ 1022 ], [ 1024 ], [ 1026 ], [ 1028 ], [ 1030 ], [ 1032 ], [ 1036 ], [ 1038 ], [ 1040 ], [ 1044 ], [ 1046 ], [ 1048 ], [ 1050 ], [ 1052 ], [ 1054 ], [ 1058 ], [ 1060 ], [ 1062 ], [ 1064 ], [ 1066 ], [ 1068 ], [ 1070 ], [ 1072 ], [ 1074 ], [ 1076 ], [ 1078 ], [ 1080 ], [ 1082 ], [ 1084 ], [ 1088 ], [ 1090 ], [ 1094 ], [ 1096 ], [ 1098 ], [ 1100 ], [ 1104 ], [ 1106 ] ]

[ "static inline void FUNC_0(rgb32to15)(const uint8_t *VAR_2, uint8_t *dst, unsigned src_size)\n{", "const uint8_t *VAR_0 = VAR_2;", "const uint8_t *VAR_1;", "#ifdef HAVE_MMX\nconst uint8_t *mm_end;", "#endif\nuint16_t *d = (uint16_t *)dst;", "VAR_1 = VAR_0 + src_size;", "#ifdef HAVE_MMX\nmm_end = VAR_1 - 15;", "#if 1\nasm volatile(\n\"movq %3, %%mm5\t\t\t\\n\\t\"\n\"movq %4, %%mm6\t\t\t\\n\\t\"\n\"movq %5, %%mm7\t\t\t\\n\\t\"\n\".balign 16\t\t\t\\n\\t\"\n\"1:\t\t\t\t\\n\\t\"\nPREFETCH\" 32(%1)\t\t\\n\\t\"\n\"movd\t(%1), %%mm0\t\t\\n\\t\"\n\"movd\t4(%1), %%mm3\t\t\\n\\t\"\n\"punpckldq 8(%1), %%mm0\t\t\\n\\t\"\n\"punpckldq 12(%1), %%mm3\t\\n\\t\"\n\"movq %%mm0, %%mm1\t\t\\n\\t\"\n\"movq %%mm3, %%mm4\t\t\\n\\t\"\n\"pand %%mm6, %%mm0\t\t\\n\\t\"\n\"pand %%mm6, %%mm3\t\t\\n\\t\"\n\"pmaddwd %%mm7, %%mm0\t\t\\n\\t\"\n\"pmaddwd %%mm7, %%mm3\t\t\\n\\t\"\n\"pand %%mm5, %%mm1\t\t\\n\\t\"\n\"pand %%mm5, %%mm4\t\t\\n\\t\"\n\"por %%mm1, %%mm0\t\t\\n\\t\"\n\"por %%mm4, %%mm3\t\t\\n\\t\"\n\"psrld $6, %%mm0\t\t\\n\\t\"\n\"pslld $10, %%mm3\t\t\\n\\t\"\n\"por %%mm3, %%mm0\t\t\\n\\t\"\nMOVNTQ\"\t%%mm0, (%0)\t\t\\n\\t\"\n\"add $16, %1\t\t\t\\n\\t\"\n\"add $8, %0\t\t\t\\n\\t\"\n\"cmp %2, %1\t\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n: \"+r\" (d), \"+r\"(VAR_0)\n: \"r\" (mm_end), \"m\" (mask3215g), \"m\" (mask3216br), \"m\" (mul3215)\n);", "#else\n__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*VAR_2):\"memory\");", "__asm __volatile(\n\"movq\t%0, %%mm7\\n\\t\"\n\"movq\t%1, %%mm6\\n\\t\"\n::\"m\"(red_15mask),\"m\"(green_15mask));", "while(VAR_0 < mm_end)\n{", "__asm __volatile(\nPREFETCH\" 32%1\\n\\t\"\n\"movd\t%1, %%mm0\\n\\t\"\n\"movd\t4%1, %%mm3\\n\\t\"\n\"punpckldq 8%1, %%mm0\\n\\t\"\n\"punpckldq 12%1, %%mm3\\n\\t\"\n\"movq\t%%mm0, %%mm1\\n\\t\"\n\"movq\t%%mm0, %%mm2\\n\\t\"\n\"movq\t%%mm3, %%mm4\\n\\t\"\n\"movq\t%%mm3, %%mm5\\n\\t\"\n\"psrlq\t$3, %%mm0\\n\\t\"\n\"psrlq\t$3, %%mm3\\n\\t\"\n\"pand\t%2, %%mm0\\n\\t\"\n\"pand\t%2, %%mm3\\n\\t\"\n\"psrlq\t$6, %%mm1\\n\\t\"\n\"psrlq\t$6, %%mm4\\n\\t\"\n\"pand\t%%mm6, %%mm1\\n\\t\"\n\"pand\t%%mm6, %%mm4\\n\\t\"\n\"psrlq\t$9, %%mm2\\n\\t\"\n\"psrlq\t$9, %%mm5\\n\\t\"\n\"pand\t%%mm7, %%mm2\\n\\t\"\n\"pand\t%%mm7, %%mm5\\n\\t\"\n\"por\t%%mm1, %%mm0\\n\\t\"\n\"por\t%%mm4, %%mm3\\n\\t\"\n\"por\t%%mm2, %%mm0\\n\\t\"\n\"por\t%%mm5, %%mm3\\n\\t\"\n\"psllq\t$16, %%mm3\\n\\t\"\n\"por\t%%mm3, %%mm0\\n\\t\"\nMOVNTQ\"\t%%mm0, %0\\n\\t\"\n:\"=m\"(*d):\"m\"(*VAR_0),\"m\"(blue_15mask):\"memory\");", "d += 4;", "VAR_0 += 16;", "}", "#endif\n__asm __volatile(SFENCE:::\"memory\");", "__asm __volatile(EMMS:::\"memory\");", "#endif\nwhile(VAR_0 < VAR_1)\n{", "const int VAR_2= *VAR_0; VAR_0 += 4;", "*d++ = ((VAR_2&0xFF)>>3) + ((VAR_2&0xF800)>>6) + ((VAR_2&0xF80000)>>9);", "}", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "MOVMuxContext *mov = VAR_0->priv_data;", "AVIOContext *pb = VAR_0->pb;", "int VAR_1 = 0;", "int VAR_2;", "int64_t moov_pos = avio_tell(pb);", "if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) {", "if (mov->mdat_size + 8 <= UINT32_MAX) {", "avio_seek(pb, mov->mdat_pos, SEEK_SET);", "avio_wb32(pb, mov->mdat_size + 8);", "} else {", "avio_seek(pb, mov->mdat_pos - 8, SEEK_SET);", "avio_wb32(pb, 1);", "ffio_wfourcc(pb, \"mdat\");", "avio_wb64(pb, mov->mdat_size + 16);", "}", "avio_seek(pb, mov->reserved_moov_size ? mov->reserved_moov_pos : moov_pos, SEEK_SET);", "mov_write_moov_tag(pb, mov, VAR_0);", "if(mov->reserved_moov_size){", "int64_t size= mov->reserved_moov_size - (avio_tell(pb) - mov->reserved_moov_pos);", "if(size < 8){", "av_log(VAR_0, AV_LOG_ERROR, \"reserved_moov_size is too small, needed %\"PRId64\" additional\\n\", 8-size);", "return -1;", "}", "avio_wb32(pb, size);", "ffio_wfourcc(pb, \"free\");", "for(VAR_2=0; VAR_2<size; VAR_2++)", "avio_w8(pb, 0);", "avio_seek(pb, moov_pos, SEEK_SET);", "}", "} else {", "mov_flush_fragment(VAR_0);", "mov_write_mfra_tag(pb, mov);", "}", "if (mov->chapter_track)\nav_freep(&mov->tracks[mov->chapter_track].enc);", "for (VAR_2=0; VAR_2<mov->nb_streams; VAR_2++) {", "if (mov->tracks[VAR_2].tag == MKTAG('r','t','p',' '))\nff_mov_close_hinting(&mov->tracks[VAR_2]);", "else if (mov->tracks[VAR_2].tag == MKTAG('t','m','c','d'))\nav_freep(&mov->tracks[VAR_2].enc);", "if (mov->flags & FF_MOV_FLAG_FRAGMENT &&\nmov->tracks[VAR_2].vc1_info.struct_offset && VAR_0->pb->seekable) {", "int64_t off = avio_tell(pb);", "uint8_t buf[7];", "if (mov_write_dvc1_structs(&mov->tracks[VAR_2], buf) >= 0) {", "avio_seek(pb, mov->tracks[VAR_2].vc1_info.struct_offset, SEEK_SET);", "avio_write(pb, buf, 7);", "avio_seek(pb, off, SEEK_SET);", "}", "}", "av_freep(&mov->tracks[VAR_2].cluster);", "av_freep(&mov->tracks[VAR_2].frag_info);", "if (mov->tracks[VAR_2].vos_len)\nav_free(mov->tracks[VAR_2].vos_data);", "}", "avio_flush(pb);", "av_freep(&mov->tracks);", "return VAR_1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 87, 89 ], [ 93 ], [ 95, 97 ], [ 99, 101 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129, 131 ], [ 135 ], [ 139 ], [ 143 ], [ 147 ], [ 149 ] ]

[ "static void FUNC_0(AVCodecContext *VAR_0,\nconst uint8_t *VAR_1, int VAR_2)\n{", "DVBSubContext *ctx = VAR_0->priv_data;", "const uint8_t *VAR_3 = VAR_1 + VAR_2;", "int VAR_4, VAR_5;", "int VAR_6 version;", "DVBSubRegion *region;", "DVBSubObject *object;", "DVBSubObjectDisplay *display;", "int VAR_7;", "if (VAR_2 < 10)\nVAR_4 = *VAR_1++;", "region = get_region(ctx, VAR_4);", "if (!region) {", "region = av_mallocz(sizeof(DVBSubRegion));", "region->id = VAR_4;", "region->version = -1;", "region->next = ctx->region_list;", "ctx->region_list = region;", "}", "version = ((*VAR_1)>>4) & 15;", "VAR_7 = ((*VAR_1++) >> 3) & 1;", "region->width = AV_RB16(VAR_1);", "VAR_1 += 2;", "region->height = AV_RB16(VAR_1);", "VAR_1 += 2;", "if (region->width * region->height != region->VAR_2) {", "av_free(region->pbuf);", "region->VAR_2 = region->width * region->height;", "region->pbuf = av_malloc(region->VAR_2);", "VAR_7 = 1;", "region->dirty = 0;", "}", "region->depth = 1 << (((*VAR_1++) >> 2) & 7);", "if(region->depth<2 || region->depth>8){", "av_log(VAR_0, AV_LOG_ERROR, \"region depth %d is invalid\\n\", region->depth);", "region->depth= 4;", "}", "region->clut = *VAR_1++;", "if (region->depth == 8) {", "region->bgcolor = *VAR_1++;", "VAR_1 += 1;", "} else {", "VAR_1 += 1;", "if (region->depth == 4)\nregion->bgcolor = (((*VAR_1++) >> 4) & 15);", "else\nregion->bgcolor = (((*VAR_1++) >> 2) & 3);", "}", "av_dlog(VAR_0, \"Region %d, (%dx%d)\\n\", VAR_4, region->width, region->height);", "if (VAR_7) {", "memset(region->pbuf, region->bgcolor, region->VAR_2);", "av_dlog(VAR_0, \"Fill region (%d)\\n\", region->bgcolor);", "}", "delete_region_display_list(ctx, region);", "while (VAR_1 + 5 < VAR_3) {", "VAR_5 = AV_RB16(VAR_1);", "VAR_1 += 2;", "object = get_object(ctx, VAR_5);", "if (!object) {", "object = av_mallocz(sizeof(DVBSubObject));", "object->id = VAR_5;", "object->next = ctx->object_list;", "ctx->object_list = object;", "}", "object->type = (*VAR_1) >> 6;", "display = av_mallocz(sizeof(DVBSubObjectDisplay));", "display->VAR_5 = VAR_5;", "display->VAR_4 = VAR_4;", "display->x_pos = AV_RB16(VAR_1) & 0xfff;", "VAR_1 += 2;", "display->y_pos = AV_RB16(VAR_1) & 0xfff;", "VAR_1 += 2;", "if ((object->type == 1 || object->type == 2) && VAR_1+1 < VAR_3) {", "display->fgcolor = *VAR_1++;", "display->bgcolor = *VAR_1++;", "}", "display->region_list_next = region->display_list;", "region->display_list = display;", "display->object_list_next = object->display_list;", "object->display_list = display;", "}", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 32 ], [ 36 ], [ 40 ], [ 42 ], [ 48 ], [ 50 ], [ 54 ], [ 56 ], [ 58 ], [ 62 ], [ 64 ], [ 68 ], [ 70 ], [ 72 ], [ 74 ], [ 78 ], [ 80 ], [ 84 ], [ 88 ], [ 92 ], [ 94 ], [ 96 ], [ 100 ], [ 102 ], [ 104 ], [ 106 ], [ 108 ], [ 110 ], [ 114 ], [ 116 ], [ 118 ], [ 120 ], [ 122 ], [ 126, 128 ], [ 130, 132 ], [ 134 ], [ 138 ], [ 142 ], [ 144 ], [ 146 ], [ 148 ], [ 152 ], [ 156 ], [ 158 ], [ 160 ], [ 164 ], [ 168 ], [ 170 ], [ 174 ], [ 176 ], [ 178 ], [ 180 ], [ 184 ], [ 188 ], [ 192 ], [ 194 ], [ 198 ], [ 200 ], [ 202 ], [ 204 ], [ 208 ], [ 210 ], [ 212 ], [ 214 ], [ 218 ], [ 220 ], [ 224 ], [ 226 ], [ 228 ], [ 230 ] ]

[ "static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,\nV9fsPath *VAR_2, const char *VAR_3)\n{", "int VAR_4;", "V9fsString newpath;", "char *VAR_5, *VAR_6;", "int VAR_7;", "v9fs_string_init(&newpath);", "v9fs_string_sprintf(&newpath, \"%s/%s\", VAR_2->data, VAR_3);", "VAR_5 = rpath(VAR_0, VAR_1->data);", "VAR_6 = rpath(VAR_0, newpath.data);", "VAR_4 = link(VAR_5, VAR_6);", "g_free(VAR_5);", "if (VAR_4 < 0) {", "goto out;", "}", "if (VAR_0->export_flags & V9FS_SM_MAPPED_FILE) {", "char *VAR_8, *VAR_9;", "VAR_4 = local_create_mapped_attr_dir(VAR_0, newpath.data);", "if (VAR_4 < 0) {", "goto err_out;", "}", "VAR_8 = local_mapped_attr_path(VAR_0, VAR_1->data);", "VAR_9 = local_mapped_attr_path(VAR_0, newpath.data);", "VAR_4 = link(VAR_8, VAR_9);", "g_free(VAR_8);", "g_free(VAR_9);", "if (VAR_4 < 0 && errno != ENOENT) {", "goto err_out;", "}", "}", "goto out;", "err_out:\nVAR_7 = errno;", "remove(VAR_6);", "errno = VAR_7;", "out:\ng_free(VAR_6);", "v9fs_string_free(&newpath);", "return VAR_4;", "}" ]

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

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

[ "static int FUNC_0(StringInputVisitor *VAR_0, const char *VAR_1, Error **VAR_2)\n{", "char *VAR_3 = (char *) VAR_0->string;", "long long VAR_4, VAR_5;", "Range *cur;", "char *VAR_6;", "if (VAR_0->ranges) {", "return 0;", "}", "do {", "errno = 0;", "VAR_4 = strtoll(VAR_3, &VAR_6, 0);", "if (errno == 0 && VAR_6 > VAR_3) {", "if (*VAR_6 == '\\0') {", "cur = g_malloc0(sizeof(*cur));", "cur->begin = VAR_4;", "cur->VAR_5 = VAR_4 + 1;", "VAR_0->ranges = g_list_insert_sorted_merged(VAR_0->ranges, cur,\nrange_compare);", "cur = NULL;", "VAR_3 = NULL;", "} else if (*VAR_6 == '-') {", "VAR_3 = VAR_6 + 1;", "errno = 0;", "VAR_5 = strtoll(VAR_3, &VAR_6, 0);", "if (errno == 0 && VAR_6 > VAR_3 && VAR_4 <= VAR_5 &&\n(VAR_4 > INT64_MAX - 65536 ||\nVAR_5 < VAR_4 + 65536)) {", "if (*VAR_6 == '\\0') {", "cur = g_malloc0(sizeof(*cur));", "cur->begin = VAR_4;", "cur->VAR_5 = VAR_5 + 1;", "VAR_0->ranges =\ng_list_insert_sorted_merged(VAR_0->ranges,\ncur,\nrange_compare);", "cur = NULL;", "VAR_3 = NULL;", "} else if (*VAR_6 == ',') {", "VAR_3 = VAR_6 + 1;", "cur = g_malloc0(sizeof(*cur));", "cur->begin = VAR_4;", "cur->VAR_5 = VAR_5 + 1;", "VAR_0->ranges =\ng_list_insert_sorted_merged(VAR_0->ranges,\ncur,\nrange_compare);", "cur = NULL;", "} else {", "goto error;", "}", "} else {", "goto error;", "}", "} else if (*VAR_6 == ',') {", "VAR_3 = VAR_6 + 1;", "cur = g_malloc0(sizeof(*cur));", "cur->begin = VAR_4;", "cur->VAR_5 = VAR_4 + 1;", "VAR_0->ranges = g_list_insert_sorted_merged(VAR_0->ranges,\ncur,\nrange_compare);", "cur = NULL;", "} else {", "goto error;", "}", "} else {", "goto error;", "}", "} while (VAR_3);", "return 0;", "error:\ng_list_foreach(VAR_0->ranges, free_range, NULL);", "g_list_free(VAR_0->ranges);", "VAR_0->ranges = NULL;", "error_setg(VAR_2, QERR_INVALID_PARAMETER_VALUE, VAR_1 ? VAR_1 : \"null\",\n\"an int64 value or range\");", "return -1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39, 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69, 71, 73, 75 ], [ 77 ], [ 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 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 157, 159 ], [ 161 ], [ 163 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "ADPCMEncodeContext *s = avctx->priv_data;", "uint8_t *extradata;", "int VAR_0;", "if (avctx->channels > 2)\nreturn -1;", "if (avctx->trellis && (unsigned)avctx->trellis > 16U) {", "av_log(avctx, AV_LOG_ERROR, \"invalid trellis size\\n\");", "return -1;", "}", "if (avctx->trellis) {", "int VAR_1 = 1 << avctx->trellis;", "int VAR_2 = VAR_1 * FREEZE_INTERVAL;", "FF_ALLOC_OR_GOTO(avctx, s->paths,\nVAR_2 * sizeof(*s->paths), error);", "FF_ALLOC_OR_GOTO(avctx, s->node_buf,\n2 * VAR_1 * sizeof(*s->node_buf), error);", "FF_ALLOC_OR_GOTO(avctx, s->nodep_buf,\n2 * VAR_1 * sizeof(*s->nodep_buf), error);", "FF_ALLOC_OR_GOTO(avctx, s->trellis_hash,\n65536 * sizeof(*s->trellis_hash), error);", "}", "avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);", "switch (avctx->codec->id) {", "case CODEC_ID_ADPCM_IMA_WAV:\navctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 /\n(4 * avctx->channels) + 1;", "avctx->block_align = BLKSIZE;", "avctx->bits_per_coded_sample = 4;", "break;", "case CODEC_ID_ADPCM_IMA_QT:\navctx->frame_size = 64;", "avctx->block_align = 34 * avctx->channels;", "break;", "case CODEC_ID_ADPCM_MS:\navctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2;", "avctx->block_align = BLKSIZE;", "avctx->bits_per_coded_sample = 4;", "avctx->extradata_size = 32;", "extradata = avctx->extradata = av_malloc(avctx->extradata_size);", "if (!extradata)\nreturn AVERROR(ENOMEM);", "bytestream_put_le16(&extradata, avctx->frame_size);", "bytestream_put_le16(&extradata, 7);", "for (VAR_0 = 0; VAR_0 < 7; VAR_0++) {", "bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff1[VAR_0] * 4);", "bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff2[VAR_0] * 4);", "}", "break;", "case CODEC_ID_ADPCM_YAMAHA:\navctx->frame_size = BLKSIZE * avctx->channels;", "avctx->block_align = BLKSIZE;", "break;", "case CODEC_ID_ADPCM_SWF:\nif (avctx->sample_rate != 11025 &&\navctx->sample_rate != 22050 &&\navctx->sample_rate != 44100) {", "av_log(avctx, AV_LOG_ERROR, \"Sample rate must be 11025, \"\n\"22050 or 44100\\n\");", "goto error;", "}", "avctx->frame_size = 512 * (avctx->sample_rate / 11025);", "break;", "default:\ngoto error;", "}", "avctx->coded_frame = avcodec_alloc_frame();", "avctx->coded_frame->key_frame= 1;", "return 0;", "error:\nav_freep(&s->paths);", "av_freep(&s->node_buf);", "av_freep(&s->nodep_buf);", "av_freep(&s->trellis_hash);", "return -1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11, 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 37, 39 ], [ 41, 43 ], [ 45, 47 ], [ 49 ], [ 53 ], [ 57 ], [ 59, 65, 67 ], [ 73 ], [ 75 ], [ 77 ], [ 79, 81 ], [ 83 ], [ 85 ], [ 87, 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 ], [ 157 ], [ 159 ], [ 163 ], [ 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ] ]

[ "void *FUNC_0(target_phys_addr_t VAR_0, int VAR_1)\n{", "struct fs_dma_ctrl *VAR_2 = NULL;", "VAR_2 = g_malloc0(sizeof *VAR_2);", "VAR_2->bh = qemu_bh_new(DMA_run, VAR_2);", "VAR_2->VAR_1 = VAR_1;", "VAR_2->channels = g_malloc0(sizeof VAR_2->channels[0] * VAR_1);", "memory_region_init_io(&VAR_2->mmio, &dma_ops, VAR_2, \"etraxfs-dma\",\nVAR_1 * 0x2000);", "memory_region_add_subregion(get_system_memory(), VAR_0, &VAR_2->mmio);", "return VAR_2;", "}" ]

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

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

[ "static inline void FUNC_0(DisasContext *VAR_0, int VAR_1)\n{", "int VAR_2;", "VAR_2 = gen_new_label();", "tcg_gen_brcond_tl(VAR_1, cpu_R[VAR_0->r0], cpu_R[VAR_0->r1], VAR_2);", "gen_goto_tb(VAR_0, 0, VAR_0->pc + 4);", "gen_set_label(VAR_2);", "gen_goto_tb(VAR_0, 1, VAR_0->pc + (sign_extend(VAR_0->imm16 << 2, 16)));", "VAR_0->is_jmp = DISAS_TB_JUMP;", "}" ]

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

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

[ "static void FUNC_0(sws_init_swScale)(SwsContext *c)\n{", "enum PixelFormat VAR_0 = c->VAR_0;", "if (!(c->flags & SWS_BITEXACT)) {", "if (c->flags & SWS_ACCURATE_RND) {", "c->yuv2yuv1 = FUNC_0(yuv2yuv1_ar );", "c->yuv2yuvX = FUNC_0(yuv2yuvX_ar );", "switch (c->dstFormat) {", "case PIX_FMT_RGB32: c->yuv2packedX = FUNC_0(yuv2rgb32_X_ar); break;", "case PIX_FMT_BGR24: c->yuv2packedX = FUNC_0(yuv2bgr24_X_ar); break;", "case PIX_FMT_RGB555: c->yuv2packedX = FUNC_0(yuv2rgb555_X_ar); break;", "case PIX_FMT_RGB565: c->yuv2packedX = FUNC_0(yuv2rgb565_X_ar); break;", "case PIX_FMT_YUYV422: c->yuv2packedX = FUNC_0(yuv2yuyv422_X_ar); break;", "default: break;", "}", "} else {", "c->yuv2yuv1 = FUNC_0(yuv2yuv1 );", "c->yuv2yuvX = FUNC_0(yuv2yuvX );", "switch (c->dstFormat) {", "case PIX_FMT_RGB32: c->yuv2packedX = FUNC_0(yuv2rgb32_X); break;", "case PIX_FMT_BGR24: c->yuv2packedX = FUNC_0(yuv2bgr24_X); break;", "case PIX_FMT_RGB555: c->yuv2packedX = FUNC_0(yuv2rgb555_X); break;", "case PIX_FMT_RGB565: c->yuv2packedX = FUNC_0(yuv2rgb565_X); break;", "case PIX_FMT_YUYV422: c->yuv2packedX = FUNC_0(yuv2yuyv422_X); break;", "default: break;", "}", "}", "switch (c->dstFormat) {", "case PIX_FMT_RGB32:\nc->yuv2packed1 = FUNC_0(yuv2rgb32_1);", "c->yuv2packed2 = FUNC_0(yuv2rgb32_2);", "break;", "case PIX_FMT_BGR24:\nc->yuv2packed1 = FUNC_0(yuv2bgr24_1);", "c->yuv2packed2 = FUNC_0(yuv2bgr24_2);", "break;", "case PIX_FMT_RGB555:\nc->yuv2packed1 = FUNC_0(yuv2rgb555_1);", "c->yuv2packed2 = FUNC_0(yuv2rgb555_2);", "break;", "case PIX_FMT_RGB565:\nc->yuv2packed1 = FUNC_0(yuv2rgb565_1);", "c->yuv2packed2 = FUNC_0(yuv2rgb565_2);", "break;", "case PIX_FMT_YUYV422:\nc->yuv2packed1 = FUNC_0(yuv2yuyv422_1);", "c->yuv2packed2 = FUNC_0(yuv2yuyv422_2);", "break;", "default:\nbreak;", "}", "}", "#if !COMPILE_TEMPLATE_MMX2\nc->hScale = FUNC_0(hScale );", "#endif\n#if COMPILE_TEMPLATE_MMX2\nif (c->flags & SWS_FAST_BILINEAR && c->canMMX2BeUsed)\n{", "c->hyscale_fast = FUNC_0(hyscale_fast);", "c->hcscale_fast = FUNC_0(hcscale_fast);", "} else {", "#endif\nc->hyscale_fast = NULL;", "c->hcscale_fast = NULL;", "#if COMPILE_TEMPLATE_MMX2\n}", "#endif\n#if !COMPILE_TEMPLATE_MMX2\nswitch(VAR_0) {", "case PIX_FMT_YUYV422 : c->chrToYV12 = FUNC_0(yuy2ToUV); break;", "case PIX_FMT_UYVY422 : c->chrToYV12 = FUNC_0(uyvyToUV); break;", "case PIX_FMT_NV12 : c->chrToYV12 = FUNC_0(nv12ToUV); break;", "case PIX_FMT_NV21 : c->chrToYV12 = FUNC_0(nv21ToUV); break;", "case PIX_FMT_GRAY16LE :\ncase PIX_FMT_YUV420P9LE:\ncase PIX_FMT_YUV422P10LE:\ncase PIX_FMT_YUV420P10LE:\ncase PIX_FMT_YUV420P16LE:\ncase PIX_FMT_YUV422P16LE:\ncase PIX_FMT_YUV444P16LE: c->hScale16= FUNC_0(hScale16); break;", "}", "#endif\nif (!c->chrSrcHSubSample) {", "switch(VAR_0) {", "case PIX_FMT_BGR24 : c->chrToYV12 = FUNC_0(bgr24ToUV); break;", "case PIX_FMT_RGB24 : c->chrToYV12 = FUNC_0(rgb24ToUV); break;", "default: break;", "}", "}", "switch (VAR_0) {", "#if !COMPILE_TEMPLATE_MMX2\ncase PIX_FMT_YUYV422 :\ncase PIX_FMT_Y400A :\nc->lumToYV12 = FUNC_0(yuy2ToY); break;", "case PIX_FMT_UYVY422 :\nc->lumToYV12 = FUNC_0(uyvyToY); break;", "#endif\ncase PIX_FMT_BGR24 : c->lumToYV12 = FUNC_0(bgr24ToY); break;", "case PIX_FMT_RGB24 : c->lumToYV12 = FUNC_0(rgb24ToY); break;", "default: break;", "}", "#if !COMPILE_TEMPLATE_MMX2\nif (c->alpPixBuf) {", "switch (VAR_0) {", "case PIX_FMT_Y400A : c->alpToYV12 = FUNC_0(yuy2ToY); break;", "default: break;", "}", "}", "#endif\nif(isAnyRGB(c->VAR_0))\nc->hScale16= FUNC_0(hScale16);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 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 ], [ 109, 111 ], [ 113, 119, 121, 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131, 133 ], [ 135 ], [ 137, 139 ], [ 141, 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157, 159, 161, 163, 165, 167, 169 ], [ 171 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 191 ], [ 193, 195, 197, 199 ], [ 201, 203 ], [ 205, 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215, 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229, 231, 233 ], [ 235 ] ]

[ "static void FUNC_0(struct tftp_t *VAR_0, int VAR_1)\n{", "struct tftp_session *VAR_2;", "int VAR_3, VAR_4, VAR_5;", "u_int8_t *src, *dst;", "VAR_3 = tftp_session_allocate(VAR_0);", "if (VAR_3 < 0) {", "return;", "}", "VAR_2 = &tftp_sessions[VAR_3];", "src = VAR_0->x.tp_buf;", "dst = VAR_2->filename;", "VAR_5 = VAR_1 - ((uint8_t *)&VAR_0->x.tp_buf[0] - (uint8_t *)VAR_0);", "for (VAR_4 = 0; VAR_4 < VAR_5; VAR_4++) {", "if (VAR_4 < TFTP_FILENAME_MAX) {", "dst[VAR_4] = src[VAR_4];", "}", "else {", "return;", "}", "if (src[VAR_4] == '\\0') {", "break;", "}", "}", "if (VAR_4 >= VAR_5) {", "return;", "}", "VAR_4++;", "if ((VAR_5 - VAR_4) < 6) {", "return;", "}", "if (memcmp(&src[VAR_4], \"octet\\0\", 6) != 0) {", "tftp_send_error(VAR_2, 4, \"Unsupported transfer mode\", VAR_0);", "return;", "}", "VAR_4 += 6;", "if ((VAR_2->filename[0] != '/')\n|| (VAR_2->filename[strlen((char *)VAR_2->filename) - 1] == '/')\n|| strstr((char *)VAR_2->filename, \"/../\")) {", "tftp_send_error(VAR_2, 2, \"Access violation\", VAR_0);", "return;", "}", "if (!tftp_prefix) {", "tftp_send_error(VAR_2, 2, \"Access violation\", VAR_0);", "return;", "}", "if (tftp_read_data(VAR_2, 0, VAR_2->filename, 0) < 0) {", "tftp_send_error(VAR_2, 1, \"File not found\", VAR_0);", "return;", "}", "if (src[VAR_5 - 1] != 0) {", "tftp_send_error(VAR_2, 2, \"Access violation\", VAR_0);", "return;", "}", "while (VAR_4 < VAR_5) {", "const char *VAR_6, *VAR_7;", "VAR_6 = (char *)src + VAR_4;", "VAR_4 += strlen(VAR_6) + 1;", "if (VAR_4 >= VAR_5) {", "tftp_send_error(VAR_2, 2, \"Access violation\", VAR_0);", "return;", "}", "VAR_7 = (char *)src + VAR_4;", "VAR_4 += strlen(VAR_7) + 1;", "if (strcmp(VAR_6, \"VAR_8\") == 0) {", "int VAR_8 = atoi(VAR_7);", "struct stat VAR_9;", "if (VAR_8 == 0 && tftp_prefix) {", "char VAR_10[1024];", "int VAR_11;", "VAR_11 = snprintf(VAR_10, sizeof(VAR_10), \"%VAR_3/%VAR_3\",\ntftp_prefix, VAR_2->filename);", "if (stat(VAR_10, &VAR_9) == 0)\nVAR_8 = VAR_9.st_size;", "else {", "tftp_send_error(VAR_2, 1, \"File not found\", VAR_0);", "return;", "}", "}", "tftp_send_oack(VAR_2, \"VAR_8\", VAR_8, VAR_0);", "}", "}", "tftp_send_data(VAR_2, 1, 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 107, 109, 111 ], [ 113 ], [ 115 ], [ 117 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ], [ 199 ], [ 203, 205 ], [ 209, 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 225 ], [ 227 ], [ 229 ], [ 233 ], [ 235 ] ]

[ "static int FUNC_0 (WAVEFORMATEX *VAR_0, audsettings_t *VAR_1)\n{", "if (VAR_0->wFormatTag != WAVE_FORMAT_PCM) {", "dolog (\"Invalid wave format, tag is not PCM, but %d\\n\",\nVAR_0->wFormatTag);", "return -1;", "}", "if (!VAR_0->nSamplesPerSec) {", "dolog (\"Invalid wave format, frequency is zero\\n\");", "return -1;", "}", "VAR_1->freq = VAR_0->nSamplesPerSec;", "switch (VAR_0->nChannels) {", "case 1:\nVAR_1->nchannels = 1;", "break;", "case 2:\nVAR_1->nchannels = 2;", "break;", "default:\ndolog (\n\"Invalid wave format, number of channels is not 1 or 2, but %d\\n\",\nVAR_0->nChannels\n);", "return -1;", "}", "switch (VAR_0->wBitsPerSample) {", "case 8:\nVAR_1->fmt = AUD_FMT_U8;", "break;", "case 16:\nVAR_1->fmt = AUD_FMT_S16;", "break;", "case 32:\nVAR_1->fmt = AUD_FMT_S32;", "break;", "default:\ndolog (\"Invalid wave format, bits per sample is not \"\n\"8, 16 or 32, but %d\\n\",\nVAR_0->wBitsPerSample);", "return -1;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7, 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 39, 41 ], [ 43 ], [ 47, 49, 51, 53, 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 73, 75 ], [ 77 ], [ 81, 83 ], [ 85 ], [ 89, 91, 93, 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ] ]

[ "void FUNC_0(uint8_t VAR_0, uint8_t VAR_1, int VAR_2, uint16_t VAR_3)\n{", "CrwContainer *crw_cont;", "trace_css_crw(VAR_0, VAR_1, VAR_3, VAR_2 ? \"(chained)\" : \"\");", "crw_cont = g_try_malloc0(sizeof(CrwContainer));", "if (!crw_cont) {", "channel_subsys.crws_lost = true;", "return;", "}", "crw_cont->crw.flags = (VAR_0 << 8) | VAR_1;", "if (VAR_2) {", "crw_cont->crw.flags |= CRW_FLAGS_MASK_C;", "}", "crw_cont->crw.VAR_3 = VAR_3;", "if (channel_subsys.crws_lost) {", "crw_cont->crw.flags |= CRW_FLAGS_MASK_R;", "channel_subsys.crws_lost = false;", "}", "QTAILQ_INSERT_TAIL(&channel_subsys.pending_crws, crw_cont, sibling);", "if (channel_subsys.do_crw_mchk) {", "channel_subsys.do_crw_mchk = false;", "s390_crw_mchk();", "}", "}" ]

[ 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 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ] ]

[ "static int FUNC_0(void *VAR_0)\n{", "QEMUFileBuffered *s = VAR_0;", "return qemu_get_fd(s->file);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "size_t FUNC_0(QEMUFile *f)\n{", "if (f->get_rate_limit)\nreturn f->get_rate_limit(f->opaque);", "return 0;", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static uint8_t *FUNC_0(struct csrhci_s *s, int len)\n{", "int VAR_0 = s->out_start + s->out_len;", "s->out_len += len;", "if (VAR_0 < FIFO_LEN) {", "if (VAR_0 + len > FIFO_LEN && (s->out_size = VAR_0 + len) > FIFO_LEN * 2) {", "fprintf(stderr, \"%s: can't alloc %i bytes\\n\", __func__, len);", "exit(-1);", "}", "return s->outfifo + VAR_0;", "}", "if (s->out_len > s->out_size) {", "fprintf(stderr, \"%s: can't alloc %i bytes\\n\", __func__, len);", "exit(-1);", "}", "return s->outfifo + VAR_0 - s->out_size;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "QemuOpts *opts;", "DummyObject *dobj;", "Error *err = NULL;", "const char *VAR_0 = TYPE_DUMMY \\\n\",id=dev0,\" \\\n\"bv=yes,sv=Hiss hiss hiss,av=platypus\";", "qemu_add_opts(&qemu_object_opts);", "opts = qemu_opts_parse(&qemu_object_opts, VAR_0, true, &err);", "g_assert(err == NULL);", "g_assert(opts);", "dobj = DUMMY_OBJECT(user_creatable_add_opts(opts, &err));", "g_assert(err == NULL);", "g_assert(dobj);", "g_assert_cmpstr(dobj->sv, ==, \"Hiss hiss hiss\");", "g_assert(dobj->bv == true);", "g_assert(dobj->av == DUMMY_PLATYPUS);", "user_creatable_del(\"dev0\", &err);", "g_assert(err == NULL);", "error_free(err);", "}" ]

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

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

[ "static void FUNC_0(ram_addr_t VAR_0, int VAR_1,\nconst char *VAR_2, DisplayState *VAR_3,\nconst char *VAR_4, const char *VAR_5,\nconst char *VAR_6, const char *VAR_7)\n{", "CPUState *env;", "qemu_irq *pic;", "int VAR_8;", "int VAR_9;", "unsigned long VAR_10;", "if (!VAR_7)\nVAR_7 = \"arm926\";", "env = cpu_init(VAR_7);", "if (!env) {", "fprintf(stderr, \"Unable to find CPU definition\\n\");", "exit(1);", "}", "pic = arm_pic_init_cpu(env);", "cpu_register_physical_memory(0, MP_RAM_DEFAULT_SIZE,\nqemu_ram_alloc(MP_RAM_DEFAULT_SIZE));", "sram_off = qemu_ram_alloc(MP_SRAM_SIZE);", "cpu_register_physical_memory(MP_SRAM_BASE, MP_SRAM_SIZE, sram_off);", "VAR_9 = cpu_register_io_memory(0, musicpal_readfn,\nmusicpal_writefn, env);", "cpu_register_physical_memory(0x80000000, 0x10000, VAR_9);", "pic = mv88w8618_pic_init(MP_PIC_BASE, pic[ARM_PIC_CPU_IRQ]);", "mv88w8618_pit_init(MP_PIT_BASE, pic, MP_TIMER1_IRQ);", "if (serial_hds[0])\nserial_mm_init(MP_UART1_BASE, 2, pic[MP_UART1_IRQ], 1825000,\nserial_hds[0], 1);", "if (serial_hds[1])\nserial_mm_init(MP_UART2_BASE, 2, pic[MP_UART2_IRQ], 1825000,\nserial_hds[1], 1);", "VAR_8 = drive_get_index(IF_PFLASH, 0, 0);", "if (VAR_8 != -1) {", "VAR_10 = bdrv_getlength(drives_table[VAR_8].bdrv);", "if (VAR_10 != 8*1024*1024 && VAR_10 != 16*1024*1024 &&\nVAR_10 != 32*1024*1024) {", "fprintf(stderr, \"Invalid flash image size\\n\");", "exit(1);", "}", "pflash_cfi02_register(0-MP_FLASH_SIZE_MAX, qemu_ram_alloc(VAR_10),\ndrives_table[VAR_8].bdrv, 0x10000,\n(VAR_10 + 0xffff) >> 16,\nMP_FLASH_SIZE_MAX / VAR_10,\n2, 0x00BF, 0x236D, 0x0000, 0x0000,\n0x5555, 0x2AAA);", "}", "mv88w8618_flashcfg_init(MP_FLASHCFG_BASE);", "musicpal_lcd_init(VAR_3, MP_LCD_BASE);", "qemu_add_kbd_event_handler(musicpal_key_event, pic[MP_GPIO_IRQ]);", "sleep(1);", "mv88w8618_eth_init(&nd_table[0], MP_ETH_BASE, pic[MP_ETH_IRQ]);", "mixer_i2c = musicpal_audio_init(MP_AUDIO_BASE, pic[MP_AUDIO_IRQ]);", "musicpal_binfo.VAR_0 = MP_RAM_DEFAULT_SIZE;", "musicpal_binfo.VAR_4 = VAR_4;", "musicpal_binfo.VAR_5 = VAR_5;", "musicpal_binfo.VAR_6 = VAR_6;", "arm_load_kernel(env, &musicpal_binfo);", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 45, 47 ], [ 51 ], [ 53 ], [ 59, 61 ], [ 63 ], [ 67 ], [ 69 ], [ 73, 75, 77 ], [ 79, 81, 83 ], [ 89 ], [ 91 ], [ 93 ], [ 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 117, 119, 121, 123, 125, 127 ], [ 129 ], [ 131 ], [ 135 ], [ 139 ], [ 151 ], [ 155 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ] ]

[ "void FUNC_0(CPUX86State *VAR_0)\n{", "if (VAR_0->sysenter_cs == 0) {", "raise_exception_err(VAR_0, EXCP0D_GPF, 0);", "}", "VAR_0->eflags &= ~(VM_MASK | IF_MASK | RF_MASK);", "cpu_x86_set_cpl(VAR_0, 0);", "#ifdef TARGET_X86_64\nif (VAR_0->hflags & HF_LMA_MASK) {", "cpu_x86_load_seg_cache(VAR_0, R_CS, VAR_0->sysenter_cs & 0xfffc,\n0, 0xffffffff,\nDESC_G_MASK | DESC_B_MASK | DESC_P_MASK |\nDESC_S_MASK |\nDESC_CS_MASK | DESC_R_MASK | DESC_A_MASK |\nDESC_L_MASK);", "} else", "#endif\n{", "cpu_x86_load_seg_cache(VAR_0, R_CS, VAR_0->sysenter_cs & 0xfffc,\n0, 0xffffffff,\nDESC_G_MASK | DESC_B_MASK | DESC_P_MASK |\nDESC_S_MASK |\nDESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);", "}", "cpu_x86_load_seg_cache(VAR_0, R_SS, (VAR_0->sysenter_cs + 8) & 0xfffc,\n0, 0xffffffff,\nDESC_G_MASK | DESC_B_MASK | DESC_P_MASK |\nDESC_S_MASK |\nDESC_W_MASK | DESC_A_MASK);", "VAR_0->regs[R_ESP] = VAR_0->sysenter_esp;", "VAR_0->eip = VAR_0->sysenter_eip;", "}" ]

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

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

[ "int FUNC_0(BlockDriverState *VAR_0,\nconst char *VAR_1,\nError **VAR_2)\n{", "int VAR_3;", "Error *local_err = NULL;", "VAR_3 = bdrv_snapshot_load_tmp(VAR_0, VAR_1, NULL, &local_err);", "if (VAR_3 == -ENOENT || VAR_3 == -EINVAL) {", "error_free(local_err);", "local_err = NULL;", "VAR_3 = bdrv_snapshot_load_tmp(VAR_0, NULL, VAR_1, &local_err);", "}", "if (local_err) {", "error_propagate(VAR_2, local_err);", "}", "return VAR_3;", "}" ]

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

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

[ "void FUNC_0(VncState *VAR_0)\n{", "VAR_0->initialized = true;", "VncDisplay *vd = VAR_0->vd;", "bool first_client = QTAILQ_EMPTY(&vd->clients);", "VAR_0->last_x = -1;", "VAR_0->last_y = -1;", "VAR_0->as.freq = 44100;", "VAR_0->as.nchannels = 2;", "VAR_0->as.fmt = AUD_FMT_S16;", "VAR_0->as.endianness = 0;", "qemu_mutex_init(&VAR_0->output_mutex);", "VAR_0->bh = qemu_bh_new(vnc_jobs_bh, VAR_0);", "QTAILQ_INSERT_TAIL(&vd->clients, VAR_0, next);", "if (first_client) {", "vnc_update_server_surface(vd);", "}", "graphic_hw_update(vd->dcl.con);", "vnc_write(VAR_0, \"RFB 003.008\\n\", 12);", "vnc_flush(VAR_0);", "vnc_read_when(VAR_0, protocol_version, 12);", "reset_keys(VAR_0);", "if (VAR_0->vd->lock_key_sync)\nVAR_0->led = qemu_add_led_event_handler(kbd_leds, VAR_0);", "VAR_0->mouse_mode_notifier.notify = check_pointer_type_change;", "qemu_add_mouse_mode_change_notifier(&VAR_0->mouse_mode_notifier);", "}" ]

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

[ "void FUNC_0(MigrationState *VAR_0, const Error *VAR_1)\n{", "trace_migrate_fd_error(VAR_1 ? error_get_pretty(VAR_1) : \"\");", "assert(VAR_0->to_dst_file == NULL);", "migrate_set_state(&VAR_0->state, MIGRATION_STATUS_SETUP,\nMIGRATION_STATUS_FAILED);", "if (!VAR_0->VAR_1) {", "VAR_0->VAR_1 = error_copy(VAR_1);", "}", "notifier_list_notify(&migration_state_notifiers, VAR_0);", "}" ]

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

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

[ "FUNC_0 (const unsigned char *VAR_0, enum floatformat_byteorders VAR_1,\nunsigned int VAR_2, unsigned int VAR_3, unsigned int VAR_4)\n{", "unsigned long VAR_5;", "unsigned int VAR_6;", "int VAR_7;", "VAR_6 = (VAR_3 + VAR_4) / FLOATFORMAT_CHAR_BIT;", "if (VAR_1 == floatformat_little)\nVAR_6 = (VAR_2 / FLOATFORMAT_CHAR_BIT) - VAR_6 - 1;", "VAR_7 =\n((VAR_3 + VAR_4) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;", "VAR_5 = *(VAR_0 + VAR_6) >> (-VAR_7);", "VAR_7 += FLOATFORMAT_CHAR_BIT;", "if (VAR_1 == floatformat_little)\n++VAR_6;", "else\n--VAR_6;", "while ((unsigned int) VAR_7 < VAR_4)\n{", "if (VAR_4 - VAR_7 < FLOATFORMAT_CHAR_BIT)\nVAR_5 |=\n(*(VAR_0 + VAR_6) & ((1 << (VAR_4 - VAR_7)) - 1))\n<< VAR_7;", "else\nVAR_5 |= *(VAR_0 + VAR_6) << VAR_7;", "VAR_7 += FLOATFORMAT_CHAR_BIT;", "if (VAR_1 == floatformat_little)\n++VAR_6;", "else\n--VAR_6;", "}", "return VAR_5;", "}" ]

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

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