Datasets:

---

DetectVul

/

devign

like 4

Follow

DetectVul 2

[ "static void FUNC_0(uint64_t VAR_0)\n{", "struct VAR_1 VAR_1;", "int VAR_2;", "int VAR_3;", "bool found = false;", "bool check_devno = false;", "uint16_t dev_no = -1;", "blk_schid.one = 1;", "if (VAR_0 != -1) {", "check_devno = true;", "dev_no = VAR_0 & 0xffff;", "debug_print_int(\"device no. \", dev_no);", "blk_schid.ssid = (VAR_0 >> 16) & 0x3;", "if (blk_schid.ssid != 0) {", "debug_print_int(\"ssid \", blk_schid.ssid);", "if (enable_mss_facility() != 0) {", "virtio_panic(\"Failed to enable mss facility\\n\");", "}", "}", "}", "for (VAR_2 = 0; VAR_2 < 0x10000; VAR_2++) {", "blk_schid.sch_no = VAR_2;", "VAR_3 = stsch_err(blk_schid, &VAR_1);", "if (VAR_3 == 3) {", "break;", "}", "if (VAR_1.pmcw.dnv) {", "if (!check_devno || (VAR_1.pmcw.dev == dev_no)) {", "if (virtio_is_blk(blk_schid)) {", "found = true;", "break;", "}", "}", "}", "}", "if (!found) {", "virtio_panic(\"No virtio-blk device found!\\n\");", "}", "virtio_setup_block(blk_schid);", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 81 ], [ 83 ], [ 87 ], [ 89 ] ]

[ "void FUNC_0(MemoryRegion *VAR_0,\nconst char *VAR_1,\nuint64_t VAR_2)\n{", "memory_region_init(VAR_0, VAR_1, VAR_2);", "VAR_0->ram = true;", "VAR_0->terminates = true;", "VAR_0->destructor = memory_region_destructor_ram;", "VAR_0->ram_addr = qemu_ram_alloc(VAR_2, VAR_0);", "VAR_0->backend_registered = true;", "}" ]

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

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

