Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "void FUNC_0(target_phys_addr_t VAR_0, int VAR_1,\nespdma_memory_read_write VAR_2,\nespdma_memory_read_write VAR_3,\nvoid *VAR_4, qemu_irq VAR_5, qemu_irq *VAR_6)\n{", "DeviceState *dev;", "SysBusDevice *s;", "ESPState *esp;", "dev = qdev_create(NULL, \"esp\");", "esp = DO_UPCAST(ESPState, busdev.qdev, dev);", "esp->VAR_2 = VAR_2;", "esp->VAR_3 = VAR_3;", "esp->VAR_4 = VAR_4;", "esp->VAR_1 = VAR_1;", "qdev_init(dev);", "s = sysbus_from_qdev(dev);", "sysbus_connect_irq(s, 0, VAR_5);", "sysbus_mmio_map(s, 0, VAR_0);", "*VAR_6 = qdev_get_gpio_in(dev, 0);", "}" ]

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

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

[ "static void FUNC_0(MPTSASState *VAR_0, MPIMsgSCSITaskMgmt *VAR_1)\n{", "MPIMsgSCSITaskMgmtReply reply;", "MPIMsgSCSITaskMgmtReply *reply_async;", "int VAR_2, VAR_3;", "SCSIDevice *sdev;", "SCSIRequest *r, *next;", "BusChild *kid;", "mptsas_fix_scsi_task_mgmt_endianness(VAR_1);", "QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*VAR_1));", "QEMU_BUILD_BUG_ON(sizeof(VAR_0->doorbell_msg) < sizeof(*VAR_1));", "QEMU_BUILD_BUG_ON(sizeof(VAR_0->doorbell_reply) < sizeof(reply));", "memset(&reply, 0, sizeof(reply));", "reply.TargetID = VAR_1->TargetID;", "reply.Bus = VAR_1->Bus;", "reply.MsgLength = sizeof(reply) / 4;", "reply.Function = VAR_1->Function;", "reply.TaskType = VAR_1->TaskType;", "reply.MsgContext = VAR_1->MsgContext;", "switch (VAR_1->TaskType) {", "case MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK:\ncase MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK:\nVAR_2 = mptsas_scsi_device_find(VAR_0, VAR_1->Bus, VAR_1->TargetID,\nVAR_1->LUN, &sdev);", "if (VAR_2) {", "reply.IOCStatus = VAR_2;", "goto out;", "}", "if (sdev->lun != VAR_1->LUN[1]) {", "reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN;", "goto out;", "}", "QTAILQ_FOREACH_SAFE(r, &sdev->requests, next, next) {", "MPTSASRequest *cmd_req = r->hba_private;", "if (cmd_req && cmd_req->scsi_io.MsgContext == VAR_1->TaskMsgContext) {", "break;", "}", "}", "if (r) {", "assert(r->hba_private);", "if (VAR_1->TaskType == MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK) {", "reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED;", "} else {", "MPTSASCancelNotifier *notifier;", "reply_async = g_memdup(&reply, sizeof(MPIMsgSCSITaskMgmtReply));", "reply_async->IOCLogInfo = INT_MAX;", "VAR_3 = 1;", "notifier = g_new(MPTSASCancelNotifier, 1);", "notifier->VAR_0 = VAR_0;", "notifier->reply = reply_async;", "notifier->notifier.notify = mptsas_cancel_notify;", "scsi_req_cancel_async(r, &notifier->notifier);", "goto reply_maybe_async;", "}", "}", "break;", "case MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:\ncase MPI_SCSITASKMGMT_TASKTYPE_CLEAR_TASK_SET:\nVAR_2 = mptsas_scsi_device_find(VAR_0, VAR_1->Bus, VAR_1->TargetID,\nVAR_1->LUN, &sdev);", "if (VAR_2) {", "reply.IOCStatus = VAR_2;", "goto out;", "}", "if (sdev->lun != VAR_1->LUN[1]) {", "reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN;", "goto out;", "}", "reply_async = g_memdup(&reply, sizeof(MPIMsgSCSITaskMgmtReply));", "reply_async->IOCLogInfo = INT_MAX;", "VAR_3 = 0;", "QTAILQ_FOREACH_SAFE(r, &sdev->requests, next, next) {", "if (r->hba_private) {", "MPTSASCancelNotifier *notifier;", "VAR_3++;", "notifier = g_new(MPTSASCancelNotifier, 1);", "notifier->VAR_0 = VAR_0;", "notifier->reply = reply_async;", "notifier->notifier.notify = mptsas_cancel_notify;", "scsi_req_cancel_async(r, &notifier->notifier);", "}", "}", "reply_maybe_async:\nif (reply_async->TerminationCount < VAR_3) {", "reply_async->IOCLogInfo = VAR_3;", "return;", "}", "reply.TerminationCount = VAR_3;", "break;", "case MPI_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:\nVAR_2 = mptsas_scsi_device_find(VAR_0, VAR_1->Bus, VAR_1->TargetID,\nVAR_1->LUN, &sdev);", "if (VAR_2) {", "reply.IOCStatus = VAR_2;", "goto out;", "}", "if (sdev->lun != VAR_1->LUN[1]) {", "reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN;", "goto out;", "}", "qdev_reset_all(&sdev->qdev);", "break;", "case MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET:\nif (VAR_1->Bus != 0) {", "reply.IOCStatus = MPI_IOCSTATUS_SCSI_INVALID_BUS;", "goto out;", "}", "if (VAR_1->TargetID > VAR_0->max_devices) {", "reply.IOCStatus = MPI_IOCSTATUS_SCSI_INVALID_TARGETID;", "goto out;", "}", "QTAILQ_FOREACH(kid, &VAR_0->bus.qbus.children, sibling) {", "sdev = SCSI_DEVICE(kid->child);", "if (sdev->channel == 0 && sdev->id == VAR_1->TargetID) {", "qdev_reset_all(kid->child);", "}", "}", "break;", "case MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS:\nqbus_reset_all(&VAR_0->bus.qbus);", "break;", "default:\nreply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED;", "break;", "}", "out:\nmptsas_fix_scsi_task_mgmt_reply_endianness(&reply);", "mptsas_post_reply(VAR_0, (MPIDefaultReply *)&reply);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49, 51, 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 97 ], [ 99 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 143, 145, 147, 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203, 205 ], [ 207 ], [ 209 ], [ 211 ], [ 214 ], [ 216 ], [ 220, 222, 224 ], [ 226 ], [ 228 ], [ 230 ], [ 232 ], [ 234 ], [ 236 ], [ 238 ], [ 240 ], [ 242 ], [ 244 ], [ 248, 250 ], [ 252 ], [ 254 ], [ 256 ], [ 258 ], [ 260 ], [ 262 ], [ 264 ], [ 268 ], [ 270 ], [ 272 ], [ 274 ], [ 276 ], [ 278 ], [ 280 ], [ 284, 286 ], [ 288 ], [ 292, 294 ], [ 296 ], [ 298 ], [ 302, 304 ], [ 306 ], [ 308 ] ]

[ "static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{", "SCLPEventClass *k = SCLP_EVENT_CLASS(VAR_0);", "DeviceClass *dc = DEVICE_CLASS(VAR_0);", "k->get_send_mask = send_mask;", "k->get_receive_mask = receive_mask;", "k->read_event_data = read_event_data;", "set_bit(DEVICE_CATEGORY_MISC, dc->categories);", "}" ]

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

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

[ "BlockDriverAIOCB *FUNC_0(\nBlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num,\nDMAIOFunc *io_func, BlockDriverCompletionFunc *cb,\nvoid *opaque, DMADirection dir)\n{", "DMAAIOCB *dbs = qemu_aio_get(&dma_aiocb_info, bs, cb, opaque);", "trace_dma_bdrv_io(dbs, bs, sector_num, (dir == DMA_DIRECTION_TO_DEVICE));", "dbs->acb = NULL;", "dbs->bs = bs;", "dbs->sg = sg;", "dbs->sector_num = sector_num;", "dbs->sg_cur_index = 0;", "dbs->sg_cur_byte = 0;", "dbs->dir = dir;", "dbs->io_func = io_func;", "dbs->bh = NULL;", "qemu_iovec_init(&dbs->iov, sg->nsg);", "dma_bdrv_cb(dbs, 0);", "return &dbs->common;", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 34 ], [ 36 ], [ 38 ], [ 40 ], [ 42 ], [ 44 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,\nuint64_t VAR_2, QEMUIOVector *VAR_3, int VAR_4)\n{", "NBDClientSession *client = nbd_get_client_session(VAR_0);", "NBDRequest request = {", ".type = NBD_CMD_WRITE,\n.from = VAR_1,\n.len = VAR_2,\n};", "if (VAR_4 & BDRV_REQ_FUA) {", "assert(client->info.VAR_4 & NBD_FLAG_SEND_FUA);", "request.VAR_4 |= NBD_CMD_FLAG_FUA;", "}", "assert(VAR_2 <= NBD_MAX_BUFFER_SIZE);", "return nbd_co_request(VAR_0, &request, VAR_3);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11, 13, 15, 17 ], [ 22 ], [ 24 ], [ 26 ], [ 28 ], [ 32 ], [ 36 ], [ 38 ] ]

[ "static abi_long FUNC_0(struct nlmsghdr *nlh)\n{", "uint32_t nlmsg_len;", "struct ifinfomsg *VAR_0;", "struct ifaddrmsg *VAR_1;", "struct rtmsg *VAR_2;", "nlmsg_len = nlh->nlmsg_len;", "switch (nlh->nlmsg_type) {", "case RTM_NEWLINK:\ncase RTM_DELLINK:\ncase RTM_GETLINK:\nVAR_0 = NLMSG_DATA(nlh);", "VAR_0->ifi_type = tswap16(VAR_0->ifi_type);", "VAR_0->ifi_index = tswap32(VAR_0->ifi_index);", "VAR_0->ifi_flags = tswap32(VAR_0->ifi_flags);", "VAR_0->ifi_change = tswap32(VAR_0->ifi_change);", "host_to_target_link_rtattr(IFLA_RTA(VAR_0),\nnlmsg_len - NLMSG_LENGTH(sizeof(*VAR_0)));", "break;", "case RTM_NEWADDR:\ncase RTM_DELADDR:\ncase RTM_GETADDR:\nVAR_1 = NLMSG_DATA(nlh);", "VAR_1->ifa_index = tswap32(VAR_1->ifa_index);", "host_to_target_addr_rtattr(IFA_RTA(VAR_1),\nnlmsg_len - NLMSG_LENGTH(sizeof(*VAR_1)));", "break;", "case RTM_NEWROUTE:\ncase RTM_DELROUTE:\ncase RTM_GETROUTE:\nVAR_2 = NLMSG_DATA(nlh);", "VAR_2->rtm_flags = tswap32(VAR_2->rtm_flags);", "host_to_target_route_rtattr(RTM_RTA(VAR_2),\nnlmsg_len - NLMSG_LENGTH(sizeof(*VAR_2)));", "break;", "default:\nreturn -TARGET_EINVAL;", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{", "PCMDecode *s = VAR_0->priv_data;", "int VAR_5;", "short *VAR_6;", "uint8_t *src;", "VAR_6 = VAR_1;", "src = VAR_3;", "if(VAR_4 > AVCODEC_MAX_AUDIO_FRAME_SIZE/2)\nVAR_4 = AVCODEC_MAX_AUDIO_FRAME_SIZE/2;", "switch(VAR_0->codec->id) {", "case CODEC_ID_PCM_S32LE:\ndecode_to16(4, 1, 0, &src, &VAR_6, VAR_4);", "break;", "case CODEC_ID_PCM_S32BE:\ndecode_to16(4, 0, 0, &src, &VAR_6, VAR_4);", "break;", "case CODEC_ID_PCM_U32LE:\ndecode_to16(4, 1, 1, &src, &VAR_6, VAR_4);", "break;", "case CODEC_ID_PCM_U32BE:\ndecode_to16(4, 0, 1, &src, &VAR_6, VAR_4);", "break;", "case CODEC_ID_PCM_S24LE:\ndecode_to16(3, 1, 0, &src, &VAR_6, VAR_4);", "break;", "case CODEC_ID_PCM_S24BE:\ndecode_to16(3, 0, 0, &src, &VAR_6, VAR_4);", "break;", "case CODEC_ID_PCM_U24LE:\ndecode_to16(3, 1, 1, &src, &VAR_6, VAR_4);", "break;", "case CODEC_ID_PCM_U24BE:\ndecode_to16(3, 0, 1, &src, &VAR_6, VAR_4);", "break;", "case CODEC_ID_PCM_S24DAUD:\nVAR_5 = VAR_4 / 3;", "for(;VAR_5>0;VAR_5--) {", "uint32_t v = src[0] << 16 | src[1] << 8 | src[2];", "v >>= 4;", "*VAR_6++ = ff_reverse[(v >> 8) & 0xff] +\n(ff_reverse[v & 0xff] << 8);", "src += 3;", "}", "break;", "case CODEC_ID_PCM_S16LE:\nVAR_5 = VAR_4 >> 1;", "for(;VAR_5>0;VAR_5--) {", "*VAR_6++ = src[0] | (src[1] << 8);", "src += 2;", "}", "break;", "case CODEC_ID_PCM_S16BE:\nVAR_5 = VAR_4 >> 1;", "for(;VAR_5>0;VAR_5--) {", "*VAR_6++ = (src[0] << 8) | src[1];", "src += 2;", "}", "break;", "case CODEC_ID_PCM_U16LE:\nVAR_5 = VAR_4 >> 1;", "for(;VAR_5>0;VAR_5--) {", "*VAR_6++ = (src[0] | (src[1] << 8)) - 0x8000;", "src += 2;", "}", "break;", "case CODEC_ID_PCM_U16BE:\nVAR_5 = VAR_4 >> 1;", "for(;VAR_5>0;VAR_5--) {", "*VAR_6++ = ((src[0] << 8) | src[1]) - 0x8000;", "src += 2;", "}", "break;", "case CODEC_ID_PCM_S8:\nVAR_5 = VAR_4;", "for(;VAR_5>0;VAR_5--) {", "*VAR_6++ = src[0] << 8;", "src++;", "}", "break;", "case CODEC_ID_PCM_U8:\nVAR_5 = VAR_4;", "for(;VAR_5>0;VAR_5--) {", "*VAR_6++ = ((int)src[0] - 128) << 8;", "src++;", "}", "break;", "case CODEC_ID_PCM_ALAW:\ncase CODEC_ID_PCM_MULAW:\nVAR_5 = VAR_4;", "for(;VAR_5>0;VAR_5--) {", "*VAR_6++ = s->table[src[0]];", "src++;", "}", "break;", "default:\nreturn -1;", "}", "*VAR_2 = (uint8_t *)VAR_6 - (uint8_t *)VAR_1;", "return src - VAR_3;", "}" ]

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

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

[ "static inline void FUNC_0(rgb32to16)(const uint8_t *src, uint8_t *dst, long src_size)\n{", "const uint8_t *VAR_0 = src;", "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\"\nASMALIGN16\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 $5, %%mm0\t\t\\n\\t\"\n\"pslld $11, %%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\" (mask3216g), \"m\" (mask3216br), \"m\" (mul3216)\n);", "#else\n__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");", "__asm __volatile(\n\"movq\t%0, %%mm7\\n\\t\"\n\"movq\t%1, %%mm6\\n\\t\"\n::\"m\"(red_16mask),\"m\"(green_16mask));", "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$5, %%mm1\\n\\t\"\n\"psrlq\t$5, %%mm4\\n\\t\"\n\"pand\t%%mm6, %%mm1\\n\\t\"\n\"pand\t%%mm6, %%mm4\\n\\t\"\n\"psrlq\t$8, %%mm2\\n\\t\"\n\"psrlq\t$8, %%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_16mask):\"memory\");", "d += 4;", "VAR_0 += 16;", "}", "#endif\n__asm __volatile(SFENCE:::\"memory\");", "__asm __volatile(EMMS:::\"memory\");", "#endif\nwhile(VAR_0 < VAR_1)\n{", "register int VAR_2 = *(uint32_t*)VAR_0; VAR_0 += 4;", "*d++ = ((VAR_2&0xFF)>>3) + ((VAR_2&0xFC00)>>5) + ((VAR_2&0xF80000)>>8);", "}", "}" ]

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

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

[ "static int64_t FUNC_0(const DCAADPCMEncContext *s, const int32_t *in, int len)\n{", "const premultiplied_coeffs *VAR_0 = s->private_data;", "int VAR_1, VAR_2, VAR_3 = 0;", "int VAR_4;", "int64_t err;", "int64_t min_err = 1ll << 62;", "int64_t corr[15];", "for (VAR_1 = 0; VAR_1 <= DCA_ADPCM_COEFFS; VAR_1++)", "for (VAR_2 = VAR_1; VAR_2 <= DCA_ADPCM_COEFFS; VAR_2++)", "corr[VAR_3++] = calc_corr(in+4, len, VAR_1, VAR_2);", "for (VAR_1 = 0; VAR_1 < DCA_ADPCM_VQCODEBOOK_SZ; VAR_1++) {", "err = apply_filter(ff_dca_adpcm_vb[VAR_1], corr, *VAR_0);", "if (err < min_err) {", "min_err = err;", "VAR_4 = VAR_1;", "}", "VAR_0++;", "}", "return VAR_4;", "}" ]

[ 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 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47 ] ]

