Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static void FUNC_0(sPAPRMachineState *VAR_0, void *VAR_1)\n{", "int VAR_2;", "GString *hypertas = g_string_sized_new(256);", "GString *qemu_hypertas = g_string_sized_new(256);", "uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) };", "uint64_t max_hotplug_addr = VAR_0->hotplug_memory.base +\nmemory_region_size(&VAR_0->hotplug_memory.mr);", "uint32_t lrdr_capacity[] = {", "cpu_to_be32(max_hotplug_addr >> 32),\ncpu_to_be32(max_hotplug_addr & 0xffffffff),\n0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE),\ncpu_to_be32(max_cpus / smp_threads),\n};", "_FDT(VAR_2 = fdt_add_subnode(VAR_1, 0, \"VAR_2\"));", "add_str(hypertas, \"hcall-pft\");", "add_str(hypertas, \"hcall-term\");", "add_str(hypertas, \"hcall-dabr\");", "add_str(hypertas, \"hcall-interrupt\");", "add_str(hypertas, \"hcall-tce\");", "add_str(hypertas, \"hcall-vio\");", "add_str(hypertas, \"hcall-splpar\");", "add_str(hypertas, \"hcall-bulk\");", "add_str(hypertas, \"hcall-set-mode\");", "add_str(hypertas, \"hcall-sprg0\");", "add_str(hypertas, \"hcall-copy\");", "add_str(hypertas, \"hcall-debug\");", "add_str(qemu_hypertas, \"hcall-memop1\");", "if (!kvm_enabled() || kvmppc_spapr_use_multitce()) {", "add_str(hypertas, \"hcall-multi-tce\");", "}", "if (VAR_0->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) {", "add_str(hypertas, \"hcall-hpt-resize\");", "}", "_FDT(fdt_setprop(VAR_1, VAR_2, \"ibm,hypertas-functions\",\nhypertas->str, hypertas->len));", "g_string_free(hypertas, TRUE);", "_FDT(fdt_setprop(VAR_1, VAR_2, \"qemu,hypertas-functions\",\nqemu_hypertas->str, qemu_hypertas->len));", "g_string_free(qemu_hypertas, TRUE);", "_FDT(fdt_setprop(VAR_1, VAR_2, \"ibm,associativity-reference-points\",\nrefpoints, sizeof(refpoints)));", "_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"VAR_2-error-log-max\",\nRTAS_ERROR_LOG_MAX));", "_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"VAR_2-event-scan-rate\",\nRTAS_EVENT_SCAN_RATE));", "if (msi_nonbroken) {", "_FDT(fdt_setprop(VAR_1, VAR_2, \"ibm,change-msix-capable\", NULL, 0));", "}", "_FDT(fdt_setprop(VAR_1, VAR_2, \"ibm,extended-os-term\", NULL, 0));", "_FDT(fdt_setprop(VAR_1, VAR_2, \"ibm,lrdr-capacity\",\nlrdr_capacity, sizeof(lrdr_capacity)));", "spapr_dt_rtas_tokens(VAR_1, VAR_2);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13, 15 ], [ 17 ], [ 19, 21, 23, 25, 27 ], [ 31 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ], [ 77 ], [ 81, 83 ], [ 85 ], [ 87, 89 ], [ 91 ], [ 95, 97 ], [ 101, 103 ], [ 105, 107 ], [ 111 ], [ 113 ], [ 115 ], [ 133 ], [ 137, 139 ], [ 143 ], [ 145 ] ]

[ "static ssize_t FUNC_0(NBDRequest *req,\nstruct nbd_request *request)\n{", "NBDClient *client = req->client;", "uint32_t command;", "ssize_t rc;", "g_assert(qemu_in_coroutine());", "client->recv_coroutine = qemu_coroutine_self();", "nbd_update_can_read(client);", "rc = nbd_receive_request(client->ioc, request);", "if (rc < 0) {", "if (rc != -EAGAIN) {", "rc = -EIO;", "}", "goto out;", "}", "TRACE(\"Decoding type\");", "command = request->type & NBD_CMD_MASK_COMMAND;", "if (command != NBD_CMD_WRITE) {", "req->complete = true;", "}", "if (command == NBD_CMD_DISC) {", "TRACE(\"Request type is DISCONNECT\");", "rc = -EIO;", "goto out;", "}", "if ((request->from + request->len) < request->from) {", "LOG(\"integer overflow detected, you're probably being attacked\");", "rc = -EINVAL;", "goto out;", "}", "if (command == NBD_CMD_READ || command == NBD_CMD_WRITE) {", "if (request->len > NBD_MAX_BUFFER_SIZE) {", "LOG(\"len (%\" PRIu32\" ) is larger than max len (%u)\",\nrequest->len, NBD_MAX_BUFFER_SIZE);", "rc = -EINVAL;", "goto out;", "}", "req->data = blk_try_blockalign(client->exp->blk, request->len);", "if (req->data == NULL) {", "rc = -ENOMEM;", "goto out;", "}", "}", "if (command == NBD_CMD_WRITE) {", "TRACE(\"Reading %\" PRIu32 \" byte(s)\", request->len);", "if (read_sync(client->ioc, req->data, request->len) != request->len) {", "LOG(\"reading from socket failed\");", "rc = -EIO;", "goto out;", "}", "req->complete = true;", "}", "if (request->from + request->len > client->exp->size) {", "LOG(\"operation past EOF; From: %\" PRIu64 \", Len: %\" PRIu32", "\", Size: %\" PRIu64, request->from, request->len,\n(uint64_t)client->exp->size);", "rc = command == NBD_CMD_WRITE ? -ENOSPC : -EINVAL;", "goto out;", "}", "if (request->type & ~NBD_CMD_MASK_COMMAND & ~NBD_CMD_FLAG_FUA) {", "LOG(\"unsupported flags (got 0x%x)\",\nrequest->type & ~NBD_CMD_MASK_COMMAND);", "rc = -EINVAL;", "goto out;", "}", "rc = 0;", "out:\nclient->recv_coroutine = NULL;", "nbd_update_can_read(client);", "return rc;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 55 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 141 ], [ 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157, 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 173, 175 ], [ 177 ], [ 181 ], [ 183 ] ]

[ "static void FUNC_0(QIOTask *VAR_0,\ngpointer VAR_1)\n{", "QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(VAR_0));", "SocketAddressLegacy *addr = VAR_1;", "Error *err = NULL;", "qio_channel_socket_listen_sync(ioc, addr, &err);", "qio_task_set_error(VAR_0, err);", "}" ]

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

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

[ "static void FUNC_0(QemuOpts *VAR_0)\n{", "if (VAR_0) {", "unsigned VAR_1 = qemu_opt_get_number(VAR_0, \"VAR_1\", 0);", "unsigned VAR_2 = qemu_opt_get_number(VAR_0, \"VAR_2\", 0);", "unsigned VAR_3 = qemu_opt_get_number(VAR_0, \"VAR_3\", 0);", "unsigned VAR_4 = qemu_opt_get_number(VAR_0, \"VAR_4\", 0);", "if (VAR_1 == 0 || VAR_2 == 0) {", "VAR_2 = VAR_2 > 0 ? VAR_2 : 1;", "VAR_3 = VAR_3 > 0 ? VAR_3 : 1;", "VAR_4 = VAR_4 > 0 ? VAR_4 : 1;", "if (VAR_1 == 0) {", "VAR_1 = VAR_3 * VAR_4 * VAR_2;", "}", "} else if (VAR_3 == 0) {", "VAR_4 = VAR_4 > 0 ? VAR_4 : 1;", "VAR_3 = VAR_1 / (VAR_2 * VAR_4);", "} else if (VAR_4 == 0) {", "VAR_4 = VAR_1 / (VAR_3 * VAR_2);", "} else if (VAR_2 * VAR_3 * VAR_4 < VAR_1) {", "error_report(\"cpu topology: \"\n\"VAR_2 (%u) * VAR_3 (%u) * VAR_4 (%u) < \"\n\"smp_cpus (%u)\",\nVAR_2, VAR_3, VAR_4, VAR_1);", "exit(1);", "}", "max_cpus = qemu_opt_get_number(VAR_0, \"maxcpus\", VAR_1);", "if (VAR_2 * VAR_3 * VAR_4 > max_cpus) {", "error_report(\"cpu topology: \"\n\"VAR_2 (%u) * VAR_3 (%u) * VAR_4 (%u) > \"\n\"maxcpus (%u)\",\nVAR_2, VAR_3, VAR_4, max_cpus);", "exit(1);", "}", "smp_cpus = VAR_1;", "smp_cores = VAR_3 > 0 ? VAR_3 : 1;", "smp_threads = VAR_4 > 0 ? VAR_4 : 1;", "}", "if (max_cpus == 0) {", "max_cpus = smp_cpus;", "}", "if (max_cpus > MAX_CPUMASK_BITS) {", "error_report(\"unsupported number of maxcpus\");", "exit(1);", "}", "if (max_cpus < smp_cpus) {", "error_report(\"maxcpus must be equal to or greater than smp\");", "exit(1);", "}", "if (smp_cpus > 1 || smp_cores > 1 || smp_threads > 1) {", "Error *blocker = NULL;", "error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, \"smp\");", "replay_add_blocker(blocker);", "}", "}" ]

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

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

[ "static void FUNC_0(uint8_t *VAR_0, int16_t VAR_1[4][16], ptrdiff_t VAR_2)\n{", "vp8_idct_dc_add_c(VAR_0+ 0, VAR_1[0], VAR_2);", "vp8_idct_dc_add_c(VAR_0+ 4, VAR_1[1], VAR_2);", "vp8_idct_dc_add_c(VAR_0+ 8, VAR_1[2], VAR_2);", "vp8_idct_dc_add_c(VAR_0+12, VAR_1[3], VAR_2);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, uint8_t VAR_1, uint32_t VAR_2)\n{", "RTL8139State *s = VAR_0;", "switch (VAR_1)\n{", "case MAC0 ... MAC0+5:\ns->phys[VAR_1 - MAC0] = VAR_2;", "qemu_format_nic_info_str(qemu_get_queue(s->nic), s->phys);", "break;", "case MAC0+6 ... MAC0+7:\nbreak;", "case MAR0 ... MAR0+7:\ns->mult[VAR_1 - MAR0] = VAR_2;", "break;", "case ChipCmd:\nrtl8139_ChipCmd_write(s, VAR_2);", "break;", "case Cfg9346:\nrtl8139_Cfg9346_write(s, VAR_2);", "break;", "case TxConfig:\nrtl8139_TxConfig_writeb(s, VAR_2);", "break;", "case Config0:\nrtl8139_Config0_write(s, VAR_2);", "break;", "case Config1:\nrtl8139_Config1_write(s, VAR_2);", "break;", "case Config3:\nrtl8139_Config3_write(s, VAR_2);", "break;", "case Config4:\nrtl8139_Config4_write(s, VAR_2);", "break;", "case Config5:\nrtl8139_Config5_write(s, VAR_2);", "break;", "case MediaStatus:\nDPRINTF(\"not implemented write(b) to MediaStatus VAR_2=0x%02x\\n\",\nVAR_2);", "break;", "case HltClk:\nDPRINTF(\"HltClk write VAR_2=0x%08x\\n\", VAR_2);", "if (VAR_2 == 'R')\n{", "s->clock_enabled = 1;", "}", "else if (VAR_2 == 'H')\n{", "s->clock_enabled = 0;", "}", "break;", "case TxThresh:\nDPRINTF(\"C+ TxThresh write(b) VAR_2=0x%02x\\n\", VAR_2);", "s->TxThresh = VAR_2;", "break;", "case TxPoll:\nDPRINTF(\"C+ TxPoll write(b) VAR_2=0x%02x\\n\", VAR_2);", "if (VAR_2 & (1 << 7))\n{", "DPRINTF(\"C+ TxPoll high priority transmission (not \"\n\"implemented)\\n\");", "}", "if (VAR_2 & (1 << 6))\n{", "DPRINTF(\"C+ TxPoll normal priority transmission\\n\");", "rtl8139_cplus_transmit(s);", "}", "break;", "default:\nDPRINTF(\"not implemented write(b) VAR_1=0x%x VAR_2=0x%02x\\n\", VAR_1,\nVAR_2);", "break;", "}", "}" ]

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

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

[ "static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{", "UserDefUnion *tmp = NULL;", "Error *err = NULL;", "Visitor *v;", "v = validate_test_init(VAR_0, \"{ 'type': 'b', 'VAR_0' : { 'integer': 42 } }\");", "visit_type_UserDefUnion(v, &tmp, NULL, &err);", "g_assert(err);", "qapi_free_UserDefUnion(tmp);", "}" ]

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

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

[ "static void FUNC_0 (void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{", "PCIAC97LinkState *d = VAR_0;", "AC97LinkState *s = &d->ac97;", "AC97BusMasterRegs *r = NULL;", "uint32_t index = VAR_1 - s->base[1];", "switch (index) {", "case PI_SR:\ncase PO_SR:\ncase MC_SR:\nr = &s->bm_regs[GET_BM (index)];", "r->sr |= VAR_2 & ~(SR_RO_MASK | SR_WCLEAR_MASK);", "update_sr (s, r, r->sr & ~(VAR_2 & SR_WCLEAR_MASK));", "dolog (\"SR[%d] <- %#x (sr %#x)\\n\", GET_BM (index), VAR_2, r->sr);", "break;", "default:\ndolog (\"U nabm writew %#x <- %#x\\n\", VAR_1, VAR_2);", "break;", "}", "}" ]

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

[ "static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{", "}" ]

[ 0, 0 ]

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

[ "void FUNC_0(ucf64_cmpd)(float64 a, float64 b, uint32_t c, CPUUniCore32State *env)\n{", "int VAR_0;", "VAR_0 = float64_compare_quiet(a, b, &env->ucf64.fp_status);", "env->CF = 0;", "switch (c & 0x7) {", "case 0:\nbreak;", "case 1:\nif (VAR_0 == 2) {", "env->CF = 1;", "}", "break;", "case 2:\nif (VAR_0 == 0) {", "env->CF = 1;", "}", "break;", "case 3:\nif ((VAR_0 == 0) || (VAR_0 == 2)) {", "env->CF = 1;", "}", "break;", "case 4:\nif (VAR_0 == -1) {", "env->CF = 1;", "}", "break;", "case 5:\nif ((VAR_0 == -1) || (VAR_0 == 2)) {", "env->CF = 1;", "}", "break;", "case 6:\nif ((VAR_0 == -1) || (VAR_0 == 0)) {", "env->CF = 1;", "}", "break;", "case 7:\nif (VAR_0 != 1) {", "env->CF = 1;", "}", "break;", "}", "env->ucf64.xregs[UC32_UCF64_FPSCR] = (env->CF << 29)\n| (env->ucf64.xregs[UC32_UCF64_FPSCR] & 0x0fffffff);", "}" ]

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

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

[ "static void FUNC_0(GArray *VAR_0, unsigned VAR_1)\n{", "g_array_set_size(VAR_0, (ROUND_UP(acpi_data_len(VAR_0), VAR_1) +\ng_array_get_element_size(VAR_0) - 1) /\ng_array_get_element_size(VAR_0));", "}" ]

[ 0, 0, 0 ]

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

[ "int FUNC_0(MigrationState *VAR_0, const char *VAR_1)\n{", "VAR_0->fd = monitor_get_fd(VAR_0->mon, VAR_1);", "if (VAR_0->fd == -1) {", "DPRINTF(\"fd_migration: invalid file descriptor identifier\\n\");", "goto err_after_get_fd;", "}", "if (fcntl(VAR_0->fd, F_SETFL, O_NONBLOCK) == -1) {", "DPRINTF(\"Unable to set nonblocking mode on file descriptor\\n\");", "goto err_after_open;", "}", "VAR_0->get_error = fd_errno;", "VAR_0->write = fd_write;", "VAR_0->close = fd_close;", "migrate_fd_connect(VAR_0);", "return 0;", "err_after_open:\nclose(VAR_0->fd);", "err_after_get_fd:\nreturn -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 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 41, 43 ], [ 45, 47 ], [ 49 ] ]

[ "int FUNC_0(MpegEncContext * VAR_0)\n{", "int VAR_1;", "#if 0\n{", "int i;", "for(i=0; i<VAR_0->gb.size*8; i++)", "printf(\"%d\", get_bits1(&VAR_0->gb));", "printf(\"END\\n\");", "return -1;", "}", "#endif\nif(VAR_0->msmpeg4_version==1){", "int VAR_2, VAR_3;", "VAR_2 = (get_bits(&VAR_0->gb, 16)<<16) | get_bits(&VAR_0->gb, 16);", "if(VAR_2!=0x00000100){", "fprintf(stderr, \"invalid startcode\\n\");", "return -1;", "}", "VAR_3= get_bits(&VAR_0->gb, 5);", "}", "VAR_0->pict_type = get_bits(&VAR_0->gb, 2) + 1;", "if (VAR_0->pict_type != I_TYPE &&\nVAR_0->pict_type != P_TYPE){", "fprintf(stderr, \"invalid picture type\\n\");", "return -1;", "}", "#if 0\n{", "static int had_i=0;", "if(VAR_0->pict_type == I_TYPE) had_i=1;", "if(!had_i) return -1;", "}", "#endif\nVAR_0->qscale = get_bits(&VAR_0->gb, 5);", "if (VAR_0->pict_type == I_TYPE) {", "VAR_1 = get_bits(&VAR_0->gb, 5);", "if(VAR_0->msmpeg4_version==1){", "if(VAR_1==0 || VAR_1>VAR_0->mb_height){", "fprintf(stderr, \"invalid slice height %d\\n\", VAR_1);", "return -1;", "}", "VAR_0->slice_height = VAR_1;", "}else{", "if (VAR_1 < 0x17){", "fprintf(stderr, \"error, slice VAR_1 was %X\\n\", VAR_1);", "return -1;", "}", "VAR_0->slice_height = VAR_0->mb_height / (VAR_1 - 0x16);", "}", "switch(VAR_0->msmpeg4_version){", "case 1:\ncase 2:\nVAR_0->rl_chroma_table_index = 2;", "VAR_0->rl_table_index = 2;", "VAR_0->dc_table_index = 0;", "break;", "case 3:\nVAR_0->rl_chroma_table_index = decode012(&VAR_0->gb);", "VAR_0->rl_table_index = decode012(&VAR_0->gb);", "VAR_0->dc_table_index = get_bits1(&VAR_0->gb);", "break;", "case 4:\nmsmpeg4_decode_ext_header(VAR_0, (2+5+5+17+7)/8);", "if(VAR_0->bit_rate > MBAC_BITRATE) VAR_0->per_mb_rl_table= get_bits1(&VAR_0->gb);", "else VAR_0->per_mb_rl_table= 0;", "if(!VAR_0->per_mb_rl_table){", "VAR_0->rl_chroma_table_index = decode012(&VAR_0->gb);", "VAR_0->rl_table_index = decode012(&VAR_0->gb);", "}", "VAR_0->dc_table_index = get_bits1(&VAR_0->gb);", "VAR_0->inter_intra_pred= 0;", "break;", "}", "VAR_0->no_rounding = 1;", "} else {", "switch(VAR_0->msmpeg4_version){", "case 1:\ncase 2:\nif(VAR_0->msmpeg4_version==1)\nVAR_0->use_skip_mb_code = 1;", "else\nVAR_0->use_skip_mb_code = get_bits1(&VAR_0->gb);", "VAR_0->rl_table_index = 2;", "VAR_0->rl_chroma_table_index = VAR_0->rl_table_index;", "VAR_0->dc_table_index = 0;", "VAR_0->mv_table_index = 0;", "break;", "case 3:\nVAR_0->use_skip_mb_code = get_bits1(&VAR_0->gb);", "VAR_0->rl_table_index = decode012(&VAR_0->gb);", "VAR_0->rl_chroma_table_index = VAR_0->rl_table_index;", "VAR_0->dc_table_index = get_bits1(&VAR_0->gb);", "VAR_0->mv_table_index = get_bits1(&VAR_0->gb);", "break;", "case 4:\nVAR_0->use_skip_mb_code = get_bits1(&VAR_0->gb);", "if(VAR_0->bit_rate > MBAC_BITRATE) VAR_0->per_mb_rl_table= get_bits1(&VAR_0->gb);", "else VAR_0->per_mb_rl_table= 0;", "if(!VAR_0->per_mb_rl_table){", "VAR_0->rl_table_index = decode012(&VAR_0->gb);", "VAR_0->rl_chroma_table_index = VAR_0->rl_table_index;", "}", "VAR_0->dc_table_index = get_bits1(&VAR_0->gb);", "VAR_0->mv_table_index = get_bits1(&VAR_0->gb);", "VAR_0->inter_intra_pred= (VAR_0->width*VAR_0->height < 320*240 && VAR_0->bit_rate<=II_BITRATE);", "break;", "}", "if(VAR_0->flipflop_rounding){", "VAR_0->no_rounding ^= 1;", "}else{", "VAR_0->no_rounding = 0;", "}", "}", "VAR_0->esc3_level_length= 0;", "VAR_0->esc3_run_length= 0;", "#ifdef DEBUG\nprintf(\"*****frame %d:\\n\", frame_count++);", "#endif\nreturn 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9, 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27, 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ], [ 121 ], [ 123, 125, 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137, 139 ], [ 141 ], [ 145 ], [ 147 ], [ 149, 151 ], [ 155 ], [ 157 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 195 ], [ 197 ], [ 199, 201, 203, 205 ], [ 207, 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221, 223 ], [ 225 ], [ 227 ], [ 231 ], [ 235 ], [ 237 ], [ 239, 241 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 261 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 305 ], [ 307 ], [ 311, 313 ], [ 315, 317 ], [ 319 ] ]

[ "static void FUNC_0(void *VAR_0, const uint8_t *VAR_1, size_t VAR_2)\n{", "USBNetState *s = VAR_0;", "struct rndis_packet_msg_type *VAR_3;", "if (s->rndis) {", "VAR_3 = (struct rndis_packet_msg_type *) s->in_buf;", "if (!s->rndis_state == RNDIS_DATA_INITIALIZED)\nreturn;", "if (VAR_2 + sizeof(struct rndis_packet_msg_type) > sizeof(s->in_buf))\nreturn;", "memset(VAR_3, 0, sizeof(struct rndis_packet_msg_type));", "VAR_3->MessageType = cpu_to_le32(RNDIS_PACKET_MSG);", "VAR_3->MessageLength = cpu_to_le32(VAR_2 + sizeof(struct rndis_packet_msg_type));", "VAR_3->DataOffset = cpu_to_le32(sizeof(struct rndis_packet_msg_type) - 8);", "VAR_3->DataLength = cpu_to_le32(VAR_2);", "memcpy(VAR_3 + 1, VAR_1, VAR_2);", "s->in_len = VAR_2 + sizeof(struct rndis_packet_msg_type);", "} else {", "if (VAR_2 > sizeof(s->in_buf))\nreturn;", "memcpy(s->in_buf, VAR_1, VAR_2);", "s->in_len = VAR_2;", "}", "s->in_ptr = 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 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 51 ], [ 53 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ] ]

[ "static int FUNC_0(V9fsPDU *VAR_0, uint16_t VAR_1, V9fsQID *VAR_2)\n{", "int VAR_3;", "size_t offset = 7;", "offset += pdu_marshal(VAR_0, offset, \"w\", VAR_1);", "for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++) {", "offset += pdu_marshal(VAR_0, offset, \"Q\", &VAR_2[VAR_3]);", "}", "return offset;", "}" ]

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

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

[ "static void FUNC_0(BlockDriverState *VAR_0, BlockDriverState *VAR_1,\nconst char *VAR_2)\n{", "BlockDriverState *intermediate;", "intermediate = VAR_0->backing_hd;", "while (intermediate) {", "BlockDriverState *unused;", "if (intermediate == VAR_1) {", "break;", "}", "unused = intermediate;", "intermediate = intermediate->backing_hd;", "unused->backing_hd = NULL;", "bdrv_delete(unused);", "}", "VAR_0->backing_hd = VAR_1;", "}" ]

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

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

[ "static void FUNC_0(struct qemu_paiocb *VAR_0)\n{", "VAR_0->ret = -EINPROGRESS;", "VAR_0->active = 0;", "mutex_lock(&lock);", "if (idle_threads == 0 && cur_threads < max_threads)\nspawn_thread();", "TAILQ_INSERT_TAIL(&request_list, VAR_0, node);", "mutex_unlock(&lock);", "cond_signal(&cond);", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0)\n{", "return bdrv_media_changed(VAR_0->file->VAR_0);", "}" ]

[ 0, 0, 0 ]

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

[ "bool FUNC_0(uintptr_t tc_ptr)\n{", "return (tc_ptr >= (uintptr_t)tcg_ctx.code_gen_buffer &&\ntc_ptr < (uintptr_t)(tcg_ctx.code_gen_buffer +\ntcg_ctx.code_gen_buffer_max_size));", "}" ]

[ 0, 0, 0 ]

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

[ "int FUNC_0(H264Context *VAR_0)\n{", "while (get_bits_left(&VAR_0->gb) > 16) {", "int VAR_1 = 0;", "int VAR_2 = 0;", "int VAR_3 = 0;", "int VAR_4 = 0;", "while (get_bits_left(&VAR_0->gb) >= 8 &&\n(VAR_4 = get_bits(&VAR_0->gb, 8)) == 255) {", "VAR_2 += 255;", "}", "VAR_2 += VAR_4;", "VAR_4 = 0;", "while (get_bits_left(&VAR_0->gb) >= 8 &&\n(VAR_4 = get_bits(&VAR_0->gb, 8)) == 255) {", "VAR_1 += 255;", "}", "VAR_1 += VAR_4;", "if (VAR_1 > get_bits_left(&VAR_0->gb) / 8) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"SEI VAR_2 %d truncated at %d\\n\",\nVAR_2, get_bits_left(&VAR_0->gb));", "return AVERROR_INVALIDDATA;", "}", "switch (VAR_2) {", "case SEI_TYPE_PIC_TIMING:\nVAR_3 = decode_picture_timing(VAR_0);", "if (VAR_3 < 0)\nreturn VAR_3;", "break;", "case SEI_TYPE_USER_DATA_UNREGISTERED:\nVAR_3 = decode_unregistered_user_data(VAR_0, VAR_1);", "if (VAR_3 < 0)\nreturn VAR_3;", "break;", "case SEI_TYPE_RECOVERY_POINT:\nVAR_3 = decode_recovery_point(VAR_0);", "if (VAR_3 < 0)\nreturn VAR_3;", "break;", "case SEI_TYPE_BUFFERING_PERIOD:\nVAR_3 = decode_buffering_period(VAR_0);", "if (VAR_3 < 0)\nreturn VAR_3;", "break;", "case SEI_TYPE_FRAME_PACKING:\nVAR_3 = decode_frame_packing_arrangement(VAR_0);", "if (VAR_3 < 0)\nreturn VAR_3;", "break;", "case SEI_TYPE_DISPLAY_ORIENTATION:\nVAR_3 = decode_display_orientation(VAR_0);", "if (VAR_3 < 0)\nreturn VAR_3;", "break;", "default:\nav_log(VAR_0->avctx, AV_LOG_DEBUG, \"unknown SEI VAR_2 %d\\n\", VAR_2);", "skip_bits(&VAR_0->gb, 8 * VAR_1);", "}", "align_get_bits(&VAR_0->gb);", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17, 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31, 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 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 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ] ]

[ "av_cold int FUNC_0(SwsContext *c, const int inv_table[4],\nint fullRange, int brightness,\nint contrast, int saturation)\n{", "const int VAR_0 = c->dstFormat == AV_PIX_FMT_RGB32 ||\nc->dstFormat == AV_PIX_FMT_RGB32_1 ||\nc->dstFormat == AV_PIX_FMT_BGR24 ||\nc->dstFormat == AV_PIX_FMT_RGB565BE ||\nc->dstFormat == AV_PIX_FMT_RGB565LE ||\nc->dstFormat == AV_PIX_FMT_RGB555BE ||\nc->dstFormat == AV_PIX_FMT_RGB555LE ||\nc->dstFormat == AV_PIX_FMT_RGB444BE ||\nc->dstFormat == AV_PIX_FMT_RGB444LE ||\nc->dstFormat == AV_PIX_FMT_RGB8 ||\nc->dstFormat == AV_PIX_FMT_RGB4 ||\nc->dstFormat == AV_PIX_FMT_RGB4_BYTE ||\nc->dstFormat == AV_PIX_FMT_MONOBLACK;", "const int VAR_1 = c->dstFormat == AV_PIX_FMT_NE(RGB565LE, RGB565BE) ||\nc->dstFormat == AV_PIX_FMT_NE(RGB555LE, RGB555BE) ||\nc->dstFormat == AV_PIX_FMT_NE(RGB444LE, RGB444BE) ||\nc->dstFormat == AV_PIX_FMT_NE(BGR565LE, BGR565BE) ||\nc->dstFormat == AV_PIX_FMT_NE(BGR555LE, BGR555BE) ||\nc->dstFormat == AV_PIX_FMT_NE(BGR444LE, BGR444BE);", "const int VAR_2 = c->dstFormatBpp;", "uint8_t *y_table;", "uint16_t *y_table16;", "uint32_t *y_table32;", "int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;", "const int VAR_10 = fullRange ? 384 : 326;", "int64_t crv = inv_table[0];", "int64_t cbu = inv_table[1];", "int64_t cgu = -inv_table[2];", "int64_t cgv = -inv_table[3];", "int64_t cy = 1 << 16;", "int64_t oy = 0;", "int64_t yb = 0;", "if (!fullRange) {", "cy = (cy * 255) / 219;", "oy = 16 << 16;", "} else {", "crv = (crv * 224) / 255;", "cbu = (cbu * 224) / 255;", "cgu = (cgu * 224) / 255;", "cgv = (cgv * 224) / 255;", "}", "cy = (cy * contrast) >> 16;", "crv = (crv * contrast * saturation) >> 32;", "cbu = (cbu * contrast * saturation) >> 32;", "cgu = (cgu * contrast * saturation) >> 32;", "cgv = (cgv * contrast * saturation) >> 32;", "oy -= 256 * brightness;", "c->uOffset = 0x0400040004000400LL;", "c->vOffset = 0x0400040004000400LL;", "c->yCoeff = roundToInt16(cy * 8192) * 0x0001000100010001ULL;", "c->vrCoeff = roundToInt16(crv * 8192) * 0x0001000100010001ULL;", "c->ubCoeff = roundToInt16(cbu * 8192) * 0x0001000100010001ULL;", "c->vgCoeff = roundToInt16(cgv * 8192) * 0x0001000100010001ULL;", "c->ugCoeff = roundToInt16(cgu * 8192) * 0x0001000100010001ULL;", "c->yOffset = roundToInt16(oy * 8) * 0x0001000100010001ULL;", "c->yuv2rgb_y_coeff = (int16_t)roundToInt16(cy << 13);", "c->yuv2rgb_y_offset = (int16_t)roundToInt16(oy << 9);", "c->yuv2rgb_v2r_coeff = (int16_t)roundToInt16(crv << 13);", "c->yuv2rgb_v2g_coeff = (int16_t)roundToInt16(cgv << 13);", "c->yuv2rgb_u2g_coeff = (int16_t)roundToInt16(cgu << 13);", "c->yuv2rgb_u2b_coeff = (int16_t)roundToInt16(cbu << 13);", "crv = ((crv << 16) + 0x8000) / cy;", "cbu = ((cbu << 16) + 0x8000) / cy;", "cgu = ((cgu << 16) + 0x8000) / cy;", "cgv = ((cgv << 16) + 0x8000) / cy;", "av_free(c->yuvTable);", "switch (VAR_2) {", "case 1:\nc->yuvTable = av_malloc(1024);", "y_table = c->yuvTable;", "yb = -(384 << 16) - oy;", "for (VAR_3 = 0; VAR_3 < 1024 - 110; VAR_3++) {", "y_table[VAR_3 + 110] = av_clip_uint8((yb + 0x8000) >> 16) >> 7;", "yb += cy;", "}", "fill_table(c->table_gU, 1, cgu, y_table + VAR_10);", "fill_gv_table(c->table_gV, 1, cgv);", "break;", "case 4:\ncase 4 | 128:\nVAR_5 = VAR_0 ? 3 : 0;", "VAR_6 = 1;", "VAR_7 = VAR_0 ? 0 : 3;", "c->yuvTable = av_malloc(1024 * 3);", "y_table = c->yuvTable;", "yb = -(384 << 16) - oy;", "for (VAR_3 = 0; VAR_3 < 1024 - 110; VAR_3++) {", "int VAR_12 = av_clip_uint8((yb + 0x8000) >> 16);", "y_table[VAR_3 + 110] = (VAR_12 >> 7) << VAR_5;", "y_table[VAR_3 + 37 + 1024] = ((VAR_12 + 43) / 85) << VAR_6;", "y_table[VAR_3 + 110 + 2048] = (VAR_12 >> 7) << VAR_7;", "yb += cy;", "}", "fill_table(c->table_rV, 1, crv, y_table + VAR_10);", "fill_table(c->table_gU, 1, cgu, y_table + VAR_10 + 1024);", "fill_table(c->table_bU, 1, cbu, y_table + VAR_10 + 2048);", "fill_gv_table(c->table_gV, 1, cgv);", "break;", "case 8:\nVAR_5 = VAR_0 ? 5 : 0;", "VAR_6 = VAR_0 ? 2 : 3;", "VAR_7 = VAR_0 ? 0 : 6;", "c->yuvTable = av_malloc(1024 * 3);", "y_table = c->yuvTable;", "yb = -(384 << 16) - oy;", "for (VAR_3 = 0; VAR_3 < 1024 - 38; VAR_3++) {", "int VAR_12 = av_clip_uint8((yb + 0x8000) >> 16);", "y_table[VAR_3 + 16] = ((VAR_12 + 18) / 36) << VAR_5;", "y_table[VAR_3 + 16 + 1024] = ((VAR_12 + 18) / 36) << VAR_6;", "y_table[VAR_3 + 37 + 2048] = ((VAR_12 + 43) / 85) << VAR_7;", "yb += cy;", "}", "fill_table(c->table_rV, 1, crv, y_table + VAR_10);", "fill_table(c->table_gU, 1, cgu, y_table + VAR_10 + 1024);", "fill_table(c->table_bU, 1, cbu, y_table + VAR_10 + 2048);", "fill_gv_table(c->table_gV, 1, cgv);", "break;", "case 12:\nVAR_5 = VAR_0 ? 8 : 0;", "VAR_6 = 4;", "VAR_7 = VAR_0 ? 0 : 8;", "c->yuvTable = av_malloc(1024 * 3 * 2);", "y_table16 = c->yuvTable;", "yb = -(384 << 16) - oy;", "for (VAR_3 = 0; VAR_3 < 1024; VAR_3++) {", "uint8_t VAR_12 = av_clip_uint8((yb + 0x8000) >> 16);", "y_table16[VAR_3] = (VAR_12 >> 4) << VAR_5;", "y_table16[VAR_3 + 1024] = (VAR_12 >> 4) << VAR_6;", "y_table16[VAR_3 + 2048] = (VAR_12 >> 4) << VAR_7;", "yb += cy;", "}", "if (VAR_1)\nfor (VAR_3 = 0; VAR_3 < 1024 * 3; VAR_3++)", "y_table16[VAR_3] = av_bswap16(y_table16[VAR_3]);", "fill_table(c->table_rV, 2, crv, y_table16 + VAR_10);", "fill_table(c->table_gU, 2, cgu, y_table16 + VAR_10 + 1024);", "fill_table(c->table_bU, 2, cbu, y_table16 + VAR_10 + 2048);", "fill_gv_table(c->table_gV, 2, cgv);", "break;", "case 15:\ncase 16:\nVAR_5 = VAR_0 ? VAR_2 - 5 : 0;", "VAR_6 = 5;", "VAR_7 = VAR_0 ? 0 : (VAR_2 - 5);", "c->yuvTable = av_malloc(1024 * 3 * 2);", "y_table16 = c->yuvTable;", "yb = -(384 << 16) - oy;", "for (VAR_3 = 0; VAR_3 < 1024; VAR_3++) {", "uint8_t VAR_12 = av_clip_uint8((yb + 0x8000) >> 16);", "y_table16[VAR_3] = (VAR_12 >> 3) << VAR_5;", "y_table16[VAR_3 + 1024] = (VAR_12 >> (18 - VAR_2)) << VAR_6;", "y_table16[VAR_3 + 2048] = (VAR_12 >> 3) << VAR_7;", "yb += cy;", "}", "if (VAR_1)\nfor (VAR_3 = 0; VAR_3 < 1024 * 3; VAR_3++)", "y_table16[VAR_3] = av_bswap16(y_table16[VAR_3]);", "fill_table(c->table_rV, 2, crv, y_table16 + VAR_10);", "fill_table(c->table_gU, 2, cgu, y_table16 + VAR_10 + 1024);", "fill_table(c->table_bU, 2, cbu, y_table16 + VAR_10 + 2048);", "fill_gv_table(c->table_gV, 2, cgv);", "break;", "case 24:\ncase 48:\nc->yuvTable = av_malloc(1024);", "y_table = c->yuvTable;", "yb = -(384 << 16) - oy;", "for (VAR_3 = 0; VAR_3 < 1024; VAR_3++) {", "y_table[VAR_3] = av_clip_uint8((yb + 0x8000) >> 16);", "yb += cy;", "}", "fill_table(c->table_rV, 1, crv, y_table + VAR_10);", "fill_table(c->table_gU, 1, cgu, y_table + VAR_10);", "fill_table(c->table_bU, 1, cbu, y_table + VAR_10);", "fill_gv_table(c->table_gV, 1, cgv);", "break;", "case 32:\nVAR_4 = (c->dstFormat == AV_PIX_FMT_RGB32_1 ||\nc->dstFormat == AV_PIX_FMT_BGR32_1) ? 8 : 0;", "VAR_5 = VAR_4 + (VAR_0 ? 16 : 0);", "VAR_6 = VAR_4 + 8;", "VAR_7 = VAR_4 + (VAR_0 ? 0 : 16);", "VAR_9 = CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat);", "if (!VAR_9)\nVAR_8 = (VAR_4 + 24) & 31;", "c->yuvTable = av_malloc(1024 * 3 * 4);", "y_table32 = c->yuvTable;", "yb = -(384 << 16) - oy;", "for (VAR_3 = 0; VAR_3 < 1024; VAR_3++) {", "unsigned VAR_12 = av_clip_uint8((yb + 0x8000) >> 16);", "y_table32[VAR_3] = (VAR_12 << VAR_5) +\n(VAR_9 ? 0 : (255u << VAR_8));", "y_table32[VAR_3 + 1024] = VAR_12 << VAR_6;", "y_table32[VAR_3 + 2048] = VAR_12 << VAR_7;", "yb += cy;", "}", "fill_table(c->table_rV, 4, crv, y_table32 + VAR_10);", "fill_table(c->table_gU, 4, cgu, y_table32 + VAR_10 + 1024);", "fill_table(c->table_bU, 4, cbu, y_table32 + VAR_10 + 2048);", "fill_gv_table(c->table_gV, 4, cgv);", "break;", "default:\nc->yuvTable = NULL;", "if(!isPlanar(c->dstFormat) || VAR_2 <= 24)\nav_log(c, AV_LOG_ERROR, \"%ibpp not supported by yuv2rgb\\n\", VAR_2);", "return -1;", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33 ], [ 35, 37, 39, 41, 43, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 155 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183, 185, 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223, 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261, 263 ], [ 265 ], [ 267 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289, 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305, 307, 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335, 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351, 353, 355 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379, 381, 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393, 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407, 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429, 431 ], [ 433, 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0)\n{", "Vp3DecodeContext *s = VAR_0->priv_data;", "int VAR_1;", "s->VAR_0 = VAR_0;", "s->width = VAR_0->width;", "s->height = VAR_0->height;", "VAR_0->pix_fmt = PIX_FMT_YUV420P;", "VAR_0->has_b_frames = 0;", "dsputil_init(&s->dsp, VAR_0);", "s->quality_index = -1;", "s->superblock_width = (s->width + 31) / 32;", "s->superblock_height = (s->height + 31) / 32;", "s->superblock_count = s->superblock_width * s->superblock_height * 3 / 2;", "s->u_superblock_start = s->superblock_width * s->superblock_height;", "s->v_superblock_start = s->superblock_width * s->superblock_height * 5 / 4;", "s->superblock_coding = av_malloc(s->superblock_count);", "s->macroblock_width = (s->width + 15) / 16;", "s->macroblock_height = (s->height + 15) / 16;", "s->macroblock_count = s->macroblock_width * s->macroblock_height;", "s->fragment_width = s->width / FRAGMENT_PIXELS;", "s->fragment_height = s->height / FRAGMENT_PIXELS;", "s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;", "s->u_fragment_start = s->fragment_width * s->fragment_height;", "s->v_fragment_start = s->fragment_width * s->fragment_height * 5 / 4;", "debug_init(\" width: %d x %d\\n\", s->width, s->height);", "debug_init(\" superblocks: %d x %d, %d total\\n\",\ns->superblock_width, s->superblock_height, s->superblock_count);", "debug_init(\" macroblocks: %d x %d, %d total\\n\",\ns->macroblock_width, s->macroblock_height, s->macroblock_count);", "debug_init(\" %d fragments, %d x %d, u starts @ %d, v starts @ %d\\n\",\ns->fragment_count,\ns->fragment_width,\ns->fragment_height,\ns->u_fragment_start,\ns->v_fragment_start);", "s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));", "s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));", "s->pixel_addresses_inited = 0;", "for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {", "init_vlc(&s->dc_vlc[VAR_1], 5, 32,\n&dc_bias[VAR_1][0][1], 4, 2,\n&dc_bias[VAR_1][0][0], 4, 2);", "init_vlc(&s->ac_vlc_1[VAR_1], 5, 32,\n&ac_bias_0[VAR_1][0][1], 4, 2,\n&ac_bias_0[VAR_1][0][0], 4, 2);", "init_vlc(&s->ac_vlc_2[VAR_1], 5, 32,\n&ac_bias_1[VAR_1][0][1], 4, 2,\n&ac_bias_1[VAR_1][0][0], 4, 2);", "init_vlc(&s->ac_vlc_3[VAR_1], 5, 32,\n&ac_bias_2[VAR_1][0][1], 4, 2,\n&ac_bias_2[VAR_1][0][0], 4, 2);", "init_vlc(&s->ac_vlc_4[VAR_1], 5, 32,\n&ac_bias_3[VAR_1][0][1], 4, 2,\n&ac_bias_3[VAR_1][0][0], 4, 2);", "}", "for (VAR_1 = 0; VAR_1 < 64; VAR_1++)", "quant_index[dequant_index[VAR_1]] = VAR_1;", "s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));", "s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));", "s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));", "s->macroblock_coded = av_malloc(s->macroblock_count + 1);", "init_block_mapping(s);", "for (VAR_1 = 0; VAR_1 < 3; VAR_1++) {", "s->current_frame.data[VAR_1] = NULL;", "s->last_frame.data[VAR_1] = NULL;", "s->golden_frame.data[VAR_1] = NULL;", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73, 75 ], [ 77, 79 ], [ 81, 83, 85, 87, 89, 91 ], [ 95 ], [ 97 ], [ 99 ], [ 105 ], [ 111, 113, 115 ], [ 121, 123, 125 ], [ 131, 133, 135 ], [ 141, 143, 145 ], [ 151, 153, 155 ], [ 157 ], [ 163 ], [ 165 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ] ]

[ "static void FUNC_0(DisasContext *VAR_0)\n{", "#if defined(CONFIG_USER_ONLY)\nGEN_PRIV;", "#else\nCHK_HV;", "gen_check_tlb_flush(VAR_0);", "#endif\n}" ]

[ 0, 0, 0, 1, 0 ]

[ [ 1, 3 ], [ 5, 7 ], [ 9, 11 ], [ 23 ], [ 25, 27 ] ]

[ "static void FUNC_0(AACEncContext *VAR_0, ChannelElement *VAR_1)\n{", "int VAR_2 = 0, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;", "float VAR_8[128], VAR_9[128];", "float *VAR_10 = VAR_0->scoefs, *VAR_11 = VAR_0->scoefs + 128, *VAR_12 = VAR_0->scoefs + 128*2, *VAR_13 = VAR_0->scoefs + 128*3;", "const float VAR_14 = VAR_0->VAR_14;", "const float VAR_15 = FFMIN(1.0f, VAR_14 / 120.f);", "SingleChannelElement *sce0 = &VAR_1->ch[0];", "SingleChannelElement *sce1 = &VAR_1->ch[1];", "if (!VAR_1->common_window)\nreturn;", "for (VAR_4 = 0; VAR_4 < sce0->ics.num_windows; VAR_4 += sce0->ics.group_len[VAR_4]) {", "int min_sf_idx_mid = SCALE_MAX_POS;", "int min_sf_idx_side = SCALE_MAX_POS;", "for (VAR_6 = 0; VAR_6 < sce0->ics.num_swb; VAR_6++) {", "if (!sce0->zeroes[VAR_4*16+VAR_6] && sce0->band_type[VAR_4*16+VAR_6] < RESERVED_BT)\nmin_sf_idx_mid = FFMIN(min_sf_idx_mid, sce0->sf_idx[VAR_4*16+VAR_6]);", "if (!sce1->zeroes[VAR_4*16+VAR_6] && sce1->band_type[VAR_4*16+VAR_6] < RESERVED_BT)\nmin_sf_idx_side = FFMIN(min_sf_idx_side, sce1->sf_idx[VAR_4*16+VAR_6]);", "}", "VAR_2 = 0;", "for (VAR_6 = 0; VAR_6 < sce0->ics.num_swb; VAR_6++) {", "float bmax = bval2bmax(VAR_6 * 17.0f / sce0->ics.num_swb) / 0.0045f;", "VAR_1->ms_mask[VAR_4*16+VAR_6] = 0;", "if (!VAR_1->ch[0].zeroes[VAR_4*16+VAR_6] && !VAR_1->ch[1].zeroes[VAR_4*16+VAR_6]) {", "float Mmax = 0.0f, Smax = 0.0f;", "for (VAR_5 = 0; VAR_5 < sce0->ics.group_len[VAR_4]; VAR_5++) {", "for (VAR_3 = 0; VAR_3 < sce0->ics.swb_sizes[VAR_6]; VAR_3++) {", "VAR_8[VAR_3] = (sce0->coeffs[VAR_2+(VAR_4+VAR_5)*128+VAR_3]\n+ sce1->coeffs[VAR_2+(VAR_4+VAR_5)*128+VAR_3]) * 0.5;", "VAR_9[VAR_3] = VAR_8[VAR_3]\n- sce1->coeffs[VAR_2+(VAR_4+VAR_5)*128+VAR_3];", "}", "abs_pow34_v(VAR_12, VAR_8, sce0->ics.swb_sizes[VAR_6]);", "abs_pow34_v(VAR_13, VAR_9, sce0->ics.swb_sizes[VAR_6]);", "for (VAR_3 = 0; VAR_3 < sce0->ics.swb_sizes[VAR_6]; VAR_3++ ) {", "Mmax = FFMAX(Mmax, VAR_12[VAR_3]);", "Smax = FFMAX(Smax, VAR_13[VAR_3]);", "}", "}", "for (VAR_7 = 0; VAR_7 < 4; VAR_7++) {", "float dist1 = 0.0f, dist2 = 0.0f;", "int B0 = 0, B1 = 0;", "int minidx;", "int mididx, sididx;", "int midcb, sidcb;", "minidx = FFMIN(sce0->sf_idx[VAR_4*16+VAR_6], sce1->sf_idx[VAR_4*16+VAR_6]);", "mididx = av_clip(minidx, min_sf_idx_mid, min_sf_idx_mid + SCALE_MAX_DIFF);", "sididx = av_clip(minidx - VAR_7 * 3, min_sf_idx_side, min_sf_idx_side + SCALE_MAX_DIFF);", "midcb = find_min_book(Mmax, mididx);", "sidcb = find_min_book(Smax, sididx);", "if ((mididx > minidx) || (sididx > minidx)) {", "continue;", "}", "midcb = FFMAX(1,midcb);", "sidcb = FFMAX(1,sidcb);", "for (VAR_5 = 0; VAR_5 < sce0->ics.group_len[VAR_4]; VAR_5++) {", "FFPsyBand *band0 = &VAR_0->psy.ch[VAR_0->cur_channel+0].psy_bands[(VAR_4+VAR_5)*16+VAR_6];", "FFPsyBand *band1 = &VAR_0->psy.ch[VAR_0->cur_channel+1].psy_bands[(VAR_4+VAR_5)*16+VAR_6];", "float minthr = FFMIN(band0->threshold, band1->threshold);", "int b1,b2,b3,b4;", "for (VAR_3 = 0; VAR_3 < sce0->ics.swb_sizes[VAR_6]; VAR_3++) {", "VAR_8[VAR_3] = (sce0->coeffs[VAR_2+(VAR_4+VAR_5)*128+VAR_3]\n+ sce1->coeffs[VAR_2+(VAR_4+VAR_5)*128+VAR_3]) * 0.5;", "VAR_9[VAR_3] = VAR_8[VAR_3]\n- sce1->coeffs[VAR_2+(VAR_4+VAR_5)*128+VAR_3];", "}", "abs_pow34_v(VAR_10, sce0->coeffs+VAR_2+(VAR_4+VAR_5)*128, sce0->ics.swb_sizes[VAR_6]);", "abs_pow34_v(VAR_11, sce1->coeffs+VAR_2+(VAR_4+VAR_5)*128, sce0->ics.swb_sizes[VAR_6]);", "abs_pow34_v(VAR_12, VAR_8, sce0->ics.swb_sizes[VAR_6]);", "abs_pow34_v(VAR_13, VAR_9, sce0->ics.swb_sizes[VAR_6]);", "dist1 += quantize_band_cost(VAR_0, &sce0->coeffs[VAR_2 + (VAR_4+VAR_5)*128],\nVAR_10,\nsce0->ics.swb_sizes[VAR_6],\nsce0->sf_idx[(VAR_4+VAR_5)*16+VAR_6],\nsce0->band_type[(VAR_4+VAR_5)*16+VAR_6],\nVAR_14 / band0->threshold, INFINITY, &b1, NULL, 0);", "dist1 += quantize_band_cost(VAR_0, &sce1->coeffs[VAR_2 + (VAR_4+VAR_5)*128],\nVAR_11,\nsce1->ics.swb_sizes[VAR_6],\nsce1->sf_idx[(VAR_4+VAR_5)*16+VAR_6],\nsce1->band_type[(VAR_4+VAR_5)*16+VAR_6],\nVAR_14 / band1->threshold, INFINITY, &b2, NULL, 0);", "dist2 += quantize_band_cost(VAR_0, VAR_8,\nVAR_12,\nsce0->ics.swb_sizes[VAR_6],\nsce0->sf_idx[(VAR_4+VAR_5)*16+VAR_6],\nsce0->band_type[(VAR_4+VAR_5)*16+VAR_6],\nVAR_14 / minthr, INFINITY, &b3, NULL, 0);", "dist2 += quantize_band_cost(VAR_0, VAR_9,\nVAR_13,\nsce1->ics.swb_sizes[VAR_6],\nsce1->sf_idx[(VAR_4+VAR_5)*16+VAR_6],\nsce1->band_type[(VAR_4+VAR_5)*16+VAR_6],\nVAR_15 / (minthr * bmax), INFINITY, &b4, NULL, 0);", "B0 += b1+b2;", "B1 += b3+b4;", "dist1 -= B0;", "dist2 -= B1;", "}", "VAR_1->ms_mask[VAR_4*16+VAR_6] = dist2 <= dist1 && B1 < B0;", "if (VAR_1->ms_mask[VAR_4*16+VAR_6]) {", "if (!VAR_1->is_mask[VAR_4*16+VAR_6] && sce0->band_type[VAR_4*16+VAR_6] != NOISE_BT && sce1->band_type[VAR_4*16+VAR_6] != NOISE_BT) {", "sce0->sf_idx[VAR_4*16+VAR_6] = mididx;", "sce1->sf_idx[VAR_4*16+VAR_6] = sididx;", "sce0->band_type[VAR_4*16+VAR_6] = midcb;", "sce1->band_type[VAR_4*16+VAR_6] = sidcb;", "}", "break;", "} else if (B1 > B0) {", "break;", "}", "}", "}", "VAR_2 += sce0->ics.swb_sizes[VAR_6];", "}", "}", "}" ]

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

[ [ 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 ], [ 59 ], [ 61 ], [ 63, 65 ], [ 67, 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 119 ], [ 121 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145, 147 ], [ 149, 151 ], [ 153 ], [ 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 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ] ]

[ "static void FUNC_0(struct NetTxPkt *VAR_0)\n{", "struct iovec *VAR_1 = &VAR_0->vec[NET_TX_PKT_L2HDR_FRAG];", "uint32_t csum_cntr;", "uint16_t csum = 0;", "uint32_t cso;", "uint32_t iov_len = VAR_0->payload_frags + NET_TX_PKT_PL_START_FRAG - 1;", "uint16_t csl;", "struct ip_header *VAR_2;", "size_t csum_offset = VAR_0->virt_hdr.csum_start + VAR_0->virt_hdr.csum_offset;", "iov_from_buf(VAR_1, iov_len, csum_offset, &csum, sizeof csum);", "csl = VAR_0->payload_len;", "VAR_2 = VAR_0->vec[NET_TX_PKT_L3HDR_FRAG].iov_base;", "csum_cntr = eth_calc_ip4_pseudo_hdr_csum(VAR_2, csl, &cso);", "csum_cntr +=\nnet_checksum_add_iov(VAR_1, iov_len, VAR_0->virt_hdr.csum_start, csl, cso);", "csum = cpu_to_be16(net_checksum_finish(csum_cntr));", "iov_from_buf(VAR_1, iov_len, csum_offset, &csum, sizeof csum);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 27 ], [ 33 ], [ 39 ], [ 41 ], [ 47, 49 ], [ 55 ], [ 57 ], [ 59 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "int VAR_0, VAR_1, VAR_9 = -1;", "int VAR_3 = avctx->flags;", "struct xvid_context *VAR_4 = avctx->priv_data;", "uint16_t *intra, *inter;", "int VAR_5;", "xvid_plugin_single_t single = { 0 };", "struct xvid_ff_pass1 VAR_6 = { 0 };", "xvid_plugin_2pass2_t rc2pass2 = { 0 };", "xvid_plugin_lumimasking_t masking_l = { 0 };", "xvid_plugin_lumimasking_t masking_v = { 0 };", "xvid_plugin_ssim_t ssim = { 0 };", "xvid_gbl_init_t xvid_gbl_init = { 0 };", "xvid_enc_create_t xvid_enc_create = { 0 };", "xvid_enc_plugin_t plugins[4];", "VAR_4->twopassfd = -1;", "VAR_4->vop_flags = XVID_VOP_HALFPEL;", "if (VAR_3 & AV_CODEC_FLAG_4MV)\nVAR_4->vop_flags |= XVID_VOP_INTER4V;", "if (avctx->trellis)\nVAR_4->vop_flags |= XVID_VOP_TRELLISQUANT;", "if (VAR_3 & AV_CODEC_FLAG_AC_PRED)\nVAR_4->vop_flags |= XVID_VOP_HQACPRED;", "if (VAR_3 & AV_CODEC_FLAG_GRAY)\nVAR_4->vop_flags |= XVID_VOP_GREYSCALE;", "VAR_4->me_flags = 0;", "switch (VAR_4->me_quality) {", "case 6:\ncase 5:\nVAR_4->me_flags |= XVID_ME_EXTSEARCH16 |\nXVID_ME_EXTSEARCH8;", "case 4:\ncase 3:\nVAR_4->me_flags |= XVID_ME_ADVANCEDDIAMOND8 |\nXVID_ME_HALFPELREFINE8 |\nXVID_ME_CHROMA_PVOP |\nXVID_ME_CHROMA_BVOP;", "case 2:\ncase 1:\nVAR_4->me_flags |= XVID_ME_ADVANCEDDIAMOND16 |\nXVID_ME_HALFPELREFINE16;", "#if FF_API_MOTION_EST\nFF_DISABLE_DEPRECATION_WARNINGS\nbreak;", "default:\nswitch (avctx->me_method) {", "case ME_FULL:\nVAR_4->me_flags |= XVID_ME_EXTSEARCH16 |\nXVID_ME_EXTSEARCH8;", "case ME_EPZS:\nVAR_4->me_flags |= XVID_ME_ADVANCEDDIAMOND8 |\nXVID_ME_HALFPELREFINE8 |\nXVID_ME_CHROMA_PVOP |\nXVID_ME_CHROMA_BVOP;", "case ME_LOG:\ncase ME_PHODS:\ncase ME_X1:\nVAR_4->me_flags |= XVID_ME_ADVANCEDDIAMOND16 |\nXVID_ME_HALFPELREFINE16;", "case ME_ZERO:\ndefault:\nbreak;", "}", "FF_ENABLE_DEPRECATION_WARNINGS\n#endif\n}", "switch (avctx->mb_decision) {", "case 2:\nVAR_4->vop_flags |= XVID_VOP_MODEDECISION_RD;", "VAR_4->me_flags |= XVID_ME_HALFPELREFINE8_RD |\nXVID_ME_QUARTERPELREFINE8_RD |\nXVID_ME_EXTSEARCH_RD |\nXVID_ME_CHECKPREDICTION_RD;", "case 1:\nif (!(VAR_4->vop_flags & XVID_VOP_MODEDECISION_RD))\nVAR_4->vop_flags |= XVID_VOP_FAST_MODEDECISION_RD;", "VAR_4->me_flags |= XVID_ME_HALFPELREFINE16_RD |\nXVID_ME_QUARTERPELREFINE16_RD;", "default:\nbreak;", "}", "#if FF_API_GMC\nif (avctx->flags & CODEC_FLAG_GMC)\nVAR_4->gmc = 1;", "#endif\nVAR_4->vol_flags = 0;", "if (VAR_4->gmc) {", "VAR_4->vol_flags |= XVID_VOL_GMC;", "VAR_4->me_flags |= XVID_ME_GME_REFINE;", "}", "if (VAR_3 & AV_CODEC_FLAG_QPEL) {", "VAR_4->vol_flags |= XVID_VOL_QUARTERPEL;", "VAR_4->me_flags |= XVID_ME_QUARTERPELREFINE16;", "if (VAR_4->vop_flags & XVID_VOP_INTER4V)\nVAR_4->me_flags |= XVID_ME_QUARTERPELREFINE8;", "}", "xvid_gbl_init.version = XVID_VERSION;", "xvid_gbl_init.debug = 0;", "xvid_gbl_init.cpu_flags = 0;", "xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);", "xvid_enc_create.version = XVID_VERSION;", "xvid_enc_create.width =\nVAR_4->xsize = avctx->width;", "xvid_enc_create.height =\nVAR_4->ysize = avctx->height;", "xvid_enc_create.zones = NULL;", "xvid_enc_create.num_zones = 0;", "xvid_enc_create.num_threads = avctx->thread_count;", "#if (XVID_VERSION <= 0x010303) && (XVID_VERSION >= 0x010300)\nif (avctx->height <= 16) {", "if (avctx->thread_count < 2) {", "xvid_enc_create.num_threads = 0;", "} else {", "av_log(avctx, AV_LOG_ERROR,\n\"Too small height for threads > 1.\");", "return AVERROR(EINVAL);", "}", "}", "#endif\nxvid_enc_create.plugins = plugins;", "xvid_enc_create.num_plugins = 0;", "VAR_4->twopassbuffer = NULL;", "VAR_4->old_twopassbuffer = NULL;", "VAR_4->twopassfile = NULL;", "if (VAR_3 & AV_CODEC_FLAG_PASS1) {", "VAR_6.version = XVID_VERSION;", "VAR_6.context = VAR_4;", "VAR_4->twopassbuffer = av_malloc(BUFFER_SIZE);", "VAR_4->old_twopassbuffer = av_malloc(BUFFER_SIZE);", "if (!VAR_4->twopassbuffer || !VAR_4->old_twopassbuffer) {", "av_log(avctx, AV_LOG_ERROR,\n\"Xvid: Cannot allocate 2-pass log buffers\\n\");", "return AVERROR(ENOMEM);", "}", "VAR_4->twopassbuffer[0] =\nVAR_4->old_twopassbuffer[0] = 0;", "plugins[xvid_enc_create.num_plugins].func = xvid_ff_2pass;", "plugins[xvid_enc_create.num_plugins].param = &VAR_6;", "xvid_enc_create.num_plugins++;", "} else if (VAR_3 & AV_CODEC_FLAG_PASS2) {", "rc2pass2.version = XVID_VERSION;", "rc2pass2.bitrate = avctx->bit_rate;", "VAR_5 = avpriv_tempfile(\"xvidff.\", &VAR_4->twopassfile, 0, avctx);", "if (VAR_5 < 0) {", "av_log(avctx, AV_LOG_ERROR, \"Xvid: Cannot write 2-pass pipe\\n\");", "return VAR_5;", "}", "VAR_4->twopassfd = VAR_5;", "if (!avctx->stats_in) {", "av_log(avctx, AV_LOG_ERROR,\n\"Xvid: No 2-pass information loaded for second pass\\n\");", "return AVERROR(EINVAL);", "}", "VAR_9 = write(VAR_5, avctx->stats_in, strlen(avctx->stats_in));", "if (VAR_9 == -1)\nVAR_9 = AVERROR(errno);", "else if (strlen(avctx->stats_in) > VAR_9) {", "av_log(avctx, AV_LOG_ERROR, \"Xvid: Cannot write to 2-pass pipe\\n\");", "VAR_9 = AVERROR(EIO);", "}", "if (VAR_9 < 0)\nreturn VAR_9;", "rc2pass2.filename = VAR_4->twopassfile;", "plugins[xvid_enc_create.num_plugins].func = xvid_plugin_2pass2;", "plugins[xvid_enc_create.num_plugins].param = &rc2pass2;", "xvid_enc_create.num_plugins++;", "} else if (!(VAR_3 & AV_CODEC_FLAG_QSCALE)) {", "single.version = XVID_VERSION;", "single.bitrate = avctx->bit_rate;", "plugins[xvid_enc_create.num_plugins].func = xvid_plugin_single;", "plugins[xvid_enc_create.num_plugins].param = &single;", "xvid_enc_create.num_plugins++;", "}", "if (avctx->lumi_masking != 0.0)\nVAR_4->lumi_aq = 1;", "if (VAR_4->lumi_aq) {", "masking_l.method = 0;", "plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;", "plugins[xvid_enc_create.num_plugins].param =\navctx->lumi_masking ? NULL : &masking_l;", "xvid_enc_create.num_plugins++;", "}", "if (VAR_4->variance_aq) {", "masking_v.method = 1;", "plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;", "plugins[xvid_enc_create.num_plugins].param = &masking_v;", "xvid_enc_create.num_plugins++;", "}", "if (VAR_4->lumi_aq && VAR_4->variance_aq )\nav_log(avctx, AV_LOG_INFO,\n\"Both lumi_aq and variance_aq are enabled. The resulting quality\"\n\"will be the worse one of the two effects made by the AQ.\\n\");", "if (VAR_4->ssim) {", "plugins[xvid_enc_create.num_plugins].func = xvid_plugin_ssim;", "ssim.b_printstat = VAR_4->ssim == 2;", "ssim.acc = VAR_4->ssim_acc;", "ssim.cpu_flags = xvid_gbl_init.cpu_flags;", "ssim.b_visualize = 0;", "plugins[xvid_enc_create.num_plugins].param = &ssim;", "xvid_enc_create.num_plugins++;", "}", "xvid_correct_framerate(avctx);", "xvid_enc_create.fincr = avctx->time_base.num;", "xvid_enc_create.fbase = avctx->time_base.den;", "if (avctx->gop_size > 0)\nxvid_enc_create.max_key_interval = avctx->gop_size;", "else\nxvid_enc_create.max_key_interval = 240;", "if (VAR_3 & AV_CODEC_FLAG_QSCALE)\nVAR_4->qscale = 1;", "else\nVAR_4->qscale = 0;", "xvid_enc_create.min_quant[0] = avctx->qmin;", "xvid_enc_create.min_quant[1] = avctx->qmin;", "xvid_enc_create.min_quant[2] = avctx->qmin;", "xvid_enc_create.max_quant[0] = avctx->qmax;", "xvid_enc_create.max_quant[1] = avctx->qmax;", "xvid_enc_create.max_quant[2] = avctx->qmax;", "VAR_4->intra_matrix =\nVAR_4->inter_matrix = NULL;", "#if FF_API_PRIVATE_OPT\nFF_DISABLE_DEPRECATION_WARNINGS\nif (avctx->mpeg_quant)\nVAR_4->mpeg_quant = avctx->mpeg_quant;", "FF_ENABLE_DEPRECATION_WARNINGS\n#endif\nif (VAR_4->mpeg_quant)\nVAR_4->vol_flags |= XVID_VOL_MPEGQUANT;", "if ((avctx->intra_matrix || avctx->inter_matrix)) {", "VAR_4->vol_flags |= XVID_VOL_MPEGQUANT;", "if (avctx->intra_matrix) {", "intra = avctx->intra_matrix;", "VAR_4->intra_matrix = av_malloc(sizeof(unsigned char) * 64);", "if (!VAR_4->intra_matrix)\nreturn AVERROR(ENOMEM);", "} else", "intra = NULL;", "if (avctx->inter_matrix) {", "inter = avctx->inter_matrix;", "VAR_4->inter_matrix = av_malloc(sizeof(unsigned char) * 64);", "if (!VAR_4->inter_matrix)\nreturn AVERROR(ENOMEM);", "} else", "inter = NULL;", "for (VAR_1 = 0; VAR_1 < 64; VAR_1++) {", "if (intra)\nVAR_4->intra_matrix[VAR_1] = (unsigned char) intra[VAR_1];", "if (inter)\nVAR_4->inter_matrix[VAR_1] = (unsigned char) inter[VAR_1];", "}", "}", "xvid_enc_create.frame_drop_ratio = 0;", "xvid_enc_create.global = 0;", "if (VAR_3 & AV_CODEC_FLAG_CLOSED_GOP)\nxvid_enc_create.global |= XVID_GLOBAL_CLOSED_GOP;", "avctx->extradata = NULL;", "avctx->extradata_size = 0;", "if (VAR_3 & AV_CODEC_FLAG_GLOBAL_HEADER) {", "VAR_4->quicktime_format = 1;", "avctx->codec_id = AV_CODEC_ID_MPEG4;", "} else {", "VAR_4->quicktime_format = 0;", "if (!avctx->codec_tag)\navctx->codec_tag = AV_RL32(\"xvid\");", "}", "xvid_enc_create.max_bframes = avctx->max_b_frames;", "xvid_enc_create.bquant_offset = 100 * avctx->b_quant_offset;", "xvid_enc_create.bquant_ratio = 100 * avctx->b_quant_factor;", "if (avctx->max_b_frames > 0 && !VAR_4->quicktime_format)\nxvid_enc_create.global |= XVID_GLOBAL_PACKED;", "av_assert0(xvid_enc_create.num_plugins + (!!VAR_4->ssim) + (!!VAR_4->variance_aq) + (!!VAR_4->lumi_aq) <= FF_ARRAY_ELEMS(plugins));", "if (VAR_4->quicktime_format) {", "AVFrame *picture;", "AVPacket packet;", "int VAR_7, VAR_8, VAR_9;", "av_init_packet(&packet);", "picture = av_frame_alloc();", "if (!picture)\nreturn AVERROR(ENOMEM);", "VAR_0 = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);", "if( VAR_0 ) {", "av_frame_free(&picture);", "av_log(avctx, AV_LOG_ERROR, \"Xvid: Could not create encoder reference\\n\");", "return AVERROR_EXTERNAL;", "}", "VAR_4->encoder_handle = xvid_enc_create.handle;", "VAR_7 = ((avctx->width + 1) & ~1) * ((avctx->height + 1) & ~1);", "picture->data[0] = av_malloc(VAR_7 + VAR_7 / 2);", "if (!picture->data[0]) {", "av_frame_free(&picture);", "return AVERROR(ENOMEM);", "}", "picture->data[1] = picture->data[0] + VAR_7;", "picture->data[2] = picture->data[1] + VAR_7 / 4;", "memset(picture->data[0], 0, VAR_7);", "memset(picture->data[1], 128, VAR_7 / 2);", "VAR_9 = xvid_encode_frame(avctx, &packet, picture, &VAR_8);", "if (!VAR_9 && VAR_8)\nav_packet_unref(&packet);", "av_free(picture->data[0]);", "av_frame_free(&picture);", "xvid_encore(VAR_4->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);", "}", "VAR_0 = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);", "if (VAR_0) {", "av_log(avctx, AV_LOG_ERROR, \"Xvid: Could not create encoder reference\\n\");", "return AVERROR_EXTERNAL;", "}", "VAR_4->encoder_handle = xvid_enc_create.handle;", "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, 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 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 43 ], [ 45, 47 ], [ 49, 51 ], [ 53, 55 ], [ 57, 59 ], [ 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 ], [ 151 ], [ 153, 155 ], [ 157, 159, 161, 163 ], [ 165, 167, 169 ], [ 171, 173 ], [ 175, 177 ], [ 179 ], [ 185, 187, 189 ], [ 191, 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211, 213 ], [ 215 ], [ 219 ], [ 221 ], [ 223 ], [ 229 ], [ 235 ], [ 241, 243 ], [ 245, 247 ], [ 259 ], [ 261 ], [ 265 ], [ 267, 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279, 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289, 293 ], [ 295 ], [ 301 ], [ 303 ], [ 305 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321, 323 ], [ 325 ], [ 327 ], [ 329, 331 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 363 ], [ 365, 367 ], [ 369 ], [ 371 ], [ 375 ], [ 377, 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389, 391 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 407 ], [ 409 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 423, 425 ], [ 431 ], [ 433 ], [ 435 ], [ 443, 445 ], [ 447 ], [ 449 ], [ 455 ], [ 457 ], [ 459 ], [ 461 ], [ 463 ], [ 465 ], [ 469, 471, 473, 475 ], [ 481 ], [ 483 ], [ 485 ], [ 487 ], [ 489 ], [ 491 ], [ 493 ], [ 495 ], [ 497 ], [ 503 ], [ 505 ], [ 507 ], [ 509, 511 ], [ 513, 515 ], [ 521, 523 ], [ 525, 527 ], [ 531 ], [ 533 ], [ 535 ], [ 537 ], [ 539 ], [ 541 ], [ 547, 549 ], [ 553, 555, 557, 559 ], [ 561, 563, 567, 569 ], [ 571 ], [ 573 ], [ 577 ], [ 579 ], [ 581 ], [ 583, 585 ], [ 587 ], [ 589 ], [ 591 ], [ 593 ], [ 595 ], [ 597, 599 ], [ 601 ], [ 603 ], [ 607 ], [ 609, 611 ], [ 613, 615 ], [ 617 ], [ 619 ], [ 625 ], [ 627 ], [ 629, 631 ], [ 637 ], [ 639 ], [ 641 ], [ 645 ], [ 647 ], [ 649 ], [ 653 ], [ 655, 657 ], [ 659 ], [ 665 ], [ 667 ], [ 669 ], [ 671, 673 ], [ 677 ], [ 683 ], [ 685 ], [ 687 ], [ 689 ], [ 693 ], [ 697 ], [ 699, 701 ], [ 705 ], [ 707 ], [ 709 ], [ 711 ], [ 713 ], [ 715 ], [ 717 ], [ 719 ], [ 721 ], [ 723 ], [ 725 ], [ 727 ], [ 729 ], [ 731 ], [ 733 ], [ 735 ], [ 737 ], [ 739 ], [ 741, 743 ], [ 745 ], [ 747 ], [ 749 ], [ 751 ], [ 757 ], [ 759 ], [ 761 ], [ 763 ], [ 765 ], [ 769 ], [ 773 ], [ 775 ] ]

[ "static void FUNC_0(void)\n{", "WorkerTestData data;", "Coroutine *co = qemu_coroutine_create(co_test_cb);", "qemu_coroutine_enter(co, &data);", "g_assert_cmpint(active, ==, 1);", "g_assert_cmpint(data.ret, ==, -EINPROGRESS);", "qemu_aio_wait_all();", "g_assert_cmpint(active, ==, 0);", "g_assert_cmpint(data.ret, ==, 0);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 19 ], [ 21 ], [ 29 ], [ 37 ], [ 39 ], [ 41 ] ]

[ "static void FUNC_0(PCNetState *VAR_0)\n{", "hwaddr xmit_cxda = 0;", "int VAR_1 = CSR_XMTRL(VAR_0)-1;", "int VAR_2 = 0;", "int VAR_3;", "VAR_0->xmit_pos = -1;", "if (!CSR_TXON(VAR_0)) {", "VAR_0->csr[0] &= ~0x0008;", "return;", "}", "VAR_0->tx_busy = 1;", "txagain:\nif (pcnet_tdte_poll(VAR_0)) {", "struct pcnet_TMD VAR_5;", "TMDLOAD(&VAR_5, PHYSADDR(VAR_0,CSR_CXDA(VAR_0)));", "#ifdef PCNET_DEBUG_TMD\nprintf(\" TMDLOAD 0x%08x\\n\", PHYSADDR(VAR_0,CSR_CXDA(VAR_0)));", "PRINT_TMD(&VAR_5);", "#endif\nif (GET_FIELD(VAR_5.status, TMDS, STP)) {", "VAR_0->xmit_pos = 0;", "xmit_cxda = PHYSADDR(VAR_0,CSR_CXDA(VAR_0));", "if (BCR_SWSTYLE(VAR_0) != 1)\nVAR_2 = GET_FIELD(VAR_5.status, TMDS, ADDFCS);", "}", "if (VAR_0->lnkst == 0 &&\n(!CSR_LOOP(VAR_0) || (!CSR_INTL(VAR_0) && !BCR_TMAULOOP(VAR_0)))) {", "SET_FIELD(&VAR_5.misc, TMDM, LCAR, 1);", "SET_FIELD(&VAR_5.status, TMDS, ERR, 1);", "SET_FIELD(&VAR_5.status, TMDS, OWN, 0);", "VAR_0->csr[0] |= 0xa000;", "VAR_0->xmit_pos = -1;", "goto txdone;", "}", "if (VAR_0->xmit_pos < 0) {", "goto txdone;", "}", "VAR_3 = 4096 - GET_FIELD(VAR_5.length, TMDL, BCNT);", "if (VAR_0->xmit_pos + VAR_3 > sizeof(VAR_0->buffer)) {", "VAR_0->xmit_pos = -1;", "goto txdone;", "}", "VAR_0->phys_mem_read(VAR_0->dma_opaque, PHYSADDR(VAR_0, VAR_5.tbadr),\nVAR_0->buffer + VAR_0->xmit_pos, VAR_3, CSR_BSWP(VAR_0));", "VAR_0->xmit_pos += VAR_3;", "if (!GET_FIELD(VAR_5.status, TMDS, ENP)) {", "goto txdone;", "}", "#ifdef PCNET_DEBUG\nprintf(\"FUNC_0 size=%d\\n\", VAR_0->xmit_pos);", "#endif\nif (CSR_LOOP(VAR_0)) {", "if (BCR_SWSTYLE(VAR_0) == 1)\nVAR_2 = !GET_FIELD(VAR_5.status, TMDS, NOFCS);", "VAR_0->looptest = VAR_2 ? PCNET_LOOPTEST_CRC : PCNET_LOOPTEST_NOCRC;", "pcnet_receive(qemu_get_queue(VAR_0->nic), VAR_0->buffer, VAR_0->xmit_pos);", "VAR_0->looptest = 0;", "} else {", "if (VAR_0->nic) {", "qemu_send_packet(qemu_get_queue(VAR_0->nic), VAR_0->buffer,\nVAR_0->xmit_pos);", "}", "}", "VAR_0->csr[0] &= ~0x0008;", "VAR_0->csr[4] |= 0x0004;", "VAR_0->xmit_pos = -1;", "txdone:\nSET_FIELD(&VAR_5.status, TMDS, OWN, 0);", "TMDSTORE(&VAR_5, PHYSADDR(VAR_0,CSR_CXDA(VAR_0)));", "if (!CSR_TOKINTD(VAR_0) || (CSR_LTINTEN(VAR_0) && GET_FIELD(VAR_5.status, TMDS, LTINT)))\nVAR_0->csr[0] |= 0x0200;", "if (CSR_XMTRC(VAR_0)<=1)\nCSR_XMTRC(VAR_0) = CSR_XMTRL(VAR_0);", "else\nCSR_XMTRC(VAR_0)--;", "if (VAR_1--)\ngoto txagain;", "} else", "if (VAR_0->xmit_pos >= 0) {", "struct pcnet_TMD VAR_5;", "TMDLOAD(&VAR_5, xmit_cxda);", "SET_FIELD(&VAR_5.misc, TMDM, BUFF, 1);", "SET_FIELD(&VAR_5.misc, TMDM, UFLO, 1);", "SET_FIELD(&VAR_5.status, TMDS, ERR, 1);", "SET_FIELD(&VAR_5.status, TMDS, OWN, 0);", "TMDSTORE(&VAR_5, xmit_cxda);", "VAR_0->csr[0] |= 0x0200;", "if (!CSR_DXSUFLO(VAR_0)) {", "VAR_0->csr[0] &= ~0x0010;", "} else", "if (VAR_1--)\ngoto txagain;", "}", "VAR_0->tx_busy = 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 31, 33 ], [ 35 ], [ 39 ], [ 43, 45 ], [ 47 ], [ 49, 51 ], [ 53 ], [ 55 ], [ 57, 59 ], [ 61 ], [ 63, 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109, 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 125, 127 ], [ 129, 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147, 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ], [ 161 ], [ 165, 167 ], [ 169 ], [ 171, 173 ], [ 177, 179 ], [ 181, 183 ], [ 185, 187 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 207 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 217, 219 ], [ 221 ], [ 225 ], [ 227 ] ]

[ "long FUNC_0(CPUMBState *VAR_0)\n{", "struct target_signal_frame *VAR_1;", "abi_ulong frame_addr;", "target_sigset_t target_set;", "sigset_t set;", "int VAR_2;", "frame_addr = VAR_0->regs[R_SP];", "trace_user_do_sigreturn(VAR_0, frame_addr);", "if (!lock_user_struct(VERIFY_WRITE, VAR_1, frame_addr, 1))\ngoto badframe;", "__get_user(target_set.sig[0], &VAR_1->uc.tuc_mcontext.oldmask);", "for(VAR_2 = 1; VAR_2 < TARGET_NSIG_WORDS; VAR_2++) {", "__get_user(target_set.sig[VAR_2], &VAR_1->extramask[VAR_2 - 1]);", "}", "target_to_host_sigset_internal(&set, &target_set);", "do_sigprocmask(SIG_SETMASK, &set, NULL);", "restore_sigcontext(&VAR_1->uc.tuc_mcontext, VAR_0);", "VAR_0->regs[14] = VAR_0->sregs[SR_PC];", "unlock_user_struct(VAR_1, frame_addr, 0);", "return VAR_0->regs[10];", "badframe:\nforce_sig(TARGET_SIGSEGV);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 51 ], [ 55 ], [ 57 ], [ 59, 61 ], [ 63 ] ]

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

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

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

[ "static void FUNC_0(CPUState *VAR_0, int VAR_1)\n{", "struct timespec VAR_2;", "int VAR_3, VAR_4;", "siginfo_t siginfo;", "sigset_t waitset;", "VAR_2.tv_sec = VAR_1 / 1000;", "VAR_2.tv_nsec = (VAR_1 % 1000) * 1000000;", "sigemptyset(&waitset);", "sigaddset(&waitset, SIG_IPI);", "qemu_mutex_unlock(&qemu_global_mutex);", "VAR_3 = sigtimedwait(&waitset, &siginfo, &VAR_2);", "VAR_4 = errno;", "qemu_mutex_lock(&qemu_global_mutex);", "if (VAR_3 == -1 && !(VAR_4 == EAGAIN || VAR_4 == EINTR)) {", "fprintf(stderr, \"sigtimedwait: %s\\n\", strerror(VAR_4));", "exit(1);", "}", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1, char *VAR_2,\nint VAR_3, int VAR_4,\nint VAR_5) {", "WebMDashMuxContext *w = VAR_0->priv_data;", "AVDictionaryEntry *irange = av_dict_get(VAR_1->metadata, INITIALIZATION_RANGE, NULL, 0);", "AVDictionaryEntry *cues_start = av_dict_get(VAR_1->metadata, CUES_START, NULL, 0);", "AVDictionaryEntry *cues_end = av_dict_get(VAR_1->metadata, CUES_END, NULL, 0);", "AVDictionaryEntry *filename = av_dict_get(VAR_1->metadata, FILENAME, NULL, 0);", "AVDictionaryEntry *bandwidth = av_dict_get(VAR_1->metadata, BANDWIDTH, NULL, 0);", "if ((w->is_live && (!filename)) ||\n(!w->is_live && (!irange || !cues_start || !cues_end || !filename || !bandwidth))) {", "return -1;", "}", "avio_printf(VAR_0->pb, \"<Representation VAR_2=\\\"%VAR_0\\\"\", VAR_2);", "avio_printf(VAR_0->pb, \" bandwidth=\\\"%VAR_0\\\"\",\nw->is_live ? (VAR_1->codec->codec_type == AVMEDIA_TYPE_AUDIO ? \"128000\" : \"1000000\") : bandwidth->value);", "if (VAR_1->codec->codec_type == AVMEDIA_TYPE_VIDEO && VAR_3)\navio_printf(VAR_0->pb, \" width=\\\"%d\\\"\", VAR_1->codec->width);", "if (VAR_1->codec->codec_type == AVMEDIA_TYPE_VIDEO && VAR_4)\navio_printf(VAR_0->pb, \" height=\\\"%d\\\"\", VAR_1->codec->height);", "if (VAR_1->codec->codec_type = AVMEDIA_TYPE_AUDIO && VAR_5)\navio_printf(VAR_0->pb, \" audioSamplingRate=\\\"%d\\\"\", VAR_1->codec->sample_rate);", "if (w->is_live) {", "avio_printf(VAR_0->pb, \" codecs=\\\"%VAR_0\\\"\", get_codec_name(VAR_1->codec->codec_id));", "avio_printf(VAR_0->pb, \" mimeType=\\\"%VAR_0/webm\\\"\",\nVAR_1->codec->codec_type == AVMEDIA_TYPE_VIDEO ? \"video\" : \"audio\");", "avio_printf(VAR_0->pb, \" startsWithSAP=\\\"1\\\"\");", "avio_printf(VAR_0->pb, \">\");", "} else {", "avio_printf(VAR_0->pb, \">\\n\");", "avio_printf(VAR_0->pb, \"<BaseURL>%VAR_0</BaseURL>\\n\", filename->value);", "avio_printf(VAR_0->pb, \"<SegmentBase\\n\");", "avio_printf(VAR_0->pb, \" indexRange=\\\"%VAR_0-%VAR_0\\\">\\n\", cues_start->value, cues_end->value);", "avio_printf(VAR_0->pb, \"<Initialization\\n\");", "avio_printf(VAR_0->pb, \" range=\\\"0-%VAR_0\\\" />\\n\", irange->value);", "avio_printf(VAR_0->pb, \"</SegmentBase>\\n\");", "}", "avio_printf(VAR_0->pb, \"</Representation>\\n\");", "return 0;", "}" ]

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

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

[ "static inline int FUNC_0(AVFilterContext *VAR_0, const char *VAR_1)\n{", "HueContext *hue = VAR_0->priv;", "int VAR_2, VAR_3;", "char VAR_4 = 0, VAR_5 = 0;", "char *VAR_6, *VAR_7, *VAR_8;", "AVExpr *old_hue_pexpr, *old_hue_deg_pexpr, *old_saturation_pexpr;", "if (VAR_1) {", "if (strchr(VAR_1, '=')) {", "VAR_6 = hue->hue_expr;", "VAR_7 = hue->hue_deg_expr;", "VAR_8 = hue->saturation_expr;", "old_hue_pexpr = hue->hue_pexpr;", "old_hue_deg_pexpr = hue->hue_deg_pexpr;", "old_saturation_pexpr = hue->saturation_pexpr;", "hue->hue_expr = NULL;", "hue->hue_deg_expr = NULL;", "hue->saturation_expr = NULL;", "if ((VAR_3 = av_set_options_string(hue, VAR_1, \"=\", \":\")) < 0)\nreturn VAR_3;", "if (hue->hue_expr && hue->hue_deg_expr) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"H and h options are incompatible and cannot be specified \"\n\"at the same time\\VAR_2\");", "hue->hue_expr = VAR_6;", "hue->hue_deg_expr = VAR_7;", "return AVERROR(EINVAL);", "}", "if (!hue->hue_expr && !hue->hue_deg_expr) {", "hue->hue_expr = VAR_6;", "hue->hue_deg_expr = VAR_7;", "}", "if (hue->hue_deg_expr)\nPARSE_EXPRESSION(hue_deg, h);", "if (hue->hue_expr)\nPARSE_EXPRESSION(hue, H);", "if (hue->saturation_expr)\nPARSE_EXPRESSION(saturation, s);", "hue->flat_syntax = 0;", "av_log(VAR_0, AV_LOG_VERBOSE,\n\"H_expr:%s h_deg_expr:%s s_expr:%s\\VAR_2\",\nhue->hue_expr, hue->hue_deg_expr, hue->saturation_expr);", "} else {", "VAR_2 = sscanf(VAR_1, \"%f%c%f%c\", &hue->hue_deg, &VAR_4, &hue->saturation, &VAR_5);", "if (VAR_2 != 1 && (VAR_2 != 3 || VAR_4 != ':')) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Invalid syntax for argument '%s': \"\n\"must be in the form 'hue[:saturation]'\\VAR_2\", VAR_1);", "return AVERROR(EINVAL);", "}", "if (hue->saturation < SAT_MIN_VAL || hue->saturation > SAT_MAX_VAL) {", "av_log(VAR_0, AV_LOG_ERROR,\n\"Invalid value for saturation %0.1f: \"\n\"must be included between range %d and +%d\\VAR_2\",\nhue->saturation, SAT_MIN_VAL, SAT_MAX_VAL);", "return AVERROR(EINVAL);", "}", "hue->hue = hue->hue_deg * M_PI / 180;", "hue->flat_syntax = 1;", "av_log(VAR_0, AV_LOG_VERBOSE,\n\"H:%0.1f h:%0.1f s:%0.1f\\VAR_2\",\nhue->hue, hue->hue_deg, hue->saturation);", "}", "}", "compute_sin_and_cos(hue);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 47, 49 ], [ 51 ], [ 53, 55, 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89, 91 ], [ 93, 95 ], [ 97, 99 ], [ 103 ], [ 107, 109, 111 ], [ 117 ], [ 119 ], [ 121 ], [ 123, 125, 127 ], [ 129 ], [ 131 ], [ 135 ], [ 137, 139, 141, 143 ], [ 145 ], [ 147 ], [ 151 ], [ 153 ], [ 157, 159, 161 ], [ 163 ], [ 165 ], [ 169 ], [ 173 ], [ 175 ] ]

[ "static int FUNC_0(Object *VAR_0, void *VAR_1)\n{", "IOThread *iothread;", "iothread = (IOThread *)object_dynamic_cast(VAR_0, TYPE_IOTHREAD);", "if (!iothread || !iothread->ctx) {", "return 0;", "}", "iothread->stopping = true;", "aio_notify(iothread->ctx);", "if (atomic_read(&iothread->main_loop)) {", "g_main_loop_quit(iothread->main_loop);", "}", "qemu_thread_join(&iothread->thread);", "return 0;", "}" ]

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

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

[ "SCSIDevice *FUNC_0(BlockDriverState *bdrv, int tcq,\nscsi_completionfn completion, void *opaque)\n{", "SCSIDevice *d;", "SCSIDeviceState *s;", "s = (SCSIDeviceState *)qemu_mallocz(sizeof(SCSIDeviceState));", "s->bdrv = bdrv;", "s->tcq = tcq;", "s->completion = completion;", "s->opaque = opaque;", "if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {", "s->cluster_size = 4;", "} else {", "s->cluster_size = 1;", "}", "bdrv_get_geometry(s->bdrv, &nb_sectors);", "nb_sectors /= s->cluster_size;", "if (nb_sectors)\nnb_sectors--;", "s->max_lba = nb_sectors;", "strncpy(s->drive_serial_str, drive_get_serial(s->bdrv),\nsizeof(s->drive_serial_str));", "if (strlen(s->drive_serial_str) == 0)\npstrcpy(s->drive_serial_str, sizeof(s->drive_serial_str), \"0\");", "qemu_add_vm_change_state_handler(scsi_dma_restart_cb, s);", "d = (SCSIDevice *)qemu_mallocz(sizeof(SCSIDevice));", "d->state = s;", "d->destroy = scsi_destroy;", "d->send_command = scsi_send_command;", "d->read_data = scsi_read_data;", "d->write_data = scsi_write_data;", "d->cancel_io = scsi_cancel_io;", "d->get_buf = scsi_get_buf;", "return d;", "}" ]

[ 0, 0, 0, 0, 0, 0, 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 ], [ 14 ], [ 16 ], [ 18 ], [ 20 ], [ 22 ], [ 24 ], [ 26 ], [ 28 ], [ 30 ], [ 32 ], [ 34 ], [ 36 ], [ 38, 40 ], [ 42 ], [ 44, 46 ], [ 48, 50 ], [ 52 ], [ 54 ], [ 56 ], [ 58 ], [ 60 ], [ 62 ], [ 64 ], [ 66 ], [ 68 ], [ 72 ], [ 74 ] ]

[ "static void FUNC_0(USBDevice *VAR_0)\n{", "USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, VAR_0);", "qemu_chr_delete(dev->cs);", "qemu_bh_delete(dev->chardev_close_bh);", "qemu_del_timer(dev->attach_timer);", "qemu_free_timer(dev->attach_timer);", "usbredir_cleanup_device_queues(dev);", "if (dev->parser) {", "usbredirparser_destroy(dev->parser);", "}", "if (dev->watch) {", "g_source_remove(dev->watch);", "}", "free(dev->filter_rules);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 14 ], [ 18 ], [ 20 ], [ 24 ], [ 28 ], [ 30 ], [ 32 ], [ 34 ], [ 36 ], [ 38 ], [ 42 ], [ 44 ] ]

[ "static int FUNC_0(uint32_t VAR_0, int VAR_1)\n{", "int VAR_2;", "uint32_t sum2;", "if (VAR_0 <= VAR_1 >> 1)\nreturn 0;", "sum2 = VAR_0 - (VAR_1 >> 1);", "VAR_2 = av_log2(VAR_1 < 256 ? FASTDIV(sum2, VAR_1) : sum2 / VAR_1);", "return FFMIN(VAR_2, MAX_RICE_PARAM);", "}" ]

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

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

[ "static void FUNC_0(VncState *VAR_0,\nint VAR_1, int VAR_2,\nint VAR_3, int VAR_4,\nint VAR_5, int VAR_6, int VAR_7,\nint VAR_8, int VAR_9, int VAR_10)\n{", "int VAR_11;", "#ifdef WORDS_BIGENDIAN\nVAR_11 = 1;", "#else\nVAR_11 = 0;", "#endif\nif (!VAR_4) {", "fail:\nvnc_client_error(VAR_0);", "return;", "}", "if (VAR_1 == 32 &&\nVAR_1 == VAR_0->VAR_2 * 8 &&\nVAR_11 == VAR_3 &&\nVAR_5 == 0xff && VAR_6 == 0xff && VAR_7 == 0xff &&\nVAR_8 == 16 && VAR_9 == 8 && VAR_10 == 0) {", "VAR_0->VAR_2 = 4;", "VAR_0->write_pixels = vnc_write_pixels_copy;", "VAR_0->send_hextile_tile = send_hextile_tile_32;", "} else", "if (VAR_1 == 16 &&\nVAR_1 == VAR_0->VAR_2 * 8 &&\nVAR_11 == VAR_3 &&\nVAR_5 == 31 && VAR_6 == 63 && VAR_7 == 31 &&\nVAR_8 == 11 && VAR_9 == 5 && VAR_10 == 0) {", "VAR_0->VAR_2 = 2;", "VAR_0->write_pixels = vnc_write_pixels_copy;", "VAR_0->send_hextile_tile = send_hextile_tile_16;", "} else", "if (VAR_1 == 8 &&\nVAR_1 == VAR_0->VAR_2 * 8 &&\nVAR_5 == 7 && VAR_6 == 7 && VAR_7 == 3 &&\nVAR_8 == 5 && VAR_9 == 2 && VAR_10 == 0) {", "VAR_0->VAR_2 = 1;", "VAR_0->write_pixels = vnc_write_pixels_copy;", "VAR_0->send_hextile_tile = send_hextile_tile_8;", "} else", "{", "if (VAR_1 != 8 &&\nVAR_1 != 16 &&\nVAR_1 != 32)\ngoto fail;", "if (VAR_0->VAR_2 == 4) {", "VAR_0->send_hextile_tile = send_hextile_tile_generic_32;", "} else if (VAR_0->VAR_2 == 2) {", "VAR_0->send_hextile_tile = send_hextile_tile_generic_16;", "} else {", "VAR_0->send_hextile_tile = send_hextile_tile_generic_8;", "}", "VAR_0->pix_big_endian = VAR_3;", "VAR_0->write_pixels = vnc_write_pixels_generic;", "}", "VAR_0->client_red_shift = VAR_8;", "VAR_0->client_red_max = VAR_5;", "VAR_0->client_green_shift = VAR_9;", "VAR_0->client_green_max = VAR_6;", "VAR_0->client_blue_shift = VAR_10;", "VAR_0->client_blue_max = VAR_7;", "VAR_0->pix_bpp = VAR_1 / 8;", "vga_hw_invalidate();", "vga_hw_update();", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,\nsize_t VAR_2)\n{", "int64_t len;", "if (!bdrv_is_inserted(VAR_0))\nreturn -ENOMEDIUM;", "if (VAR_0->growable)\nreturn 0;", "len = bdrv_getlength(VAR_0);", "if (VAR_1 < 0)\nif ((VAR_1 > len) || (len - VAR_1 < VAR_2))\nreturn 0;" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "NetSocketListenState *s = VAR_0;", "NetSocketState *s1;", "struct sockaddr_in VAR_1;", "socklen_t len;", "int VAR_2;", "for(;;) {", "len = sizeof(VAR_1);", "VAR_2 = qemu_accept(s->VAR_2, (struct sockaddr *)&VAR_1, &len);", "if (VAR_2 < 0 && errno != EINTR) {", "return;", "} else if (VAR_2 >= 0) {", "break;", "}", "}", "s1 = net_socket_fd_init(s->vlan, s->model, s->name, VAR_2, 1);", "if (!s1) {", "closesocket(VAR_2);", "} else {", "snprintf(s1->nc.info_str, sizeof(s1->nc.info_str),\n\"socket: connection from %s:%d\",\ninet_ntoa(VAR_1.sin_addr), ntohs(VAR_1.sin_port));", "}", "}" ]

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

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

[ "static void FUNC_0(int16_t *VAR_0, int16_t *VAR_1, int VAR_2)\n{", "const int VAR_3 = svq3_dequant_coeff[VAR_2];", "#define stride 16\nint VAR_4;", "int VAR_5[16];", "static const uint8_t VAR_6[4] = { 0, 1 * stride, 4 * stride, 5 * stride };", "for (VAR_4 = 0; VAR_4 < 4; VAR_4++) {", "const int VAR_12 = 13 * (VAR_1[4 * VAR_4 + 0] + VAR_1[4 * VAR_4 + 2]);", "const int VAR_12 = 13 * (VAR_1[4 * VAR_4 + 0] - VAR_1[4 * VAR_4 + 2]);", "const int VAR_12 = 7 * VAR_1[4 * VAR_4 + 1] - 17 * VAR_1[4 * VAR_4 + 3];", "const int VAR_12 = 17 * VAR_1[4 * VAR_4 + 1] + 7 * VAR_1[4 * VAR_4 + 3];", "VAR_5[4 * VAR_4 + 0] = VAR_12 + VAR_12;", "VAR_5[4 * VAR_4 + 1] = VAR_12 + VAR_12;", "VAR_5[4 * VAR_4 + 2] = VAR_12 - VAR_12;", "VAR_5[4 * VAR_4 + 3] = VAR_12 - VAR_12;", "}", "for (VAR_4 = 0; VAR_4 < 4; VAR_4++) {", "const int VAR_11 = VAR_6[VAR_4];", "const int VAR_12 = 13 * (VAR_5[4 * 0 + VAR_4] + VAR_5[4 * 2 + VAR_4]);", "const int VAR_12 = 13 * (VAR_5[4 * 0 + VAR_4] - VAR_5[4 * 2 + VAR_4]);", "const int VAR_12 = 7 * VAR_5[4 * 1 + VAR_4] - 17 * VAR_5[4 * 3 + VAR_4];", "const int VAR_12 = 17 * VAR_5[4 * 1 + VAR_4] + 7 * VAR_5[4 * 3 + VAR_4];", "VAR_0[stride * 0 + VAR_11] = (VAR_12 + VAR_12) * VAR_3 + 0x80000 >> 20;", "VAR_0[stride * 2 + VAR_11] = (VAR_12 + VAR_12) * VAR_3 + 0x80000 >> 20;", "VAR_0[stride * 8 + VAR_11] = (VAR_12 - VAR_12) * VAR_3 + 0x80000 >> 20;", "VAR_0[stride * 10 + VAR_11] = (VAR_12 - VAR_12) * VAR_3 + 0x80000 >> 20;", "}", "}" ]

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

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

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

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

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

[ "int FUNC_0(H264Context *VAR_0, H264SliceContext *VAR_1)\n{", "ERContext *er = &VAR_1->er;", "int VAR_2 = VAR_0->mb_height * VAR_0->mb_stride;", "int VAR_3 = (2 * VAR_0->mb_width + 1) * (2 * VAR_0->mb_height + 1);", "int VAR_4 = VAR_0->mb_stride * (VAR_0->mb_height + 1);", "int VAR_5 = VAR_3 + 2 * VAR_4;", "int VAR_6, VAR_7, VAR_8;", "VAR_1->ref_cache[0][scan8[5] + 1] =\nVAR_1->ref_cache[0][scan8[7] + 1] =\nVAR_1->ref_cache[0][scan8[13] + 1] =\nVAR_1->ref_cache[1][scan8[5] + 1] =\nVAR_1->ref_cache[1][scan8[7] + 1] =\nVAR_1->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;", "if (VAR_1 != VAR_0->slice_ctx) {", "memset(er, 0, sizeof(*er));", "} else", "if (CONFIG_ERROR_RESILIENCE) {", "er->avctx = VAR_0->avctx;", "er->decode_mb = h264_er_decode_mb;", "er->opaque = VAR_0;", "er->quarter_sample = 1;", "er->mb_num = VAR_0->mb_num;", "er->mb_width = VAR_0->mb_width;", "er->mb_height = VAR_0->mb_height;", "er->mb_stride = VAR_0->mb_stride;", "er->b8_stride = VAR_0->mb_width * 2 + 1;", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, er->mb_index2xy,\n(VAR_0->mb_num + 1) * sizeof(int), fail);", "for (VAR_7 = 0; VAR_7 < VAR_0->mb_height; VAR_7++)", "for (VAR_6 = 0; VAR_6 < VAR_0->mb_width; VAR_6++)", "er->mb_index2xy[VAR_6 + VAR_7 * VAR_0->mb_width] = VAR_6 + VAR_7 * VAR_0->mb_stride;", "er->mb_index2xy[VAR_0->mb_height * VAR_0->mb_width] = (VAR_0->mb_height - 1) *\nVAR_0->mb_stride + VAR_0->mb_width;", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, er->error_status_table,\nVAR_2 * sizeof(uint8_t), fail);", "FF_ALLOC_OR_GOTO(VAR_0->avctx, er->er_temp_buffer,\nVAR_0->mb_height * VAR_0->mb_stride, fail);", "FF_ALLOCZ_OR_GOTO(VAR_0->avctx, VAR_1->dc_val_base,\nVAR_5 * sizeof(int16_t), fail);", "er->dc_val[0] = VAR_1->dc_val_base + VAR_0->mb_width * 2 + 2;", "er->dc_val[1] = VAR_1->dc_val_base + VAR_3 + VAR_0->mb_stride + 1;", "er->dc_val[2] = er->dc_val[1] + VAR_4;", "for (VAR_8 = 0; VAR_8 < VAR_5; VAR_8++)", "VAR_1->dc_val_base[VAR_8] = 1024;", "}", "return 0;", "fail:\nreturn AVERROR(ENOMEM);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19, 21, 23, 25, 27, 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 69, 71 ], [ 75 ], [ 77 ], [ 79 ], [ 83, 85 ], [ 89, 91 ], [ 95, 97 ], [ 101, 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 123, 125 ], [ 127 ] ]

[ "static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{", "Visitor *v;", "Error *err = NULL;", "AltStrBool *asb;", "AltStrNum *asn;", "AltNumStr *ans;", "AltStrInt *asi;", "AltIntNum *ain;", "AltNumInt *ani;", "v = visitor_input_test_init(VAR_0, \"42\");", "visit_type_AltStrBool(v, &asb, NULL, &err);", "error_free_or_abort(&err);", "qapi_free_AltStrBool(asb);", "v = visitor_input_test_init(VAR_0, \"42\");", "visit_type_AltStrNum(v, &asn, NULL, &err);", "error_free_or_abort(&err);", "qapi_free_AltStrNum(asn);", "v = visitor_input_test_init(VAR_0, \"42\");", "visit_type_AltNumStr(v, &ans, NULL, &error_abort);", "g_assert_cmpint(ans->type, ==, ALT_NUM_STR_KIND_N);", "g_assert_cmpfloat(ans->u.n, ==, 42);", "qapi_free_AltNumStr(ans);", "v = visitor_input_test_init(VAR_0, \"42\");", "visit_type_AltStrInt(v, &asi, NULL, &error_abort);", "g_assert_cmpint(asi->type, ==, ALT_STR_INT_KIND_I);", "g_assert_cmpint(asi->u.i, ==, 42);", "qapi_free_AltStrInt(asi);", "v = visitor_input_test_init(VAR_0, \"42\");", "visit_type_AltIntNum(v, &ain, NULL, &error_abort);", "g_assert_cmpint(ain->type, ==, ALT_INT_NUM_KIND_I);", "g_assert_cmpint(ain->u.i, ==, 42);", "qapi_free_AltIntNum(ain);", "v = visitor_input_test_init(VAR_0, \"42\");", "visit_type_AltNumInt(v, &ani, NULL, &error_abort);", "g_assert_cmpint(ani->type, ==, ALT_NUM_INT_KIND_I);", "g_assert_cmpint(ani->u.i, ==, 42);", "qapi_free_AltNumInt(ani);", "v = visitor_input_test_init(VAR_0, \"42.5\");", "visit_type_AltStrBool(v, &asb, NULL, &err);", "error_free_or_abort(&err);", "qapi_free_AltStrBool(asb);", "v = visitor_input_test_init(VAR_0, \"42.5\");", "visit_type_AltStrNum(v, &asn, NULL, &error_abort);", "g_assert_cmpint(asn->type, ==, ALT_STR_NUM_KIND_N);", "g_assert_cmpfloat(asn->u.n, ==, 42.5);", "qapi_free_AltStrNum(asn);", "v = visitor_input_test_init(VAR_0, \"42.5\");", "visit_type_AltNumStr(v, &ans, NULL, &error_abort);", "g_assert_cmpint(ans->type, ==, ALT_NUM_STR_KIND_N);", "g_assert_cmpfloat(ans->u.n, ==, 42.5);", "qapi_free_AltNumStr(ans);", "v = visitor_input_test_init(VAR_0, \"42.5\");", "visit_type_AltStrInt(v, &asi, NULL, &err);", "error_free_or_abort(&err);", "qapi_free_AltStrInt(asi);", "v = visitor_input_test_init(VAR_0, \"42.5\");", "visit_type_AltIntNum(v, &ain, NULL, &error_abort);", "g_assert_cmpint(ain->type, ==, ALT_INT_NUM_KIND_N);", "g_assert_cmpfloat(ain->u.n, ==, 42.5);", "qapi_free_AltIntNum(ain);", "v = visitor_input_test_init(VAR_0, \"42.5\");", "visit_type_AltNumInt(v, &ani, NULL, &error_abort);", "g_assert_cmpint(ani->type, ==, ALT_NUM_INT_KIND_N);", "g_assert_cmpfloat(ani->u.n, ==, 42.5);", "qapi_free_AltNumInt(ani);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 43 ], [ 45 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ] ]

[ "static int VAR_0 iscsi_co_writev(BlockDriverState *bs,\nint64_t sector_num, int nb_sectors,\nQEMUIOVector *iov)\n{", "IscsiLun *iscsilun = bs->opaque;", "struct IscsiTask iTask;", "uint64_t lba;", "uint32_t num_sectors;", "uint8_t *data = NULL;", "uint8_t *buf = NULL;", "if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {", "return -EINVAL;", "}", "lba = sector_qemu2lun(sector_num, iscsilun);", "num_sectors = sector_qemu2lun(nb_sectors, iscsilun);", "#if !defined(LIBISCSI_FEATURE_IOVECTOR)\nif (iov->niov == 1) {", "data = iov->iov[0].iov_base;", "} else {", "size_t size = MIN(nb_sectors * BDRV_SECTOR_SIZE, iov->size);", "buf = g_malloc(size);", "qemu_iovec_to_buf(iov, 0, buf, size);", "data = buf;", "}", "#endif\niscsi_co_init_iscsitask(iscsilun, &iTask);", "retry:\nif (iscsilun->use_16_for_rw) {", "iTask.task = iscsi_write16_task(iscsilun->iscsi, iscsilun->lun, lba,\ndata, num_sectors * iscsilun->block_size,\niscsilun->block_size, 0, 0, 0, 0, 0,\niscsi_co_generic_cb, &iTask);", "} else {", "iTask.task = iscsi_write10_task(iscsilun->iscsi, iscsilun->lun, lba,\ndata, num_sectors * iscsilun->block_size,\niscsilun->block_size, 0, 0, 0, 0, 0,\niscsi_co_generic_cb, &iTask);", "}", "if (iTask.task == NULL) {", "g_free(buf);", "return -ENOMEM;", "}", "#if defined(LIBISCSI_FEATURE_IOVECTOR)\nscsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov,\niov->niov);", "#endif\nwhile (!iTask.complete) {", "iscsi_set_events(iscsilun);", "qemu_coroutine_yield();", "}", "if (iTask.task != NULL) {", "scsi_free_scsi_task(iTask.task);", "iTask.task = NULL;", "}", "if (iTask.do_retry) {", "iTask.complete = 0;", "goto retry;", "}", "g_free(buf);", "if (iTask.status != SCSI_STATUS_GOOD) {", "return -EIO;", "}", "iscsi_allocationmap_set(iscsilun, sector_num, nb_sectors);", "return 0;", "}" ]

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

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

[ "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(18);", "if (sel_add_event(VAR_0, VAR_1 + 2)) {", "VAR_3[2] = IPMI_CC_OUT_OF_SPACE;", "return;", "}", "IPMI_ADD_RSP_DATA(VAR_1[2]);", "IPMI_ADD_RSP_DATA(VAR_1[3]);", "}" ]

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

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

[ "static void FUNC_0(BlockDriverState *VAR_0)\n{", "BDRVVmdkState *s = VAR_0->opaque;", "if (s->num_extents == 0) {", "return;", "}", "s->num_extents--;", "s->extents = g_realloc(s->extents, s->num_extents * sizeof(VmdkExtent));", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,\nconst AVFrame *VAR_2, int *VAR_3)\n{", "int VAR_4 = 0;", "SchroEncoderParams *p_schro_params = VAR_0->priv_data;", "SchroEncoder *encoder = p_schro_params->encoder;", "struct FFSchroEncodedFrame *VAR_5 = NULL;", "int VAR_6 = 1;", "SchroBuffer *enc_buf;", "int VAR_7;", "int VAR_8;", "int VAR_9 = 0;", "int VAR_10, VAR_11;", "if (!VAR_2) {", "if (!p_schro_params->eos_signalled) {", "schro_encoder_end_of_stream(encoder);", "p_schro_params->eos_signalled = 1;", "}", "} else {", "SchroFrame *in_frame = libschroedinger_frame_from_data(VAR_0, VAR_2);", "if (!in_frame)\nreturn AVERROR(ENOMEM);", "schro_encoder_push_frame(encoder, in_frame);", "}", "if (p_schro_params->eos_pulled)\nVAR_6 = 0;", "while (VAR_6) {", "int VAR_12;", "SchroStateEnum state;", "state = schro_encoder_wait(encoder);", "switch (state) {", "case SCHRO_STATE_HAVE_BUFFER:\ncase SCHRO_STATE_END_OF_STREAM:\nenc_buf = schro_encoder_pull(encoder, &VAR_7);", "if (enc_buf->length <= 0)\nreturn AVERROR_BUG;", "VAR_8 = enc_buf->data[4];", "if ((VAR_12 = av_reallocp(&p_schro_params->enc_buf,\np_schro_params->enc_buf_size +\nenc_buf->length)) < 0) {", "p_schro_params->enc_buf_size = 0;", "return VAR_12;", "}", "memcpy(p_schro_params->enc_buf + p_schro_params->enc_buf_size,\nenc_buf->data, enc_buf->length);", "p_schro_params->enc_buf_size += enc_buf->length;", "if (state == SCHRO_STATE_END_OF_STREAM) {", "p_schro_params->eos_pulled = 1;", "VAR_6 = 0;", "}", "if (!SCHRO_PARSE_CODE_IS_PICTURE(VAR_8)) {", "schro_buffer_unref(enc_buf);", "break;", "}", "VAR_5 = av_mallocz(sizeof(FFSchroEncodedFrame));", "if (!VAR_5)\nreturn AVERROR(ENOMEM);", "VAR_5->size = p_schro_params->enc_buf_size;", "VAR_5->p_encbuf = p_schro_params->enc_buf;", "if (SCHRO_PARSE_CODE_IS_INTRA(VAR_8) &&\nSCHRO_PARSE_CODE_IS_REFERENCE(VAR_8))\nVAR_5->key_frame = 1;", "VAR_5->frame_num = AV_RB32(enc_buf->data + 13);", "ff_schro_queue_push_back(&p_schro_params->enc_frame_queue,\nVAR_5);", "p_schro_params->enc_buf_size = 0;", "p_schro_params->enc_buf = NULL;", "schro_buffer_unref(enc_buf);", "break;", "case SCHRO_STATE_NEED_FRAME:\nVAR_6 = 0;", "break;", "case SCHRO_STATE_AGAIN:\nbreak;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unknown Schro Encoder state\\n\");", "return -1;", "}", "}", "if (p_schro_params->enc_frame_queue.size == 1 &&\np_schro_params->eos_pulled)\nVAR_9 = 1;", "VAR_5 = ff_schro_queue_pop(&p_schro_params->enc_frame_queue);", "if (!VAR_5)\nreturn 0;", "VAR_10 = VAR_5->size;", "if (VAR_9 && p_schro_params->enc_buf_size > 0)\nVAR_10 += p_schro_params->enc_buf_size;", "if ((VAR_11 = ff_alloc_packet2(VAR_0, VAR_1, VAR_10, 0)) < 0)\ngoto error;", "memcpy(VAR_1->data, VAR_5->p_encbuf, VAR_5->size);", "#if FF_API_CODED_FRAME\nFF_DISABLE_DEPRECATION_WARNINGS\nVAR_0->coded_frame->key_frame = VAR_5->key_frame;", "VAR_0->coded_frame->pts = VAR_5->frame_num;", "FF_ENABLE_DEPRECATION_WARNINGS\n#endif\nVAR_1->pts = VAR_5->frame_num;", "VAR_1->dts = p_schro_params->dts++;", "VAR_4 = VAR_5->size;", "if (VAR_9 && p_schro_params->enc_buf_size > 0) {", "memcpy(VAR_1->data + VAR_4, p_schro_params->enc_buf,\np_schro_params->enc_buf_size);", "VAR_4 += p_schro_params->enc_buf_size;", "av_freep(&p_schro_params->enc_buf);", "p_schro_params->enc_buf_size = 0;", "}", "if (VAR_5->key_frame)\nVAR_1->flags |= AV_PKT_FLAG_KEY;", "*VAR_3 = 1;", "error:\nlibschroedinger_free_frame(VAR_5);", "return VAR_11;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 45 ], [ 47, 49 ], [ 53 ], [ 55 ], [ 59, 61 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77, 79, 81 ], [ 83, 85 ], [ 87 ], [ 99, 101, 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113, 115 ], [ 117 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 145 ], [ 147, 149 ], [ 153 ], [ 155 ], [ 157, 159, 161 ], [ 169 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 183 ], [ 187 ], [ 191, 193 ], [ 195 ], [ 199, 201 ], [ 205, 207 ], [ 209 ], [ 211 ], [ 213 ], [ 221, 223, 225 ], [ 229 ], [ 233, 235 ], [ 239 ], [ 241, 243 ], [ 245, 247 ], [ 251 ], [ 253, 255, 257 ], [ 259 ], [ 261, 263, 271 ], [ 273 ], [ 275 ], [ 283 ], [ 285, 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 299, 301 ], [ 303 ], [ 307, 311 ], [ 313 ], [ 315 ] ]

[ "static int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,\nconst uint8_t *VAR_2, int VAR_3)\n{", "Coroutine *co;", "AioContext *aio_context = bdrv_get_aio_context(VAR_0);", "Qcow2WriteCo data = {", ".VAR_0 = VAR_0,\n.VAR_1 = VAR_1,\n.VAR_2 = VAR_2,\n.VAR_3 = VAR_3,\n.ret = -EINPROGRESS,\n};", "co = qemu_coroutine_create(qcow2_write_co_entry);", "qemu_coroutine_enter(co, &data);", "while (data.ret == -EINPROGRESS) {", "aio_poll(aio_context, true);", "}", "return data.ret;", "}" ]

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

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

[ "static void FUNC_0(HotplugHandler *VAR_0, DeviceState *VAR_1,\nError **VAR_2)\n{", "VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0);", "VirtIOSCSI *s = VIRTIO_SCSI(vdev);", "SCSIDevice *sd = SCSI_DEVICE(VAR_1);", "if (s->ctx && !s->dataplane_disabled) {", "VirtIOSCSIBlkChangeNotifier *insert_notifier, *remove_notifier;", "if (blk_op_is_blocked(sd->conf.blk, BLOCK_OP_TYPE_DATAPLANE, VAR_2)) {", "return;", "}", "blk_op_block_all(sd->conf.blk, s->blocker);", "aio_context_acquire(s->ctx);", "blk_set_aio_context(sd->conf.blk, s->ctx);", "aio_context_release(s->ctx);", "insert_notifier = g_new0(VirtIOSCSIBlkChangeNotifier, 1);", "insert_notifier->n.notify = virtio_scsi_blk_insert_notifier;", "insert_notifier->s = s;", "insert_notifier->sd = sd;", "blk_add_insert_bs_notifier(sd->conf.blk, &insert_notifier->n);", "QTAILQ_INSERT_TAIL(&s->insert_notifiers, insert_notifier, next);", "remove_notifier = g_new0(VirtIOSCSIBlkChangeNotifier, 1);", "remove_notifier->n.notify = virtio_scsi_blk_remove_notifier;", "remove_notifier->s = s;", "remove_notifier->sd = sd;", "blk_add_remove_bs_notifier(sd->conf.blk, &remove_notifier->n);", "QTAILQ_INSERT_TAIL(&s->remove_notifiers, remove_notifier, next);", "}", "if (virtio_vdev_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG)) {", "virtio_scsi_push_event(s, sd,\nVIRTIO_SCSI_T_TRANSPORT_RESET,\nVIRTIO_SCSI_EVT_RESET_RESCAN);", "}", "}" ]

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

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

[ "static CharDriverState *FUNC_0(const char *id,\nChardevReturn *ret)\n{", "CharDriverState *chr;", "PtyCharDriver *s;", "int VAR_0, VAR_1;", "char VAR_2[PATH_MAX];", "VAR_0 = qemu_openpty_raw(&VAR_1, VAR_2);", "if (VAR_0 < 0) {", "return NULL;", "}", "close(VAR_1);", "qemu_set_nonblock(VAR_0);", "chr = qemu_chr_alloc();", "chr->filename = g_strdup_printf(\"pty:%s\", VAR_2);", "ret->pty = g_strdup(VAR_2);", "ret->has_pty = true;", "fprintf(stderr, \"char device redirected to %s (label %s)\\n\",\nVAR_2, id);", "s = g_malloc0(sizeof(PtyCharDriver));", "chr->opaque = s;", "chr->chr_write = pty_chr_write;", "chr->chr_update_read_handler = pty_chr_update_read_handler;", "chr->chr_close = pty_chr_close;", "chr->chr_add_watch = pty_chr_add_watch;", "chr->explicit_be_open = true;", "s->fd = io_channel_from_fd(VAR_0);", "s->timer_tag = 0;", "return chr;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27 ], [ 29 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 45, 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 73 ], [ 75 ] ]

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

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

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

[ "av_cold int FUNC_0(AVCodecContext *avctx)\n{", "H264Context *h = avctx->priv_data;", "int VAR_0;", "int VAR_1;", "h->avctx = avctx;", "h->bit_depth_luma = 8;", "h->chroma_format_idc = 1;", "h->cur_chroma_format_idc = 1;", "ff_h264dsp_init(&h->h264dsp, 8, 1);", "av_assert0(h->sps.bit_depth_chroma == 0);", "ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);", "ff_h264qpel_init(&h->h264qpel, 8);", "ff_h264_pred_init(&h->hpc, h->avctx->codec_id, 8, 1);", "h->dequant_coeff_pps = -1;", "h->current_sps_id = -1;", "ff_videodsp_init(&h->vdsp, 8);", "memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));", "memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));", "h->picture_structure = PICT_FRAME;", "h->slice_context_count = 1;", "h->workaround_bugs = avctx->workaround_bugs;", "h->flags = avctx->flags;", "if (!avctx->has_b_frames)\nh->low_delay = 1;", "avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;", "ff_h264_decode_init_vlc();", "ff_init_cabac_states();", "h->pixel_shift = 0;", "h->cur_bit_depth_luma =\nh->sps.bit_depth_luma = avctx->bits_per_raw_sample = 8;", "h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? H264_MAX_THREADS : 1;", "h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx));", "if (!h->slice_ctx) {", "h->nb_slice_ctx = 0;", "return AVERROR(ENOMEM);", "}", "for (VAR_0 = 0; VAR_0 < h->nb_slice_ctx; VAR_0++)", "h->slice_ctx[VAR_0].h264 = h;", "h->outputed_poc = h->next_outputed_poc = INT_MIN;", "for (VAR_0 = 0; VAR_0 < MAX_DELAYED_PIC_COUNT; VAR_0++)", "h->last_pocs[VAR_0] = INT_MIN;", "h->prev_poc_msb = 1 << 16;", "h->prev_frame_num = -1;", "h->x264_build = -1;", "h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;", "ff_h264_reset_sei(h);", "if (avctx->codec_id == AV_CODEC_ID_H264) {", "if (avctx->ticks_per_frame == 1) {", "if(h->avctx->time_base.den < INT_MAX/2) {", "h->avctx->time_base.den *= 2;", "} else", "h->avctx->time_base.num /= 2;", "}", "avctx->ticks_per_frame = 2;", "}", "if (avctx->extradata_size > 0 && avctx->extradata) {", "VAR_1 = ff_h264_decode_extradata(h, avctx->extradata, avctx->extradata_size);", "if (VAR_1 < 0) {", "ff_h264_free_context(h);", "return VAR_1;", "}", "}", "if (h->sps.bitstream_restriction_flag &&\nh->avctx->has_b_frames < h->sps.num_reorder_frames) {", "h->avctx->has_b_frames = h->sps.num_reorder_frames;", "h->low_delay = 0;", "}", "avctx->internal->allocate_progress = 1;", "ff_h264_flush_change(h);", "if (h->enable_er) {", "av_log(avctx, AV_LOG_WARNING,\n\"Error resilience is enabled. It is unsafe and unsupported and may crash. \"\n\"Use it at your own risk\\n\");", "}", "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, 1, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 19 ], [ 23 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 47 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 71, 73 ], [ 77 ], [ 81 ], [ 85 ], [ 89 ], [ 91, 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 111 ], [ 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169, 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181 ], [ 185 ], [ 189 ], [ 191, 193, 195 ], [ 197 ], [ 201 ], [ 203 ] ]

[ "static int FUNC_0(VmncContext *VAR_0, uint8_t* VAR_1, GetByteContext *VAR_2,\nint VAR_3, int VAR_4, int VAR_5)\n{", "int VAR_6, VAR_7, VAR_8;", "int VAR_9 = 0, VAR_10 = 0, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15;", "const int VAR_16 = VAR_0->bpp2;", "uint8_t *dst2;", "int VAR_17 = 16, VAR_18 = 16;", "for (VAR_7 = 0; VAR_7 < VAR_4; VAR_7 += 16) {", "dst2 = VAR_1;", "VAR_17 = 16;", "if (VAR_7 + 16 > VAR_4)\nVAR_18 = VAR_4 - VAR_7;", "for (VAR_6 = 0; VAR_6 < VAR_3; VAR_6 += 16, dst2 += 16 * VAR_16) {", "if (bytestream2_get_bytes_left(VAR_2) <= 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Premature end of data!\\n\");", "return AVERROR_INVALIDDATA;", "}", "if (VAR_6 + 16 > VAR_3)\nVAR_17 = VAR_3 - VAR_6;", "VAR_13 = bytestream2_get_byte(VAR_2);", "if (VAR_13 & HT_RAW) {", "if (bytestream2_get_bytes_left(VAR_2) < VAR_17 * VAR_18 * VAR_16) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Premature end of data!\\n\");", "return AVERROR_INVALIDDATA;", "}", "paint_raw(dst2, VAR_17, VAR_18, VAR_2, VAR_16, VAR_0->bigendian, VAR_5);", "} else {", "if (VAR_13 & HT_BKG)\nVAR_9 = vmnc_get_pixel(VAR_2, VAR_16, VAR_0->bigendian);", "if (VAR_13 & HT_FG)\nVAR_10 = vmnc_get_pixel(VAR_2, VAR_16, VAR_0->bigendian);", "VAR_11 = 0;", "if (VAR_13 & HT_SUB)\nVAR_11 = bytestream2_get_byte(VAR_2);", "VAR_12 = !!(VAR_13 & HT_CLR);", "paint_rect(dst2, 0, 0, VAR_17, VAR_18, VAR_9, VAR_16, VAR_5);", "if (bytestream2_get_bytes_left(VAR_2) < VAR_11 * (VAR_12 * VAR_16 + 2)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Premature end of data!\\n\");", "return AVERROR_INVALIDDATA;", "}", "for (VAR_8 = 0; VAR_8 < VAR_11; VAR_8++) {", "if (VAR_12)\nVAR_10 = vmnc_get_pixel(VAR_2, VAR_16, VAR_0->bigendian);", "VAR_14 = bytestream2_get_byte(VAR_2);", "VAR_15 = bytestream2_get_byte(VAR_2);", "paint_rect(dst2, VAR_14 >> 4, VAR_14 & 0xF,\n(VAR_15>>4)+1, (VAR_15 & 0xF)+1, VAR_10, VAR_16, VAR_5);", "}", "}", "}", "VAR_1 += VAR_5 * 16;", "}", "return 0;", "}" ]

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

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

[ "int FUNC_0(struct PCIDevice *VAR_0, uint8_t VAR_1,\nunsigned int VAR_2, bool VAR_3, bool VAR_4)\n{", "unsigned int VAR_5;", "uint16_t flags;", "uint8_t cap_size;", "int VAR_6;", "if (!msi_nonbroken) {", "return -ENOTSUP;", "}", "MSI_DEV_PRINTF(VAR_0,\n\"init VAR_1: 0x%\"PRIx8\" vector: %\"PRId8\n\" 64bit %d mask %d\\n\",\nVAR_1, VAR_2, VAR_3, VAR_4);", "assert(!(VAR_2 & (VAR_2 - 1)));", "assert(VAR_2 > 0);", "assert(VAR_2 <= PCI_MSI_VECTORS_MAX);", "VAR_5 = ctz32(VAR_2);", "flags = VAR_5 << ctz32(PCI_MSI_FLAGS_QMASK);", "if (VAR_3) {", "flags |= PCI_MSI_FLAGS_64BIT;", "}", "if (VAR_4) {", "flags |= PCI_MSI_FLAGS_MASKBIT;", "}", "cap_size = msi_cap_sizeof(flags);", "VAR_6 = pci_add_capability(VAR_0, PCI_CAP_ID_MSI, VAR_1, cap_size);", "if (VAR_6 < 0) {", "return VAR_6;", "}", "VAR_0->msi_cap = VAR_6;", "VAR_0->cap_present |= QEMU_PCI_CAP_MSI;", "pci_set_word(VAR_0->config + msi_flags_off(VAR_0), flags);", "pci_set_word(VAR_0->wmask + msi_flags_off(VAR_0),\nPCI_MSI_FLAGS_QSIZE | PCI_MSI_FLAGS_ENABLE);", "pci_set_long(VAR_0->wmask + msi_address_lo_off(VAR_0),\nPCI_MSI_ADDRESS_LO_MASK);", "if (VAR_3) {", "pci_set_long(VAR_0->wmask + msi_address_hi_off(VAR_0), 0xffffffff);", "}", "pci_set_word(VAR_0->wmask + msi_data_off(VAR_0, VAR_3), 0xffff);", "if (VAR_4) {", "pci_set_long(VAR_0->wmask + msi_mask_off(VAR_0, VAR_3),\n0xffffffff >> (PCI_MSI_VECTORS_MAX - VAR_2));", "}", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 25, 27, 29, 31 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 81 ], [ 83, 85 ], [ 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 105, 107 ], [ 109 ], [ 113 ], [ 115 ] ]

[ "static int FUNC_0(AVCodecContext *VAR_0, GetBitContext *VAR_1, Bundle *VAR_2)\n{", "int VAR_3, VAR_4, VAR_5;", "const uint8_t *VAR_6;", "CHECK_READ_VAL(VAR_1, VAR_2, VAR_3);", "VAR_6 = VAR_2->cur_dec + VAR_3;", "if (VAR_6 > VAR_2->data_end) {", "av_log(VAR_0, AV_LOG_ERROR, \"Too many motion values\\n\");", "return -1;", "}", "if (get_bits1(VAR_1)) {", "VAR_5 = get_bits(VAR_1, 4);", "if (VAR_5) {", "VAR_4 = -get_bits1(VAR_1);", "VAR_5 = (VAR_5 ^ VAR_4) - VAR_4;", "}", "memset(VAR_2->cur_dec, VAR_5, VAR_3);", "VAR_2->cur_dec += VAR_3;", "} else {", "do {", "VAR_5 = GET_HUFF(VAR_1, VAR_2->tree);", "if (VAR_5) {", "VAR_4 = -get_bits1(VAR_1);", "VAR_5 = (VAR_5 ^ VAR_4) - VAR_4;", "}", "*VAR_2->cur_dec++ = VAR_5;", "} while (VAR_2->cur_dec < VAR_6);", "}", "return 0;", "}" ]

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

[ "static int FUNC_0(DisasContext *VAR_0, uint32_t VAR_1, int VAR_2, TCGv VAR_3)\n{", "TCGv tmp;", "if (VAR_2) {", "if (IS_USER(VAR_0))\nreturn 1;", "tmp = load_cpu_field(VAR_2);", "tcg_gen_andi_i32(tmp, tmp, ~VAR_1);", "tcg_gen_andi_i32(VAR_3, VAR_3, VAR_1);", "tcg_gen_or_i32(tmp, tmp, VAR_3);", "store_cpu_field(tmp, VAR_2);", "} else {", "gen_set_cpsr(VAR_3, VAR_1);", "}", "dead_tmp(VAR_3);", "gen_lookup_tb(VAR_0);", "return 0;", "}" ]

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

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

[ "int FUNC_0(int VAR_0[4], enum PixelFormat VAR_1, int VAR_2)\n{", "int VAR_3;", "const AVPixFmtDescriptor *VAR_4 = &av_pix_fmt_descriptors[VAR_1];", "int VAR_5 [4];", "int VAR_6[4];", "memset(VAR_0, 0, 4*sizeof(VAR_0[0]));", "if ((unsigned)VAR_1 >= PIX_FMT_NB || VAR_4->flags & PIX_FMT_HWACCEL)\nreturn AVERROR(EINVAL);", "if (VAR_4->flags & PIX_FMT_BITSTREAM) {", "if (VAR_2 > (INT_MAX -7) / (VAR_4->comp[0].step_minus1+1))\nreturn AVERROR(EINVAL);", "VAR_0[0] = (VAR_2 * (VAR_4->comp[0].step_minus1+1) + 7) >> 3;", "return 0;", "}", "av_image_fill_max_pixsteps(VAR_5, VAR_6, VAR_4);", "for (VAR_3 = 0; VAR_3 < 4; VAR_3++) {", "int VAR_7 = (VAR_6[VAR_3] == 1 || VAR_6[VAR_3] == 2) ? VAR_4->log2_chroma_w : 0;", "int VAR_8 = ((VAR_2 + (1 << VAR_7) - 1)) >> VAR_7;", "if (VAR_5[VAR_3] > INT_MAX / VAR_8)\nreturn AVERROR(EINVAL);", "VAR_0[VAR_3] = VAR_5[VAR_3] * VAR_8;", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(NBDClient *VAR_0, uint16_t VAR_1,\nError **VAR_2)\n{", "uint32_t flags;", "bool fixedNewstyle = false;", "bool no_zeroes = false;", "if (nbd_read(VAR_0->ioc, &flags, sizeof(flags), VAR_2) < 0) {", "error_prepend(VAR_2, \"read failed: \");", "return -EIO;", "be32_to_cpus(&flags);", "trace_nbd_negotiate_options_flags(flags);", "if (flags & NBD_FLAG_C_FIXED_NEWSTYLE) {", "fixedNewstyle = true;", "flags &= ~NBD_FLAG_C_FIXED_NEWSTYLE;", "if (flags & NBD_FLAG_C_NO_ZEROES) {", "no_zeroes = true;", "flags &= ~NBD_FLAG_C_NO_ZEROES;", "if (flags != 0) {", "error_setg(VAR_2, \"Unknown VAR_0 flags 0x%\" PRIx32 \" received\", flags);", "while (1) {", "int VAR_3;", "uint32_t option, length;", "uint64_t magic;", "if (nbd_read(VAR_0->ioc, &magic, sizeof(magic), VAR_2) < 0) {", "error_prepend(VAR_2, \"read failed: \");", "magic = be64_to_cpu(magic);", "trace_nbd_negotiate_options_check_magic(magic);", "if (magic != NBD_OPTS_MAGIC) {", "error_setg(VAR_2, \"Bad magic received\");", "if (nbd_read(VAR_0->ioc, &option,\nsizeof(option), VAR_2) < 0) {", "error_prepend(VAR_2, \"read failed: \");", "option = be32_to_cpu(option);", "if (nbd_read(VAR_0->ioc, &length, sizeof(length), VAR_2) < 0) {", "error_prepend(VAR_2, \"read failed: \");", "length = be32_to_cpu(length);", "trace_nbd_negotiate_options_check_option(option,\nnbd_opt_lookup(option));", "if (VAR_0->tlscreds &&\nVAR_0->ioc == (QIOChannel *)VAR_0->sioc) {", "QIOChannel *tioc;", "if (!fixedNewstyle) {", "error_setg(VAR_2, \"Unsupported option 0x%\" PRIx32, option);", "switch (option) {", "case NBD_OPT_STARTTLS:\nif (length) {", "return nbd_reject_length(VAR_0, length, option, true,\nVAR_2);", "tioc = nbd_negotiate_handle_starttls(VAR_0, VAR_2);", "if (!tioc) {", "return -EIO;", "VAR_3 = 0;", "object_unref(OBJECT(VAR_0->ioc));", "VAR_0->ioc = QIO_CHANNEL(tioc);", "break;", "case NBD_OPT_EXPORT_NAME:\nerror_setg(VAR_2, \"Option 0x%x not permitted before TLS\",\noption);", "default:\nif (nbd_drop(VAR_0->ioc, length, VAR_2) < 0) {", "return -EIO;", "VAR_3 = nbd_negotiate_send_rep_err(VAR_0->ioc,\nNBD_REP_ERR_TLS_REQD,\noption, VAR_2,\n\"Option 0x%\" PRIx32\n\"not permitted before TLS\",\noption);", "if (option == NBD_OPT_ABORT) {", "return 1;", "break;", "} else if (fixedNewstyle) {", "switch (option) {", "case NBD_OPT_LIST:\nif (length) {", "VAR_3 = nbd_reject_length(VAR_0, length, option, false,\nVAR_2);", "} else {", "VAR_3 = nbd_negotiate_handle_list(VAR_0, VAR_2);", "break;", "case NBD_OPT_ABORT:\nnbd_negotiate_send_rep(VAR_0->ioc, NBD_REP_ACK, option, NULL);", "return 1;", "case NBD_OPT_EXPORT_NAME:\nreturn nbd_negotiate_handle_export_name(VAR_0, length,\nVAR_1, no_zeroes,\nVAR_2);", "case NBD_OPT_INFO:\ncase NBD_OPT_GO:\nVAR_3 = nbd_negotiate_handle_info(VAR_0, length, option,\nVAR_1, VAR_2);", "if (VAR_3 == 1) {", "assert(option == NBD_OPT_GO);", "return 0;", "break;", "case NBD_OPT_STARTTLS:\nif (length) {", "VAR_3 = nbd_reject_length(VAR_0, length, option, false,\nVAR_2);", "} else if (VAR_0->tlscreds) {", "VAR_3 = nbd_negotiate_send_rep_err(VAR_0->ioc,\nNBD_REP_ERR_INVALID,\noption, VAR_2,\n\"TLS already enabled\");", "} else {", "VAR_3 = nbd_negotiate_send_rep_err(VAR_0->ioc,\nNBD_REP_ERR_POLICY,\noption, VAR_2,\n\"TLS not configured\");", "break;", "case NBD_OPT_STRUCTURED_REPLY:\nif (length) {", "VAR_3 = nbd_reject_length(VAR_0, length, option, false,\nVAR_2);", "} else if (VAR_0->structured_reply) {", "VAR_3 = nbd_negotiate_send_rep_err(\nVAR_0->ioc, NBD_REP_ERR_INVALID, option, VAR_2,\n\"structured reply already negotiated\");", "} else {", "VAR_3 = nbd_negotiate_send_rep(VAR_0->ioc, NBD_REP_ACK,\noption, VAR_2);", "VAR_0->structured_reply = true;", "VAR_1 |= NBD_FLAG_SEND_DF;", "break;", "default:\nif (nbd_drop(VAR_0->ioc, length, VAR_2) < 0) {", "return -EIO;", "VAR_3 = nbd_negotiate_send_rep_err(VAR_0->ioc,\nNBD_REP_ERR_UNSUP,\noption, VAR_2,\n\"Unsupported option 0x%\"\nPRIx32 \" (%s)\", option,\nnbd_opt_lookup(option));", "break;", "} else {", "switch (option) {", "case NBD_OPT_EXPORT_NAME:\nreturn nbd_negotiate_handle_export_name(VAR_0, length,\nVAR_1, no_zeroes,\nVAR_2);", "default:\nerror_setg(VAR_2, \"Unsupported option 0x%\" PRIx32 \" (%s)\",\noption, nbd_opt_lookup(option));", "if (VAR_3 < 0) {", "return VAR_3;" ]

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

[ [ 1, 2, 3 ], [ 4 ], [ 5 ], [ 6 ], [ 19 ], [ 20 ], [ 21 ], [ 22 ], [ 23 ], [ 24 ], [ 25 ], [ 26 ], [ 27 ], [ 28 ], [ 29 ], [ 30 ], [ 31 ], [ 32 ], [ 33 ], [ 34 ], [ 35 ], [ 36 ], [ 37 ], [ 38 ], [ 39 ], [ 40 ], [ 41 ], [ 42, 43 ], [ 44 ], [ 45 ], [ 46 ], [ 47 ], [ 48 ], [ 49, 50 ], [ 51, 52 ], [ 53 ], [ 54 ], [ 55 ], [ 56 ], [ 57, 58 ], [ 61, 62 ], [ 63 ], [ 64 ], [ 65 ], [ 66 ], [ 67 ], [ 68 ], [ 69 ], [ 70, 72, 73 ], [ 74, 75 ], [ 76 ], [ 77, 78, 79, 80, 81, 82 ], [ 86 ], [ 87 ], [ 88 ], [ 89 ], [ 90 ], [ 91, 92 ], [ 93, 94 ], [ 95 ], [ 96 ], [ 97 ], [ 98, 102 ], [ 103 ], [ 104, 105, 106, 107 ], [ 108, 109, 110, 111 ], [ 112 ], [ 113 ], [ 114 ], [ 115 ], [ 116, 117 ], [ 118, 119 ], [ 120 ], [ 121, 122, 123, 124 ], [ 125 ], [ 126, 127, 128, 129 ], [ 130 ], [ 131, 132 ], [ 133, 134 ], [ 135 ], [ 136, 137, 138 ], [ 139 ], [ 140, 141 ], [ 142 ], [ 143 ], [ 144 ], [ 145, 146 ], [ 147 ], [ 148, 149, 150, 151, 152, 153 ], [ 154 ], [ 155 ], [ 160 ], [ 161, 162, 163, 164 ], [ 165, 166, 167 ], [ 168 ], [ 169 ] ]

[ "static int FUNC_0(VirtioCcwDevice *VAR_0)\n{", "VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(VAR_0);", "DeviceState *vdev = DEVICE(&dev->vdev);", "virtio_blk_set_conf(vdev, &(dev->blk));", "qdev_set_parent_bus(vdev, BUS(&VAR_0->bus));", "if (qdev_init(vdev) < 0) {", "return -1;", "}", "return virtio_ccw_device_init(VAR_0, VIRTIO_DEVICE(vdev));", "}" ]

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

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

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "SchroDecoderParams *p_schro_params = avctx->priv_data;", "schro_decoder_free(p_schro_params->decoder);", "av_freep(&p_schro_params->format);", "ff_schro_queue_free(&p_schro_params->dec_frame_queue,\nlibschroedinger_decode_frame_free);", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 17, 19 ], [ 23 ], [ 25 ] ]

[ "static void FUNC_0(char *VAR_0, OutputStream *VAR_1,\nAVCodecContext *VAR_2)\n{", "char *VAR_3;", "int VAR_4 = 1, VAR_5;", "int64_t t;", "for (VAR_3 = VAR_0; *VAR_3; VAR_3++)", "if (*VAR_3 == ',')\nVAR_4++;", "VAR_1->forced_kf_count = VAR_4;", "VAR_1->forced_kf_pts = av_malloc(sizeof(*VAR_1->forced_kf_pts) * VAR_4);", "if (!VAR_1->forced_kf_pts) {", "av_log(NULL, AV_LOG_FATAL, \"Could not allocate forced key frames array.\\VAR_4\");", "exit(1);", "}", "VAR_3 = VAR_0;", "for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {", "char *VAR_6 = strchr(VAR_3, ',');", "if (VAR_6)\n*VAR_6++ = 0;", "t = parse_time_or_die(\"force_key_frames\", VAR_3, 1);", "VAR_1->forced_kf_pts[VAR_5] = av_rescale_q(t, AV_TIME_BASE_Q, VAR_2->time_base);", "VAR_3 = VAR_6;", "}", "}" ]

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

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

[ "void FUNC_0(VP8Context *VAR_0, VP8Macroblock *VAR_1, int VAR_2, int VAR_3)\n{", "VP8Macroblock *mb_edge[3] = { VAR_1 + 2 ,", "VAR_1 - 1 ,\nVAR_1 + 1 };", "enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };", "enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };", "int VAR_4 = CNT_ZERO;", "int VAR_5 = VAR_0->sign_bias[VAR_1->ref_frame];", "int8_t *sign_bias = VAR_0->sign_bias;", "VP56mv near_mv[4];", "uint8_t cnt[4] = { 0 };", "VP56RangeCoder *c = &VAR_0->c;", "AV_ZERO32(&near_mv[0]);", "AV_ZERO32(&near_mv[1]);", "#define MV_EDGE_CHECK(n)\\\n{\\", "VP8Macroblock *edge = mb_edge[n];\\", "int VAR_6 = edge->ref_frame;\\", "if (VAR_6 != VP56_FRAME_CURRENT) {\\", "uint32_t mv = AV_RN32A(&edge->mv);\\", "if (mv) {\\", "if (VAR_5 != sign_bias[VAR_6]) {\\", "\\\nmv = ~mv;\\", "mv = ((mv&0x7fff7fff) + 0x00010001) ^ (mv&0x80008000);\\", "}\\", "if (!n || mv != AV_RN32A(&near_mv[VAR_4]))\\\nAV_WN32A(&near_mv[++VAR_4], mv);\\", "cnt[VAR_4] += 1 + (n != 2);\\", "} else\\", "cnt[CNT_ZERO] += 1 + (n != 2);\\", "}\\", "}", "MV_EDGE_CHECK(0)\nMV_EDGE_CHECK(1)\nMV_EDGE_CHECK(2)\nVAR_1->partitioning = VP8_SPLITMVMODE_NONE;", "if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_ZERO]][0])) {", "VAR_1->mode = VP8_MVMODE_MV;", "if (cnt[CNT_SPLITMV] && AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) == AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))\ncnt[CNT_NEAREST] += 1;", "if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {", "FFSWAP(uint8_t, cnt[CNT_NEAREST], cnt[CNT_NEAR]);", "FFSWAP( VP56mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);", "}", "if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAREST]][1])) {", "if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAR]][2])) {", "clamp_mv(VAR_0, &VAR_1->mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);", "cnt[CNT_SPLITMV] = ((mb_edge[VP8_EDGE_LEFT]->mode == VP8_MVMODE_SPLIT) +\n(mb_edge[VP8_EDGE_TOP]->mode == VP8_MVMODE_SPLIT)) * 2 +\n(mb_edge[VP8_EDGE_TOPLEFT]->mode == VP8_MVMODE_SPLIT);", "if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_SPLITMV]][3])) {", "VAR_1->mode = VP8_MVMODE_SPLIT;", "VAR_1->mv = VAR_1->bmv[decode_splitmvs(VAR_0, c, VAR_1) - 1];", "} else {", "VAR_1->mv.y += read_mv_component(c, VAR_0->prob->mvc[0]);", "VAR_1->mv.x += read_mv_component(c, VAR_0->prob->mvc[1]);", "VAR_1->bmv[0] = VAR_1->mv;", "}", "} else {", "clamp_mv(VAR_0, &VAR_1->mv, &near_mv[CNT_NEAR]);", "VAR_1->bmv[0] = VAR_1->mv;", "}", "} else {", "clamp_mv(VAR_0, &VAR_1->mv, &near_mv[CNT_NEAREST]);", "VAR_1->bmv[0] = VAR_1->mv;", "}", "} else {", "VAR_1->mode = VP8_MVMODE_ZERO;", "AV_ZERO32(&VAR_1->mv);", "VAR_1->bmv[0] = VAR_1->mv;", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 38, 40 ], [ 42 ], [ 44 ], [ 46 ], [ 48 ], [ 50 ], [ 52 ], [ 54, 56 ], [ 58 ], [ 60 ], [ 62, 64 ], [ 66 ], [ 68 ], [ 70 ], [ 72 ], [ 74 ], [ 78, 80, 82, 86 ], [ 88 ], [ 90 ], [ 96, 98 ], [ 104 ], [ 106 ], [ 108 ], [ 110 ], [ 114 ], [ 116 ], [ 122 ], [ 124, 126, 128 ], [ 132 ], [ 134 ], [ 136 ], [ 138 ], [ 140 ], [ 142 ], [ 144 ], [ 146 ], [ 148 ], [ 150 ], [ 152 ], [ 154 ], [ 156 ], [ 158 ], [ 160 ], [ 162 ], [ 164 ], [ 166 ], [ 168 ], [ 170 ], [ 172 ], [ 174 ] ]

[ "static int FUNC_0(InputStream *VAR_0, OutputStream *VAR_1)\n{", "OutputFile *of = output_files[VAR_1->file_index];", "int VAR_2 = input_files[VAR_0->file_index]->VAR_2 + VAR_0->st->index;", "if (VAR_1->source_index != VAR_2)\nreturn 0;", "if (of->start_time && VAR_0->pts < of->start_time)\nreturn 0;", "if (of->recording_time != INT64_MAX &&\nav_compare_ts(VAR_0->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,\n(AVRational){ 1, 1000000 }) >= 0) {", "VAR_1->is_past_recording_time = 1;", "return 0;", "}", "return 1;", "}" ]

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

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

[ "CPUState *FUNC_0(void)\n{", "if (!cur_mon->mon_cpu) {", "monitor_set_cpu(0);", "}", "cpu_synchronize_state(cur_mon->mon_cpu);", "return cur_mon->mon_cpu;", "}" ]

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

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

[ "static int FUNC_0(VC1Context *VAR_0)\n{", "MpegEncContext *s = &VAR_0->s;", "GetBitContext *gb = &s->gb;", "int VAR_1;", "int VAR_2 = s->mb_x + s->mb_y * s->mb_stride;", "int VAR_3 = 0;", "int VAR_4, VAR_5;", "int VAR_6 = VAR_0->ttfrm;", "int VAR_7 = 1;", "int VAR_8, VAR_9;", "int VAR_10;", "int VAR_11 = 1;", "int VAR_12, VAR_13;", "int VAR_14, VAR_15 = 0, VAR_16 = 0;", "int VAR_17 = 0, VAR_18, VAR_19 = 0;", "int VAR_20 = 0, VAR_21;", "int VAR_22, VAR_23;", "VAR_5 = VAR_0->pq;", "if (VAR_0->skip_is_raw)\nVAR_14 = get_bits1(gb);", "else\nVAR_14 = VAR_0->s.mbskip_table[VAR_2];", "if (!VAR_14) {", "if (VAR_0->fourmvswitch)\nVAR_20 = get_vlc2(gb, VAR_0->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2);", "else\nVAR_20 = get_vlc2(gb, VAR_0->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);", "switch (ff_vc1_mbmode_intfrp[VAR_0->fourmvswitch][VAR_20][0]) {", "case MV_PMODE_INTFR_4MV:\nVAR_15 = 1;", "VAR_0->blk_mv_type[s->block_index[0]] = 0;", "VAR_0->blk_mv_type[s->block_index[1]] = 0;", "VAR_0->blk_mv_type[s->block_index[2]] = 0;", "VAR_0->blk_mv_type[s->block_index[3]] = 0;", "break;", "case MV_PMODE_INTFR_4MV_FIELD:\nVAR_15 = 1;", "VAR_0->blk_mv_type[s->block_index[0]] = 1;", "VAR_0->blk_mv_type[s->block_index[1]] = 1;", "VAR_0->blk_mv_type[s->block_index[2]] = 1;", "VAR_0->blk_mv_type[s->block_index[3]] = 1;", "break;", "case MV_PMODE_INTFR_2MV_FIELD:\nVAR_16 = 1;", "VAR_0->blk_mv_type[s->block_index[0]] = 1;", "VAR_0->blk_mv_type[s->block_index[1]] = 1;", "VAR_0->blk_mv_type[s->block_index[2]] = 1;", "VAR_0->blk_mv_type[s->block_index[3]] = 1;", "break;", "case MV_PMODE_INTFR_1MV:\nVAR_0->blk_mv_type[s->block_index[0]] = 0;", "VAR_0->blk_mv_type[s->block_index[1]] = 0;", "VAR_0->blk_mv_type[s->block_index[2]] = 0;", "VAR_0->blk_mv_type[s->block_index[3]] = 0;", "break;", "}", "if (ff_vc1_mbmode_intfrp[VAR_0->fourmvswitch][VAR_20][0] == MV_PMODE_INTFR_INTRA) {", "s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;", "s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;", "s->current_picture.f.mb_type[VAR_2] = MB_TYPE_INTRA;", "s->mb_intra = VAR_0->is_intra[s->mb_x] = 1;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++)", "VAR_0->mb_type[0][s->block_index[VAR_1]] = 1;", "VAR_23 = VAR_0->fieldtx_plane[VAR_2] = get_bits1(gb);", "VAR_7 = get_bits1(gb);", "if (VAR_7)\nVAR_3 = 1 + get_vlc2(&VAR_0->s.gb, VAR_0->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);", "VAR_0->s.ac_pred = VAR_0->acpred_plane[VAR_2] = get_bits1(gb);", "GET_MQUANT();", "s->current_picture.f.qscale_table[VAR_2] = VAR_5;", "s->y_dc_scale = s->y_dc_scale_table[VAR_5];", "s->c_dc_scale = s->c_dc_scale_table[VAR_5];", "VAR_12 = 0;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {", "s->dc_val[0][s->block_index[VAR_1]] = 0;", "VAR_12 += VAR_1 >> 2;", "VAR_10 = ((VAR_3 >> (5 - VAR_1)) & 1);", "VAR_0->mb_type[0][s->block_index[VAR_1]] = s->mb_intra;", "VAR_0->a_avail = VAR_0->c_avail = 0;", "if (VAR_1 == 2 || VAR_1 == 3 || !s->first_slice_line)\nVAR_0->a_avail = VAR_0->mb_type[0][s->block_index[VAR_1] - s->block_wrap[VAR_1]];", "if (VAR_1 == 1 || VAR_1 == 3 || s->mb_x)\nVAR_0->c_avail = VAR_0->mb_type[0][s->block_index[VAR_1] - 1];", "vc1_decode_intra_block(VAR_0, s->block[VAR_1], VAR_1, VAR_10, VAR_5,\n(VAR_1 & 4) ? VAR_0->codingset2 : VAR_0->codingset);", "if ((VAR_1>3) && (s->flags & CODEC_FLAG_GRAY)) continue;", "VAR_0->vc1dsp.vc1_inv_trans_8x8(s->block[VAR_1]);", "if (VAR_1 < 4) {", "VAR_22 = s->linesize << VAR_23;", "VAR_13 = (VAR_23) ? ((VAR_1 & 1) * 8) + ((VAR_1 & 2) >> 1) * s->linesize : (VAR_1 & 1) * 8 + 4 * (VAR_1 & 2) * s->linesize;", "} else {", "VAR_22 = s->uvlinesize;", "VAR_13 = 0;", "}", "s->dsp.put_signed_pixels_clamped(s->block[VAR_1], s->dest[VAR_12] + VAR_13, VAR_22);", "}", "} else {", "VAR_7 = ff_vc1_mbmode_intfrp[VAR_0->fourmvswitch][VAR_20][3];", "if (VAR_7)\nVAR_3 = 1 + get_vlc2(&VAR_0->s.gb, VAR_0->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);", "if (ff_vc1_mbmode_intfrp[VAR_0->fourmvswitch][VAR_20][0] == MV_PMODE_INTFR_2MV_FIELD) {", "VAR_0->twomvbp = get_vlc2(gb, VAR_0->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);", "} else {", "if ((ff_vc1_mbmode_intfrp[VAR_0->fourmvswitch][VAR_20][0] == MV_PMODE_INTFR_4MV)\n|| (ff_vc1_mbmode_intfrp[VAR_0->fourmvswitch][VAR_20][0] == MV_PMODE_INTFR_4MV_FIELD)) {", "VAR_0->fourmvbp = get_vlc2(gb, VAR_0->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);", "}", "}", "s->mb_intra = VAR_0->is_intra[s->mb_x] = 0;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++)", "VAR_0->mb_type[0][s->block_index[VAR_1]] = 0;", "VAR_23 = VAR_0->fieldtx_plane[VAR_2] = ff_vc1_mbmode_intfrp[VAR_0->fourmvswitch][VAR_20][1];", "VAR_12 = 0;", "if (VAR_15) {", "VAR_21 = VAR_0->fourmvbp;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {", "if (VAR_1 < 4) {", "VAR_10 = ((VAR_21 >> (3 - VAR_1)) & 1);", "if (VAR_10) {", "get_mvdata_interlaced(VAR_0, &VAR_8, &VAR_9, 0);", "}", "vc1_pred_mv_intfr(VAR_0, VAR_1, VAR_8, VAR_9, 0, VAR_0->range_x, VAR_0->range_y, VAR_0->mb_type[0]);", "vc1_mc_4mv_luma(VAR_0, VAR_1, 0);", "} else if (VAR_1 == 4) {", "vc1_mc_4mv_chroma4(VAR_0);", "}", "}", "} else if (VAR_16) {", "VAR_21 = VAR_0->twomvbp;", "if (VAR_21 & 2) {", "get_mvdata_interlaced(VAR_0, &VAR_8, &VAR_9, 0);", "}", "vc1_pred_mv_intfr(VAR_0, 0, VAR_8, VAR_9, 2, VAR_0->range_x, VAR_0->range_y, VAR_0->mb_type[0]);", "vc1_mc_4mv_luma(VAR_0, 0, 0);", "vc1_mc_4mv_luma(VAR_0, 1, 0);", "if (VAR_21 & 1) {", "get_mvdata_interlaced(VAR_0, &VAR_8, &VAR_9, 0);", "}", "vc1_pred_mv_intfr(VAR_0, 2, VAR_8, VAR_9, 2, VAR_0->range_x, VAR_0->range_y, VAR_0->mb_type[0]);", "vc1_mc_4mv_luma(VAR_0, 2, 0);", "vc1_mc_4mv_luma(VAR_0, 3, 0);", "vc1_mc_4mv_chroma4(VAR_0);", "} else {", "VAR_21 = ff_vc1_mbmode_intfrp[VAR_0->fourmvswitch][VAR_20][2];", "if (VAR_21) {", "get_mvdata_interlaced(VAR_0, &VAR_8, &VAR_9, 0);", "}", "vc1_pred_mv_intfr(VAR_0, 0, VAR_8, VAR_9, 1, VAR_0->range_x, VAR_0->range_y, VAR_0->mb_type[0]);", "vc1_mc_1mv(VAR_0, 0);", "}", "if (VAR_3)\nGET_MQUANT();", "s->current_picture.f.qscale_table[VAR_2] = VAR_5;", "if (!VAR_0->ttmbf && VAR_3)\nVAR_6 = get_vlc2(gb, ff_vc1_ttmb_vlc[VAR_0->tt_index].table, VC1_TTMB_VLC_BITS, 2);", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {", "s->dc_val[0][s->block_index[VAR_1]] = 0;", "VAR_12 += VAR_1 >> 2;", "VAR_10 = ((VAR_3 >> (5 - VAR_1)) & 1);", "if (!VAR_23)\nVAR_13 = (VAR_1 & 4) ? 0 : ((VAR_1 & 1) * 8 + (VAR_1 & 2) * 4 * s->linesize);", "else\nVAR_13 = (VAR_1 & 4) ? 0 : ((VAR_1 & 1) * 8 + ((VAR_1 > 1) * s->linesize));", "if (VAR_10) {", "VAR_18 = vc1_decode_p_block(VAR_0, s->block[VAR_1], VAR_1, VAR_5, VAR_6,\nVAR_11, s->dest[VAR_12] + VAR_13,\n(VAR_1 & 4) ? s->uvlinesize : (s->linesize << VAR_23),\n(VAR_1 & 4) && (s->flags & CODEC_FLAG_GRAY), &VAR_19);", "VAR_17 |= VAR_18 << (VAR_1 << 2);", "if (!VAR_0->ttmbf && VAR_6 < 8)\nVAR_6 = -1;", "VAR_11 = 0;", "}", "}", "}", "} else {", "s->mb_intra = VAR_0->is_intra[s->mb_x] = 0;", "for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {", "VAR_0->mb_type[0][s->block_index[VAR_1]] = 0;", "s->dc_val[0][s->block_index[VAR_1]] = 0;", "}", "s->current_picture.f.mb_type[VAR_2] = MB_TYPE_SKIP;", "s->current_picture.f.qscale_table[VAR_2] = 0;", "VAR_0->blk_mv_type[s->block_index[0]] = 0;", "VAR_0->blk_mv_type[s->block_index[1]] = 0;", "VAR_0->blk_mv_type[s->block_index[2]] = 0;", "VAR_0->blk_mv_type[s->block_index[3]] = 0;", "vc1_pred_mv_intfr(VAR_0, 0, 0, 0, 1, VAR_0->range_x, VAR_0->range_y, VAR_0->mb_type[0]);", "vc1_mc_1mv(VAR_0, 0);", "}", "if (s->mb_x == s->mb_width - 1)\nmemmove(VAR_0->is_intra_base, VAR_0->is_intra, sizeof(VAR_0->is_intra_base[0])*s->mb_stride);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 41 ], [ 45, 47 ], [ 49, 51 ], [ 53 ], [ 55, 57 ], [ 59, 61 ], [ 63 ], [ 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 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171, 173 ], [ 175, 177 ], [ 181, 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 207 ], [ 211 ], [ 213 ], [ 215, 217 ], [ 219 ], [ 221 ], [ 223 ], [ 225, 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 256 ], [ 258 ], [ 260 ], [ 262 ], [ 264 ], [ 266 ], [ 268 ], [ 270 ], [ 272 ], [ 274 ], [ 276 ], [ 278 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 294 ], [ 296 ], [ 298 ], [ 300 ], [ 302 ], [ 304 ], [ 306 ], [ 308 ], [ 310 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325, 327 ], [ 329 ], [ 331, 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343, 345 ], [ 347, 349 ], [ 351 ], [ 353, 355, 357, 359 ], [ 361 ], [ 363, 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 383 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405, 407 ], [ 409 ], [ 411 ] ]

[ "ssize_t FUNC_0(NetClientState *nc, const uint8_t *buf, size_t size_)\n{", "NE2000State *s = qemu_get_nic_opaque(nc);", "int VAR_0 = size_;", "uint8_t *p;", "unsigned int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6;", "uint8_t buf1[60];", "static const uint8_t VAR_7[6] =\n{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };", "#if defined(DEBUG_NE2000)\nprintf(\"NE2000: received VAR_4=%d\\n\", VAR_0);", "#endif\nif (s->cmd & E8390_STOP || ne2000_buffer_full(s))\nreturn -1;", "if (s->rxcr & 0x10) {", "} else {", "if (!memcmp(buf, VAR_7, 6)) {", "if (!(s->rxcr & 0x04))\nreturn VAR_0;", "} else if (buf[0] & 0x01) {", "if (!(s->rxcr & 0x08))\nreturn VAR_0;", "VAR_6 = compute_mcast_idx(buf);", "if (!(s->mult[VAR_6 >> 3] & (1 << (VAR_6 & 7))))\nreturn VAR_0;", "} else if (s->mem[0] == buf[0] &&", "s->mem[2] == buf[1] &&\ns->mem[4] == buf[2] &&\ns->mem[6] == buf[3] &&\ns->mem[8] == buf[4] &&\ns->mem[10] == buf[5]) {", "} else {", "return VAR_0;", "}", "}", "if (VAR_0 < MIN_BUF_SIZE) {", "memcpy(buf1, buf, VAR_0);", "memset(buf1 + VAR_0, 0, MIN_BUF_SIZE - VAR_0);", "buf = buf1;", "VAR_0 = MIN_BUF_SIZE;", "}", "VAR_5 = s->curpag << 8;", "if (VAR_5 >= NE2000_PMEM_END) {", "VAR_5 = s->start;", "}", "VAR_1 = VAR_0 + 4;", "VAR_2 = VAR_5 + ((VAR_1 + 4 + 255) & ~0xff);", "if (VAR_2 >= s->stop)\nVAR_2 -= (s->stop - s->start);", "p = s->mem + VAR_5;", "s->rsr = ENRSR_RXOK;", "if (buf[0] & 0x01)\ns->rsr |= ENRSR_PHY;", "p[0] = s->rsr;", "p[1] = VAR_2 >> 8;", "p[2] = VAR_1;", "p[3] = VAR_1 >> 8;", "VAR_5 += 4;", "while (VAR_0 > 0) {", "if (VAR_5 <= s->stop)\nVAR_3 = s->stop - VAR_5;", "else\nVAR_3 = 0;", "VAR_4 = VAR_0;", "if (VAR_4 > VAR_3)\nVAR_4 = VAR_3;", "memcpy(s->mem + VAR_5, buf, VAR_4);", "buf += VAR_4;", "VAR_5 += VAR_4;", "if (VAR_5 == s->stop)\nVAR_5 = s->start;", "VAR_0 -= VAR_4;", "}", "s->curpag = VAR_2 >> 8;", "s->isr |= ENISR_RX;", "ne2000_update_irq(s);", "return size_;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15, 17 ], [ 21, 23 ], [ 25, 29, 31 ], [ 37 ], [ 41 ], [ 43 ], [ 47, 49 ], [ 51 ], [ 55, 57 ], [ 59 ], [ 61, 63 ], [ 65 ], [ 67, 69, 71, 73, 75 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 117 ], [ 121 ], [ 123, 125 ], [ 129 ], [ 131 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 153 ], [ 155, 157 ], [ 159, 161 ], [ 163 ], [ 165, 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177 ], [ 179 ], [ 181 ], [ 183 ], [ 189 ], [ 191 ], [ 195 ], [ 197 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx)\n{", "HYuvContext *s = avctx->priv_data;", "int VAR_0, VAR_1;", "if ((VAR_1 = ff_huffyuv_alloc_temp(s)) < 0) {", "ff_huffyuv_common_end(s);", "return VAR_1;", "}", "for (VAR_0 = 0; VAR_0 < 8; VAR_0++)", "s->vlc[VAR_0].table = NULL;", "if (s->version >= 2) {", "if ((VAR_1 = read_huffman_tables(s, avctx->extradata + 4,\navctx->extradata_size)) < 0)\nreturn VAR_1;", "} else {", "if ((VAR_1 = read_old_huffman_tables(s)) < 0)\nreturn VAR_1;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(Object *VAR_0, Visitor *VAR_1, const char *VAR_2,\nvoid *VAR_3, Error **VAR_4)\n{", "DeviceState *dev = DEVICE(VAR_0);", "Property *prop = VAR_3;", "PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);", "char VAR_5[] = \"xxxx:xx:xx.x\";", "char *VAR_6 = VAR_5;", "int VAR_7 = 0;", "VAR_7 = snprintf(VAR_5, sizeof(VAR_5), \"%04x:%02x:%02x.%d\",\naddr->domain, addr->bus, addr->slot, addr->function);", "assert(VAR_7 == sizeof(VAR_5) - 1);", "visit_type_str(VAR_1, VAR_2, &VAR_6, VAR_4);", "}" ]

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

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

[ "static int FUNC_0(AVProbeData *VAR_0)\n{", "if (VAR_0->buf_size < 18)\nreturn 0;", "if (AV_RL32(&VAR_0->buf[0]) != 0x55AA0000)\nreturn 0;", "if (AV_RL32(&VAR_0->buf[12]) != 22050 || VAR_0->buf[16] != 16 || VAR_0->buf[17] != 0)\nreturn 0;", "return AVPROBE_SCORE_MAX;", "}" ]

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

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

[ "static int FUNC_0(AVStream *VAR_0, AVPacket *VAR_1, AVDictionary **VAR_2)\n{", "AVCodec *codec;", "int VAR_3 = 1, VAR_4 = 0;", "AVFrame picture;", "AVPacket pkt = *VAR_1;", "if(!VAR_0->codec->codec){", "AVDictionary *thread_opt = NULL;", "codec = avcodec_find_decoder(VAR_0->codec->codec_id);", "if (!codec)\nreturn -1;", "av_dict_set(VAR_2 ? VAR_2 : &thread_opt, \"threads\", \"1\", 0);", "VAR_4 = avcodec_open2(VAR_0->codec, codec, VAR_2 ? VAR_2 : &thread_opt);", "if (!VAR_2)\nav_dict_free(&thread_opt);", "if (VAR_4 < 0)\nreturn VAR_4;", "}", "while ((pkt.size > 0 || (!pkt.data && VAR_3)) &&\nVAR_4 >= 0 &&\n(!has_codec_parameters(VAR_0->codec) ||\n!has_decode_delay_been_guessed(VAR_0) ||\n(!VAR_0->codec_info_nb_frames && VAR_0->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {", "VAR_3 = 0;", "avcodec_get_frame_defaults(&picture);", "switch(VAR_0->codec->codec_type) {", "case AVMEDIA_TYPE_VIDEO:\nVAR_4 = avcodec_decode_video2(VAR_0->codec, &picture,\n&VAR_3, &pkt);", "break;", "case AVMEDIA_TYPE_AUDIO:\nVAR_4 = avcodec_decode_audio4(VAR_0->codec, &picture, &VAR_3, &pkt);", "break;", "default:\nbreak;", "}", "if (VAR_4 >= 0) {", "if (VAR_3)\nVAR_0->info->nb_decoded_frames++;", "pkt.data += VAR_4;", "pkt.size -= VAR_4;", "VAR_4 = VAR_3;", "}", "}", "return VAR_4;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 21 ], [ 23, 25 ], [ 33 ], [ 35 ], [ 37, 39 ], [ 41, 43 ], [ 45 ], [ 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 ] ]

[ "static void FUNC_0(AVCodecContext *VAR_0)\n{", "int VAR_1 = (VAR_0->codec->capabilities & CODEC_CAP_FRAME_THREADS)\n&& !(VAR_0->flags & CODEC_FLAG_TRUNCATED)\n&& !(VAR_0->flags & CODEC_FLAG_LOW_DELAY)\n&& !(VAR_0->flags2 & CODEC_FLAG2_CHUNKS);", "if (VAR_0->thread_count == 1) {", "VAR_0->active_thread_type = 0;", "} else if (VAR_1 && (VAR_0->thread_type & FF_THREAD_FRAME)) {", "VAR_0->active_thread_type = FF_THREAD_FRAME;", "} else {", "VAR_0->active_thread_type = FF_THREAD_SLICE;", "}", "}" ]

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

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

[ "static int FUNC_0(const uint8_t *VAR_0, const int VAR_1,\nuint8_t *VAR_2, const int VAR_3)\n{", "int VAR_4, VAR_5;", "const uint8_t *VAR_6;", "int VAR_7, VAR_8;", "int VAR_9, VAR_10;", "const uint8_t *VAR_11 = VAR_2 + VAR_3;", "const uint8_t *VAR_12 = VAR_0 + VAR_1;", "VAR_4 = *VAR_0++;", "VAR_5 = *VAR_0++;", "VAR_6 = VAR_0 - VAR_5 * 2 - 2;", "VAR_9 = VAR_5 + VAR_4;", "VAR_0 += VAR_4 * 2;", "VAR_10 = VAR_9;", "VAR_7 = *VAR_0++;", "VAR_8 = 0x80;", "for (;;) {", "int VAR_13 = !!(VAR_7 & VAR_8);", "VAR_8 >>= 1;", "VAR_10 = VAR_6[VAR_10*2 + VAR_13];", "if (VAR_10 == VAR_5)\nbreak;", "if (VAR_10 < VAR_5) {", "*VAR_2++ = VAR_10;", "if (VAR_2 > VAR_11)\nbreak;", "VAR_10 = VAR_9;", "}", "if (!VAR_8) {", "VAR_7 = *VAR_0++;", "if (VAR_0 > VAR_12)\nbreak;", "VAR_8 = 0x80;", "}", "}", "return VAR_2 != VAR_11;", "}" ]

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

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

[ "FUNC_0(VAR_0)\n{", "T1 = PARAM(1);", "RETURN();", "}" ]

[ 0, 1, 1, 0 ]

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

[ "static int FUNC_0(BlockDriverState *VAR_0,\nNBDRequest *VAR_1,\nQEMUIOVector *VAR_2)\n{", "NBDClientSession *s = nbd_get_client_session(VAR_0);", "int VAR_3, VAR_4, VAR_5;", "qemu_co_mutex_lock(&s->send_mutex);", "while (s->in_flight == MAX_NBD_REQUESTS) {", "qemu_co_queue_wait(&s->free_sema, &s->send_mutex);", "}", "s->in_flight++;", "for (VAR_5 = 0; VAR_5 < MAX_NBD_REQUESTS; VAR_5++) {", "if (s->recv_coroutine[VAR_5] == NULL) {", "s->recv_coroutine[VAR_5] = qemu_coroutine_self();", "break;", "}", "}", "g_assert(qemu_in_coroutine());", "assert(VAR_5 < MAX_NBD_REQUESTS);", "VAR_1->handle = INDEX_TO_HANDLE(s, VAR_5);", "if (!s->ioc) {", "qemu_co_mutex_unlock(&s->send_mutex);", "return -EPIPE;", "}", "if (VAR_2) {", "qio_channel_set_cork(s->ioc, true);", "VAR_3 = nbd_send_request(s->ioc, VAR_1);", "if (VAR_3 >= 0) {", "VAR_4 = nbd_rwv(s->ioc, VAR_2->iov, VAR_2->niov, VAR_1->len, false,\nNULL);", "if (VAR_4 != VAR_1->len) {", "VAR_3 = -EIO;", "}", "}", "qio_channel_set_cork(s->ioc, false);", "} else {", "VAR_3 = nbd_send_request(s->ioc, VAR_1);", "}", "qemu_co_mutex_unlock(&s->send_mutex);", "return VAR_3;", "}" ]

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

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

[ "static void __attribute__((__constructor__)) FUNC_0(void)\n{", "QemuThread thread;", "qemu_mutex_init(&rcu_gp_lock);", "qemu_event_init(&rcu_gp_event, true);", "qemu_event_init(&rcu_call_ready_event, false);", "qemu_thread_create(&thread, \"call_rcu\", call_rcu_thread,\nNULL, QEMU_THREAD_DETACHED);", "rcu_register_thread();", "}" ]

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

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

[ "static int FUNC_0(Indeo3DecodeContext *VAR_0, AVCodecContext *VAR_1,\nconst uint8_t *VAR_2, int VAR_3)\n{", "GetByteContext gb;", "const uint8_t *VAR_4;", "uint32_t frame_num, word2, check_sum, data_size;", "uint32_t y_offset, u_offset, v_offset, starts[3], ends[3];", "uint16_t height, width;", "int VAR_5, VAR_6;", "bytestream2_init(&gb, VAR_2, VAR_3);", "frame_num = bytestream2_get_le32(&gb);", "word2 = bytestream2_get_le32(&gb);", "check_sum = bytestream2_get_le32(&gb);", "data_size = bytestream2_get_le32(&gb);", "if ((frame_num ^ word2 ^ data_size ^ OS_HDR_ID) != check_sum) {", "av_log(VAR_1, AV_LOG_ERROR, \"OS header checksum mismatch!\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_4 = gb.buffer;", "if (bytestream2_get_le16(&gb) != 32) {", "av_log(VAR_1, AV_LOG_ERROR, \"Unsupported codec version!\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->frame_num = frame_num;", "VAR_0->frame_flags = bytestream2_get_le16(&gb);", "VAR_0->data_size = (bytestream2_get_le32(&gb) + 7) >> 3;", "VAR_0->cb_offset = bytestream2_get_byte(&gb);", "if (VAR_0->data_size == 16)\nreturn 4;", "if (VAR_0->data_size > VAR_3)\nVAR_0->data_size = VAR_3;", "bytestream2_skip(&gb, 3);", "height = bytestream2_get_le16(&gb);", "width = bytestream2_get_le16(&gb);", "if (av_image_check_size(width, height, 0, VAR_1))\nreturn AVERROR_INVALIDDATA;", "if (width != VAR_0->width || height != VAR_0->height) {", "int VAR_7;", "av_dlog(VAR_1, \"Frame dimensions changed!\\n\");", "if (width < 16 || width > 640 ||\nheight < 16 || height > 480 ||\nwidth & 3 || height & 3) {", "av_log(VAR_1, AV_LOG_ERROR,\n\"Invalid picture dimensions: %d x %d!\\n\", width, height);", "return AVERROR_INVALIDDATA;", "}", "VAR_0->width = width;", "VAR_0->height = height;", "free_frame_buffers(VAR_0);", "if ((VAR_7 = allocate_frame_buffers(VAR_0, VAR_1)) < 0)\nreturn VAR_7;", "avcodec_set_dimensions(VAR_1, width, height);", "}", "y_offset = bytestream2_get_le32(&gb);", "v_offset = bytestream2_get_le32(&gb);", "u_offset = bytestream2_get_le32(&gb);", "bytestream2_skip(&gb, 4);", "starts[0] = y_offset;", "starts[1] = v_offset;", "starts[2] = u_offset;", "for (VAR_6 = 0; VAR_6 < 3; VAR_6++) {", "ends[VAR_6] = VAR_0->data_size;", "for (VAR_5 = 2; VAR_5 >= 0; VAR_5--)", "if (starts[VAR_5] < ends[VAR_6] && starts[VAR_5] > starts[VAR_6])\nends[VAR_6] = starts[VAR_5];", "}", "VAR_0->y_data_size = ends[0] - starts[0];", "VAR_0->v_data_size = ends[1] - starts[1];", "VAR_0->u_data_size = ends[2] - starts[2];", "if (FFMAX3(y_offset, v_offset, u_offset) >= VAR_0->data_size - 16 ||\nFFMIN3(y_offset, v_offset, u_offset) < gb.buffer - VAR_4 + 16 ||\nFFMIN3(VAR_0->y_data_size, VAR_0->v_data_size, VAR_0->u_data_size) <= 0) {", "av_log(VAR_1, AV_LOG_ERROR, \"One of the y/u/v offsets is invalid\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->y_data_ptr = VAR_4 + y_offset;", "VAR_0->v_data_ptr = VAR_4 + v_offset;", "VAR_0->u_data_ptr = VAR_4 + u_offset;", "VAR_0->alt_quant = gb.buffer;", "if (VAR_0->data_size == 16) {", "av_log(VAR_1, AV_LOG_DEBUG, \"Sync frame encountered!\\n\");", "return 16;", "}", "if (VAR_0->frame_flags & BS_8BIT_PEL) {", "avpriv_request_sample(VAR_1, \"8-bit pixel format\");", "return AVERROR_PATCHWELCOME;", "}", "if (VAR_0->frame_flags & BS_MV_X_HALF || VAR_0->frame_flags & BS_MV_Y_HALF) {", "avpriv_request_sample(VAR_1, \"Halfpel motion vectors\");", "return AVERROR_PATCHWELCOME;", "}", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 73, 75 ], [ 77, 79 ], [ 83 ], [ 89 ], [ 91 ], [ 93, 95 ], [ 99 ], [ 101 ], [ 105 ], [ 109, 111, 113 ], [ 115, 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127 ], [ 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 157 ], [ 159 ], [ 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171, 173 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185, 187, 189 ], [ 191 ], [ 193 ], [ 195 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 209 ], [ 211 ], [ 213 ], [ 215 ], [ 219 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 239 ], [ 241 ] ]

[ "static int FUNC_0(AVProbeData *VAR_0)\n{", "int VAR_1;", "quvi_t q;", "QUVIcode rc;", "rc = quvi_init(&q);", "if (rc != QUVI_OK)\nreturn AVERROR(ENOMEM);", "VAR_1 = quvi_supported(q, (char *)VAR_0->filename) == QUVI_OK ? AVPROBE_SCORE_EXTENSION : 0;", "quvi_close(&q);", "return VAR_1;", "}" ]

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

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

[ "void FUNC_0(const uint8_t *VAR_0, uint8_t *VAR_1, unsigned int VAR_2)\n{", "unsigned VAR_3;", "unsigned VAR_4 = VAR_2 >> 1;", "for(VAR_3=0; VAR_3<VAR_4; VAR_3++)", "{", "unsigned VAR_5,VAR_6,VAR_7;", "register uint16_t VAR_8;", "VAR_8 = VAR_0[2*VAR_3];", "VAR_7 = VAR_8&0x1F;", "VAR_6 = (VAR_8&0x7E0)>>5;", "VAR_5 = (VAR_8&0xF800)>>11;", "VAR_1[2*VAR_3] = (VAR_5&0x1F) | ((VAR_6&0x3F)<<5) | ((VAR_7&0x1F)<<11);", "}", "}" ]

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

[ "static int FUNC_0(MpegEncContext *VAR_0, int16_t VAR_1[12][64])\n{", "int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_11, VAR_8;", "const int VAR_9 = 4 + (1 << VAR_0->chroma_format);", "int VAR_10;", "ff_tlog(VAR_0->avctx, \"decode_mb: x=%d y=%d\\n\", VAR_0->mb_x, VAR_0->mb_y);", "av_assert2(VAR_0->mb_skipped == 0);", "if (VAR_0->mb_skip_run-- != 0) {", "if (VAR_0->pict_type == AV_PICTURE_TYPE_P) {", "VAR_0->mb_skipped = 1;", "VAR_0->current_picture.VAR_11[VAR_0->mb_x + VAR_0->mb_y * VAR_0->mb_stride] =\nMB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;", "} else {", "int VAR_11;", "if (VAR_0->mb_x)\nVAR_11 = VAR_0->current_picture.VAR_11[VAR_0->mb_x + VAR_0->mb_y * VAR_0->mb_stride - 1];", "else\nVAR_11 = VAR_0->current_picture.VAR_11[VAR_0->mb_width + (VAR_0->mb_y - 1) * VAR_0->mb_stride - 1];", "if (IS_INTRA(VAR_11)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"skip with previntra\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->current_picture.VAR_11[VAR_0->mb_x + VAR_0->mb_y * VAR_0->mb_stride] =\nVAR_11 | MB_TYPE_SKIP;", "if ((VAR_0->mv[0][0][0] | VAR_0->mv[0][0][1] | VAR_0->mv[1][0][0] | VAR_0->mv[1][0][1]) == 0)\nVAR_0->mb_skipped = 1;", "}", "return 0;", "}", "switch (VAR_0->pict_type) {", "default:\ncase AV_PICTURE_TYPE_I:\nif (get_bits1(&VAR_0->gb) == 0) {", "if (get_bits1(&VAR_0->gb) == 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Invalid mb type in I-frame at %d %d\\n\",\nVAR_0->mb_x, VAR_0->mb_y);", "return AVERROR_INVALIDDATA;", "}", "VAR_11 = MB_TYPE_QUANT | MB_TYPE_INTRA;", "} else {", "VAR_11 = MB_TYPE_INTRA;", "}", "break;", "case AV_PICTURE_TYPE_P:\nVAR_11 = get_vlc2(&VAR_0->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);", "if (VAR_11 < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Invalid mb type in P-frame at %d %d\\n\", VAR_0->mb_x, VAR_0->mb_y);", "return AVERROR_INVALIDDATA;", "}", "VAR_11 = ptype2mb_type[VAR_11];", "break;", "case AV_PICTURE_TYPE_B:\nVAR_11 = get_vlc2(&VAR_0->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);", "if (VAR_11 < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Invalid mb type in B-frame at %d %d\\n\", VAR_0->mb_x, VAR_0->mb_y);", "return AVERROR_INVALIDDATA;", "}", "VAR_11 = btype2mb_type[VAR_11];", "break;", "}", "ff_tlog(VAR_0->avctx, \"VAR_11=%x\\n\", VAR_11);", "if (IS_INTRA(VAR_11)) {", "VAR_0->bdsp.clear_blocks(VAR_0->VAR_1[0]);", "if (!VAR_0->chroma_y_shift)\nVAR_0->bdsp.clear_blocks(VAR_0->VAR_1[6]);", "if (VAR_0->picture_structure == PICT_FRAME &&\n!VAR_0->frame_pred_frame_dct)\nVAR_0->interlaced_dct = get_bits1(&VAR_0->gb);", "if (IS_QUANT(VAR_11))\nVAR_0->qscale = get_qscale(VAR_0);", "if (VAR_0->concealment_motion_vectors) {", "if (VAR_0->picture_structure != PICT_FRAME)\nskip_bits1(&VAR_0->gb);", "VAR_0->mv[0][0][0] =\nVAR_0->last_mv[0][0][0] =\nVAR_0->last_mv[0][1][0] = mpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[0][0],\nVAR_0->last_mv[0][0][0]);", "VAR_0->mv[0][0][1] =\nVAR_0->last_mv[0][0][1] =\nVAR_0->last_mv[0][1][1] = mpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[0][1],\nVAR_0->last_mv[0][0][1]);", "check_marker(VAR_0->avctx, &VAR_0->gb, \"after concealment_motion_vectors\");", "} else {", "memset(VAR_0->last_mv, 0, sizeof(VAR_0->last_mv));", "}", "VAR_0->mb_intra = 1;", "if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && VAR_0->pack_pblocks)\nff_xvmc_pack_pblocks(VAR_0, -1);", "if (VAR_0->codec_id == AV_CODEC_ID_MPEG2VIDEO) {", "if (VAR_0->avctx->flags2 & AV_CODEC_FLAG2_FAST) {", "for (VAR_2 = 0; VAR_2 < 6; VAR_2++)", "mpeg2_fast_decode_block_intra(VAR_0, *VAR_0->pblocks[VAR_2], VAR_2);", "} else {", "for (VAR_2 = 0; VAR_2 < VAR_9; VAR_2++)", "if ((VAR_10 = mpeg2_decode_block_intra(VAR_0, *VAR_0->pblocks[VAR_2], VAR_2)) < 0)\nreturn VAR_10;", "}", "} else {", "for (VAR_2 = 0; VAR_2 < 6; VAR_2++) {", "VAR_10 = ff_mpeg1_decode_block_intra(&VAR_0->gb,\nVAR_0->intra_matrix,\nVAR_0->intra_scantable.permutated,\nVAR_0->last_dc, *VAR_0->pblocks[VAR_2],\nVAR_2, VAR_0->qscale);", "if (VAR_10 < 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"ac-tex damaged at %d %d\\n\",\nVAR_0->mb_x, VAR_0->mb_y);", "return VAR_10;", "}", "VAR_0->block_last_index[VAR_2] = VAR_10;", "}", "}", "} else {", "if (VAR_11 & MB_TYPE_ZERO_MV) {", "av_assert2(VAR_11 & MB_TYPE_CBP);", "VAR_0->mv_dir = MV_DIR_FORWARD;", "if (VAR_0->picture_structure == PICT_FRAME) {", "if (VAR_0->picture_structure == PICT_FRAME\n&& !VAR_0->frame_pred_frame_dct)\nVAR_0->interlaced_dct = get_bits1(&VAR_0->gb);", "VAR_0->mv_type = MV_TYPE_16X16;", "} else {", "VAR_0->mv_type = MV_TYPE_FIELD;", "VAR_11 |= MB_TYPE_INTERLACED;", "VAR_0->field_select[0][0] = VAR_0->picture_structure - 1;", "}", "if (IS_QUANT(VAR_11))\nVAR_0->qscale = get_qscale(VAR_0);", "VAR_0->last_mv[0][0][0] = 0;", "VAR_0->last_mv[0][0][1] = 0;", "VAR_0->last_mv[0][1][0] = 0;", "VAR_0->last_mv[0][1][1] = 0;", "VAR_0->mv[0][0][0] = 0;", "VAR_0->mv[0][0][1] = 0;", "} else {", "av_assert2(VAR_11 & MB_TYPE_L0L1);", "if (VAR_0->picture_structure == PICT_FRAME && VAR_0->frame_pred_frame_dct) {", "VAR_8 = MT_FRAME;", "} else {", "VAR_8 = get_bits(&VAR_0->gb, 2);", "if (VAR_0->picture_structure == PICT_FRAME && HAS_CBP(VAR_11))\nVAR_0->interlaced_dct = get_bits1(&VAR_0->gb);", "}", "if (IS_QUANT(VAR_11))\nVAR_0->qscale = get_qscale(VAR_0);", "VAR_0->mv_dir = (VAR_11 >> 13) & 3;", "ff_tlog(VAR_0->avctx, \"VAR_8=%d\\n\", VAR_8);", "switch (VAR_8) {", "case MT_FRAME:\nif (VAR_0->picture_structure == PICT_FRAME) {", "VAR_11 |= MB_TYPE_16x16;", "VAR_0->mv_type = MV_TYPE_16X16;", "for (VAR_2 = 0; VAR_2 < 2; VAR_2++) {", "if (USES_LIST(VAR_11, VAR_2)) {", "VAR_0->mv[VAR_2][0][0] =\nVAR_0->last_mv[VAR_2][0][0] =\nVAR_0->last_mv[VAR_2][1][0] =\nmpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[VAR_2][0],\nVAR_0->last_mv[VAR_2][0][0]);", "VAR_0->mv[VAR_2][0][1] =\nVAR_0->last_mv[VAR_2][0][1] =\nVAR_0->last_mv[VAR_2][1][1] =\nmpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[VAR_2][1],\nVAR_0->last_mv[VAR_2][0][1]);", "if (VAR_0->full_pel[VAR_2]) {", "VAR_0->mv[VAR_2][0][0] *= 2;", "VAR_0->mv[VAR_2][0][1] *= 2;", "}", "}", "}", "} else {", "VAR_11 |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;", "VAR_0->mv_type = MV_TYPE_16X8;", "for (VAR_2 = 0; VAR_2 < 2; VAR_2++) {", "if (USES_LIST(VAR_11, VAR_2)) {", "for (VAR_3 = 0; VAR_3 < 2; VAR_3++) {", "VAR_0->field_select[VAR_2][VAR_3] = get_bits1(&VAR_0->gb);", "for (VAR_4 = 0; VAR_4 < 2; VAR_4++) {", "VAR_6 = mpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[VAR_2][VAR_4],\nVAR_0->last_mv[VAR_2][VAR_3][VAR_4]);", "VAR_0->last_mv[VAR_2][VAR_3][VAR_4] = VAR_6;", "VAR_0->mv[VAR_2][VAR_3][VAR_4] = VAR_6;", "}", "}", "}", "}", "}", "break;", "case MT_FIELD:\nVAR_0->mv_type = MV_TYPE_FIELD;", "if (VAR_0->picture_structure == PICT_FRAME) {", "VAR_11 |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;", "for (VAR_2 = 0; VAR_2 < 2; VAR_2++) {", "if (USES_LIST(VAR_11, VAR_2)) {", "for (VAR_3 = 0; VAR_3 < 2; VAR_3++) {", "VAR_0->field_select[VAR_2][VAR_3] = get_bits1(&VAR_0->gb);", "VAR_6 = mpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[VAR_2][0],\nVAR_0->last_mv[VAR_2][VAR_3][0]);", "VAR_0->last_mv[VAR_2][VAR_3][0] = VAR_6;", "VAR_0->mv[VAR_2][VAR_3][0] = VAR_6;", "ff_tlog(VAR_0->avctx, \"fmx=%d\\n\", VAR_6);", "VAR_6 = mpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[VAR_2][1],\nVAR_0->last_mv[VAR_2][VAR_3][1] >> 1);", "VAR_0->last_mv[VAR_2][VAR_3][1] = 2 * VAR_6;", "VAR_0->mv[VAR_2][VAR_3][1] = VAR_6;", "ff_tlog(VAR_0->avctx, \"fmy=%d\\n\", VAR_6);", "}", "}", "}", "} else {", "av_assert0(!VAR_0->progressive_sequence);", "VAR_11 |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;", "for (VAR_2 = 0; VAR_2 < 2; VAR_2++) {", "if (USES_LIST(VAR_11, VAR_2)) {", "VAR_0->field_select[VAR_2][0] = get_bits1(&VAR_0->gb);", "for (VAR_4 = 0; VAR_4 < 2; VAR_4++) {", "VAR_6 = mpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[VAR_2][VAR_4],\nVAR_0->last_mv[VAR_2][0][VAR_4]);", "VAR_0->last_mv[VAR_2][0][VAR_4] = VAR_6;", "VAR_0->last_mv[VAR_2][1][VAR_4] = VAR_6;", "VAR_0->mv[VAR_2][0][VAR_4] = VAR_6;", "}", "}", "}", "}", "break;", "case MT_DMV:\nif (VAR_0->progressive_sequence){", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"MT_DMV in progressive_sequence\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_0->mv_type = MV_TYPE_DMV;", "for (VAR_2 = 0; VAR_2 < 2; VAR_2++) {", "if (USES_LIST(VAR_11, VAR_2)) {", "int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15;", "const int VAR_16 = VAR_0->picture_structure == PICT_FRAME;", "VAR_13 = mpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[VAR_2][0],\nVAR_0->last_mv[VAR_2][0][0]);", "VAR_0->last_mv[VAR_2][0][0] = VAR_13;", "VAR_0->last_mv[VAR_2][1][0] = VAR_13;", "VAR_11 = get_dmv(VAR_0);", "VAR_14 = mpeg_decode_motion(VAR_0, VAR_0->mpeg_f_code[VAR_2][1],\nVAR_0->last_mv[VAR_2][0][1] >> VAR_16);", "VAR_12 = get_dmv(VAR_0);", "VAR_0->last_mv[VAR_2][0][1] = VAR_14 * (1 << VAR_16);", "VAR_0->last_mv[VAR_2][1][1] = VAR_14 * (1 << VAR_16);", "VAR_0->mv[VAR_2][0][0] = VAR_13;", "VAR_0->mv[VAR_2][0][1] = VAR_14;", "VAR_0->mv[VAR_2][1][0] = VAR_13;", "VAR_0->mv[VAR_2][1][1] = VAR_14;", "if (VAR_0->picture_structure == PICT_FRAME) {", "VAR_11 |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;", "VAR_15 = VAR_0->top_field_first ? 1 : 3;", "VAR_0->mv[VAR_2][2][0] = ((VAR_13 * VAR_15 + (VAR_13 > 0)) >> 1) + VAR_11;", "VAR_0->mv[VAR_2][2][1] = ((VAR_14 * VAR_15 + (VAR_14 > 0)) >> 1) + VAR_12 - 1;", "VAR_15 = 4 - VAR_15;", "VAR_0->mv[VAR_2][3][0] = ((VAR_13 * VAR_15 + (VAR_13 > 0)) >> 1) + VAR_11;", "VAR_0->mv[VAR_2][3][1] = ((VAR_14 * VAR_15 + (VAR_14 > 0)) >> 1) + VAR_12 + 1;", "} else {", "VAR_11 |= MB_TYPE_16x16;", "VAR_0->mv[VAR_2][2][0] = ((VAR_13 + (VAR_13 > 0)) >> 1) + VAR_11;", "VAR_0->mv[VAR_2][2][1] = ((VAR_14 + (VAR_14 > 0)) >> 1) + VAR_12;", "if (VAR_0->picture_structure == PICT_TOP_FIELD)\nVAR_0->mv[VAR_2][2][1]--;", "else\nVAR_0->mv[VAR_2][2][1]++;", "}", "}", "}", "break;", "default:\nav_log(VAR_0->avctx, AV_LOG_ERROR,\n\"00 VAR_8 at %d %d\\n\", VAR_0->mb_x, VAR_0->mb_y);", "return AVERROR_INVALIDDATA;", "}", "}", "VAR_0->mb_intra = 0;", "if (HAS_CBP(VAR_11)) {", "VAR_0->bdsp.clear_blocks(VAR_0->VAR_1[0]);", "VAR_5 = get_vlc2(&VAR_0->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);", "if (VAR_9 > 6) {", "VAR_5 <<= VAR_9 - 6;", "VAR_5 |= get_bits(&VAR_0->gb, VAR_9 - 6);", "VAR_0->bdsp.clear_blocks(VAR_0->VAR_1[6]);", "}", "if (VAR_5 <= 0) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"invalid VAR_5 %d at %d %d\\n\", VAR_5, VAR_0->mb_x, VAR_0->mb_y);", "return AVERROR_INVALIDDATA;", "}", "if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && VAR_0->pack_pblocks)\nff_xvmc_pack_pblocks(VAR_0, VAR_5);", "if (VAR_0->codec_id == AV_CODEC_ID_MPEG2VIDEO) {", "if (VAR_0->avctx->flags2 & AV_CODEC_FLAG2_FAST) {", "for (VAR_2 = 0; VAR_2 < 6; VAR_2++) {", "if (VAR_5 & 32)\nmpeg2_fast_decode_block_non_intra(VAR_0, *VAR_0->pblocks[VAR_2], VAR_2);", "else\nVAR_0->block_last_index[VAR_2] = -1;", "VAR_5 += VAR_5;", "}", "} else {", "VAR_5 <<= 12 - VAR_9;", "for (VAR_2 = 0; VAR_2 < VAR_9; VAR_2++) {", "if (VAR_5 & (1 << 11)) {", "if ((VAR_10 = mpeg2_decode_block_non_intra(VAR_0, *VAR_0->pblocks[VAR_2], VAR_2)) < 0)\nreturn VAR_10;", "} else {", "VAR_0->block_last_index[VAR_2] = -1;", "}", "VAR_5 += VAR_5;", "}", "}", "} else {", "if (VAR_0->avctx->flags2 & AV_CODEC_FLAG2_FAST) {", "for (VAR_2 = 0; VAR_2 < 6; VAR_2++) {", "if (VAR_5 & 32)\nmpeg1_fast_decode_block_inter(VAR_0, *VAR_0->pblocks[VAR_2], VAR_2);", "else\nVAR_0->block_last_index[VAR_2] = -1;", "VAR_5 += VAR_5;", "}", "} else {", "for (VAR_2 = 0; VAR_2 < 6; VAR_2++) {", "if (VAR_5 & 32) {", "if ((VAR_10 = mpeg1_decode_block_inter(VAR_0, *VAR_0->pblocks[VAR_2], VAR_2)) < 0)\nreturn VAR_10;", "} else {", "VAR_0->block_last_index[VAR_2] = -1;", "}", "VAR_5 += VAR_5;", "}", "}", "}", "} else {", "for (VAR_2 = 0; VAR_2 < 12; VAR_2++)", "VAR_0->block_last_index[VAR_2] = -1;", "}", "}", "VAR_0->current_picture.VAR_11[VAR_0->mb_x + VAR_0->mb_y * VAR_0->mb_stride] = VAR_11;", "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, 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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 27, 29 ], [ 31 ], [ 33 ], [ 37, 39 ], [ 41, 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 61, 63 ], [ 65 ], [ 69 ], [ 71 ], [ 75 ], [ 77, 79, 81 ], [ 83 ], [ 85, 87, 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105, 107 ], [ 109 ], [ 111, 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123, 125 ], [ 127 ], [ 129, 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 147 ], [ 149 ], [ 153, 155 ], [ 163, 165, 167 ], [ 171, 173 ], [ 177 ], [ 181, 183 ], [ 187, 189, 191, 193 ], [ 195, 197, 199, 201 ], [ 205 ], [ 207 ], [ 211 ], [ 213 ], [ 215 ], [ 219, 221 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237, 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247, 249, 251, 253, 255 ], [ 257 ], [ 259, 261 ], [ 263 ], [ 265 ], [ 269 ], [ 271 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 283 ], [ 285 ], [ 287, 289, 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 307, 309 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341, 343 ], [ 345 ], [ 349, 351 ], [ 357 ], [ 359 ], [ 361 ], [ 363, 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 377, 379, 381, 383, 385 ], [ 387, 389, 391, 393, 395 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 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 ], [ 495 ], [ 497 ], [ 499 ], [ 501 ], [ 503 ], [ 505, 507 ], [ 509 ], [ 511 ], [ 513 ], [ 515 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525, 527 ], [ 529 ], [ 531 ], [ 533 ], [ 535 ], [ 537 ], [ 539 ], [ 541 ], [ 543 ], [ 547, 549 ], [ 551 ], [ 553 ], [ 555 ], [ 557, 559 ], [ 561 ], [ 567 ], [ 569 ], [ 573 ], [ 575 ], [ 577 ], [ 579 ], [ 583 ], [ 585 ], [ 591 ], [ 597 ], [ 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ], [ 609 ], [ 613 ], [ 615 ], [ 617, 619 ], [ 621, 623 ], [ 625 ], [ 627 ], [ 629 ], [ 631 ], [ 633, 635, 637 ], [ 639 ], [ 641 ], [ 643 ], [ 647 ], [ 649 ], [ 651 ], [ 655 ], [ 657 ], [ 659 ], [ 661 ], [ 663 ], [ 665 ], [ 667 ], [ 669, 671 ], [ 673 ], [ 675 ], [ 681, 683 ], [ 687 ], [ 689 ], [ 691 ], [ 693, 695 ], [ 697, 699 ], [ 701 ], [ 703 ], [ 705 ], [ 707 ], [ 711 ], [ 713 ], [ 715, 717 ], [ 719 ], [ 721 ], [ 723 ], [ 725 ], [ 727 ], [ 729 ], [ 731 ], [ 733 ], [ 735 ], [ 737, 739 ], [ 741, 743 ], [ 745 ], [ 747 ], [ 749 ], [ 751 ], [ 753 ], [ 755, 757 ], [ 759 ], [ 761 ], [ 763 ], [ 765 ], [ 767 ], [ 769 ], [ 771 ], [ 773 ], [ 775 ], [ 777 ], [ 779 ], [ 781 ], [ 785 ], [ 789 ], [ 791 ] ]

[ "static inline void FUNC_0(rgb15ToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, int width)\n{", "int VAR_0;", "assert(src1 == src2);", "for(VAR_0=0; VAR_0<width; VAR_0++)", "{", "int d0= ((uint32_t*)src1)[VAR_0];", "int dl= (d0&0x03E07C1F);", "int dh= ((d0>>5)&0x03E0F81F);", "int dh2= (dh>>11) + (dh<<21);", "int d= dh2 + dl;", "int g= d&0x7F;", "int r= (d>>10)&0x7F;", "int b= d>>21;", "dstU[VAR_0]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+1-3)) + 128;", "dstV[VAR_0]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+1-3)) + 128;", "}", "}" ]

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

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

[ "const char *FUNC_0(void *VAR_0, const char *VAR_1, const AVOption **VAR_2, char *VAR_3, int VAR_4){", "const AVOption *VAR_5= av_find_opt(VAR_0, VAR_1, NULL, 0, 0);", "void *VAR_6;", "if(!VAR_5 || VAR_5->offset<=0)\nreturn NULL;", "if(VAR_5->type != FF_OPT_TYPE_STRING && (!VAR_3 || !VAR_4))\nreturn NULL;", "VAR_6= ((uint8_t*)VAR_0) + VAR_5->offset;", "if(VAR_2) *VAR_2= VAR_5;", "if(VAR_5->type == FF_OPT_TYPE_STRING)\nreturn VAR_6;", "switch(VAR_5->type){", "case FF_OPT_TYPE_FLAGS: snprintf(VAR_3, VAR_4, \"0x%08X\",*(int *)VAR_6);break;", "case FF_OPT_TYPE_INT: snprintf(VAR_3, VAR_4, \"%d\" , *(int *)VAR_6);break;", "case FF_OPT_TYPE_INT64: snprintf(VAR_3, VAR_4, \"%\"PRId64, *(int64_t*)VAR_6);break;", "case FF_OPT_TYPE_FLOAT: snprintf(VAR_3, VAR_4, \"%f\" , *(float *)VAR_6);break;", "case FF_OPT_TYPE_DOUBLE: snprintf(VAR_3, VAR_4, \"%f\" , *(double *)VAR_6);break;", "case FF_OPT_TYPE_RATIONAL: snprintf(VAR_3, VAR_4, \"%d/%d\", ((AVRational*)VAR_6)->num, ((AVRational*)VAR_6)->den);break;", "default: return NULL;", "}", "return VAR_3;", "}" ]

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

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

[ "static void FUNC_0(IVShmemState *VAR_0, int VAR_1) {", "int VAR_2, VAR_3;", "VAR_3 = VAR_0->nb_peers;", "while (VAR_1 >= VAR_0->nb_peers)\nVAR_0->nb_peers = VAR_0->nb_peers * 2;", "IVSHMEM_DPRINTF(\"bumping storage to %d guests\\n\", VAR_0->nb_peers);", "VAR_0->peers = g_realloc(VAR_0->peers, VAR_0->nb_peers * sizeof(Peer));", "for (VAR_2 = VAR_3; VAR_2 < VAR_0->nb_peers; VAR_2++) {", "VAR_0->peers[VAR_2].eventfds = NULL;", "VAR_0->peers[VAR_2].nb_eventfds = 0;", "}", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0)\n{", "struct USBHostDevice *VAR_1;", "struct USBAutoFilter *VAR_2;", "libusb_device **devs;", "struct libusb_device_descriptor VAR_3;", "int VAR_4 = 0;", "int VAR_5, VAR_6;", "if (usb_host_init() != 0) {", "return;", "}", "if (runstate_is_running()) {", "VAR_6 = libusb_get_device_list(ctx, &devs);", "for (VAR_5 = 0; VAR_5 < VAR_6; VAR_5++) {", "if (libusb_get_device_descriptor(devs[VAR_5], &VAR_3) != 0) {", "continue;", "}", "if (VAR_3.bDeviceClass == LIBUSB_CLASS_HUB) {", "continue;", "}", "QTAILQ_FOREACH(VAR_1, &hostdevs, next) {", "VAR_2 = &VAR_1->match;", "if (VAR_2->bus_num > 0 &&\nVAR_2->bus_num != libusb_get_bus_number(devs[VAR_5])) {", "continue;", "}", "if (VAR_2->addr > 0 &&\nVAR_2->addr != libusb_get_device_address(devs[VAR_5])) {", "continue;", "}", "if (VAR_2->port != NULL) {", "char port[16] = \"-\";", "usb_host_get_port(devs[VAR_5], port, sizeof(port));", "if (strcmp(VAR_2->port, port) != 0) {", "continue;", "}", "}", "if (VAR_2->vendor_id > 0 &&\nVAR_2->vendor_id != VAR_3.idVendor) {", "continue;", "}", "if (VAR_2->product_id > 0 &&\nVAR_2->product_id != VAR_3.idProduct) {", "continue;", "}", "VAR_1->seen++;", "if (VAR_1->errcount >= 3) {", "continue;", "}", "if (VAR_1->dh != NULL) {", "continue;", "}", "if (usb_host_open(VAR_1, devs[VAR_5]) < 0) {", "VAR_1->errcount++;", "continue;", "}", "break;", "}", "}", "libusb_free_device_list(devs, 1);", "QTAILQ_FOREACH(VAR_1, &hostdevs, next) {", "if (VAR_1->dh == NULL) {", "VAR_4++;", "}", "if (VAR_1->seen == 0) {", "if (VAR_1->dh) {", "usb_host_close(VAR_1);", "}", "VAR_1->errcount = 0;", "}", "VAR_1->seen = 0;", "}", "#if 0\nif (VAR_4 == 0) {", "if (usb_auto_timer) {", "timer_del(usb_auto_timer);", "trace_usb_host_auto_scan_disabled();", "}", "return;", "}", "#endif\n}", "if (!usb_vmstate) {", "usb_vmstate = qemu_add_vm_change_state_handler(usb_host_vm_state, NULL);", "}", "if (!usb_auto_timer) {", "usb_auto_timer = timer_new_ms(QEMU_CLOCK_REALTIME, FUNC_0, NULL);", "if (!usb_auto_timer) {", "return;", "}", "trace_usb_host_auto_scan_enabled();", "}", "timer_mod(usb_auto_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 2000);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21 ], [ 23 ], [ 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 ], [ 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 ], [ 157, 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175, 177 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ] ]

[ "int FUNC_0(TCGContext *VAR_0, TranslationBlock *VAR_1)\n{", "#ifdef CONFIG_PROFILER\nTCGProfile *prof = &VAR_0->prof;", "#endif\nint VAR_2, VAR_3, VAR_4, VAR_5;", "#ifdef CONFIG_PROFILER\n{", "int n;", "n = VAR_0->gen_op_buf[0].prev + 1;", "atomic_set(&prof->op_count, prof->op_count + n);", "if (n > prof->op_count_max) {", "atomic_set(&prof->op_count_max, n);", "}", "n = VAR_0->nb_temps;", "atomic_set(&prof->temp_count, prof->temp_count + n);", "if (n > prof->temp_count_max) {", "atomic_set(&prof->temp_count_max, n);", "}", "}", "#endif\n#ifdef DEBUG_DISAS\nif (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP)\n&& qemu_log_in_addr_range(VAR_1->pc))) {", "qemu_log_lock();", "qemu_log(\"OP:\\n\");", "tcg_dump_ops(VAR_0);", "qemu_log(\"\\n\");", "qemu_log_unlock();", "}", "#endif\n#ifdef CONFIG_PROFILER\natomic_set(&prof->opt_time, prof->opt_time - profile_getclock());", "#endif\n#ifdef USE_TCG_OPTIMIZATIONS\ntcg_optimize(VAR_0);", "#endif\n#ifdef CONFIG_PROFILER\natomic_set(&prof->opt_time, prof->opt_time + profile_getclock());", "atomic_set(&prof->la_time, prof->la_time - profile_getclock());", "#endif\nliveness_pass_1(VAR_0);", "if (VAR_0->nb_indirects > 0) {", "#ifdef DEBUG_DISAS\nif (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_IND)\n&& qemu_log_in_addr_range(VAR_1->pc))) {", "qemu_log_lock();", "qemu_log(\"OP before indirect lowering:\\n\");", "tcg_dump_ops(VAR_0);", "qemu_log(\"\\n\");", "qemu_log_unlock();", "}", "#endif\nif (liveness_pass_2(VAR_0)) {", "liveness_pass_1(VAR_0);", "}", "}", "#ifdef CONFIG_PROFILER\natomic_set(&prof->la_time, prof->la_time + profile_getclock());", "#endif\n#ifdef DEBUG_DISAS\nif (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT)\n&& qemu_log_in_addr_range(VAR_1->pc))) {", "qemu_log_lock();", "qemu_log(\"OP after optimization and liveness analysis:\\n\");", "tcg_dump_ops(VAR_0);", "qemu_log(\"\\n\");", "qemu_log_unlock();", "}", "#endif\ntcg_reg_alloc_start(VAR_0);", "VAR_0->code_buf = VAR_1->tc.ptr;", "VAR_0->code_ptr = VAR_1->tc.ptr;", "#ifdef TCG_TARGET_NEED_LDST_LABELS\nVAR_0->ldst_labels = NULL;", "#endif\n#ifdef TCG_TARGET_NEED_POOL_LABELS\nVAR_0->pool_labels = NULL;", "#endif\nVAR_5 = -1;", "for (VAR_3 = VAR_0->gen_op_buf[0].next; VAR_3 != 0; VAR_3 = VAR_4) {", "TCGOp * const op = &VAR_0->gen_op_buf[VAR_3];", "TCGOpcode opc = op->opc;", "VAR_4 = op->next;", "#ifdef CONFIG_PROFILER\natomic_set(&prof->table_op_count[opc], prof->table_op_count[opc] + 1);", "#endif\nswitch (opc) {", "case INDEX_op_mov_i32:\ncase INDEX_op_mov_i64:\ntcg_reg_alloc_mov(VAR_0, op);", "break;", "case INDEX_op_movi_i32:\ncase INDEX_op_movi_i64:\ntcg_reg_alloc_movi(VAR_0, op);", "break;", "case INDEX_op_insn_start:\nif (VAR_5 >= 0) {", "VAR_0->gen_insn_end_off[VAR_5] = tcg_current_code_size(VAR_0);", "}", "VAR_5++;", "for (VAR_2 = 0; VAR_2 < TARGET_INSN_START_WORDS; ++VAR_2) {", "target_ulong a;", "#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS\na = deposit64(op->args[VAR_2 * 2], 32, 32, op->args[VAR_2 * 2 + 1]);", "#else\na = op->args[VAR_2];", "#endif\nVAR_0->gen_insn_data[VAR_5][VAR_2] = a;", "}", "break;", "case INDEX_op_discard:\ntemp_dead(VAR_0, arg_temp(op->args[0]));", "break;", "case INDEX_op_set_label:\ntcg_reg_alloc_bb_end(VAR_0, VAR_0->reserved_regs);", "tcg_out_label(VAR_0, arg_label(op->args[0]), VAR_0->code_ptr);", "break;", "case INDEX_op_call:\ntcg_reg_alloc_call(VAR_0, op);", "break;", "default:\ntcg_debug_assert(tcg_op_supported(opc));", "tcg_reg_alloc_op(VAR_0, op);", "break;", "}", "#ifdef CONFIG_DEBUG_TCG\ncheck_regs(VAR_0);", "#endif\nif (unlikely((void *)VAR_0->code_ptr > VAR_0->code_gen_highwater)) {", "return -1;", "}", "}", "tcg_debug_assert(VAR_5 >= 0);", "VAR_0->gen_insn_end_off[VAR_5] = tcg_current_code_size(VAR_0);", "#ifdef TCG_TARGET_NEED_LDST_LABELS\nif (!tcg_out_ldst_finalize(VAR_0)) {", "return -1;", "}", "#endif\n#ifdef TCG_TARGET_NEED_POOL_LABELS\nif (!tcg_out_pool_finalize(VAR_0)) {", "return -1;", "}", "#endif\nflush_icache_range((uintptr_t)VAR_0->code_buf, (uintptr_t)VAR_0->code_ptr);", "return tcg_current_code_size(VAR_0);", "}" ]

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

[ [ 1, 3 ], [ 5, 7 ], [ 9, 11 ], [ 15, 17 ], [ 19 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47, 51, 53, 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69, 73, 75 ], [ 77, 81, 83 ], [ 85, 89, 91 ], [ 93 ], [ 95, 99 ], [ 103 ], [ 105, 107, 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123, 127 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141 ], [ 143, 147, 149, 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165, 169 ], [ 173 ], [ 175 ], [ 179, 181 ], [ 183, 185, 187 ], [ 189, 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205, 207 ], [ 209, 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, 285 ], [ 293 ], [ 295 ], [ 297 ], [ 299, 301 ], [ 303, 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 329, 331 ], [ 333 ], [ 335 ], [ 337, 339, 341 ], [ 343 ], [ 345 ], [ 347, 353 ], [ 357 ], [ 359 ] ]

[ "void FUNC_0(VncPalette *VAR_0)\n{", "if (VAR_0 == NULL) {", "qemu_free(VAR_0);", "}", "}" ]

[ 0, 1, 1, 0, 0 ]

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

[ "static int FUNC_0(IVShmemState *VAR_0)\n{", "VAR_0->msi_vectors = g_malloc0(VAR_0->vectors * sizeof(MSIVector));", "if (ivshmem_has_feature(VAR_0, IVSHMEM_MSI)) {", "if (msix_init_exclusive_bar(PCI_DEVICE(VAR_0), VAR_0->vectors, 1)) {", "return -1;", "}", "IVSHMEM_DPRINTF(\"msix initialized (%d vectors)\\n\", VAR_0->vectors);", "ivshmem_msix_vector_use(VAR_0);", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ] ]

[ "static int FUNC_0(WavPackEncodeContext *VAR_0,\nint32_t *VAR_1, int32_t *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{", "int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11 = 0;", "int VAR_12, VAR_13, VAR_14 = 0, VAR_15 = 0, VAR_16 = VAR_0->block_samples;", "uint32_t crc = 0xffffffffu;", "struct Decorr *VAR_20;", "PutByteContext pb;", "if (!(VAR_0->flags & WV_MONO) && VAR_0->optimize_mono) {", "int32_t lor = 0, diff = 0;", "for (VAR_12 = 0; VAR_12 < VAR_16; VAR_12++) {", "lor |= VAR_1[VAR_12] | VAR_2[VAR_12];", "diff |= VAR_1[VAR_12] - VAR_2[VAR_12];", "if (lor && diff)\nbreak;", "}", "if (VAR_12 == VAR_16 && lor && !diff) {", "VAR_0->flags &= ~(WV_JOINT_STEREO | WV_CROSS_DECORR);", "VAR_0->flags |= WV_FALSE_STEREO;", "if (!VAR_0->false_stereo) {", "VAR_0->false_stereo = 1;", "VAR_0->num_terms = 0;", "CLEAR(VAR_0->w);", "}", "} else if (VAR_0->false_stereo) {", "VAR_0->false_stereo = 0;", "VAR_0->num_terms = 0;", "CLEAR(VAR_0->w);", "}", "}", "if (VAR_0->flags & SHIFT_MASK) {", "int VAR_18 = (VAR_0->flags & SHIFT_MASK) >> SHIFT_LSB;", "int VAR_19 = (VAR_0->flags & MAG_MASK) >> MAG_LSB;", "if (VAR_0->flags & WV_MONO_DATA)\nshift_mono(VAR_1, VAR_16, VAR_18);", "else\nshift_stereo(VAR_1, VAR_2, VAR_16, VAR_18);", "if ((VAR_19 -= VAR_18) < 0)\nVAR_0->flags &= ~MAG_MASK;", "else\nVAR_0->flags -= (1 << MAG_LSB) * VAR_18;", "}", "if ((VAR_0->flags & WV_FLOAT_DATA) || (VAR_0->flags & MAG_MASK) >> MAG_LSB >= 24) {", "av_fast_padded_malloc(&VAR_0->orig_l, &VAR_0->orig_l_size, sizeof(int32_t) * VAR_16);", "memcpy(VAR_0->orig_l, VAR_1, sizeof(int32_t) * VAR_16);", "if (!(VAR_0->flags & WV_MONO_DATA)) {", "av_fast_padded_malloc(&VAR_0->orig_r, &VAR_0->orig_r_size, sizeof(int32_t) * VAR_16);", "memcpy(VAR_0->orig_r, VAR_2, sizeof(int32_t) * VAR_16);", "}", "if (VAR_0->flags & WV_FLOAT_DATA)\nVAR_15 = scan_float(VAR_0, VAR_1, VAR_2, VAR_16);", "else\nVAR_15 = scan_int32(VAR_0, VAR_1, VAR_2, VAR_16);", "VAR_0->num_terms = 0;", "} else {", "scan_int23(VAR_0, VAR_1, VAR_2, VAR_16);", "if (VAR_0->VAR_18 != VAR_0->int32_zeros + VAR_0->int32_ones + VAR_0->int32_dups) {", "VAR_0->VAR_18 = VAR_0->int32_zeros + VAR_0->int32_ones + VAR_0->int32_dups;", "VAR_0->num_terms = 0;", "}", "}", "if (!VAR_0->num_passes && !VAR_0->num_terms) {", "VAR_0->num_passes = 1;", "if (VAR_0->flags & WV_MONO_DATA)\nVAR_14 = wv_mono(VAR_0, VAR_1, 1, 0);", "else\nVAR_14 = wv_stereo(VAR_0, VAR_1, VAR_2, 1, 0);", "VAR_0->num_passes = 0;", "}", "if (VAR_0->flags & WV_MONO_DATA) {", "for (VAR_12 = 0; VAR_12 < VAR_16; VAR_12++)", "crc += (crc << 1) + VAR_1[VAR_12];", "if (VAR_0->num_passes)\nVAR_14 = wv_mono(VAR_0, VAR_1, !VAR_0->num_terms, 1);", "} else {", "for (VAR_12 = 0; VAR_12 < VAR_16; VAR_12++)", "crc += (crc << 3) + (VAR_1[VAR_12] << 1) + VAR_1[VAR_12] + VAR_2[VAR_12];", "if (VAR_0->num_passes)\nVAR_14 = wv_stereo(VAR_0, VAR_1, VAR_2, !VAR_0->num_terms, 1);", "}", "if (VAR_14 < 0)\nreturn VAR_14;", "if (!VAR_0->ch_offset)\nVAR_0->flags |= WV_INITIAL_BLOCK;", "VAR_0->ch_offset += 1 + !(VAR_0->flags & WV_MONO);", "if (VAR_0->ch_offset == VAR_0->avctx->channels)\nVAR_0->flags |= WV_FINAL_BLOCK;", "bytestream2_init_writer(&pb, VAR_3, VAR_4);", "bytestream2_put_le32(&pb, MKTAG('w', 'v', 'p', 'VAR_20'));", "bytestream2_put_le32(&pb, 0);", "bytestream2_put_le16(&pb, 0x410);", "bytestream2_put_le16(&pb, 0);", "bytestream2_put_le32(&pb, 0);", "bytestream2_put_le32(&pb, VAR_0->sample_index);", "bytestream2_put_le32(&pb, VAR_16);", "bytestream2_put_le32(&pb, VAR_0->flags);", "bytestream2_put_le32(&pb, crc);", "if (VAR_0->flags & WV_INITIAL_BLOCK &&\nVAR_0->avctx->channel_layout != AV_CH_LAYOUT_MONO &&\nVAR_0->avctx->channel_layout != AV_CH_LAYOUT_STEREO) {", "put_metadata_block(&pb, WP_ID_CHANINFO, 5);", "bytestream2_put_byte(&pb, VAR_0->avctx->channels);", "bytestream2_put_le32(&pb, VAR_0->avctx->channel_layout);", "bytestream2_put_byte(&pb, 0);", "}", "if ((VAR_0->flags & SRATE_MASK) == SRATE_MASK) {", "put_metadata_block(&pb, WP_ID_SAMPLE_RATE, 3);", "bytestream2_put_le24(&pb, VAR_0->avctx->sample_rate);", "bytestream2_put_byte(&pb, 0);", "}", "put_metadata_block(&pb, WP_ID_DECTERMS, VAR_0->num_terms);", "for (VAR_12 = 0; VAR_12 < VAR_0->num_terms; VAR_12++) {", "struct Decorr *VAR_20 = &VAR_0->decorr_passes[VAR_12];", "bytestream2_put_byte(&pb, ((VAR_20->value + 5) & 0x1f) | ((VAR_20->delta << 5) & 0xe0));", "}", "if (VAR_0->num_terms & 1)\nbytestream2_put_byte(&pb, 0);", "#define WRITE_DECWEIGHT(type) do { \\", "VAR_10 = store_weight(type); \\", "bytestream2_put_byte(&pb, VAR_10); \\", "type = restore_weight(VAR_10); \\", "} while (0)", "bytestream2_put_byte(&pb, WP_ID_DECWEIGHTS);", "bytestream2_put_byte(&pb, 0);", "VAR_6 = bytestream2_tell_p(&pb);", "for (VAR_12 = VAR_0->num_terms - 1; VAR_12 >= 0; --VAR_12) {", "struct Decorr *VAR_20 = &VAR_0->decorr_passes[VAR_12];", "if (store_weight(VAR_20->weightA) ||\n(!(VAR_0->flags & WV_MONO_DATA) && store_weight(VAR_20->weightB)))\nbreak;", "}", "VAR_9 = VAR_12 + 1;", "for (VAR_12 = 0; VAR_12 < VAR_0->num_terms; VAR_12++) {", "struct Decorr *VAR_20 = &VAR_0->decorr_passes[VAR_12];", "if (VAR_12 < VAR_9) {", "WRITE_DECWEIGHT(VAR_20->weightA);", "if (!(VAR_0->flags & WV_MONO_DATA))\nWRITE_DECWEIGHT(VAR_20->weightB);", "} else {", "VAR_20->weightA = VAR_20->weightB = 0;", "}", "}", "VAR_7 = bytestream2_tell_p(&pb);", "VAR_3[VAR_6 - 2] = WP_ID_DECWEIGHTS | (((VAR_7 - VAR_6) & 1) ? WP_IDF_ODD: 0);", "VAR_3[VAR_6 - 1] = (VAR_7 - VAR_6 + 1) >> 1;", "if ((VAR_7 - VAR_6) & 1)\nbytestream2_put_byte(&pb, 0);", "#define WRITE_DECSAMPLE(type) do { \\", "VAR_10 = log2s(type); \\", "type = wp_exp2(VAR_10); \\", "bytestream2_put_le16(&pb, VAR_10); \\", "} while (0)", "bytestream2_put_byte(&pb, WP_ID_DECSAMPLES);", "bytestream2_put_byte(&pb, 0);", "VAR_6 = bytestream2_tell_p(&pb);", "for (VAR_12 = 0; VAR_12 < VAR_0->num_terms; VAR_12++) {", "struct Decorr *VAR_20 = &VAR_0->decorr_passes[VAR_12];", "if (VAR_12 == 0) {", "if (VAR_20->value > MAX_TERM) {", "WRITE_DECSAMPLE(VAR_20->samplesA[0]);", "WRITE_DECSAMPLE(VAR_20->samplesA[1]);", "if (!(VAR_0->flags & WV_MONO_DATA)) {", "WRITE_DECSAMPLE(VAR_20->samplesB[0]);", "WRITE_DECSAMPLE(VAR_20->samplesB[1]);", "}", "} else if (VAR_20->value < 0) {", "WRITE_DECSAMPLE(VAR_20->samplesA[0]);", "WRITE_DECSAMPLE(VAR_20->samplesB[0]);", "} else {", "for (VAR_13 = 0; VAR_13 < VAR_20->value; VAR_13++) {", "WRITE_DECSAMPLE(VAR_20->samplesA[VAR_13]);", "if (!(VAR_0->flags & WV_MONO_DATA))\nWRITE_DECSAMPLE(VAR_20->samplesB[VAR_13]);", "}", "}", "} else {", "CLEAR(VAR_20->samplesA);", "CLEAR(VAR_20->samplesB);", "}", "}", "VAR_7 = bytestream2_tell_p(&pb);", "VAR_3[VAR_6 - 1] = (VAR_7 - VAR_6) >> 1;", "#define WRITE_CHAN_ENTROPY(chan) do { \\", "for (VAR_12 = 0; VAR_12 < 3; VAR_12++) { \\", "VAR_10 = wp_log2(VAR_0->w.c[chan].median[VAR_12]); \\", "bytestream2_put_le16(&pb, VAR_10); \\", "VAR_0->w.c[chan].median[VAR_12] = wp_exp2(VAR_10); \\", "} \\", "} while (0)", "put_metadata_block(&pb, WP_ID_ENTROPY, 6 * (1 + (!(VAR_0->flags & WV_MONO_DATA))));", "WRITE_CHAN_ENTROPY(0);", "if (!(VAR_0->flags & WV_MONO_DATA))\nWRITE_CHAN_ENTROPY(1);", "if (VAR_0->flags & WV_FLOAT_DATA) {", "put_metadata_block(&pb, WP_ID_FLOATINFO, 4);", "bytestream2_put_byte(&pb, VAR_0->float_flags);", "bytestream2_put_byte(&pb, VAR_0->float_shift);", "bytestream2_put_byte(&pb, VAR_0->float_max_exp);", "bytestream2_put_byte(&pb, 127);", "}", "if (VAR_0->flags & WV_INT32_DATA) {", "put_metadata_block(&pb, WP_ID_INT32INFO, 4);", "bytestream2_put_byte(&pb, VAR_0->int32_sent_bits);", "bytestream2_put_byte(&pb, VAR_0->int32_zeros);", "bytestream2_put_byte(&pb, VAR_0->int32_ones);", "bytestream2_put_byte(&pb, VAR_0->int32_dups);", "}", "if (VAR_0->flags & WV_MONO_DATA && !VAR_0->num_passes) {", "for (VAR_12 = 0; VAR_12 < VAR_16; VAR_12++) {", "int32_t code = VAR_1[VAR_12];", "for (VAR_9 = VAR_0->num_terms, VAR_20 = VAR_0->decorr_passes; VAR_9--; VAR_20++) {", "int32_t sam;", "if (VAR_20->value > MAX_TERM) {", "if (VAR_20->value & 1)\nsam = 2 * VAR_20->samplesA[0] - VAR_20->samplesA[1];", "else\nsam = (3 * VAR_20->samplesA[0] - VAR_20->samplesA[1]) >> 1;", "VAR_20->samplesA[1] = VAR_20->samplesA[0];", "VAR_20->samplesA[0] = code;", "} else {", "sam = VAR_20->samplesA[VAR_11];", "VAR_20->samplesA[(VAR_11 + VAR_20->value) & (MAX_TERM - 1)] = code;", "}", "code -= APPLY_WEIGHT(VAR_20->weightA, sam);", "UPDATE_WEIGHT(VAR_20->weightA, VAR_20->delta, sam, code);", "}", "VAR_11 = (VAR_11 + 1) & (MAX_TERM - 1);", "VAR_1[VAR_12] = code;", "}", "if (VAR_11) {", "for (VAR_9 = VAR_0->num_terms, VAR_20 = VAR_0->decorr_passes; VAR_9--; VAR_20++)", "if (VAR_20->value > 0 && VAR_20->value <= MAX_TERM) {", "int32_t temp_A[MAX_TERM], temp_B[MAX_TERM];", "int VAR_20;", "memcpy(temp_A, VAR_20->samplesA, sizeof(VAR_20->samplesA));", "memcpy(temp_B, VAR_20->samplesB, sizeof(VAR_20->samplesB));", "for (VAR_20 = 0; VAR_20 < MAX_TERM; VAR_20++) {", "VAR_20->samplesA[VAR_20] = temp_A[VAR_11];", "VAR_20->samplesB[VAR_20] = temp_B[VAR_11];", "VAR_11 = (VAR_11 + 1) & (MAX_TERM - 1);", "}", "}", "}", "} else if (!VAR_0->num_passes) {", "if (VAR_0->flags & WV_JOINT_STEREO) {", "for (VAR_12 = 0; VAR_12 < VAR_16; VAR_12++)", "VAR_2[VAR_12] += ((VAR_1[VAR_12] -= VAR_2[VAR_12]) >> 1);", "}", "for (VAR_12 = 0; VAR_12 < VAR_0->num_terms; VAR_12++) {", "struct Decorr *VAR_20 = &VAR_0->decorr_passes[VAR_12];", "if (((VAR_0->flags & MAG_MASK) >> MAG_LSB) >= 16 || VAR_20->delta != 2)\ndecorr_stereo_pass2(VAR_20, VAR_1, VAR_2, VAR_16);", "else\ndecorr_stereo_pass_id2(VAR_20, VAR_1, VAR_2, VAR_16);", "}", "}", "bytestream2_put_byte(&pb, WP_ID_DATA | WP_IDF_LONG);", "init_put_bits(&VAR_0->pb, pb.buffer + 3, bytestream2_get_bytes_left_p(&pb));", "if (VAR_0->flags & WV_MONO_DATA) {", "for (VAR_12 = 0; VAR_12 < VAR_16; VAR_12++)", "wavpack_encode_sample(VAR_0, &VAR_0->w.c[0], VAR_0->samples[0][VAR_12]);", "} else {", "for (VAR_12 = 0; VAR_12 < VAR_16; VAR_12++) {", "wavpack_encode_sample(VAR_0, &VAR_0->w.c[0], VAR_0->samples[0][VAR_12]);", "wavpack_encode_sample(VAR_0, &VAR_0->w.c[1], VAR_0->samples[1][VAR_12]);", "}", "}", "encode_flush(VAR_0);", "flush_put_bits(&VAR_0->pb);", "VAR_8 = put_bits_count(&VAR_0->pb) >> 3;", "bytestream2_put_le24(&pb, (VAR_8 + 1) >> 1);", "bytestream2_skip_p(&pb, VAR_8);", "if (VAR_8 & 1)\nbytestream2_put_byte(&pb, 0);", "if (VAR_15) {", "bytestream2_put_byte(&pb, WP_ID_EXTRABITS | WP_IDF_LONG);", "init_put_bits(&VAR_0->pb, pb.buffer + 7, bytestream2_get_bytes_left_p(&pb));", "if (VAR_0->flags & WV_FLOAT_DATA)\npack_float(VAR_0, VAR_0->orig_l, VAR_0->orig_r, VAR_16);", "else\npack_int32(VAR_0, VAR_0->orig_l, VAR_0->orig_r, VAR_16);", "flush_put_bits(&VAR_0->pb);", "VAR_8 = put_bits_count(&VAR_0->pb) >> 3;", "bytestream2_put_le24(&pb, (VAR_8 + 5) >> 1);", "bytestream2_put_le32(&pb, VAR_0->crc_x);", "bytestream2_skip_p(&pb, VAR_8);", "if (VAR_8 & 1)\nbytestream2_put_byte(&pb, 0);", "}", "VAR_5 = bytestream2_tell_p(&pb);", "AV_WL32(VAR_3 + 4, VAR_5 - 8);", "return VAR_5;", "}" ]

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

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

[ "FUNC_0(Object *VAR_0, const char *VAR_1,\nObject *VAR_2, Error **VAR_3)\n{", "if (cryptodev_backend_is_used(CRYPTODEV_BACKEND(VAR_2))) {", "char *VAR_4 = object_get_canonical_path_component(VAR_2);", "error_setg(VAR_3,\n\"can't use already used cryptodev backend: %s\", VAR_4);", "g_free(VAR_4);", "} else {", "qdev_prop_allow_set_link_before_realize(VAR_0, VAR_1, VAR_2, VAR_3);", "}", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "QObject *obj = qobject_from_json(\"{'abc':32\", NULL);", "g_assert(obj == NULL);", "}" ]

[ 0, 1, 0, 0 ]

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

[ "static void* VAR_0 worker(void *v)\n{", "AVCodecContext *avctx = v;", "SliceThreadContext *c = avctx->internal->thread_ctx;", "unsigned last_execute = 0;", "int our_job = c->job_count;", "int thread_count = avctx->thread_count;", "int self_id;", "pthread_mutex_lock(&c->current_job_lock);", "self_id = c->current_job++;", "for (;;){", "while (our_job >= c->job_count) {", "if (c->current_job == thread_count + c->job_count)\npthread_cond_signal(&c->last_job_cond);", "while (last_execute == c->current_execute && !c->done)\npthread_cond_wait(&c->current_job_cond, &c->current_job_lock);", "last_execute = c->current_execute;", "our_job = self_id;", "if (c->done) {", "pthread_mutex_unlock(&c->current_job_lock);", "return NULL;", "}", "}", "pthread_mutex_unlock(&c->current_job_lock);", "c->rets[our_job%c->rets_count] = c->func ? c->func(avctx, (char*)c->args + our_job*c->job_size):\nc->func2(avctx, c->args, our_job, self_id);", "pthread_mutex_lock(&c->current_job_lock);", "our_job = c->current_job++;", "}", "}" ]

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

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

[ "static void FUNC_0(uint8_t *VAR_0,\nint32_t VAR_1,\nint32_t VAR_2,\nint32_t VAR_3)\n{", "uint64_t load0, load1;", "uint32_t out0, out2;", "uint16_t out1, out3;", "v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;", "v8u16 dst0_r, dst1_r, dst4_r, dst5_r;", "v8u16 dst2_x_r, dst2_y_r, dst3_x_r, dst3_y_r;", "v16u8 dst0, dst1, dst4, dst5, dst2_x, dst2_y, dst3_x, dst3_y;", "v8i16 tmp0, tmp1, tmp2, tmp3;", "v16u8 alpha, beta;", "v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, p2_asub_p0, q2_asub_q0;", "v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;", "v16u8 is_less_than_beta1, is_less_than_beta2;", "v16i8 src0 = { 0 };", "v16i8 src1 = { 0 };", "v16i8 src2 = { 0 };", "v16i8 src3 = { 0 };", "v16i8 src4 = { 0 };", "v16i8 src5 = { 0 };", "v16i8 src6 = { 0 };", "v16i8 src7 = { 0 };", "v16i8 zeros = { 0 };", "load0 = LOAD_DWORD(VAR_0 - 4);", "load1 = LOAD_DWORD(VAR_0 + VAR_1 - 4);", "src0 = (v16i8) __msa_insert_d((v2i64) src0, 0, load0);", "src1 = (v16i8) __msa_insert_d((v2i64) src1, 0, load1);", "load0 = LOAD_DWORD(VAR_0 + (2 * VAR_1) - 4);", "load1 = LOAD_DWORD(VAR_0 + (3 * VAR_1) - 4);", "src2 = (v16i8) __msa_insert_d((v2i64) src2, 0, load0);", "src3 = (v16i8) __msa_insert_d((v2i64) src3, 0, load1);", "load0 = LOAD_DWORD(VAR_0 + (4 * VAR_1) - 4);", "load1 = LOAD_DWORD(VAR_0 + (5 * VAR_1) - 4);", "src4 = (v16i8) __msa_insert_d((v2i64) src4, 0, load0);", "src5 = (v16i8) __msa_insert_d((v2i64) src5, 0, load1);", "load0 = LOAD_DWORD(VAR_0 + (6 * VAR_1) - 4);", "load1 = LOAD_DWORD(VAR_0 + (7 * VAR_1) - 4);", "src6 = (v16i8) __msa_insert_d((v2i64) src6, 0, load0);", "src7 = (v16i8) __msa_insert_d((v2i64) src7, 0, load1);", "src0 = __msa_ilvr_b(src1, src0);", "src1 = __msa_ilvr_b(src3, src2);", "src2 = __msa_ilvr_b(src5, src4);", "src3 = __msa_ilvr_b(src7, src6);", "tmp0 = __msa_ilvr_h((v8i16) src1, (v8i16) src0);", "tmp1 = __msa_ilvl_h((v8i16) src1, (v8i16) src0);", "tmp2 = __msa_ilvr_h((v8i16) src3, (v8i16) src2);", "tmp3 = __msa_ilvl_h((v8i16) src3, (v8i16) src2);", "src6 = (v16i8) __msa_ilvr_w((v4i32) tmp2, (v4i32) tmp0);", "src0 = __msa_sldi_b(zeros, src6, 8);", "src1 = (v16i8) __msa_ilvl_w((v4i32) tmp2, (v4i32) tmp0);", "src2 = __msa_sldi_b(zeros, src1, 8);", "src3 = (v16i8) __msa_ilvr_w((v4i32) tmp3, (v4i32) tmp1);", "src4 = __msa_sldi_b(zeros, src3, 8);", "src5 = (v16i8) __msa_ilvl_w((v4i32) tmp3, (v4i32) tmp1);", "src7 = __msa_sldi_b(zeros, src5, 8);", "p0_asub_q0 = __msa_asub_u_b((v16u8) src2, (v16u8) src3);", "p1_asub_p0 = __msa_asub_u_b((v16u8) src1, (v16u8) src2);", "q1_asub_q0 = __msa_asub_u_b((v16u8) src4, (v16u8) src3);", "alpha = (v16u8) __msa_fill_b(VAR_2);", "beta = (v16u8) __msa_fill_b(VAR_3);", "is_less_than_alpha = (p0_asub_q0 < alpha);", "is_less_than_beta = (p1_asub_p0 < beta);", "is_less_than = is_less_than_alpha & is_less_than_beta;", "is_less_than_beta = (q1_asub_q0 < beta);", "is_less_than = is_less_than & is_less_than_beta;", "alpha >>= 2;", "alpha += 2;", "is_less_than_alpha = (p0_asub_q0 < alpha);", "p2_asub_p0 = __msa_asub_u_b((v16u8) src0, (v16u8) src2);", "is_less_than_beta1 = (p2_asub_p0 < beta);", "q2_asub_q0 = __msa_asub_u_b((v16u8) src5, (v16u8) src3);", "is_less_than_beta2 = (q2_asub_q0 < beta);", "src0_r = (v8u16) __msa_ilvr_b(zeros, src0);", "src1_r = (v8u16) __msa_ilvr_b(zeros, src1);", "src2_r = (v8u16) __msa_ilvr_b(zeros, src2);", "src3_r = (v8u16) __msa_ilvr_b(zeros, src3);", "src4_r = (v8u16) __msa_ilvr_b(zeros, src4);", "src5_r = (v8u16) __msa_ilvr_b(zeros, src5);", "src6_r = (v8u16) __msa_ilvr_b(zeros, src6);", "src7_r = (v8u16) __msa_ilvr_b(zeros, src7);", "dst2_x_r = src1_r + src2_r + src3_r;", "dst2_x_r = src0_r + (2 * (dst2_x_r)) + src4_r;", "dst2_x_r = (v8u16) __msa_srari_h((v8i16) dst2_x_r, 3);", "dst1_r = src0_r + src1_r + src2_r + src3_r;", "dst1_r = (v8u16) __msa_srari_h((v8i16) dst1_r, 2);", "dst0_r = (2 * src6_r) + (3 * src0_r);", "dst0_r += src1_r + src2_r + src3_r;", "dst0_r = (v8u16) __msa_srari_h((v8i16) dst0_r, 3);", "dst2_y_r = (2 * src1_r) + src2_r + src4_r;", "dst2_y_r = (v8u16) __msa_srari_h((v8i16) dst2_y_r, 2);", "dst2_x = (v16u8) __msa_pckev_b((v16i8) dst2_x_r, (v16i8) dst2_x_r);", "dst2_y = (v16u8) __msa_pckev_b((v16i8) dst2_y_r, (v16i8) dst2_y_r);", "dst2_x = __msa_bmnz_v(dst2_y, dst2_x, is_less_than_beta1);", "dst3_x_r = src2_r + src3_r + src4_r;", "dst3_x_r = src1_r + (2 * dst3_x_r) + src5_r;", "dst3_x_r = (v8u16) __msa_srari_h((v8i16) dst3_x_r, 3);", "dst4_r = src2_r + src3_r + src4_r + src5_r;", "dst4_r = (v8u16) __msa_srari_h((v8i16) dst4_r, 2);", "dst5_r = (2 * src7_r) + (3 * src5_r);", "dst5_r += src4_r + src3_r + src2_r;", "dst5_r = (v8u16) __msa_srari_h((v8i16) dst5_r, 3);", "dst3_y_r = (2 * src4_r) + src3_r + src1_r;", "dst3_y_r = (v8u16) __msa_srari_h((v8i16) dst3_y_r, 2);", "dst3_x = (v16u8) __msa_pckev_b((v16i8) dst3_x_r, (v16i8) dst3_x_r);", "dst3_y = (v16u8) __msa_pckev_b((v16i8) dst3_y_r, (v16i8) dst3_y_r);", "dst3_x = __msa_bmnz_v(dst3_y, dst3_x, is_less_than_beta2);", "dst2_y_r = (2 * src1_r) + src2_r + src4_r;", "dst2_y_r = (v8u16) __msa_srari_h((v8i16) dst2_y_r, 2);", "dst3_y_r = (2 * src4_r) + src3_r + src1_r;", "dst3_y_r = (v8u16) __msa_srari_h((v8i16) dst3_y_r, 2);", "dst2_y = (v16u8) __msa_pckev_b((v16i8) dst2_y_r, (v16i8) dst2_y_r);", "dst3_y = (v16u8) __msa_pckev_b((v16i8) dst3_y_r, (v16i8) dst3_y_r);", "dst2_x = __msa_bmnz_v(dst2_y, dst2_x, is_less_than_alpha);", "dst3_x = __msa_bmnz_v(dst3_y, dst3_x, is_less_than_alpha);", "dst2_x = __msa_bmnz_v((v16u8) src2, dst2_x, is_less_than);", "dst3_x = __msa_bmnz_v((v16u8) src3, dst3_x, is_less_than);", "is_less_than = is_less_than_alpha & is_less_than;", "dst1 = (v16u8) __msa_pckev_b((v16i8) dst1_r, (v16i8) dst1_r);", "is_less_than_beta1 = is_less_than_beta1 & is_less_than;", "dst1 = __msa_bmnz_v((v16u8) src1, dst1, is_less_than_beta1);", "dst0 = (v16u8) __msa_pckev_b((v16i8) dst0_r, (v16i8) dst0_r);", "dst0 = __msa_bmnz_v((v16u8) src0, dst0, is_less_than_beta1);", "dst4 = (v16u8) __msa_pckev_b((v16i8) dst4_r, (v16i8) dst4_r);", "is_less_than_beta2 = is_less_than_beta2 & is_less_than;", "dst4 = __msa_bmnz_v((v16u8) src4, dst4, is_less_than_beta2);", "dst5 = (v16u8) __msa_pckev_b((v16i8) dst5_r, (v16i8) dst5_r);", "dst5 = __msa_bmnz_v((v16u8) src5, dst5, is_less_than_beta2);", "dst0 = (v16u8) __msa_ilvr_b((v16i8) dst1, (v16i8) dst0);", "dst1 = (v16u8) __msa_ilvr_b((v16i8) dst3_x, (v16i8) dst2_x);", "dst2_x = (v16u8) __msa_ilvr_b((v16i8) dst5, (v16i8) dst4);", "tmp0 = __msa_ilvr_h((v8i16) dst1, (v8i16) dst0);", "tmp1 = __msa_ilvl_h((v8i16) dst1, (v8i16) dst0);", "tmp2 = __msa_ilvr_h((v8i16) zeros, (v8i16) dst2_x);", "tmp3 = __msa_ilvl_h((v8i16) zeros, (v8i16) dst2_x);", "dst0 = (v16u8) __msa_ilvr_w((v4i32) tmp2, (v4i32) tmp0);", "dst1 = (v16u8) __msa_sldi_b(zeros, (v16i8) dst0, 8);", "dst2_x = (v16u8) __msa_ilvl_w((v4i32) tmp2, (v4i32) tmp0);", "dst3_x = (v16u8) __msa_sldi_b(zeros, (v16i8) dst2_x, 8);", "dst4 = (v16u8) __msa_ilvr_w((v4i32) tmp3, (v4i32) tmp1);", "dst5 = (v16u8) __msa_sldi_b(zeros, (v16i8) dst4, 8);", "dst2_y = (v16u8) __msa_ilvl_w((v4i32) tmp3, (v4i32) tmp1);", "dst3_y = (v16u8) __msa_sldi_b(zeros, (v16i8) dst2_y, 8);", "out0 = __msa_copy_u_w((v4i32) dst0, 0);", "out1 = __msa_copy_u_h((v8i16) dst0, 2);", "out2 = __msa_copy_u_w((v4i32) dst1, 0);", "out3 = __msa_copy_u_h((v8i16) dst1, 2);", "STORE_WORD((VAR_0 - 3), out0);", "STORE_HWORD((VAR_0 + 1), out1);", "VAR_0 += VAR_1;", "STORE_WORD((VAR_0 - 3), out2);", "STORE_HWORD((VAR_0 + 1), out3);", "VAR_0 += VAR_1;", "out0 = __msa_copy_u_w((v4i32) dst2_x, 0);", "out1 = __msa_copy_u_h((v8i16) dst2_x, 2);", "out2 = __msa_copy_u_w((v4i32) dst3_x, 0);", "out3 = __msa_copy_u_h((v8i16) dst3_x, 2);", "STORE_WORD((VAR_0 - 3), out0);", "STORE_HWORD((VAR_0 + 1), out1);", "VAR_0 += VAR_1;", "STORE_WORD((VAR_0 - 3), out2);", "STORE_HWORD((VAR_0 + 1), out3);", "VAR_0 += VAR_1;", "out0 = __msa_copy_u_w((v4i32) dst4, 0);", "out1 = __msa_copy_u_h((v8i16) dst4, 2);", "out2 = __msa_copy_u_w((v4i32) dst5, 0);", "out3 = __msa_copy_u_h((v8i16) dst5, 2);", "STORE_WORD((VAR_0 - 3), out0);", "STORE_HWORD((VAR_0 + 1), out1);", "VAR_0 += VAR_1;", "STORE_WORD((VAR_0 - 3), out2);", "STORE_HWORD((VAR_0 + 1), out3);", "VAR_0 += VAR_1;", "out0 = __msa_copy_u_w((v4i32) dst2_y, 0);", "out1 = __msa_copy_u_h((v8i16) dst2_y, 2);", "out2 = __msa_copy_u_w((v4i32) dst3_y, 0);", "out3 = __msa_copy_u_h((v8i16) dst3_y, 2);", "STORE_WORD((VAR_0 - 3), out0);", "STORE_HWORD((VAR_0 + 1), out1);", "VAR_0 += VAR_1;", "STORE_WORD((VAR_0 - 3), out2);", "STORE_HWORD((VAR_0 + 1), out3);", "}" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 139 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 155 ], [ 157 ], [ 161 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 203 ], [ 207 ], [ 209 ], [ 211 ], [ 215 ], [ 217 ], [ 221 ], [ 223 ], [ 225 ], [ 229 ], [ 231 ], [ 233 ], [ 237 ], [ 239 ], [ 243 ], [ 245 ], [ 247 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 263 ], [ 265 ], [ 269 ], [ 271 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 299 ], [ 301 ], [ 305 ], [ 307 ], [ 309 ], [ 313 ], [ 315 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 361 ], [ 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 375 ], [ 377 ], [ 379 ], [ 381 ], [ 385 ], [ 387 ], [ 389 ], [ 391 ], [ 393 ], [ 395 ], [ 399 ], [ 401 ], [ 403 ], [ 405 ], [ 409 ], [ 411 ], [ 413 ], [ 415 ], [ 417 ], [ 419 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ] ]

[ "static int FUNC_0(MOVContext *VAR_0, ByteIOContext *VAR_1, MOVAtom VAR_2)\n{", "int VAR_3;", "int VAR_4;", "int VAR_5;", "int64_t disp_transform[2];", "int VAR_6[3][2];", "AVStream *st = VAR_0->fc->streams[VAR_0->fc->nb_streams-1];", "MOVStreamContext *sc = st->priv_data;", "int VAR_7 = get_byte(VAR_1);", "get_be24(VAR_1);", "if (VAR_7 == 1) {", "get_be64(VAR_1);", "get_be64(VAR_1);", "} else {", "get_be32(VAR_1);", "get_be32(VAR_1);", "}", "st->id = (int)get_be32(VAR_1);", "get_be32(VAR_1);", "(VAR_7 == 1) ? get_be64(VAR_1) : get_be32(VAR_1);", "get_be32(VAR_1);", "get_be32(VAR_1);", "get_be16(VAR_1);", "get_be16(VAR_1);", "get_be16(VAR_1);", "get_be16(VAR_1);", "for (VAR_3 = 0; VAR_3 < 3; VAR_3++) {", "VAR_6[VAR_3][0] = get_be32(VAR_1);", "VAR_6[VAR_3][1] = get_be32(VAR_1);", "get_be32(VAR_1);", "}", "VAR_4 = get_be32(VAR_1); track VAR_4", "VAR_5 = get_be32(VAR_1); track VAR_5", "sc->VAR_4 = VAR_4 >> 16;", "sc->VAR_5 = VAR_5 >> 16;", "if (VAR_4 && VAR_5 &&\n(VAR_6[0][0] != 65536 || VAR_6[0][1] ||\nVAR_6[1][0] || VAR_6[1][1] != 65536 ||\nVAR_6[2][0] || VAR_6[2][1])) {", "for (VAR_3 = 0; VAR_3 < 2; VAR_3++)", "disp_transform[VAR_3] =\n(int64_t) VAR_4 * VAR_6[0][VAR_3] +\n(int64_t) VAR_5 * VAR_6[1][VAR_3] +\n((int64_t) VAR_6[2][VAR_3] << 16);", "st->sample_aspect_ratio = av_d2q(\n((double) disp_transform[0] * VAR_5) /\n((double) disp_transform[1] * VAR_4), INT_MAX);", "}", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 113, 115, 117, 119 ], [ 121 ], [ 123, 125, 127, 129 ], [ 135, 137, 139 ], [ 141 ], [ 143 ], [ 145 ] ]

[ "static void FUNC_0(void *VAR_0)\n{", "int32_t fid;", "int64_t off;", "ssize_t err = 0;", "int32_t count = 0;", "size_t offset = 7;", "int32_t max_count;", "V9fsFidState *fidp;", "V9fsPDU *pdu = VAR_0;", "V9fsState *s = pdu->s;", "pdu_unmarshal(pdu, offset, \"dqd\", &fid, &off, &max_count);", "fidp = get_fid(pdu, fid);", "if (fidp == NULL) {", "err = -EINVAL;", "goto out_nofid;", "}", "if (fidp->fid_type == P9_FID_DIR) {", "if (off == 0) {", "v9fs_co_rewinddir(pdu, fidp);", "}", "count = v9fs_do_readdir_with_stat(pdu, fidp, max_count);", "if (count < 0) {", "err = count;", "goto out;", "}", "err = offset;", "err += pdu_marshal(pdu, offset, \"d\", count);", "err += count;", "} else if (fidp->fid_type == P9_FID_FILE) {", "int32_t cnt;", "int32_t len;", "struct iovec *VAR_1;", "struct iovec VAR_2[128];", "VAR_1 = VAR_2;", "pdu_marshal(pdu, offset + 4, \"v\", VAR_1, &cnt);", "VAR_1 = cap_sg(VAR_1, max_count, &cnt);", "do {", "if (0) {", "print_sg(VAR_1, cnt);", "}", "do {", "len = v9fs_co_preadv(pdu, fidp, VAR_1, cnt, off);", "if (len >= 0) {", "off += len;", "count += len;", "}", "} while (len == -EINTR && !pdu->cancelled);", "if (len < 0) {", "err = len;", "goto out;", "}", "VAR_1 = adjust_sg(VAR_1, len, &cnt);", "} while (count < max_count && len > 0);", "err = offset;", "err += pdu_marshal(pdu, offset, \"d\", count);", "err += count;", "} else if (fidp->fid_type == P9_FID_XATTR) {", "err = v9fs_xattr_read(s, pdu, fidp, off, max_count);", "} else {", "err = -EINVAL;", "}", "out:\nput_fid(pdu, fidp);", "out_nofid:\ntrace_v9fs_read_return(pdu->tag, pdu->id, count, err);", "complete_pdu(s, pdu, err);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 30 ], [ 32 ], [ 34 ], [ 36 ], [ 38 ], [ 40 ], [ 44 ], [ 46 ], [ 48 ], [ 50 ], [ 52 ], [ 54 ], [ 56 ], [ 58 ], [ 60 ], [ 62 ], [ 64 ], [ 66 ], [ 68 ], [ 70 ], [ 72 ], [ 74 ], [ 78 ], [ 80 ], [ 82 ], [ 84 ], [ 86 ], [ 88 ], [ 90 ], [ 94 ], [ 96 ], [ 98 ], [ 100 ], [ 102 ], [ 104 ], [ 106 ], [ 108 ], [ 112 ], [ 114 ], [ 116 ], [ 118 ], [ 120 ], [ 122 ], [ 124 ], [ 126 ], [ 128 ], [ 130 ], [ 132 ], [ 134 ], [ 136 ], [ 138, 140 ], [ 142, 144 ], [ 146 ], [ 148 ] ]

[ "int FUNC_0(QIOChannel *VAR_0,\nconst struct iovec *VAR_1,\nsize_t VAR_2,\nError **VAR_3)\n{", "int VAR_4 = -1;", "struct iovec *VAR_5 = g_new(struct iovec, VAR_2);", "struct iovec *VAR_6 = VAR_5;", "unsigned int VAR_7 = VAR_2;", "VAR_7 = iov_copy(VAR_5, VAR_7,\nVAR_1, VAR_2,\n0, iov_size(VAR_1, VAR_2));", "while (VAR_7 > 0) {", "ssize_t len;", "len = qio_channel_readv(VAR_0, VAR_5, VAR_7, VAR_3);", "if (len == QIO_CHANNEL_ERR_BLOCK) {", "if (qemu_in_coroutine()) {", "qio_channel_yield(VAR_0, G_IO_IN);", "} else {", "qio_channel_wait(VAR_0, G_IO_IN);", "}", "continue;", "} else if (len < 0) {", "goto cleanup;", "} else if (len == 0) {", "error_setg(VAR_3,\n\"Unexpected end-of-file before all bytes were read\");", "goto cleanup;", "}", "iov_discard_front(&VAR_5, &VAR_7, len);", "}", "VAR_4 = 0;", "cleanup:\ng_free(VAR_6);", "return VAR_4;", "}" ]

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

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

[ "void FUNC_0(QVirtioPCIDevice *VAR_0)\n{", "qpci_iounmap(VAR_0->pdev, VAR_0->addr);", "VAR_0->addr = NULL;", "}" ]

[ 0, 1, 1, 0 ]

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

[ "static void FUNC_0(VFIODevice *VAR_0)\n{", "int VAR_1;", "for (VAR_1 = 0; VAR_1 < ARRAY_SIZE(VAR_0->vga.region); VAR_1++) {", "while (!QLIST_EMPTY(&VAR_0->vga.region[VAR_1].quirks)) {", "VFIOQuirk *quirk = QLIST_FIRST(&VAR_0->vga.region[VAR_1].quirks);", "memory_region_del_subregion(&VAR_0->vga.region[VAR_1].mem, &quirk->mem);", "QLIST_REMOVE(quirk, next);", "g_free(quirk);", "}", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 18 ], [ 20 ], [ 22 ], [ 24 ], [ 26 ] ]

[ "int FUNC_0(V4L2m2mContext *VAR_0)\n{", "void *VAR_1 = VAR_0->avctx;", "int VAR_2;", "av_log(VAR_1, AV_LOG_DEBUG, \"%VAR_0 full reinit\\n\", VAR_0->devname);", "if (atomic_load(&VAR_0->refcount))\nwhile(sem_wait(&VAR_0->refsync) == -1 && errno == EINTR);", "ff_v4l2_m2m_codec_end(VAR_0->avctx);", "VAR_0->draining = 0;", "VAR_0->reinit = 0;", "VAR_0->fd = open(VAR_0->devname, O_RDWR | O_NONBLOCK, 0);", "if (VAR_0->fd < 0)\nreturn AVERROR(errno);", "VAR_2 = v4l2_prepare_contexts(VAR_0);", "if (VAR_2 < 0)\ngoto error;", "VAR_2 = ff_v4l2_context_get_format(&VAR_0->output);", "if (VAR_2) {", "av_log(VAR_1, AV_LOG_DEBUG, \"v4l2 output format not supported\\n\");", "goto error;", "}", "VAR_2 = ff_v4l2_context_get_format(&VAR_0->capture);", "if (VAR_2) {", "av_log(VAR_1, AV_LOG_DEBUG, \"v4l2 capture format not supported\\n\");", "goto error;", "}", "VAR_2 = ff_v4l2_context_set_format(&VAR_0->output);", "if (VAR_2) {", "av_log(VAR_1, AV_LOG_ERROR, \"can't set v4l2 output format\\n\");", "goto error;", "}", "VAR_2 = ff_v4l2_context_set_format(&VAR_0->capture);", "if (VAR_2) {", "av_log(VAR_1, AV_LOG_ERROR, \"can't to set v4l2 capture format\\n\");", "goto error;", "}", "VAR_2 = ff_v4l2_context_init(&VAR_0->output);", "if (VAR_2) {", "av_log(VAR_1, AV_LOG_ERROR, \"no v4l2 output context'VAR_0 buffers\\n\");", "goto error;", "}", "if (!av_codec_is_decoder(VAR_0->avctx->codec)) {", "VAR_2 = ff_v4l2_context_init(&VAR_0->capture);", "if (VAR_2) {", "av_log(VAR_1, AV_LOG_ERROR, \"no v4l2 capture context'VAR_0 buffers\\n\");", "goto error;", "}", "}", "return 0;", "error:\nif (close(VAR_0->fd) < 0) {", "VAR_2 = AVERROR(errno);", "av_log(VAR_1, AV_LOG_ERROR, \"error closing %VAR_0 (%VAR_0)\\n\",\nVAR_0->devname, av_err2str(AVERROR(errno)));", "}", "VAR_0->fd = -1;", "return VAR_2;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 17, 19 ], [ 25 ], [ 31 ], [ 33 ], [ 37 ], [ 39, 41 ], [ 45 ], [ 47, 49 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133 ], [ 137 ], [ 141, 143 ], [ 145 ], [ 147, 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ] ]

[ "static av_cold int FUNC_0(AVCodecContext *avctx){", "Wmv2Context * const w= avctx->priv_data;", "if(avctx->idct_algo==FF_IDCT_AUTO){", "avctx->idct_algo=FF_IDCT_WMV2;", "}", "if(ff_msmpeg4_decode_init(avctx) < 0)\nreturn -1;", "ff_wmv2_common_init(w);", "ff_intrax8_common_init(&w->x8,&w->s);", "return 0;", "}" ]

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

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

[ "static inline int FUNC_0(int VAR_0)\n{", "return ((VAR_0+1)*21845 + 10922) >> 16;", "}" ]

[ 0, 1, 0 ]

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