[ "static uint64_t FUNC_0(void *opaque, hwaddr addr, unsigned size)\n{", "TyphoonState *s = opaque;", "uint64_t ret = 0;", "if (addr & 4) {", "return s->latch_tmp;", "}", "switch (addr) {", "case 0x0000:\nret = s->pchip.win[0].base_addr;", "break;", "case 0x0040:\nret = s->pchip.win[1].base_addr;", "break;", "case 0x0080:\nret = s->pchip.win[2].base_addr;", "break;", "case 0x00c0:\nret = s->pchip.win[3].base_addr;", "break;", "case 0x0100:\nret = s->pchip.win[0].mask;", "break;", "case 0x0140:\nret = s->pchip.win[1].mask;", "break;", "case 0x0180:\nret = s->pchip.win[2].mask;", "break;", "case 0x01c0:\nret = s->pchip.win[3].mask;", "break;", "case 0x0200:\nret = (uint64_t)s->pchip.win[0].translated_base_pfn << 10;", "break;", "case 0x0240:\nret = (uint64_t)s->pchip.win[1].translated_base_pfn << 10;", "break;", "case 0x0280:\nret = (uint64_t)s->pchip.win[2].translated_base_pfn << 10;", "break;", "case 0x02c0:\nret = (uint64_t)s->pchip.win[3].translated_base_pfn << 10;", "break;", "case 0x0300:\nret = s->pchip.ctl;", "break;", "case 0x0340:\nbreak;", "case 0x03c0:\nbreak;", "case 0x0400:\nbreak;", "case 0x0440:\nbreak;", "case 0x0480:\nbreak;", "case 0x04c0:\nbreak;", "case 0x0500:\ncase 0x0540:\ncase 0x0800:\nbreak;", "default:\ncpu_unassigned_access(current_cpu, addr, false, false, 0, size);", "return -1;", "}", "s->latch_tmp = ret >> 32;", "return ret;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21, 25 ], [ 27 ], [ 29, 33 ], [ 35 ], [ 37, 41 ], [ 43 ], [ 45, 49 ], [ 51 ], [ 55, 59 ], [ 61 ], [ 63, 67 ], [ 69 ], [ 71, 75 ], [ 77 ], [ 79, 83 ], [ 85 ], [ 89, 93 ], [ 95 ], [ 97, 101 ], [ 103 ], [ 105, 109 ], [ 111 ], [ 113, 117 ], [ 119 ], [ 123, 127 ], [ 129 ], [ 131, 135 ], [ 137, 141 ], [ 143, 147 ], [ 149, 153 ], [ 155, 159 ], [ 161, 165 ], [ 167, 169, 171, 173 ], [ 177, 179 ], [ 181 ], [ 183 ], [ 187 ], [ 189 ], [ 191 ] ]

[ "void FUNC_0(CPUX86State *VAR_0, uint32_t VAR_1)\n{", "int VAR_2;", "for (VAR_2 = 0; VAR_2 < DR7_MAX_BP; VAR_2++) {", "hw_breakpoint_remove(VAR_0, VAR_2);", "}", "VAR_0->dr[7] = VAR_1;", "for (VAR_2 = 0; VAR_2 < DR7_MAX_BP; VAR_2++) {", "hw_breakpoint_insert(VAR_0, VAR_2);", "}", "}" ]

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

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

[ "int FUNC_0(URLContext *VAR_0)\n{", "if (!VAR_0->prot->url_get_file_handle)\nreturn -1;", "return VAR_0->prot->url_get_file_handle(VAR_0);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static void FUNC_0(IDEState *VAR_0, uint8_t* VAR_1)\n{", "int VAR_2, VAR_3, VAR_4, VAR_5;", "uint64_t total_sectors = VAR_0->nb_sectors >> 2;", "int VAR_6;", "if (total_sectors == 0) {", "ide_atapi_cmd_error(VAR_0, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);", "return;", "}", "VAR_6 = ube16_to_cpu(VAR_1 + 7);", "VAR_2 = VAR_1[9] >> 6;", "VAR_3 = (VAR_1[1] >> 1) & 1;", "VAR_4 = VAR_1[6];", "switch(VAR_2) {", "case 0:\nVAR_5 = cdrom_read_toc(total_sectors, VAR_1, VAR_3, VAR_4);", "if (VAR_5 < 0)\ngoto error_cmd;", "ide_atapi_cmd_reply(VAR_0, VAR_5, VAR_6);", "break;", "case 1:\nmemset(VAR_1, 0, 12);", "VAR_1[1] = 0x0a;", "VAR_1[2] = 0x01;", "VAR_1[3] = 0x01;", "ide_atapi_cmd_reply(VAR_0, 12, VAR_6);", "break;", "case 2:\nVAR_5 = cdrom_read_toc_raw(total_sectors, VAR_1, VAR_3, VAR_4);", "if (VAR_5 < 0)\ngoto error_cmd;", "ide_atapi_cmd_reply(VAR_0, VAR_5, VAR_6);", "break;", "default:\nerror_cmd:\nide_atapi_cmd_error(VAR_0, SENSE_ILLEGAL_REQUEST,\nASC_INV_FIELD_IN_CMD_PACKET);", "}", "}" ]

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

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

[ "av_cold void FUNC_0(RV34DSPContext *c, DSPContext* dsp) {", "ff_rv34dsp_init(c, dsp);", "c->put_pixels_tab[0][ 0] = dsp->put_h264_qpel_pixels_tab[0][0];", "c->put_pixels_tab[0][ 1] = put_rv40_qpel16_mc10_c;", "c->put_pixels_tab[0][ 2] = dsp->put_h264_qpel_pixels_tab[0][2];", "c->put_pixels_tab[0][ 3] = put_rv40_qpel16_mc30_c;", "c->put_pixels_tab[0][ 4] = put_rv40_qpel16_mc01_c;", "c->put_pixels_tab[0][ 5] = put_rv40_qpel16_mc11_c;", "c->put_pixels_tab[0][ 6] = put_rv40_qpel16_mc21_c;", "c->put_pixels_tab[0][ 7] = put_rv40_qpel16_mc31_c;", "c->put_pixels_tab[0][ 8] = dsp->put_h264_qpel_pixels_tab[0][8];", "c->put_pixels_tab[0][ 9] = put_rv40_qpel16_mc12_c;", "c->put_pixels_tab[0][10] = put_rv40_qpel16_mc22_c;", "c->put_pixels_tab[0][11] = put_rv40_qpel16_mc32_c;", "c->put_pixels_tab[0][12] = put_rv40_qpel16_mc03_c;", "c->put_pixels_tab[0][13] = put_rv40_qpel16_mc13_c;", "c->put_pixels_tab[0][14] = put_rv40_qpel16_mc23_c;", "c->put_pixels_tab[0][15] = ff_put_rv40_qpel16_mc33_c;", "c->avg_pixels_tab[0][ 0] = dsp->avg_h264_qpel_pixels_tab[0][0];", "c->avg_pixels_tab[0][ 1] = avg_rv40_qpel16_mc10_c;", "c->avg_pixels_tab[0][ 2] = dsp->avg_h264_qpel_pixels_tab[0][2];", "c->avg_pixels_tab[0][ 3] = avg_rv40_qpel16_mc30_c;", "c->avg_pixels_tab[0][ 4] = avg_rv40_qpel16_mc01_c;", "c->avg_pixels_tab[0][ 5] = avg_rv40_qpel16_mc11_c;", "c->avg_pixels_tab[0][ 6] = avg_rv40_qpel16_mc21_c;", "c->avg_pixels_tab[0][ 7] = avg_rv40_qpel16_mc31_c;", "c->avg_pixels_tab[0][ 8] = dsp->avg_h264_qpel_pixels_tab[0][8];", "c->avg_pixels_tab[0][ 9] = avg_rv40_qpel16_mc12_c;", "c->avg_pixels_tab[0][10] = avg_rv40_qpel16_mc22_c;", "c->avg_pixels_tab[0][11] = avg_rv40_qpel16_mc32_c;", "c->avg_pixels_tab[0][12] = avg_rv40_qpel16_mc03_c;", "c->avg_pixels_tab[0][13] = avg_rv40_qpel16_mc13_c;", "c->avg_pixels_tab[0][14] = avg_rv40_qpel16_mc23_c;", "c->avg_pixels_tab[0][15] = ff_avg_rv40_qpel16_mc33_c;", "c->put_pixels_tab[1][ 0] = dsp->put_h264_qpel_pixels_tab[1][0];", "c->put_pixels_tab[1][ 1] = put_rv40_qpel8_mc10_c;", "c->put_pixels_tab[1][ 2] = dsp->put_h264_qpel_pixels_tab[1][2];", "c->put_pixels_tab[1][ 3] = put_rv40_qpel8_mc30_c;", "c->put_pixels_tab[1][ 4] = put_rv40_qpel8_mc01_c;", "c->put_pixels_tab[1][ 5] = put_rv40_qpel8_mc11_c;", "c->put_pixels_tab[1][ 6] = put_rv40_qpel8_mc21_c;", "c->put_pixels_tab[1][ 7] = put_rv40_qpel8_mc31_c;", "c->put_pixels_tab[1][ 8] = dsp->put_h264_qpel_pixels_tab[1][8];", "c->put_pixels_tab[1][ 9] = put_rv40_qpel8_mc12_c;", "c->put_pixels_tab[1][10] = put_rv40_qpel8_mc22_c;", "c->put_pixels_tab[1][11] = put_rv40_qpel8_mc32_c;", "c->put_pixels_tab[1][12] = put_rv40_qpel8_mc03_c;", "c->put_pixels_tab[1][13] = put_rv40_qpel8_mc13_c;", "c->put_pixels_tab[1][14] = put_rv40_qpel8_mc23_c;", "c->put_pixels_tab[1][15] = ff_put_rv40_qpel8_mc33_c;", "c->avg_pixels_tab[1][ 0] = dsp->avg_h264_qpel_pixels_tab[1][0];", "c->avg_pixels_tab[1][ 1] = avg_rv40_qpel8_mc10_c;", "c->avg_pixels_tab[1][ 2] = dsp->avg_h264_qpel_pixels_tab[1][2];", "c->avg_pixels_tab[1][ 3] = avg_rv40_qpel8_mc30_c;", "c->avg_pixels_tab[1][ 4] = avg_rv40_qpel8_mc01_c;", "c->avg_pixels_tab[1][ 5] = avg_rv40_qpel8_mc11_c;", "c->avg_pixels_tab[1][ 6] = avg_rv40_qpel8_mc21_c;", "c->avg_pixels_tab[1][ 7] = avg_rv40_qpel8_mc31_c;", "c->avg_pixels_tab[1][ 8] = dsp->avg_h264_qpel_pixels_tab[1][8];", "c->avg_pixels_tab[1][ 9] = avg_rv40_qpel8_mc12_c;", "c->avg_pixels_tab[1][10] = avg_rv40_qpel8_mc22_c;", "c->avg_pixels_tab[1][11] = avg_rv40_qpel8_mc32_c;", "c->avg_pixels_tab[1][12] = avg_rv40_qpel8_mc03_c;", "c->avg_pixels_tab[1][13] = avg_rv40_qpel8_mc13_c;", "c->avg_pixels_tab[1][14] = avg_rv40_qpel8_mc23_c;", "c->avg_pixels_tab[1][15] = ff_avg_rv40_qpel8_mc33_c;", "c->put_chroma_pixels_tab[0] = put_rv40_chroma_mc8_c;", "c->put_chroma_pixels_tab[1] = put_rv40_chroma_mc4_c;", "c->avg_chroma_pixels_tab[0] = avg_rv40_chroma_mc8_c;", "c->avg_chroma_pixels_tab[1] = avg_rv40_chroma_mc4_c;", "c->rv40_weight_pixels_tab[0][0] = rv40_weight_func_rnd_16;", "c->rv40_weight_pixels_tab[0][1] = rv40_weight_func_rnd_8;", "c->rv40_weight_pixels_tab[1][0] = rv40_weight_func_nornd_16;", "c->rv40_weight_pixels_tab[1][1] = rv40_weight_func_nornd_8;", "c->rv40_weak_loop_filter[0] = rv40_h_weak_loop_filter;", "c->rv40_weak_loop_filter[1] = rv40_v_weak_loop_filter;", "c->rv40_strong_loop_filter[0] = rv40_h_strong_loop_filter;", "c->rv40_strong_loop_filter[1] = rv40_v_strong_loop_filter;", "c->rv40_loop_filter_strength[0] = rv40_h_loop_filter_strength;", "c->rv40_loop_filter_strength[1] = rv40_v_loop_filter_strength;", "if (ARCH_X86)\nff_rv40dsp_init_x86(c, dsp);", "if (HAVE_NEON)\nff_rv40dsp_init_neon(c, dsp);", "}" ]

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

[ "static int FUNC_0(HEVCContext *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "int VAR_7, VAR_4, VAR_5 = 0;", "VAR_0->ref = NULL;", "VAR_0->eos = 0;", "VAR_0->nb_nals = 0;", "while (VAR_2 >= 4) {", "HEVCNAL *nal;", "int VAR_6 = 0;", "if (VAR_0->is_nalff) {", "int VAR_7;", "for (VAR_7 = 0; VAR_7 < VAR_0->nal_length_size; VAR_7++)", "VAR_6 = (VAR_6 << 8) | VAR_1[VAR_7];", "VAR_1 += VAR_0->nal_length_size;", "VAR_2 -= VAR_0->nal_length_size;", "if (VAR_6 > VAR_2) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Invalid NAL unit size.\\n\");", "VAR_5 = AVERROR_INVALIDDATA;", "goto fail;", "}", "} else {", "if (VAR_1[2] == 0) {", "VAR_2--;", "VAR_1++;", "continue;", "}", "if (VAR_1[0] != 0 || VAR_1[1] != 0 || VAR_1[2] != 1) {", "VAR_5 = AVERROR_INVALIDDATA;", "goto fail;", "}", "VAR_1 += 3;", "VAR_2 -= 3;", "}", "if (!VAR_0->is_nalff)\nVAR_6 = VAR_2;", "if (VAR_0->nals_allocated < VAR_0->nb_nals + 1) {", "int VAR_7 = VAR_0->nals_allocated + 1;", "HEVCNAL *tmp = av_realloc_array(VAR_0->nals, VAR_7, sizeof(*tmp));", "if (!tmp) {", "VAR_5 = AVERROR(ENOMEM);", "goto fail;", "}", "VAR_0->nals = tmp;", "memset(VAR_0->nals + VAR_0->nals_allocated, 0, (VAR_7 - VAR_0->nals_allocated) * sizeof(*tmp));", "av_reallocp_array(&VAR_0->skipped_bytes_nal, VAR_7, sizeof(*VAR_0->skipped_bytes_nal));", "av_reallocp_array(&VAR_0->skipped_bytes_pos_size_nal, VAR_7, sizeof(*VAR_0->skipped_bytes_pos_size_nal));", "av_reallocp_array(&VAR_0->skipped_bytes_pos_nal, VAR_7, sizeof(*VAR_0->skipped_bytes_pos_nal));", "VAR_0->skipped_bytes_pos_size_nal[VAR_0->nals_allocated] = 1024;", "VAR_0->skipped_bytes_pos_nal[VAR_0->nals_allocated] = av_malloc_array(VAR_0->skipped_bytes_pos_size_nal[VAR_0->nals_allocated], sizeof(*VAR_0->skipped_bytes_pos));", "VAR_0->nals_allocated = VAR_7;", "}", "VAR_0->skipped_bytes_pos_size = VAR_0->skipped_bytes_pos_size_nal[VAR_0->nb_nals];", "VAR_0->skipped_bytes_pos = VAR_0->skipped_bytes_pos_nal[VAR_0->nb_nals];", "nal = &VAR_0->nals[VAR_0->nb_nals];", "VAR_4 = extract_rbsp(VAR_0, VAR_1, VAR_6, nal);", "VAR_0->skipped_bytes_nal[VAR_0->nb_nals] = VAR_0->skipped_bytes;", "VAR_0->skipped_bytes_pos_size_nal[VAR_0->nb_nals] = VAR_0->skipped_bytes_pos_size;", "VAR_0->skipped_bytes_pos_nal[VAR_0->nb_nals++] = VAR_0->skipped_bytes_pos;", "if (VAR_4 < 0) {", "VAR_5 = VAR_4;", "goto fail;", "}", "VAR_5 = init_get_bits8(&VAR_0->HEVClc->gb, nal->data, nal->size);", "if (VAR_5 < 0)\ngoto fail;", "hls_nal_unit(VAR_0);", "if (VAR_0->nal_unit_type == NAL_EOS_NUT || VAR_0->nal_unit_type == NAL_EOB_NUT)\nVAR_0->eos = 1;", "VAR_1 += VAR_4;", "VAR_2 -= VAR_4;", "}", "for (VAR_7 = 0; VAR_7 < VAR_0->nb_nals; VAR_7++) {", "int VAR_5;", "VAR_0->skipped_bytes = VAR_0->skipped_bytes_nal[VAR_7];", "VAR_0->skipped_bytes_pos = VAR_0->skipped_bytes_pos_nal[VAR_7];", "VAR_5 = decode_nal_unit(VAR_0, VAR_0->nals[VAR_7].data, VAR_0->nals[VAR_7].size);", "if (VAR_5 < 0) {", "av_log(VAR_0->avctx, AV_LOG_WARNING, \"Error parsing NAL unit #%d.\\n\", VAR_7);", "if (VAR_0->avctx->err_recognition & AV_EF_EXPLODE)\ngoto fail;", "}", "}", "fail:\nif (VAR_0->ref && VAR_0->threads_type == FF_THREAD_FRAME)\nff_thread_report_progress(&VAR_0->ref->tf, INT_MAX, 0);", "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 ]

[ [ 1, 3 ], [ 5 ], [ 9 ], [ 11 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 83, 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155, 157 ], [ 159 ], [ 163, 165 ], [ 169 ], [ 171 ], [ 173 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 191 ], [ 193 ], [ 195, 197 ], [ 199 ], [ 201 ], [ 205, 207, 209 ], [ 213 ], [ 215 ] ]

[ "static always_inline void FUNC_0 (CPUState *env,\nTranslationBlock *tb,\nint search_pc)\n{", "DisasContext ctx, *ctxp = &ctx;", "opc_handler_t **table, *handler;", "target_ulong pc_start;", "uint16_t *gen_opc_end;", "CPUBreakpoint *bp;", "int VAR_0, VAR_1 = -1;", "int VAR_2;", "int VAR_3;", "pc_start = tb->pc;", "gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;", "ctx.nip = pc_start;", "ctx.tb = tb;", "ctx.exception = POWERPC_EXCP_NONE;", "ctx.spr_cb = env->spr_cb;", "ctx.mem_idx = env->mmu_idx;", "ctx.access_type = -1;", "ctx.le_mode = env->hflags & (1 << MSR_LE) ? 1 : 0;", "#if defined(TARGET_PPC64)\nctx.sf_mode = msr_sf;", "#endif\nctx.fpu_enabled = msr_fp;", "if ((env->flags & POWERPC_FLAG_SPE) && msr_spe)\nctx.spe_enabled = msr_spe;", "else\nctx.spe_enabled = 0;", "if ((env->flags & POWERPC_FLAG_VRE) && msr_vr)\nctx.altivec_enabled = msr_vr;", "else\nctx.altivec_enabled = 0;", "if ((env->flags & POWERPC_FLAG_SE) && msr_se)\nctx.singlestep_enabled = CPU_SINGLE_STEP;", "else\nctx.singlestep_enabled = 0;", "if ((env->flags & POWERPC_FLAG_BE) && msr_be)\nctx.singlestep_enabled |= CPU_BRANCH_STEP;", "if (unlikely(env->singlestep_enabled))\nctx.singlestep_enabled |= GDBSTUB_SINGLE_STEP;", "#if defined (DO_SINGLE_STEP) && 0\nmsr_se = 1;", "#endif\nVAR_2 = 0;", "VAR_3 = tb->cflags & CF_COUNT_MASK;", "if (VAR_3 == 0)\nVAR_3 = CF_COUNT_MASK;", "gen_icount_start();", "while (ctx.exception == POWERPC_EXCP_NONE && gen_opc_ptr < gen_opc_end) {", "if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) {", "TAILQ_FOREACH(bp, &env->breakpoints, entry) {", "if (bp->pc == ctx.nip) {", "gen_debug_exception(ctxp);", "break;", "}", "}", "}", "if (unlikely(search_pc)) {", "VAR_0 = gen_opc_ptr - gen_opc_buf;", "if (VAR_1 < VAR_0) {", "VAR_1++;", "while (VAR_1 < VAR_0)\ngen_opc_instr_start[VAR_1++] = 0;", "gen_opc_pc[VAR_1] = ctx.nip;", "gen_opc_instr_start[VAR_1] = 1;", "gen_opc_icount[VAR_1] = VAR_2;", "}", "}", "LOG_DISAS(\"----------------\\n\");", "LOG_DISAS(\"nip=\" ADDRX \" super=%d ir=%d\\n\",\nctx.nip, ctx.mem_idx, (int)msr_ir);", "if (VAR_2 + 1 == VAR_3 && (tb->cflags & CF_LAST_IO))\ngen_io_start();", "if (unlikely(ctx.le_mode)) {", "ctx.opcode = bswap32(ldl_code(ctx.nip));", "} else {", "ctx.opcode = ldl_code(ctx.nip);", "}", "LOG_DISAS(\"translate opcode %08x (%02x %02x %02x) (%s)\\n\",\nctx.opcode, opc1(ctx.opcode), opc2(ctx.opcode),\nopc3(ctx.opcode), little_endian ? \"little\" : \"big\");", "ctx.nip += 4;", "table = env->opcodes;", "VAR_2++;", "handler = table[opc1(ctx.opcode)];", "if (is_indirect_opcode(handler)) {", "table = ind_table(handler);", "handler = table[opc2(ctx.opcode)];", "if (is_indirect_opcode(handler)) {", "table = ind_table(handler);", "handler = table[opc3(ctx.opcode)];", "}", "}", "if (unlikely(handler->handler == &gen_invalid)) {", "if (qemu_log_enabled()) {", "qemu_log(\"invalid/unsupported opcode: \"\n\"%02x - %02x - %02x (%08x) \" ADDRX \" %d\\n\",\nopc1(ctx.opcode), opc2(ctx.opcode),\nopc3(ctx.opcode), ctx.opcode, ctx.nip - 4, (int)msr_ir);", "} else {", "printf(\"invalid/unsupported opcode: \"\n\"%02x - %02x - %02x (%08x) \" ADDRX \" %d\\n\",\nopc1(ctx.opcode), opc2(ctx.opcode),\nopc3(ctx.opcode), ctx.opcode, ctx.nip - 4, (int)msr_ir);", "}", "} else {", "if (unlikely((ctx.opcode & handler->inval) != 0)) {", "if (qemu_log_enabled()) {", "qemu_log(\"invalid bits: %08x for opcode: \"\n\"%02x - %02x - %02x (%08x) \" ADDRX \"\\n\",\nctx.opcode & handler->inval, opc1(ctx.opcode),\nopc2(ctx.opcode), opc3(ctx.opcode),\nctx.opcode, ctx.nip - 4);", "} else {", "printf(\"invalid bits: %08x for opcode: \"\n\"%02x - %02x - %02x (%08x) \" ADDRX \"\\n\",\nctx.opcode & handler->inval, opc1(ctx.opcode),\nopc2(ctx.opcode), opc3(ctx.opcode),\nctx.opcode, ctx.nip - 4);", "}", "gen_inval_exception(ctxp, POWERPC_EXCP_INVAL_INVAL);", "break;", "}", "}", "(*(handler->handler))(&ctx);", "#if defined(DO_PPC_STATISTICS)\nhandler->count++;", "#endif\nif (unlikely(ctx.singlestep_enabled & CPU_SINGLE_STEP &&\n(ctx.nip <= 0x100 || ctx.nip > 0xF00) &&\nctx.exception != POWERPC_SYSCALL &&\nctx.exception != POWERPC_EXCP_TRAP &&\nctx.exception != POWERPC_EXCP_BRANCH)) {", "gen_exception(ctxp, POWERPC_EXCP_TRACE);", "} else if (unlikely(((ctx.nip & (TARGET_PAGE_SIZE - 1)) == 0) ||", "(env->singlestep_enabled) ||\nVAR_2 >= VAR_3)) {", "break;", "}", "#if defined (DO_SINGLE_STEP)\nbreak;", "#endif\n}", "if (tb->cflags & CF_LAST_IO)\ngen_io_end();", "if (ctx.exception == POWERPC_EXCP_NONE) {", "gen_goto_tb(&ctx, 0, ctx.nip);", "} else if (ctx.exception != POWERPC_EXCP_BRANCH) {", "if (unlikely(env->singlestep_enabled)) {", "gen_debug_exception(ctxp);", "}", "tcg_gen_exit_tb(0);", "}", "gen_icount_end(tb, VAR_2);", "*gen_opc_ptr = INDEX_op_end;", "if (unlikely(search_pc)) {", "VAR_0 = gen_opc_ptr - gen_opc_buf;", "VAR_1++;", "while (VAR_1 <= VAR_0)\ngen_opc_instr_start[VAR_1++] = 0;", "} else {", "tb->size = ctx.nip - pc_start;", "tb->icount = VAR_2;", "}", "#if defined(DEBUG_DISAS)\nqemu_log_mask(CPU_LOG_TB_CPU, \"---------------- excp: %04x\\n\", ctx.exception);", "log_cpu_state_mask(CPU_LOG_TB_CPU, env, 0);", "if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {", "int flags;", "flags = env->bfd_mach;", "flags |= ctx.le_mode << 16;", "qemu_log(\"IN: %s\\n\", lookup_symbol(pc_start));", "log_target_disas(pc_start, ctx.nip - pc_start, flags);", "qemu_log(\"\\n\");", "}", "#endif\n}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 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, 89 ], [ 91, 93 ], [ 95 ], [ 97, 99 ], [ 103 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149, 151 ], [ 153, 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167, 169, 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 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, 271, 273, 275, 277, 279 ], [ 281 ], [ 283 ], [ 285, 287 ], [ 295 ], [ 297 ], [ 299, 301 ], [ 303, 305 ], [ 307, 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 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 ] ]

[ "static int FUNC_0 (CPUPPCState *VAR_0, target_ulong VAR_1,\ntarget_ulong *VAR_2, target_ulong *VAR_3, int *VAR_4)\n{", "target_phys_addr_t sr_base;", "target_ulong mask;", "uint64_t tmp64;", "uint32_t tmp;", "int VAR_5, VAR_6;", "int VAR_7;", "VAR_6 = -5;", "sr_base = VAR_0->spr[SPR_ASR];", "#if defined(DEBUG_SLB)\nif (loglevel != 0) {", "fprintf(logfile, \"%s: VAR_1 \" ADDRX \" base \" PADDRX \"\\VAR_5\",\n__func__, VAR_1, sr_base);", "}", "#endif\nmask = 0x0000000000000000ULL;", "VAR_7 = VAR_0->VAR_7;", "for (VAR_5 = 0; VAR_5 < VAR_7; VAR_5++) {", "tmp64 = ldq_phys(sr_base);", "tmp = ldl_phys(sr_base + 8);", "#if defined(DEBUG_SLB)\nif (loglevel != 0) {", "fprintf(logfile, \"%s: seg %d \" PADDRX \" %016\" PRIx64 \" %08\"\nPRIx32 \"\\VAR_5\", __func__, VAR_5, sr_base, tmp64, tmp);", "}", "#endif\nif (tmp64 & 0x0000000008000000ULL) {", "switch (tmp64 & 0x0000000006000000ULL) {", "case 0x0000000000000000ULL:\nmask = 0xFFFFFFFFF0000000ULL;", "break;", "case 0x0000000002000000ULL:\nmask = 0xFFFF000000000000ULL;", "break;", "case 0x0000000004000000ULL:\ncase 0x0000000006000000ULL:\ncontinue;", "}", "if ((VAR_1 & mask) == (tmp64 & mask)) {", "*VAR_2 = ((tmp64 << 24) | (tmp >> 8)) & 0x0003FFFFFFFFFFFFULL;", "*VAR_3 = ~mask;", "*VAR_4 = tmp & 0xFF;", "VAR_6 = 0;", "break;", "}", "}", "sr_base += 12;", "}", "return VAR_6;", "}" ]

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

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

[ "static const mon_cmd_t *FUNC_0(Monitor *mon,\nconst char *cmdline,\nQDict *qdict)\n{", "const char *VAR_0, *VAR_1;", "int VAR_2;", "const mon_cmd_t *VAR_3;", "char VAR_4[256];", "char VAR_5[1024];", "char *VAR_6;", "#ifdef DEBUG\nmonitor_printf(mon, \"command='%s'\\n\", cmdline);", "#endif\nVAR_0 = get_command_name(cmdline, VAR_4, sizeof(VAR_4));", "if (!VAR_0)\nreturn NULL;", "for(VAR_3 = mon_cmds; VAR_3->name != NULL; VAR_3++) {", "if (compare_cmd(VAR_4, VAR_3->name))\nbreak;", "}", "if (VAR_3->name == NULL) {", "monitor_printf(mon, \"unknown command: '%s'\\n\", VAR_4);", "return NULL;", "}", "VAR_1 = VAR_3->args_type;", "for(;;) {", "VAR_1 = key_get_info(VAR_1, &VAR_6);", "if (!VAR_1)\nbreak;", "VAR_2 = *VAR_1;", "VAR_1++;", "switch(VAR_2) {", "case 'F':\ncase 'B':\ncase 's':\n{", "int VAR_7;", "while (qemu_isspace(*VAR_0))\nVAR_0++;", "if (*VAR_1 == '?') {", "VAR_1++;", "if (*VAR_0 == '\\0') {", "break;", "}", "}", "VAR_7 = get_str(VAR_5, sizeof(VAR_5), &VAR_0);", "if (VAR_7 < 0) {", "switch(VAR_2) {", "case 'F':\nmonitor_printf(mon, \"%s: filename expected\\n\",\nVAR_4);", "break;", "case 'B':\nmonitor_printf(mon, \"%s: block device name expected\\n\",\nVAR_4);", "break;", "default:\nmonitor_printf(mon, \"%s: string expected\\n\", VAR_4);", "break;", "}", "goto fail;", "}", "qdict_put(qdict, VAR_6, qstring_from_str(VAR_5));", "}", "break;", "case '/':\n{", "int VAR_8, VAR_9, VAR_10;", "while (qemu_isspace(*VAR_0))\nVAR_0++;", "if (*VAR_0 == '/') {", "VAR_0++;", "VAR_8 = 1;", "if (qemu_isdigit(*VAR_0)) {", "VAR_8 = 0;", "while (qemu_isdigit(*VAR_0)) {", "VAR_8 = VAR_8 * 10 + (*VAR_0 - '0');", "VAR_0++;", "}", "}", "VAR_10 = -1;", "VAR_9 = -1;", "for(;;) {", "switch(*VAR_0) {", "case 'o':\ncase 'd':\ncase 'u':\ncase 'x':\ncase 'i':\ncase 'VAR_2':\nVAR_9 = *VAR_0++;", "break;", "case 'b':\nVAR_10 = 1;", "VAR_0++;", "break;", "case 'h':\nVAR_10 = 2;", "VAR_0++;", "break;", "case 'w':\nVAR_10 = 4;", "VAR_0++;", "break;", "case 'g':\ncase 'L':\nVAR_10 = 8;", "VAR_0++;", "break;", "default:\ngoto next;", "}", "}", "next:\nif (*VAR_0 != '\\0' && !qemu_isspace(*VAR_0)) {", "monitor_printf(mon, \"invalid char in VAR_9: '%VAR_2'\\n\",\n*VAR_0);", "goto fail;", "}", "if (VAR_9 < 0)\nVAR_9 = default_fmt_format;", "if (VAR_9 != 'i') {", "if (VAR_10 < 0)\nVAR_10 = default_fmt_size;", "default_fmt_size = VAR_10;", "}", "default_fmt_format = VAR_9;", "} else {", "VAR_8 = 1;", "VAR_9 = default_fmt_format;", "if (VAR_9 != 'i') {", "VAR_10 = default_fmt_size;", "} else {", "VAR_10 = -1;", "}", "}", "qdict_put(qdict, \"VAR_8\", qint_from_int(VAR_8));", "qdict_put(qdict, \"VAR_9\", qint_from_int(VAR_9));", "qdict_put(qdict, \"VAR_10\", qint_from_int(VAR_10));", "}", "break;", "case 'i':\ncase 'l':\n{", "int64_t val;", "while (qemu_isspace(*VAR_0))\nVAR_0++;", "if (*VAR_1 == '?' || *VAR_1 == '.') {", "if (*VAR_1 == '?') {", "if (*VAR_0 == '\\0') {", "VAR_1++;", "break;", "}", "} else {", "if (*VAR_0 == '.') {", "VAR_0++;", "while (qemu_isspace(*VAR_0))\nVAR_0++;", "} else {", "VAR_1++;", "break;", "}", "}", "VAR_1++;", "}", "if (get_expr(mon, &val, &VAR_0))\ngoto fail;", "if ((VAR_2 == 'i') && ((val >> 32) & 0xffffffff)) {", "monitor_printf(mon, \"\\'%s\\' has failed: \", VAR_4);", "monitor_printf(mon, \"integer is for 32-bit values\\n\");", "goto fail;", "}", "qdict_put(qdict, VAR_6, qint_from_int(val));", "}", "break;", "case '-':\n{", "const char *VAR_11 = VAR_0;", "int VAR_12, VAR_13 = 0;", "VAR_2 = *VAR_1++;", "if (VAR_2 == '\\0')\ngoto bad_type;", "while (qemu_isspace(*VAR_0))\nVAR_0++;", "VAR_12 = 0;", "if (*VAR_0 == '-') {", "VAR_0++;", "if(VAR_2 != *VAR_0) {", "if(!is_valid_option(VAR_0, VAR_1)) {", "monitor_printf(mon, \"%s: unsupported option -%VAR_2\\n\",\nVAR_4, *VAR_0);", "goto fail;", "} else {", "VAR_13 = 1;", "}", "}", "if(VAR_13) {", "VAR_0 = VAR_11;", "} else {", "VAR_0++;", "VAR_12 = 1;", "}", "}", "qdict_put(qdict, VAR_6, qint_from_int(VAR_12));", "}", "break;", "default:\nbad_type:\nmonitor_printf(mon, \"%s: unknown type '%VAR_2'\\n\", VAR_4, VAR_2);", "goto fail;", "}", "qemu_free(VAR_6);", "VAR_6 = NULL;", "}", "while (qemu_isspace(*VAR_0))\nVAR_0++;", "if (*VAR_0 != '\\0') {", "monitor_printf(mon, \"%s: extraneous characters at the end of line\\n\",\nVAR_4);", "goto fail;", "}", "return VAR_3;", "fail:\nqemu_free(VAR_6);", "return NULL;", "}" ]

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

[ [ 1, 3, 5, 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 23, 25 ], [ 27, 33 ], [ 35, 37 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 65 ], [ 67 ], [ 69 ], [ 71, 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81, 83, 85, 87 ], [ 89 ], [ 93, 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117, 119, 121 ], [ 123 ], [ 125, 127, 129 ], [ 131 ], [ 133, 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151, 153 ], [ 155 ], [ 159, 161 ], [ 163 ], [ 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 ], [ 271, 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309, 311, 313 ], [ 315 ], [ 319, 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341, 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359, 361 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 377 ], [ 379 ], [ 381, 383 ], [ 385 ], [ 387 ], [ 393 ], [ 395, 397 ], [ 399, 401 ], [ 403 ], [ 405 ], [ 407 ], [ 409 ], [ 411 ], [ 415, 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 433 ], [ 435 ], [ 437 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 447 ], [ 449, 451, 453 ], [ 455 ], [ 457 ], [ 459 ], [ 461 ], [ 463 ], [ 467, 469 ], [ 471 ], [ 473, 475 ], [ 477 ], [ 479 ], [ 483 ], [ 487, 489 ], [ 491 ], [ 493 ] ]

[ "static coroutine_fn int FUNC_0(BlockDriverState *bs, int64_t sector_num,\nint nb_sectors, QEMUIOVector *qiov)\n{", "BDRVQcowState *s = bs->opaque;", "int VAR_0;", "uint64_t cluster_offset;", "int VAR_1 = 0, VAR_2;", "struct iovec VAR_3;", "QEMUIOVector hd_qiov;", "uint8_t *buf;", "void *VAR_4;", "s->cluster_cache_offset = -1;", "if (bs->encrypted || qiov->niov > 1) {", "buf = VAR_4 = qemu_try_blockalign(bs, qiov->size);", "if (buf == NULL) {", "return -ENOMEM;", "}", "qemu_iovec_to_buf(qiov, 0, buf, qiov->size);", "} else {", "VAR_4 = NULL;", "buf = (uint8_t *)qiov->iov->iov_base;", "}", "qemu_co_mutex_lock(&s->lock);", "while (nb_sectors != 0) {", "VAR_0 = sector_num & (s->cluster_sectors - 1);", "VAR_2 = s->cluster_sectors - VAR_0;", "if (VAR_2 > nb_sectors) {", "VAR_2 = nb_sectors;", "}", "cluster_offset = get_cluster_offset(bs, sector_num << 9, 1, 0,\nVAR_0,\nVAR_0 + VAR_2);", "if (!cluster_offset || (cluster_offset & 511) != 0) {", "VAR_1 = -EIO;", "break;", "}", "if (bs->encrypted) {", "Error *err = NULL;", "assert(s->cipher);", "if (encrypt_sectors(s, sector_num, buf, VAR_2, true, &err) < 0) {", "error_free(err);", "VAR_1 = -EIO;", "break;", "}", "}", "VAR_3.iov_base = (void *)buf;", "VAR_3.iov_len = VAR_2 * 512;", "qemu_iovec_init_external(&hd_qiov, &VAR_3, 1);", "qemu_co_mutex_unlock(&s->lock);", "VAR_1 = bdrv_co_writev(bs->file,\n(cluster_offset >> 9) + VAR_0,\nVAR_2, &hd_qiov);", "qemu_co_mutex_lock(&s->lock);", "if (VAR_1 < 0) {", "break;", "}", "VAR_1 = 0;", "nb_sectors -= VAR_2;", "sector_num += VAR_2;", "buf += VAR_2 * 512;", "}", "qemu_co_mutex_unlock(&s->lock);", "qemu_vfree(VAR_4);", "return VAR_1;", "}" ]

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

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

[ "static void FUNC_0(VncState *VAR_0)\n{", "switch (VAR_0->vd->subauth) {", "case VNC_AUTH_VENCRYPT_TLSNONE:\ncase VNC_AUTH_VENCRYPT_X509NONE:\nVNC_DEBUG(\"Accept TLS auth none\\n\");", "vnc_write_u32(VAR_0, 0);", "start_client_init(VAR_0);", "break;", "case VNC_AUTH_VENCRYPT_TLSVNC:\ncase VNC_AUTH_VENCRYPT_X509VNC:\nVNC_DEBUG(\"Start TLS auth VNC\\n\");", "start_auth_vnc(VAR_0);", "break;", "#ifdef CONFIG_VNC_SASL\ncase VNC_AUTH_VENCRYPT_TLSSASL:\ncase VNC_AUTH_VENCRYPT_X509SASL:\nVNC_DEBUG(\"Start TLS auth SASL\\n\");", "return start_auth_sasl(VAR_0);", "#endif\ndefault:\nVNC_DEBUG(\"Reject subauth %d server bug\\n\", VAR_0->vd->auth);", "vnc_write_u8(VAR_0, 1);", "if (VAR_0->minor >= 8) {", "static const char VAR_1[] = \"Unsupported authentication type\";", "vnc_write_u32(VAR_0, sizeof(VAR_1));", "vnc_write(VAR_0, VAR_1, sizeof(VAR_1));", "}", "vnc_client_error(VAR_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 ], [ 33, 35, 37, 39 ], [ 41 ], [ 43, 47, 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ] ]

[ "static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1)\n{", "unsigned int VAR_2, VAR_3, VAR_4;", "uint64_t addr;", "int VAR_5;", "TCGv_i64 tcg_cmp;", "VAR_2 = (extract32(VAR_1, 31, 1) << 5) | extract32(VAR_1, 19, 5);", "VAR_3 = extract32(VAR_1, 24, 1);", "addr = VAR_0->pc + sextract32(VAR_1, 5, 14) * 4 - 4;", "VAR_4 = extract32(VAR_1, 0, 5);", "tcg_cmp = tcg_temp_new_i64();", "tcg_gen_andi_i64(tcg_cmp, cpu_reg(VAR_0, VAR_4), (1ULL << VAR_2));", "VAR_5 = gen_new_label();", "tcg_gen_brcondi_i64(VAR_3 ? TCG_COND_NE : TCG_COND_EQ,\ntcg_cmp, 0, VAR_5);", "tcg_temp_free_i64(tcg_cmp);", "gen_goto_tb(VAR_0, 0, VAR_0->pc);", "gen_set_label(VAR_5);", "gen_goto_tb(VAR_0, 1, addr);", "}" ]

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

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

[ "static QObject *FUNC_0(JSONParserContext *ctxt, QList **tokens, va_list *ap)\n{", "QObject *token = NULL, *obj;", "QList *working = qlist_copy(*tokens);", "if (ap == NULL) {", "goto out;", "}", "token = qlist_pop(working);", "if (token == NULL) {", "goto out;", "}", "if (token_is_escape(token, \"%p\")) {", "obj = va_arg(*ap, QObject *);", "} else if (token_is_escape(token, \"%i\")) {", "obj = QOBJECT(qbool_from_int(va_arg(*ap, int)));", "} else if (token_is_escape(token, \"%d\")) {", "obj = QOBJECT(qint_from_int(va_arg(*ap, int)));", "} else if (token_is_escape(token, \"%ld\")) {", "obj = QOBJECT(qint_from_int(va_arg(*ap, long)));", "} else if (token_is_escape(token, \"%lld\") ||", "token_is_escape(token, \"%I64d\")) {", "obj = QOBJECT(qint_from_int(va_arg(*ap, long long)));", "} else if (token_is_escape(token, \"%s\")) {", "obj = QOBJECT(qstring_from_str(va_arg(*ap, const char *)));", "} else if (token_is_escape(token, \"%f\")) {", "obj = QOBJECT(qfloat_from_double(va_arg(*ap, double)));", "} else {", "goto out;", "}", "qobject_decref(token);", "QDECREF(*tokens);", "*tokens = working;", "return obj;", "out:\nqobject_decref(token);", "QDECREF(working);", "return NULL;", "}" ]

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

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

[ "ParallelState *FUNC_0(target_phys_addr_t base, int it_shift, qemu_irq irq, CharDriverState *chr)\n{", "ParallelState *s;", "int VAR_0;", "s = qemu_mallocz(sizeof(ParallelState));", "s->irq = irq;", "s->chr = chr;", "s->it_shift = it_shift;", "qemu_register_reset(parallel_reset, s);", "VAR_0 = cpu_register_io_memory(parallel_mm_read_sw, parallel_mm_write_sw,\ns, DEVICE_NATIVE_ENDIAN);", "cpu_register_physical_memory(base, 8 << it_shift, VAR_0);", "return s;", "}" ]

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

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

[ "int FUNC_0( float32 VAR_0, float32 VAR_1 STATUS_PARAM )\n{", "flag aSign, bSign;", "if ( ( ( extractFloat32Exp( VAR_0 ) == 0xFF ) && extractFloat32Frac( VAR_0 ) )\n|| ( ( extractFloat32Exp( VAR_1 ) == 0xFF ) && extractFloat32Frac( VAR_1 ) )\n) {", "float_raise( float_flag_invalid STATUS_VAR);", "return 0;", "}", "aSign = extractFloat32Sign( VAR_0 );", "bSign = extractFloat32Sign( VAR_1 );", "if ( aSign != bSign ) return aSign || ( (bits32) ( ( VAR_0 | VAR_1 )<<1 ) == 0 );", "return ( VAR_0 == VAR_1 ) || ( aSign ^ ( VAR_0 < VAR_1 ) );", "}" ]

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

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

[ "static void FUNC_0(TTAContext *VAR_0, TTAFilter *VAR_1, int32_t VAR_2) {", "memset(VAR_1, 0, sizeof(TTAFilter));", "if (VAR_0->pass) {", "int VAR_3;", "for (VAR_3 = 0; VAR_3 < 8; VAR_3++)", "VAR_1->qm[VAR_3] = sign_extend(VAR_0->crc_pass[VAR_3], 8);", "}", "VAR_1->VAR_2 = VAR_2;", "VAR_1->round = shift_1[VAR_2-1];", "}" ]

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

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

[ "USBDevice *FUNC_0(const char *filename, BlockDriverState **pbs)\n{", "MSDState *s;", "BlockDriverState *bdrv;", "BlockDriver *drv = NULL;", "const char *VAR_0;", "char VAR_1[32];", "VAR_0 = strchr(filename, ':');", "if (VAR_0++) {", "const char *VAR_2;", "if (strstart(filename, \"format=\", &VAR_2)) {", "int VAR_3 = MIN(VAR_0 - VAR_2, sizeof(VAR_1));", "pstrcpy(VAR_1, VAR_3, VAR_2);", "drv = bdrv_find_format(VAR_1);", "if (!drv) {", "printf(\"invalid format %s\\n\", VAR_1);", "return NULL;", "}", "} else if (*filename != ':') {", "printf(\"unrecognized USB mass-storage option %s\\n\", filename);", "return NULL;", "}", "filename = VAR_0;", "}", "if (!*filename) {", "printf(\"block device specification needed\\n\");", "return NULL;", "}", "s = qemu_mallocz(sizeof(MSDState));", "bdrv = bdrv_new(\"usb\");", "if (bdrv_open2(bdrv, filename, 0, drv) < 0)\ngoto fail;", "s->bs = bdrv;", "*pbs = bdrv;", "s->dev.speed = USB_SPEED_FULL;", "s->dev.handle_packet = usb_generic_handle_packet;", "s->dev.handle_reset = usb_msd_handle_reset;", "s->dev.handle_control = usb_msd_handle_control;", "s->dev.handle_data = usb_msd_handle_data;", "s->dev.handle_destroy = usb_msd_handle_destroy;", "snprintf(s->dev.devname, sizeof(s->dev.devname), \"QEMU USB MSD(%.16s)\",\nfilename);", "s->scsi_dev = scsi_disk_init(bdrv, 0, usb_msd_command_complete, s);", "usb_msd_handle_reset((USBDevice *)s);", "return (USBDevice *)s;", "fail:\nqemu_free(s);", "return NULL;", "}" ]

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

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

[ "static int FUNC_0(void *VAR_0)\n{", "QEMUFileBuffered *s = VAR_0;", "int VAR_1;", "VAR_1 = qemu_file_get_error(s->file);", "if (VAR_1) {", "return VAR_1;", "}", "if (s->bytes_xfer > s->xfer_limit)\nreturn 1;", "return 0;", "}" ]

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

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

[ "static int FUNC_0(BlockDriverState *VAR_0,\nint64_t VAR_1, void **VAR_2)\n{", "BDRVQcowState *s = VAR_0->opaque;", "unsigned int VAR_3;", "int VAR_4;", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC);", "VAR_3 = VAR_1 >> s->refcount_block_bits;", "if (VAR_3 < s->refcount_table_size) {", "uint64_t refcount_block_offset =\ns->refcount_table[VAR_3] & REFT_OFFSET_MASK;", "if (refcount_block_offset) {", "if (offset_into_cluster(s, refcount_block_offset)) {", "qcow2_signal_corruption(VAR_0, true, -1, -1, \"Refblock offset %#\"\nPRIx64 \" unaligned (reftable index: \"\n\"%#x)\", refcount_block_offset,\nVAR_3);", "return -EIO;", "}", "return load_refcount_block(VAR_0, refcount_block_offset,\nVAR_2);", "}", "}", "*VAR_2 = NULL;", "VAR_4 = qcow2_cache_flush(VAR_0, s->l2_table_cache);", "if (VAR_4 < 0) {", "return VAR_4;", "}", "int64_t new_block = alloc_clusters_noref(VAR_0, s->cluster_size);", "if (new_block < 0) {", "return new_block;", "}", "#ifdef DEBUG_ALLOC2\nfprintf(stderr, \"qcow2: Allocate refcount VAR_8 %d for %\" PRIx64\n\" at %\" PRIx64 \"\\n\",\nVAR_3, VAR_1 << s->cluster_bits, new_block);", "#endif\nif (in_same_refcount_block(s, new_block, VAR_1 << s->cluster_bits)) {", "VAR_4 = qcow2_cache_get_empty(VAR_0, s->refcount_block_cache, new_block,\nVAR_2);", "if (VAR_4 < 0) {", "goto fail_block;", "}", "memset(*VAR_2, 0, s->cluster_size);", "int VAR_5 = (new_block >> s->cluster_bits) &\n(s->refcount_block_size - 1);", "s->set_refcount(*VAR_2, VAR_5, 1);", "} else {", "VAR_4 = update_refcount(VAR_0, new_block, s->cluster_size, 1, false,\nQCOW2_DISCARD_NEVER);", "if (VAR_4 < 0) {", "goto fail_block;", "}", "VAR_4 = qcow2_cache_flush(VAR_0, s->refcount_block_cache);", "if (VAR_4 < 0) {", "goto fail_block;", "}", "VAR_4 = qcow2_cache_get_empty(VAR_0, s->refcount_block_cache, new_block,\nVAR_2);", "if (VAR_4 < 0) {", "goto fail_block;", "}", "memset(*VAR_2, 0, s->cluster_size);", "}", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_WRITE);", "qcow2_cache_entry_mark_dirty(VAR_0, s->refcount_block_cache, *VAR_2);", "VAR_4 = qcow2_cache_flush(VAR_0, s->refcount_block_cache);", "if (VAR_4 < 0) {", "goto fail_block;", "}", "if (VAR_3 < s->refcount_table_size) {", "uint64_t data64 = cpu_to_be64(new_block);", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);", "VAR_4 = bdrv_pwrite_sync(VAR_0->file,\ns->refcount_table_offset + VAR_3 * sizeof(uint64_t),\n&data64, sizeof(data64));", "if (VAR_4 < 0) {", "goto fail_block;", "}", "s->refcount_table[VAR_3] = new_block;", "return -EAGAIN;", "}", "VAR_4 = qcow2_cache_put(VAR_0, s->refcount_block_cache, VAR_2);", "if (VAR_4 < 0) {", "goto fail_block;", "}", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFTABLE_GROW);", "uint64_t blocks_used = DIV_ROUND_UP(MAX(VAR_1 + 1,\n(new_block >> s->cluster_bits) + 1),\ns->refcount_block_size);", "if (blocks_used > QCOW_MAX_REFTABLE_SIZE / sizeof(uint64_t)) {", "return -EFBIG;", "}", "uint64_t table_size = next_refcount_table_size(s, blocks_used + 1);", "uint64_t last_table_size;", "uint64_t blocks_clusters;", "do {", "uint64_t table_clusters =\nsize_to_clusters(s, table_size * sizeof(uint64_t));", "blocks_clusters = 1 +\n((table_clusters + s->refcount_block_size - 1)\n/ s->refcount_block_size);", "uint64_t meta_clusters = table_clusters + blocks_clusters;", "last_table_size = table_size;", "table_size = next_refcount_table_size(s, blocks_used +\n((meta_clusters + s->refcount_block_size - 1)\n/ s->refcount_block_size));", "} while (last_table_size != table_size);", "#ifdef DEBUG_ALLOC2\nfprintf(stderr, \"qcow2: Grow refcount table %\" PRId32 \" => %\" PRId64 \"\\n\",\ns->refcount_table_size, table_size);", "#endif\nuint64_t meta_offset = (blocks_used * s->refcount_block_size) *\ns->cluster_size;", "uint64_t table_offset = meta_offset + blocks_clusters * s->cluster_size;", "uint64_t *new_table = g_try_new0(uint64_t, table_size);", "void *VAR_6 = g_try_malloc0(blocks_clusters * s->cluster_size);", "assert(table_size > 0 && blocks_clusters > 0);", "if (new_table == NULL || VAR_6 == NULL) {", "VAR_4 = -ENOMEM;", "goto fail_table;", "}", "memcpy(new_table, s->refcount_table,\ns->refcount_table_size * sizeof(uint64_t));", "new_table[VAR_3] = new_block;", "int VAR_7;", "for (VAR_7 = 0; VAR_7 < blocks_clusters; VAR_7++) {", "new_table[blocks_used + VAR_7] = meta_offset + (VAR_7 * s->cluster_size);", "}", "uint64_t table_clusters = size_to_clusters(s, table_size * sizeof(uint64_t));", "int VAR_8 = 0;", "for (VAR_7 = 0; VAR_7 < table_clusters + blocks_clusters; VAR_7++) {", "s->set_refcount(VAR_6, VAR_8++, 1);", "}", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);", "VAR_4 = bdrv_pwrite_sync(VAR_0->file, meta_offset, VAR_6,\nblocks_clusters * s->cluster_size);", "g_free(VAR_6);", "VAR_6 = NULL;", "if (VAR_4 < 0) {", "goto fail_table;", "}", "for(VAR_7 = 0; VAR_7 < table_size; VAR_7++) {", "cpu_to_be64s(&new_table[VAR_7]);", "}", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);", "VAR_4 = bdrv_pwrite_sync(VAR_0->file, table_offset, new_table,\ntable_size * sizeof(uint64_t));", "if (VAR_4 < 0) {", "goto fail_table;", "}", "for(VAR_7 = 0; VAR_7 < table_size; VAR_7++) {", "be64_to_cpus(&new_table[VAR_7]);", "}", "uint8_t data[12];", "cpu_to_be64w((uint64_t*)data, table_offset);", "cpu_to_be32w((uint32_t*)(data + 8), table_clusters);", "BLKDBG_EVENT(VAR_0->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);", "VAR_4 = bdrv_pwrite_sync(VAR_0->file, offsetof(QCowHeader, refcount_table_offset),\ndata, sizeof(data));", "if (VAR_4 < 0) {", "goto fail_table;", "}", "uint64_t old_table_offset = s->refcount_table_offset;", "uint64_t old_table_size = s->refcount_table_size;", "g_free(s->refcount_table);", "s->refcount_table = new_table;", "s->refcount_table_size = table_size;", "s->refcount_table_offset = table_offset;", "qcow2_free_clusters(VAR_0, old_table_offset, old_table_size * sizeof(uint64_t),\nQCOW2_DISCARD_OTHER);", "VAR_4 = load_refcount_block(VAR_0, new_block, VAR_2);", "if (VAR_4 < 0) {", "return VAR_4;", "}", "return -EAGAIN;", "fail_table:\ng_free(VAR_6);", "g_free(new_table);", "fail_block:\nif (*VAR_2 != NULL) {", "qcow2_cache_put(VAR_0, s->refcount_block_cache, VAR_2);", "}", "return VAR_4;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 21 ], [ 25 ], [ 29, 31 ], [ 37 ], [ 39 ], [ 41, 43, 45, 47 ], [ 49 ], [ 51 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 111 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139, 141, 143, 145 ], [ 147, 151 ], [ 155, 157 ], [ 159 ], [ 161 ], [ 163 ], [ 167 ], [ 173, 175 ], [ 177 ], [ 179 ], [ 185, 187 ], [ 189 ], [ 191 ], [ 193 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 247 ], [ 249 ], [ 251 ], [ 253, 255, 257 ], [ 259 ], [ 261 ], [ 263 ], [ 267 ], [ 275 ], [ 277 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 313 ], [ 339, 341, 343 ], [ 347 ], [ 349 ], [ 351 ], [ 357 ], [ 359 ], [ 361 ], [ 363 ], [ 365, 367 ], [ 369, 371, 373 ], [ 375 ], [ 379 ], [ 381, 383, 385 ], [ 389 ], [ 393, 395, 397 ], [ 399, 405, 407 ], [ 409 ], [ 411 ], [ 413 ], [ 417 ], [ 419 ], [ 421 ], [ 423 ], [ 425 ], [ 431, 433 ], [ 435 ], [ 439 ], [ 441 ], [ 443 ], [ 445 ], [ 451 ], [ 453 ], [ 455 ], [ 457 ], [ 459 ], [ 465 ], [ 467, 469 ], [ 471 ], [ 473 ], [ 475 ], [ 477 ], [ 479 ], [ 485 ], [ 487 ], [ 489 ], [ 493 ], [ 495, 497 ], [ 499 ], [ 501 ], [ 503 ], [ 507 ], [ 509 ], [ 511 ], [ 517 ], [ 519 ], [ 521 ], [ 523 ], [ 525, 527 ], [ 529 ], [ 531 ], [ 533 ], [ 539 ], [ 541 ], [ 545 ], [ 547 ], [ 549 ], [ 551 ], [ 557, 559 ], [ 563 ], [ 565 ], [ 567 ], [ 569 ], [ 579 ], [ 583, 585 ], [ 587 ], [ 589, 591 ], [ 593 ], [ 595 ], [ 597 ], [ 599 ] ]

[ "static inline int FUNC_0(MpegEncContext *VAR_0, int VAR_1, int VAR_2, int VAR_3,\nint VAR_4, int VAR_5,\nint16_t **VAR_6, int *VAR_7)\n{", "int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;", "int16_t *dc_val;", "int VAR_13 = VAR_0->mb_x + VAR_0->mb_y * VAR_0->mb_stride;", "int VAR_14, VAR_15 = 0;", "VAR_11 = VAR_0->block_wrap[VAR_3];", "dc_val = VAR_0->dc_val[0] + VAR_0->block_index[VAR_3];", "VAR_10 = dc_val[ - 1];", "VAR_9 = dc_val[ - 1 - VAR_11];", "VAR_8 = dc_val[ - VAR_11];", "VAR_14 = VAR_0->current_picture.f.qscale_table[VAR_13];", "if (VAR_5 && (VAR_3 != 1 && VAR_3 != 3)) {", "VAR_15 = VAR_0->current_picture.f.qscale_table[VAR_13 - 1];", "if (VAR_15 && VAR_15 != VAR_14)\nVAR_10 = (VAR_10 * VAR_0->y_dc_scale_table[VAR_15] * ff_vc1_dqscale[VAR_0->y_dc_scale_table[VAR_14] - 1] + 0x20000) >> 18;", "}", "if (VAR_4 && (VAR_3 != 2 && VAR_3 != 3)) {", "VAR_15 = VAR_0->current_picture.f.qscale_table[VAR_13 - VAR_0->mb_stride];", "if (VAR_15 && VAR_15 != VAR_14)\nVAR_8 = (VAR_8 * VAR_0->y_dc_scale_table[VAR_15] * ff_vc1_dqscale[VAR_0->y_dc_scale_table[VAR_14] - 1] + 0x20000) >> 18;", "}", "if (VAR_4 && VAR_5 && (VAR_3 != 3)) {", "int VAR_16 = VAR_13;", "if (VAR_3 != 1)\nVAR_16--;", "if (VAR_3 != 2)\nVAR_16 -= VAR_0->mb_stride;", "VAR_15 = VAR_0->current_picture.f.qscale_table[VAR_16];", "if (VAR_15 && VAR_15 != VAR_14)\nVAR_9 = (VAR_9 * VAR_0->y_dc_scale_table[VAR_15] * ff_vc1_dqscale[VAR_0->y_dc_scale_table[VAR_14] - 1] + 0x20000) >> 18;", "}", "if (VAR_4 && VAR_5) {", "if (abs(VAR_8 - VAR_9) <= abs(VAR_9 - VAR_10)) {", "VAR_12 = VAR_10;", "*VAR_7 = 1;", "} else {", "VAR_12 = VAR_8;", "*VAR_7 = 0;", "}", "} else if (VAR_4) {", "VAR_12 = VAR_8;", "*VAR_7 = 0;", "} else if (VAR_5) {", "VAR_12 = VAR_10;", "*VAR_7 = 1;", "} else {", "VAR_12 = 0;", "*VAR_7 = 1;", "}", "*VAR_6 = &dc_val[0];", "return VAR_12;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65, 67 ], [ 69, 71 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 123 ], [ 125 ], [ 127 ] ]

[ "static void FUNC_0(BlkTransactionState *VAR_0,\nError **VAR_1)\n{", "BlockDriver *drv;", "int VAR_2, VAR_3;", "QDict *options = NULL;", "Error *local_err = NULL;", "bool has_device = false;", "const char *VAR_4;", "bool has_node_name = false;", "const char *VAR_5;", "bool has_snapshot_node_name = false;", "const char *VAR_6;", "const char *VAR_7;", "const char *VAR_8 = \"qcow2\";", "enum NewImageMode VAR_9 = NEW_IMAGE_MODE_ABSOLUTE_PATHS;", "ExternalSnapshotState *state =\nDO_UPCAST(ExternalSnapshotState, VAR_0, VAR_0);", "TransactionAction *action = VAR_0->action;", "g_assert(action->kind == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC);", "has_device = action->blockdev_snapshot_sync->has_device;", "VAR_4 = action->blockdev_snapshot_sync->VAR_4;", "has_node_name = action->blockdev_snapshot_sync->has_node_name;", "VAR_5 = action->blockdev_snapshot_sync->VAR_5;", "has_snapshot_node_name =\naction->blockdev_snapshot_sync->has_snapshot_node_name;", "VAR_6 = action->blockdev_snapshot_sync->VAR_6;", "VAR_7 = action->blockdev_snapshot_sync->snapshot_file;", "if (action->blockdev_snapshot_sync->has_format) {", "VAR_8 = action->blockdev_snapshot_sync->VAR_8;", "}", "if (action->blockdev_snapshot_sync->has_mode) {", "VAR_9 = action->blockdev_snapshot_sync->VAR_9;", "}", "drv = bdrv_find_format(VAR_8);", "if (!drv) {", "error_set(VAR_1, QERR_INVALID_BLOCK_FORMAT, VAR_8);", "return;", "}", "state->old_bs = bdrv_lookup_bs(has_device ? VAR_4 : NULL,\nhas_node_name ? VAR_5 : NULL,\n&local_err);", "if (error_is_set(&local_err)) {", "error_propagate(VAR_1, local_err);", "return;", "}", "if (has_node_name && !has_snapshot_node_name) {", "error_setg(VAR_1, \"New snapshot node name missing\");", "return;", "}", "if (has_snapshot_node_name && bdrv_find_node(VAR_6)) {", "error_setg(VAR_1, \"New snapshot node name already existing\");", "return;", "}", "if (!bdrv_is_inserted(state->old_bs)) {", "error_set(VAR_1, QERR_DEVICE_HAS_NO_MEDIUM, VAR_4);", "return;", "}", "if (bdrv_in_use(state->old_bs)) {", "error_set(VAR_1, QERR_DEVICE_IN_USE, VAR_4);", "return;", "}", "if (!bdrv_is_read_only(state->old_bs)) {", "if (bdrv_flush(state->old_bs)) {", "error_set(VAR_1, QERR_IO_ERROR);", "return;", "}", "}", "if (!bdrv_is_first_non_filter(state->old_bs)) {", "error_set(VAR_1, QERR_FEATURE_DISABLED, \"snapshot\");", "return;", "}", "VAR_2 = state->old_bs->open_flags;", "if (VAR_9 != NEW_IMAGE_MODE_EXISTING) {", "bdrv_img_create(VAR_7, VAR_8,\nstate->old_bs->filename,\nstate->old_bs->drv->format_name,\nNULL, -1, VAR_2, &local_err, false);", "if (error_is_set(&local_err)) {", "error_propagate(VAR_1, local_err);", "return;", "}", "}", "if (has_snapshot_node_name) {", "options = qdict_new();", "qdict_put(options, \"node-name\",\nqstring_from_str(VAR_6));", "}", "state->new_bs = bdrv_new(\"\");", "VAR_3 = bdrv_open(state->new_bs, VAR_7, options,\nVAR_2 | BDRV_O_NO_BACKING, drv, &local_err);", "if (VAR_3 != 0) {", "error_propagate(VAR_1, local_err);", "}", "QDECREF(options);", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33, 35 ], [ 37 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55, 57 ], [ 59 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93, 95, 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 133 ], [ 135 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 173 ], [ 179 ], [ 181, 183, 185, 187 ], [ 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 201 ], [ 203 ], [ 205, 207 ], [ 209 ], [ 215 ], [ 221, 223 ], [ 225 ], [ 227 ], [ 229 ], [ 233 ], [ 235 ] ]

[ "int FUNC_0(AVIOContext *VAR_0, int VAR_1, char *VAR_2, int VAR_3)\n{", "int VAR_4;", "VAR_3 = FFMIN(VAR_3 - 1, VAR_1);", "for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++)", "if (!(VAR_2[VAR_4] = avio_r8(VAR_0)))\nreturn VAR_4 + 1;", "if (VAR_3)\nVAR_2[VAR_4] = 0;", "for (; VAR_4 < VAR_1; VAR_4++)", "if (!avio_r8(VAR_0))\nreturn VAR_4 + 1;", "return VAR_1;", "}" ]

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

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

[ "static int FUNC_0(swScale)(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,\nint srcSliceH, uint8_t* dst[], int dstStride[])\n{", "const int VAR_0= c->VAR_0;", "const int VAR_1= c->VAR_1;", "const int VAR_2= c->VAR_2;", "const int VAR_3= c->VAR_3;", "const int VAR_4= c->VAR_4;", "const int VAR_5= c->VAR_5;", "const int VAR_6= c->VAR_6;", "const enum PixelFormat VAR_7= c->VAR_7;", "const int VAR_8= c->VAR_8;", "int16_t *vLumFilterPos= c->vLumFilterPos;", "int16_t *vChrFilterPos= c->vChrFilterPos;", "int16_t *hLumFilterPos= c->hLumFilterPos;", "int16_t *hChrFilterPos= c->hChrFilterPos;", "int16_t *vLumFilter= c->vLumFilter;", "int16_t *vChrFilter= c->vChrFilter;", "int16_t *hLumFilter= c->hLumFilter;", "int16_t *hChrFilter= c->hChrFilter;", "int32_t *lumMmxFilter= c->lumMmxFilter;", "int32_t *chrMmxFilter= c->chrMmxFilter;", "int32_t av_unused *alpMmxFilter= c->alpMmxFilter;", "const int VAR_9= c->VAR_9;", "const int VAR_10= c->VAR_10;", "const int VAR_11= c->VAR_11;", "const int VAR_12= c->VAR_12;", "int16_t **lumPixBuf= c->lumPixBuf;", "int16_t **chrPixBuf= c->chrPixBuf;", "int16_t **alpPixBuf= c->alpPixBuf;", "const int VAR_13= c->VAR_13;", "const int VAR_14= c->VAR_14;", "uint8_t *formatConvBuffer= c->formatConvBuffer;", "const int VAR_15= srcSliceY >> c->chrSrcVSubSample;", "const int VAR_16= -((-srcSliceH) >> c->chrSrcVSubSample);", "int VAR_17;", "uint32_t *pal=c->pal_yuv;", "int VAR_18= c->VAR_18;", "int VAR_19= c->VAR_19;", "int VAR_20= c->VAR_20;", "int VAR_21= c->VAR_21;", "int VAR_22= c->VAR_22;", "if (isPacked(c->srcFormat)) {", "src[0]=\nsrc[1]=\nsrc[2]=\nsrc[3]= src[0];", "srcStride[0]=\nsrcStride[1]=\nsrcStride[2]=\nsrcStride[3]= srcStride[0];", "}", "srcStride[1]<<= c->vChrDrop;", "srcStride[2]<<= c->vChrDrop;", "DEBUG_BUFFERS(\"swScale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\\n\",\nsrc[0], srcStride[0], src[1], srcStride[1], src[2], srcStride[2], src[3], srcStride[3],\ndst[0], dstStride[0], dst[1], dstStride[1], dst[2], dstStride[2], dst[3], dstStride[3]);", "DEBUG_BUFFERS(\"srcSliceY: %d srcSliceH: %d VAR_18: %d VAR_2: %d\\n\",\nsrcSliceY, srcSliceH, VAR_18, VAR_2);", "DEBUG_BUFFERS(\"VAR_9: %d VAR_13: %d VAR_10: %d VAR_14: %d\\n\",\nVAR_9, VAR_13, VAR_10, VAR_14);", "if (dstStride[0]%8 !=0 || dstStride[1]%8 !=0 || dstStride[2]%8 !=0 || dstStride[3]%8 != 0) {", "static int VAR_23=0;", "if (VAR_8 & SWS_PRINT_INFO && !VAR_23) {", "av_log(c, AV_LOG_WARNING, \"Warning: dstStride is not aligned!\\n\"\n\" ->cannot do aligned memory accesses anymore\\n\");", "VAR_23=1;", "}", "}", "if (srcSliceY ==0) {", "VAR_19=-1;", "VAR_20=-1;", "VAR_18=0;", "VAR_21= -1;", "VAR_22= -1;", "}", "VAR_17= VAR_18;", "for (;VAR_18 < VAR_2; VAR_18++) {", "unsigned char *VAR_24 =dst[0]+dstStride[0]*VAR_18;", "const int VAR_25= VAR_18>>c->chrDstVSubSample;", "unsigned char *VAR_26=dst[1]+dstStride[1]*VAR_25;", "unsigned char *VAR_27=dst[2]+dstStride[2]*VAR_25;", "unsigned char *VAR_28=(CONFIG_SWSCALE_ALPHA && alpPixBuf) ? dst[3]+dstStride[3]*VAR_18 : NULL;", "const int VAR_29= vLumFilterPos[VAR_18];", "const int VAR_30= vLumFilterPos[FFMIN(VAR_18 | ((1<<c->chrDstVSubSample) - 1), VAR_2-1)];", "const int VAR_31= vChrFilterPos[VAR_25];", "int VAR_32= VAR_29 + VAR_9 -1;", "int VAR_33=VAR_30+ VAR_9 -1;", "int VAR_34= VAR_31 + VAR_10 -1;", "int VAR_35;", "if (VAR_29 > VAR_21) VAR_21= VAR_29-1;", "if (VAR_31 > VAR_22) VAR_22= VAR_31-1;", "assert(VAR_29 >= VAR_21 - VAR_13 + 1);", "assert(VAR_31 >= VAR_22 - VAR_14 + 1);", "DEBUG_BUFFERS(\"VAR_18: %d\\n\", VAR_18);", "DEBUG_BUFFERS(\"\\tfirstLumSrcY: %d VAR_32: %d VAR_21: %d\\n\",\nVAR_29, VAR_32, VAR_21);", "DEBUG_BUFFERS(\"\\tfirstChrSrcY: %d VAR_34: %d VAR_22: %d\\n\",\nVAR_31, VAR_34, VAR_22);", "VAR_35 = VAR_33 < srcSliceY + srcSliceH && VAR_34 < -((-srcSliceY - srcSliceH)>>c->chrSrcVSubSample);", "if (!VAR_35) {", "VAR_32 = srcSliceY + srcSliceH - 1;", "VAR_34 = VAR_15 + VAR_16 - 1;", "DEBUG_BUFFERS(\"buffering slice: VAR_32 %d VAR_34 %d\\n\",\nVAR_32, VAR_34);", "}", "while(VAR_21 < VAR_32) {", "const uint8_t *VAR_38= src[0]+(VAR_21 + 1 - srcSliceY)*srcStride[0];", "const uint8_t *VAR_38= src[3]+(VAR_21 + 1 - srcSliceY)*srcStride[3];", "VAR_19++;", "assert(VAR_19 < 2*VAR_13);", "assert(VAR_21 + 1 - srcSliceY < srcSliceH);", "assert(VAR_21 + 1 - srcSliceY >= 0);", "FUNC_0(hyscale)(c, lumPixBuf[ VAR_19 ], VAR_1, VAR_38, VAR_0, VAR_5,\nhLumFilter, hLumFilterPos, VAR_11,\nformatConvBuffer,\npal, 0);", "if (CONFIG_SWSCALE_ALPHA && alpPixBuf)\nFUNC_0(hyscale)(c, alpPixBuf[ VAR_19 ], VAR_1, VAR_38, VAR_0, VAR_5,\nhLumFilter, hLumFilterPos, VAR_11,\nformatConvBuffer,\npal, 1);", "VAR_21++;", "DEBUG_BUFFERS(\"\\t\\tlumBufIndex %d: VAR_21: %d\\n\",\nVAR_19, VAR_21);", "}", "while(VAR_22 < VAR_34) {", "const uint8_t *VAR_38= src[1]+(VAR_22 + 1 - VAR_15)*srcStride[1];", "const uint8_t *VAR_38= src[2]+(VAR_22 + 1 - VAR_15)*srcStride[2];", "VAR_20++;", "assert(VAR_20 < 2*VAR_14);", "assert(VAR_22 + 1 - VAR_15 < (VAR_16));", "assert(VAR_22 + 1 - VAR_15 >= 0);", "if (c->needs_hcscale)\nFUNC_0(hcscale)(c, chrPixBuf[ VAR_20 ], VAR_3, VAR_38, VAR_38, VAR_4, VAR_6,\nhChrFilter, hChrFilterPos, VAR_12,\nformatConvBuffer,\npal);", "VAR_22++;", "DEBUG_BUFFERS(\"\\t\\tchrBufIndex %d: VAR_22: %d\\n\",\nVAR_20, VAR_22);", "}", "if (VAR_19 >= VAR_13) VAR_19-= VAR_13;", "if (VAR_20 >= VAR_14) VAR_20-= VAR_14;", "if (!VAR_35)\nbreak;", "#if COMPILE_TEMPLATE_MMX\nc->blueDither= ff_dither8[VAR_18&1];", "if (c->VAR_7 == PIX_FMT_RGB555 || c->VAR_7 == PIX_FMT_BGR555)\nc->greenDither= ff_dither8[VAR_18&1];", "else\nc->greenDither= ff_dither4[VAR_18&1];", "c->redDither= ff_dither8[(VAR_18+1)&1];", "#endif\nif (VAR_18 < VAR_2-2) {", "const int16_t **VAR_47= (const int16_t **) lumPixBuf + VAR_19 + VAR_29 - VAR_21 + VAR_13;", "const int16_t **VAR_47= (const int16_t **) chrPixBuf + VAR_20 + VAR_31 - VAR_22 + VAR_14;", "const int16_t **VAR_47= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **) alpPixBuf + VAR_19 + VAR_29 - VAR_21 + VAR_13 : NULL;", "#if COMPILE_TEMPLATE_MMX\nint i;", "if (VAR_8 & SWS_ACCURATE_RND) {", "int s= APCK_SIZE / 8;", "for (i=0; i<VAR_9; i+=2) {", "*(const void**)&lumMmxFilter[s*i ]= VAR_47[i ];", "*(const void**)&lumMmxFilter[s*i+APCK_PTR2/4 ]= VAR_47[i+(VAR_9>1)];", "lumMmxFilter[s*i+APCK_COEF/4 ]=\nlumMmxFilter[s*i+APCK_COEF/4+1]= vLumFilter[VAR_18*VAR_9 + i ]\n+ (VAR_9>1 ? vLumFilter[VAR_18*VAR_9 + i + 1]<<16 : 0);", "if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {", "*(const void**)&alpMmxFilter[s*i ]= VAR_47[i ];", "*(const void**)&alpMmxFilter[s*i+APCK_PTR2/4 ]= VAR_47[i+(VAR_9>1)];", "alpMmxFilter[s*i+APCK_COEF/4 ]=\nalpMmxFilter[s*i+APCK_COEF/4+1]= lumMmxFilter[s*i+APCK_COEF/4 ];", "}", "}", "for (i=0; i<VAR_10; i+=2) {", "*(const void**)&chrMmxFilter[s*i ]= VAR_47[i ];", "*(const void**)&chrMmxFilter[s*i+APCK_PTR2/4 ]= VAR_47[i+(VAR_10>1)];", "chrMmxFilter[s*i+APCK_COEF/4 ]=\nchrMmxFilter[s*i+APCK_COEF/4+1]= vChrFilter[VAR_25*VAR_10 + i ]\n+ (VAR_10>1 ? vChrFilter[VAR_25*VAR_10 + i + 1]<<16 : 0);", "}", "} else {", "for (i=0; i<VAR_9; i++) {", "lumMmxFilter[4*i+0]= (int32_t)VAR_47[i];", "lumMmxFilter[4*i+1]= (uint64_t)VAR_47[i] >> 32;", "lumMmxFilter[4*i+2]=\nlumMmxFilter[4*i+3]=\n((uint16_t)vLumFilter[VAR_18*VAR_9 + i])*0x10001;", "if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {", "alpMmxFilter[4*i+0]= (int32_t)VAR_47[i];", "alpMmxFilter[4*i+1]= (uint64_t)VAR_47[i] >> 32;", "alpMmxFilter[4*i+2]=\nalpMmxFilter[4*i+3]= lumMmxFilter[4*i+2];", "}", "}", "for (i=0; i<VAR_10; i++) {", "chrMmxFilter[4*i+0]= (int32_t)VAR_47[i];", "chrMmxFilter[4*i+1]= (uint64_t)VAR_47[i] >> 32;", "chrMmxFilter[4*i+2]=\nchrMmxFilter[4*i+3]=\n((uint16_t)vChrFilter[VAR_25*VAR_10 + i])*0x10001;", "}", "}", "#endif\nif (VAR_7 == PIX_FMT_NV12 || VAR_7 == PIX_FMT_NV21) {", "const int VAR_47= (1<<c->chrDstVSubSample)-1;", "if (VAR_18&VAR_47) VAR_26= NULL;", "c->yuv2nv12X(c,\nvLumFilter+VAR_18*VAR_9 , VAR_47, VAR_9,\nvChrFilter+VAR_25*VAR_10, VAR_47, VAR_10,\nVAR_24, VAR_26, VAR_1, VAR_3, VAR_7);", "} else if (isPlanarYUV(VAR_7) || VAR_7==PIX_FMT_GRAY8) {", "const int VAR_47= (1<<c->chrDstVSubSample)-1;", "if ((VAR_18&VAR_47) || isGray(VAR_7)) VAR_26=VAR_27= NULL;", "if (is16BPS(VAR_7) || isNBPS(VAR_7)) {", "yuv2yuvX16inC(\nvLumFilter+VAR_18*VAR_9 , VAR_47, VAR_9,\nvChrFilter+VAR_25*VAR_10, VAR_47, VAR_10,\nVAR_47, (uint16_t *) VAR_24, (uint16_t *) VAR_26, (uint16_t *) VAR_27, (uint16_t *) VAR_28, VAR_1, VAR_3,\nVAR_7);", "} else if (VAR_9 == 1 && VAR_10 == 1) {", "const int16_t *VAR_42 = VAR_47[0];", "const int16_t *VAR_43= VAR_47[0];", "const int16_t *VAR_44= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? VAR_47[0] : NULL;", "c->yuv2yuv1(c, VAR_42, VAR_43, VAR_44, VAR_24, VAR_26, VAR_27, VAR_28, VAR_1, VAR_3);", "} else {", "c->yuv2yuvX(c,\nvLumFilter+VAR_18*VAR_9 , VAR_47, VAR_9,\nvChrFilter+VAR_25*VAR_10, VAR_47, VAR_10,\nVAR_47, VAR_24, VAR_26, VAR_27, VAR_28, VAR_1, VAR_3);", "}", "} else {", "assert(VAR_47 + VAR_9 - 1 < lumPixBuf + VAR_13*2);", "assert(VAR_47 + VAR_10 - 1 < chrPixBuf + VAR_14*2);", "if (VAR_9 == 1 && VAR_10 == 2) {", "int VAR_47= vChrFilter[2*VAR_18+1];", "if(VAR_8 & SWS_FULL_CHR_H_INT) {", "yuv2rgbXinC_full(c,\nvLumFilter+VAR_18*VAR_9, VAR_47, VAR_9,\nvChrFilter+VAR_18*VAR_10, VAR_47, VAR_10,\nVAR_47, VAR_24, VAR_1, VAR_18);", "} else {", "c->yuv2packed1(c, *VAR_47, *VAR_47, *(VAR_47+1),\nalpPixBuf ? *VAR_47 : NULL,\nVAR_24, VAR_1, VAR_47, VAR_7, VAR_8, VAR_18);", "}", "} else if (VAR_9 == 2 && VAR_10 == 2) {", "int VAR_46= vLumFilter[2*VAR_18+1];", "int VAR_47= vChrFilter[2*VAR_18+1];", "lumMmxFilter[2]=\nlumMmxFilter[3]= vLumFilter[2*VAR_18 ]*0x10001;", "chrMmxFilter[2]=\nchrMmxFilter[3]= vChrFilter[2*VAR_25]*0x10001;", "if(VAR_8 & SWS_FULL_CHR_H_INT) {", "yuv2rgbXinC_full(c,\nvLumFilter+VAR_18*VAR_9, VAR_47, VAR_9,\nvChrFilter+VAR_18*VAR_10, VAR_47, VAR_10,\nVAR_47, VAR_24, VAR_1, VAR_18);", "} else {", "c->yuv2packed2(c, *VAR_47, *(VAR_47+1), *VAR_47, *(VAR_47+1),\nalpPixBuf ? *VAR_47 : NULL, alpPixBuf ? *(VAR_47+1) : NULL,\nVAR_24, VAR_1, VAR_46, VAR_47, VAR_18);", "}", "} else {", "if(VAR_8 & SWS_FULL_CHR_H_INT) {", "yuv2rgbXinC_full(c,\nvLumFilter+VAR_18*VAR_9, VAR_47, VAR_9,\nvChrFilter+VAR_18*VAR_10, VAR_47, VAR_10,\nVAR_47, VAR_24, VAR_1, VAR_18);", "} else {", "c->yuv2packedX(c,\nvLumFilter+VAR_18*VAR_9, VAR_47, VAR_9,\nvChrFilter+VAR_18*VAR_10, VAR_47, VAR_10,\nVAR_47, VAR_24, VAR_1, VAR_18);", "}", "}", "}", "} else {", "const int16_t **VAR_47= (const int16_t **)lumPixBuf + VAR_19 + VAR_29 - VAR_21 + VAR_13;", "const int16_t **VAR_47= (const int16_t **)chrPixBuf + VAR_20 + VAR_31 - VAR_22 + VAR_14;", "const int16_t **VAR_47= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **)alpPixBuf + VAR_19 + VAR_29 - VAR_21 + VAR_13 : NULL;", "if (VAR_7 == PIX_FMT_NV12 || VAR_7 == PIX_FMT_NV21) {", "const int VAR_47= (1<<c->chrDstVSubSample)-1;", "if (VAR_18&VAR_47) VAR_26= NULL;", "yuv2nv12XinC(\nvLumFilter+VAR_18*VAR_9 , VAR_47, VAR_9,\nvChrFilter+VAR_25*VAR_10, VAR_47, VAR_10,\nVAR_24, VAR_26, VAR_1, VAR_3, VAR_7);", "} else if (isPlanarYUV(VAR_7) || VAR_7==PIX_FMT_GRAY8) {", "const int VAR_47= (1<<c->chrDstVSubSample)-1;", "if ((VAR_18&VAR_47) || isGray(VAR_7)) VAR_26=VAR_27= NULL;", "if (is16BPS(VAR_7) || isNBPS(VAR_7)) {", "yuv2yuvX16inC(\nvLumFilter+VAR_18*VAR_9 , VAR_47, VAR_9,\nvChrFilter+VAR_25*VAR_10, VAR_47, VAR_10,\nVAR_47, (uint16_t *) VAR_24, (uint16_t *) VAR_26, (uint16_t *) VAR_27, (uint16_t *) VAR_28, VAR_1, VAR_3,\nVAR_7);", "} else {", "yuv2yuvXinC(\nvLumFilter+VAR_18*VAR_9 , VAR_47, VAR_9,\nvChrFilter+VAR_25*VAR_10, VAR_47, VAR_10,\nVAR_47, VAR_24, VAR_26, VAR_27, VAR_28, VAR_1, VAR_3);", "}", "} else {", "assert(VAR_47 + VAR_9 - 1 < lumPixBuf + VAR_13*2);", "assert(VAR_47 + VAR_10 - 1 < chrPixBuf + VAR_14*2);", "if(VAR_8 & SWS_FULL_CHR_H_INT) {", "yuv2rgbXinC_full(c,\nvLumFilter+VAR_18*VAR_9, VAR_47, VAR_9,\nvChrFilter+VAR_18*VAR_10, VAR_47, VAR_10,\nVAR_47, VAR_24, VAR_1, VAR_18);", "} else {", "yuv2packedXinC(c,\nvLumFilter+VAR_18*VAR_9, VAR_47, VAR_9,\nvChrFilter+VAR_18*VAR_10, VAR_47, VAR_10,\nVAR_47, VAR_24, VAR_1, VAR_18);", "}", "}", "}", "}", "if ((VAR_7 == PIX_FMT_YUVA420P) && !alpPixBuf)\nfillPlane(dst[3], dstStride[3], VAR_1, VAR_18-VAR_17, VAR_17, 255);", "#if COMPILE_TEMPLATE_MMX\nif (VAR_8 & SWS_CPU_CAPS_MMX2 ) __asm__ volatile(\"sfence\":::\"memory\");", "if (VAR_8 & SWS_CPU_CAPS_3DNOW) __asm__ volatile(\"femms\" :::\"memory\");", "else __asm__ volatile(\"emms\" :::\"memory\");", "#endif\nc->VAR_18= VAR_18;", "c->VAR_19= VAR_19;", "c->VAR_20= VAR_20;", "c->VAR_21= VAR_21;", "c->VAR_22= VAR_22;", "return VAR_18 - VAR_17;", "}" ]

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

[ [ 1, 3, 5 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 95, 97, 99, 101 ], [ 103, 105, 107, 109 ], [ 111 ], [ 113 ], [ 115 ], [ 119, 121, 123 ], [ 125, 127 ], [ 129, 131 ], [ 135 ], [ 137 ], [ 139 ], [ 141, 143 ], [ 145 ], [ 147 ], [ 149 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 189 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 211 ], [ 213 ], [ 215 ], [ 217 ], [ 221 ], [ 223, 225 ], [ 227, 229 ], [ 235 ], [ 239 ], [ 241 ], [ 243 ], [ 245, 247 ], [ 249 ], [ 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 ], [ 313, 315, 317, 319, 321 ], [ 323 ], [ 325, 327 ], [ 329 ], [ 333 ], [ 335 ], [ 337, 339 ], [ 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 ], [ 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 ], [ 545 ], [ 547 ], [ 549 ], [ 551, 553 ], [ 555, 557 ], [ 559 ], [ 561, 563, 565, 567 ], [ 569 ], [ 571, 573, 575 ], [ 577 ], [ 579 ], [ 581 ], [ 583, 585, 587, 589 ], [ 591 ], [ 593, 595, 597, 599 ], [ 601 ], [ 603 ], [ 605 ], [ 607 ], [ 609 ], [ 611 ], [ 613 ], [ 615 ], [ 617 ], [ 619 ], [ 621, 623, 625, 627 ], [ 629 ], [ 631 ], [ 633 ], [ 635 ], [ 637, 639, 641, 643, 645 ], [ 647 ], [ 649, 651, 653, 655 ], [ 657 ], [ 659 ], [ 661 ], [ 663 ], [ 665 ], [ 667, 669, 671, 673 ], [ 675 ], [ 677, 679, 681, 683 ], [ 685 ], [ 687 ], [ 689 ], [ 691 ], [ 695, 697 ], [ 701, 703 ], [ 707 ], [ 709 ], [ 711, 715 ], [ 717 ], [ 719 ], [ 721 ], [ 723 ], [ 727 ], [ 729 ] ]

[ "static inline int FUNC_0(WavpackFrameContext *VAR_0, GetBitContext *VAR_1,\nvoid *VAR_2, const int VAR_3)\n{", "int VAR_4, VAR_5, VAR_6 = 0;", "int VAR_7, VAR_8;", "int VAR_9, VAR_10, VAR_11;", "int VAR_12 = VAR_0->VAR_12;", "uint32_t crc = VAR_0->sc.crc;", "uint32_t crc_extra_bits = VAR_0->extra_sc.crc;", "int16_t *dst16 = VAR_2;", "int32_t *dst32 = VAR_2;", "float *VAR_13 = VAR_2;", "VAR_0->one = VAR_0->zero = VAR_0->zeroes = 0;", "do {", "VAR_11 = wv_get_value(VAR_0, VAR_1, 0, &VAR_7);", "VAR_10 = 0;", "if (VAR_7)\nbreak;", "for (VAR_4 = 0; VAR_4 < VAR_0->terms; VAR_4++) {", "VAR_8 = VAR_0->decorr[VAR_4].value;", "if (VAR_8 > 8) {", "if (VAR_8 & 1)\nVAR_9 = 2U * VAR_0->decorr[VAR_4].samplesA[0] - VAR_0->decorr[VAR_4].samplesA[1];", "else\nVAR_9 = (int)(3U * VAR_0->decorr[VAR_4].samplesA[0] - VAR_0->decorr[VAR_4].samplesA[1]) >> 1;", "VAR_0->decorr[VAR_4].samplesA[1] = VAR_0->decorr[VAR_4].samplesA[0];", "VAR_5 = 0;", "} else {", "VAR_9 = VAR_0->decorr[VAR_4].samplesA[VAR_12];", "VAR_5 = (VAR_12 + VAR_8) & 7;", "}", "if (VAR_3 != AV_SAMPLE_FMT_S16P)\nVAR_10 = VAR_11 + ((VAR_0->decorr[VAR_4].weightA * (int64_t)VAR_9 + 512) >> 10);", "else\nVAR_10 = VAR_11 + ((VAR_0->decorr[VAR_4].weightA * VAR_9 + 512) >> 10);", "if (VAR_9 && VAR_11)\nVAR_0->decorr[VAR_4].weightA -= ((((VAR_11 ^ VAR_9) >> 30) & 2) - 1) * VAR_0->decorr[VAR_4].delta;", "VAR_0->decorr[VAR_4].samplesA[VAR_5] = VAR_11 = VAR_10;", "}", "VAR_12 = (VAR_12 + 1) & 7;", "crc = crc * 3 + VAR_10;", "if (VAR_3 == AV_SAMPLE_FMT_FLTP) {", "*VAR_13++ = wv_get_value_float(VAR_0, &crc_extra_bits, VAR_10);", "} else if (VAR_3 == AV_SAMPLE_FMT_S32P) {", "*dst32++ = wv_get_value_integer(VAR_0, &crc_extra_bits, VAR_10);", "} else {", "*dst16++ = wv_get_value_integer(VAR_0, &crc_extra_bits, VAR_10);", "}", "VAR_6++;", "} while (!VAR_7 && VAR_6 < VAR_0->samples);", "wv_reset_saved_context(VAR_0);", "if (VAR_7 && VAR_6 < VAR_0->samples) {", "int VAR_14 = av_get_bytes_per_sample(VAR_3);", "memset((uint8_t*)VAR_2 + VAR_6*VAR_14, 0, (VAR_0->samples-VAR_6)*VAR_14);", "}", "if (VAR_0->avctx->err_recognition & AV_EF_CRCCHECK) {", "int VAR_15 = wv_check_crc(VAR_0, crc, crc_extra_bits);", "if (VAR_15 < 0 && VAR_0->avctx->err_recognition & AV_EF_EXPLODE)\nreturn VAR_15;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0 (CPUMIPSState *VAR_0, const mips_def_t *VAR_1)\n{", "VAR_0->tlb = qemu_mallocz(sizeof(CPUMIPSTLBContext));", "switch (VAR_1->mmu_type) {", "case MMU_TYPE_NONE:\nno_mmu_init(VAR_0, VAR_1);", "break;", "case MMU_TYPE_R4000:\nr4k_mmu_init(VAR_0, VAR_1);", "break;", "case MMU_TYPE_FMT:\nfixed_mmu_init(VAR_0, VAR_1);", "break;", "case MMU_TYPE_R3000:\ncase MMU_TYPE_R6000:\ncase MMU_TYPE_R8000:\ndefault:\ncpu_abort(VAR_0, \"MMU type not supported\\n\");", "}", "VAR_0->CP0_Random = VAR_0->tlb->nb_tlb - 1;", "VAR_0->tlb->tlb_in_use = VAR_0->tlb->nb_tlb;", "}" ]

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

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

[ "static void FUNC_0(HintSampleQueue *VAR_0, uint8_t *VAR_1, int VAR_2,\nint VAR_3)\n{", "if (VAR_2 <= 14)\nreturn;", "if (!VAR_0->samples || VAR_0->len >= VAR_0->VAR_2) {", "HintSample *samples;", "samples = av_realloc(VAR_0->samples, sizeof(HintSample) * (VAR_0->VAR_2 + 10));", "if (!samples)\nreturn;", "VAR_0->VAR_2 += 10;", "VAR_0->samples = samples;", "}", "VAR_0->samples[VAR_0->len].VAR_1 = VAR_1;", "VAR_0->samples[VAR_0->len].VAR_2 = VAR_2;", "VAR_0->samples[VAR_0->len].sample_number = VAR_3;", "VAR_0->samples[VAR_0->len].offset = 0;", "VAR_0->samples[VAR_0->len].own_data = 0;", "VAR_0->len++;", "}" ]

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

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

[ "static void FUNC_0(CPUPPCState *VAR_0)\n{", "spr_register(VAR_0, SPR_TAR, \"TAR\",\n&spr_read_generic, &spr_write_generic,\n&spr_read_generic, &spr_write_generic,\n0x00000000);", "}" ]

[ 0, 1, 0 ]

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

[ "static inline int FUNC_0(MpegEncContext * VAR_0, DCTELEM * VAR_1,\nint VAR_2, int VAR_3, int VAR_4)\n{", "int VAR_5, VAR_6, VAR_7, VAR_8;", "int VAR_9;", "RLTable * rl;", "RL_VLC_ELEM * rl_vlc;", "const UINT8 * VAR_10;", "int VAR_11, VAR_12;", "if(VAR_4) {", "if(VAR_0->partitioned_frame){", "VAR_5 = VAR_0->dc_val[0][ VAR_0->block_index[VAR_2] ];", "if(VAR_2<4) VAR_5= (VAR_5 + (VAR_0->y_dc_scale>>1))/VAR_0->y_dc_scale;", "else VAR_5= (VAR_5 + (VAR_0->c_dc_scale>>1))/VAR_0->c_dc_scale;", "VAR_9= (VAR_0->pred_dir_table[VAR_0->mb_x + VAR_0->mb_y*VAR_0->mb_width]<<VAR_2)&32;", "}else{", "VAR_5 = mpeg4_decode_dc(VAR_0, VAR_2, &VAR_9);", "if (VAR_5 < 0)\nreturn -1;", "}", "VAR_1[0] = VAR_5;", "VAR_6 = 0;", "if (!VAR_3)\ngoto not_coded;", "rl = &rl_intra;", "rl_vlc = rl_intra.rl_vlc[0];", "if (VAR_0->ac_pred) {", "if (VAR_9 == 0)\nVAR_10 = VAR_0->intra_v_scantable.permutated;", "else\nVAR_10 = VAR_0->intra_h_scantable.permutated;", "} else {", "VAR_10 = VAR_0->intra_scantable.permutated;", "}", "VAR_11=1;", "VAR_12=0;", "} else {", "VAR_6 = -1;", "if (!VAR_3) {", "VAR_0->block_last_index[VAR_2] = VAR_6;", "return 0;", "}", "rl = &rl_inter;", "VAR_10 = VAR_0->intra_scantable.permutated;", "if(VAR_0->mpeg_quant){", "VAR_11=1;", "VAR_12=0;", "rl_vlc = rl_inter.rl_vlc[0];", "}else{", "VAR_11 = VAR_0->qscale << 1;", "VAR_12 = (VAR_0->qscale - 1) | 1;", "rl_vlc = rl_inter.rl_vlc[VAR_0->qscale];", "}", "}", "{", "OPEN_READER(re, &VAR_0->gb);", "for(;;) {", "UPDATE_CACHE(re, &VAR_0->gb);", "GET_RL_VLC(VAR_5, VAR_8, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2);", "if (VAR_5==0) {", "int VAR_13;", "VAR_13= GET_CACHE(re, &VAR_0->gb);", "if (VAR_13&0x80000000) {", "if (VAR_13&0x40000000) {", "SKIP_CACHE(re, &VAR_0->gb, 2);", "VAR_7= SHOW_UBITS(re, &VAR_0->gb, 1); SKIP_CACHE(re, &VAR_0->gb, 1);", "VAR_8= SHOW_UBITS(re, &VAR_0->gb, 6); LAST_SKIP_CACHE(re, &VAR_0->gb, 6);", "SKIP_COUNTER(re, &VAR_0->gb, 2+1+6);", "UPDATE_CACHE(re, &VAR_0->gb);", "if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){", "fprintf(stderr, \"1. marker bit missing in 3. esc\\VAR_2\");", "return -1;", "}; SKIP_CACHE(re, &VAR_0->gb, 1);", "VAR_5= SHOW_SBITS(re, &VAR_0->gb, 12); SKIP_CACHE(re, &VAR_0->gb, 12);", "if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){", "fprintf(stderr, \"2. marker bit missing in 3. esc\\VAR_2\");", "return -1;", "}; LAST_SKIP_CACHE(re, &VAR_0->gb, 1);", "SKIP_COUNTER(re, &VAR_0->gb, 1+12+1);", "if(VAR_5*VAR_0->qscale>1024 || VAR_5*VAR_0->qscale<-1024){", "fprintf(stderr, \"|VAR_5| overflow in 3. esc, qp=%d\\VAR_2\", VAR_0->qscale);", "return -1;", "}", "#if 1\n{", "const int VAR_14= ABS(VAR_5);", "if(VAR_14<=MAX_LEVEL && VAR_8<=MAX_RUN && ((VAR_0->workaround_bugs&FF_BUG_AC_VLC)==0)){", "const int VAR_15= VAR_8 - rl->max_run[VAR_7][VAR_14] - 1;", "if(VAR_14 <= rl->max_level[VAR_7][VAR_8]){", "fprintf(stderr, \"illegal 3. esc, vlc encoding possible\\VAR_2\");", "return -1;", "}", "if(VAR_14 <= rl->max_level[VAR_7][VAR_8]*2){", "fprintf(stderr, \"illegal 3. esc, esc 1 encoding possible\\VAR_2\");", "return -1;", "}", "if(VAR_15 >= 0 && VAR_14 <= rl->max_level[VAR_7][VAR_15]){", "fprintf(stderr, \"illegal 3. esc, esc 2 encoding possible\\VAR_2\");", "return -1;", "}", "}", "}", "#endif\nif (VAR_5>0) VAR_5= VAR_5 * VAR_11 + VAR_12;", "else VAR_5= VAR_5 * VAR_11 - VAR_12;", "VAR_6+= VAR_8 + 1;", "if(VAR_7) VAR_6+=192;", "} else {", "#if MIN_CACHE_BITS < 20\nLAST_SKIP_BITS(re, &VAR_0->gb, 2);", "UPDATE_CACHE(re, &VAR_0->gb);", "#else\nSKIP_BITS(re, &VAR_0->gb, 2);", "#endif\nGET_RL_VLC(VAR_5, VAR_8, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2);", "VAR_6+= VAR_8 + rl->max_run[VAR_8>>7][VAR_5/VAR_11] +1;", "VAR_5 = (VAR_5 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);", "LAST_SKIP_BITS(re, &VAR_0->gb, 1);", "}", "} else {", "#if MIN_CACHE_BITS < 19\nLAST_SKIP_BITS(re, &VAR_0->gb, 1);", "UPDATE_CACHE(re, &VAR_0->gb);", "#else\nSKIP_BITS(re, &VAR_0->gb, 1);", "#endif\nGET_RL_VLC(VAR_5, VAR_8, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2);", "VAR_6+= VAR_8;", "VAR_5 = VAR_5 + rl->max_level[VAR_8>>7][(VAR_8-1)&63] * VAR_11;", "VAR_5 = (VAR_5 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);", "LAST_SKIP_BITS(re, &VAR_0->gb, 1);", "}", "} else {", "VAR_6+= VAR_8;", "VAR_5 = (VAR_5 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);", "LAST_SKIP_BITS(re, &VAR_0->gb, 1);", "}", "if (VAR_6 > 62){", "VAR_6-= 192;", "if(VAR_6&(~63)){", "fprintf(stderr, \"ac-tex damaged at %d %d\\VAR_2\", VAR_0->mb_x, VAR_0->mb_y);", "return -1;", "}", "VAR_1[VAR_10[VAR_6]] = VAR_5;", "break;", "}", "VAR_1[VAR_10[VAR_6]] = VAR_5;", "}", "CLOSE_READER(re, &VAR_0->gb);", "}", "not_coded:\nif (VAR_0->mb_intra) {", "mpeg4_pred_ac(VAR_0, VAR_1, VAR_2, VAR_9);", "if (VAR_0->ac_pred) {", "VAR_6 = 63;", "}", "}", "VAR_0->block_last_index[VAR_2] = 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 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 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 163 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 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 ], [ 235 ], [ 237 ], [ 239 ], [ 243, 245 ], [ 247 ], [ 249, 251 ], [ 253, 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 269, 271 ], [ 273 ], [ 275, 277 ], [ 279, 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 291 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 317 ], [ 319 ], [ 321 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333, 335 ], [ 337 ], [ 339 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349 ], [ 351 ] ]

[ "int FUNC_0(const char *VAR_0, target_ulong *VAR_1, int *VAR_2)\n{", "int VAR_3;", "int VAR_4;", "uboot_image_header_t h;", "uboot_image_header_t *hdr = &h;", "uint8_t *data = NULL;", "VAR_3 = open(VAR_0, O_RDONLY | O_BINARY);", "if (VAR_3 < 0)\nreturn -1;", "VAR_4 = read(VAR_3, hdr, sizeof(uboot_image_header_t));", "if (VAR_4 < 0)\ngoto fail;", "bswap_uboot_header(hdr);", "if (hdr->ih_magic != IH_MAGIC)\ngoto fail;", "if (hdr->ih_type == IH_TYPE_MULTI) {", "fprintf(stderr, \"Unable to load multi-file u-boot images\\n\");", "goto fail;", "}", "if (hdr->ih_comp != IH_COMP_NONE) {", "fprintf(stderr, \"Unable to load compressed u-boot images\\n\");", "goto fail;", "}", "if (VAR_2) {", "if (hdr->ih_type == IH_TYPE_KERNEL && hdr->ih_os == IH_OS_LINUX)\n*VAR_2 = 1;", "else\n*VAR_2 = 0;", "}", "*VAR_1 = hdr->ih_ep;", "data = qemu_malloc(hdr->ih_size);", "if (!data)\ngoto fail;", "if (read(VAR_3, data, hdr->ih_size) != hdr->ih_size) {", "fprintf(stderr, \"Error reading file\\n\");", "goto fail;", "}", "cpu_physical_memory_write_rom(hdr->ih_load, data, hdr->ih_size);", "return hdr->ih_size;", "fail:\nif (data)\nqemu_free(data);", "close(VAR_3);", "return -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, 0, 0, 0, 1, 1, 0, 1, 0 ]

[ [ 1, 3 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 21, 23 ], [ 27 ], [ 29, 31 ], [ 35 ], [ 39, 41 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 71 ], [ 73, 75 ], [ 77, 79 ], [ 81 ], [ 85 ], [ 87 ], [ 89, 91 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 105 ], [ 109 ], [ 113, 115, 117 ], [ 119 ], [ 121 ], [ 123 ] ]

[ "static int64_t FUNC_0(BlockDriverState *bs, int64_t cluster_index)\n{", "BDRVQcowState *s = bs->opaque;", "unsigned int VAR_0;", "int VAR_1;", "BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);", "VAR_0 = cluster_index >> (s->cluster_bits - REFCOUNT_SHIFT);", "if (VAR_0 < s->refcount_table_size) {", "uint64_t refcount_block_offset =\ns->refcount_table[VAR_0];", "if (refcount_block_offset) {", "if (refcount_block_offset != s->refcount_block_cache_offset) {", "VAR_1 = load_refcount_block(bs, refcount_block_offset);", "if (VAR_1 < 0) {", "return VAR_1;", "}", "}", "return refcount_block_offset;", "}", "}", "if (cache_refcount_updates) {", "VAR_1 = write_refcount_block(bs);", "if (VAR_1 < 0) {", "return VAR_1;", "}", "}", "uint64_t new_block = alloc_clusters_noref(bs, s->cluster_size);", "memset(s->refcount_block_cache, 0, s->cluster_size);", "s->refcount_block_cache_offset = new_block;", "#ifdef DEBUG_ALLOC2\nfprintf(stderr, \"qcow2: Allocate refcount VAR_4 %d for %\" PRIx64\n\" at %\" PRIx64 \"\\n\",\nVAR_0, cluster_index << s->cluster_bits, new_block);", "#endif\nif (in_same_refcount_block(s, new_block, cluster_index << s->cluster_bits)) {", "int VAR_2 = (new_block >> s->cluster_bits) &\n((1 << (s->cluster_bits - REFCOUNT_SHIFT)) - 1);", "s->refcount_block_cache[VAR_2] = cpu_to_be16(1);", "} else {", "VAR_1 = update_refcount(bs, new_block, s->cluster_size, 1);", "if (VAR_1 < 0) {", "goto fail_block;", "}", "}", "BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE);", "VAR_1 = bdrv_pwrite(bs->file, new_block, s->refcount_block_cache,\ns->cluster_size);", "if (VAR_1 < 0) {", "goto fail_block;", "}", "if (VAR_0 < s->refcount_table_size) {", "uint64_t data64 = cpu_to_be64(new_block);", "BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);", "VAR_1 = bdrv_pwrite(bs->file,\ns->refcount_table_offset + VAR_0 * sizeof(uint64_t),\n&data64, sizeof(data64));", "if (VAR_1 < 0) {", "goto fail_block;", "}", "s->refcount_table[VAR_0] = new_block;", "return new_block;", "}", "BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_GROW);", "uint64_t refcount_block_clusters = 1 << (s->cluster_bits - REFCOUNT_SHIFT);", "uint64_t blocks_used = (s->free_cluster_index +\nrefcount_block_clusters - 1) / refcount_block_clusters;", "uint64_t table_size = next_refcount_table_size(s, blocks_used + 1);", "uint64_t last_table_size;", "uint64_t blocks_clusters;", "do {", "uint64_t table_clusters = size_to_clusters(s, table_size);", "blocks_clusters = 1 +\n((table_clusters + refcount_block_clusters - 1)\n/ refcount_block_clusters);", "uint64_t meta_clusters = table_clusters + blocks_clusters;", "last_table_size = table_size;", "table_size = next_refcount_table_size(s, blocks_used +\n((meta_clusters + refcount_block_clusters - 1)\n/ refcount_block_clusters));", "} while (last_table_size != table_size);", "#ifdef DEBUG_ALLOC2\nfprintf(stderr, \"qcow2: Grow refcount table %\" PRId32 \" => %\" PRId64 \"\\n\",\ns->refcount_table_size, table_size);", "#endif\nuint64_t meta_offset = (blocks_used * refcount_block_clusters) *\ns->cluster_size;", "uint64_t table_offset = meta_offset + blocks_clusters * s->cluster_size;", "uint16_t *new_blocks = qemu_mallocz(blocks_clusters * s->cluster_size);", "uint64_t *new_table = qemu_mallocz(table_size * sizeof(uint64_t));", "assert(meta_offset >= (s->free_cluster_index * s->cluster_size));", "memcpy(new_table, s->refcount_table,\ns->refcount_table_size * sizeof(uint64_t));", "new_table[VAR_0] = new_block;", "int VAR_3;", "for (VAR_3 = 0; VAR_3 < blocks_clusters; VAR_3++) {", "new_table[blocks_used + VAR_3] = meta_offset + (VAR_3 * s->cluster_size);", "}", "uint64_t table_clusters = size_to_clusters(s, table_size * sizeof(uint64_t));", "int VAR_4 = 0;", "for (VAR_3 = 0; VAR_3 < table_clusters + blocks_clusters; VAR_3++) {", "new_blocks[VAR_4++] = cpu_to_be16(1);", "}", "BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);", "VAR_1 = bdrv_pwrite(bs->file, meta_offset, new_blocks,\nblocks_clusters * s->cluster_size);", "qemu_free(new_blocks);", "if (VAR_1 < 0) {", "goto fail_table;", "}", "for(VAR_3 = 0; VAR_3 < table_size; VAR_3++) {", "cpu_to_be64s(&new_table[VAR_3]);", "}", "BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);", "VAR_1 = bdrv_pwrite(bs->file, table_offset, new_table,\ntable_size * sizeof(uint64_t));", "if (VAR_1 < 0) {", "goto fail_table;", "}", "for(VAR_3 = 0; VAR_3 < table_size; VAR_3++) {", "cpu_to_be64s(&new_table[VAR_3]);", "}", "uint8_t data[12];", "cpu_to_be64w((uint64_t*)data, table_offset);", "cpu_to_be32w((uint32_t*)(data + 8), table_clusters);", "BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);", "VAR_1 = bdrv_pwrite(bs->file, offsetof(QCowHeader, refcount_table_offset),\ndata, sizeof(data));", "if (VAR_1 < 0) {", "goto fail_table;", "}", "uint64_t old_table_offset = s->refcount_table_offset;", "uint64_t old_table_size = s->refcount_table_size;", "qemu_free(s->refcount_table);", "s->refcount_table = new_table;", "s->refcount_table_size = table_size;", "s->refcount_table_offset = table_offset;", "uint64_t old_free_cluster_index = s->free_cluster_index;", "qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t));", "s->free_cluster_index = old_free_cluster_index;", "VAR_1 = load_refcount_block(bs, new_block);", "if (VAR_1 < 0) {", "goto fail_block;", "}", "return new_block;", "fail_table:\nqemu_free(new_table);", "fail_block:\ns->refcount_block_cache_offset = 0;", "return VAR_1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 13 ], [ 19 ], [ 23 ], [ 27, 29 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 117 ], [ 119 ], [ 121 ], [ 125, 127, 129, 131 ], [ 133, 137 ], [ 141, 143 ], [ 145 ], [ 147 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 167 ], [ 169, 171 ], [ 173 ], [ 175 ], [ 177 ], [ 183 ], [ 185 ], [ 187 ], [ 189, 191, 193 ], [ 195 ], [ 197 ], [ 199 ], [ 203 ], [ 205 ], [ 207 ], [ 233 ], [ 239 ], [ 241, 243 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 257 ], [ 259, 261, 263 ], [ 265 ], [ 269 ], [ 271, 273, 275 ], [ 279 ], [ 283, 285, 287 ], [ 289, 295, 297 ], [ 299 ], [ 301 ], [ 303 ], [ 307 ], [ 313, 315 ], [ 317 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 333 ], [ 335 ], [ 337 ], [ 339 ], [ 341 ], [ 347 ], [ 349, 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 365 ], [ 367 ], [ 369 ], [ 373 ], [ 375, 377 ], [ 379 ], [ 381 ], [ 383 ], [ 387 ], [ 389 ], [ 391 ], [ 397 ], [ 399 ], [ 401 ], [ 403 ], [ 405, 407 ], [ 409 ], [ 411 ], [ 413 ], [ 419 ], [ 421 ], [ 425 ], [ 427 ], [ 429 ], [ 431 ], [ 437 ], [ 439 ], [ 441 ], [ 445 ], [ 447 ], [ 449 ], [ 451 ], [ 455 ], [ 459, 461 ], [ 463, 465 ], [ 467 ], [ 469 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0,\nFourxmDemuxContext *VAR_1, uint8_t *VAR_2, int VAR_3)\n{", "AVStream *st;", "if (VAR_3 != vtrk_SIZE) {", "return AVERROR_INVALIDDATA;", "}", "st = avformat_new_stream(VAR_0, NULL);", "if (!st)\nreturn AVERROR(ENOMEM);", "avpriv_set_pts_info(st, 60, 1, VAR_1->fps);", "VAR_1->video_stream_index = st->index;", "st->codec->codec_type = AVMEDIA_TYPE_VIDEO;", "st->codec->codec_id = AV_CODEC_ID_4XM;", "st->codec->extradata_size = 4;", "st->codec->extradata = av_malloc(4);", "AV_WL32(st->codec->extradata, AV_RL32(VAR_2 + 16));", "st->codec->width = AV_RL32(VAR_2 + 36);", "st->codec->height = AV_RL32(VAR_2 + 40);", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 21 ], [ 23, 25 ], [ 29 ], [ 33 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 53 ], [ 55 ] ]

[ "void FUNC_0(BlockDriverState *VAR_0, BlockDriverState *VAR_1)\n{", "if (VAR_0->VAR_1) {", "assert(VAR_0->backing_blocker);", "bdrv_op_unblock_all(VAR_0->VAR_1, VAR_0->backing_blocker);", "} else if (VAR_1) {", "error_setg(&VAR_0->backing_blocker,\n\"device is used as backing hd of '%s'\",\nbdrv_get_device_name(VAR_0));", "}", "VAR_0->VAR_1 = VAR_1;", "if (!VAR_1) {", "error_free(VAR_0->backing_blocker);", "VAR_0->backing_blocker = NULL;", "goto out;", "}", "VAR_0->open_flags &= ~BDRV_O_NO_BACKING;", "pstrcpy(VAR_0->backing_file, sizeof(VAR_0->backing_file), VAR_1->filename);", "pstrcpy(VAR_0->backing_format, sizeof(VAR_0->backing_format),\nVAR_1->drv ? VAR_1->drv->format_name : \"\");", "bdrv_op_block_all(VAR_0->VAR_1, VAR_0->backing_blocker);", "bdrv_op_unblock(VAR_0->VAR_1, BLOCK_OP_TYPE_COMMIT,\nVAR_0->backing_blocker);", "out:\nbdrv_refresh_limits(VAR_0, NULL);", "}" ]

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

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

[ "static void FUNC_0(void *VAR_0, int VAR_1)\n{", "SCSIGenericReq *r = (SCSIGenericReq *)VAR_0;", "SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, r->req.dev);", "r->req.aiocb = NULL;", "s->driver_status = r->io_header.driver_status;", "if (s->driver_status & SG_ERR_DRIVER_SENSE)\ns->senselen = r->io_header.sb_len_wr;", "if (VAR_1 != 0)\nr->req.status = BUSY;", "else {", "if (s->driver_status & SG_ERR_DRIVER_TIMEOUT) {", "r->req.status = BUSY;", "BADF(\"Driver Timeout\\n\");", "} else if (r->io_header.status)", "r->req.status = r->io_header.status;", "else if (s->driver_status & SG_ERR_DRIVER_SENSE)\nr->req.status = CHECK_CONDITION;", "else\nr->req.status = GOOD;", "}", "DPRINTF(\"Command complete 0x%p tag=0x%x status=%d\\n\",\nr, r->req.tag, r->req.status);", "scsi_req_complete(&r->req);", "}" ]

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

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

[ "static int VAR_0 update_refcount(BlockDriverState *bs,\nint64_t offset,\nint64_t length,\nuint64_t addend,\nbool decrease,\nenum qcow2_discard_type type)\n{", "BDRVQcowState *s = bs->opaque;", "int64_t start, last, cluster_offset;", "uint16_t *refcount_block = NULL;", "int64_t old_table_index = -1;", "int ret;", "#ifdef DEBUG_ALLOC2\nfprintf(stderr, \"update_refcount: offset=%\" PRId64 \" size=%\" PRId64\n\" addend=%s%\" PRIu64 \"\\n\", offset, length, decrease ? \"-\" : \"\",\naddend);", "#endif\nif (length < 0) {", "return -EINVAL;", "} else if (length == 0) {", "return 0;", "}", "if (decrease) {", "qcow2_cache_set_dependency(bs, s->refcount_block_cache,\ns->l2_table_cache);", "}", "start = start_of_cluster(s, offset);", "last = start_of_cluster(s, offset + length - 1);", "for(cluster_offset = start; cluster_offset <= last;", "cluster_offset += s->cluster_size)\n{", "int block_index;", "uint64_t refcount;", "int64_t cluster_index = cluster_offset >> s->cluster_bits;", "int64_t table_index = cluster_index >> s->refcount_block_bits;", "if (table_index != old_table_index) {", "if (refcount_block) {", "ret = qcow2_cache_put(bs, s->refcount_block_cache,\n(void**) &refcount_block);", "if (ret < 0) {", "goto fail;", "}", "}", "ret = alloc_refcount_block(bs, cluster_index, &refcount_block);", "if (ret < 0) {", "goto fail;", "}", "}", "old_table_index = table_index;", "qcow2_cache_entry_mark_dirty(s->refcount_block_cache, refcount_block);", "block_index = cluster_index & (s->refcount_block_size - 1);", "refcount = be16_to_cpu(refcount_block[block_index]);", "if (decrease ? (refcount - addend > refcount)\n: (refcount + addend < refcount ||\nrefcount + addend > s->refcount_max))\n{", "ret = -EINVAL;", "goto fail;", "}", "if (decrease) {", "refcount -= addend;", "} else {", "refcount += addend;", "}", "if (refcount == 0 && cluster_index < s->free_cluster_index) {", "s->free_cluster_index = cluster_index;", "}", "refcount_block[block_index] = cpu_to_be16(refcount);", "if (refcount == 0 && s->discard_passthrough[type]) {", "update_refcount_discard(bs, cluster_offset, s->cluster_size);", "}", "}", "ret = 0;", "fail:\nif (!s->cache_discards) {", "qcow2_process_discards(bs, ret);", "}", "if (refcount_block) {", "int wret;", "wret = qcow2_cache_put(bs, s->refcount_block_cache,\n(void**) &refcount_block);", "if (wret < 0) {", "return ret < 0 ? ret : wret;", "}", "}", "if (ret < 0) {", "int dummy;", "dummy = update_refcount(bs, offset, cluster_offset - offset, addend,\n!decrease, QCOW2_DISCARD_NEVER);", "(void)dummy;", "}", "return ret;", "}" ]

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

[ [ 1, 3, 5, 7, 9, 11, 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 29, 31, 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51, 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 85, 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113 ], [ 119 ], [ 123 ], [ 125, 127, 129, 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 153 ], [ 155 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 169 ], [ 171, 173 ], [ 175 ], [ 177 ], [ 183 ], [ 185 ], [ 187, 189 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 209 ], [ 211 ], [ 213, 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ] ]

[ "int FUNC_0(MPEG4AudioConfig *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{", "GetBitContext gb;", "int VAR_3;", "init_get_bits(&gb, VAR_1, VAR_2*8);", "VAR_0->object_type = get_object_type(&gb);", "VAR_0->sample_rate = get_sample_rate(&gb, &VAR_0->sampling_index);", "VAR_0->chan_config = get_bits(&gb, 4);", "if (VAR_0->chan_config < FF_ARRAY_ELEMS(ff_mpeg4audio_channels))\nVAR_0->channels = ff_mpeg4audio_channels[VAR_0->chan_config];", "VAR_0->sbr = -1;", "if (VAR_0->object_type == AOT_SBR || (VAR_0->object_type == AOT_PS &&\n!(show_bits(&gb, 3) & 0x03 && !(show_bits(&gb, 9) & 0x3F)))) {", "VAR_0->ext_object_type = AOT_SBR;", "VAR_0->sbr = 1;", "VAR_0->ext_sample_rate = get_sample_rate(&gb, &VAR_0->ext_sampling_index);", "VAR_0->object_type = get_object_type(&gb);", "if (VAR_0->object_type == AOT_ER_BSAC)\nVAR_0->ext_chan_config = get_bits(&gb, 4);", "} else {", "VAR_0->ext_object_type = AOT_NULL;", "VAR_0->ext_sample_rate = 0;", "}", "VAR_3 = get_bits_count(&gb);", "if (VAR_0->object_type == AOT_ALS) {", "skip_bits(&gb, 5);", "if (show_bits_long(&gb, 24) != MKBETAG('\\0','A','L','S'))\nskip_bits_long(&gb, 24);", "VAR_3 = get_bits_count(&gb);", "if (parse_config_ALS(&gb, VAR_0))\nreturn -1;", "}", "if (VAR_0->ext_object_type != AOT_SBR) {", "int VAR_4 = VAR_2*8 - get_bits_count(&gb);", "for (; VAR_4 > 15; VAR_4--) {", "if (show_bits(&gb, 11) == 0x2b7) {", "get_bits(&gb, 11);", "VAR_0->ext_object_type = get_object_type(&gb);", "if (VAR_0->ext_object_type == AOT_SBR && (VAR_0->sbr = get_bits1(&gb)) == 1)\nVAR_0->ext_sample_rate = get_sample_rate(&gb, &VAR_0->ext_sampling_index);", "break;", "} else", "get_bits1(&gb);", "}", "}", "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 ]

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

[ "void FUNC_0(HEVCContext *VAR_0, int VAR_1, int VAR_2, int VAR_3,\nint VAR_4, int VAR_5, int VAR_6,\nint VAR_7, MvField *VAR_8,\nint VAR_9, int VAR_10)\n{", "HEVCLocalContext *lc = VAR_0->HEVClc;", "MvField *tab_mvf = VAR_0->ref->tab_mvf;", "int VAR_11 = 0;", "int VAR_12 = 1;", "int VAR_13 = 1;", "int VAR_14 = 0;", "int VAR_15 = VAR_0->sps->VAR_15;", "int VAR_16, VAR_17;", "int VAR_18;", "int VAR_19, VAR_20;", "int VAR_21;", "int VAR_22, VAR_23;", "int VAR_24;", "int VAR_25, VAR_26;", "int VAR_27;", "int VAR_28, VAR_29;", "int VAR_30;", "Mv mvpcand_list[2] = { { 0 } };", "Mv mxA;", "Mv mxB;", "int VAR_31 = 0;", "int VAR_32 = 0;", "int VAR_33;", "int VAR_34;", "const int VAR_35 = lc->na.VAR_35;", "const int VAR_36 = lc->na.VAR_36;", "const int VAR_37 = lc->na.VAR_37;", "const int VAR_38 = lc->na.VAR_38;", "const int VAR_39 = lc->na.cand_up_right_sap;", "VAR_31 = VAR_10;", "VAR_32 = VAR_8->VAR_32[VAR_10];", "VAR_33 = VAR_10;", "VAR_34 = !VAR_10;", "VAR_16 = VAR_1 - 1;", "VAR_17 = VAR_2 + VAR_4;", "VAR_18 = AVAILABLE(VAR_35, A0) &&\nVAR_17 < VAR_0->sps->height &&\nPRED_BLOCK_AVAILABLE(A0);", "VAR_19 = VAR_1 - 1;", "VAR_20 = VAR_2 + VAR_4 - 1;", "VAR_21 = AVAILABLE(VAR_36, A1);", "if (VAR_18 || VAR_21)\nVAR_11 = 1;", "if (VAR_18) {", "if (MP_MX(A0, VAR_33, mxA)) {", "goto b_candidates;", "}", "if (MP_MX(A0, VAR_34, mxA)) {", "goto b_candidates;", "}", "}", "if (VAR_21) {", "if (MP_MX(A1, VAR_33, mxA)) {", "goto b_candidates;", "}", "if (MP_MX(A1, VAR_34, mxA)) {", "goto b_candidates;", "}", "}", "if (VAR_18) {", "if (MP_MX_LT(A0, VAR_33, mxA)) {", "goto b_candidates;", "}", "if (MP_MX_LT(A0, VAR_34, mxA)) {", "goto b_candidates;", "}", "}", "if (VAR_21) {", "if (MP_MX_LT(A1, VAR_33, mxA)) {", "goto b_candidates;", "}", "if (MP_MX_LT(A1, VAR_34, mxA)) {", "goto b_candidates;", "}", "}", "VAR_12 = 0;", "b_candidates:\nVAR_22 = VAR_1 + VAR_3;", "VAR_23 = VAR_2 - 1;", "VAR_24 = AVAILABLE(VAR_39, B0) &&\nVAR_22 < VAR_0->sps->width &&\nPRED_BLOCK_AVAILABLE(B0);", "VAR_25 = VAR_1 + VAR_3 - 1;", "VAR_26 = VAR_2 - 1;", "VAR_27 = AVAILABLE(VAR_38, B1);", "VAR_28 = VAR_1 - 1;", "VAR_29 = VAR_2 - 1;", "VAR_30 = AVAILABLE(VAR_37, B2);", "if (VAR_24) {", "if (MP_MX(B0, VAR_33, mxB)) {", "goto scalef;", "}", "if (MP_MX(B0, VAR_34, mxB)) {", "goto scalef;", "}", "}", "if (VAR_27) {", "if (MP_MX(B1, VAR_33, mxB)) {", "goto scalef;", "}", "if (MP_MX(B1, VAR_34, mxB)) {", "goto scalef;", "}", "}", "if (VAR_30) {", "if (MP_MX(B2, VAR_33, mxB)) {", "goto scalef;", "}", "if (MP_MX(B2, VAR_34, mxB)) {", "goto scalef;", "}", "}", "VAR_13 = 0;", "scalef:\nif (!VAR_11) {", "if (VAR_13) {", "VAR_12 = 1;", "mxA = mxB;", "}", "VAR_13 = 0;", "if (VAR_24) {", "VAR_13 = MP_MX_LT(B0, VAR_33, mxB);", "if (!VAR_13)\nVAR_13 = MP_MX_LT(B0, VAR_34, mxB);", "}", "if (VAR_27 && !VAR_13) {", "VAR_13 = MP_MX_LT(B1, VAR_33, mxB);", "if (!VAR_13)\nVAR_13 = MP_MX_LT(B1, VAR_34, mxB);", "}", "if (VAR_30 && !VAR_13) {", "VAR_13 = MP_MX_LT(B2, VAR_33, mxB);", "if (!VAR_13)\nVAR_13 = MP_MX_LT(B2, VAR_34, mxB);", "}", "}", "if (VAR_12)\nmvpcand_list[VAR_14++] = mxA;", "if (VAR_13 && (!VAR_12 || mxA.x != mxB.x || mxA.y != mxB.y))\nmvpcand_list[VAR_14++] = mxB;", "if (VAR_14 < 2 && VAR_0->sh.slice_temporal_mvp_enabled_flag &&\nVAR_9 == VAR_14) {", "Mv mv_col;", "int VAR_40 = temporal_luma_motion_vector(VAR_0, VAR_1, VAR_2, VAR_3,\nVAR_4, VAR_32,\n&mv_col, VAR_10);", "if (VAR_40)\nmvpcand_list[VAR_14++] = mv_col;", "}", "VAR_8->VAR_8[VAR_10] = mvpcand_list[VAR_9];", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 87 ], [ 89 ], [ 93, 95, 97 ], [ 103 ], [ 105 ], [ 109 ], [ 111, 113 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 131 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 187 ], [ 191, 197 ], [ 199 ], [ 203, 205, 207 ], [ 213 ], [ 215 ], [ 217 ], [ 223 ], [ 225 ], [ 227 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 253 ], [ 255 ], [ 257 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 267 ], [ 273 ], [ 275 ], [ 277 ], [ 279 ], [ 281 ], [ 283 ], [ 285 ], [ 287 ], [ 289 ], [ 293, 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 311 ], [ 313 ], [ 315, 317 ], [ 319 ], [ 323 ], [ 325 ], [ 327, 329 ], [ 331 ], [ 335 ], [ 337 ], [ 339, 341 ], [ 343 ], [ 345 ], [ 349, 351 ], [ 355, 357 ], [ 363, 365 ], [ 367 ], [ 369, 371, 373 ], [ 375, 377 ], [ 379 ], [ 383 ], [ 385 ] ]

[ "static void FUNC_0(MachineState *VAR_0)\n{", "smbios_legacy_mode = true;", "has_reserved_memory = false;", "}" ]

[ 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 22 ], [ 24 ], [ 26 ] ]

[ "static CharDriverState *FUNC_0(const char *id,\nChardevBackend *backend,\nChardevReturn *ret,\nError **errp)\n{", "ChardevCommon *common = backend->u.msmouse.data;", "MouseState *mouse;", "CharDriverState *chr;", "chr = qemu_chr_alloc(common, errp);", "chr->chr_write = msmouse_chr_write;", "chr->chr_close = msmouse_chr_close;", "chr->chr_accept_input = msmouse_chr_accept_input;", "chr->explicit_be_open = true;", "mouse = g_new0(MouseState, 1);", "mouse->hs = qemu_input_handler_register((DeviceState *)mouse,\n&msmouse_handler);", "mouse->chr = chr;", "chr->opaque = mouse;", "return chr;" ]

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

[ [ 1, 3, 5, 7, 9 ], [ 11 ], [ 13 ], [ 15 ], [ 19 ], [ 24 ], [ 26 ], [ 28 ], [ 30 ], [ 34 ], [ 36, 38 ], [ 42 ], [ 44 ], [ 48 ] ]

[ "int FUNC_0(CPUState *VAR_0, int VAR_1, void *VAR_2)\n{", "#ifdef KVM_CAP_MCE\nram_addr_t ram_addr;", "target_phys_addr_t paddr;", "if ((VAR_0->mcg_cap & MCG_SER_P) && VAR_2\n&& (VAR_1 == BUS_MCEERR_AR || VAR_1 == BUS_MCEERR_AO)) {", "if (qemu_ram_addr_from_host(VAR_2, &ram_addr) ||\n!kvm_physical_memory_addr_from_ram(VAR_0->kvm_state, ram_addr,\n&paddr)) {", "fprintf(stderr, \"Hardware memory error for memory used by \"\n\"QEMU itself instead of guest system!\\n\");", "if (VAR_1 == BUS_MCEERR_AO) {", "return 0;", "} else {", "hardware_memory_error();", "}", "}", "kvm_mce_inject(VAR_0, paddr, VAR_1);", "} else", "#endif\n{", "if (VAR_1 == BUS_MCEERR_AO) {", "return 0;", "} else if (VAR_1 == BUS_MCEERR_AR) {", "hardware_memory_error();", "} else {", "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 ]

[ [ 1, 3 ], [ 5, 7 ], [ 9 ], [ 13, 15 ], [ 17, 19, 21 ], [ 23, 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 42 ], [ 44 ], [ 46, 48 ], [ 50 ], [ 52 ], [ 54 ], [ 56 ], [ 58 ], [ 60 ], [ 62 ], [ 64 ], [ 66 ], [ 68 ] ]

[ "static int FUNC_0(VC1Context *VAR_0, DCTELEM VAR_1[64], int VAR_2, int VAR_3, int VAR_4, int VAR_5)\n{", "GetBitContext *gb = &VAR_0->s.gb;", "MpegEncContext *s = &VAR_0->s;", "int VAR_6 = 0;", "int VAR_7, VAR_8;", "int16_t *dc_val;", "int16_t *ac_val, *ac_val2;", "int VAR_9;", "int VAR_10 = s->mb_x + s->mb_y * s->mb_stride;", "int VAR_11 = VAR_0->VAR_11, VAR_12 = VAR_0->VAR_12;", "int VAR_13 = s->ac_pred;", "int VAR_14;", "int VAR_15, VAR_16 = 0;", "VAR_4 = (VAR_4 < 1) ? 0 : ( (VAR_4>31) ? 31 : VAR_4 );", "s->y_dc_scale = s->y_dc_scale_table[VAR_4];", "s->c_dc_scale = s->c_dc_scale_table[VAR_4];", "if (VAR_2 < 4) {", "VAR_9 = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);", "} else {", "VAR_9 = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);", "}", "if (VAR_9 < 0){", "av_log(s->avctx, AV_LOG_ERROR, \"Illegal DC VLC\\VAR_2\");", "return -1;", "}", "if (VAR_9)\n{", "if (VAR_9 == 119 )\n{", "if (VAR_4 == 1) VAR_9 = get_bits(gb, 10);", "else if (VAR_4 == 2) VAR_9 = get_bits(gb, 9);", "else VAR_9 = get_bits(gb, 8);", "}", "else\n{", "if (VAR_4 == 1)\nVAR_9 = (VAR_9<<2) + get_bits(gb, 2) - 3;", "else if (VAR_4 == 2)\nVAR_9 = (VAR_9<<1) + get_bits(gb, 1) - 1;", "}", "if (get_bits(gb, 1))\nVAR_9 = -VAR_9;", "}", "VAR_9 += vc1_pred_dc(&VAR_0->s, VAR_0->overlap, VAR_4, VAR_2, VAR_11, VAR_12, &dc_val, &VAR_6);", "*dc_val = VAR_9;", "if (VAR_2 < 4) {", "VAR_1[0] = VAR_9 * s->y_dc_scale;", "} else {", "VAR_1[0] = VAR_9 * s->c_dc_scale;", "}", "VAR_7 = 0;", "VAR_8 = 0;", "VAR_8 = 1;", "if(!VAR_11) VAR_6 = 1;", "if(!VAR_12) VAR_6 = 0;", "if(!VAR_11 && !VAR_12) VAR_13 = 0;", "ac_val = s->ac_val[0][0] + s->block_index[VAR_2] * 16;", "ac_val2 = ac_val;", "VAR_14 = VAR_4 * 2 + VAR_0->halfpq;", "if(VAR_6)\nac_val -= 16;", "else\nac_val -= 16 * s->block_wrap[VAR_2];", "VAR_15 = s->current_picture.qscale_table[VAR_10];", "if(VAR_6 && VAR_12) VAR_16 = s->current_picture.qscale_table[VAR_10 - 1];", "if(!VAR_6 && VAR_11) VAR_16 = s->current_picture.qscale_table[VAR_10 - s->mb_stride];", "if(VAR_2 && VAR_2<4) VAR_16 = VAR_15;", "if(VAR_3) {", "int VAR_17 = 0, VAR_18, VAR_19;", "const int8_t *VAR_20;", "int VAR_22;", "VAR_20 = vc1_simple_progressive_8x8_zz;", "while (!VAR_17) {", "vc1_decode_ac_coeff(VAR_0, &VAR_17, &VAR_18, &VAR_19, VAR_5);", "VAR_8 += VAR_18;", "if(VAR_8 > 63)\nbreak;", "VAR_1[VAR_20[VAR_8++]] = VAR_19;", "}", "if(VAR_13) {", "if(VAR_16 && VAR_15!=VAR_16) {", "VAR_15 = VAR_15 * 2 + ((VAR_15 == VAR_0->pq) ? VAR_0->halfpq : 0) - 1;", "VAR_16 = VAR_16 * 2 + ((VAR_16 == VAR_0->pq) ? VAR_0->halfpq : 0) - 1;", "if(VAR_6) {", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++)", "VAR_1[VAR_22 << 3] += (ac_val[VAR_22] * VAR_16 * vc1_dqscale[VAR_15 - 1] + 0x20000) >> 18;", "} else {", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++)", "VAR_1[VAR_22] += (ac_val[VAR_22 + 8] * VAR_16 * vc1_dqscale[VAR_15 - 1] + 0x20000) >> 18;", "}", "} else {", "if(VAR_6) {", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++)", "VAR_1[VAR_22 << 3] += ac_val[VAR_22];", "} else {", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++)", "VAR_1[VAR_22] += ac_val[VAR_22 + 8];", "}", "}", "}", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++) {", "ac_val2[VAR_22] = VAR_1[VAR_22 << 3];", "ac_val2[VAR_22 + 8] = VAR_1[VAR_22];", "}", "for(VAR_22 = 1; VAR_22 < 64; VAR_22++)", "if(VAR_1[VAR_22]) {", "VAR_1[VAR_22] *= VAR_14;", "if(!VAR_0->pquantizer)\nVAR_1[VAR_22] += (VAR_1[VAR_22] < 0) ? -VAR_4 : VAR_4;", "}", "if(VAR_13) VAR_8 = 63;", "} else {", "int VAR_22;", "memset(ac_val2, 0, 16 * 2);", "if(VAR_6) {", "if(VAR_13) {", "memcpy(ac_val2, ac_val, 8 * 2);", "if(VAR_16 && VAR_15!=VAR_16) {", "VAR_15 = VAR_15 * 2 + ((VAR_15 == VAR_0->pq) ? VAR_0->halfpq : 0) - 1;", "VAR_16 = VAR_16 * 2 + ((VAR_16 == VAR_0->pq) ? VAR_0->halfpq : 0) - 1;", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++)", "ac_val2[VAR_22] = (ac_val2[VAR_22] * VAR_16 * vc1_dqscale[VAR_15 - 1] + 0x20000) >> 18;", "}", "}", "} else {", "if(VAR_13) {", "memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);", "if(VAR_16 && VAR_15!=VAR_16) {", "VAR_15 = VAR_15 * 2 + ((VAR_15 == VAR_0->pq) ? VAR_0->halfpq : 0) - 1;", "VAR_16 = VAR_16 * 2 + ((VAR_16 == VAR_0->pq) ? VAR_0->halfpq : 0) - 1;", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++)", "ac_val2[VAR_22 + 8] = (ac_val2[VAR_22 + 8] * VAR_16 * vc1_dqscale[VAR_15 - 1] + 0x20000) >> 18;", "}", "}", "}", "if(VAR_13) {", "if(VAR_6) {", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++) {", "VAR_1[VAR_22 << 3] = ac_val2[VAR_22] * VAR_14;", "if(!VAR_0->pquantizer && VAR_1[VAR_22 << 3])\nVAR_1[VAR_22 << 3] += (VAR_1[VAR_22 << 3] < 0) ? -VAR_4 : VAR_4;", "}", "} else {", "for(VAR_22 = 1; VAR_22 < 8; VAR_22++) {", "VAR_1[VAR_22] = ac_val2[VAR_22 + 8] * VAR_14;", "if(!VAR_0->pquantizer && VAR_1[VAR_22])\nVAR_1[VAR_22] += (VAR_1[VAR_22] < 0) ? -VAR_4 : VAR_4;", "}", "}", "VAR_8 = 63;", "}", "}", "s->block_last_index[VAR_2] = VAR_8;", "return 0;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 27 ], [ 33 ], [ 39 ], [ 41 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65, 67 ], [ 69, 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83, 85 ], [ 87, 89 ], [ 91, 93 ], [ 95 ], [ 97, 99 ], [ 101 ], [ 107 ], [ 109 ], [ 117 ], [ 119 ], [ 121 ], [ 123 ], [ 125 ], [ 129 ], [ 131 ], [ 137 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 151 ], [ 155 ], [ 159, 161 ], [ 163, 165 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 179 ], [ 181 ], [ 183 ], [ 185 ], [ 189 ], [ 193 ], [ 195 ], [ 197 ], [ 199, 201 ], [ 203 ], [ 205 ], [ 211 ], [ 215 ], [ 217 ], [ 219 ], [ 223 ], [ 225 ], [ 227 ], [ 229 ], [ 231 ], [ 233 ], [ 235 ], [ 237 ], [ 239 ], [ 241 ], [ 243 ], [ 245 ], [ 247 ], [ 249 ], [ 251 ], [ 253 ], [ 255 ], [ 259 ], [ 261 ], [ 263 ], [ 265 ], [ 271 ], [ 273 ], [ 275 ], [ 277, 279 ], [ 281 ], [ 285 ], [ 287 ], [ 289 ], [ 293 ], [ 295 ], [ 297 ], [ 299 ], [ 301 ], [ 303 ], [ 305 ], [ 307 ], [ 309 ], [ 311 ], [ 313 ], [ 315 ], [ 317 ], [ 319 ], [ 321 ], [ 323 ], [ 325 ], [ 327 ], [ 329 ], [ 331 ], [ 333 ], [ 335 ], [ 341 ], [ 343 ], [ 345 ], [ 347 ], [ 349, 351 ], [ 353 ], [ 355 ], [ 357 ], [ 359 ], [ 361, 363 ], [ 365 ], [ 367 ], [ 369 ], [ 371 ], [ 373 ], [ 375 ], [ 379 ], [ 381 ] ]

[ "static int FUNC_0(GetBitContext* VAR_0, uint64_t VAR_1) {", "return get_bits_left(VAR_0) >= VAR_1;", "}" ]

[ 0, 0, 0 ]

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

[ "static int FUNC_0(AVProbeData *VAR_0)\n{", "const uint8_t *VAR_1 = VAR_0->buf;", "if (VAR_0->buf_size < 4)\nreturn 0;", "if (VAR_1[0] == 'T' && VAR_1[1] == 'T' && VAR_1[2] == 'A' && VAR_1[3] == '1')\nreturn 80;", "return 0;", "}" ]

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

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

[ "static void FUNC_0(BlockDriverState *VAR_0, Qcow2Cache *VAR_1,\nint VAR_2, int VAR_3)\n{", "#ifdef CONFIG_LINUX\nBDRVQcow2State *s = VAR_0->opaque;", "void *t = qcow2_cache_get_table_addr(VAR_0, VAR_1, VAR_2);", "int align = getpagesize();", "size_t mem_size = (size_t) s->cluster_size * VAR_3;", "size_t offset = QEMU_ALIGN_UP((uintptr_t) t, align) - (uintptr_t) t;", "size_t length = QEMU_ALIGN_DOWN(mem_size - offset, align);", "if (length > 0) {", "madvise((uint8_t *) t + offset, length, MADV_DONTNEED);", "}", "#endif\n}" ]

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

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

[ "static void FUNC_0(void)\n{", "kqemu_comm_base = 0xff000000 | 1;", "qpi_io_memory = cpu_register_io_memory(\nqpi_mem_read,\nqpi_mem_write, NULL);", "cpu_register_physical_memory(kqemu_comm_base & ~0xfff,\n0x1000, qpi_io_memory);", "}" ]

[ 0, 0, 0, 0, 0 ]

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

[ "FUNC_0(VncState *VAR_0, int VAR_1, int VAR_2)\n{", "uint errors;", "int VAR_3 = VAR_0->tight.VAR_3;", "int VAR_4 = VAR_0->tight.VAR_4;", "if (!VAR_0->vd->lossy) {", "return 0;", "}", "if (ds_get_bytes_per_pixel(VAR_0->ds) == 1 ||\nVAR_0->clientds.pf.bytes_per_pixel == 1 ||\nVAR_1 < VNC_TIGHT_DETECT_MIN_WIDTH || VAR_2 < VNC_TIGHT_DETECT_MIN_HEIGHT) {", "return 0;", "}", "if (VAR_0->tight.VAR_4 != -1) {", "if (VAR_1 * VAR_2 < VNC_TIGHT_JPEG_MIN_RECT_SIZE) {", "return 0;", "}", "} else {", "if (VAR_1 * VAR_2 < tight_conf[VAR_3].gradient_min_rect_size) {", "return 0;", "}", "}", "if (VAR_0->clientds.pf.bytes_per_pixel == 4) {", "if (VAR_0->tight.pixel24) {", "errors = tight_detect_smooth_image24(VAR_0, VAR_1, VAR_2);", "if (VAR_0->tight.VAR_4 != -1) {", "return (errors < tight_conf[VAR_4].jpeg_threshold24);", "}", "return (errors < tight_conf[VAR_3].gradient_threshold24);", "} else {", "errors = tight_detect_smooth_image32(VAR_0, VAR_1, VAR_2);", "}", "} else {", "errors = tight_detect_smooth_image16(VAR_0, VAR_1, VAR_2);", "}", "if (VAR_4 != -1) {", "return (errors < tight_conf[VAR_4].jpeg_threshold);", "}", "return (errors < tight_conf[VAR_3].gradient_threshold);", "}" ]

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

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

[ "static void FUNC_0(AVFormatContext *VAR_0, int VAR_1)\n{", "const struct video_data *VAR_2 = VAR_0->priv_data;", "struct v4l2_fmtdesc VAR_3 = { .VAR_1 = V4L2_BUF_TYPE_VIDEO_CAPTURE };", "while(!v4l2_ioctl(VAR_2->fd, VIDIOC_ENUM_FMT, &VAR_3)) {", "enum AVCodecID VAR_4 = avpriv_fmt_v4l2codec(VAR_3.pixelformat);", "enum AVPixelFormat VAR_5 = avpriv_fmt_v4l2ff(VAR_3.pixelformat, VAR_4);", "VAR_3.index++;", "if (!(VAR_3.flags & V4L2_FMT_FLAG_COMPRESSED) &&\nVAR_1 & V4L_RAWFORMATS) {", "const char *VAR_6 = av_get_pix_fmt_name(VAR_5);", "av_log(VAR_0, AV_LOG_INFO, \"Raw : %9s : %20s :\",\nVAR_6 ? VAR_6 : \"Unsupported\",\nVAR_3.description);", "} else if (VAR_3.flags & V4L2_FMT_FLAG_COMPRESSED &&", "VAR_1 & V4L_COMPFORMATS) {", "AVCodec *codec = avcodec_find_decoder(VAR_4);", "av_log(VAR_0, AV_LOG_INFO, \"Compressed: %9s : %20s :\",\ncodec ? codec->name : \"Unsupported\",\nVAR_3.description);", "} else {", "continue;", "}", "#ifdef V4L2_FMT_FLAG_EMULATED\nif (VAR_3.flags & V4L2_FMT_FLAG_EMULATED)\nav_log(VAR_0, AV_LOG_INFO, \" Emulated :\");", "#endif\n#if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE\nlist_framesizes(VAR_0, VAR_3.pixelformat);", "#endif\nav_log(VAR_0, AV_LOG_INFO, \"\\n\");", "}", "}" ]

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

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

[ "static CharDriverState *FUNC_0(int fd, Error **errp)\n{", "CharDriverState *chr;", "ParallelCharDriver *drv;", "if (ioctl(fd, PPCLAIM) < 0) {", "error_setg_errno(errp, errno, \"not a parallel port\");", "close(fd);", "return NULL;", "}", "drv = g_new0(ParallelCharDriver, 1);", "drv->fd = fd;", "drv->mode = IEEE1284_MODE_COMPAT;", "chr = qemu_chr_alloc();", "chr->chr_write = null_chr_write;", "chr->chr_ioctl = pp_ioctl;", "chr->chr_close = pp_close;", "chr->opaque = drv;", "return chr;", "}" ]

[ 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 ], [ 23 ], [ 25 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ] ]

[ "static QError *FUNC_0(const char *fmt, va_list *va)\n{", "QError *qerr;", "qerr = qerror_new();", "loc_save(&qerr->loc);", "qerr->error = error_obj_from_fmt_no_fail(fmt, va);", "qerr->err_msg = qerror_format(fmt, qerr->error);", "return qerr;", "}" ]

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

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

[ "static void FUNC_0(void)\n{", "sigset_t set;", "sigemptyset(&set);", "sigaddset(&set, SIGUSR2);", "sigaddset(&set, SIGIO);", "sigaddset(&set, SIGALRM);", "pthread_sigmask(SIG_UNBLOCK, &set, NULL);", "sigemptyset(&set);", "sigaddset(&set, SIGUSR1);", "pthread_sigmask(SIG_BLOCK, &set, NULL);", "}" ]

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

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

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

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

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

[ "float32 FUNC_0( float32 a STATUS_PARAM)\n{", "flag aSign;", "int16 aExp;", "bits32 lastBitMask, roundBitsMask;", "int8 roundingMode;", "float32 z;", "aExp = extractFloat32Exp( a );", "if ( 0x96 <= aExp ) {", "if ( ( aExp == 0xFF ) && extractFloat32Frac( a ) ) {", "return propagateFloat32NaN( a, a STATUS_VAR );", "}", "return a;", "}", "if ( aExp <= 0x7E ) {", "if ( (bits32) ( a<<1 ) == 0 ) return a;", "STATUS(float_exception_flags) |= float_flag_inexact;", "aSign = extractFloat32Sign( a );", "switch ( STATUS(float_rounding_mode) ) {", "case float_round_nearest_even:\nif ( ( aExp == 0x7E ) && extractFloat32Frac( a ) ) {", "return packFloat32( aSign, 0x7F, 0 );", "}", "break;", "case float_round_down:\nreturn aSign ? 0xBF800000 : 0;", "case float_round_up:\nreturn aSign ? 0x80000000 : 0x3F800000;", "}", "return packFloat32( aSign, 0, 0 );", "}", "lastBitMask = 1;", "lastBitMask <<= 0x96 - aExp;", "roundBitsMask = lastBitMask - 1;", "z = a;", "roundingMode = STATUS(float_rounding_mode);", "if ( roundingMode == float_round_nearest_even ) {", "z += lastBitMask>>1;", "if ( ( z & roundBitsMask ) == 0 ) z &= ~ lastBitMask;", "}", "else if ( roundingMode != float_round_to_zero ) {", "if ( extractFloat32Sign( z ) ^ ( roundingMode == float_round_up ) ) {", "z += roundBitsMask;", "}", "}", "z &= ~ roundBitsMask;", "if ( z != a ) STATUS(float_exception_flags) |= float_flag_inexact;", "return z;", "}" ]

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

[ "static void FUNC_0(DriveBackup *VAR_0, BlockJobTxn *VAR_1, Error **VAR_2)\n{", "BlockDriverState *bs;", "BlockDriverState *target_bs;", "BlockDriverState *source = NULL;", "BdrvDirtyBitmap *bmap = NULL;", "AioContext *aio_context;", "QDict *options = NULL;", "Error *local_err = NULL;", "int VAR_3;", "int64_t size;", "if (!VAR_0->has_speed) {", "VAR_0->speed = 0;", "}", "if (!VAR_0->has_on_source_error) {", "VAR_0->on_source_error = BLOCKDEV_ON_ERROR_REPORT;", "}", "if (!VAR_0->has_on_target_error) {", "VAR_0->on_target_error = BLOCKDEV_ON_ERROR_REPORT;", "}", "if (!VAR_0->has_mode) {", "VAR_0->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;", "}", "if (!VAR_0->has_job_id) {", "VAR_0->job_id = NULL;", "}", "bs = qmp_get_root_bs(VAR_0->device, VAR_2);", "if (!bs) {", "return;", "}", "aio_context = bdrv_get_aio_context(bs);", "aio_context_acquire(aio_context);", "if (!VAR_0->has_format) {", "VAR_0->format = VAR_0->mode == NEW_IMAGE_MODE_EXISTING ?\nNULL : (char*) bs->drv->format_name;", "}", "if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, VAR_2)) {", "goto out;", "}", "VAR_3 = bs->open_flags | BDRV_O_RDWR;", "if (VAR_0->sync == MIRROR_SYNC_MODE_TOP) {", "source = backing_bs(bs);", "if (!source) {", "VAR_0->sync = MIRROR_SYNC_MODE_FULL;", "}", "}", "if (VAR_0->sync == MIRROR_SYNC_MODE_NONE) {", "source = bs;", "}", "size = bdrv_getlength(bs);", "if (size < 0) {", "error_setg_errno(VAR_2, -size, \"bdrv_getlength failed\");", "goto out;", "}", "if (VAR_0->mode != NEW_IMAGE_MODE_EXISTING) {", "assert(VAR_0->format);", "if (source) {", "bdrv_img_create(VAR_0->target, VAR_0->format, source->filename,\nsource->drv->format_name, NULL,\nsize, VAR_3, &local_err, false);", "} else {", "bdrv_img_create(VAR_0->target, VAR_0->format, NULL, NULL, NULL,\nsize, VAR_3, &local_err, false);", "}", "}", "if (local_err) {", "error_propagate(VAR_2, local_err);", "goto out;", "}", "if (VAR_0->format) {", "options = qdict_new();", "qdict_put(options, \"driver\", qstring_from_str(VAR_0->format));", "}", "target_bs = bdrv_open(VAR_0->target, NULL, options, VAR_3, VAR_2);", "if (!target_bs) {", "goto out;", "}", "bdrv_set_aio_context(target_bs, aio_context);", "if (VAR_0->has_bitmap) {", "bmap = bdrv_find_dirty_bitmap(bs, VAR_0->bitmap);", "if (!bmap) {", "error_setg(VAR_2, \"Bitmap '%s' could not be found\", VAR_0->bitmap);", "bdrv_unref(target_bs);", "goto out;", "}", "}", "backup_start(VAR_0->job_id, bs, target_bs, VAR_0->speed, VAR_0->sync,\nbmap, VAR_0->on_source_error, VAR_0->on_target_error,\nblock_job_cb, bs, VAR_1, &local_err);", "bdrv_unref(target_bs);", "if (local_err != NULL) {", "error_propagate(VAR_2, local_err);", "goto out;", "}", "out:\naio_context_release(aio_context);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 67 ], [ 69 ], [ 73 ], [ 75, 77 ], [ 79 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 121 ], [ 123 ], [ 125 ], [ 127 ], [ 129 ], [ 133 ], [ 135 ], [ 137 ], [ 139, 141, 143 ], [ 145 ], [ 147, 149 ], [ 151 ], [ 153 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 187 ], [ 191 ], [ 193 ], [ 195 ], [ 197 ], [ 199 ], [ 201 ], [ 203 ], [ 205 ], [ 209, 211, 213 ], [ 215 ], [ 217 ], [ 219 ], [ 221 ], [ 223 ], [ 227, 229 ], [ 231 ] ]

[ "static int FUNC_0(BDRVQcowState *VAR_0, int64_t VAR_1,\nuint8_t *VAR_2, int VAR_3, bool VAR_4,\nError **VAR_5)\n{", "union {", "uint64_t ll[2];", "uint8_t b[16];", "} VAR_6;", "int VAR_7;", "int VAR_8;", "for(VAR_7 = 0; VAR_7 < VAR_3; VAR_7++) {", "VAR_6.ll[0] = cpu_to_le64(VAR_1);", "VAR_6.ll[1] = 0;", "if (qcrypto_cipher_setiv(VAR_0->cipher,\nVAR_6.b, G_N_ELEMENTS(VAR_6.b),\nVAR_5) < 0) {", "return -1;", "}", "if (VAR_4) {", "VAR_8 = qcrypto_cipher_encrypt(VAR_0->cipher,\nVAR_2, VAR_2,\n512,\nVAR_5);", "} else {", "VAR_8 = qcrypto_cipher_decrypt(VAR_0->cipher,\nVAR_2, VAR_2,\n512,\nVAR_5);", "}", "if (VAR_8 < 0) {", "return -1;", "}", "VAR_1++;", "VAR_2 += 512;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(BlockDriverState *VAR_0)\n{", "NBDClientSession *client = nbd_get_client_session(VAR_0);", "if (!client->ioc) {", "return;", "}", "qio_channel_shutdown(client->ioc,\nQIO_CHANNEL_SHUTDOWN_BOTH,\nNULL);", "nbd_recv_coroutines_enter_all(VAR_0);", "nbd_client_detach_aio_context(VAR_0);", "object_unref(OBJECT(client->sioc));", "client->sioc = NULL;", "object_unref(OBJECT(client->ioc));", "client->ioc = NULL;", "}" ]

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

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

[ "static int FUNC_0 (CinepakContext *VAR_0,\ncvid_strip *VAR_1, const uint8_t *VAR_2, int VAR_3)\n{", "const uint8_t *VAR_4 = (VAR_2 + VAR_3);", "int VAR_5, VAR_6;", "if (VAR_1->x1 >= VAR_0->width || VAR_1->x2 > VAR_0->width ||\nVAR_1->y1 >= VAR_0->height || VAR_1->y2 > VAR_0->height ||\nVAR_1->x1 >= VAR_1->x2 || VAR_1->y1 >= VAR_1->y2)\nreturn -1;", "while ((VAR_2 + 4) <= VAR_4) {", "VAR_5 = VAR_2[0];", "VAR_6 = AV_RB24 (&VAR_2[1]) - 4;", "if(VAR_6 < 0)\nreturn -1;", "VAR_2 += 4;", "VAR_6 = ((VAR_2 + VAR_6) > VAR_4) ? (VAR_4 - VAR_2) : VAR_6;", "switch (VAR_5) {", "case 0x20:\ncase 0x21:\ncase 0x24:\ncase 0x25:\ncinepak_decode_codebook (VAR_1->v4_codebook, VAR_5,\nVAR_6, VAR_2);", "break;", "case 0x22:\ncase 0x23:\ncase 0x26:\ncase 0x27:\ncinepak_decode_codebook (VAR_1->v1_codebook, VAR_5,\nVAR_6, VAR_2);", "break;", "case 0x30:\ncase 0x31:\ncase 0x32:\nreturn cinepak_decode_vectors (VAR_0, VAR_1, VAR_5,\nVAR_6, VAR_2);", "}", "VAR_2 += VAR_6;", "}", "return -1;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 15, 17, 19, 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31, 33 ], [ 37 ], [ 39 ], [ 43 ], [ 47, 49, 51, 53, 55, 57 ], [ 59 ], [ 63, 65, 67, 69, 71, 73 ], [ 75 ], [ 79, 81, 83, 85, 87 ], [ 89 ], [ 93 ], [ 95 ], [ 99 ], [ 101 ] ]

[ "static int VAR_0 bdrv_driver_pwritev(BlockDriverState *bs,\nuint64_t offset, uint64_t bytes,\nQEMUIOVector *qiov, int flags)\n{", "BlockDriver *drv = bs->drv;", "int64_t sector_num = offset >> BDRV_SECTOR_BITS;", "unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;", "int ret;", "assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);", "assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);", "assert((bytes >> BDRV_SECTOR_BITS) <= BDRV_REQUEST_MAX_SECTORS);", "if (drv->bdrv_co_writev_flags) {", "ret = drv->bdrv_co_writev_flags(bs, sector_num, nb_sectors, qiov,\nflags);", "} else {", "assert(drv->supported_write_flags == 0);", "ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);", "}", "if (ret == 0 && (flags & BDRV_REQ_FUA) &&\n!(drv->supported_write_flags & BDRV_REQ_FUA))\n{", "ret = bdrv_co_flush(bs);", "}", "return ret;", "}" ]

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

[ "static void FUNC_0(int VAR_0, int VAR_1, int VAR_2,\nDisplayState *VAR_3, const char **VAR_4, int VAR_5,\nconst char *VAR_6, const char *VAR_7,\nconst char *VAR_8, const char *VAR_9)\n{", "if (VAR_9 == NULL)\nVAR_9 = \"TI SuperSparc II\";", "sun4m_common_init(VAR_0, VAR_2, VAR_3, VAR_6,\nVAR_7, VAR_8, VAR_9,\n1, PROM_ADDR);", "}" ]

[ 0, 0, 0, 0 ]

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

[ "static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,\nunsigned size)\n{", "PCIBonitoState *s = opaque;", "uint32_t saddr;", "saddr = (addr - BONITO_REGBASE) >> 2;", "DPRINTF(\"FUNC_0 \"TARGET_FMT_plx\"\\n\", addr);", "switch (saddr) {", "case BONITO_INTISR:\nreturn s->regs[saddr];", "default:\nreturn s->regs[saddr];", "}", "}" ]

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

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

[ "static int FUNC_0(AVFormatContext *VAR_0)\n{", "ASTMuxContext *ast = VAR_0->priv_data;", "AVIOContext *pb = VAR_0->pb;", "AVCodecContext *enc;", "unsigned int VAR_1;", "if (VAR_0->nb_streams == 1) {", "enc = VAR_0->streams[0]->codec;", "} else {", "av_log(VAR_0, AV_LOG_ERROR, \"only one stream is supported\\n\");", "return AVERROR(EINVAL);", "}", "if (enc->codec_id == AV_CODEC_ID_ADPCM_AFC) {", "av_log(VAR_0, AV_LOG_ERROR, \"muxing ADPCM AFC is not implemented\\n\");", "return AVERROR_PATCHWELCOME;", "}", "VAR_1 = ff_codec_get_tag(ff_codec_ast_tags, enc->codec_id);", "if (!VAR_1) {", "av_log(VAR_0, AV_LOG_ERROR, \"unsupported codec\\n\");", "return AVERROR(EINVAL);", "}", "if (ast->loopstart && ast->loopend && ast->loopstart >= ast->loopend) {", "av_log(VAR_0, AV_LOG_ERROR, \"loopend can't be less or equal to loopstart\\n\");", "return AVERROR(EINVAL);", "}", "CHECK_LOOP(start)\nCHECK_LOOP(end)\nffio_wfourcc(pb, \"STRM\");", "ast->size = avio_tell(pb);", "avio_wb32(pb, 0);", "avio_wb16(pb, VAR_1);", "avio_wb16(pb, 16);", "avio_wb16(pb, enc->channels);", "avio_wb16(pb, 0xFFFF);", "avio_wb32(pb, enc->sample_rate);", "ast->samples = avio_tell(pb);", "avio_wb32(pb, 0);", "avio_wb32(pb, 0);", "avio_wb32(pb, 0);", "avio_wb32(pb, 0);", "avio_wb32(pb, 0);", "avio_wl32(pb, 0x7F);", "avio_wb64(pb, 0);", "avio_wb64(pb, 0);", "avio_wb32(pb, 0);", "avio_flush(pb);", "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 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 63, 65, 69 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 119 ], [ 121 ] ]

[ "static int FUNC_0(HYuvContext *VAR_0)\n{", "GetBitContext gb;", "int VAR_1;", "init_get_bits(&gb, classic_shift_luma,\nclassic_shift_luma_table_size * 8);", "if (read_len_table(VAR_0->len[0], &gb) < 0)\nreturn -1;", "init_get_bits(&gb, classic_shift_chroma,\nclassic_shift_chroma_table_size * 8);", "if (read_len_table(VAR_0->len[1], &gb) < 0)\nreturn -1;", "for(VAR_1=0; VAR_1<256; VAR_1++) VAR_0->bits[0][VAR_1] = classic_add_luma [VAR_1];", "for(VAR_1=0; VAR_1<256; VAR_1++) VAR_0->bits[1][VAR_1] = classic_add_chroma[VAR_1];", "if (VAR_0->bitstream_bpp >= 24) {", "memcpy(VAR_0->bits[1], VAR_0->bits[0], 256 * sizeof(uint32_t));", "memcpy(VAR_0->len[1] , VAR_0->len [0], 256 * sizeof(uint8_t));", "}", "memcpy(VAR_0->bits[2], VAR_0->bits[1], 256 * sizeof(uint32_t));", "memcpy(VAR_0->len[2] , VAR_0->len [1], 256 * sizeof(uint8_t));", "for (VAR_1 = 0; VAR_1 < 3; VAR_1++) {", "ff_free_vlc(&VAR_0->vlc[VAR_1]);", "init_vlc(&VAR_0->vlc[VAR_1], VLC_BITS, 256, VAR_0->len[VAR_1], 1, 1,\nVAR_0->bits[VAR_1], 4, 4, 0);", "}", "generate_joint_tables(VAR_0);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(MachineState *VAR_0)\n{", "has_pci_info = false;", "has_acpi_build = false;", "smbios_defaults = false;", "if (!VAR_0->cpu_model) {", "VAR_0->cpu_model = \"486\";", "}", "x86_cpu_compat_disable_kvm_features(FEAT_KVM, KVM_FEATURE_PV_EOI);", "enable_compat_apic_id_mode();", "pc_init1(VAR_0, 0, 1);", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 16 ], [ 18 ], [ 20 ], [ 22 ], [ 24 ], [ 26 ], [ 28 ] ]

[ "static int FUNC_0(AACContext *VAR_0, IndividualChannelStream *VAR_1,\nGetBitContext *VAR_2)\n{", "const MPEG4AudioConfig *const VAR_3 = &VAR_0->oc[1].VAR_3;", "const int VAR_4 = VAR_3->object_type;", "const int VAR_5 = VAR_3->VAR_5;", "if (VAR_4 != AOT_ER_AAC_ELD) {", "if (get_bits1(VAR_2)) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"Reserved bit set.\\n\");", "return AVERROR_INVALIDDATA;", "}", "VAR_1->window_sequence[1] = VAR_1->window_sequence[0];", "VAR_1->window_sequence[0] = get_bits(VAR_2, 2);", "if (VAR_4 == AOT_ER_AAC_LD &&\nVAR_1->window_sequence[0] != ONLY_LONG_SEQUENCE) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"AAC LD is only defined for ONLY_LONG_SEQUENCE but \"\n\"window sequence %d found.\\n\", VAR_1->window_sequence[0]);", "VAR_1->window_sequence[0] = ONLY_LONG_SEQUENCE;", "return AVERROR_INVALIDDATA;", "}", "VAR_1->use_kb_window[1] = VAR_1->use_kb_window[0];", "VAR_1->use_kb_window[0] = get_bits1(VAR_2);", "}", "VAR_1->num_window_groups = 1;", "VAR_1->group_len[0] = 1;", "if (VAR_1->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {", "int VAR_6;", "VAR_1->max_sfb = get_bits(VAR_2, 4);", "for (VAR_6 = 0; VAR_6 < 7; VAR_6++) {", "if (get_bits1(VAR_2)) {", "VAR_1->group_len[VAR_1->num_window_groups - 1]++;", "} else {", "VAR_1->num_window_groups++;", "VAR_1->group_len[VAR_1->num_window_groups - 1] = 1;", "}", "}", "VAR_1->num_windows = 8;", "VAR_1->swb_offset = ff_swb_offset_128[VAR_5];", "VAR_1->num_swb = ff_aac_num_swb_128[VAR_5];", "VAR_1->tns_max_bands = ff_tns_max_bands_128[VAR_5];", "VAR_1->predictor_present = 0;", "} else {", "VAR_1->max_sfb = get_bits(VAR_2, 6);", "VAR_1->num_windows = 1;", "if (VAR_4 == AOT_ER_AAC_LD || VAR_4 == AOT_ER_AAC_ELD) {", "if (VAR_3->frame_length_short) {", "VAR_1->swb_offset = ff_swb_offset_480[VAR_5];", "VAR_1->num_swb = ff_aac_num_swb_480[VAR_5];", "VAR_1->tns_max_bands = ff_tns_max_bands_480[VAR_5];", "} else {", "VAR_1->swb_offset = ff_swb_offset_512[VAR_5];", "VAR_1->num_swb = ff_aac_num_swb_512[VAR_5];", "VAR_1->tns_max_bands = ff_tns_max_bands_512[VAR_5];", "}", "if (!VAR_1->num_swb || !VAR_1->swb_offset)\nreturn AVERROR_BUG;", "} else {", "VAR_1->swb_offset = ff_swb_offset_1024[VAR_5];", "VAR_1->num_swb = ff_aac_num_swb_1024[VAR_5];", "VAR_1->tns_max_bands = ff_tns_max_bands_1024[VAR_5];", "}", "if (VAR_4 != AOT_ER_AAC_ELD) {", "VAR_1->predictor_present = get_bits1(VAR_2);", "VAR_1->predictor_reset_group = 0;", "}", "if (VAR_1->predictor_present) {", "if (VAR_4 == AOT_AAC_MAIN) {", "if (decode_prediction(VAR_0, VAR_1, VAR_2)) {", "return AVERROR_INVALIDDATA;", "}", "} else if (VAR_4 == AOT_AAC_LC ||", "VAR_4 == AOT_ER_AAC_LC) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Prediction is not allowed in AAC-LC.\\n\");", "return AVERROR_INVALIDDATA;", "} else {", "if (VAR_4 == AOT_ER_AAC_LD) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"LTP in ER AAC LD not yet implemented.\\n\");", "return AVERROR_PATCHWELCOME;", "}", "if ((VAR_1->ltp.present = get_bits(VAR_2, 1)))\ndecode_ltp(&VAR_1->ltp, VAR_2, VAR_1->max_sfb);", "}", "}", "}", "if (VAR_1->max_sfb > VAR_1->num_swb) {", "av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"Number of scalefactor bands in group (%d) \"\n\"exceeds limit (%d).\\n\",\nVAR_1->max_sfb, VAR_1->num_swb);", "return AVERROR_INVALIDDATA;", "}", "return 0;", "}" ]

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

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

[ "static void FUNC_0(AVCodecContext *VAR_0,\nuint8_t *VAR_1, int VAR_2)\n{", "DVBSubContext *ctx = (DVBSubContext*) VAR_0->priv_data;", "uint8_t *buf_end = VAR_1 + VAR_2;", "int VAR_3, VAR_4;", "DVBSubRegion *region;", "DVBSubObject *object;", "DVBSubObjectDisplay *display;", "int VAR_5;", "if (VAR_2 < 10)\nreturn;", "VAR_3 = *VAR_1++;", "region = get_region(ctx, VAR_3);", "if (region == NULL)\n{", "region = av_mallocz(sizeof(DVBSubRegion));", "region->id = VAR_3;", "region->next = ctx->region_list;", "ctx->region_list = region;", "VAR_5 = ((*VAR_1++) >> 3) & 1;", "region->width = AV_RB16(VAR_1);", "VAR_1 += 2;", "region->height = AV_RB16(VAR_1);", "VAR_1 += 2;", "if (region->width * region->height != region->VAR_2) {", "if (region->pbuf != 0)\nav_free(region->pbuf);", "region->VAR_2 = region->width * region->height;", "region->pbuf = av_malloc(region->VAR_2);", "VAR_5 = 1;", "region->depth = 1 << (((*VAR_1++) >> 2) & 7);", "region->clut = *VAR_1++;", "if (region->depth == 8)\nregion->bgcolour = *VAR_1++;", "else {", "VAR_1 += 1;", "if (region->depth == 4)\nregion->bgcolour = (((*VAR_1++) >> 4) & 15);", "else\nregion->bgcolour = (((*VAR_1++) >> 2) & 3);", "#ifdef DEBUG\nav_log(VAR_0, AV_LOG_INFO, \"Region %d, (%dx%d)\\n\", VAR_3, region->width, region->height);", "#endif\nif (VAR_5) {", "memset(region->pbuf, region->bgcolour, region->VAR_2);", "#ifdef DEBUG\nav_log(VAR_0, AV_LOG_INFO, \"Fill region (%d)\\n\", region->bgcolour);", "#endif\ndelete_region_display_list(ctx, region);", "while (VAR_1 + 5 < buf_end) {", "VAR_4 = AV_RB16(VAR_1);", "VAR_1 += 2;", "object = get_object(ctx, VAR_4);", "if (object == NULL) {", "object = av_mallocz(sizeof(DVBSubObject));", "object->id = VAR_4;", "object->next = ctx->object_list;", "ctx->object_list = object;", "object->type = (*VAR_1) >> 6;", "display = av_mallocz(sizeof(DVBSubObjectDisplay));", "display->VAR_4 = VAR_4;", "display->VAR_3 = VAR_3;", "display->x_pos = AV_RB16(VAR_1) & 0xfff;", "VAR_1 += 2;", "display->y_pos = AV_RB16(VAR_1) & 0xfff;", "VAR_1 += 2;", "if ((object->type == 1 || object->type == 2) && VAR_1+1 < buf_end) {", "display->fgcolour = *VAR_1++;", "display->bgcolour = *VAR_1++;", "display->region_list_next = region->display_list;", "region->display_list = display;", "display->object_list_next = object->display_list;", "object->display_list = display;" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25, 27 ], [ 31 ], [ 35 ], [ 39, 41 ], [ 43 ], [ 47 ], [ 51 ], [ 53 ], [ 58 ], [ 62 ], [ 64 ], [ 66 ], [ 68 ], [ 72 ], [ 74, 76 ], [ 80 ], [ 84 ], [ 88 ], [ 93 ], [ 99 ], [ 103, 105 ], [ 107 ], [ 109 ], [ 113, 115 ], [ 117, 119 ], [ 124, 126 ], [ 128, 132 ], [ 134 ], [ 136, 138 ], [ 140, 145 ], [ 149 ], [ 151 ], [ 153 ], [ 157 ], [ 161 ], [ 163 ], [ 167 ], [ 169 ], [ 171 ], [ 176 ], [ 180 ], [ 184 ], [ 186 ], [ 190 ], [ 192 ], [ 194 ], [ 196 ], [ 200 ], [ 202 ], [ 204 ], [ 209 ], [ 211 ], [ 215 ], [ 217 ] ]

[ "int FUNC_0(const AVCodec *VAR_0)\n{", "if (VAR_0->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE || !VAR_0->init)\nreturn 0;", "av_assert0(ff_avcodec_locked);", "ff_avcodec_locked = 0;", "atomic_fetch_add(&entangled_thread_counter, -1);", "if (lockmgr_cb) {", "if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE))\nreturn -1;", "}", "return 0;", "}" ]

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

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

[ "static inline void FUNC_0(LZOContext *VAR_0, int VAR_1)\n{", "register const uint8_t *VAR_2 = VAR_0->in;", "register uint8_t *VAR_3 = VAR_0->out;", "if (VAR_1 > VAR_0->in_end - VAR_2) {", "VAR_1 = FFMAX(VAR_0->in_end - VAR_2, 0);", "VAR_0->error |= AV_LZO_INPUT_DEPLETED;", "}", "if (VAR_1 > VAR_0->out_end - VAR_3) {", "VAR_1 = FFMAX(VAR_0->out_end - VAR_3, 0);", "VAR_0->error |= AV_LZO_OUTPUT_FULL;", "}", "#if defined(INBUF_PADDED) && defined(OUTBUF_PADDED)\nAV_COPY32U(VAR_3, VAR_2);", "VAR_2 += 4;", "VAR_3 += 4;", "VAR_1 -= 4;", "if (VAR_1 > 0)\n#endif\nmemcpy(VAR_3, VAR_2, VAR_1);", "VAR_0->in = VAR_2 + VAR_1;", "VAR_0->out = VAR_3 + VAR_1;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 10 ], [ 12 ], [ 14 ], [ 16 ], [ 18 ], [ 20 ], [ 22 ], [ 24 ], [ 26, 28 ], [ 30 ], [ 32 ], [ 34 ], [ 36, 38, 40 ], [ 42 ], [ 44 ], [ 46 ] ]

[ "static int FUNC_0(void *VAR_0, AVIOContext *VAR_1, int VAR_2, int VAR_3, UID VAR_4)\n{", "MXFDescriptor *descriptor = VAR_0;", "switch(VAR_2) {", "case 0x3F01:\ndescriptor->sub_descriptors_count = avio_rb32(VAR_1);", "if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID))\nreturn -1;", "descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID));", "if (!descriptor->sub_descriptors_refs)\nreturn -1;", "avio_skip(VAR_1, 4);", "avio_read(VAR_1, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));", "break;", "case 0x3004:\navio_read(VAR_1, descriptor->essence_container_ul, 16);", "break;", "case 0x3006:\ndescriptor->linked_track_id = avio_rb32(VAR_1);", "break;", "case 0x3201:\navio_read(VAR_1, descriptor->essence_codec_ul, 16);", "break;", "case 0x3203:\ndescriptor->width = avio_rb32(VAR_1);", "break;", "case 0x3202:\ndescriptor->height = avio_rb32(VAR_1);", "break;", "case 0x320E:\ndescriptor->aspect_ratio.num = avio_rb32(VAR_1);", "descriptor->aspect_ratio.den = avio_rb32(VAR_1);", "break;", "case 0x3D03:\ndescriptor->sample_rate.num = avio_rb32(VAR_1);", "descriptor->sample_rate.den = avio_rb32(VAR_1);", "break;", "case 0x3D06:\navio_read(VAR_1, descriptor->essence_codec_ul, 16);", "break;", "case 0x3D07:\ndescriptor->channels = avio_rb32(VAR_1);", "break;", "case 0x3D01:\ndescriptor->bits_per_sample = avio_rb32(VAR_1);", "break;", "case 0x3401:\nmxf_read_pixel_layout(VAR_1, descriptor);", "break;", "default:\nif (IS_KLV_KEY(VAR_4, mxf_sony_mpeg4_extradata)) {", "descriptor->extradata = av_malloc(VAR_3 + FF_INPUT_BUFFER_PADDING_SIZE);", "if (!descriptor->extradata)\nreturn -1;", "descriptor->extradata_size = VAR_3;", "avio_read(VAR_1, descriptor->extradata, VAR_3);", "}", "break;", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVFilterContext *VAR_0, void *VAR_1, int VAR_2, int VAR_3)\n{", "AudioFIRContext *s = VAR_0->priv;", "const float *VAR_4 = (const float *)s->in[0]->extended_data[VAR_2];", "int VAR_5 = (s->index + 1) % 3;", "int VAR_6 = (s->index + 2) % 3;", "float *VAR_7 = s->VAR_7[VAR_2];", "AVFrame *out = VAR_1;", "float *VAR_8;", "float *VAR_9;", "int VAR_10, VAR_11, VAR_12;", "memset(VAR_7, 0, sizeof(*VAR_7) * s->fft_length);", "VAR_8 = s->VAR_8[VAR_2] + s->part_index * s->block_size;", "memset(VAR_8, 0, sizeof(*VAR_8) * s->fft_length);", "s->fdsp->vector_fmul_scalar(VAR_8 + s->part_size, VAR_4, s->dry_gain, s->nb_samples);", "emms_c();", "av_rdft_calc(s->rdft[VAR_2], VAR_8);", "VAR_8[2 * s->part_size] = VAR_8[1];", "VAR_8[1] = 0;", "VAR_12 = s->part_index;", "for (VAR_11 = 0; VAR_11 < s->nb_partitions; VAR_11++) {", "const int coffset = VAR_11 * s->coeff_size;", "const FFTComplex *coeff = s->coeff[VAR_2 * !s->one2many] + coffset;", "VAR_8 = s->VAR_8[VAR_2] + VAR_12 * s->block_size;", "s->fcmul_add(VAR_7, VAR_8, (const float *)coeff, s->part_size);", "if (VAR_12 == 0)\nVAR_12 = s->nb_partitions;", "VAR_12--;", "}", "VAR_7[1] = VAR_7[2 * s->part_size];", "av_rdft_calc(s->irdft[VAR_2], VAR_7);", "VAR_9 = (float *)s->buffer->extended_data[VAR_2] + VAR_5 * s->part_size;", "for (VAR_10 = 0; VAR_10 < s->part_size; VAR_10++) {", "VAR_9[VAR_10] += VAR_7[VAR_10];", "}", "VAR_9 = (float *)s->buffer->extended_data[VAR_2] + VAR_6 * s->part_size;", "memcpy(VAR_9, VAR_7 + s->part_size, s->part_size * sizeof(*VAR_9));", "VAR_9 = (float *)s->buffer->extended_data[VAR_2] + s->index * s->part_size;", "if (out) {", "float *VAR_13 = (float *)out->extended_data[VAR_2];", "s->fdsp->vector_fmul_scalar(VAR_13, VAR_9, s->gain * s->wet_gain, out->nb_samples);", "emms_c();", "}", "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 ]

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 33 ], [ 35 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 65, 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 91 ], [ 95 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 115 ], [ 117 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0,\nAVPacket *VAR_1)\n{", "AVStream *st = VAR_0->streams[0];", "AIFFInputContext *aiff = VAR_0->priv_data;", "int64_t max_size;", "int VAR_2, VAR_3;", "max_size = aiff->data_end - avio_tell(VAR_0->pb);", "if (max_size <= 0)\nreturn AVERROR_EOF;", "if (st->codec->block_align >= 17)\nVAR_3 = st->codec->block_align;", "else\nVAR_3 = (MAX_SIZE / st->codec->block_align) * st->codec->block_align;", "VAR_3 = FFMIN(max_size, VAR_3);", "VAR_2 = av_get_packet(VAR_0->pb, VAR_1, VAR_3);", "if (VAR_2 < 0)\nreturn VAR_2;", "if (VAR_3 >= st->codec->block_align)\nVAR_1->flags &= ~AV_PKT_FLAG_CORRUPT;", "VAR_1->stream_index = 0;", "VAR_1->duration = (VAR_2 / st->codec->block_align) * aiff->block_duration;", "return 0;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 19 ], [ 21, 23 ], [ 29, 31 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41, 43 ], [ 47, 49 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ] ]

[ "static int FUNC_0(AVFormatContext *VAR_0, AVIOContext *VAR_1)\n{", "AVIContext *avi = VAR_0->priv_data;", "char VAR_2[8];", "int VAR_3;", "avio_read(VAR_1, VAR_2, 4);", "avi->riff_end = avio_rl32(VAR_1);", "avi->riff_end += avio_tell(VAR_1);", "avio_read(VAR_1, VAR_2 + 4, 4);", "for (VAR_3 = 0; avi_headers[VAR_3][0]; VAR_3++)", "if (!memcmp(VAR_2, avi_headers[VAR_3], 8))\nbreak;", "if (!avi_headers[VAR_3][0])\nreturn AVERROR_INVALIDDATA;", "if (VAR_2[7] == 0x19)\nav_log(VAR_0, AV_LOG_INFO,\n\"This file has been generated by a totally broken muxer.\\n\");", "return 0;", "}" ]

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

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

[ "static int FUNC_0(TAKDecContext *VAR_0, int8_t VAR_1, int32_t *VAR_2, int VAR_3)\n{", "struct CParam VAR_4;", "GetBitContext *gb = &VAR_0->gb;", "int VAR_5;", "if (!VAR_1) {", "memset(VAR_2, 0, VAR_3 * sizeof(*VAR_2));", "return 0;", "}", "if (VAR_1 > FF_ARRAY_ELEMS(xcodes))\nreturn AVERROR_INVALIDDATA;", "VAR_4 = xcodes[VAR_1 - 1];", "for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++) {", "int VAR_6 = get_bits_long(gb, VAR_4.init);", "if (VAR_6 >= VAR_4.escape && get_bits1(gb)) {", "VAR_6 |= 1 << VAR_4.init;", "if (VAR_6 >= VAR_4.aescape) {", "int VAR_7 = get_unary(gb, 1, 9);", "if (VAR_7 == 9) {", "int VAR_8 = get_bits(gb, 3);", "if (VAR_8 > 0) {", "if (VAR_8 == 7) {", "VAR_8 += get_bits(gb, 5);", "if (VAR_8 > 29)\nreturn AVERROR_INVALIDDATA;", "}", "VAR_7 = get_bits_long(gb, VAR_8) + 1;", "VAR_6 += VAR_4.VAR_7 * VAR_7;", "}", "VAR_6 += VAR_4.bias;", "} else", "VAR_6 += VAR_4.VAR_7 * VAR_7 - VAR_4.escape;", "} else", "VAR_6 -= VAR_4.escape;", "}", "VAR_2[VAR_5] = (VAR_6 >> 1) ^ -(VAR_6 & 1);", "}", "return 0;", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "PAFVideoDecContext *c = VAR_0->priv_data;", "uint8_t code, *dst, *end;", "int VAR_4, VAR_5, VAR_6;", "if (VAR_3->size < 2)\nreturn AVERROR_INVALIDDATA;", "bytestream2_init(&c->gb, VAR_3->VAR_1, VAR_3->size);", "code = bytestream2_get_byte(&c->gb);", "if ((code & 0xF) > 4) {", "avpriv_request_sample(VAR_0, \"unknown/invalid code\");", "return AVERROR_INVALIDDATA;", "}", "if ((VAR_6 = ff_reget_buffer(VAR_0, c->pic)) < 0)\nreturn VAR_6;", "if (code & 0x20) {", "for (VAR_4 = 0; VAR_4 < 4; VAR_4++)", "memset(c->VAR_5[VAR_4], 0, c->frame_size);", "memset(c->pic->VAR_1[1], 0, AVPALETTE_SIZE);", "c->current_frame = 0;", "c->pic->key_frame = 1;", "c->pic->pict_type = AV_PICTURE_TYPE_I;", "} else {", "c->pic->key_frame = 0;", "c->pic->pict_type = AV_PICTURE_TYPE_P;", "}", "if (code & 0x40) {", "uint32_t *out = (uint32_t *)c->pic->VAR_1[1];", "int VAR_7, VAR_12;", "VAR_7 = bytestream2_get_byte(&c->gb);", "VAR_12 = bytestream2_get_byte(&c->gb) + 1;", "if (VAR_7 + VAR_12 > 256)\nreturn AVERROR_INVALIDDATA;", "if (bytestream2_get_bytes_left(&c->gb) < 3 * VAR_12)\nreturn AVERROR_INVALIDDATA;", "out += VAR_7;", "for (VAR_4 = 0; VAR_4 < VAR_12; VAR_4++) {", "unsigned VAR_9, VAR_10, VAR_11;", "VAR_9 = bytestream2_get_byteu(&c->gb);", "VAR_9 = VAR_9 << 2 | VAR_9 >> 4;", "VAR_10 = bytestream2_get_byteu(&c->gb);", "VAR_10 = VAR_10 << 2 | VAR_10 >> 4;", "VAR_11 = bytestream2_get_byteu(&c->gb);", "VAR_11 = VAR_11 << 2 | VAR_11 >> 4;", "*out++ = (0xFFU << 24) | (VAR_9 << 16) | (VAR_10 << 8) | VAR_11;", "}", "c->pic->palette_has_changed = 1;", "}", "switch (code & 0x0F) {", "case 0:\nif ((VAR_6 = decode_0(c, VAR_3->VAR_1, code)) < 0)\nreturn VAR_6;", "break;", "case 1:\ndst = c->VAR_5[c->current_frame];", "bytestream2_skip(&c->gb, 2);", "if (bytestream2_get_bytes_left(&c->gb) < c->video_size)\nreturn AVERROR_INVALIDDATA;", "bytestream2_get_bufferu(&c->gb, dst, c->video_size);", "break;", "case 2:\nVAR_5 = bytestream2_get_byte(&c->gb);", "if (VAR_5 > 3)\nreturn AVERROR_INVALIDDATA;", "if (VAR_5 != c->current_frame)\nmemcpy(c->VAR_5[c->current_frame], c->VAR_5[VAR_5], c->frame_size);", "break;", "case 4:\ndst = c->VAR_5[c->current_frame];", "end = dst + c->video_size;", "bytestream2_skip(&c->gb, 2);", "while (dst < end) {", "int8_t code;", "int VAR_12;", "if (bytestream2_get_bytes_left(&c->gb) < 2)\nreturn AVERROR_INVALIDDATA;", "code = bytestream2_get_byteu(&c->gb);", "VAR_12 = FFABS(code) + 1;", "if (dst + VAR_12 > end)\nreturn AVERROR_INVALIDDATA;", "if (code < 0)\nmemset(dst, bytestream2_get_byteu(&c->gb), VAR_12);", "else\nbytestream2_get_buffer(&c->gb, dst, VAR_12);", "dst += VAR_12;", "}", "break;", "default:\nav_assert0(0);", "}", "av_image_copy_plane(c->pic->VAR_1[0], c->pic->linesize[0],\nc->VAR_5[c->current_frame], c->width,\nc->width, c->height);", "c->current_frame = (c->current_frame + 1) & 3;", "if ((VAR_6 = av_frame_ref(VAR_1, c->pic)) < 0)\nreturn VAR_6;", "*VAR_2 = 1;", "return VAR_3->size;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15, 17 ], [ 21 ], [ 25 ], [ 27 ], [ 29 ], [ 31 ], [ 33 ], [ 37, 39 ], [ 43 ], [ 45 ], [ 47 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 69 ], [ 71 ], [ 73 ], [ 77 ], [ 79 ], [ 83, 85 ], [ 87, 89 ], [ 93 ], [ 95 ], [ 97 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 123 ], [ 125, 131, 133 ], [ 135 ], [ 137, 143 ], [ 147 ], [ 149, 151 ], [ 153 ], [ 155 ], [ 157, 165 ], [ 167, 169 ], [ 171, 173 ], [ 175 ], [ 177, 181 ], [ 183 ], [ 187 ], [ 191 ], [ 193 ], [ 195 ], [ 199, 201 ], [ 205 ], [ 207 ], [ 211, 213 ], [ 215, 217 ], [ 219, 221 ], [ 223 ], [ 225 ], [ 227 ], [ 229, 231 ], [ 233 ], [ 237, 239, 241 ], [ 245 ], [ 247, 249 ], [ 253 ], [ 257 ], [ 259 ] ]

[ "int FUNC_0(AVAudioResampleContext *VAR_0, double *VAR_1,\nint VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6;", "VAR_3 = av_get_channel_layout_nb_channels(VAR_0->in_channel_layout);", "VAR_4 = av_get_channel_layout_nb_channels(VAR_0->out_channel_layout);", "if ( VAR_3 < 0 || VAR_3 > AVRESAMPLE_MAX_CHANNELS ||\nVAR_4 < 0 || VAR_4 > AVRESAMPLE_MAX_CHANNELS) {", "av_log(VAR_0, AV_LOG_ERROR, \"Invalid channel layouts\\n\");", "return AVERROR(EINVAL);", "}", "switch (VAR_0->mix_coeff_type) {", "case AV_MIX_COEFF_TYPE_Q8:\nif (!VAR_0->am->matrix_q8[0]) {", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_1 is not set\\n\");", "return AVERROR(EINVAL);", "}", "for (VAR_6 = 0; VAR_6 < VAR_4; VAR_6++)", "for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++)", "VAR_1[VAR_6 * VAR_2 + VAR_5] = VAR_0->am->matrix_q8[VAR_6][VAR_5] / 256.0;", "break;", "case AV_MIX_COEFF_TYPE_Q15:\nif (!VAR_0->am->matrix_q15[0]) {", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_1 is not set\\n\");", "return AVERROR(EINVAL);", "}", "for (VAR_6 = 0; VAR_6 < VAR_4; VAR_6++)", "for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++)", "VAR_1[VAR_6 * VAR_2 + VAR_5] = VAR_0->am->matrix_q15[VAR_6][VAR_5] / 32768.0;", "break;", "case AV_MIX_COEFF_TYPE_FLT:\nif (!VAR_0->am->matrix_flt[0]) {", "av_log(VAR_0, AV_LOG_ERROR, \"VAR_1 is not set\\n\");", "return AVERROR(EINVAL);", "}", "for (VAR_6 = 0; VAR_6 < VAR_4; VAR_6++)", "for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++)", "VAR_1[VAR_6 * VAR_2 + VAR_5] = VAR_0->am->matrix_flt[VAR_6][VAR_5];", "break;", "default:\nav_log(VAR_0, AV_LOG_ERROR, \"Invalid mix coeff type\\n\");", "return AVERROR(EINVAL);", "}", "return 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 ]

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

[ "static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1, int VAR_2)\n{", "AVPacket out_pkt = { 0 }, flush_pkt = { 0 };", "AVStream *st = VAR_0->streams[VAR_2];", "uint8_t *data = VAR_1 ? VAR_1->data : NULL;", "int VAR_3 = VAR_1 ? VAR_1->VAR_3 : 0;", "int VAR_4 = 0, VAR_5 = 0;", "if (!VAR_1) {", "av_init_packet(&flush_pkt);", "VAR_1 = &flush_pkt;", "VAR_5 = 1;", "}", "while (VAR_3 > 0 || (VAR_1 == &flush_pkt && VAR_5)) {", "int VAR_6;", "av_init_packet(&out_pkt);", "VAR_6 = av_parser_parse2(st->parser, st->codec,\n&out_pkt.data, &out_pkt.VAR_3, data, VAR_3,\nVAR_1->pts, VAR_1->dts, VAR_1->pos);", "VAR_1->pts = VAR_1->dts = AV_NOPTS_VALUE;", "data += VAR_6;", "VAR_3 -= VAR_6;", "VAR_5 = !!out_pkt.VAR_3;", "if (!out_pkt.VAR_3)\ncontinue;", "if (VAR_1->side_data) {", "out_pkt.side_data = VAR_1->side_data;", "out_pkt.side_data_elems = VAR_1->side_data_elems;", "VAR_1->side_data = NULL;", "VAR_1->side_data_elems = 0;", "}", "out_pkt.duration = 0;", "if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {", "if (st->codec->sample_rate > 0) {", "out_pkt.duration =\nav_rescale_q_rnd(st->parser->duration,\n(AVRational) { 1, st->codec->sample_rate },", "st->time_base,\nAV_ROUND_DOWN);", "}", "}", "out_pkt.VAR_2 = st->index;", "out_pkt.pts = st->parser->pts;", "out_pkt.dts = st->parser->dts;", "out_pkt.pos = st->parser->pos;", "if (st->parser->key_frame == 1 ||\n(st->parser->key_frame == -1 &&\nst->parser->pict_type == AV_PICTURE_TYPE_I))\nout_pkt.flags |= AV_PKT_FLAG_KEY;", "compute_pkt_fields(VAR_0, st, st->parser, &out_pkt);", "if ((VAR_0->iformat->flags & AVFMT_GENERIC_INDEX) &&\nout_pkt.flags & AV_PKT_FLAG_KEY) {", "ff_reduce_index(VAR_0, st->index);", "av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,\n0, 0, AVINDEX_KEYFRAME);", "}", "if (out_pkt.data == VAR_1->data && out_pkt.VAR_3 == VAR_1->VAR_3) {", "out_pkt.buf = VAR_1->buf;", "VAR_1->buf = NULL;", "}", "if ((VAR_4 = av_dup_packet(&out_pkt)) < 0)\ngoto fail;", "if (!add_to_pktbuf(&VAR_0->internal->parse_queue, &out_pkt, &VAR_0->internal->parse_queue_end)) {", "av_packet_unref(&out_pkt);", "VAR_4 = AVERROR(ENOMEM);", "goto fail;", "}", "}", "if (VAR_1 == &flush_pkt) {", "av_parser_close(st->parser);", "st->parser = NULL;", "}", "fail:\nav_packet_unref(VAR_1);", "return VAR_4;", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 9 ], [ 11 ], [ 13 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25 ], [ 29 ], [ 31 ], [ 35 ], [ 37, 39, 41 ], [ 45 ], [ 49 ], [ 51 ], [ 55 ], [ 59, 61 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 73 ], [ 75 ], [ 81 ], [ 83 ], [ 85 ], [ 87, 89, 91 ], [ 93, 95 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 113, 115, 117, 119 ], [ 123 ], [ 127, 129 ], [ 131 ], [ 133, 135 ], [ 137 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149, 151 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 181, 183 ], [ 185 ], [ 187 ] ]

[ "int FUNC_0(DVDemuxContext *VAR_0, AVPacket *VAR_1,\nuint8_t* VAR_2, int VAR_3, int64_t VAR_4)\n{", "int VAR_5, VAR_6;", "uint8_t *ppcm[4] = {0};", "if (VAR_3 < DV_PROFILE_BYTES ||\n!(VAR_0->sys = avpriv_dv_frame_profile(VAR_0->sys, VAR_2, VAR_3)) ||\nVAR_3 < VAR_0->sys->frame_size) {", "return -1;", "}", "VAR_5 = dv_extract_audio_info(VAR_0, VAR_2);", "for (VAR_6 = 0; VAR_6 < VAR_0->ach; VAR_6++) {", "VAR_0->audio_pkt[VAR_6].VAR_4 = VAR_4;", "VAR_0->audio_pkt[VAR_6].VAR_5 = VAR_5;", "VAR_0->audio_pkt[VAR_6].pts = VAR_0->abytes * 30000*8 / VAR_0->ast[VAR_6]->codec->bit_rate;", "ppcm[VAR_6] = VAR_0->audio_buf[VAR_6];", "}", "dv_extract_audio(VAR_2, ppcm, VAR_0->sys);", "if (VAR_0->sys->height == 720) {", "if (VAR_2[1] & 0x0C) {", "VAR_0->audio_pkt[2].VAR_5 = VAR_0->audio_pkt[3].VAR_5 = 0;", "} else {", "VAR_0->audio_pkt[0].VAR_5 = VAR_0->audio_pkt[1].VAR_5 = 0;", "VAR_0->abytes += VAR_5;", "}", "} else {", "VAR_0->abytes += VAR_5;", "}", "VAR_5 = dv_extract_video_info(VAR_0, VAR_2);", "av_init_packet(VAR_1);", "VAR_1->data = VAR_2;", "VAR_1->VAR_4 = VAR_4;", "VAR_1->VAR_5 = VAR_5;", "VAR_1->flags |= AV_PKT_FLAG_KEY;", "VAR_1->stream_index = VAR_0->vst->id;", "VAR_1->pts = VAR_0->frames;", "VAR_0->frames++;", "return VAR_5;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 13, 15, 17 ], [ 19 ], [ 21 ], [ 29 ], [ 31 ], [ 33 ], [ 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 93 ], [ 97 ], [ 99 ] ]

[ "int FUNC_0 (CPUState *VAR_0, mmu_ctx_t *VAR_1,\ntarget_ulong VAR_2, int VAR_3, int VAR_4)\n{", "ppcemb_tlb_t *tlb;", "target_phys_addr_t raddr;", "int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;", "VAR_6 = -1;", "raddr = -1;", "VAR_9 = msr_pr;", "for (VAR_5 = 0; VAR_5 < VAR_0->nb_tlb; VAR_5++) {", "tlb = &VAR_0->tlb[VAR_5].tlbe;", "if (ppcemb_tlb_check(VAR_0, tlb, &raddr, VAR_2,\nVAR_0->spr[SPR_40x_PID], 0, VAR_5) < 0)\ncontinue;", "VAR_7 = (tlb->attr >> 4) & 0xF;", "VAR_8 = (VAR_0->spr[SPR_40x_ZPR] >> (28 - (2 * VAR_7))) & 0x3;", "#if defined (DEBUG_SOFTWARE_TLB)\nif (loglevel != 0) {", "fprintf(logfile, \"%s: TLB %d VAR_7 %d VAR_8 %d VAR_3 %d attr %08x\\n\",\n__func__, VAR_5, VAR_7, VAR_8, VAR_3, tlb->attr);", "}", "#endif\nswitch (VAR_8) {", "case 0x2:\nif (VAR_9 != 0)\ngoto check_perms;", "case 0x3:\nVAR_1->prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;", "VAR_6 = 0;", "break;", "case 0x0:\nif (VAR_9 != 0) {", "VAR_1->prot = 0;", "VAR_6 = -2;", "break;", "}", "case 0x1:\ncheck_perms:\nVAR_1->prot = tlb->prot;", "VAR_1->prot |= PAGE_EXEC;", "VAR_6 = check_prot(VAR_1->prot, VAR_3, VAR_4);", "break;", "}", "if (VAR_6 >= 0) {", "VAR_1->raddr = raddr;", "#if defined (DEBUG_SOFTWARE_TLB)\nif (loglevel != 0) {", "fprintf(logfile, \"%s: access granted \" ADDRX \" => \" REGX\n\" %d %d\\n\", __func__, VAR_2, VAR_1->raddr, VAR_1->prot,\nVAR_6);", "}", "#endif\nreturn 0;", "}", "}", "#if defined (DEBUG_SOFTWARE_TLB)\nif (loglevel != 0) {", "fprintf(logfile, \"%s: access refused \" ADDRX \" => \" REGX\n\" %d %d\\n\", __func__, VAR_2, raddr, VAR_1->prot,\nVAR_6);", "}", "#endif\nreturn VAR_6;", "}" ]

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

[ [ 1, 3, 5 ], [ 7 ], [ 9 ], [ 11 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 25, 27, 29 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39, 41 ], [ 43 ], [ 45, 49 ], [ 51, 53, 55 ], [ 59, 63 ], [ 65 ], [ 67 ], [ 69, 71 ], [ 73 ], [ 75 ], [ 77 ], [ 79 ], [ 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, 141 ], [ 143 ] ]

[ "int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1)\n{", "int64_t chunk = VAR_1 / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;", "if (VAR_0->dirty_bitmap != NULL &&\n(VAR_1 << BDRV_SECTOR_BITS) <= bdrv_getlength(VAR_0)) {", "return VAR_0->dirty_bitmap[chunk];", "} else {", "return 0;", "}", "}" ]

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

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

[ "static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{", "GDVContext *gdv = VAR_0->priv_data;", "GetByteContext *gb = &gdv->gb;", "PutByteContext *pb = &gdv->pb;", "AVFrame *frame = VAR_1;", "int VAR_4, VAR_5, VAR_6;", "const uint8_t *VAR_7 = av_packet_get_side_data(VAR_3, AV_PKT_DATA_PALETTE, &VAR_6);", "int VAR_8;", "unsigned VAR_9;", "uint8_t *dst;", "if ((VAR_4 = ff_get_buffer(VAR_0, frame, 0)) < 0)\nreturn VAR_4;", "if (VAR_7 && VAR_6 == AVPALETTE_SIZE)\nmemcpy(gdv->VAR_7, VAR_7, AVPALETTE_SIZE);", "bytestream2_init(gb, VAR_3->VAR_1, VAR_3->size);", "bytestream2_init_writer(pb, gdv->frame, gdv->frame_size);", "VAR_9 = bytestream2_get_le32(gb);", "VAR_8 = VAR_9 & 0xF;", "rescale(gdv, gdv->frame, VAR_0->width, VAR_0->height,\n!!(VAR_9 & 0x10), !!(VAR_9 & 0x20));", "switch (VAR_8) {", "case 1:\nmemset(gdv->frame + PREAMBLE_SIZE, 0, gdv->frame_size - PREAMBLE_SIZE);", "case 0:\nif (bytestream2_get_bytes_left(gb) < 256*3)\nreturn AVERROR_INVALIDDATA;", "for (VAR_5 = 0; VAR_5 < 256; VAR_5++) {", "unsigned VAR_10 = bytestream2_get_byte(gb);", "unsigned VAR_11 = bytestream2_get_byte(gb);", "unsigned VAR_12 = bytestream2_get_byte(gb);", "gdv->VAR_7[VAR_5] = 0xFFU << 24 | VAR_10 << 18 | VAR_11 << 10 | VAR_12 << 2;", "}", "break;", "case 2:\nVAR_4 = decompress_2(VAR_0);", "break;", "case 3:\nbreak;", "case 5:\nVAR_4 = decompress_5(VAR_0, VAR_9 >> 8);", "break;", "case 6:\nVAR_4 = decompress_68(VAR_0, VAR_9 >> 8, 0);", "break;", "case 8:\nVAR_4 = decompress_68(VAR_0, VAR_9 >> 8, 1);", "break;", "default:\nreturn AVERROR_INVALIDDATA;", "}", "memcpy(frame->VAR_1[1], gdv->VAR_7, AVPALETTE_SIZE);", "dst = frame->VAR_1[0];", "if (!gdv->scale_v && !gdv->scale_h) {", "int VAR_17 = PREAMBLE_SIZE, VAR_17 = 0;", "int VAR_17, VAR_17;", "for (VAR_17 = 0; VAR_17 < VAR_0->height; VAR_17++) {", "for (VAR_17 = 0; VAR_17 < VAR_0->width; VAR_17++) {", "dst[VAR_17+VAR_17] = gdv->frame[VAR_17+VAR_17];", "}", "VAR_17 += VAR_0->width;", "VAR_17 += frame->linesize[0];", "}", "} else {", "int VAR_17 = PREAMBLE_SIZE, VAR_17 = 0;", "int VAR_17, VAR_17;", "for (VAR_17 = 0; VAR_17 < VAR_0->height; VAR_17++) {", "if (!gdv->scale_v) {", "for (VAR_17 = 0; VAR_17 < VAR_0->width; VAR_17++) {", "dst[VAR_17 + VAR_17] = gdv->frame[VAR_17 + VAR_17];", "}", "} else {", "for (VAR_17 = 0; VAR_17 < VAR_0->width; VAR_17++) {", "dst[VAR_17 + VAR_17] = gdv->frame[VAR_17 + VAR_17/2];", "}", "}", "if (!gdv->scale_h || ((VAR_17 & 1) == 1)) {", "VAR_17 += !gdv->scale_v ? VAR_0->width : VAR_0->width/2;", "}", "VAR_17 += frame->linesize[0];", "}", "}", "*VAR_2 = 1;", "return VAR_4 < 0 ? VAR_4 : VAR_3->size;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 ], [ 15 ], [ 17 ], [ 19 ], [ 21 ], [ 23 ], [ 27, 29 ], [ 31, 33 ], [ 37 ], [ 39 ], [ 43 ], [ 45 ], [ 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 ], [ 117 ], [ 119 ], [ 123 ], [ 125 ], [ 127 ], [ 131 ], [ 133 ], [ 135 ], [ 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ], [ 149 ], [ 153 ], [ 155 ], [ 157 ], [ 159 ], [ 161 ], [ 163 ], [ 165 ], [ 167 ], [ 169 ], [ 171 ], [ 173 ], [ 175 ], [ 177 ], [ 179 ], [ 181 ], [ 183 ], [ 187 ], [ 191 ], [ 193 ] ]

[ "int FUNC_0(uint8_t *VAR_0, int VAR_1, const uint8_t *VAR_2 , int VAR_3, int VAR_4,\nint VAR_5, int VAR_6, int VAR_7, int VAR_8)\n{", "int VAR_9, VAR_10;", "uint8_t *out = VAR_0;", "for(VAR_10 = 0; VAR_10 < VAR_4; VAR_10 += VAR_9) {", "if((VAR_9 = count_pixels(VAR_2, VAR_4-VAR_10, VAR_3, 1)) > 1) {", "if(out + VAR_3 + 1 > VAR_0 + VAR_1) return -1;", "*out++ = (VAR_9 ^ VAR_6) + VAR_5;", "memcpy(out, VAR_2, VAR_3);", "out += VAR_3;", "} else {", "VAR_9 = count_pixels(VAR_2, VAR_4-VAR_10, VAR_3, 0);", "*out++ = (VAR_9 ^ VAR_8) + VAR_7;", "if(out + VAR_3*VAR_9 > VAR_0 + VAR_1) return -1;", "memcpy(out, VAR_2, VAR_3 * VAR_9);", "out += VAR_3 * VAR_9;", "}", "VAR_2 += VAR_9 * VAR_3;", "}", "return out - VAR_0;", "}" ]

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

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

[ "static void FUNC_0(VideoState *VAR_0, int VAR_1)\n{", "AVFormatContext *ic = VAR_0->ic;", "AVCodecContext *avctx;", "if (VAR_1 < 0 || VAR_1 >= ic->nb_streams)\nreturn;", "avctx = ic->streams[VAR_1]->codec;", "switch (avctx->codec_type) {", "case AVMEDIA_TYPE_AUDIO:\npacket_queue_abort(&VAR_0->audioq);", "SDL_CloseAudio();", "packet_queue_flush(&VAR_0->audioq);", "av_free_packet(&VAR_0->audio_pkt);", "if (VAR_0->swr_ctx)\nswr_free(&VAR_0->swr_ctx);", "av_freep(&VAR_0->audio_buf1);", "VAR_0->audio_buf = NULL;", "av_freep(&VAR_0->frame);", "if (VAR_0->rdft) {", "av_rdft_end(VAR_0->rdft);", "av_freep(&VAR_0->rdft_data);", "VAR_0->rdft = NULL;", "VAR_0->rdft_bits = 0;", "}", "break;", "case AVMEDIA_TYPE_VIDEO:\npacket_queue_abort(&VAR_0->videoq);", "SDL_LockMutex(VAR_0->pictq_mutex);", "SDL_CondSignal(VAR_0->pictq_cond);", "SDL_UnlockMutex(VAR_0->pictq_mutex);", "SDL_WaitThread(VAR_0->video_tid, NULL);", "packet_queue_flush(&VAR_0->videoq);", "break;", "case AVMEDIA_TYPE_SUBTITLE:\npacket_queue_abort(&VAR_0->subtitleq);", "SDL_LockMutex(VAR_0->subpq_mutex);", "VAR_0->subtitle_stream_changed = 1;", "SDL_CondSignal(VAR_0->subpq_cond);", "SDL_UnlockMutex(VAR_0->subpq_mutex);", "SDL_WaitThread(VAR_0->subtitle_tid, NULL);", "packet_queue_flush(&VAR_0->subtitleq);", "break;", "default:\nbreak;", "}", "ic->streams[VAR_1]->discard = AVDISCARD_ALL;", "avcodec_close(avctx);", "#if CONFIG_AVFILTER\nfree_buffer_pool(&VAR_0->buffer_pool);", "#endif\nswitch (avctx->codec_type) {", "case AVMEDIA_TYPE_AUDIO:\nVAR_0->audio_st = NULL;", "VAR_0->audio_stream = -1;", "break;", "case AVMEDIA_TYPE_VIDEO:\nVAR_0->video_st = NULL;", "VAR_0->video_stream = -1;", "break;", "case AVMEDIA_TYPE_SUBTITLE:\nVAR_0->subtitle_st = NULL;", "VAR_0->subtitle_stream = -1;", "break;", "default:\nbreak;", "}", "}" ]

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

[ [ 1, 3 ], [ 5 ], [ 7 ], [ 11, 13 ], [ 15 ], [ 19 ], [ 21, 23 ], [ 27 ], [ 31 ], [ 33 ], [ 35, 37 ], [ 39 ], [ 41 ], [ 43 ], [ 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61, 63 ], [ 71 ], [ 73 ], [ 75 ], [ 79 ], [ 83 ], [ 85 ], [ 87, 89 ], [ 97 ], [ 99 ], [ 103 ], [ 105 ], [ 109 ], [ 113 ], [ 115 ], [ 117, 119 ], [ 121 ], [ 125 ], [ 127 ], [ 129, 131 ], [ 133, 135 ], [ 137, 139 ], [ 141 ], [ 143 ], [ 145, 147 ], [ 149 ], [ 151 ], [ 153, 155 ], [ 157 ], [ 159 ], [ 161, 163 ], [ 165 ], [ 167 ] ]

[ "static inline int FUNC_0(MpegEncContext *VAR_0, int16_t *VAR_1, int VAR_2)\n{", "int VAR_3, VAR_4, VAR_5, VAR_6;", "RLTable *rl = &ff_rl_mpeg1;", "uint8_t * const scantable = VAR_0->intra_scantable.permutated;", "const uint16_t *VAR_7 = VAR_0->inter_matrix;", "const int VAR_8 = VAR_0->VAR_8;", "{", "OPEN_READER(re, &VAR_0->gb);", "VAR_4 = -1;", "UPDATE_CACHE(re, &VAR_0->gb);", "if (((int32_t)GET_CACHE(re, &VAR_0->gb)) < 0) {", "VAR_3 = (3 * VAR_8 * VAR_7[0]) >> 5;", "VAR_3 = (VAR_3 - 1) | 1;", "if (GET_CACHE(re, &VAR_0->gb) & 0x40000000)\nVAR_3 = -VAR_3;", "VAR_1[0] = VAR_3;", "VAR_4++;", "SKIP_BITS(re, &VAR_0->gb, 2);", "if (((int32_t)GET_CACHE(re, &VAR_0->gb)) <= (int32_t)0xBFFFFFFF)\ngoto end;", "}", "for (;;) {", "GET_RL_VLC(VAR_3, VAR_6, re, &VAR_0->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);", "if (VAR_3 != 0) {", "VAR_4 += VAR_6;", "VAR_5 = scantable[VAR_4];", "VAR_3 = ((VAR_3 * 2 + 1) * VAR_8 * VAR_7[VAR_5]) >> 5;", "VAR_3 = (VAR_3 - 1) | 1;", "VAR_3 = (VAR_3 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);", "SKIP_BITS(re, &VAR_0->gb, 1);", "} else {", "VAR_6 = SHOW_UBITS(re, &VAR_0->gb, 6) + 1; LAST_SKIP_BITS(re, &VAR_0->gb, 6);", "UPDATE_CACHE(re, &VAR_0->gb);", "VAR_3 = SHOW_SBITS(re, &VAR_0->gb, 8); SKIP_BITS(re, &VAR_0->gb, 8);", "if (VAR_3 == -128) {", "VAR_3 = SHOW_UBITS(re, &VAR_0->gb, 8) - 256; SKIP_BITS(re, &VAR_0->gb, 8);", "} else if (VAR_3 == 0) {", "VAR_3 = SHOW_UBITS(re, &VAR_0->gb, 8) ; SKIP_BITS(re, &VAR_0->gb, 8);", "}", "VAR_4 += VAR_6;", "VAR_5 = scantable[VAR_4];", "if (VAR_3 < 0) {", "VAR_3 = -VAR_3;", "VAR_3 = ((VAR_3 * 2 + 1) * VAR_8 * VAR_7[VAR_5]) >> 5;", "VAR_3 = (VAR_3 - 1) | 1;", "VAR_3 = -VAR_3;", "} else {", "VAR_3 = ((VAR_3 * 2 + 1) * VAR_8 * VAR_7[VAR_5]) >> 5;", "VAR_3 = (VAR_3 - 1) | 1;", "}", "}", "if (VAR_4 > 63) {", "av_log(VAR_0->avctx, AV_LOG_ERROR, \"ac-tex damaged at %d %d\\VAR_2\", VAR_0->mb_x, VAR_0->mb_y);", "return -1;", "}", "VAR_1[VAR_5] = VAR_3;", "if (((int32_t)GET_CACHE(re, &VAR_0->gb)) <= (int32_t)0xBFFFFFFF)\nbreak;", "UPDATE_CACHE(re, &VAR_0->gb);", "}", "end:\nLAST_SKIP_BITS(re, &VAR_0->gb, 2);", "CLOSE_READER(re, &VAR_0->gb);", "}", "VAR_0->block_last_index[VAR_2] = VAR_4;", "return 0;", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 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 ], [ 33, 35 ], [ 37 ], [ 39 ], [ 41 ], [ 43, 45 ], [ 47 ], [ 51 ], [ 53 ], [ 57 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 75 ], [ 77 ], [ 79 ], [ 81 ], [ 83 ], [ 85 ], [ 87 ], [ 89 ], [ 91 ], [ 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ], [ 107 ], [ 109 ], [ 111 ], [ 113 ], [ 115 ], [ 117 ], [ 119 ], [ 121 ], [ 125 ], [ 127, 129 ], [ 131 ], [ 133 ], [ 135, 137 ], [ 139 ], [ 141 ], [ 143 ], [ 145 ], [ 147 ] ]

[ "static void FUNC_0(AVCodecContext *VAR_0, VP8Frame *VAR_1,\nVP8Frame *VAR_2)\n{", "VP8Context *s = VAR_0->priv_data;", "int VAR_3, VAR_4;", "s->mv_min.y = -MARGIN;", "s->mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;", "for (VAR_4 = 0; VAR_4 < s->mb_height; VAR_4++) {", "VP8Macroblock *mb = s->macroblocks_base +\n((s->mb_width + 1) * (VAR_4 + 1) + 1);", "int mb_xy = VAR_4 * s->mb_width;", "AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);", "s->mv_min.x = -MARGIN;", "s->mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;", "for (VAR_3 = 0; VAR_3 < s->mb_width; VAR_3++, mb_xy++, mb++) {", "if (VAR_4 == 0)\nAV_WN32A((mb - s->mb_width - 1)->intra4x4_pred_mode_top,\nDC_PRED * 0x01010101);", "decode_mb_mode(s, mb, VAR_3, VAR_4, VAR_1->seg_map->data + mb_xy,\nVAR_2 && VAR_2->seg_map ?\nVAR_2->seg_map->data + mb_xy : NULL, 1);", "s->mv_min.x -= 64;", "s->mv_max.x -= 64;", "}", "s->mv_min.y -= 64;", "s->mv_max.y -= 64;", "}", "}" ]

[ 1, 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 ], [ 13 ], [ 15 ], [ 17 ], [ 19, 21 ], [ 23 ], [ 27 ], [ 31 ], [ 33 ], [ 35 ], [ 37, 39, 41 ], [ 43, 45, 47 ], [ 49 ], [ 51 ], [ 53 ], [ 55 ], [ 57 ], [ 59 ], [ 61 ] ]

[ "static struct omap_eac_s *FUNC_0(struct omap_target_agent_s *VAR_0,\nqemu_irq VAR_1, qemu_irq *VAR_2, omap_clk VAR_3, omap_clk VAR_4)\n{", "struct omap_eac_s *VAR_5 = (struct omap_eac_s *)\ng_malloc0(sizeof(struct omap_eac_s));", "VAR_5->VAR_1 = VAR_1;", "VAR_5->codec.rxdrq = *VAR_2 ++;", "VAR_5->codec.txdrq = *VAR_2;", "omap_eac_reset(VAR_5);", "AUD_register_card(\"OMAP EAC\", &VAR_5->codec.card);", "memory_region_init_io(&VAR_5->iomem, NULL, &omap_eac_ops, VAR_5, \"omap.eac\",\nomap_l4_region_size(VAR_0, 0));", "omap_l4_attach(VAR_0, 0, &VAR_5->iomem);", "return VAR_5;", "}" ]

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

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

[ "bool FUNC_0(void)\n{", "return runstate_check(RUN_STATE_INTERNAL_ERROR) ||\nrunstate_check(RUN_STATE_SHUTDOWN) ||\nrunstate_check(RUN_STATE_GUEST_PANICKED);", "}" ]

[ 0, 1, 0 ]

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

[ "int64_t FUNC_0(BlockDriverState *bs)\n{", "int64_t ret = bdrv_nb_sectors(bs);", "return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;", "}" ]

[ 0, 0, 0, 0 ]

[ [ 1, 3 ], [ 5 ], [ 10 ], [ 12 ] ]

[ "static av_always_inline void FUNC_0(VP9Context *s, vp9_scaled_mc_func smc,\nvp9_mc_func (*mc)[2],\nuint8_t *dst, ptrdiff_t dst_stride,\nconst uint8_t *ref, ptrdiff_t ref_stride,\nThreadFrame *ref_frame,\nptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,\nint px, int py, int pw, int ph,\nint bw, int bh, int w, int h, int bytesperpixel,\nconst uint16_t *scale, const uint8_t *step)\n{", "if (s->s.frames[CUR_FRAME].tf.f->width == ref_frame->f->width &&\ns->s.frames[CUR_FRAME].tf.f->height == ref_frame->f->height) {", "mc_luma_unscaled(s, mc, dst, dst_stride, ref, ref_stride, ref_frame,\ny, x, in_mv, bw, bh, w, h, bytesperpixel);", "} else {", "#define scale_mv(n, dim) (((int64_t)(n) * scale[dim]) >> 14)\nint VAR_0, VAR_1;", "int VAR_2, VAR_3;", "int VAR_4;", "VP56mv mv;", "mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 8, (s->cols * 8 - x + px + 3) * 8);", "mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 8, (s->rows * 8 - y + py + 3) * 8);", "VAR_0 = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);", "VAR_1 = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);", "y = VAR_1 >> 4;", "x = VAR_0 >> 4;", "ref += y * ref_stride + x * bytesperpixel;", "VAR_0 &= 15;", "VAR_1 &= 15;", "VAR_2 = ((bw - 1) * step[0] + VAR_0) >> 4;", "VAR_3 = ((bh - 1) * step[1] + VAR_1) >> 4;", "VAR_4 = (y + VAR_3 + 4 + 7) >> 6;", "ff_thread_await_progress(ref_frame, FFMAX(VAR_4, 0), 0);", "if (x < 3 || y < 3 || x + 4 >= w - VAR_2 || y + 4 >= h - VAR_3) {", "s->vdsp.emulated_edge_mc(s->edge_emu_buffer,\nref - 3 * ref_stride - 3 * bytesperpixel,\n288, ref_stride,\nVAR_2 + 8, VAR_3 + 8,\nx - 3, y - 3, w, h);", "ref = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;", "ref_stride = 288;", "}", "smc(dst, dst_stride, ref, ref_stride, bh, VAR_0, VAR_1, step[0], step[1]);", "}", "}" ]

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 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 ], [ 53 ], [ 55 ], [ 59 ], [ 61 ], [ 63 ], [ 65 ], [ 67 ], [ 69 ], [ 71 ], [ 79 ], [ 81 ], [ 83 ], [ 85, 87, 89, 91, 93 ], [ 95 ], [ 97 ], [ 99 ], [ 101 ], [ 103 ], [ 105 ] ]

[ "static void FUNC_0(uint8_t *VAR_0, int VAR_1, DCTELEM *VAR_2)\n{", "int VAR_3;", "register int VAR_4,VAR_5,VAR_6,VAR_7;", "DCTELEM *src, *dst;", "const uint8_t *VAR_8 = ff_cropTbl + MAX_NEG_CROP;", "src = VAR_2;", "dst = VAR_2;", "for(VAR_3 = 0; VAR_3 < 4; VAR_3++){", "VAR_4 = 17 * (src[0] + src[2]) + 4;", "VAR_5 = 17 * (src[0] - src[2]) + 4;", "VAR_6 = 22 * src[1] + 10 * src[3];", "VAR_7 = 22 * src[3] - 10 * src[1];", "dst[0] = (VAR_4 + VAR_6) >> 3;", "dst[1] = (VAR_5 - VAR_7) >> 3;", "dst[2] = (VAR_5 + VAR_7) >> 3;", "dst[3] = (VAR_4 - VAR_6) >> 3;", "src += 8;", "dst += 8;", "}", "src = VAR_2;", "for(VAR_3 = 0; VAR_3 < 4; VAR_3++){", "VAR_4 = 17 * (src[ 0] + src[16]) + 64;", "VAR_5 = 17 * (src[ 0] - src[16]) + 64;", "VAR_6 = 22 * src[ 8] + 10 * src[24];", "VAR_7 = 22 * src[24] - 10 * src[ 8];", "VAR_0[0*VAR_1] = VAR_8[VAR_0[0*VAR_1] + ((VAR_4 + VAR_6) >> 7)];", "VAR_0[1*VAR_1] = VAR_8[VAR_0[1*VAR_1] + ((VAR_5 - VAR_7) >> 7)];", "VAR_0[2*VAR_1] = VAR_8[VAR_0[2*VAR_1] + ((VAR_5 + VAR_7) >> 7)];", "VAR_0[3*VAR_1] = VAR_8[VAR_0[3*VAR_1] + ((VAR_4 - VAR_6) >> 7)];", "src ++;", "VAR_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, 0, 0, 0, 0 ]

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

[ "long FUNC_0(CPUSH4State *VAR_0)\n{", "struct target_rt_sigframe *VAR_1;", "abi_ulong frame_addr;", "sigset_t blocked;", "target_ulong r0;", "#if defined(DEBUG_SIGNAL)\nfprintf(stderr, \"FUNC_0\\n\");", "#endif\nframe_addr = VAR_0->gregs[15];", "if (!lock_user_struct(VERIFY_READ, VAR_1, frame_addr, 1))\ngoto badframe;", "target_to_host_sigset(&blocked, &VAR_1->uc.tuc_sigmask);", "do_sigprocmask(SIG_SETMASK, &blocked, NULL);", "if (restore_sigcontext(VAR_0, &VAR_1->uc.tuc_mcontext, &r0))\ngoto badframe;", "if (do_sigaltstack(frame_addr +\noffsetof(struct target_rt_sigframe, uc.tuc_stack),\n0, get_sp_from_cpustate(VAR_0)) == -EFAULT)\ngoto badframe;", "unlock_user_struct(VAR_1, frame_addr, 0);", "return r0;", "badframe:\nunlock_user_struct(VAR_1, frame_addr, 0);", "force_sig(TARGET_SIGSEGV);", "return 0;", "}" ]

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

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

[ "int FUNC_0(FFDrawContext *VAR_0, enum PixelFormat VAR_1, unsigned VAR_2)\n{", "const AVPixFmtDescriptor *VAR_3 = &av_pix_fmt_descriptors[VAR_1];", "const AVComponentDescriptor *VAR_4;", "unsigned VAR_5, VAR_6 = 0;", "int VAR_7[MAX_PLANES] = { 0 };", "if (!VAR_3->name)\nreturn AVERROR(EINVAL);", "if (VAR_3->VAR_2 & ~(PIX_FMT_PLANAR | PIX_FMT_RGB))\nreturn AVERROR(ENOSYS);", "for (VAR_5 = 0; VAR_5 < VAR_3->nb_components; VAR_5++) {", "VAR_4 = &VAR_3->comp[VAR_5];", "if (VAR_4->depth_minus1 != 8 - 1)\nreturn AVERROR(ENOSYS);", "if (VAR_4->plane >= MAX_PLANES)\nreturn AVERROR(ENOSYS);", "if (VAR_7[VAR_4->plane] != 0 &&\nVAR_7[VAR_4->plane] != VAR_4->step_minus1 + 1)\nreturn AVERROR(ENOSYS);", "VAR_7[VAR_4->plane] = VAR_4->step_minus1 + 1;", "if (VAR_7[VAR_4->plane] >= 8)\nreturn AVERROR(ENOSYS);", "VAR_6 = FFMAX(VAR_6, VAR_4->plane + 1);", "}", "if ((VAR_3->log2_chroma_w || VAR_3->log2_chroma_h) && VAR_6 < 3)\nreturn AVERROR(ENOSYS);", "memset(VAR_0, 0, sizeof(*VAR_0));", "VAR_0->VAR_3 = VAR_3;", "VAR_0->VAR_1 = VAR_1;", "VAR_0->VAR_6 = VAR_6;", "memcpy(VAR_0->VAR_7, VAR_7, sizeof(VAR_0->VAR_7));", "if (VAR_6 >= 3 && !(VAR_3->VAR_2 & PIX_FMT_RGB)) {", "VAR_0->hsub[1] = VAR_0->hsub[2] = VAR_0->hsub_max = VAR_3->log2_chroma_w;", "VAR_0->vsub[1] = VAR_0->vsub[2] = VAR_0->vsub_max = VAR_3->log2_chroma_h;", "}", "for (VAR_5 = 0; VAR_5 < ((VAR_3->nb_components - 1) | 1); VAR_5++)", "VAR_0->comp_mask[VAR_3->comp[VAR_5].plane] |=\n1 << (VAR_3->comp[VAR_5].offset_plus1 - 1);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(struct CharDriverState *VAR_0)\n{", "PtyCharDriver *s = VAR_0->opaque;", "int VAR_1;", "remove_fd_in_watch(VAR_0);", "VAR_1 = g_io_channel_unix_get_fd(s->VAR_1);", "g_io_channel_unref(s->VAR_1);", "close(VAR_1);", "if (s->timer_tag) {", "g_source_remove(s->timer_tag);", "s->timer_tag = 0;", "}", "g_free(s);", "qemu_chr_be_event(VAR_0, CHR_EVENT_CLOSED);", "}" ]

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

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

[ "av_cold void FUNC_0(DCTContext *s)\n{", "#if HAVE_YASM\nint has_vectors = av_get_cpu_flags();", "if (has_vectors & AV_CPU_FLAG_SSE && HAVE_SSE)\ns->dct32 = ff_dct32_float_sse;", "if (has_vectors & AV_CPU_FLAG_SSE2 && HAVE_SSE)\ns->dct32 = ff_dct32_float_sse2;", "if (has_vectors & AV_CPU_FLAG_AVX && HAVE_AVX)\ns->dct32 = ff_dct32_float_avx;", "#endif\n}" ]

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

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

[ "int FUNC_0(AVCodecContext *VAR_0, AVFrame *VAR_1)\n{", "AVFrame *tmp;", "int VAR_2;", "av_assert0(VAR_0->codec_type == AVMEDIA_TYPE_VIDEO);", "if (!VAR_1->data[0])\nreturn ff_get_buffer(VAR_0, VAR_1, AV_GET_BUFFER_FLAG_REF);", "if (av_frame_is_writable(VAR_1)) {", "VAR_1->pkt_pts = VAR_0->internal->pkt ? VAR_0->internal->pkt->pts : AV_NOPTS_VALUE;", "VAR_1->reordered_opaque = VAR_0->reordered_opaque;", "return 0;", "}", "tmp = av_frame_alloc();", "if (!tmp)\nreturn AVERROR(ENOMEM);", "av_frame_move_ref(tmp, VAR_1);", "VAR_2 = ff_get_buffer(VAR_0, VAR_1, AV_GET_BUFFER_FLAG_REF);", "if (VAR_2 < 0) {", "av_frame_free(&tmp);", "return VAR_2;", "}", "av_frame_copy(VAR_1, tmp);", "av_frame_free(&tmp);", "return 0;", "}" ]

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

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

[ "static void FUNC_0(BlkActionState *VAR_0)\n{", "BlockDirtyBitmapAdd *action;", "BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,\nVAR_0, VAR_0);", "action = VAR_0->action->u.block_dirty_bitmap_add;", "if (state->prepared) {", "qmp_block_dirty_bitmap_remove(action->node, action->name, &error_abort);", "}", "}" ]

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

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

[ "static int FUNC_0(CirrusVGAState *VAR_0, bool VAR_1)\n{", "uint32_t patternsize;", "uint8_t *dst;", "uint8_t *src;", "dst = VAR_0->vga.vram_ptr + VAR_0->cirrus_blt_dstaddr;", "if (VAR_1) {", "switch (VAR_0->vga.get_bpp(&VAR_0->vga)) {", "case 8:\npatternsize = 64;", "break;", "case 15:\ncase 16:\npatternsize = 128;", "break;", "case 24:\ncase 32:\ndefault:\npatternsize = 256;", "break;", "}", "VAR_0->cirrus_blt_srcaddr &= ~(patternsize - 1);", "if (VAR_0->cirrus_blt_srcaddr + patternsize > VAR_0->vga.vram_size) {", "return 0;", "}", "src = VAR_0->vga.vram_ptr + VAR_0->cirrus_blt_srcaddr;", "} else {", "src = VAR_0->cirrus_bltbuf;", "}", "if (blit_is_unsafe(VAR_0, true)) {", "return 0;", "}", "(*VAR_0->cirrus_rop) (VAR_0, dst, src,\nVAR_0->cirrus_blt_dstpitch, 0,\nVAR_0->cirrus_blt_width, VAR_0->cirrus_blt_height);", "cirrus_invalidate_region(VAR_0, VAR_0->cirrus_blt_dstaddr,\nVAR_0->cirrus_blt_dstpitch, VAR_0->cirrus_blt_width,\nVAR_0->cirrus_blt_height);", "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 ]

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

[ "static int FUNC_0(NBDClient *VAR_0, uint32_t VAR_1)\n{", "int VAR_2 = -EINVAL, VAR_3 = VAR_0->sock;", "char VAR_4[256];", "TRACE(\"Checking VAR_1\");", "if (VAR_1 > 255) {", "LOG(\"Bad VAR_1 received\");", "goto fail;", "}", "if (read_sync(VAR_3, VAR_4, VAR_1) != VAR_1) {", "LOG(\"read failed\");", "goto fail;", "}", "VAR_4[VAR_1] = '\\0';", "VAR_0->exp = nbd_export_find(VAR_4);", "if (!VAR_0->exp) {", "LOG(\"export not found\");", "goto fail;", "}", "QTAILQ_INSERT_TAIL(&VAR_0->exp->clients, VAR_0, next);", "nbd_export_get(VAR_0->exp);", "VAR_2 = 0;", "fail:\nreturn 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 ]

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

[ "static void FUNC_0(TCGContext *VAR_0, AArch64Insn VAR_1, TCGType VAR_2,\nTCGReg VAR_3, TCGReg VAR_4, uint64_t VAR_5)\n{", "if (VAR_5 > 0xfff) {", "assert((VAR_5 & 0xfff) == 0);", "VAR_5 >>= 12;", "assert(VAR_5 <= 0xfff);", "VAR_5 |= 1 << 12;", "}", "tcg_out32(VAR_0, VAR_1 | VAR_2 << 31 | VAR_5 << 10 | VAR_4 << 5 | VAR_3);", "}" ]

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

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

[ "static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,\nconst char *VAR_2, FsCred *VAR_3)\n{", "int VAR_4;", "V9fsString fullname;", "v9fs_string_init(&fullname);", "v9fs_string_sprintf(&fullname, \"%s/%s\", VAR_1->data, VAR_2);", "VAR_4 = v9fs_request(VAR_0->private, T_MKDIR, NULL, \"sddd\", &fullname,\nVAR_3->fc_mode, VAR_3->fc_uid, VAR_3->fc_gid);", "v9fs_string_free(&fullname);", "if (VAR_4 < 0) {", "errno = -VAR_4;", "VAR_4 = -1;", "}", "v9fs_string_free(&fullname);", "return VAR_4;", "}" ]

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

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

[ "static always_inline VAR_0 float_zero_divide_excp (VAR_0 arg1, VAR_0 arg2)\n{", "env->fpscr |= 1 << FPSCR_ZX;", "env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI));", "env->fpscr |= 1 << FPSCR_FX;", "if (fpscr_ze != 0) {", "env->fpscr |= 1 << FPSCR_FEX;", "if (msr_fe0 != 0 || msr_fe1 != 0) {", "helper_raise_exception_err(POWERPC_EXCP_PROGRAM,\nPOWERPC_EXCP_FP | POWERPC_EXCP_FP_ZX);", "}", "} else {", "arg1 = ((arg1 ^ arg2) & 0x8000000000000000ULL);", "arg1 |= 0x7FFULL << 52;", "}", "return arg1;", "}" ]

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

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

[ "void *FUNC_0(qemu_irq VAR_0)\n{", "BlizzardState *s = (BlizzardState *) g_malloc0(sizeof(*s));", "DisplaySurface *surface;", "s->fb = g_malloc(0x180000);", "s->con = graphic_console_init(blizzard_update_display,\nblizzard_invalidate_display,\nblizzard_screen_dump, NULL, s);", "surface = qemu_console_surface(s->con);", "switch (surface_bits_per_pixel(surface)) {", "case 0:\ns->line_fn_tab[0] = s->line_fn_tab[1] =\ng_malloc0(sizeof(blizzard_fn_t) * 0x10);", "break;", "case 8:\ns->line_fn_tab[0] = blizzard_draw_fn_8;", "s->line_fn_tab[1] = blizzard_draw_fn_r_8;", "break;", "case 15:\ns->line_fn_tab[0] = blizzard_draw_fn_15;", "s->line_fn_tab[1] = blizzard_draw_fn_r_15;", "break;", "case 16:\ns->line_fn_tab[0] = blizzard_draw_fn_16;", "s->line_fn_tab[1] = blizzard_draw_fn_r_16;", "break;", "case 24:\ns->line_fn_tab[0] = blizzard_draw_fn_24;", "s->line_fn_tab[1] = blizzard_draw_fn_r_24;", "break;", "case 32:\ns->line_fn_tab[0] = blizzard_draw_fn_32;", "s->line_fn_tab[1] = blizzard_draw_fn_r_32;", "break;", "default:\nfprintf(stderr, \"%s: Bad color depth\\n\", __FUNCTION__);", "exit(1);", "}", "blizzard_reset(s);", "return s;", "}" ]

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

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