[ "static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1)\n{", "uint32_t op0, op1;", "uint32_t ra, rb, rd;", "uint32_t L6, K5, K16, K5_11;", "int32_t I16, I5_11, N26;", "TCGMemOp mop;", "TCGv t0;", "op0 = extract32(VAR_1, 26, 6);", "op1 = extract32(VAR_1, 24, 2);", "ra = extract32(VAR_1, 16, 5);", "rb = extract32(VAR_1, 11, 5);", "rd = extract32(VAR_1, 21, 5);", "L6 = extract32(VAR_1, 5, 6);", "K5 = extract32(VAR_1, 0, 5);", "K16 = extract32(VAR_1, 0, 16);", "I16 = (int16_t)K16;", "N26 = sextract32(VAR_1, 0, 26);", "K5_11 = (extract32(VAR_1, 21, 5) << 11) | extract32(VAR_1, 0, 11);", "I5_11 = (int16_t)K5_11;", "switch (op0) {", "case 0x00:\nLOG_DIS(\"l.j %d\\n\", N26);", "gen_jump(VAR_0, N26, 0, op0);", "break;", "case 0x01:\nLOG_DIS(\"l.jal %d\\n\", N26);", "gen_jump(VAR_0, N26, 0, op0);", "break;", "case 0x03:\nLOG_DIS(\"l.bnf %d\\n\", N26);", "gen_jump(VAR_0, N26, 0, op0);", "break;", "case 0x04:\nLOG_DIS(\"l.bf %d\\n\", N26);", "gen_jump(VAR_0, N26, 0, op0);", "break;", "case 0x05:\nswitch (op1) {", "case 0x01:\nLOG_DIS(\"l.nop %d\\n\", I16);", "break;", "default:\ngen_illegal_exception(VAR_0);", "break;", "}", "break;", "case 0x11:\nLOG_DIS(\"l.jr r%d\\n\", rb);", "gen_jump(VAR_0, 0, rb, op0);", "break;", "case 0x12:\nLOG_DIS(\"l.jalr r%d\\n\", rb);", "gen_jump(VAR_0, 0, rb, op0);", "break;", "case 0x13:\nLOG_DIS(\"l.maci r%d, %d\\n\", ra, I16);", "t0 = tcg_const_tl(I16);", "gen_mac(VAR_0, cpu_R[ra], t0);", "tcg_temp_free(t0);", "break;", "case 0x09:\nLOG_DIS(\"l.rfe\\n\");", "{", "#if defined(CONFIG_USER_ONLY)\nreturn;", "#else\nif (VAR_0->mem_idx == MMU_USER_IDX) {", "gen_illegal_exception(VAR_0);", "return;", "}", "gen_helper_rfe(cpu_env);", "VAR_0->is_jmp = DISAS_UPDATE;", "#endif\n}", "break;", "case 0x1b:\nLOG_DIS(\"l.lwa r%d, r%d, %d\\n\", rd, ra, I16);", "gen_lwa(VAR_0, cpu_R[rd], cpu_R[ra], I16);", "break;", "case 0x1c:\nLOG_DIS(\"l.cust1\\n\");", "break;", "case 0x1d:\nLOG_DIS(\"l.cust2\\n\");", "break;", "case 0x1e:\nLOG_DIS(\"l.cust3\\n\");", "break;", "case 0x1f:\nLOG_DIS(\"l.cust4\\n\");", "break;", "case 0x3c:\nLOG_DIS(\"l.cust5 r%d, r%d, r%d, %d, %d\\n\", rd, ra, rb, L6, K5);", "break;", "case 0x3d:\nLOG_DIS(\"l.cust6\\n\");", "break;", "case 0x3e:\nLOG_DIS(\"l.cust7\\n\");", "break;", "case 0x3f:\nLOG_DIS(\"l.cust8\\n\");", "break;", "case 0x21:\nLOG_DIS(\"l.lwz r%d, r%d, %d\\n\", rd, ra, I16);", "mop = MO_TEUL;", "goto do_load;", "case 0x22:\nLOG_DIS(\"l.lws r%d, r%d, %d\\n\", rd, ra, I16);", "mop = MO_TESL;", "goto do_load;", "case 0x23:\nLOG_DIS(\"l.lbz r%d, r%d, %d\\n\", rd, ra, I16);", "mop = MO_UB;", "goto do_load;", "case 0x24:\nLOG_DIS(\"l.lbs r%d, r%d, %d\\n\", rd, ra, I16);", "mop = MO_SB;", "goto do_load;", "case 0x25:\nLOG_DIS(\"l.lhz r%d, r%d, %d\\n\", rd, ra, I16);", "mop = MO_TEUW;", "goto do_load;", "case 0x26:\nLOG_DIS(\"l.lhs r%d, r%d, %d\\n\", rd, ra, I16);", "mop = MO_TESW;", "goto do_load;", "do_load:\n{", "TCGv t0 = tcg_temp_new();", "tcg_gen_addi_tl(t0, cpu_R[ra], I16);", "tcg_gen_qemu_ld_tl(cpu_R[rd], t0, VAR_0->mem_idx, mop);", "tcg_temp_free(t0);", "}", "break;", "case 0x27:\nLOG_DIS(\"l.addi r%d, r%d, %d\\n\", rd, ra, I16);", "t0 = tcg_const_tl(I16);", "gen_add(VAR_0, cpu_R[rd], cpu_R[ra], t0);", "tcg_temp_free(t0);", "break;", "case 0x28:\nLOG_DIS(\"l.addic r%d, r%d, %d\\n\", rd, ra, I16);", "t0 = tcg_const_tl(I16);", "gen_addc(VAR_0, cpu_R[rd], cpu_R[ra], t0);", "tcg_temp_free(t0);", "break;", "case 0x29:\nLOG_DIS(\"l.andi r%d, r%d, %d\\n\", rd, ra, K16);", "tcg_gen_andi_tl(cpu_R[rd], cpu_R[ra], K16);", "break;", "case 0x2a:\nLOG_DIS(\"l.ori r%d, r%d, %d\\n\", rd, ra, K16);", "tcg_gen_ori_tl(cpu_R[rd], cpu_R[ra], K16);", "break;", "case 0x2b:\nLOG_DIS(\"l.xori r%d, r%d, %d\\n\", rd, ra, I16);", "tcg_gen_xori_tl(cpu_R[rd], cpu_R[ra], I16);", "break;", "case 0x2c:\nLOG_DIS(\"l.muli r%d, r%d, %d\\n\", rd, ra, I16);", "t0 = tcg_const_tl(I16);", "gen_mul(VAR_0, cpu_R[rd], cpu_R[ra], t0);", "tcg_temp_free(t0);", "break;", "case 0x2d:\nLOG_DIS(\"l.mfspr r%d, r%d, %d\\n\", rd, ra, K16);", "{", "#if defined(CONFIG_USER_ONLY)\nreturn;", "#else\nTCGv_i32 ti = tcg_const_i32(K16);", "if (VAR_0->mem_idx == MMU_USER_IDX) {", "gen_illegal_exception(VAR_0);", "return;", "}", "gen_helper_mfspr(cpu_R[rd], cpu_env, cpu_R[rd], cpu_R[ra], ti);", "tcg_temp_free_i32(ti);", "#endif\n}", "break;", "case 0x30:\nLOG_DIS(\"l.mtspr r%d, r%d, %d\\n\", ra, rb, K5_11);", "{", "#if defined(CONFIG_USER_ONLY)\nreturn;", "#else\nTCGv_i32 im = tcg_const_i32(K5_11);", "if (VAR_0->mem_idx == MMU_USER_IDX) {", "gen_illegal_exception(VAR_0);", "return;", "}", "gen_helper_mtspr(cpu_env, cpu_R[ra], cpu_R[rb], im);", "tcg_temp_free_i32(im);", "#endif\n}", "break;", "case 0x33:\nLOG_DIS(\"l.swa r%d, r%d, %d\\n\", ra, rb, I5_11);", "gen_swa(VAR_0, cpu_R[rb], cpu_R[ra], I5_11);", "break;", "case 0x35:\nLOG_DIS(\"l.sw r%d, r%d, %d\\n\", ra, rb, I5_11);", "mop = MO_TEUL;", "goto do_store;", "case 0x36:\nLOG_DIS(\"l.sb r%d, r%d, %d\\n\", ra, rb, I5_11);", "mop = MO_UB;", "goto do_store;", "case 0x37:\nLOG_DIS(\"l.sh r%d, r%d, %d\\n\", ra, rb, I5_11);", "mop = MO_TEUW;", "goto do_store;", "do_store:\n{", "TCGv t0 = tcg_temp_new();", "tcg_gen_addi_tl(t0, cpu_R[ra], I5_11);", "tcg_gen_qemu_st_tl(cpu_R[rb], t0, VAR_0->mem_idx, mop);", "tcg_temp_free(t0);", "}", "break;", "default:\ngen_illegal_exception(VAR_0);", "break;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 87, 89 ], [ 91, 93 ], [ 95 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 131, 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 145, 147 ], [ 149 ], [ 151, 153 ], [ 155, 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169, 171 ], [ 173 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 187, 189 ], [ 191 ], [ 195, 197 ], [ 199 ], [ 203, 205 ], [ 207 ], [ 211, 213 ], [ 215 ], [ 219, 221 ], [ 223 ], [ 227, 229 ], [ 231 ], [ 235, 237 ], [ 239 ], [ 243, 245 ], [ 247 ], [ 269, 271 ], [ 273 ], [ 275 ], [ 279, 281 ], [ 283 ], [ 285 ], [ 289, 291 ], [ 293 ], [ 295 ], [ 299, 301 ], [ 303 ], [ 305 ], [ 309, 311 ], [ 313 ], [ 315 ], [ 319, 321 ], [ 323 ], [ 325 ], [ 329, 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 347, 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 361, 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 375, 377 ], [ 379 ], [ 381 ], [ 385, 387 ], [ 389 ], [ 391 ], [ 395, 397 ], [ 399 ], [ 401 ], [ 405, 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 419, 421 ], [ 423 ], [ 425, 427 ], [ 429, 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ], [ 445, 447 ], [ 449 ], [ 453, 455 ], [ 457 ], [ 459, 461 ], [ 463, 465 ], [ 467 ], [ 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 479, 481 ], [ 483 ], [ 487, 489 ], [ 491 ], [ 493 ], [ 515, 517 ], [ 519 ], [ 521 ], [ 525, 527 ], [ 529 ], [ 531 ], [ 535, 537 ], [ 539 ], [ 541 ], [ 545, 547 ], [ 549 ], [ 551 ], [ 553 ], [ 555 ], [ 557 ], [ 559 ], [ 563, 565 ], [ 567 ], [ 569 ], [ 571 ] ]

[ "FUNC_0(size_t VAR_0)\n{", "void *VAR_1;", "__coverity_negative_sink__(VAR_0);", "VAR_1 = calloc(1, VAR_0 == 0 ? 1 : VAR_0);", "if (!VAR_1) __coverity_panic__();", "return VAR_1;", "}" ]

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

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

[ "static ssize_t FUNC_0(void *opaque, struct iovec *iov, int iovcnt,\nint64_t pos)\n{", "QEMUFileSocket *s = opaque;", "ssize_t len, offset;", "ssize_t size = iov_size(iov, iovcnt);", "ssize_t total = 0;", "assert(iovcnt > 0);", "offset = 0;", "while (size > 0) {", "while (offset >= iov[0].iov_len) {", "offset -= iov[0].iov_len;", "iov++, iovcnt--;", "}", "assert(iovcnt > 0);", "iov[0].iov_base += offset;", "iov[0].iov_len -= offset;", "do {", "len = writev(s->fd, iov, iovcnt);", "} while (len == -1 && errno == EINTR);", "if (len == -1) {", "return -errno;", "}", "iov[0].iov_base -= offset;", "iov[0].iov_len += offset;", "offset += len;", "total += len;", "size -= len;", "}", "return total;", "}" ]

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

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

[ "void FUNC_0(AVFormatContext *VAR_0)\n{", "int VAR_1, VAR_2;", "for (VAR_1 = 0; VAR_1 < VAR_0->nb_streams; VAR_1++) {", "AVStream *st = VAR_0->streams[VAR_1];", "if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)\ncontinue;", "if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)\nav_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);", "if (st->info->duration_count>1 && !st->r_frame_rate.num\n&& tb_unreliable(st->codec)) {", "int num = 0;", "double best_error= 0.01;", "AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);", "for (VAR_2= 0; VAR_2<MAX_STD_TIMEBASES; VAR_2++) {", "int k;", "if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(VAR_2))\ncontinue;", "if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(VAR_2))\ncontinue;", "if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(VAR_2))\ncontinue;", "for (k= 0; k<2; k++) {", "int n = st->info->duration_count;", "double a= st->info->duration_error[k][0][VAR_2] / n;", "double error= st->info->duration_error[k][1][VAR_2]/n - a*a;", "if (error < best_error && best_error> 0.000000001) {", "best_error= error;", "num = get_std_framerate(VAR_2);", "}", "if (error < 0.02)\nav_log(VAR_0, AV_LOG_DEBUG, \"rfps: %f %f\\n\", get_std_framerate(VAR_2) / 12.0/1001, error);", "}", "}", "if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))\nav_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);", "}", "if ( !st->avg_frame_rate.num\n&& st->r_frame_rate.num && st->info->rfps_duration_sum\n&& st->info->codec_info_duration <= 0\n&& st->info->duration_count > 2\n&& fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0\n) {", "av_log(VAR_0, AV_LOG_DEBUG, \"Setting avg frame rate based on r frame rate\\n\");", "st->avg_frame_rate = st->r_frame_rate;", "}", "av_freep(&st->info->duration_error);", "st->info->last_dts = AV_NOPTS_VALUE;", "st->info->duration_count = 0;", "st->info->rfps_duration_sum = 0;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 25, 27 ], [ 29, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 47, 49 ], [ 51, 53 ], [ 57, 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 91, 93 ], [ 95 ], [ 97, 99, 101, 103, 105, 107 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "AVFrame *frame = VAR_1;", "ThreadFrame tframe = { .f = VAR_1 };", "const uint8_t *VAR_4 = VAR_3->VAR_1;", "int VAR_5 = VAR_3->size;", "FLACContext *s = VAR_0->priv_data;", "int VAR_6 = 0;", "int VAR_7;", "*VAR_2 = 0;", "if (s->max_framesize == 0) {", "s->max_framesize =\nff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,\nFLAC_MAX_CHANNELS, 32);", "}", "if (VAR_5 > 5 && !memcmp(VAR_4, \"\\177FLAC\", 5)) {", "av_log(s->VAR_0, AV_LOG_DEBUG, \"skiping flac header packet 1\\n\");", "return VAR_5;", "}", "if (VAR_5 > 0 && (*VAR_4 & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {", "av_log(s->VAR_0, AV_LOG_DEBUG, \"skiping vorbis comment\\n\");", "return VAR_5;", "}", "if (VAR_5 < FLAC_MIN_FRAME_SIZE)\nreturn VAR_5;", "if (AV_RB32(VAR_4) == MKBETAG('f','L','a','C')) {", "if (!s->got_streaminfo && (VAR_7 = parse_streaminfo(s, VAR_4, VAR_5))) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"invalid header\\n\");", "return VAR_7;", "}", "return get_metadata_size(VAR_4, VAR_5);", "}", "if ((VAR_7 = init_get_bits8(&s->gb, VAR_4, VAR_5)) < 0)\nreturn VAR_7;", "if ((VAR_7 = decode_frame(s)) < 0) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"decode_frame() failed\\n\");", "return VAR_7;", "}", "VAR_6 = get_bits_count(&s->gb)/8;", "if ((s->VAR_0->err_recognition & AV_EF_CRCCHECK) &&\nav_crc(av_crc_get_table(AV_CRC_16_ANSI),\n0, VAR_4, VAR_6)) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"CRC error at PTS %\"PRId64\"\\n\", VAR_3->pts);", "if (s->VAR_0->err_recognition & AV_EF_EXPLODE)\nreturn AVERROR_INVALIDDATA;", "}", "frame->nb_samples = s->blocksize;", "if ((VAR_7 = ff_thread_get_buffer(VAR_0, &tframe, 0)) < 0)\nreturn VAR_7;", "s->dsp.decorrelate[s->ch_mode](frame->VAR_1, s->decoded, s->channels,\ns->blocksize, s->sample_shift);", "if (VAR_6 > VAR_5) {", "av_log(s->VAR_0, AV_LOG_ERROR, \"overread: %d\\n\", VAR_6 - VAR_5);", "return AVERROR_INVALIDDATA;", "}", "if (VAR_6 < VAR_5) {", "av_log(s->VAR_0, AV_LOG_DEBUG, \"underread: %d orig size: %d\\n\",\nVAR_5 - VAR_6, VAR_5);", "}", "*VAR_2 = 1;", "return VAR_6;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 27 ], [ 29, 31, 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 65, 67 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 91, 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107, 109, 111 ], [ 113 ], [ 115, 117 ], [ 119 ], [ 125 ], [ 127, 129 ], [ 133, 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 157 ], [ 161 ], [ 163 ] ]

[ "static int FUNC_0(AVFormatContext * VAR_0, AVPacket * VAR_1) {", "NUTContext * priv = VAR_0->priv_data;", "nut_packet_t pd;", "int VAR_2;", "while ((VAR_2 = nut_read_next_packet(priv->nut, &pd)) < 0)\nav_log(VAR_0, AV_LOG_ERROR, \" NUT error: %s\\n\", nut_error(-VAR_2));", "if (VAR_2 || av_new_packet(VAR_1, pd.len) < 0) return -1;", "if (pd.flags & NUT_FLAG_KEY) VAR_1->flags |= PKT_FLAG_KEY;", "VAR_1->pts = pd.pts;", "VAR_1->stream_index = pd.stream;", "VAR_1->pos = url_ftell(&VAR_0->pb);", "VAR_2 = nut_read_frame(priv->nut, &pd.len, VAR_1->data);", "return VAR_2;", "}" ]

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

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

[ "void FUNC_0(HotplugHandler *VAR_0,\nMemHotplugState *VAR_1,\nDeviceState *VAR_2, Error **VAR_3)\n{", "MemStatus *mdev;", "mdev = acpi_memory_slot_status(VAR_1, VAR_2, VAR_3);", "if (!mdev) {", "return;", "}", "assert(!object_dynamic_cast(OBJECT(VAR_2), TYPE_NVDIMM));", "mdev->is_removing = true;", "acpi_send_event(DEVICE(VAR_0), ACPI_MEMORY_HOTPLUG_STATUS);", "}" ]

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

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

[ "static inline uint32_t FUNC_0(NE2000State *s, uint32_t addr)\n{", "addr &= ~1;", "if (addr < 32 ||\n(addr >= NE2000_PMEM_START && addr < NE2000_MEM_SIZE)) {", "return ldl_le_p(s->mem + addr);", "} else {", "return 0xffffffff;", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned int VAR_3)\n{", "LedState *s = VAR_0;", "uint8_t new_val = VAR_2 & 0xff;", "trace_jazz_led_write(VAR_1, new_val);", "s->segments = new_val;", "s->state |= REDRAW_SEGMENTS;", "}" ]

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

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

[ "static void FUNC_0(GtkDisplayState *VAR_0)\n{", "#if GTK_CHECK_VERSION(3, 0, 0)\nGdkDisplay *display = gtk_widget_get_display(VAR_0->drawing_area);", "GdkDeviceManager *mgr = gdk_display_get_device_manager(display);", "GList *devices = gdk_device_manager_list_devices(mgr,\nGDK_DEVICE_TYPE_MASTER);", "GList *tmp = devices;", "while (tmp) {", "GdkDevice *dev = tmp->data;", "if (gdk_device_get_source(dev) == GDK_SOURCE_MOUSE) {", "gdk_device_grab(dev,\ngtk_widget_get_window(VAR_0->drawing_area),\nGDK_OWNERSHIP_NONE,\nFALSE,\nGDK_POINTER_MOTION_MASK |\nGDK_BUTTON_PRESS_MASK |\nGDK_BUTTON_RELEASE_MASK |\nGDK_BUTTON_MOTION_MASK |\nGDK_SCROLL_MASK,\nVAR_0->null_cursor,\nGDK_CURRENT_TIME);", "}", "tmp = tmp->next;", "}", "g_list_free(devices);", "#else\ngdk_pointer_grab(gtk_widget_get_window(VAR_0->drawing_area),\nFALSE,\nGDK_POINTER_MOTION_MASK |\nGDK_BUTTON_PRESS_MASK |\nGDK_BUTTON_RELEASE_MASK |\nGDK_BUTTON_MOTION_MASK |\nGDK_SCROLL_MASK,\nNULL,\nVAR_0->null_cursor,\nGDK_CURRENT_TIME);", "#endif\n}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque, hwaddr addr,\nunsigned size)\n{", "VirtIOPCIProxy *proxy = opaque;", "uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);", "uint64_t val = 0;", "if (addr < config) {", "return virtio_ioport_read(proxy, addr);", "}", "addr -= config;", "switch (size) {", "case 1:\nval = virtio_config_readb(proxy->vdev, addr);", "break;", "case 2:\nval = virtio_config_readw(proxy->vdev, addr);", "if (virtio_is_big_endian()) {", "val = bswap16(val);", "}", "break;", "case 4:\nval = virtio_config_readl(proxy->vdev, addr);", "if (virtio_is_big_endian()) {", "val = bswap32(val);", "}", "break;", "}", "return val;", "}" ]

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

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

[ "void FUNC_0(sPAPRMachineState *VAR_0)\n{", "gchar **inpieces;", "gchar *newprops;", "int VAR_1, VAR_2;", "gchar *compat_str = NULL;", "inpieces = g_strsplit(MACHINE(VAR_0)->cpu_model, \",\", 0);", "VAR_1 = 1;", "VAR_2 = 1;", "while (inpieces[VAR_1]) {", "if (g_str_has_prefix(inpieces[VAR_1], \"compat=\")) {", "g_free(compat_str);", "compat_str = inpieces[VAR_1];", "} else {", "VAR_2++;", "}", "VAR_1++;", "inpieces[VAR_2] = inpieces[VAR_1];", "}", "if (compat_str) {", "char *VAR_3 = compat_str + strlen(\"compat=\");", "object_property_set_str(OBJECT(VAR_0), VAR_3, \"max-cpu-compat\",\n&error_fatal);", "}", "newprops = g_strjoinv(\",\", inpieces);", "cpu_parse_cpu_model(TYPE_POWERPC_CPU, newprops);", "g_free(newprops);", "g_strfreev(inpieces);", "}" ]

[ 0, 0, 0, 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 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 79, 81 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ] ]

[ "static void FUNC_0(DisasContext *VAR_0, target_ulong VAR_1)\n{", "gen_update_cc_op(VAR_0);", "gen_jmp_im(VAR_1);", "gen_helper_debug(cpu_env);", "VAR_0->is_jmp = DISAS_TB_JUMP;", "}" ]

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

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

[ "int FUNC_0(AVFilterLink *VAR_0)\n{", "int VAR_1 = -1;", "FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, VAR_0, 1);", "if (VAR_0->closed)\nreturn AVERROR_EOF;", "av_assert0(!VAR_0->frame_requested);", "VAR_0->frame_requested = 1;", "while (VAR_0->frame_requested) {", "if (VAR_0->srcpad->request_frame)\nVAR_1 = VAR_0->srcpad->request_frame(VAR_0);", "else if (VAR_0->src->inputs[0])\nVAR_1 = FUNC_0(VAR_0->src->inputs[0]);", "if (VAR_1 == AVERROR_EOF && VAR_0->partial_buf) {", "AVFrame *pbuf = VAR_0->partial_buf;", "VAR_0->partial_buf = NULL;", "VAR_1 = ff_filter_frame_framed(VAR_0, pbuf);", "}", "if (VAR_1 < 0) {", "VAR_0->frame_requested = 0;", "if (VAR_1 == AVERROR_EOF)\nVAR_0->closed = 1;", "} else {", "av_assert0(!VAR_0->frame_requested ||\nVAR_0->flags & FF_LINK_FLAG_REQUEST_LOOP);", "}", "}", "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 ]

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

[ "static int FUNC_0(SysBusDevice *VAR_0)\n{", "UNINState *s;", "int VAR_1, VAR_2;", "s = FROM_SYSBUS(UNINState, VAR_0);", "VAR_1 = cpu_register_io_memory(pci_unin_config_read,\npci_unin_config_write, s);", "VAR_2 = cpu_register_io_memory(pci_unin_main_read,\npci_unin_main_write, &s->host_state);", "sysbus_init_mmio(VAR_0, 0x1000, VAR_1);", "sysbus_init_mmio(VAR_0, 0x1000, VAR_2);", "return 0;", "}" ]

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

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

[ "FUNC_0(void *VAR_0, target_phys_addr_t VAR_1, uint64_t VAR_2,\nunsigned VAR_3)\n{", "struct nand_state_t *VAR_4 = VAR_0;", "int VAR_5;", "DNAND(printf(\"%VAR_4 VAR_1=%x v=%x\\n\", __func__, VAR_1, (unsigned)VAR_2));", "nand_setpins(VAR_4->nand, VAR_4->cle, VAR_4->ale, VAR_4->ce, 1, 0);", "nand_setio(VAR_4->nand, VAR_2);", "nand_getpins(VAR_4->nand, &VAR_5);", "VAR_4->VAR_5 = VAR_5;", "}" ]

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

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

[ "static void FUNC_0(MemoryRegion *VAR_0, target_phys_addr_t VAR_1,\nstruct omap_mpu_state_s *VAR_2)\n{", "memory_region_init_io(&VAR_2->mpui_iomem, &omap_mpui_ops, VAR_2,\n\"omap-mpui\", 0x100);", "memory_region_add_subregion(VAR_0, VAR_1, &VAR_2->mpui_iomem);", "omap_mpui_reset(VAR_2);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "static BusState *FUNC_0(const char *path)\n{", "DeviceState *dev;", "BusState *bus;", "char VAR_0[128], VAR_1[256];", "int VAR_2, VAR_3;", "if (path[0] == '/') {", "bus = main_system_bus;", "VAR_2 = 0;", "} else {", "if (sscanf(path, \"%127[^/]%n\", VAR_0, &VAR_3) != 1) {", "qemu_error(\"path parse error (\\\"%s\\\")\\n\", path);", "return NULL;", "}", "bus = qbus_find_recursive(main_system_bus, VAR_0, NULL);", "if (!bus) {", "qemu_error(\"bus \\\"%s\\\" not found\\n\", VAR_0);", "return NULL;", "}", "VAR_2 = VAR_3;", "}", "for (;;) {", "if (path[VAR_2] == '\\0') {", "return bus;", "}", "if (sscanf(path+VAR_2, \"/%127[^/]%n\", VAR_0, &VAR_3) != 1) {", "qemu_error(\"path parse error (\\\"%s\\\" VAR_2 %d)\\n\", path, VAR_2);", "return NULL;", "}", "VAR_2 += VAR_3;", "dev = qbus_find_dev(bus, VAR_0);", "if (!dev) {", "qbus_list_dev(bus, VAR_1, sizeof(VAR_1));", "qemu_error(\"device \\\"%s\\\" not found\\n%s\\n\", VAR_0, VAR_1);", "return NULL;", "}", "if (path[VAR_2] == '\\0') {", "switch (dev->num_child_bus) {", "case 0:\nqemu_error(\"device has no child bus (%s)\\n\", path);", "return NULL;", "case 1:\nreturn LIST_FIRST(&dev->child_bus);", "default:\nqbus_list_bus(dev, VAR_1, sizeof(VAR_1));", "qemu_error(\"device has multiple child busses (%s)\\n%s\\n\",\npath, VAR_1);", "return NULL;", "}", "}", "if (sscanf(path+VAR_2, \"/%127[^/]%n\", VAR_0, &VAR_3) != 1) {", "qemu_error(\"path parse error (\\\"%s\\\" VAR_2 %d)\\n\", path, VAR_2);", "return NULL;", "}", "VAR_2 += VAR_3;", "bus = qbus_find_bus(dev, VAR_0);", "if (!bus) {", "qbus_list_bus(dev, VAR_1, sizeof(VAR_1));", "qemu_error(\"child bus \\\"%s\\\" not found\\n%s\\n\", VAR_0, VAR_1);", "return NULL;", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 91 ], [ 93, 95 ], [ 97 ], [ 99, 101 ], [ 103, 105 ], [ 107, 109 ], [ 111 ], [ 113 ], [ 115 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ] ]

[ "FUNC_0(struct iscsi_context *VAR_0, int VAR_1,\nvoid *VAR_2, void *VAR_3)\n{", "IscsiAIOCB *acb = VAR_3;", "trace_iscsi_aio_read16_cb(VAR_0, VAR_1, acb, acb->canceled);", "if (acb->canceled != 0) {", "return;", "}", "acb->VAR_1 = 0;", "if (VAR_1 != 0) {", "if (VAR_1 == SCSI_STATUS_CHECK_CONDITION\n&& acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION\n&& acb->retries-- > 0) {", "if (acb->task != NULL) {", "scsi_free_scsi_task(acb->task);", "acb->task = NULL;", "}", "if (iscsi_aio_readv_acb(acb) == 0) {", "iscsi_set_events(acb->iscsilun);", "return;", "}", "}", "error_report(\"Failed to read16 data from iSCSI lun. %s\",\niscsi_get_error(VAR_0));", "acb->VAR_1 = -EIO;", "}", "iscsi_schedule_bh(acb);", "}" ]

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

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

[ "void FUNC_0(CPUState *VAR_0)\n{", "APICState *s = VAR_0->apic_state;", "cpu_reset_interrupt(VAR_0, CPU_INTERRUPT_SIPI);", "if (!s->wait_for_sipi)\nreturn;", "VAR_0->eip = 0;", "cpu_x86_load_seg_cache(VAR_0, R_CS, s->sipi_vector << 8, s->sipi_vector << 12,\n0xffff, 0);", "VAR_0->halted = 0;", "s->wait_for_sipi = 0;", "}" ]

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

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

[ "static int FUNC_0(DeviceState *VAR_0, Property *VAR_1, char *VAR_2, size_t VAR_3)\n{", "DriveInfo **ptr = qdev_get_prop_ptr(VAR_0, VAR_1);", "return snprintf(VAR_2, VAR_3, \"%s\", (*ptr) ? (*ptr)->id : \"<null>\");", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "PXA2xxPICState *s = (PXA2xxPICState *) VAR_0;", "switch (VAR_1) {", "case ICMR:\ns->int_enabled[0] = VAR_2;", "break;", "case ICMR2:\ns->int_enabled[1] = VAR_2;", "break;", "case ICLR:\ns->is_fiq[0] = VAR_2;", "break;", "case ICLR2:\ns->is_fiq[1] = VAR_2;", "break;", "case ICCR:\ns->int_idle = (VAR_2 & 1) ? 0 : ~0;", "break;", "case IPR0 ... IPR31:\ns->priority[0 + ((VAR_1 - IPR0 ) >> 2)] = VAR_2 & 0x8000003f;", "break;", "case IPR32 ... IPR39:\ns->priority[32 + ((VAR_1 - IPR32) >> 2)] = VAR_2 & 0x8000003f;", "break;", "default:\nprintf(\"%s: Bad register VAR_1 \" REG_FMT \"\\n\", __FUNCTION__, VAR_1);", "return;", "}", "pxa2xx_pic_update(VAR_0);", "}" ]

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

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

[ "static void FUNC_0(BlockDriverState *VAR_0, int VAR_1, Error **VAR_2)\n{", "BDRVRawState *s = VAR_0->opaque;", "char *VAR_3;", "size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());", "if (bdrv_is_sg(VAR_0) || !s->needs_alignment) {", "VAR_0->request_alignment = 1;", "s->buf_align = 1;", "return;", "}", "VAR_0->request_alignment = 0;", "s->buf_align = 0;", "if (probe_logical_blocksize(VAR_1, &VAR_0->request_alignment) < 0) {", "VAR_0->request_alignment = 0;", "}", "#ifdef CONFIG_XFS\nif (s->is_xfs) {", "struct dioattr da;", "if (xfsctl(NULL, VAR_1, XFS_IOC_DIOINFO, &da) >= 0) {", "VAR_0->request_alignment = da.d_miniosz;", "}", "}", "#endif\nif (!s->buf_align) {", "size_t align;", "VAR_3 = qemu_memalign(max_align, 2 * max_align);", "for (align = 512; align <= max_align; align <<= 1) {", "if (raw_is_io_aligned(VAR_1, VAR_3 + align, max_align)) {", "s->buf_align = align;", "break;", "}", "}", "qemu_vfree(VAR_3);", "}", "if (!VAR_0->request_alignment) {", "size_t align;", "VAR_3 = qemu_memalign(s->buf_align, max_align);", "for (align = 512; align <= max_align; align <<= 1) {", "if (raw_is_io_aligned(VAR_1, VAR_3, align)) {", "VAR_0->request_alignment = align;", "break;", "}", "}", "qemu_vfree(VAR_3);", "}", "if (!s->buf_align || !VAR_0->request_alignment) {", "error_setg(VAR_2, \"Could not find working O_DIRECT alignment. \"\n\"Try cache.direct=off.\");", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41, 43 ], [ 45 ], [ 47 ], [ 49 ], [ 55 ], [ 57 ], [ 59, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 115, 117 ], [ 119 ], [ 121 ] ]

[ "static void FUNC_0(H264Context *VAR_0) {", "int VAR_1 = 0;", "int VAR_2 = 0;", "for( VAR_2 = 0; VAR_2 < VAR_0->s.mb_height; VAR_2++ ) {", "for( VAR_1 = 0; VAR_1 < VAR_0->s.mb_width; VAR_1++ ) {", "filter_mb( VAR_0, VAR_1, VAR_2 );", "}", "}", "}" ]

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

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

[ "static int FUNC_0(XenPCIPassthroughState *VAR_0,\nXenPTReg *VAR_1, uint32_t *VAR_2,\nuint32_t VAR_3, uint32_t VAR_4)\n{", "XenPTRegInfo *reg = VAR_1->reg;", "uint32_t writable_mask = 0;", "uint32_t old_addr = VAR_1->data;", "if (!(VAR_0->msi->flags & PCI_MSI_FLAGS_64BIT)) {", "XEN_PT_ERR(&VAR_0->dev,\n\"Can't write to the upper address without 64 bit support\\n\");", "return -1;", "}", "writable_mask = reg->emu_mask & ~reg->ro_mask & VAR_4;", "VAR_1->data = XEN_PT_MERGE_VALUE(*VAR_2, VAR_1->data, writable_mask);", "VAR_0->msi->addr_hi = VAR_1->data;", "*VAR_2 = XEN_PT_MERGE_VALUE(*VAR_2, VAR_3, 0);", "if (VAR_1->data != old_addr) {", "if (VAR_0->msi->mapped) {", "xen_pt_msi_update(VAR_0);", "}", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19 ], [ 21, 23 ], [ 25 ], [ 27 ], [ 33 ], [ 35 ], [ 39 ], [ 45 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ] ]

[ "static int FUNC_0(FsContext *VAR_0, V9fsFidOpenState *VAR_1)\n{", "V9fsSynthOpenState *synth_open = VAR_1->private;", "V9fsSynthNode *node = synth_open->node;", "node->open_count--;", "g_free(synth_open);", "VAR_1->private = NULL;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(Monitor *VAR_30, const char *VAR_1)\n{", "const char *VAR_2, *VAR_3, *VAR_4;", "char *VAR_5;", "int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;", "const mon_cmd_t *VAR_11;", "char VAR_12[256];", "char VAR_13[1024];", "void *VAR_14[MAX_ARGS];", "void *VAR_15[MAX_ARGS];", "void (*VAR_16)(Monitor *VAR_30);", "void (*VAR_17)(Monitor *VAR_30, void *VAR_30);", "void (*VAR_19)(Monitor *VAR_30, void *VAR_30, void *VAR_30);", "void (*VAR_21)(Monitor *VAR_30, void *VAR_30, void *VAR_30, void *VAR_30);", "void (*VAR_23)(Monitor *VAR_30, void *VAR_30, void *VAR_30, void *VAR_30,\nvoid *VAR_30);", "void (*VAR_25)(Monitor *VAR_30, void *VAR_30, void *VAR_30, void *VAR_30,\nvoid *VAR_30, void *VAR_30);", "void (*VAR_27)(Monitor *VAR_30, void *VAR_30, void *VAR_30, void *VAR_30,\nvoid *VAR_30, void *VAR_30, void *VAR_30);", "void (*VAR_29)(Monitor *VAR_30, void *VAR_30, void *VAR_30, void *VAR_30,\nvoid *VAR_30, void *VAR_30, void *VAR_30, void *VAR_30);", "#ifdef DEBUG\nmonitor_printf(VAR_30, \"command='%s'\\n\", VAR_1);", "#endif\nVAR_2 = VAR_1;", "VAR_5 = VAR_12;", "while (qemu_isspace(*VAR_2))\nVAR_2++;", "if (*VAR_2 == '\\0')\nreturn;", "VAR_3 = VAR_2;", "while (*VAR_2 != '\\0' && *VAR_2 != '/' && !qemu_isspace(*VAR_2))\nVAR_2++;", "VAR_8 = VAR_2 - VAR_3;", "if (VAR_8 > sizeof(VAR_12) - 1)\nVAR_8 = sizeof(VAR_12) - 1;", "memcpy(VAR_12, VAR_3, VAR_8);", "VAR_12[VAR_8] = '\\0';", "for(VAR_11 = mon_cmds; VAR_11->name != NULL; VAR_11++) {", "if (compare_cmd(VAR_12, VAR_11->name))\ngoto found;", "}", "monitor_printf(VAR_30, \"unknown command: '%s'\\n\", VAR_12);", "return;", "found:\nfor(VAR_9 = 0; VAR_9 < MAX_ARGS; VAR_9++)", "VAR_14[VAR_9] = NULL;", "VAR_4 = VAR_11->args_type;", "VAR_7 = 0;", "for(;;) {", "VAR_6 = *VAR_4;", "if (VAR_6 == '\\0')\nbreak;", "VAR_4++;", "switch(VAR_6) {", "case 'F':\ncase 'B':\ncase 's':\n{", "int VAR_31;", "char *VAR_32;", "while (qemu_isspace(*VAR_2))\nVAR_2++;", "if (*VAR_4 == '?') {", "VAR_4++;", "if (*VAR_2 == '\\0') {", "VAR_32 = NULL;", "goto add_str;", "}", "}", "VAR_31 = get_str(VAR_13, sizeof(VAR_13), &VAR_2);", "if (VAR_31 < 0) {", "switch(VAR_6) {", "case 'F':\nmonitor_printf(VAR_30, \"%s: filename expected\\n\",\nVAR_12);", "break;", "case 'B':\nmonitor_printf(VAR_30, \"%s: block device name expected\\n\",\nVAR_12);", "break;", "default:\nmonitor_printf(VAR_30, \"%s: string expected\\n\", VAR_12);", "break;", "}", "goto fail;", "}", "VAR_32 = qemu_malloc(strlen(VAR_13) + 1);", "pstrcpy(VAR_32, sizeof(VAR_13), VAR_13);", "VAR_14[VAR_7] = VAR_32;", "add_str:\nif (VAR_7 >= MAX_ARGS) {", "error_args:\nmonitor_printf(VAR_30, \"%s: too many arguments\\n\", VAR_12);", "goto fail;", "}", "VAR_15[VAR_7++] = VAR_32;", "}", "break;", "case '/':\n{", "int VAR_33, VAR_34, VAR_35;", "while (qemu_isspace(*VAR_2))\nVAR_2++;", "if (*VAR_2 == '/') {", "VAR_2++;", "VAR_33 = 1;", "if (qemu_isdigit(*VAR_2)) {", "VAR_33 = 0;", "while (qemu_isdigit(*VAR_2)) {", "VAR_33 = VAR_33 * 10 + (*VAR_2 - '0');", "VAR_2++;", "}", "}", "VAR_35 = -1;", "VAR_34 = -1;", "for(;;) {", "switch(*VAR_2) {", "case 'o':\ncase 'd':\ncase 'u':\ncase 'x':\ncase 'VAR_9':\ncase 'VAR_6':\nVAR_34 = *VAR_2++;", "break;", "case 'b':\nVAR_35 = 1;", "VAR_2++;", "break;", "case 'h':\nVAR_35 = 2;", "VAR_2++;", "break;", "case 'w':\nVAR_35 = 4;", "VAR_2++;", "break;", "case 'g':\ncase 'L':\nVAR_35 = 8;", "VAR_2++;", "break;", "default:\ngoto next;", "}", "}", "next:\nif (*VAR_2 != '\\0' && !qemu_isspace(*VAR_2)) {", "monitor_printf(VAR_30, \"invalid char in VAR_34: '%VAR_6'\\n\",\n*VAR_2);", "goto fail;", "}", "if (VAR_34 < 0)\nVAR_34 = default_fmt_format;", "if (VAR_34 != 'VAR_9') {", "if (VAR_35 < 0)\nVAR_35 = default_fmt_size;", "default_fmt_size = VAR_35;", "}", "default_fmt_format = VAR_34;", "} else {", "VAR_33 = 1;", "VAR_34 = default_fmt_format;", "if (VAR_34 != 'VAR_9') {", "VAR_35 = default_fmt_size;", "} else {", "VAR_35 = -1;", "}", "}", "if (VAR_7 + 3 > MAX_ARGS)\ngoto error_args;", "VAR_15[VAR_7++] = (void*)(long)VAR_33;", "VAR_15[VAR_7++] = (void*)(long)VAR_34;", "VAR_15[VAR_7++] = (void*)(long)VAR_35;", "}", "break;", "case 'VAR_9':\ncase 'l':\n{", "int64_t val;", "while (qemu_isspace(*VAR_2))\nVAR_2++;", "if (*VAR_4 == '?' || *VAR_4 == '.') {", "if (*VAR_4 == '?') {", "if (*VAR_2 == '\\0')\nVAR_10 = 0;", "else\nVAR_10 = 1;", "} else {", "if (*VAR_2 == '.') {", "VAR_2++;", "while (qemu_isspace(*VAR_2))\nVAR_2++;", "VAR_10 = 1;", "} else {", "VAR_10 = 0;", "}", "}", "VAR_4++;", "if (VAR_7 >= MAX_ARGS)\ngoto error_args;", "VAR_15[VAR_7++] = (void *)(long)VAR_10;", "if (!VAR_10) {", "if (VAR_7 >= MAX_ARGS)\ngoto error_args;", "val = -1;", "goto add_num;", "}", "}", "if (get_expr(VAR_30, &val, &VAR_2))\ngoto fail;", "add_num:\nif (VAR_6 == 'VAR_9') {", "if (VAR_7 >= MAX_ARGS)\ngoto error_args;", "VAR_15[VAR_7++] = (void *)(long)val;", "} else {", "if ((VAR_7 + 1) >= MAX_ARGS)\ngoto error_args;", "#if TARGET_PHYS_ADDR_BITS > 32\nVAR_15[VAR_7++] = (void *)(long)((val >> 32) & 0xffffffff);", "#else\nVAR_15[VAR_7++] = (void *)0;", "#endif\nVAR_15[VAR_7++] = (void *)(long)(val & 0xffffffff);", "}", "}", "break;", "case '-':\n{", "int VAR_36;", "VAR_6 = *VAR_4++;", "if (VAR_6 == '\\0')\ngoto bad_type;", "while (qemu_isspace(*VAR_2))\nVAR_2++;", "VAR_36 = 0;", "if (*VAR_2 == '-') {", "VAR_2++;", "if (*VAR_2 != VAR_6) {", "monitor_printf(VAR_30, \"%s: unsupported option -%VAR_6\\n\",\nVAR_12, *VAR_2);", "goto fail;", "}", "VAR_2++;", "VAR_36 = 1;", "}", "if (VAR_7 >= MAX_ARGS)\ngoto error_args;", "VAR_15[VAR_7++] = (void *)(long)VAR_36;", "}", "break;", "default:\nbad_type:\nmonitor_printf(VAR_30, \"%s: unknown type '%VAR_6'\\n\", VAR_12, VAR_6);", "goto fail;", "}", "}", "while (qemu_isspace(*VAR_2))\nVAR_2++;", "if (*VAR_2 != '\\0') {", "monitor_printf(VAR_30, \"%s: extraneous characters at the end of line\\n\",\nVAR_12);", "goto fail;", "}", "switch(VAR_7) {", "case 0:\nVAR_16 = VAR_11->handler;", "VAR_16(VAR_30);", "break;", "case 1:\nVAR_17 = VAR_11->handler;", "VAR_17(VAR_30, VAR_15[0]);", "break;", "case 2:\nVAR_19 = VAR_11->handler;", "VAR_19(VAR_30, VAR_15[0], VAR_15[1]);", "break;", "case 3:\nVAR_21 = VAR_11->handler;", "VAR_21(VAR_30, VAR_15[0], VAR_15[1], VAR_15[2]);", "break;", "case 4:\nVAR_23 = VAR_11->handler;", "VAR_23(VAR_30, VAR_15[0], VAR_15[1], VAR_15[2], VAR_15[3]);", "break;", "case 5:\nVAR_25 = VAR_11->handler;", "VAR_25(VAR_30, VAR_15[0], VAR_15[1], VAR_15[2], VAR_15[3], VAR_15[4]);", "break;", "case 6:\nVAR_27 = VAR_11->handler;", "VAR_27(VAR_30, VAR_15[0], VAR_15[1], VAR_15[2], VAR_15[3], VAR_15[4], VAR_15[5]);", "break;", "case 7:\nVAR_29 = VAR_11->handler;", "VAR_29(VAR_30, VAR_15[0], VAR_15[1], VAR_15[2], VAR_15[3], VAR_15[4], VAR_15[5],\nVAR_15[6]);", "break;", "default:\nmonitor_printf(VAR_30, \"unsupported number of arguments: %d\\n\", VAR_7);", "goto fail;", "}", "fail:\nfor(VAR_9 = 0; VAR_9 < MAX_ARGS; VAR_9++)", "qemu_free(VAR_14[VAR_9]);", "return;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29, 31 ], [ 33, 35 ], [ 37, 39 ], [ 41, 43 ], [ 47, 49 ], [ 51, 57 ], [ 59 ], [ 61, 63 ], [ 65, 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77, 79 ], [ 81 ], [ 83 ], [ 89 ], [ 91, 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101, 105 ], [ 107 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121, 123 ], [ 125 ], [ 127 ], [ 129, 131, 133, 135 ], [ 137 ], [ 139 ], [ 143, 145 ], [ 147 ], [ 149 ], [ 151 ], [ 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 ], [ 229, 231 ], [ 233 ], [ 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 ], [ 319 ], [ 321, 323 ], [ 325, 327 ], [ 329 ], [ 331 ], [ 333, 335 ], [ 337 ], [ 341, 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369, 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383, 385, 387 ], [ 389 ], [ 393, 395 ], [ 397 ], [ 399 ], [ 401, 403 ], [ 405, 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415, 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431, 433 ], [ 435 ], [ 437 ], [ 439, 441 ], [ 443 ], [ 445 ], [ 447 ], [ 449 ], [ 451, 453 ], [ 455, 457 ], [ 459, 461 ], [ 463 ], [ 465 ], [ 467, 469 ], [ 471, 473 ], [ 475, 477 ], [ 479, 481 ], [ 483 ], [ 485 ], [ 487 ], [ 489, 491 ], [ 493 ], [ 499 ], [ 501, 503 ], [ 505, 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515 ], [ 517, 519 ], [ 521 ], [ 523 ], [ 525 ], [ 527 ], [ 529 ], [ 531, 533 ], [ 535 ], [ 537 ], [ 539 ], [ 541, 543, 545 ], [ 547 ], [ 549 ], [ 551 ], [ 555, 557 ], [ 559 ], [ 561, 563 ], [ 565 ], [ 567 ], [ 571 ], [ 573, 575 ], [ 577 ], [ 579 ], [ 581, 583 ], [ 585 ], [ 587 ], [ 589, 591 ], [ 593 ], [ 595 ], [ 597, 599 ], [ 601 ], [ 603 ], [ 605, 607 ], [ 609 ], [ 611 ], [ 613, 615 ], [ 617 ], [ 619 ], [ 621, 623 ], [ 625 ], [ 627 ], [ 629, 631 ], [ 633, 635 ], [ 637 ], [ 639, 641 ], [ 643 ], [ 645 ], [ 647, 649 ], [ 651 ], [ 653 ], [ 655 ] ]

[ "static void FUNC_0(void *VAR_0, int VAR_1, int VAR_2)\n{", "NVICState *s = VAR_0;", "if (VAR_2) {", "armv7m_nvic_set_pending(s, ARMV7M_EXCP_SYSTICK);", "}", "}" ]

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

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

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

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

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

[ "void FUNC_0(QemuOpts *VAR_0, const char *VAR_1)\n{", "QemuOpt *opt;", "QemuOptDesc *desc = VAR_0->list->desc;", "const char *VAR_2 = \"\";", "if (VAR_0->id) {", "printf(\"id=%s\", VAR_0->id);", "VAR_2 = VAR_1;", "}", "if (desc[0].name == NULL) {", "QTAILQ_FOREACH(opt, &VAR_0->head, next) {", "printf(\"%s%s=\", VAR_2, opt->name);", "escaped_print(opt->str);", "VAR_2 = VAR_1;", "}", "return;", "}", "for (; desc && desc->name; desc++) {", "const char *value;", "QemuOpt *opt = qemu_opt_find(VAR_0, desc->name);", "value = opt ? opt->str : desc->def_value_str;", "if (!value) {", "continue;", "}", "if (desc->type == QEMU_OPT_STRING) {", "printf(\"%s%s=\", VAR_2, desc->name);", "escaped_print(value);", "} else if ((desc->type == QEMU_OPT_SIZE ||", "desc->type == QEMU_OPT_NUMBER) && opt) {", "printf(\"%s%s=%\" PRId64, VAR_2, desc->name, opt->value.uint);", "} else {", "printf(\"%s%s=%s\", VAR_2, desc->name, value);", "}", "VAR_2 = 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 ]

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

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

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

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

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

[ 0, 0, 0, 0, 0 ]

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

[ "void FUNC_0(DSPContext* VAR_0, AVCodecContext *VAR_1)\n{", "if (mm_flags & FF_MM_MMX) {", "const int VAR_2 = VAR_1->VAR_2;", "if(VAR_2==FF_DCT_AUTO || VAR_2==FF_DCT_MMX){", "if(mm_flags & FF_MM_SSE2){", "VAR_0->fdct = ff_fdct_sse2;", "}else if(mm_flags & FF_MM_MMX2){", "VAR_0->fdct = ff_fdct_mmx2;", "}else{", "VAR_0->fdct = ff_fdct_mmx;", "}", "}", "VAR_0->get_pixels = get_pixels_mmx;", "VAR_0->diff_pixels = diff_pixels_mmx;", "VAR_0->pix_sum = pix_sum16_mmx;", "VAR_0->diff_bytes= diff_bytes_mmx;", "VAR_0->sum_abs_dctelem= sum_abs_dctelem_mmx;", "VAR_0->hadamard8_diff[0]= hadamard8_diff16_mmx;", "VAR_0->hadamard8_diff[1]= hadamard8_diff_mmx;", "VAR_0->pix_norm1 = pix_norm1_mmx;", "VAR_0->sse[0] = (mm_flags & FF_MM_SSE2) ? sse16_sse2 : sse16_mmx;", "VAR_0->sse[1] = sse8_mmx;", "VAR_0->vsad[4]= vsad_intra16_mmx;", "VAR_0->nsse[0] = nsse16_mmx;", "VAR_0->nsse[1] = nsse8_mmx;", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->vsad[0] = vsad16_mmx;", "}", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->try_8x8basis= try_8x8basis_mmx;", "}", "VAR_0->add_8x8basis= add_8x8basis_mmx;", "VAR_0->ssd_int8_vs_int16 = ssd_int8_vs_int16_mmx;", "if (mm_flags & FF_MM_MMX2) {", "VAR_0->sum_abs_dctelem= sum_abs_dctelem_mmx2;", "VAR_0->hadamard8_diff[0]= hadamard8_diff16_mmx2;", "VAR_0->hadamard8_diff[1]= hadamard8_diff_mmx2;", "VAR_0->vsad[4]= vsad_intra16_mmx2;", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->vsad[0] = vsad16_mmx2;", "}", "VAR_0->sub_hfyu_median_prediction= sub_hfyu_median_prediction_mmx2;", "}", "if(mm_flags & FF_MM_SSE2){", "VAR_0->get_pixels = get_pixels_sse2;", "VAR_0->sum_abs_dctelem= sum_abs_dctelem_sse2;", "VAR_0->hadamard8_diff[0]= hadamard8_diff16_sse2;", "VAR_0->hadamard8_diff[1]= hadamard8_diff_sse2;", "#if CONFIG_LPC\nVAR_0->lpc_compute_autocorr = ff_lpc_compute_autocorr_sse2;", "#endif\n}", "#if HAVE_SSSE3\nif(mm_flags & FF_MM_SSSE3){", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->try_8x8basis= try_8x8basis_ssse3;", "}", "VAR_0->add_8x8basis= add_8x8basis_ssse3;", "VAR_0->sum_abs_dctelem= sum_abs_dctelem_ssse3;", "VAR_0->hadamard8_diff[0]= hadamard8_diff16_ssse3;", "VAR_0->hadamard8_diff[1]= hadamard8_diff_ssse3;", "}", "#endif\nif(mm_flags & FF_MM_3DNOW){", "if(!(VAR_1->flags & CODEC_FLAG_BITEXACT)){", "VAR_0->try_8x8basis= try_8x8basis_3dnow;", "}", "VAR_0->add_8x8basis= add_8x8basis_3dnow;", "}", "}", "dsputil_init_pix_mmx(VAR_0, VAR_1);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123, 125 ], [ 127, 129 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153, 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 175 ] ]

[ "PCIINTxRoute FUNC_0(PCIDevice *dev, int pin)\n{", "PCIBus *bus;", "do {", "bus = dev->bus;", "pin = bus->map_irq(dev, pin);", "dev = bus->parent_dev;", "} while (dev);", "assert(bus->route_intx_to_irq);", "return bus->route_intx_to_irq(bus->irq_opaque, pin);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "UHCIState *s = VAR_0;", "int64_t expire_time;", "uint32_t frame_addr, link, old_td_ctrl, val, int_mask;", "int VAR_1, VAR_2;", "UHCI_TD td;", "UHCI_QH qh;", "uint32_t old_async_qh;", "if (!(s->cmd & UHCI_CMD_RS)) {", "qemu_del_timer(s->frame_timer);", "s->status |= UHCI_STS_HCHALTED;", "return;", "}", "s->frnum = (s->frnum + 1) & 0x7ff;", "if (s->pending_int_mask) {", "s->status2 |= s->pending_int_mask;", "s->status |= UHCI_STS_USBINT;", "uhci_update_irq(s);", "}", "old_async_qh = s->async_qh;", "frame_addr = s->fl_base_addr + ((s->frnum & 0x3ff) << 2);", "cpu_physical_memory_read(frame_addr, (uint8_t *)&link, 4);", "le32_to_cpus(&link);", "int_mask = 0;", "VAR_1 = FRAME_MAX_LOOPS;", "while ((link & 1) == 0) {", "if (--VAR_1 == 0)\nbreak;", "if (link & 2) {", "if (link == s->async_qh) {", "old_async_qh = 0;", "break;", "}", "cpu_physical_memory_read(link & ~0xf, (uint8_t *)&qh, sizeof(qh));", "le32_to_cpus(&qh.link);", "le32_to_cpus(&qh.el_link);", "depth_first:\nif (qh.el_link & 1) {", "link = qh.link;", "} else if (qh.el_link & 2) {", "link = qh.el_link;", "} else if (s->async_qh) {", "link = qh.link;", "} else {", "if (--VAR_1 == 0)\nbreak;", "cpu_physical_memory_read(qh.el_link & ~0xf,\n(uint8_t *)&td, sizeof(td));", "le32_to_cpus(&td.link);", "le32_to_cpus(&td.ctrl);", "le32_to_cpus(&td.token);", "le32_to_cpus(&td.buffer);", "old_td_ctrl = td.ctrl;", "VAR_2 = uhci_handle_td(s, &td, &int_mask, 0);", "if (old_td_ctrl != td.ctrl) {", "val = cpu_to_le32(td.ctrl);", "cpu_physical_memory_write((qh.el_link & ~0xf) + 4,\n(const uint8_t *)&val,\nsizeof(val));", "}", "if (VAR_2 < 0)\nbreak;", "if (VAR_2 == 2) {", "s->async_qh = link;", "} else if (VAR_2 == 0) {", "qh.el_link = td.link;", "val = cpu_to_le32(qh.el_link);", "cpu_physical_memory_write((link & ~0xf) + 4,\n(const uint8_t *)&val,\nsizeof(val));", "if (qh.el_link & 4) {", "goto depth_first;", "}", "}", "link = qh.link;", "}", "} else {", "cpu_physical_memory_read(link & ~0xf, (uint8_t *)&td, sizeof(td));", "le32_to_cpus(&td.link);", "le32_to_cpus(&td.ctrl);", "le32_to_cpus(&td.token);", "le32_to_cpus(&td.buffer);", "old_td_ctrl = td.ctrl;", "VAR_2 = uhci_handle_td(s, &td, &int_mask, 0);", "if (old_td_ctrl != td.ctrl) {", "val = cpu_to_le32(td.ctrl);", "cpu_physical_memory_write((link & ~0xf) + 4,\n(const uint8_t *)&val,\nsizeof(val));", "}", "if (VAR_2 < 0)\nbreak;", "if (VAR_2 == 2) {", "s->async_frame_addr = frame_addr;", "}", "link = td.link;", "}", "}", "s->pending_int_mask = int_mask;", "if (old_async_qh) {", "#ifdef DEBUG\nprintf(\"Discarding USB packet\\n\");", "#endif\nusb_cancel_packet(&s->usb_packet);", "s->async_qh = 0;", "}", "expire_time = qemu_get_clock(vm_clock) +\n(ticks_per_sec / FRAME_TIMER_FREQ);", "qemu_mod_timer(s->frame_timer, expire_time);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 67 ], [ 71 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89, 91 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 109 ], [ 111 ], [ 115, 117 ], [ 119, 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 139 ], [ 141 ], [ 143, 145, 147 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 165 ], [ 167, 169, 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 185 ], [ 187 ], [ 189 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 209 ], [ 211 ], [ 217 ], [ 219 ], [ 221, 223, 225 ], [ 227 ], [ 229, 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 255, 257 ], [ 259, 261 ], [ 263 ], [ 265 ], [ 271, 273 ], [ 275 ], [ 277 ] ]

[ "static int FUNC_0(QEMUFile *VAR_0, void *VAR_1)\n{", "int VAR_2;", "DPRINTF(\"Enter save live iterate submitted %d transferred %d\\n\",\nblock_mig_state.submitted, block_mig_state.transferred);", "VAR_2 = flush_blks(VAR_0);", "if (VAR_2) {", "blk_mig_cleanup();", "return VAR_2;", "}", "blk_mig_reset_dirty_cursor();", "while ((block_mig_state.submitted +\nblock_mig_state.read_done) * BLOCK_SIZE <\nqemu_file_get_rate_limit(VAR_0)) {", "if (block_mig_state.bulk_completed == 0) {", "if (blk_mig_save_bulked_block(VAR_0) == 0) {", "block_mig_state.bulk_completed = 1;", "}", "} else {", "VAR_2 = blk_mig_save_dirty_block(VAR_0, 1);", "if (VAR_2 != 0) {", "break;", "}", "}", "}", "if (VAR_2 < 0) {", "blk_mig_cleanup();", "return VAR_2;", "}", "VAR_2 = flush_blks(VAR_0);", "if (VAR_2) {", "blk_mig_cleanup();", "return VAR_2;", "}", "qemu_put_be64(VAR_0, BLK_MIG_FLAG_EOS);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 9, 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 33, 35, 37 ], [ 39 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 93 ], [ 95 ] ]

[ "FUNC_0(void *VAR_0, hwaddr VAR_1, unsigned VAR_2)\n{", "SDHCIState *s = (SDHCIState *)VAR_0;", "return SDHCI_GET_CLASS(s)->mem_read(s, VAR_1, VAR_2);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "void FUNC_0(MigrationState *VAR_0)\n{", "DPRINTF(\"setting error state\\n\");", "VAR_0->state = MIG_STATE_ERROR;", "notifier_list_notify(&migration_state_notifiers, VAR_0);", "migrate_fd_cleanup(VAR_0);", "}" ]

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

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

[ "static int FUNC_0(QEMUFile *VAR_0, void *VAR_1, int VAR_2)\n{", "VirtIOSCSI *s = VAR_1;", "virtio_load(&s->vdev, VAR_0);", "return 0;", "}" ]

[ 0, 0, 1, 0, 0 ]

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

[ "static int FUNC_0(AVIOContext *VAR_0, int VAR_1, char **VAR_2)\n{", "av_free(*VAR_2);", "if (!(*VAR_2 = av_malloc(VAR_1 + 1)))\nreturn AVERROR(ENOMEM);", "if (avio_read(VAR_0, (uint8_t *) *VAR_2, VAR_1) != VAR_1) {", "av_freep(VAR_2);", "return AVERROR(EIO);", "}", "(*VAR_2)[VAR_1] = '\\0';", "return 0;", "}" ]

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

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

[ "ARITH3(addlv)\nARITH3(sublv)\nARITH3(addqv)\nARITH3(subqv)\nARITH3(umulh)\nARITH3(mullv)\nARITH3(mulqv)\nARITH3(minub8)\nARITH3(minsb8)\nARITH3(minuw4)\nARITH3(minsw4)\nARITH3(maxub8)\nARITH3(maxsb8)\nARITH3(maxuw4)\nARITH3(maxsw4)\nARITH3(perr)\n#define MVIOP2(name) \\\nstatic inline void glue(gen_, name)(int rb, int rc) \\\n{ \\", "if (unlikely(rc == 31)) \\\nreturn; \\", "if (unlikely(rb == 31)) \\\ntcg_gen_movi_i64(cpu_ir[rc], 0); \\", "else \\\ngen_helper_ ## name (cpu_ir[rc], cpu_ir[rb]); \\", "}", "MVIOP2(pklb)\nMVIOP2(pkwb)\nMVIOP2(unpkbl)\nMVIOP2(unpkbw)\nstatic void gen_cmp(TCGCond cond, int ra, int rb, int rc,\nint islit, uint8_t lit)\n{", "TCGv va, vb;", "if (unlikely(rc == 31)) {", "return;", "}", "if (ra == 31) {", "va = tcg_const_i64(0);", "} else {", "va = cpu_ir[ra];", "}", "if (islit) {", "vb = tcg_const_i64(lit);", "} else {", "vb = cpu_ir[rb];", "}", "tcg_gen_setcond_i64(cond, cpu_ir[rc], va, vb);", "if (ra == 31) {", "tcg_temp_free(va);", "}", "if (islit) {", "tcg_temp_free(vb);", "}", "}" ]

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

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

[ "void FUNC_0(CPUPPCState *VAR_0, target_ulong VAR_1)\n{", "LOG_MMU(\"%s: \" TARGET_FMT_lx \"\\n\", __func__, VAR_1);", "if (VAR_0->spr[SPR_SDR1] != VAR_1) {", "VAR_0->spr[SPR_SDR1] = VAR_1;", "#if defined(TARGET_PPC64)\nif (VAR_0->mmu_model & POWERPC_MMU_64) {", "target_ulong htabsize = VAR_1 & SDR_64_HTABSIZE;", "if (htabsize > 28) {", "fprintf(stderr, \"Invalid HTABSIZE 0x\" TARGET_FMT_lx\n\" stored in SDR1\\n\", htabsize);", "htabsize = 28;", "}", "VAR_0->htab_mask = (1ULL << (htabsize + 18)) - 1;", "VAR_0->htab_base = VAR_1 & SDR_64_HTABORG;", "} else", "#endif\n{", "VAR_0->htab_mask = ((VAR_1 & SDR_32_HTABMASK) << 16) | 0xFFFF;", "VAR_0->htab_base = VAR_1 & SDR_32_HTABORG;", "}", "tlb_flush(VAR_0, 1);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 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 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ] ]

[ "void FUNC_0(BlockDriverState *VAR_0, BlockDriverState *VAR_1,\nconst char *VAR_2, int64_t VAR_3,\nBlockdevOnError VAR_4,\nBlockCompletionFunc *VAR_5,\nvoid *VAR_6, Error **VAR_7)\n{", "StreamBlockJob *s;", "s = block_job_create(&stream_job_driver, VAR_0, VAR_3, VAR_5, VAR_6, VAR_7);", "if (!s) {", "return;", "}", "s->VAR_1 = VAR_1;", "s->VAR_2 = g_strdup(VAR_2);", "s->VAR_4 = VAR_4;", "s->common.co = qemu_coroutine_create(stream_run);", "trace_stream_start(VAR_0, VAR_1, s, s->common.co, VAR_6);", "qemu_coroutine_enter(s->common.co, s);", "}" ]

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

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

[ "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{", "IPMI_CHECK_CMD_LEN(8);", "IPMI_CHECK_RESERVATION(2, VAR_0->sel.reservation);", "if (VAR_1[4] != 'C' || VAR_1[5] != 'L' || VAR_1[6] != 'R') {", "VAR_3[2] = IPMI_CC_INVALID_DATA_FIELD;", "return;", "}", "if (VAR_1[7] == 0xaa) {", "VAR_0->sel.next_free = 0;", "VAR_0->sel.overflow = 0;", "set_timestamp(VAR_0, VAR_0->sdr.last_clear);", "IPMI_ADD_RSP_DATA(1);", "sel_inc_reservation(&VAR_0->sel);", "} else if (VAR_1[7] == 0) {", "IPMI_ADD_RSP_DATA(1);", "} else {", "VAR_3[2] = IPMI_CC_INVALID_DATA_FIELD;", "return;", "}", "}" ]

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

[ "int FUNC_0(DWTContext *VAR_0, IDWTELEM *VAR_1, int VAR_2, int VAR_3,\nint VAR_4, enum dwt_type VAR_5, int VAR_6,\nIDWTELEM *VAR_7)\n{", "int VAR_8;", "VAR_0->VAR_1 = VAR_1;", "VAR_0->VAR_2 = VAR_2;", "VAR_0->VAR_3 = VAR_3;", "VAR_0->VAR_4 = VAR_4;", "VAR_0->VAR_6 = VAR_6;", "VAR_0->VAR_7 = VAR_7 + 8;", "for(VAR_8=VAR_6-1; VAR_8>=0; VAR_8--){", "int VAR_9 = VAR_3 >> VAR_8;", "int VAR_10 = VAR_4 << VAR_8;", "switch(VAR_5){", "case DWT_DIRAC_DD9_7:\nspatial_compose_dd97i_init(VAR_0->cs+VAR_8, VAR_1, VAR_9, VAR_10);", "break;", "case DWT_DIRAC_LEGALL5_3:\nspatial_compose53i_init2(VAR_0->cs+VAR_8, VAR_1, VAR_9, VAR_10);", "break;", "case DWT_DIRAC_DD13_7:\nspatial_compose_dd137i_init(VAR_0->cs+VAR_8, VAR_1, VAR_9, VAR_10);", "break;", "case DWT_DIRAC_HAAR0:\ncase DWT_DIRAC_HAAR1:\nVAR_0->cs[VAR_8].y = 1;", "break;", "case DWT_DIRAC_DAUB9_7:\nspatial_compose97i_init2(VAR_0->cs+VAR_8, VAR_1, VAR_9, VAR_10);", "break;", "default:\nVAR_0->cs[VAR_8].y = 0;", "break;", "}", "}", "switch (VAR_5) {", "case DWT_DIRAC_DD9_7:\nVAR_0->spatial_compose = spatial_compose_dd97i_dy;", "VAR_0->vertical_compose_l0 = (void*)vertical_compose53iL0;", "VAR_0->vertical_compose_h0 = (void*)vertical_compose_dd97iH0;", "VAR_0->horizontal_compose = horizontal_compose_dd97i;", "VAR_0->support = 7;", "break;", "case DWT_DIRAC_LEGALL5_3:\nVAR_0->spatial_compose = spatial_compose_dirac53i_dy;", "VAR_0->vertical_compose_l0 = (void*)vertical_compose53iL0;", "VAR_0->vertical_compose_h0 = (void*)vertical_compose_dirac53iH0;", "VAR_0->horizontal_compose = horizontal_compose_dirac53i;", "VAR_0->support = 3;", "break;", "case DWT_DIRAC_DD13_7:\nVAR_0->spatial_compose = spatial_compose_dd137i_dy;", "VAR_0->vertical_compose_l0 = (void*)vertical_compose_dd137iL0;", "VAR_0->vertical_compose_h0 = (void*)vertical_compose_dd97iH0;", "VAR_0->horizontal_compose = horizontal_compose_dd137i;", "VAR_0->support = 7;", "break;", "case DWT_DIRAC_HAAR0:\ncase DWT_DIRAC_HAAR1:\nVAR_0->spatial_compose = spatial_compose_haari_dy;", "VAR_0->vertical_compose = (void*)vertical_compose_haar;", "if (VAR_5 == DWT_DIRAC_HAAR0)\nVAR_0->horizontal_compose = horizontal_compose_haar0i;", "else\nVAR_0->horizontal_compose = horizontal_compose_haar1i;", "VAR_0->support = 1;", "break;", "case DWT_DIRAC_FIDELITY:\nVAR_0->spatial_compose = spatial_compose_fidelity;", "VAR_0->vertical_compose_l0 = (void*)vertical_compose_fidelityiL0;", "VAR_0->vertical_compose_h0 = (void*)vertical_compose_fidelityiH0;", "VAR_0->horizontal_compose = horizontal_compose_fidelityi;", "break;", "case DWT_DIRAC_DAUB9_7:\nVAR_0->spatial_compose = spatial_compose_daub97i_dy;", "VAR_0->vertical_compose_l0 = (void*)vertical_compose_daub97iL0;", "VAR_0->vertical_compose_h0 = (void*)vertical_compose_daub97iH0;", "VAR_0->vertical_compose_l1 = (void*)vertical_compose_daub97iL1;", "VAR_0->vertical_compose_h1 = (void*)vertical_compose_daub97iH1;", "VAR_0->horizontal_compose = horizontal_compose_daub97i;", "VAR_0->support = 5;", "break;", "default:\nav_log(NULL, AV_LOG_ERROR, \"Unknown wavelet VAR_5 %VAR_0\\n\", VAR_5);", "return -1;", "}", "if (HAVE_MMX) ff_spatial_idwt_init_mmx(VAR_0, VAR_5);", "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 ]

[ [ 1, 3, 5, 7 ], [ 9 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37, 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55, 57, 59 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 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 ], [ 156 ], [ 158, 160 ], [ 162 ], [ 164 ], [ 166 ], [ 168 ], [ 170 ], [ 172 ], [ 174 ], [ 176, 178 ], [ 180 ], [ 182 ], [ 186 ], [ 190 ], [ 192 ] ]

[ "static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{", "M68kCPU *cpu = M68K_CPU(VAR_0);", "M68kCPUClass *mcc = M68K_CPU_GET_CLASS(VAR_0);", "m68k_cpu_init_gdb(cpu);", "cpu_reset(CPU(cpu));", "mcc->parent_realize(VAR_0, VAR_1);", "}" ]

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

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

[ "void FUNC_0(ReadLineState *VAR_0, int VAR_1, const char *VAR_2)\n{", "int VAR_3, VAR_4, VAR_5;", "NetClientState *ncs[MAX_QUEUE_NUM];", "if (VAR_1 != 2) {", "return;", "}", "VAR_3 = strlen(VAR_2);", "readline_set_completion_index(VAR_0, VAR_3);", "VAR_4 = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_OPTIONS_KIND_NIC,\nMAX_QUEUE_NUM);", "for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {", "QemuOpts *opts;", "const char *VAR_6 = ncs[VAR_5]->VAR_6;", "if (strncmp(VAR_2, VAR_6, VAR_3)) {", "continue;", "}", "opts = qemu_opts_find(qemu_find_opts_err(\"netdev\", NULL), VAR_6);", "if (opts) {", "readline_add_completion(VAR_0, VAR_6);", "}", "}", "}" ]

[ 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 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23, 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ] ]

[ "static void FUNC_0(RDMACapabilities *VAR_0)\n{", "VAR_0->version = htonl(VAR_0->version);", "VAR_0->flags = htonl(VAR_0->flags);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(PCIBus *VAR_0, PIIX4PMState *VAR_1)\n{", "register_ioport_write(GPE_BASE, GPE_LEN, 1, gpe_writeb, VAR_1);", "register_ioport_read(GPE_BASE, GPE_LEN, 1, gpe_readb, VAR_1);", "acpi_gpe_blk(&VAR_1->ar, GPE_BASE);", "register_ioport_read(PCI_UP_BASE, 4, 4, pci_up_read, VAR_1);", "register_ioport_read(PCI_DOWN_BASE, 4, 4, pci_down_read, VAR_1);", "register_ioport_write(PCI_EJ_BASE, 4, 4, pciej_write, VAR_0);", "register_ioport_read(PCI_EJ_BASE, 4, 4, pciej_read, VAR_0);", "register_ioport_write(PCI_RMV_BASE, 4, 4, pcirmv_write, VAR_1);", "register_ioport_read(PCI_RMV_BASE, 4, 4, pcirmv_read, VAR_1);", "pci_bus_hotplug(VAR_0, piix4_device_hotplug, &VAR_1->dev.qdev);", "}" ]

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

[ [ 1, 3 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ] ]

[ "void FUNC_0(const char *VAR_0, const char *VAR_1,\nbool VAR_2, const char *VAR_3,\nenum MirrorSyncMode VAR_4,\nbool VAR_5, enum NewImageMode VAR_6,\nbool VAR_7, int64_t VAR_8,\nbool VAR_9, BlockdevOnError VAR_10,\nbool VAR_11, BlockdevOnError VAR_12,\nError **VAR_13)\n{", "BlockDriverState *bs;", "BlockDriverState *target_bs;", "BlockDriverState *source = NULL;", "AioContext *aio_context;", "BlockDriver *drv = NULL;", "Error *local_err = NULL;", "int VAR_14;", "int64_t size;", "int VAR_15;", "if (!VAR_7) {", "VAR_8 = 0;", "}", "if (!VAR_9) {", "VAR_10 = BLOCKDEV_ON_ERROR_REPORT;", "}", "if (!VAR_11) {", "VAR_12 = BLOCKDEV_ON_ERROR_REPORT;", "}", "if (!VAR_5) {", "VAR_6 = NEW_IMAGE_MODE_ABSOLUTE_PATHS;", "}", "bs = bdrv_find(VAR_0);", "if (!bs) {", "error_set(VAR_13, QERR_DEVICE_NOT_FOUND, VAR_0);", "return;", "}", "aio_context = bdrv_get_aio_context(bs);", "aio_context_acquire(aio_context);", "if (!bdrv_is_inserted(bs)) {", "error_set(VAR_13, QERR_DEVICE_HAS_NO_MEDIUM, VAR_0);", "goto out;", "}", "if (!VAR_2) {", "VAR_3 = VAR_6 == NEW_IMAGE_MODE_EXISTING ? NULL : bs->drv->format_name;", "}", "if (VAR_3) {", "drv = bdrv_find_format(VAR_3);", "if (!drv) {", "error_set(VAR_13, QERR_INVALID_BLOCK_FORMAT, VAR_3);", "goto out;", "}", "}", "if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, VAR_13)) {", "goto out;", "}", "VAR_14 = bs->open_flags | BDRV_O_RDWR;", "if (VAR_4 == MIRROR_SYNC_MODE_TOP) {", "source = bs->backing_hd;", "if (!source) {", "VAR_4 = MIRROR_SYNC_MODE_FULL;", "}", "}", "if (VAR_4 == MIRROR_SYNC_MODE_NONE) {", "source = bs;", "}", "size = bdrv_getlength(bs);", "if (size < 0) {", "error_setg_errno(VAR_13, -size, \"bdrv_getlength failed\");", "goto out;", "}", "if (VAR_6 != NEW_IMAGE_MODE_EXISTING) {", "assert(VAR_3 && drv);", "if (source) {", "bdrv_img_create(VAR_1, VAR_3, source->filename,\nsource->drv->format_name, NULL,\nsize, VAR_14, &local_err, false);", "} else {", "bdrv_img_create(VAR_1, VAR_3, NULL, NULL, NULL,\nsize, VAR_14, &local_err, false);", "}", "}", "if (local_err) {", "error_propagate(VAR_13, local_err);", "goto out;", "}", "target_bs = NULL;", "VAR_15 = bdrv_open(&target_bs, VAR_1, NULL, NULL, VAR_14, drv, &local_err);", "if (VAR_15 < 0) {", "error_propagate(VAR_13, local_err);", "goto out;", "}", "bdrv_set_aio_context(target_bs, aio_context);", "backup_start(bs, target_bs, VAR_8, VAR_4, VAR_10, VAR_12,\nblock_job_cb, bs, &local_err);", "if (local_err != NULL) {", "bdrv_unref(target_bs);", "error_propagate(VAR_13, local_err);", "goto out;", "}", "out:\naio_context_release(aio_context);", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13, 15, 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 120 ], [ 122 ], [ 124 ], [ 128 ], [ 136 ], [ 138 ], [ 140 ], [ 142 ], [ 144 ], [ 146 ], [ 148 ], [ 150 ], [ 152 ], [ 156 ], [ 158 ], [ 160 ], [ 162 ], [ 164 ], [ 168 ], [ 170 ], [ 172 ], [ 174, 176, 178 ], [ 180 ], [ 182, 184 ], [ 186 ], [ 188 ], [ 192 ], [ 194 ], [ 196 ], [ 198 ], [ 202 ], [ 204 ], [ 206 ], [ 208 ], [ 210 ], [ 212 ], [ 216 ], [ 220, 222 ], [ 224 ], [ 226 ], [ 228 ], [ 230 ], [ 232 ], [ 236, 238 ], [ 240 ] ]

[ "static uint32_t FUNC_0(char *str,\nEnumTable *table, uint32_t not_found_value)\n{", "uint32_t ret = not_found_value;", "while (table->name != NULL) {", "if (strcmp(table->name, str) == 0) {", "ret = table->value;", "break;", "}", "table++;", "}", "return ret;", "}" ]

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

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

[ "static int FUNC_0(AVProbeData *VAR_0)\n{", "unsigned int VAR_1;", "uint32_t tag;", "int VAR_2 = 0;", "VAR_1 = 0;", "for (;;) {", "if ((VAR_1 + 8) > (unsigned int)VAR_0->buf_size)\nreturn VAR_2;", "tag = AV_RL32(VAR_0->buf + VAR_1 + 4);", "switch(tag) {", "case MKTAG('j','P',' ',' '):\ncase MKTAG('m','o','o','v'):\ncase MKTAG('m','d','a','t'):\ncase MKTAG('VAR_0','n','o','t'):\ncase MKTAG('u','d','t','a'):\ncase MKTAG('f','t','y','VAR_0'):\nreturn AVPROBE_SCORE_MAX;", "case MKTAG('e','d','i','w'):\ncase MKTAG('w','i','d','e'):\ncase MKTAG('f','r','e','e'):\ncase MKTAG('j','u','n','k'):\ncase MKTAG('VAR_0','i','c','t'):\nreturn AVPROBE_SCORE_MAX - 5;", "case MKTAG(0x82,0x82,0x7f,0x7d):\ncase MKTAG('s','k','i','VAR_0'):\ncase MKTAG('u','u','i','d'):\ncase MKTAG('VAR_0','r','f','l'):\nVAR_1 = AV_RB32(VAR_0->buf+VAR_1) + VAR_1;", "VAR_2 = AVPROBE_SCORE_MAX - 50;", "break;", "default:\nreturn VAR_2;", "}", "}", "}" ]

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

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

[ "static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{", "VirtIOSerialPort *port = VIRTIO_SERIAL_PORT(VAR_0);", "VirtIOSerialPortClass *vsc = VIRTIO_SERIAL_PORT_GET_CLASS(port);", "VirtIOSerialBus *bus = VIRTIO_SERIAL_BUS(qdev_get_parent_bus(VAR_0));", "VirtIODevice *vdev = VIRTIO_DEVICE(bus->vser);", "int VAR_2;", "bool plugging_port0;", "Error *err = NULL;", "port->vser = bus->vser;", "port->bh = qemu_bh_new(flush_queued_data_bh, port);", "assert(vsc->have_data);", "plugging_port0 = vsc->is_console && !find_port_by_id(port->vser, 0);", "if (find_port_by_id(port->vser, port->id)) {", "error_setg(VAR_1, \"virtio-serial-bus: A port already exists at id %u\",\nport->id);", "return;", "}", "if (find_port_by_name(port->name)) {", "error_setg(VAR_1, \"virtio-serial-bus: A port already exists by name %s\",\nport->name);", "return;", "}", "if (port->id == VIRTIO_CONSOLE_BAD_ID) {", "if (plugging_port0) {", "port->id = 0;", "} else {", "port->id = find_free_port_id(port->vser);", "if (port->id == VIRTIO_CONSOLE_BAD_ID) {", "error_setg(VAR_1, \"virtio-serial-bus: Maximum port limit for \"\n\"this device reached\");", "return;", "}", "}", "}", "VAR_2 = virtio_tswap32(vdev, port->vser->config.VAR_2);", "if (port->id >= VAR_2) {", "error_setg(VAR_1, \"virtio-serial-bus: Out-of-range port id specified, \"\n\"max. allowed: %u\", VAR_2 - 1);", "return;", "}", "vsc->realize(VAR_0, &err);", "if (err != NULL) {", "error_propagate(VAR_1, err);", "return;", "}", "port->elem.out_num = 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 27 ], [ 41 ], [ 45 ], [ 47, 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99, 101 ], [ 103 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ] ]

[ "YUV2RGB(rgb8, uint8_t)\nYUV2RGB(rgb16, uint16_t)\nstatic void png_handle_row(PNGDecContext *s)\n{", "uint8_t *ptr, *last_row;", "int got_line;", "if (!s->interlace_type) {", "ptr = s->image_buf + s->image_linesize * (s->y + s->y_offset) + s->x_offset * s->bpp;", "if (s->y == 0)\nlast_row = s->last_row;", "else\nlast_row = ptr - s->image_linesize;", "png_filter_row(&s->dsp, ptr, s->crow_buf[0], s->crow_buf + 1,\nlast_row, s->row_size, s->bpp);", "if (s->filter_type == PNG_FILTER_TYPE_LOCO && s->y > 0) {", "if (s->bit_depth == 16) {", "deloco_rgb16((uint16_t *)(ptr - s->image_linesize), s->row_size / 2,\ns->color_type == PNG_COLOR_TYPE_RGB_ALPHA);", "} else {", "deloco_rgb8(ptr - s->image_linesize, s->row_size,\ns->color_type == PNG_COLOR_TYPE_RGB_ALPHA);", "}", "}", "s->y++;", "if (s->y == s->cur_h) {", "s->state |= PNG_ALLIMAGE;", "if (s->filter_type == PNG_FILTER_TYPE_LOCO) {", "if (s->bit_depth == 16) {", "deloco_rgb16((uint16_t *)ptr, s->row_size / 2,\ns->color_type == PNG_COLOR_TYPE_RGB_ALPHA);", "} else {", "deloco_rgb8(ptr, s->row_size,\ns->color_type == PNG_COLOR_TYPE_RGB_ALPHA);", "}", "}", "}", "} else {", "got_line = 0;", "for (;;) {", "ptr = s->image_buf + s->image_linesize * (s->y + s->y_offset) + s->x_offset * s->bpp;", "if ((ff_png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) {", "if (got_line)\nbreak;", "png_filter_row(&s->dsp, s->tmp_row, s->crow_buf[0], s->crow_buf + 1,\ns->last_row, s->pass_row_size, s->bpp);", "FFSWAP(uint8_t *, s->last_row, s->tmp_row);", "FFSWAP(unsigned int, s->last_row_size, s->tmp_row_size);", "got_line = 1;", "}", "if ((png_pass_dsp_ymask[s->pass] << (s->y & 7)) & 0x80) {", "png_put_interlaced_row(ptr, s->cur_w, s->bits_per_pixel, s->pass,\ns->color_type, s->last_row);", "}", "s->y++;", "if (s->y == s->cur_h) {", "memset(s->last_row, 0, s->row_size);", "for (;;) {", "if (s->pass == NB_PASSES - 1) {", "s->state |= PNG_ALLIMAGE;", "goto the_end;", "} else {", "s->pass++;", "s->y = 0;", "s->pass_row_size = ff_png_pass_row_size(s->pass,\ns->bits_per_pixel,\ns->cur_w);", "s->crow_size = s->pass_row_size + 1;", "if (s->pass_row_size != 0)\nbreak;", "}", "}", "}", "}", "the_end:;", "}", "}" ]

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

[ [ 1, 3, 9, 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23, 25 ], [ 27, 29 ], [ 33, 35 ], [ 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67, 69 ], [ 71 ], [ 73, 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 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 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ] ]

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

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

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

[ "void FUNC_0(QEMUFile *VAR_0, bool VAR_1)\n{", "QJSON *vmdesc;", "int VAR_2;", "SaveStateEntry *se;", "int VAR_3;", "bool in_postcopy = migration_in_postcopy();", "trace_savevm_state_complete_precopy();", "cpu_synchronize_all_states();", "QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {", "if (!se->ops ||\n(in_postcopy && se->ops->save_live_complete_postcopy) ||\n(in_postcopy && !VAR_1) ||\n!se->ops->save_live_complete_precopy) {", "continue;", "}", "if (se->ops && se->ops->is_active) {", "if (!se->ops->is_active(se->opaque)) {", "continue;", "}", "}", "trace_savevm_section_start(se->idstr, se->section_id);", "save_section_header(VAR_0, se, QEMU_VM_SECTION_END);", "VAR_3 = se->ops->save_live_complete_precopy(VAR_0, se->opaque);", "trace_savevm_section_end(se->idstr, se->section_id, VAR_3);", "save_section_footer(VAR_0, se);", "if (VAR_3 < 0) {", "qemu_file_set_error(VAR_0, VAR_3);", "return;", "}", "}", "if (VAR_1) {", "return;", "}", "vmdesc = qjson_new();", "json_prop_int(vmdesc, \"page_size\", qemu_target_page_size());", "json_start_array(vmdesc, \"devices\");", "QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {", "if ((!se->ops || !se->ops->save_state) && !se->vmsd) {", "continue;", "}", "if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {", "trace_savevm_section_skip(se->idstr, se->section_id);", "continue;", "}", "trace_savevm_section_start(se->idstr, se->section_id);", "json_start_object(vmdesc, NULL);", "json_prop_str(vmdesc, \"name\", se->idstr);", "json_prop_int(vmdesc, \"instance_id\", se->instance_id);", "save_section_header(VAR_0, se, QEMU_VM_SECTION_FULL);", "vmstate_save(VAR_0, se, vmdesc);", "trace_savevm_section_end(se->idstr, se->section_id, 0);", "save_section_footer(VAR_0, se);", "json_end_object(vmdesc);", "}", "if (!in_postcopy) {", "qemu_put_byte(VAR_0, QEMU_VM_EOF);", "}", "json_end_array(vmdesc);", "qjson_finish(vmdesc);", "VAR_2 = strlen(qjson_get_str(vmdesc));", "if (should_send_vmdesc()) {", "qemu_put_byte(VAR_0, QEMU_VM_VMDESCRIPTION);", "qemu_put_be32(VAR_0, VAR_2);", "qemu_put_buffer(VAR_0, (uint8_t *)qjson_get_str(vmdesc), VAR_2);", "}", "qjson_destroy(vmdesc);", "qemu_fflush(VAR_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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 21 ], [ 25 ], [ 27, 29, 31, 33 ], [ 35 ], [ 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 139 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ] ]

[ "static void FUNC_0(Object *VAR_0)\n{", "CPUState *cs = CPU(VAR_0);", "OpenRISCCPU *cpu = OPENRISC_CPU(VAR_0);", "static int VAR_1;", "cs->env_ptr = &cpu->env;", "cpu_exec_init(cs, &error_abort);", "#ifndef CONFIG_USER_ONLY\ncpu_openrisc_mmu_init(cpu);", "#endif\nif (tcg_enabled() && !VAR_1) {", "VAR_1 = 1;", "openrisc_translate_init();", "}", "}" ]

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

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

[ "int FUNC_0(HEVCSPS *VAR_0, GetBitContext *VAR_1, unsigned int *VAR_2,\nint VAR_3, AVBufferRef **VAR_4, AVCodecContext *VAR_5)\n{", "HEVCWindow *ow;", "int VAR_6 = 0;", "int VAR_7;", "int VAR_8, VAR_9, VAR_10, VAR_11;", "int VAR_12;", "VAR_0->vps_id = get_bits(VAR_1, 4);", "if (VAR_0->vps_id >= HEVC_MAX_VPS_COUNT) {", "av_log(VAR_5, AV_LOG_ERROR, \"VPS id out of range: %d\\n\", VAR_0->vps_id);", "if (VAR_4 && !VAR_4[VAR_0->vps_id]) {", "av_log(VAR_5, AV_LOG_ERROR, \"VPS %d does not exist\\n\",\nVAR_0->vps_id);", "VAR_0->max_sub_layers = get_bits(VAR_1, 3) + 1;", "if (VAR_0->max_sub_layers > HEVC_MAX_SUB_LAYERS) {", "av_log(VAR_5, AV_LOG_ERROR, \"sps_max_sub_layers out of range: %d\\n\",\nVAR_0->max_sub_layers);", "skip_bits1(VAR_1);", "parse_ptl(VAR_1, VAR_5, &VAR_0->ptl, VAR_0->max_sub_layers);", "*VAR_2 = get_ue_golomb_long(VAR_1);", "if (*VAR_2 >= HEVC_MAX_SPS_COUNT) {", "av_log(VAR_5, AV_LOG_ERROR, \"SPS id out of range: %d\\n\", *VAR_2);", "VAR_0->chroma_format_idc = get_ue_golomb_long(VAR_1);", "if (VAR_0->chroma_format_idc != 1) {", "avpriv_report_missing_feature(VAR_5, \"chroma_format_idc %d\",\nVAR_0->chroma_format_idc);", "VAR_6 = AVERROR_PATCHWELCOME;", "if (VAR_0->chroma_format_idc == 3)\nVAR_0->separate_colour_plane_flag = get_bits1(VAR_1);", "VAR_0->width = get_ue_golomb_long(VAR_1);", "VAR_0->height = get_ue_golomb_long(VAR_1);", "if ((VAR_6 = av_image_check_size(VAR_0->width,\nVAR_0->height, 0, VAR_5)) < 0)\nif (get_bits1(VAR_1)) {", "VAR_0->pic_conf_win.left_offset = get_ue_golomb_long(VAR_1) * 2;", "VAR_0->pic_conf_win.right_offset = get_ue_golomb_long(VAR_1) * 2;", "VAR_0->pic_conf_win.top_offset = get_ue_golomb_long(VAR_1) * 2;", "VAR_0->pic_conf_win.bottom_offset = get_ue_golomb_long(VAR_1) * 2;", "if (VAR_5->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {", "av_log(VAR_5, AV_LOG_DEBUG,\n\"discarding VAR_0 conformance window, \"\n\"original values are l:%u r:%u t:%u b:%u\\n\",\nVAR_0->pic_conf_win.left_offset,\nVAR_0->pic_conf_win.right_offset,\nVAR_0->pic_conf_win.top_offset,\nVAR_0->pic_conf_win.bottom_offset);", "VAR_0->pic_conf_win.left_offset =\nVAR_0->pic_conf_win.right_offset =\nVAR_0->pic_conf_win.top_offset =\nVAR_0->pic_conf_win.bottom_offset = 0;", "VAR_0->output_window = VAR_0->pic_conf_win;", "VAR_0->bit_depth = get_ue_golomb_long(VAR_1) + 8;", "VAR_8 = get_ue_golomb_long(VAR_1) + 8;", "if (VAR_8 != VAR_0->bit_depth) {", "av_log(VAR_5, AV_LOG_ERROR,\n\"Luma bit depth (%d) is different from chroma bit depth (%d), \"\n\"this is unsupported.\\n\",\nVAR_0->bit_depth, VAR_8);", "VAR_6 = map_pixel_format(VAR_5, VAR_0);", "if (VAR_6 < 0)\nVAR_0->log2_max_poc_lsb = get_ue_golomb_long(VAR_1) + 4;", "if (VAR_0->log2_max_poc_lsb > 16) {", "av_log(VAR_5, AV_LOG_ERROR, \"log2_max_pic_order_cnt_lsb_minus4 out range: %d\\n\",\nVAR_0->log2_max_poc_lsb - 4);", "VAR_11 = get_bits1(VAR_1);", "VAR_9 = VAR_11 ? 0 : VAR_0->max_sub_layers - 1;", "for (VAR_12 = VAR_9; VAR_12 < VAR_0->max_sub_layers; VAR_12++) {", "VAR_0->temporal_layer[VAR_12].max_dec_pic_buffering = get_ue_golomb_long(VAR_1) + 1;", "VAR_0->temporal_layer[VAR_12].num_reorder_pics = get_ue_golomb_long(VAR_1);", "VAR_0->temporal_layer[VAR_12].max_latency_increase = get_ue_golomb_long(VAR_1) - 1;", "if (VAR_0->temporal_layer[VAR_12].max_dec_pic_buffering > HEVC_MAX_DPB_SIZE) {", "av_log(VAR_5, AV_LOG_ERROR, \"sps_max_dec_pic_buffering_minus1 out of range: %d\\n\",\nVAR_0->temporal_layer[VAR_12].max_dec_pic_buffering - 1);", "if (VAR_0->temporal_layer[VAR_12].num_reorder_pics > VAR_0->temporal_layer[VAR_12].max_dec_pic_buffering - 1) {", "av_log(VAR_5, AV_LOG_WARNING, \"sps_max_num_reorder_pics out of range: %d\\n\",\nVAR_0->temporal_layer[VAR_12].num_reorder_pics);", "if (VAR_5->err_recognition & AV_EF_EXPLODE ||\nVAR_0->temporal_layer[VAR_12].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) {", "VAR_0->temporal_layer[VAR_12].max_dec_pic_buffering = VAR_0->temporal_layer[VAR_12].num_reorder_pics + 1;", "if (!VAR_11) {", "for (VAR_12 = 0; VAR_12 < VAR_9; VAR_12++) {", "VAR_0->temporal_layer[VAR_12].max_dec_pic_buffering = VAR_0->temporal_layer[VAR_9].max_dec_pic_buffering;", "VAR_0->temporal_layer[VAR_12].num_reorder_pics = VAR_0->temporal_layer[VAR_9].num_reorder_pics;", "VAR_0->temporal_layer[VAR_12].max_latency_increase = VAR_0->temporal_layer[VAR_9].max_latency_increase;", "VAR_0->log2_min_cb_size = get_ue_golomb_long(VAR_1) + 3;", "VAR_0->log2_diff_max_min_coding_block_size = get_ue_golomb_long(VAR_1);", "VAR_0->log2_min_tb_size = get_ue_golomb_long(VAR_1) + 2;", "VAR_7 = get_ue_golomb_long(VAR_1);", "VAR_0->log2_max_trafo_size = VAR_7 +\nVAR_0->log2_min_tb_size;", "if (VAR_0->log2_min_tb_size >= VAR_0->log2_min_cb_size) {", "av_log(VAR_5, AV_LOG_ERROR, \"Invalid value for log2_min_tb_size\");", "VAR_0->max_transform_hierarchy_depth_inter = get_ue_golomb_long(VAR_1);", "VAR_0->max_transform_hierarchy_depth_intra = get_ue_golomb_long(VAR_1);", "VAR_0->scaling_list_enable_flag = get_bits1(VAR_1);", "if (VAR_0->scaling_list_enable_flag) {", "set_default_scaling_list_data(&VAR_0->scaling_list);", "if (get_bits1(VAR_1)) {", "VAR_6 = scaling_list_data(VAR_1, VAR_5, &VAR_0->scaling_list);", "if (VAR_6 < 0)\nVAR_0->amp_enabled_flag = get_bits1(VAR_1);", "VAR_0->sao_enabled = get_bits1(VAR_1);", "VAR_0->pcm_enabled_flag = get_bits1(VAR_1);", "if (VAR_0->pcm_enabled_flag) {", "VAR_0->pcm.bit_depth = get_bits(VAR_1, 4) + 1;", "VAR_0->pcm.VAR_8 = get_bits(VAR_1, 4) + 1;", "VAR_0->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(VAR_1) + 3;", "VAR_0->pcm.log2_max_pcm_cb_size = VAR_0->pcm.log2_min_pcm_cb_size +\nget_ue_golomb_long(VAR_1);", "if (VAR_0->pcm.bit_depth > VAR_0->bit_depth) {", "av_log(VAR_5, AV_LOG_ERROR,\n\"PCM bit depth (%d) is greater than normal bit depth (%d)\\n\",\nVAR_0->pcm.bit_depth, VAR_0->bit_depth);", "VAR_0->pcm.loop_filter_disable_flag = get_bits1(VAR_1);", "VAR_0->nb_st_rps = get_ue_golomb_long(VAR_1);", "if (VAR_0->nb_st_rps > HEVC_MAX_SHORT_TERM_REF_PIC_SETS) {", "av_log(VAR_5, AV_LOG_ERROR, \"Too many short term RPS: %d.\\n\",\nVAR_0->nb_st_rps);", "for (VAR_12 = 0; VAR_12 < VAR_0->nb_st_rps; VAR_12++) {", "if ((VAR_6 = ff_hevc_decode_short_term_rps(VAR_1, VAR_5, &VAR_0->st_rps[VAR_12],\nVAR_0, 0)) < 0)\nVAR_0->long_term_ref_pics_present_flag = get_bits1(VAR_1);", "if (VAR_0->long_term_ref_pics_present_flag) {", "VAR_0->num_long_term_ref_pics_sps = get_ue_golomb_long(VAR_1);", "for (VAR_12 = 0; VAR_12 < VAR_0->num_long_term_ref_pics_sps; VAR_12++) {", "VAR_0->lt_ref_pic_poc_lsb_sps[VAR_12] = get_bits(VAR_1, VAR_0->log2_max_poc_lsb);", "VAR_0->used_by_curr_pic_lt_sps_flag[VAR_12] = get_bits1(VAR_1);", "VAR_0->sps_temporal_mvp_enabled_flag = get_bits1(VAR_1);", "VAR_0->sps_strong_intra_smoothing_enable_flag = get_bits1(VAR_1);", "VAR_0->vui.sar = (AVRational){0, 1};", "VAR_10 = get_bits1(VAR_1);", "if (VAR_10)\ndecode_vui(VAR_1, VAR_5, VAR_3, VAR_0);", "skip_bits1(VAR_1);", "if (VAR_3) {", "VAR_0->output_window.left_offset += VAR_0->vui.def_disp_win.left_offset;", "VAR_0->output_window.right_offset += VAR_0->vui.def_disp_win.right_offset;", "VAR_0->output_window.top_offset += VAR_0->vui.def_disp_win.top_offset;", "VAR_0->output_window.bottom_offset += VAR_0->vui.def_disp_win.bottom_offset;", "ow = &VAR_0->output_window;", "if (ow->left_offset >= INT_MAX - ow->right_offset ||\now->top_offset >= INT_MAX - ow->bottom_offset ||\now->left_offset + ow->right_offset >= VAR_0->width ||\now->top_offset + ow->bottom_offset >= VAR_0->height) {", "av_log(VAR_5, AV_LOG_WARNING, \"Invalid cropping offsets: %u/%u/%u/%u\\n\",\now->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset);", "if (VAR_5->err_recognition & AV_EF_EXPLODE) {", "av_log(VAR_5, AV_LOG_WARNING,\n\"Displaying the whole video surface.\\n\");", "memset(ow, 0, sizeof(*ow));", "VAR_0->log2_ctb_size = VAR_0->log2_min_cb_size +\nVAR_0->log2_diff_max_min_coding_block_size;", "VAR_0->log2_min_pu_size = VAR_0->log2_min_cb_size - 1;", "VAR_0->ctb_width = (VAR_0->width + (1 << VAR_0->log2_ctb_size) - 1) >> VAR_0->log2_ctb_size;", "VAR_0->ctb_height = (VAR_0->height + (1 << VAR_0->log2_ctb_size) - 1) >> VAR_0->log2_ctb_size;", "VAR_0->ctb_size = VAR_0->ctb_width * VAR_0->ctb_height;", "VAR_0->min_cb_width = VAR_0->width >> VAR_0->log2_min_cb_size;", "VAR_0->min_cb_height = VAR_0->height >> VAR_0->log2_min_cb_size;", "VAR_0->min_tb_width = VAR_0->width >> VAR_0->log2_min_tb_size;", "VAR_0->min_tb_height = VAR_0->height >> VAR_0->log2_min_tb_size;", "VAR_0->min_pu_width = VAR_0->width >> VAR_0->log2_min_pu_size;", "VAR_0->min_pu_height = VAR_0->height >> VAR_0->log2_min_pu_size;", "VAR_0->qp_bd_offset = 6 * (VAR_0->bit_depth - 8);", "if (VAR_0->width & ((1 << VAR_0->log2_min_cb_size) - 1) ||\nVAR_0->height & ((1 << VAR_0->log2_min_cb_size) - 1)) {", "av_log(VAR_5, AV_LOG_ERROR, \"Invalid coded frame dimensions.\\n\");", "if (VAR_0->log2_ctb_size > HEVC_MAX_LOG2_CTB_SIZE) {", "av_log(VAR_5, AV_LOG_ERROR, \"CTB size out of range: 2^%d\\n\", VAR_0->log2_ctb_size);", "if (VAR_0->max_transform_hierarchy_depth_inter > VAR_0->log2_ctb_size - VAR_0->log2_min_tb_size) {", "av_log(VAR_5, AV_LOG_ERROR, \"max_transform_hierarchy_depth_inter out of range: %d\\n\",\nVAR_0->max_transform_hierarchy_depth_inter);", "if (VAR_0->max_transform_hierarchy_depth_intra > VAR_0->log2_ctb_size - VAR_0->log2_min_tb_size) {", "av_log(VAR_5, AV_LOG_ERROR, \"max_transform_hierarchy_depth_intra out of range: %d\\n\",\nVAR_0->max_transform_hierarchy_depth_intra);", "if (VAR_0->log2_max_trafo_size > FFMIN(VAR_0->log2_ctb_size, 5)) {", "av_log(VAR_5, AV_LOG_ERROR,\n\"max transform block size out of range: %d\\n\",\nVAR_0->log2_max_trafo_size);", "return 0;", "err:\nreturn VAR_6 < 0 ? VAR_6 : AVERROR_INVALIDDATA;" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23 ], [ 25 ], [ 27 ], [ 34 ], [ 36, 38 ], [ 45 ], [ 47 ], [ 49, 51 ], [ 58 ], [ 62 ], [ 66 ], [ 68 ], [ 70 ], [ 77 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 91, 93 ], [ 97 ], [ 99 ], [ 101, 103, 108 ], [ 112 ], [ 114 ], [ 116 ], [ 118 ], [ 122 ], [ 124, 126, 128, 130, 132, 134, 136 ], [ 140, 142, 144, 146 ], [ 149 ], [ 154 ], [ 156 ], [ 158 ], [ 160, 162, 164, 166 ], [ 175 ], [ 177, 182 ], [ 184 ], [ 186, 188 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209, 211 ], [ 216 ], [ 218, 220 ], [ 222, 224 ], [ 229 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257, 259 ], [ 263 ], [ 265 ], [ 270 ], [ 272 ], [ 276 ], [ 278 ], [ 280 ], [ 284 ], [ 286 ], [ 288, 295 ], [ 297 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311, 313 ], [ 315 ], [ 317, 319, 321 ], [ 328 ], [ 333 ], [ 335 ], [ 337, 339 ], [ 344 ], [ 346, 348, 354 ], [ 356 ], [ 358 ], [ 366 ], [ 368 ], [ 370 ], [ 376 ], [ 378 ], [ 380 ], [ 382 ], [ 384, 386 ], [ 388 ], [ 392 ], [ 394 ], [ 396 ], [ 398 ], [ 400 ], [ 405 ], [ 407, 409, 411, 413 ], [ 415, 417 ], [ 419 ], [ 424, 426 ], [ 428 ], [ 435, 437 ], [ 439 ], [ 443 ], [ 445 ], [ 447 ], [ 451 ], [ 453 ], [ 455 ], [ 457 ], [ 459 ], [ 461 ], [ 465 ], [ 469, 471 ], [ 473 ], [ 479 ], [ 481 ], [ 485 ], [ 487, 489 ], [ 493 ], [ 495, 497 ], [ 501 ], [ 503, 505, 507 ], [ 513 ], [ 517, 519 ] ]

[ "static int FUNC_0(Monitor *VAR_0, BlockDriverState *VAR_1, int VAR_2)\n{", "if (bdrv_is_inserted(VAR_1)) {", "if (!VAR_2) {", "if (!bdrv_is_removable(VAR_1)) {", "qerror_report(QERR_DEVICE_NOT_REMOVABLE,\nbdrv_get_device_name(VAR_1));", "return -1;", "}", "if (bdrv_is_locked(VAR_1)) {", "qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(VAR_1));", "return -1;", "}", "}", "bdrv_close(VAR_1);", "}", "return 0;", "}" ]

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

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

[ "int FUNC_0(DisplayState *VAR_0, const char *VAR_1)\n{", "VncDisplay *vs = VAR_0 ? (VncDisplay *)VAR_0->opaque : vnc_display;", "const char *VAR_2;", "int VAR_3 = 0;", "int VAR_4 = 0;", "int VAR_5 = 0;", "#ifdef CONFIG_VNC_TLS\nint tls = 0, x509 = 0;", "#endif\nif (!vnc_display)\nreturn -1;", "vnc_display_close(VAR_0);", "if (strcmp(VAR_1, \"none\") == 0)\nreturn 0;", "if (!(vs->VAR_1 = strdup(VAR_1)))\nreturn -1;", "VAR_2 = VAR_1;", "while ((VAR_2 = strchr(VAR_2, ','))) {", "VAR_2++;", "if (strncmp(VAR_2, \"VAR_3\", 8) == 0) {", "VAR_3 = 1;", "} else if (strncmp(VAR_2, \"VAR_4\", 7) == 0) {", "VAR_4 = 1;", "} else if (strncmp(VAR_2, \"to=\", 3) == 0) {", "VAR_5 = atoi(VAR_2+3) + 5900;", "#ifdef CONFIG_VNC_TLS\n} else if (strncmp(VAR_2, \"tls\", 3) == 0) {", "tls = 1;", "} else if (strncmp(VAR_2, \"x509\", 4) == 0) {", "char *start, *end;", "x509 = 1;", "if (strncmp(VAR_2, \"x509verify\", 10) == 0)\nvs->tls.x509verify = 1;", "start = strchr(VAR_2, '=');", "end = strchr(VAR_2, ',');", "if (start && (!end || (start < end))) {", "int len = end ? end-(start+1) : strlen(start+1);", "char *path = qemu_strndup(start + 1, len);", "VNC_DEBUG(\"Trying certificate path '%s'\\n\", path);", "if (vnc_tls_set_x509_creds_dir(vs, path) < 0) {", "fprintf(stderr, \"Failed to find x509 certificates/keys in %s\\n\", path);", "qemu_free(path);", "qemu_free(vs->VAR_1);", "vs->VAR_1 = NULL;", "return -1;", "}", "qemu_free(path);", "} else {", "fprintf(stderr, \"No certificate path provided\\n\");", "qemu_free(vs->VAR_1);", "vs->VAR_1 = NULL;", "return -1;", "}", "#endif\n}", "}", "if (VAR_3) {", "#ifdef CONFIG_VNC_TLS\nif (tls) {", "vs->auth = VNC_AUTH_VENCRYPT;", "if (x509) {", "VNC_DEBUG(\"Initializing VNC server with x509 VAR_3 auth\\n\");", "vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;", "} else {", "VNC_DEBUG(\"Initializing VNC server with TLS VAR_3 auth\\n\");", "vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;", "}", "} else {", "#endif\nVNC_DEBUG(\"Initializing VNC server with VAR_3 auth\\n\");", "vs->auth = VNC_AUTH_VNC;", "#ifdef CONFIG_VNC_TLS\nvs->subauth = VNC_AUTH_INVALID;", "}", "#endif\n} else {", "#ifdef CONFIG_VNC_TLS\nif (tls) {", "vs->auth = VNC_AUTH_VENCRYPT;", "if (x509) {", "VNC_DEBUG(\"Initializing VNC server with x509 no auth\\n\");", "vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;", "} else {", "VNC_DEBUG(\"Initializing VNC server with TLS no auth\\n\");", "vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;", "}", "} else {", "#endif\nVNC_DEBUG(\"Initializing VNC server with no auth\\n\");", "vs->auth = VNC_AUTH_NONE;", "#ifdef CONFIG_VNC_TLS\nvs->subauth = VNC_AUTH_INVALID;", "}", "#endif\n}", "if (VAR_4) {", "if (strncmp(VAR_1, \"unix:\", 5) == 0)\nvs->lsock = unix_connect(VAR_1+5);", "else\nvs->lsock = inet_connect(VAR_1, SOCK_STREAM);", "if (-1 == vs->lsock) {", "free(vs->VAR_1);", "vs->VAR_1 = NULL;", "return -1;", "} else {", "int VAR_6 = vs->lsock;", "vs->lsock = -1;", "vnc_connect(vs, VAR_6);", "}", "return 0;", "} else {", "char *VAR_7;", "VAR_7 = qemu_malloc(256);", "if (strncmp(VAR_1, \"unix:\", 5) == 0) {", "pstrcpy(VAR_7, 256, \"unix:\");", "vs->lsock = unix_listen(VAR_1+5, VAR_7+5, 256-5);", "} else {", "vs->lsock = inet_listen(VAR_1, VAR_7, 256, SOCK_STREAM, 5900);", "}", "if (-1 == vs->lsock) {", "free(VAR_7);", "return -1;", "} else {", "free(vs->VAR_1);", "vs->VAR_1 = VAR_7;", "}", "}", "return qemu_set_fd_handler2(vs->lsock, NULL, vnc_listen_read, NULL, vs);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15, 17 ], [ 19, 23, 25 ], [ 27 ], [ 29, 31 ], [ 35, 37 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 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 ], [ 211 ], [ 215, 217 ], [ 219, 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 245 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ] ]

[ "static int FUNC_0(void)\n{", "int VAR_0;", "for (VAR_0 = 0; VAR_0 < nb_output_streams; VAR_0++) {", "OutputStream *ost = output_streams[VAR_0];", "OutputFile *of = output_files[ost->file_index];", "AVFormatContext *os = output_files[ost->file_index]->ctx;", "if (ost->is_past_recording_time ||\n(os->pb && avio_tell(os->pb) >= of->limit_filesize))\ncontinue;", "if (ost->frame_number >= ost->max_frames) {", "int j;", "for (j = 0; j < of->ctx->nb_streams; j++)", "output_streams[of->ost_index + j]->is_past_recording_time = 1;", "continue;", "}", "return 1;", "}", "return 0;", "}" ]

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

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

[ "void FUNC_0(int64_t VAR_0, Error **VAR_1)\n{", "MigrationState *s;", "if (VAR_0 < 0) {", "VAR_0 = 0;", "}", "if (VAR_0 > SIZE_MAX) {", "VAR_0 = SIZE_MAX;", "}", "s = migrate_get_current();", "s->bandwidth_limit = VAR_0;", "if (s->file) {", "qemu_file_set_rate_limit(s->file, s->bandwidth_limit / XFER_LIMIT_RATIO);", "}", "}" ]

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

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

[ "void FUNC_0(AioContext *VAR_0,\nEventNotifier *VAR_1,\nbool VAR_2,\nEventNotifierHandler *VAR_3)\n{", "AioHandler *node;", "QLIST_FOREACH(node, &VAR_0->aio_handlers, node) {", "if (node->VAR_1 == VAR_1 && !node->deleted) {", "break;", "}", "}", "if (!VAR_3) {", "if (node) {", "g_source_remove_poll(&VAR_0->source, &node->pfd);", "if (VAR_0->walking_handlers) {", "node->deleted = 1;", "node->pfd.revents = 0;", "} else {", "QLIST_REMOVE(node, node);", "g_free(node);", "}", "}", "} else {", "if (node == NULL) {", "node = g_new0(AioHandler, 1);", "node->VAR_1 = VAR_1;", "node->pfd.fd = (uintptr_t)event_notifier_get_handle(VAR_1);", "node->pfd.events = G_IO_IN;", "node->VAR_2 = VAR_2;", "QLIST_INSERT_HEAD(&VAR_0->aio_handlers, node, node);", "g_source_add_poll(&VAR_0->source, &node->pfd);", "}", "node->VAR_3 = VAR_3;", "}", "aio_notify(VAR_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 ]

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 29 ], [ 31 ], [ 33 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "UltimotionDecodeContext *s = avctx->priv_data;", "s->avctx = avctx;", "s->width = avctx->width;", "s->height = avctx->height;", "s->blocks = (s->width / 8) * (s->height / 8);", "avctx->pix_fmt = AV_PIX_FMT_YUV410P;", "s->ulti_codebook = ulti_codebook;", "s->frame = av_frame_alloc();", "if (!s->frame)\nreturn AVERROR(ENOMEM);", "return 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 ] ]

[ "static void FUNC_0(IVState *VAR_0, const char *VAR_1, bool VAR_2)\n{", "uint64_t barsize;", "VAR_0->qtest = qtest_start(VAR_1);", "VAR_0->pcibus = qpci_init_pc(NULL);", "VAR_0->dev = get_device(VAR_0->pcibus);", "VAR_0->reg_base = qpci_iomap(VAR_0->dev, 0, &barsize);", "g_assert_nonnull(VAR_0->reg_base);", "g_assert_cmpuint(barsize, ==, 256);", "if (VAR_2) {", "qpci_msix_enable(VAR_0->dev);", "}", "VAR_0->mem_base = qpci_iomap(VAR_0->dev, 2, &barsize);", "g_assert_nonnull(VAR_0->mem_base);", "g_assert_cmpuint(barsize, ==, TMPSHMSIZE);", "qpci_device_enable(VAR_0->dev);", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "unsigned VAR_1, VAR_2, VAR_3;", "AVStream *st;", "avio_skip(VAR_0->pb, 4);", "st = avformat_new_stream(VAR_0, NULL);", "if (!st)\nreturn AVERROR(ENOMEM);", "st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;", "VAR_1 = avio_rl32(VAR_0->pb);", "VAR_2 = VAR_1 > av_bswap32(VAR_1);", "if (VAR_2) {", "VAR_1 = av_bswap32(VAR_1);", "avio_skip(VAR_0->pb, 28);", "VAR_3 = avio_rb32(VAR_0->pb);", "st->codecpar->channels = avio_rb32(VAR_0->pb);", "avio_skip(VAR_0->pb, 4);", "st->duration = avio_rb32(VAR_0->pb);", "avio_skip(VAR_0->pb, 8);", "st->codecpar->sample_rate = avio_rb32(VAR_0->pb);", "} else {", "avio_skip(VAR_0->pb, 28);", "VAR_3 = avio_rl32(VAR_0->pb);", "st->codecpar->channels = avio_rl32(VAR_0->pb);", "avio_skip(VAR_0->pb, 4);", "st->duration = avio_rl32(VAR_0->pb);", "avio_skip(VAR_0->pb, 8);", "st->codecpar->sample_rate = avio_rl32(VAR_0->pb);", "}", "if (st->codecpar->sample_rate <= 0)\nreturn AVERROR_INVALIDDATA;", "if (st->codecpar->channels <= 0)\nreturn AVERROR_INVALIDDATA;", "switch (VAR_3) {", "case 0x1c:\nst->codecpar->codec_id = AV_CODEC_ID_ADPCM_PSX;", "st->codecpar->block_align = 16 * st->codecpar->channels;", "break;", "default:\navpriv_request_sample(VAR_0, \"VAR_3 %X\", VAR_3);", "return AVERROR_PATCHWELCOME;", "};", "avio_skip(VAR_0->pb, VAR_1 - avio_tell(VAR_0->pb));", "if (avio_rb16(VAR_0->pb) == 0xFFFB) {", "st->codecpar->codec_id = AV_CODEC_ID_MP3;", "st->codecpar->block_align = 0x1000;", "st->need_parsing = AVSTREAM_PARSE_FULL_RAW;", "}", "avio_skip(VAR_0->pb, -2);", "avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 15 ], [ 17, 19 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69, 71 ], [ 73, 75 ], [ 79 ], [ 81, 83 ], [ 85 ], [ 87 ], [ 89, 91 ], [ 93 ], [ 95 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ] ]

[ "void FUNC_0(MDCTContext *VAR_0, FFTSample *VAR_1,\nconst FFTSample *VAR_2, FFTSample *VAR_3)\n{", "x86_reg k;", "long VAR_4, VAR_5, VAR_6, VAR_7;", "const uint16_t *VAR_8 = VAR_0->fft.VAR_8;", "const FFTSample *VAR_9 = VAR_0->VAR_9;", "const FFTSample *VAR_10 = VAR_0->VAR_10;", "const FFTSample *VAR_11, *in2;", "FFTComplex *z = (FFTComplex *)VAR_3;", "VAR_7 = 1 << VAR_0->nbits;", "VAR_6 = VAR_7 >> 1;", "VAR_5 = VAR_7 >> 2;", "VAR_4 = VAR_7 >> 3;", "#ifdef ARCH_X86_64\nasm volatile (\"movaps %0, %%xmm8\\VAR_7\\t\"::\"m\"(*p1m1p1m1));", "#define P1M1P1M1 \"%%xmm8\"\n#else\n#define P1M1P1M1 \"%4\"\n#endif\nVAR_11 = VAR_2;", "in2 = VAR_2 + VAR_6 - 4;", "for (k = 0; k < VAR_5; k += 4) {", "asm volatile (\n\"movaps %0, %%xmm0 \\VAR_7\\t\"\n\"movaps %1, %%xmm3 \\VAR_7\\t\"\n\"movaps -16+1*%0, %%xmm4 \\VAR_7\\t\"\n\"movaps 16+1*%1, %%xmm7 \\VAR_7\\t\"\n\"movlps %2, %%xmm1 \\VAR_7\\t\"\n\"movlps %3, %%xmm2 \\VAR_7\\t\"\n\"movlps 8+1*%2, %%xmm5 \\VAR_7\\t\"\n\"movlps 8+1*%3, %%xmm6 \\VAR_7\\t\"\n\"shufps $95, %%xmm0, %%xmm0 \\VAR_7\\t\"\n\"shufps $160,%%xmm3, %%xmm3 \\VAR_7\\t\"\n\"shufps $95, %%xmm4, %%xmm4 \\VAR_7\\t\"\n\"shufps $160,%%xmm7, %%xmm7 \\VAR_7\\t\"\n\"unpcklps %%xmm2, %%xmm1 \\VAR_7\\t\"\n\"unpcklps %%xmm6, %%xmm5 \\VAR_7\\t\"\n\"movaps %%xmm1, %%xmm2 \\VAR_7\\t\"\n\"movaps %%xmm5, %%xmm6 \\VAR_7\\t\"\n\"xorps \"P1M1P1M1\", %%xmm2 \\VAR_7\\t\"\n\"xorps \"P1M1P1M1\", %%xmm6 \\VAR_7\\t\"\n\"mulps %%xmm1, %%xmm0 \\VAR_7\\t\"\n\"mulps %%xmm5, %%xmm4 \\VAR_7\\t\"\n\"shufps $177,%%xmm2, %%xmm2 \\VAR_7\\t\"\n\"shufps $177,%%xmm6, %%xmm6 \\VAR_7\\t\"\n\"mulps %%xmm2, %%xmm3 \\VAR_7\\t\"\n\"mulps %%xmm6, %%xmm7 \\VAR_7\\t\"\n\"addps %%xmm3, %%xmm0 \\VAR_7\\t\"\n\"addps %%xmm7, %%xmm4 \\VAR_7\\t\"\n::\"m\"(in2[-2*k]), \"m\"(VAR_11[2*k]),\n\"m\"(VAR_9[k]), \"m\"(VAR_10[k])\n#ifndef ARCH_X86_64\n,\"m\"(*p1m1p1m1)\n#endif\n);", "asm (\n\"movlps %%xmm0, %0 \\VAR_7\\t\"\n\"movhps %%xmm0, %1 \\VAR_7\\t\"\n\"movlps %%xmm4, %2 \\VAR_7\\t\"\n\"movhps %%xmm4, %3 \\VAR_7\\t\"\n:\"=m\"(z[VAR_8[k]]), \"=m\"(z[VAR_8[k + 1]]),\n\"=m\"(z[VAR_8[k + 2]]), \"=m\"(z[VAR_8[k + 3]])\n);", "}", "ff_fft_calc_sse(&VAR_0->fft, z);", "#ifndef ARCH_X86_64\n#undef P1M1P1M1\n#define P1M1P1M1 \"%3\"\n#endif\nfor (k = 0; k < VAR_5; k += 4) {", "asm (\n\"movaps %0, %%xmm0 \\VAR_7\\t\"\n\"movaps 16+1*%0, %%xmm4 \\VAR_7\\t\"\n\"movlps %1, %%xmm1 \\VAR_7\\t\"\n\"movlps 8+1*%1, %%xmm5 \\VAR_7\\t\"\n\"movaps %%xmm0, %%xmm3 \\VAR_7\\t\"\n\"movaps %%xmm4, %%xmm7 \\VAR_7\\t\"\n\"movlps %2, %%xmm2 \\VAR_7\\t\"\n\"movlps 8+1*%2, %%xmm6 \\VAR_7\\t\"\n\"shufps $160,%%xmm0, %%xmm0 \\VAR_7\\t\"\n\"shufps $245,%%xmm3, %%xmm3 \\VAR_7\\t\"\n\"shufps $160,%%xmm4, %%xmm4 \\VAR_7\\t\"\n\"shufps $245,%%xmm7, %%xmm7 \\VAR_7\\t\"\n\"unpcklps %%xmm2, %%xmm1 \\VAR_7\\t\"\n\"unpcklps %%xmm6, %%xmm5 \\VAR_7\\t\"\n\"movaps %%xmm1, %%xmm2 \\VAR_7\\t\"\n\"movaps %%xmm5, %%xmm6 \\VAR_7\\t\"\n\"xorps \"P1M1P1M1\", %%xmm2 \\VAR_7\\t\"\n\"mulps %%xmm1, %%xmm0 \\VAR_7\\t\"\n\"xorps \"P1M1P1M1\", %%xmm6 \\VAR_7\\t\"\n\"mulps %%xmm5, %%xmm4 \\VAR_7\\t\"\n\"shufps $177,%%xmm2, %%xmm2 \\VAR_7\\t\"\n\"shufps $177,%%xmm6, %%xmm6 \\VAR_7\\t\"\n\"mulps %%xmm2, %%xmm3 \\VAR_7\\t\"\n\"mulps %%xmm6, %%xmm7 \\VAR_7\\t\"\n\"addps %%xmm3, %%xmm0 \\VAR_7\\t\"\n\"addps %%xmm7, %%xmm4 \\VAR_7\\t\"\n\"movaps %%xmm0, %0 \\VAR_7\\t\"\n\"movaps %%xmm4, 16+1*%0\\VAR_7\\t\"\n:\"+m\"(z[k])\n:\"m\"(VAR_9[k]), \"m\"(VAR_10[k])\n#ifndef ARCH_X86_64\n,\"m\"(*p1m1p1m1)\n#endif\n);", "}", "k = 16-VAR_7;", "asm volatile(\"movaps %0, %%xmm7 \\VAR_7\\t\"::\"m\"(*m1m1m1m1));", "asm volatile(\n\"1: \\VAR_7\\t\"\n\"movaps -16(%4,%0), %%xmm1 \\VAR_7\\t\"\n\"neg %0 \\VAR_7\\t\"\n\"movaps (%4,%0), %%xmm0 \\VAR_7\\t\"\n\"xorps %%xmm7, %%xmm0 \\VAR_7\\t\"\n\"movaps %%xmm0, %%xmm2 \\VAR_7\\t\"\n\"shufps $141,%%xmm1, %%xmm0 \\VAR_7\\t\"\n\"shufps $216,%%xmm1, %%xmm2 \\VAR_7\\t\"\n\"shufps $156,%%xmm0, %%xmm0 \\VAR_7\\t\"\n\"shufps $156,%%xmm2, %%xmm2 \\VAR_7\\t\"\n\"movaps %%xmm0, (%1,%0) \\VAR_7\\t\"\n\"movaps %%xmm2, (%2,%0) \\VAR_7\\t\"\n\"neg %0 \\VAR_7\\t\"\n\"shufps $27, %%xmm0, %%xmm0 \\VAR_7\\t\"\n\"xorps %%xmm7, %%xmm0 \\VAR_7\\t\"\n\"shufps $27, %%xmm2, %%xmm2 \\VAR_7\\t\"\n\"movaps %%xmm0, -16(%2,%0) \\VAR_7\\t\"\n\"movaps %%xmm2, -16(%3,%0) \\VAR_7\\t\"\n\"add $16, %0 \\VAR_7\\t\"\n\"jle 1b \\VAR_7\\t\"\n:\"+r\"(k)\n:\"r\"(VAR_1), \"r\"(VAR_1+VAR_6), \"r\"(VAR_1+VAR_7), \"r\"(z+VAR_4)\n:\"memory\"\n);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33, 35 ], [ 37, 39, 41, 43, 49 ], [ 51 ], [ 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 ], [ 127, 129, 131, 133, 135, 137, 139, 141 ], [ 143 ], [ 147 ], [ 151, 153, 155, 157, 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 ], [ 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 ] ]

[ "static void FUNC_0(NvmeSQueue *VAR_0, NvmeCtrl *VAR_1, uint64_t VAR_2,\nuint16_t VAR_3, uint16_t VAR_4, uint16_t VAR_5)\n{", "int VAR_6;", "NvmeCQueue *cq;", "VAR_0->ctrl = VAR_1;", "VAR_0->VAR_2 = VAR_2;", "VAR_0->VAR_3 = VAR_3;", "VAR_0->VAR_5 = VAR_5;", "VAR_0->VAR_4 = VAR_4;", "VAR_0->head = VAR_0->tail = 0;", "VAR_0->io_req = g_malloc(VAR_0->VAR_5 * sizeof(*VAR_0->io_req));", "QTAILQ_INIT(&VAR_0->req_list);", "QTAILQ_INIT(&VAR_0->out_req_list);", "for (VAR_6 = 0; VAR_6 < VAR_0->VAR_5; VAR_6++) {", "VAR_0->io_req[VAR_6].VAR_0 = VAR_0;", "QTAILQ_INSERT_TAIL(&(VAR_0->req_list), &VAR_0->io_req[VAR_6], entry);", "}", "VAR_0->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, nvme_process_sq, VAR_0);", "assert(VAR_1->cq[VAR_4]);", "cq = VAR_1->cq[VAR_4];", "QTAILQ_INSERT_TAIL(&(cq->sq_list), VAR_0, entry);", "VAR_1->VAR_0[VAR_3] = VAR_0;", "}" ]

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

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

[ "static int FUNC_0(QemuOpts *VAR_0, CharDriverState **VAR_1)\n{", "const char *VAR_2 = qemu_opt_get(VAR_0, \"path\");", "CharDriverState *chr;", "int VAR_3;", "VAR_3 = qemu_open(VAR_2, O_RDWR);", "if (VAR_3 < 0) {", "return -errno;", "}", "chr = g_malloc0(sizeof(CharDriverState));", "chr->opaque = (void *)(intptr_t)VAR_3;", "chr->chr_write = null_chr_write;", "chr->chr_ioctl = pp_ioctl;", "*VAR_1 = chr;", "return 0;", "}" ]

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

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

[ "static int FUNC_0(X86CPU *VAR_0)\n{", "CPUX86State *env = &VAR_0->env;", "struct kvm_fpu VAR_1;", "int VAR_2;", "memset(&VAR_1, 0, sizeof VAR_1);", "VAR_1.fsw = env->fpus & ~(7 << 11);", "VAR_1.fsw |= (env->fpstt & 7) << 11;", "VAR_1.fcw = env->fpuc;", "VAR_1.last_opcode = env->fpop;", "VAR_1.last_ip = env->fpip;", "VAR_1.last_dp = env->fpdp;", "for (VAR_2 = 0; VAR_2 < 8; ++VAR_2) {", "VAR_1.ftwx |= (!env->fptags[VAR_2]) << VAR_2;", "}", "memcpy(VAR_1.fpr, env->fpregs, sizeof env->fpregs);", "memcpy(VAR_1.xmm, env->xmm_regs, sizeof env->xmm_regs);", "VAR_1.mxcsr = env->mxcsr;", "return kvm_vcpu_ioctl(CPU(VAR_0), KVM_SET_FPU, &VAR_1);", "}" ]

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

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

[ "static void FUNC_0(TestOutputVisitorData *VAR_0,\nconst void *VAR_1)\n{", "test_native_list(VAR_0, VAR_1, USER_DEF_NATIVE_LIST_UNION_KIND_S64);", "}" ]

[ 0, 0, 0 ]

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

[ "static void FUNC_0(P9Req *VAR_0, uint8_t VAR_1)\n{", "QVirtIO9P *v9p = VAR_0->v9p;", "P9Hdr hdr;", "int VAR_2;", "for (VAR_2 = 0; VAR_2 < 10; VAR_2++) {", "qvirtio_wait_queue_isr(v9p->dev, v9p->vq, 1000 * 1000);", "v9fs_memread(VAR_0, &hdr, 7);", "le32_to_cpus(&hdr.size);", "le16_to_cpus(&hdr.tag);", "if (hdr.size >= 7) {", "break;", "}", "v9fs_memrewind(VAR_0, 7);", "}", "g_assert_cmpint(hdr.size, >=, 7);", "g_assert_cmpint(hdr.size, <=, P9_MAX_SIZE);", "g_assert_cmpint(hdr.tag, ==, VAR_0->tag);", "if (hdr.VAR_1 != VAR_1) {", "g_printerr(\"Received response %d (%s) instead of %d (%s)\\n\",\nhdr.VAR_1, rmessage_name(hdr.VAR_1), VAR_1, rmessage_name(VAR_1));", "if (hdr.VAR_1 == P9_RLERROR) {", "uint32_t err;", "v9fs_uint32_read(VAR_0, &err);", "g_printerr(\"Rlerror has errno %d (%s)\\n\", err, strerror(err));", "}", "}", "g_assert_cmpint(hdr.VAR_1, ==, 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 ]

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

[ "static void FUNC_0( OPL_CH *VAR_0)\n{", "INT32 *carrier = &outd[0];", "VAR_0->connect1 = VAR_0->CON ? carrier : &feedback2;", "VAR_0->connect2 = carrier;", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "void FUNC_0(GArray *VAR_0,\nconst char *VAR_1,\nuint32_t VAR_2,\nbool VAR_3)\n{", "BiosLinkerLoaderEntry entry;", "memset(&entry, 0, sizeof entry);", "strncpy(entry.alloc.VAR_1, VAR_1, sizeof entry.alloc.VAR_1 - 1);", "entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ALLOCATE);", "entry.alloc.align = cpu_to_le32(VAR_2);", "entry.alloc.zone = cpu_to_le32(VAR_3 ?\nBIOS_LINKER_LOADER_ALLOC_ZONE_FSEG :\nBIOS_LINKER_LOADER_ALLOC_ZONE_HIGH);", "g_array_prepend_val(VAR_0, entry);", "}" ]

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

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

[ "static int FUNC_0(uint64_t VAR_0, int VAR_1,\nuint64_t *VAR_2, uint64_t VAR_3)\n{", "int VAR_4;", "uint64_t mask = VAR_3 | L2E_OFFSET_MASK | QCOW_OFLAG_COMPRESSED;", "uint64_t first_entry = be64_to_cpu(VAR_2[0]);", "uint64_t offset = first_entry & mask;", "if (!offset)\nreturn 0;", "assert(qcow2_get_cluster_type(first_entry) != QCOW2_CLUSTER_COMPRESSED);", "for (VAR_4 = 0; VAR_4 < VAR_0; VAR_4++) {", "uint64_t l2_entry = be64_to_cpu(VAR_2[VAR_4]) & mask;", "if (offset + (uint64_t) VAR_4 * VAR_1 != l2_entry) {", "break;", "}", "}", "return VAR_4;", "}" ]

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

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

[ "FUNC_0(VAR_0)\n{", "int VAR_1;", "QList *qlist;", "qlist = qlist_new();", "for (VAR_1 = 0; VAR_1 < iter_max; VAR_1++)", "qlist_append(qlist, qint_from_int(VAR_1));", "iter_called = 0;", "qlist_iter(qlist, iter_func, NULL);", "fail_unless(iter_called == iter_max);", "QDECREF(qlist);", "}" ]

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

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

[ "static int FUNC_0(struct target_sigcontext *VAR_0,\nCPUOpenRISCState *VAR_1,\nunsigned long VAR_2)\n{", "int VAR_3 = 0;", "unsigned long VAR_4 = VAR_1->gpr[1];", "__put_user(VAR_2, &VAR_0->oldmask);", "__put_user(VAR_4, &VAR_0->VAR_4); return VAR_3;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 35 ], [ 37 ], [ 39 ] ]

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

[ 0, 0, 0 ]

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

[ "FUNC_0(GArray *VAR_0, BIOSLinker *VAR_1, AcpiPmInfo *VAR_2,\nunsigned VAR_3, unsigned VAR_4,\nconst char *VAR_5, const char *VAR_6)\n{", "AcpiFadtDescriptorRev1 *fadt = acpi_data_push(VAR_0, sizeof(*fadt));", "unsigned VAR_7 = (char *)&fadt->firmware_ctrl - VAR_0->data;", "unsigned VAR_8 = (char *)&fadt->dsdt - VAR_0->data;", "bios_linker_loader_add_pointer(VAR_1,\nACPI_BUILD_TABLE_FILE, VAR_7, sizeof(fadt->firmware_ctrl),\nACPI_BUILD_TABLE_FILE, VAR_3);", "fadt_setup(fadt, VAR_2);", "bios_linker_loader_add_pointer(VAR_1,\nACPI_BUILD_TABLE_FILE, VAR_8, sizeof(fadt->dsdt),\nACPI_BUILD_TABLE_FILE, VAR_4);", "build_header(VAR_1, VAR_0,\n(void *)fadt, \"FACP\", sizeof(*fadt), 1, VAR_5, VAR_6);", "}" ]

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

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

[ "static void FUNC_0(CPUState *VAR_0)\n{", "M68kCPU *cpu = M68K_CPU(VAR_0);", "M68kCPUClass *mcc = M68K_CPU_GET_CLASS(cpu);", "CPUM68KState *env = &cpu->env;", "mcc->parent_reset(VAR_0);", "memset(env, 0, offsetof(CPUM68KState, end_reset_fields));", "#if !defined(CONFIG_USER_ONLY)\nenv->sr = 0x2700;", "#endif\nm68k_switch_sp(env);", "cpu_m68k_set_ccr(env, 0);", "env->pc = 0;", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "ram_addr_t raddr = VAR_1;", "void *VAR_4 = qemu_get_ram_ptr(raddr);", "switch (VAR_3) {", "case 1: return stb_p(VAR_4, VAR_2);", "case 2: return stw_p(VAR_4, VAR_2);", "case 4: return stl_p(VAR_4, VAR_2);", "default: abort();", "}", "}" ]

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

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

[ "static bool FUNC_0(MemoryRegionSection *section)\n{", "return !memory_region_is_ram(section->mr);", "}" ]

[ 0, 0, 0 ]

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

[ "coroutine_fn FUNC_0(BlockDriverState *bs, int64_t offset,\nint count, BdrvRequestFlags flags)\n{", "IscsiLun *iscsilun = bs->opaque;", "struct IscsiTask VAR_0;", "uint64_t lba;", "uint32_t nb_blocks;", "bool use_16_for_ws = iscsilun->use_16_for_rw;", "if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {", "return -ENOTSUP;", "}", "if (flags & BDRV_REQ_MAY_UNMAP) {", "if (!use_16_for_ws && !iscsilun->lbp.lbpws10) {", "use_16_for_ws = true;", "}", "if (use_16_for_ws && !iscsilun->lbp.lbpws) {", "flags &= ~BDRV_REQ_MAY_UNMAP;", "use_16_for_ws = iscsilun->use_16_for_rw;", "}", "}", "if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {", "return -ENOTSUP;", "}", "lba = offset / iscsilun->block_size;", "nb_blocks = count / iscsilun->block_size;", "if (iscsilun->zeroblock == NULL) {", "iscsilun->zeroblock = g_try_malloc0(iscsilun->block_size);", "if (iscsilun->zeroblock == NULL) {", "return -ENOMEM;", "}", "}", "iscsi_co_init_iscsitask(iscsilun, &VAR_0);", "retry:\nif (use_16_for_ws) {", "VAR_0.task = iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,\niscsilun->zeroblock, iscsilun->block_size,\nnb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),\n0, 0, iscsi_co_generic_cb, &VAR_0);", "} else {", "VAR_0.task = iscsi_writesame10_task(iscsilun->iscsi, iscsilun->lun, lba,\niscsilun->zeroblock, iscsilun->block_size,\nnb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),\n0, 0, iscsi_co_generic_cb, &VAR_0);", "}", "if (VAR_0.task == NULL) {", "return -ENOMEM;", "}", "while (!VAR_0.complete) {", "iscsi_set_events(iscsilun);", "qemu_coroutine_yield();", "}", "if (VAR_0.status == SCSI_STATUS_CHECK_CONDITION &&\nVAR_0.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&\n(VAR_0.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE ||\nVAR_0.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB)) {", "iscsilun->has_write_same = false;", "scsi_free_scsi_task(VAR_0.task);", "return -ENOTSUP;", "}", "if (VAR_0.task != NULL) {", "scsi_free_scsi_task(VAR_0.task);", "VAR_0.task = NULL;", "}", "if (VAR_0.do_retry) {", "VAR_0.complete = 0;", "goto retry;", "}", "if (VAR_0.status != SCSI_STATUS_GOOD) {", "return VAR_0.err_code;", "}", "if (flags & BDRV_REQ_MAY_UNMAP) {", "iscsi_allocationmap_clear(iscsilun, offset >> BDRV_SECTOR_BITS,\ncount >> BDRV_SECTOR_BITS);", "} else {", "iscsi_allocationmap_set(iscsilun, offset >> BDRV_SECTOR_BITS,\ncount >> BDRV_SECTOR_BITS);", "}", "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 ]

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

[ "void FUNC_0(const char *VAR_0)\n{", "int VAR_1;", "char VAR_2[256], *VAR_3;", "const char *VAR_4;", "struct in_addr VAR_5;", "int VAR_6, VAR_7;", "if (!slirp_inited) {", "slirp_inited = 1;", "slirp_init(0, NULL);", "}", "VAR_4 = VAR_0;", "if (get_str_sep(VAR_2, sizeof(VAR_2), &VAR_4, ':') < 0)\ngoto fail;", "if (!strcmp(VAR_2, \"tcp\")) {", "VAR_1 = 0;", "} else if (!strcmp(VAR_2, \"udp\")) {", "VAR_1 = 1;", "} else {", "goto fail;", "}", "if (get_str_sep(VAR_2, sizeof(VAR_2), &VAR_4, ':') < 0)\ngoto fail;", "VAR_6 = strtol(VAR_2, &VAR_3, 0);", "if (VAR_3 == VAR_2)\ngoto fail;", "if (get_str_sep(VAR_2, sizeof(VAR_2), &VAR_4, ':') < 0)\ngoto fail;", "if (VAR_2[0] == '\\0') {", "pstrcpy(VAR_2, sizeof(VAR_2), \"10.0.2.15\");", "}", "if (!inet_aton(VAR_2, &VAR_5))\ngoto fail;", "VAR_7 = strtol(VAR_4, &VAR_3, 0);", "if (VAR_3 == VAR_4)\ngoto fail;", "if (slirp_redir(VAR_1, VAR_6, VAR_5, VAR_7) < 0) {", "fprintf(stderr, \"qemu: could not set up redirection\\n\");", "exit(1);", "}", "return;", "fail:\nfprintf(stderr, \"qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\\n\");", "exit(1);", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,\nunsigned size)\n{", "struct omap_intr_handler_s *VAR_0 = (struct omap_intr_handler_s *) opaque;", "int VAR_1 = addr;", "int VAR_2, VAR_3;", "struct omap_intr_handler_bank_s *VAR_4 = NULL;", "if ((VAR_1 & 0xf80) == 0x80) {", "VAR_2 = (VAR_1 & 0x60) >> 5;", "if (VAR_2 < VAR_0->nbanks) {", "VAR_1 &= ~0x60;", "VAR_4 = &VAR_0->VAR_4[VAR_2];", "}", "}", "switch (VAR_1) {", "case 0x00:\nreturn 0x21;", "case 0x10:\nreturn (VAR_0->autoidle >> 2) & 1;", "case 0x14:\nreturn 1;", "case 0x40:\nreturn VAR_0->sir_intr[0];", "case 0x44:\nreturn VAR_0->sir_intr[1];", "case 0x48:\nreturn (!VAR_0->mask) << 2;", "case 0x4c:\nreturn 0;", "case 0x50:\nreturn VAR_0->autoidle & 3;", "case 0x80:\nreturn VAR_4->inputs;", "case 0x84:\nreturn VAR_4->mask;", "case 0x88:\ncase 0x8c:\nreturn 0;", "case 0x90:\nreturn VAR_4->swi;", "case 0x94:\nreturn 0;", "case 0x98:\nreturn VAR_4->irqs & ~VAR_4->mask & ~VAR_4->fiq;", "case 0x9c:\nreturn VAR_4->irqs & ~VAR_4->mask & VAR_4->fiq;", "case 0x100 ... 0x300:\nVAR_2 = (VAR_1 - 0x100) >> 7;", "if (VAR_2 > VAR_0->nbanks)\nbreak;", "VAR_4 = &VAR_0->VAR_4[VAR_2];", "VAR_3 = (VAR_1 & 0x7f) >> 2;", "return (VAR_4->priority[VAR_3] << 2) |\n((VAR_4->fiq >> VAR_3) & 1);", "}", "OMAP_BAD_REG(addr);", "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 ]

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35, 37 ], [ 41, 43 ], [ 47, 49 ], [ 53, 55 ], [ 59, 61 ], [ 65, 67 ], [ 71, 73 ], [ 77, 79 ], [ 85, 87 ], [ 91, 93 ], [ 97, 99, 101 ], [ 105, 107 ], [ 111, 113 ], [ 117, 119 ], [ 123, 125 ], [ 131, 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143, 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "int64_t size, av_uninit(data_size);", "int64_t sample_count = 0;", "int VAR_1;", "uint32_t tag;", "AVIOContext *pb = VAR_0->pb;", "AVStream *st = NULL;", "WAVDemuxContext *wav = VAR_0->priv_data;", "int VAR_2, VAR_3 = 0;", "int64_t next_tag_ofs, data_ofs = -1;", "wav->unaligned = avio_tell(VAR_0->pb) & 1;", "wav->smv_data_ofs = -1;", "tag = avio_rl32(pb);", "VAR_1 = tag == MKTAG('R', 'F', '6', '4');", "wav->rifx = tag == MKTAG('R', 'I', 'F', 'X');", "if (!VAR_1 && !wav->rifx && tag != MKTAG('R', 'I', 'F', 'F'))\nreturn AVERROR_INVALIDDATA;", "avio_rl32(pb);", "tag = avio_rl32(pb);", "if (tag != MKTAG('W', 'A', 'V', 'E'))\nreturn AVERROR_INVALIDDATA;", "if (VAR_1) {", "if (avio_rl32(pb) != MKTAG('d', 'VAR_0', '6', '4'))\nreturn AVERROR_INVALIDDATA;", "size = avio_rl32(pb);", "if (size < 24)\nreturn AVERROR_INVALIDDATA;", "avio_rl64(pb);", "data_size = avio_rl64(pb);", "sample_count = avio_rl64(pb);", "if (data_size < 0 || sample_count < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"negative data_size and/or sample_count in \"\n\"ds64: data_size = %\"PRId64\", sample_count = %\"PRId64\"\\n\",\ndata_size, sample_count);", "return AVERROR_INVALIDDATA;", "}", "avio_skip(pb, size - 24);", "}", "for (;;) {", "AVStream *vst;", "size = next_tag(pb, &tag, wav->rifx);", "next_tag_ofs = avio_tell(pb) + size;", "if (avio_feof(pb))\nbreak;", "switch (tag) {", "case MKTAG('f', 'm', 't', ' '):\nif (!VAR_3 && (VAR_2 = wav_parse_fmt_tag(VAR_0, size, &st)) < 0) {", "return VAR_2;", "} else if (VAR_3)", "av_log(VAR_0, AV_LOG_WARNING, \"found more than one 'fmt ' tag\\n\");", "VAR_3 = 1;", "break;", "case MKTAG('d', 'a', 't', 'a'):\nif (!VAR_3) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"found no 'fmt ' tag before the 'data' tag\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_1) {", "next_tag_ofs = wav->data_end = avio_tell(pb) + data_size;", "} else {", "data_size = size;", "next_tag_ofs = wav->data_end = size ? next_tag_ofs : INT64_MAX;", "}", "data_ofs = avio_tell(pb);", "if (!pb->seekable || (!VAR_1 && !size))\ngoto break_loop;", "break;", "case MKTAG('f', 'a', 'c', 't'):\nif (!sample_count)\nsample_count = (!wav->rifx ? avio_rl32(pb) : avio_rb32(pb));", "break;", "case MKTAG('b', 'e', 'x', 't'):\nif ((VAR_2 = wav_parse_bext_tag(VAR_0, size)) < 0)\nreturn VAR_2;", "break;", "case MKTAG('S','M','V','0'):\nif (!VAR_3) {", "av_log(VAR_0, AV_LOG_ERROR, \"found no 'fmt ' tag before the 'SMV0' tag\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (size != MKTAG('0','2','0','0')) {", "av_log(VAR_0, AV_LOG_ERROR, \"Unknown SMV version found\\n\");", "goto break_loop;", "}", "av_log(VAR_0, AV_LOG_DEBUG, \"Found SMV data\\n\");", "wav->smv_given_first = 0;", "vst = avformat_new_stream(VAR_0, NULL);", "if (!vst)\nreturn AVERROR(ENOMEM);", "avio_r8(pb);", "vst->id = 1;", "vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;", "vst->codec->codec_id = AV_CODEC_ID_SMVJPEG;", "vst->codec->width = avio_rl24(pb);", "vst->codec->height = avio_rl24(pb);", "if (ff_alloc_extradata(vst->codec, 4)) {", "av_log(VAR_0, AV_LOG_ERROR, \"Could not allocate extradata.\\n\");", "return AVERROR(ENOMEM);", "}", "size = avio_rl24(pb);", "wav->smv_data_ofs = avio_tell(pb) + (size - 5) * 3;", "avio_rl24(pb);", "wav->smv_block_size = avio_rl24(pb);", "avpriv_set_pts_info(vst, 32, 1, avio_rl24(pb));", "vst->duration = avio_rl24(pb);", "avio_rl24(pb);", "avio_rl24(pb);", "wav->smv_frames_per_jpeg = avio_rl24(pb);", "if (wav->smv_frames_per_jpeg > 65536) {", "av_log(VAR_0, AV_LOG_ERROR, \"too many frames per jpeg\\n\");", "return AVERROR_INVALIDDATA;", "}", "AV_WL32(vst->codec->extradata, wav->smv_frames_per_jpeg);", "wav->smv_cur_pt = 0;", "goto break_loop;", "case MKTAG('L', 'I', 'S', 'T'):\nif (size < 4) {", "av_log(VAR_0, AV_LOG_ERROR, \"too short LIST tag\\n\");", "return AVERROR_INVALIDDATA;", "}", "switch (avio_rl32(pb)) {", "case MKTAG('I', 'N', 'F', 'O'):\nff_read_riff_info(VAR_0, size - 4);", "}", "break;", "}", "if ((avio_size(pb) > 0 && next_tag_ofs >= avio_size(pb)) ||\nwav_seek_tag(wav, pb, next_tag_ofs, SEEK_SET) < 0) {", "break;", "}", "}", "break_loop:\nif (data_ofs < 0) {", "av_log(VAR_0, AV_LOG_ERROR, \"no 'data' tag found\\n\");", "return AVERROR_INVALIDDATA;", "}", "avio_seek(pb, data_ofs, SEEK_SET);", "if ( data_size > 0 && sample_count && st->codec->channels\n&& data_size / sample_count / st->codec->channels > 8) {", "av_log(VAR_0, AV_LOG_WARNING, \"ignoring wrong sample_count %\"PRId64\"\\n\", sample_count);", "sample_count = 0;", "}", "if (!sample_count || av_get_exact_bits_per_sample(st->codec->codec_id) > 0)\nif ( st->codec->channels\n&& data_size\n&& av_get_bits_per_sample(st->codec->codec_id)\n&& wav->data_end <= avio_size(pb))\nsample_count = (data_size << 3)\n/\n(st->codec->channels * (uint64_t)av_get_bits_per_sample(st->codec->codec_id));", "if (sample_count)\nst->duration = sample_count;", "ff_metadata_conv_ctx(VAR_0, NULL, wav_metadata_conv);", "ff_metadata_conv_ctx(VAR_0, NULL, ff_riff_info_conv);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 29 ], [ 35 ], [ 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 49 ], [ 51, 53 ], [ 57 ], [ 59, 61 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 73 ], [ 75 ], [ 79 ], [ 81, 83, 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109, 111 ], [ 115 ], [ 117, 121 ], [ 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139, 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 173, 175 ], [ 177 ], [ 179, 181, 183 ], [ 185 ], [ 187, 189, 191 ], [ 193 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221, 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 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 ], [ 303, 305 ], [ 307 ], [ 309 ], [ 311 ], [ 315, 317 ], [ 319 ], [ 321 ], [ 323 ], [ 327 ], [ 331, 333 ], [ 335 ], [ 337 ], [ 339 ], [ 343, 345, 347, 349, 351, 353, 355, 357 ], [ 361, 363 ], [ 367 ], [ 369 ], [ 373 ], [ 375 ] ]

[ "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,\nint VAR_7, const char *VAR_8)\n{", "char VAR_9[1024];", "int VAR_10, VAR_11, VAR_12;", "ram_addr_t ram_addr, vga_ram_addr, bios_offset, vga_bios_offset;", "ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;", "int VAR_13, VAR_14, VAR_15;", "PCIBus *pci_bus;", "int VAR_16 = -1;", "CPUState *env;", "NICInfo *nd;", "qemu_irq *cpu_irq;", "qemu_irq *i8259;", "int VAR_17;", "BlockDriverState *hd[MAX_IDE_BUS * MAX_IDE_DEVS];", "BlockDriverState *fd[MAX_FD];", "if (VAR_0 >= 0xe0000000 ) {", "above_4g_mem_size = VAR_0 - 0xe0000000;", "below_4g_mem_size = 0xe0000000;", "} else {", "below_4g_mem_size = VAR_0;", "}", "VAR_11 = (VAR_4 != NULL);", "if (VAR_8 == NULL) {", "#ifdef TARGET_X86_64\nVAR_8 = \"qemu64\";", "#else\nVAR_8 = \"qemu32\";", "#endif\n}", "for(VAR_12 = 0; VAR_12 < smp_cpus; VAR_12++) {", "env = cpu_init(VAR_8);", "if (!env) {", "fprintf(stderr, \"Unable to find x86 CPU definition\\n\");", "exit(1);", "}", "if (VAR_12 != 0)\nenv->halted = 1;", "if (smp_cpus > 1) {", "env->cpuid_features |= CPUID_APIC;", "}", "qemu_register_reset(main_cpu_reset, env);", "if (VAR_7) {", "apic_init(env);", "}", "}", "vmport_init();", "ram_addr = qemu_ram_alloc(0xa0000);", "cpu_register_physical_memory(0, 0xa0000, ram_addr);", "ram_addr = qemu_ram_alloc(0x100000 - 0xa0000);", "ram_addr = qemu_ram_alloc(below_4g_mem_size - 0x100000);", "cpu_register_physical_memory(0x100000,\nbelow_4g_mem_size - 0x100000,\nram_addr);", "if (above_4g_mem_size > 0) {", "ram_addr = qemu_ram_alloc(above_4g_mem_size);", "cpu_register_physical_memory(0x100000000ULL,\nabove_4g_mem_size,\nram_addr);", "}", "vga_ram_addr = qemu_ram_alloc(VAR_1);", "if (bios_name == NULL)\nbios_name = BIOS_FILENAME;", "snprintf(VAR_9, sizeof(VAR_9), \"%s/%s\", bios_dir, bios_name);", "VAR_13 = get_image_size(VAR_9);", "if (VAR_13 <= 0 ||\n(VAR_13 % 65536) != 0) {", "goto bios_error;", "}", "bios_offset = qemu_ram_alloc(VAR_13);", "VAR_10 = load_image(VAR_9, phys_ram_base + bios_offset);", "if (VAR_10 != VAR_13) {", "bios_error:\nfprintf(stderr, \"qemu: could not load PC BIOS '%s'\\n\", VAR_9);", "exit(1);", "}", "if (cirrus_vga_enabled) {", "snprintf(VAR_9, sizeof(VAR_9), \"%s/%s\", bios_dir, VGABIOS_CIRRUS_FILENAME);", "} else {", "snprintf(VAR_9, sizeof(VAR_9), \"%s/%s\", bios_dir, VGABIOS_FILENAME);", "}", "VAR_15 = get_image_size(VAR_9);", "if (VAR_15 <= 0 || VAR_15 > 65536)\ngoto vga_bios_error;", "vga_bios_offset = qemu_ram_alloc(65536);", "VAR_10 = load_image(VAR_9, phys_ram_base + vga_bios_offset);", "if (VAR_10 != VAR_15) {", "vga_bios_error:\nfprintf(stderr, \"qemu: could not load VGA BIOS '%s'\\n\", VAR_9);", "exit(1);", "}", "cpu_register_physical_memory(0xc0000, 0x10000,\nvga_bios_offset | IO_MEM_ROM);", "VAR_14 = VAR_13;", "if (VAR_14 > (128 * 1024))\nVAR_14 = 128 * 1024;", "cpu_register_physical_memory(0x100000 - VAR_14,\nVAR_14,\n(bios_offset + VAR_13 - VAR_14) | IO_MEM_ROM);", "{", "ram_addr_t option_rom_offset;", "int VAR_18, VAR_19;", "VAR_19 = 0;", "for (VAR_12 = 0; VAR_12 < nb_option_roms; VAR_12++) {", "VAR_18 = get_image_size(option_rom[VAR_12]);", "if (VAR_18 < 0) {", "fprintf(stderr, \"Could not load option rom '%s'\\n\",\noption_rom[VAR_12]);", "exit(1);", "}", "if (VAR_18 > (0x10000 - VAR_19))\ngoto option_rom_error;", "option_rom_offset = qemu_ram_alloc(VAR_18);", "VAR_10 = load_image(option_rom[VAR_12], phys_ram_base + option_rom_offset);", "if (VAR_10 != VAR_18) {", "option_rom_error:\nfprintf(stderr, \"Too many option ROMS\\n\");", "exit(1);", "}", "VAR_18 = (VAR_18 + 4095) & ~4095;", "cpu_register_physical_memory(0xd0000 + VAR_19,\nVAR_18, option_rom_offset | IO_MEM_ROM);", "VAR_19 += VAR_18;", "}", "}", "cpu_register_physical_memory((uint32_t)(-VAR_13),\nVAR_13, bios_offset | IO_MEM_ROM);", "bochs_bios_init();", "if (VAR_11)\nload_linux(VAR_4, VAR_6, VAR_5);", "cpu_irq = qemu_allocate_irqs(pic_irq_request, NULL, 1);", "i8259 = i8259_init(cpu_irq[0]);", "ferr_irq = i8259[13];", "if (VAR_7) {", "pci_bus = i440fx_init(&i440fx_state, i8259);", "VAR_16 = piix3_init(pci_bus, -1);", "} else {", "pci_bus = NULL;", "}", "register_ioport_write(0x80, 1, 1, ioport80_write, NULL);", "register_ioport_write(0xf0, 1, 1, ioportF0_write, NULL);", "if (cirrus_vga_enabled) {", "if (VAR_7) {", "pci_cirrus_vga_init(pci_bus,\nVAR_3, phys_ram_base + vga_ram_addr,\nvga_ram_addr, VAR_1);", "} else {", "isa_cirrus_vga_init(VAR_3, phys_ram_base + vga_ram_addr,\nvga_ram_addr, VAR_1);", "}", "} else if (vmsvga_enabled) {", "if (VAR_7)\npci_vmsvga_init(pci_bus, VAR_3, phys_ram_base + vga_ram_addr,\nvga_ram_addr, VAR_1);", "else\nfprintf(stderr, \"%s: vmware_vga: no PCI VAR_21\\n\", __FUNCTION__);", "} else {", "if (VAR_7) {", "pci_vga_init(pci_bus, VAR_3, phys_ram_base + vga_ram_addr,\nvga_ram_addr, VAR_1, 0, 0);", "} else {", "isa_vga_init(VAR_3, phys_ram_base + vga_ram_addr,\nvga_ram_addr, VAR_1);", "}", "}", "rtc_state = rtc_init(0x70, i8259[8]);", "qemu_register_boot_set(pc_boot_set, rtc_state);", "register_ioport_read(0x92, 1, 1, ioport92_read, NULL);", "register_ioport_write(0x92, 1, 1, ioport92_write, NULL);", "if (VAR_7) {", "ioapic = ioapic_init();", "}", "pit = pit_init(0x40, i8259[0]);", "pcspk_init(pit);", "if (VAR_7) {", "pic_set_alt_irq_func(isa_pic, ioapic_set_irq, ioapic);", "}", "for(VAR_12 = 0; VAR_12 < MAX_SERIAL_PORTS; VAR_12++) {", "if (serial_hds[VAR_12]) {", "serial_init(serial_io[VAR_12], i8259[serial_irq[VAR_12]], 115200,\nserial_hds[VAR_12]);", "}", "}", "for(VAR_12 = 0; VAR_12 < MAX_PARALLEL_PORTS; VAR_12++) {", "if (parallel_hds[VAR_12]) {", "parallel_init(parallel_io[VAR_12], i8259[parallel_irq[VAR_12]],\nparallel_hds[VAR_12]);", "}", "}", "for(VAR_12 = 0; VAR_12 < nb_nics; VAR_12++) {", "nd = &nd_table[VAR_12];", "if (!nd->model) {", "if (VAR_7) {", "nd->model = \"ne2k_pci\";", "} else {", "nd->model = \"ne2k_isa\";", "}", "}", "if (strcmp(nd->model, \"ne2k_isa\") == 0) {", "pc_init_ne2k_isa(nd, i8259);", "} else if (VAR_7) {", "if (strcmp(nd->model, \"?\") == 0)\nfprintf(stderr, \"qemu: Supported ISA NICs: ne2k_isa\\n\");", "pci_nic_init(pci_bus, nd, -1);", "} else if (strcmp(nd->model, \"?\") == 0) {", "fprintf(stderr, \"qemu: Supported ISA NICs: ne2k_isa\\n\");", "exit(1);", "} else {", "fprintf(stderr, \"qemu: Unsupported NIC: %s\\n\", nd->model);", "exit(1);", "}", "}", "if (drive_get_max_bus(IF_IDE) >= MAX_IDE_BUS) {", "fprintf(stderr, \"qemu: too many IDE VAR_21\\n\");", "exit(1);", "}", "for(VAR_12 = 0; VAR_12 < MAX_IDE_BUS * MAX_IDE_DEVS; VAR_12++) {", "VAR_17 = drive_get_index(IF_IDE, VAR_12 / MAX_IDE_DEVS, VAR_12 % MAX_IDE_DEVS);", "if (VAR_17 != -1)\nhd[VAR_12] = drives_table[VAR_17].bdrv;", "else\nhd[VAR_12] = NULL;", "}", "if (VAR_7) {", "pci_piix3_ide_init(pci_bus, hd, VAR_16 + 1, i8259);", "} else {", "for(VAR_12 = 0; VAR_12 < MAX_IDE_BUS; VAR_12++) {", "isa_ide_init(ide_iobase[VAR_12], ide_iobase2[VAR_12], i8259[ide_irq[VAR_12]],\nhd[MAX_IDE_DEVS * VAR_12], hd[MAX_IDE_DEVS * VAR_12 + 1]);", "}", "}", "i8042_init(i8259[1], i8259[12], 0x60);", "DMA_init(0);", "#ifdef HAS_AUDIO\naudio_init(VAR_7 ? pci_bus : NULL, i8259);", "#endif\nfor(VAR_12 = 0; VAR_12 < MAX_FD; VAR_12++) {", "VAR_17 = drive_get_index(IF_FLOPPY, 0, VAR_12);", "if (VAR_17 != -1)\nfd[VAR_12] = drives_table[VAR_17].bdrv;", "else\nfd[VAR_12] = NULL;", "}", "floppy_controller = fdctrl_init(i8259[6], 2, 0, 0x3f0, fd);", "cmos_init(below_4g_mem_size, above_4g_mem_size, VAR_2, hd);", "if (VAR_7 && usb_enabled) {", "usb_uhci_piix3_init(pci_bus, VAR_16 + 2);", "}", "if (VAR_7 && acpi_enabled) {", "uint8_t *eeprom_buf = qemu_mallocz(8 * 256);", "i2c_bus *smbus;", "smbus = piix4_pm_init(pci_bus, VAR_16 + 3, 0xb100, i8259[9]);", "for (VAR_12 = 0; VAR_12 < 8; VAR_12++) {", "smbus_eeprom_device_init(smbus, 0x50 + VAR_12, eeprom_buf + (VAR_12 * 256));", "}", "}", "if (i440fx_state) {", "i440fx_init_memory_mappings(i440fx_state);", "}", "if (VAR_7) {", "int VAR_20;", "int VAR_21, VAR_22;", "void *VAR_23;", "VAR_20 = drive_get_max_bus(IF_SCSI);", "for (VAR_21 = 0; VAR_21 <= VAR_20; VAR_21++) {", "VAR_23 = lsi_scsi_init(pci_bus, -1);", "for (VAR_22 = 0; VAR_22 < LSI_MAX_DEVS; VAR_22++) {", "VAR_17 = drive_get_index(IF_SCSI, VAR_21, VAR_22);", "if (VAR_17 == -1)\ncontinue;", "lsi_scsi_attach(VAR_23, drives_table[VAR_17].bdrv, VAR_22);", "}", "}", "}", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 63 ], [ 65, 67 ], [ 69, 71 ], [ 73, 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91, 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 121 ], [ 123 ], [ 135 ], [ 137 ], [ 139, 141, 143 ], [ 149 ], [ 151 ], [ 153, 155, 157 ], [ 159 ], [ 167 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 181, 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219, 221 ], [ 223 ], [ 227 ], [ 229 ], [ 231, 233 ], [ 235 ], [ 237 ], [ 243, 245 ], [ 251 ], [ 253, 255 ], [ 257, 259, 261 ], [ 265 ], [ 267 ], [ 269 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281, 283 ], [ 285 ], [ 287 ], [ 289, 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299, 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309, 311 ], [ 313 ], [ 315 ], [ 317 ], [ 323, 325 ], [ 329 ], [ 333, 335 ], [ 339 ], [ 341 ], [ 343 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 363 ], [ 367 ], [ 371 ], [ 373 ], [ 375, 377, 379 ], [ 381 ], [ 383, 385 ], [ 387 ], [ 389 ], [ 391, 393, 395 ], [ 397, 399 ], [ 401 ], [ 403 ], [ 405, 407 ], [ 409 ], [ 411, 413 ], [ 415 ], [ 417 ], [ 421 ], [ 425 ], [ 429 ], [ 431 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 449 ], [ 453 ], [ 455 ], [ 457, 459 ], [ 461 ], [ 463 ], [ 467 ], [ 469 ], [ 471, 473 ], [ 475 ], [ 477 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 491 ], [ 493 ], [ 495 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505, 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 539 ], [ 541 ], [ 543, 545 ], [ 547, 549 ], [ 551 ], [ 555 ], [ 557 ], [ 559 ], [ 561 ], [ 563, 565 ], [ 567 ], [ 569 ], [ 573 ], [ 575 ], [ 577, 579 ], [ 581, 585 ], [ 587 ], [ 589, 591 ], [ 593, 595 ], [ 597 ], [ 599 ], [ 603 ], [ 607 ], [ 609 ], [ 611 ], [ 615 ], [ 617 ], [ 619 ], [ 625 ], [ 627 ], [ 629 ], [ 631 ], [ 633 ], [ 637 ], [ 639 ], [ 641 ], [ 645 ], [ 647 ], [ 649 ], [ 651 ], [ 655 ], [ 659 ], [ 661 ], [ 663 ], [ 665 ], [ 667, 669 ], [ 671 ], [ 673 ], [ 675 ], [ 677 ], [ 679 ] ]

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1, uint32_t VAR_2)\n{", "PCIBonitoState *s = VAR_0;", "uint32_t saddr;", "int VAR_3 = 0;", "saddr = (VAR_1 - BONITO_REGBASE) >> 2;", "DPRINTF(\"FUNC_0 \"TARGET_FMT_plx\" VAR_2 %x saddr %x \\n\", VAR_1, VAR_2, saddr);", "switch (saddr) {", "case BONITO_BONPONCFG:\ncase BONITO_IODEVCFG:\ncase BONITO_SDCFG:\ncase BONITO_PCIMAP:\ncase BONITO_PCIMEMBASECFG:\ncase BONITO_PCIMAP_CFG:\ncase BONITO_GPIODATA:\ncase BONITO_GPIOIE:\ncase BONITO_INTEDGE:\ncase BONITO_INTSTEER:\ncase BONITO_INTPOL:\ncase BONITO_PCIMAIL0:\ncase BONITO_PCIMAIL1:\ncase BONITO_PCIMAIL2:\ncase BONITO_PCIMAIL3:\ncase BONITO_PCICACHECTRL:\ncase BONITO_PCICACHETAG:\ncase BONITO_PCIBADADDR:\ncase BONITO_PCIMSTAT:\ncase BONITO_TIMECFG:\ncase BONITO_CPUCFG:\ncase BONITO_DQCFG:\ncase BONITO_MEMSIZE:\ns->regs[saddr] = VAR_2;", "break;", "case BONITO_BONGENCFG:\nif (!(s->regs[saddr] & 0x04) && (VAR_2 & 0x04)) {", "VAR_3 = 1;", "}", "s->regs[saddr] = VAR_2;", "if (VAR_3) {", "qemu_system_reset_request();", "}", "break;", "case BONITO_INTENSET:\ns->regs[BONITO_INTENSET] = VAR_2;", "s->regs[BONITO_INTEN] |= VAR_2;", "break;", "case BONITO_INTENCLR:\ns->regs[BONITO_INTENCLR] = VAR_2;", "s->regs[BONITO_INTEN] &= ~VAR_2;", "break;", "case BONITO_INTEN:\ncase BONITO_INTISR:\nDPRINTF(\"write to readonly bonito register %x \\n\", saddr);", "break;", "default:\nDPRINTF(\"write to unknown bonito register %x \\n\", saddr);", "break;", "}", "}" ]

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

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

[ "int FUNC_0(SocketAddressLegacy *VAR_0, SocketAddressLegacy *VAR_1, Error **VAR_2)\n{", "int VAR_3;", "switch (VAR_0->type) {", "case SOCKET_ADDRESS_LEGACY_KIND_INET:\nVAR_3 = inet_dgram_saddr(VAR_0->u.inet.data,\nVAR_1 ? VAR_1->u.inet.data : NULL, VAR_2);", "break;", "default:\nerror_setg(VAR_2, \"socket type unsupported for datagram\");", "VAR_3 = -1;", "}", "return VAR_3;", "}" ]

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

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

[ "static void FUNC_0(uint8_t *VAR_0,\nuint8_t *VAR_1, uint8_t *VAR_2, uint8_t *VAR_3,\nint VAR_4, int VAR_5, int VAR_6, int VAR_7)\n{", "int VAR_8;", "uint8_t *prev2 = VAR_6 ? VAR_1 : VAR_2 ;", "uint8_t *next2 = VAR_6 ? VAR_2 : VAR_3;", "for (VAR_8 = 0; VAR_8 < VAR_4; VAR_8++) {", "int VAR_9 = VAR_2[-VAR_5];", "int VAR_10 = (prev2[0] + next2[0])>>1;", "int VAR_11 = VAR_2[+VAR_5];", "int VAR_12 = FFABS(prev2[0] - next2[0]);", "int VAR_13 =(FFABS(VAR_1[-VAR_5] - VAR_9) + FFABS(VAR_1[+VAR_5] - VAR_11) )>>1;", "int VAR_14 =(FFABS(VAR_3[-VAR_5] - VAR_9) + FFABS(VAR_3[+VAR_5] - VAR_11) )>>1;", "int VAR_15 = FFMAX3(VAR_12>>1, VAR_13, VAR_14);", "int VAR_16 = (VAR_9+VAR_11)>>1;", "int VAR_17 = FFABS(VAR_2[-VAR_5-1] - VAR_2[+VAR_5-1]) + FFABS(VAR_9-VAR_11)\n+ FFABS(VAR_2[-VAR_5+1] - VAR_2[+VAR_5+1]) - 1;", "#define CHECK(j)\\\n{ int VAR_18 = FFABS(VAR_2[-VAR_5-1+j] - VAR_2[+VAR_5-1-j])\\", "+ FFABS(VAR_2[-VAR_5 +j] - VAR_2[+VAR_5 -j])\\\n+ FFABS(VAR_2[-VAR_5+1+j] - VAR_2[+VAR_5+1-j]);\\", "if (VAR_18 < VAR_17) {\\", "VAR_17= VAR_18;\\", "VAR_16= (VAR_2[-VAR_5 +j] + VAR_2[+VAR_5 -j])>>1;\\", "CHECK(-1) CHECK(-2) }} }}" ]

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

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

[ "static void FUNC_0(const char *VAR_0)\n{", "video_channel = strtol(VAR_0, NULL, 0);", "}" ]

[ 0, 0, 0 ]

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