// File: /workspace/github_c_makefile_star2_O3/ToniWestbrook[P]paladin/align.c
// Function: command_align
int command_align(int argc, char *argv[]) {
	mem_opt_t *opt, opt0;
	int fd, fd2, i, c, ignore_alt = 0, no_mt_io = 0;
	int fixed_chunk_size = -1;
	gzFile fp, fp2 = 0;
	char *p, *rg_line = 0, *hdr_line = 0;
	const char *mode = 0;
	void *ko = 0, *ko2 = 0;
	mem_pestat_t pes[VALUE_DOMAIN];
	ktp_aux_t aux;
	FILE * reportPriStream = 0, * reportSecStream = 0;
	char * readsProName = 0, * indexProName = 0, * prefixName = 0;
	char * samName = 0, * reportPriName = 0, * reportSecName = 0;
    const char * proxyAddress;

	memset(&aux, 0, sizeof(ktp_aux_t));
	memset(pes, 0, VALUE_DOMAIN * sizeof(mem_pestat_t));
	for (i = 0; i < VALUE_DOMAIN; ++i) pes[i].failed = 1;

	aux.opt = opt = mem_opt_init();
	memset(&opt0, 0, sizeof(mem_opt_t));
    proxyAddress = NULL;

	while ((c = getopt(argc, argv, "1epqabgnMCSVYJjf:F:z:u:k:o:c:v:s:r:t:R:A:B:O:E:U:w:L:d:T:Q:D:m:I:N:W:x:G:h:y:K:X:H:P:")) >= 0) {
		if (c == 'k') opt->min_seed_len = atoi(optarg), opt0.min_seed_len = 1;
		else if (c == 'u') opt->outputType = atoi(optarg);
		else if (c == 'f') opt->min_orf_len = atoi(optarg);
		else if (c == 'F') opt->min_orf_percent = atof(optarg);
        else if (c == 'z') opt->translations = convertTransArgs(optarg);
		else if (c == 'o') prefixName = optarg;
		else if (c == '1') no_mt_io = 1;
		else if (c == 'x') mode = optarg;
		else if (c == 'w') opt->w = atoi(optarg), opt0.w = 1;
		else if (c == 'A') opt->a = atoi(optarg), opt0.a = 1;
		else if (c == 'B') opt->b = atoi(optarg), opt0.b = 1;
		else if (c == 'T') opt->T = atoi(optarg), opt0.T = 1;
		else if (c == 'U') opt->pen_unpaired = atoi(optarg), opt0.pen_unpaired = 1;
		else if (c == 't') opt->n_threads = atoi(optarg), opt->n_threads = opt->n_threads > 1? opt->n_threads : 1;
		//else if (c == 'P') opt->flag |= MEM_F_NOPAIRING;
		else if (c == 'a') opt->flag |= MEM_F_ALL;
		//else if (c == 'p') opt->flag |= MEM_F_PE | MEM_F_SMARTPE;
		else if (c == 'M') opt->flag |= MEM_F_NO_MULTI;
		else if (c == 'S') opt->flag |= MEM_F_NO_RESCUE;
		else if (c == 'e') opt->flag |= MEM_F_SELF_OVLP;
		else if (c == 'F') opt->flag |= MEM_F_ALN_REG;
		else if (c == 'Y') opt->flag |= MEM_F_SOFTCLIP;
		else if (c == 'V') opt->flag |= MEM_F_REF_HDR;
		else if (c == 'b') opt->proteinFlag &= ~ALIGN_FLAG_BRUTE_ORF;
		else if (c == 'g') opt->proteinFlag |= ALIGN_FLAG_GEN_NT;
		else if (c == 'n') opt->proteinFlag |= ALIGN_FLAG_KEEP_PRO;
		else if (c == 'J') opt->proteinFlag &= ~ALIGN_FLAG_ADJUST_ORF;
        else if (c == 'p') opt->proteinFlag |= ALIGN_FLAG_MANUAL_PRO;
        else if (c == 'q') opt->proteinFlag |= ALIGN_FLAG_MANUAL_TRANSCRIPT;
		else if (c == 'c') opt->max_occ = atoi(optarg), opt0.max_occ = 1;
		else if (c == 'd') opt->zdrop = atoi(optarg), opt0.zdrop = 1;
		else if (c == 'v') bwa_verbose = atoi(optarg);
		else if (c == 'j') ignore_alt = 1;
		else if (c == 'r') opt->split_factor = atof(optarg), opt0.split_factor = 1.;
		else if (c == 'D') opt->drop_ratio = atof(optarg), opt0.drop_ratio = 1.;
		else if (c == 'm') opt->max_matesw = atoi(optarg), opt0.max_matesw = 1;
		else if (c == 's') opt->split_width = atoi(optarg), opt0.split_width = 1;
		else if (c == 'G') opt->max_chain_gap = atoi(optarg), opt0.max_chain_gap = 1;
		else if (c == 'N') opt->max_chain_extend = atoi(optarg), opt0.max_chain_extend = 1;
		else if (c == 'W') opt->min_chain_weight = atoi(optarg), opt0.min_chain_weight = 1;
		else if (c == 'y') opt->max_mem_intv = atol(optarg), opt0.max_mem_intv = 1;
		else if (c == 'C') aux.copy_comment = 1;
		else if (c == 'K') fixed_chunk_size = atoi(optarg);
		else if (c == 'X') opt->mask_level = atof(optarg);
        else if (c == 'P') proxyAddress = optarg;
		else if (c == 'h') {
			opt0.max_XA_hits = opt0.max_XA_hits_alt = 1;
			opt->max_XA_hits = opt->max_XA_hits_alt = strtol(optarg, &p, 10);
			if (*p != 0 && ispunct(*p) && isdigit(p[1]))
				opt->max_XA_hits_alt = strtol(p+1, &p, 10);
		}
		else if (c == 'Q') {
			opt0.mapQ_coef_len = 1;
			opt->mapQ_coef_len = atoi(optarg);
			opt->mapQ_coef_fac = opt->mapQ_coef_len > 0? log(opt->mapQ_coef_len) : 0;
		} else if (c == 'O') {
			opt0.o_del = opt0.o_ins = 1;
			opt->o_del = opt->o_ins = strtol(optarg, &p, 10);
			if (*p != 0 && ispunct(*p) && isdigit(p[1]))
				opt->o_ins = strtol(p+1, &p, 10);
		} else if (c == 'E') {
			opt0.e_del = opt0.e_ins = 1;
			opt->e_del = opt->e_ins = strtol(optarg, &p, 10);
			if (*p != 0 && ispunct(*p) && isdigit(p[1]))
				opt->e_ins = strtol(p+1, &p, 10);
		} else if (c == 'L') {
			opt0.pen_clip5 = opt0.pen_clip3 = 1;
			opt->pen_clip5 = opt->pen_clip3 = strtol(optarg, &p, 10);
			if (*p != 0 && ispunct(*p) && isdigit(p[1]))
				opt->pen_clip3 = strtol(p+1, &p, 10);
		} else if (c == 'R') {
			if ((rg_line = bwa_set_rg(optarg)) == 0) return 1; // FIXME: memory leak
		} else if (c == 'H') {
			if (optarg[0] != '@') {
				FILE *fp;
				if ((fp = fopen(optarg, "r")) != 0) {
					char *buf;
					buf = calloc(1, 0x10000);
					while (fgets(buf, 0xffff, fp)) {
						i = strlen(buf);
						assert(buf[i-1] == '\n'); // a long line
						buf[i-1] = 0;
						hdr_line = bwa_insert_header(buf, hdr_line);
					}
					free(buf);
					fclose(fp);
				}
			} else hdr_line = bwa_insert_header(optarg, hdr_line);
		} else if (c == 'I') { // specify the insert size distribution
			aux.pes0 = pes;
			pes[1].failed = 0;
			pes[1].avg = strtod(optarg, &p);
			pes[1].std = pes[1].avg * .1;
			if (*p != 0 && ispunct(*p) && isdigit(p[1]))
				pes[1].std = strtod(p+1, &p);
			pes[1].high = (int)(pes[1].avg + 4. * pes[1].std + .499);
			pes[1].low  = (int)(pes[1].avg - 4. * pes[1].std + .499);
			if (pes[1].low < 1) pes[1].low = 1;
			if (*p != 0 && ispunct(*p) && isdigit(p[1]))
				pes[1].high = (int)(strtod(p+1, &p) + .499);
			if (*p != 0 && ispunct(*p) && isdigit(p[1]))
				pes[1].low  = (int)(strtod(p+1, &p) + .499);

			logMessage(__func__, LOG_LEVEL_MESSAGE, "mean insert size: %.3f, stddev: %.3f, max: %d, min: %d\n",
			   									     pes[1].avg, pes[1].std, pes[1].high, pes[1].low);

		}
		else return 1;
	}

	if (rg_line) {
		hdr_line = bwa_insert_header(rg_line, hdr_line);
		free(rg_line);
	}

	if (opt->n_threads < 1) opt->n_threads = 1;
	if (optind + 1 >= argc || optind + 3 < argc) {
		renderAlignUsage(opt);
		free(opt);
		return 1;
	}

	if (mode) {
		if (strcmp(mode, "intractg") == 0) {
			if (!opt0.o_del) opt->o_del = 16;
			if (!opt0.o_ins) opt->o_ins = 16;
			if (!opt0.b) opt->b = 9;
			if (!opt0.pen_clip5) opt->pen_clip5 = 5;
			if (!opt0.pen_clip3) opt->pen_clip3 = 5;
		} else if (strcmp(mode, "pacbio") == 0 || strcmp(mode, "pbref") == 0 || strcmp(mode, "pbread") == 0 || strcmp(mode, "ont2d") == 0) {
			if (!opt0.o_del) opt->o_del = 1;
			if (!opt0.e_del) opt->e_del = 1;
			if (!opt0.o_ins) opt->o_ins = 1;
			if (!opt0.e_ins) opt->e_ins = 1;
			if (!opt0.b) opt->b = 1;
			if (opt0.split_factor == 0.) opt->split_factor = 10.;
			if (strcmp(mode, "pbread") == 0) { // pacbio read-to-read setting; NOT working well!
				opt->flag |= MEM_F_ALL | MEM_F_SELF_OVLP | MEM_F_ALN_REG;
				if (!opt0.min_chain_weight) opt->min_chain_weight = 40;
				if (!opt0.max_occ) opt->max_occ = 1000;
				if (!opt0.min_seed_len) opt->min_seed_len = 13;
				if (!opt0.max_chain_extend) opt->max_chain_extend = 25;
				if (opt0.drop_ratio == 0.) opt->drop_ratio = .001;
			} else if (strcmp(mode, "ont2d") == 0) {
				if (!opt0.min_chain_weight) opt->min_chain_weight = 20;
				if (!opt0.min_seed_len) opt->min_seed_len = 14;
				if (!opt0.pen_clip5) opt->pen_clip5 = 0;
				if (!opt0.pen_clip3) opt->pen_clip3 = 0;
			} else {
				if (!opt0.min_chain_weight) opt->min_chain_weight = 40;
				if (!opt0.min_seed_len) opt->min_seed_len = 17;
				if (!opt0.pen_clip5) opt->pen_clip5 = 0;
				if (!opt0.pen_clip3) opt->pen_clip3 = 0;
			}
		} else {
			logMessage(__func__, LOG_LEVEL_ERROR, "Unknown read type '%s'\n", mode);
			return 1; // FIXME memory leak
		}
	} else update_a(opt, &opt0);

    // Check for incompatible options
    if ((opt->proteinFlag & ALIGN_FLAG_MANUAL_PRO) && (opt->proteinFlag & ALIGN_FLAG_MANUAL_TRANSCRIPT)) {
		logMessage(__func__, LOG_LEVEL_ERROR, "Both protein and transcriptome mode selected.\n");
        return 1;
    }

    // Default to standard genetic code for translations
    if (!opt->translations) opt->translations = convertTransArgs("");

	// Create scoring weight matrix
	bwa_fill_scmat(opt->a, opt->b, opt->mat);

	// Prepare header check and filenames
	indexProName = malloc(strlen(argv[optind]) + 5);
	readsProName = malloc(strlen(argv[optind + 1]) + 5);
	sprintf(indexProName, "%s.pro", argv[optind]);
	sprintf(readsProName, "%s.pro", argv[optind + 1]);
	opt->indexInfo = getIndexHeader(indexProName);

	// Before loading index, ensure it's compatible
	switch (getIndexCompatible(opt->indexInfo)) {
		case INDEX_COMPATIBILITY_NONE:
			logMessage(__func__, LOG_LEVEL_ERROR,
					   "Index version %d.%d.%d is incompatible, please reindex the reference.\n",
						opt->indexInfo.version[0],
						opt->indexInfo.version[1],
						opt->indexInfo.version[2]);

			return 1;

		case INDEX_COMPATBILITY_FUTURE:
			logMessage(__func__, LOG_LEVEL_WARNING,
					   "Index version %d.%d.%d is newer than program version, compatibility not guaranteed.\n",
						opt->indexInfo.version[0],
						opt->indexInfo.version[1],
						opt->indexInfo.version[2]);

			break;
		default:
			break;
	}

	// Load index
	aux.idx = index_load_from_shm(argv[optind]);
	if (aux.idx == 0) {
		logMessage(__func__, LOG_LEVEL_MESSAGE, "Loading the index for reference '%s'...\n", argv[optind]);
		if ((aux.idx = index_load(argv[optind], BWA_IDX_ALL)) == 0) return 1; // FIXME: memory leak
	}
	else {
		logMessage(__func__, LOG_LEVEL_MESSAGE, "Loading the index from shared memory...\n");
	}

	if (ignore_alt)
		for (i = 0; i < aux.idx->bns->n_seqs; ++i)
			aux.idx->bns->anns[i].is_alt = 0;

	// Ready output files if requested (else stdout)
	if (prefixName != NULL) {
		if (opt->indexInfo.referenceType == 0) {
			logMessage(__func__, LOG_LEVEL_ERROR, "Reporting can only be used on prepared indices.\n");
 			return 1;
		}

		samName = malloc(strlen(prefixName) + 5);
		reportPriName = malloc(strlen(prefixName) + 23);
		reportSecName = malloc(strlen(prefixName) + 23);
		sprintf(samName, "%s.sam", prefixName);
		sprintf(reportPriName, "%s_uniprot.tsv", prefixName);

		if (opt->flag & MEM_F_ALL) {
			sprintf(reportPriName, "%s_uniprot_primary.tsv", prefixName);
			sprintf(reportSecName, "%s_uniprot_secondary.tsv", prefixName);
		}

		// Open files
		opt->outputStream = err_xopen_core(__func__, samName, "w");
		reportPriStream = err_xopen_core(__func__, reportPriName, "w");
		if (opt->flag & MEM_F_ALL) reportSecStream = err_xopen_core(__func__, reportSecName, "w");

	}

    if (opt->proteinFlag & ALIGN_FLAG_MANUAL_PRO) {
        // Protein input given, skip ORF detection
        sprintf(readsProName, "%s", argv[optind + 1]);
    }
    else {
        // Detect ORFs and write protein file
        writeReadsProtein(argv[optind + 1], readsProName, opt);
    }

	// Open ORFs sequence
	ko = kopen(readsProName, &fd);
	if (ko == 0) {
		logMessage(__func__, LOG_LEVEL_ERROR, "Failed to open file `%s'.\n", argv[optind + 1]);
		return 1;
	}

	fp = gzdopen(fd, "r");
	aux.ks = kseq_init(fp);
	if (optind + 2 < argc) {
		if (opt->flag&MEM_F_PE) {
			logMessage(__func__, LOG_LEVEL_WARNING, "When '-p' is in use, the second query file is ignored.\n");
		} else {
			ko2 = kopen(argv[optind + 2], &fd2);
			if (ko2 == 0) {
				logMessage(__func__, LOG_LEVEL_ERROR, "Failed to open file `%s'.\n", argv[optind + 2]);
				return 1;
			}
			fp2 = gzdopen(fd2, "r");
			aux.ks2 = kseq_init(fp2);
			opt->flag |= MEM_F_PE;
		}
	}

	// Render SAM header
	if (!(opt->flag & MEM_F_ALN_REG)) {
		bwa_print_sam_hdr(aux.idx->bns, hdr_line, opt->outputStream);
	}

	// Align and render
	aux.actual_chunk_size = fixed_chunk_size > 0? fixed_chunk_size : opt->chunk_size * opt->n_threads;
	kt_pipeline(no_mt_io? 1 : 2, process, &aux, 3);

	// Report number aligned
	renderNumberAligned(opt);

	// Generate UniProt report if requested
	if (prefixName != NULL) {
		renderUniprotReport(opt->outputType, 1, reportPriStream, proxyAddress);
		if (opt->flag & MEM_F_ALL) {
			renderUniprotReport(opt->outputType, 0, reportSecStream, proxyAddress);
		}
	}

	// Delete generated protein file unless requested otherwise
	if (!(opt->proteinFlag & ALIGN_FLAG_KEEP_PRO) && !(opt->proteinFlag & ALIGN_FLAG_MANUAL_PRO)) {
		remove(readsProName);
	}

	// Cleanup
	if (opt->outputStream != stdout) fclose (opt->outputStream);
	if (reportPriStream) fclose(reportPriStream);
	if (reportSecStream) fclose(reportSecStream);

	free(indexProName);
	free(readsProName);
	free(samName);
	free(reportPriName);
	free(reportSecName);
	free(hdr_line);
	free(opt);

	index_destroy(aux.idx);
	kseq_destroy(aux.ks);
	err_gzclose(fp); kclose(ko);
	if (aux.ks2) {
		kseq_destroy(aux.ks2);
		err_gzclose(fp2); kclose(ko2);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp            # imm = 0x538
movq %rsi, %r13
movl %edi, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x100(%rsp)
movaps %xmm0, 0xf0(%rsp)
movaps %xmm0, 0xe0(%rsp)
movq $0x0, 0x110(%rsp)
leaq 0x130(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x3140
movl $0x8, %eax
movl $0x1, 0x130(%rsp,%rax)
addq $0x20, %rax
cmpq $0x408, %rax            # imm = 0x408
jne 0x75aa
callq 0x13840
movq %rax, %rbx
movq %rax, 0xf0(%rsp)
leaq 0x1e350(%rip), %rdx     # 0x25928
movl %ebp, %edi
movq %r13, %rsi
callq 0x3090
testl %eax, %eax
movl %ebp, 0x28(%rsp)
movq %r13, 0xd0(%rsp)
js 0x8152
movq $0x0, 0x70(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x6c(%rsp)
movl $0xffffffff, 0x9c(%rsp) # imm = 0xFFFFFFFF
leaq 0x1e1e6(%rip), %r14     # 0x25800
movq $0x0, 0xc8(%rsp)
movq $0x0, 0xa8(%rsp)
movq $0x0, 0x78(%rsp)
xorl %r15d, %r15d
movq $0x0, 0xb0(%rsp)
movl $0x0, 0x88(%rsp)
movl $0x0, 0x64(%rsp)
movss %xmm0, 0x38(%rsp)
movl $0x0, 0x68(%rsp)
movl $0x0, 0x30(%rsp)
movl $0x0, 0x34(%rsp)
movl $0x0, 0xc4(%rsp)
movl $0x0, 0xbc(%rsp)
movl $0x0, 0x84(%rsp)
movl $0x0, 0xb8(%rsp)
movl $0x0, 0xc0(%rsp)
movl $0x0, 0x3c(%rsp)
movl $0x0, 0x50(%rsp)
movl $0x0, 0x48(%rsp)
movl $0x1, %r12d
addl $-0x31, %eax
cmpl $0x49, %eax
ja 0x8ce6
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movl $0x1, 0x88(%rsp)
jmp 0x7fe3
movq 0x288bc(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x33a0
movq %rax, 0x30(%rbx)
jmp 0x7fe3
orb $0x2, 0x4c(%rbx)
jmp 0x7fe3
movq 0x2889b(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x78(%rbx)
movl $0x1, 0x34(%rsp)
jmp 0x7fe3
movq 0x2887c(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x906c
movq %rax, 0x70(%rbx)
jmp 0x7fe3
movq 0x28864(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x28(%rbx)
movl $0x1, 0x84(%rsp)
jmp 0x7fe3
movl $0x1, %eax
movq %rax, 0x70(%rsp)
jmp 0x7fe3
movq 0x28833(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0xb8(%rbx)
jmp 0x7fe3
movq 0x28819(%rip), %rax     # 0x2ffb8
movq (%rax), %rax
movq %rax, 0xc8(%rsp)
jmp 0x7fe3
movq 0x28802(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x33e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x9c(%rbx)
jmp 0x7fe3
movq 0x287e2(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x1364b
movq %rax, 0xb0(%rsp)
testq %rax, %rax
jne 0x7fe3
jmp 0x8ce6
movq 0x287bd(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
leaq 0x29636(%rip), %rcx     # 0x30e40
movl %eax, (%rcx)
jmp 0x7fe3
orb $0x2, 0x49(%rbx)
jmp 0x7fe3
andb $-0x9, 0x4c(%rbx)
jmp 0x7fe3
orb $0x10, 0x4c(%rbx)
jmp 0x7fe3
movq 0x28785(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x18(%rbx)
movl $0x1, 0xc0(%rsp)
jmp 0x7fe3
movq 0x28763(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x44(%rbx)
movl $0x1, 0xc4(%rsp)
jmp 0x7fe3
movq 0x28741(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x90(%rbx)
jmp 0x7fe3
movq 0x28727(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x8c(%rbx)
movl $0x1, 0x64(%rsp)
jmp 0x7fe3
movq 0x28705(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x33e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xa0(%rbx)
movss 0x1dee1(%rip), %xmm0    # 0x257b0
movss %xmm0, 0x6c(%rsp)
jmp 0x7fe3
movq 0x286d7(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x24(%rbx)
jmp 0x7fe3
movq %r15, %rbp
movq 0x286bd(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
leaq 0x58(%rsp), %r12
movq %r12, %rsi
movl $0xa, %edx
callq 0x34e0
movl %eax, 0x14(%rbx)
movl %eax, 0xc(%rbx)
movq (%r12), %r12
movsbq (%r12), %r15
movl $0x1, 0x3c(%rsp)
testq %r15, %r15
je 0x7d59
callq 0x3320
movq (%rax), %rax
testb $0x4, (%rax,%r15,2)
je 0x7d59
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
movq %rbp, %r15
je 0x7fdf
incq %r12
leaq 0x58(%rsp), %rsi
movq %r12, %rdi
movl $0xa, %edx
callq 0x34e0
movl %eax, 0x14(%rbx)
jmp 0x7fdf
movq 0x2863d(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x4(%rbx)
movl $0x1, 0x48(%rsp)
jmp 0x7fe3
movl $0x1, 0x108(%rsp)
jmp 0x7fe3
orb $0x8, 0x48(%rbx)
jmp 0x7fe3
orb $0x4, 0x4c(%rbx)
jmp 0x7fe3
movq 0x285fc(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, (%rbx)
movl $0x1, 0xbc(%rsp)
jmp 0x7fe3
movq 0x285db(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x9c(%rsp)
jmp 0x7fe3
orb $0x10, 0x48(%rbx)
jmp 0x7fe3
movq 0x285b7(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x68(%rbx)
jmp 0x7fe3
movq 0x285a0(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
cmpb $0x40, (%rdi)
jne 0x7daf
movq %r15, %rsi
callq 0x13795
movq %rax, %r15
jmp 0x7fe3
movq 0x2857d(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xac(%rbx)
testl %eax, %eax
jle 0x7e30
cvtss2sd %xmm0, %xmm0
callq 0x3250
cvttsd2si %xmm0, %eax
jmp 0x7e32
orb $0x1, 0x49(%rbx)
jmp 0x7fe3
orb $0x20, 0x48(%rbx)
jmp 0x7fe3
movq %r15, %rbp
movq 0x28530(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
leaq 0x58(%rsp), %r12
movq %r12, %rsi
movl $0xa, %edx
callq 0x34e0
movl %eax, 0x20(%rbx)
movl %eax, 0x1c(%rbx)
movq (%r12), %r12
movsbq (%r12), %r15
movl $0x1, 0xb8(%rsp)
testq %r15, %r15
je 0x7d59
callq 0x3320
movq (%rax), %rax
testb $0x4, (%rax,%r15,2)
je 0x7d59
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
movq %rbp, %r15
je 0x7fdf
incq %r12
leaq 0x58(%rsp), %rsi
movq %r12, %rdi
movl $0xa, %edx
callq 0x34e0
movl %eax, 0x20(%rbx)
jmp 0x7fdf
movq 0x284ad(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x33e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x6c(%rbx)
jmp 0x7fe3
movq %r15, %rbp
movq 0x2848d(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
leaq 0x58(%rsp), %r12
movq %r12, %rsi
movl $0xa, %edx
callq 0x34e0
movl %eax, 0x10(%rbx)
movl %eax, 0x8(%rbx)
movq (%r12), %r12
movsbq (%r12), %r15
movl $0x1, 0x50(%rsp)
testq %r15, %r15
je 0x7d59
callq 0x3320
movq (%rax), %rax
testb $0x4, (%rax,%r15,2)
je 0x7d59
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
movq %rbp, %r15
je 0x7fdf
incq %r12
leaq 0x58(%rsp), %rsi
movq %r12, %rdi
movl $0xa, %edx
callq 0x34e0
movl %eax, 0x10(%rbx)
jmp 0x7fdf
movq %r15, 0x90(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, 0xf8(%rsp)
movl $0x0, 0x158(%rsp)
movq 0x283ea(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
leaq 0x58(%rsp), %r12
movq %r12, %rsi
callq 0x3210
movaps %xmm0, %xmm3
movsd %xmm0, 0x160(%rsp)
mulsd 0x1db9e(%rip), %xmm0    # 0x25790
movsd %xmm0, 0x168(%rsp)
movq (%r12), %r12
movsbq (%r12), %r15
testq %r15, %r15
je 0x7eaf
movsd %xmm3, 0xa0(%rsp)
movsd %xmm0, 0x40(%rsp)
callq 0x3320
movq (%rax), %rax
testb $0x4, (%rax,%r15,2)
je 0x7c3c
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x7e86
movsd 0x40(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm3
jmp 0x7eaf
orb $0x20, 0x4c(%rbx)
jmp 0x7fe3
movq 0x28358(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x80(%rbx)
movl $0x1, 0x68(%rsp)
jmp 0x7fe3
movq 0x28336(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x33e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x84(%rbx)
movss 0x1db12(%rip), %xmm0    # 0x257b0
movss %xmm0, 0x38(%rsp)
jmp 0x7fe3
movq 0x28308(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl %ecx, 0x94(%rbx)
jmp 0x7fe3
movq 0x282e3(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x7c(%rbx)
movl $0x1, 0x30(%rsp)
jmp 0x7fe3
orb $0x40, 0x48(%rbx)
jmp 0x7fe3
movq 0x282bb(%rip), %rax     # 0x2ffb8
movq (%rax), %rax
movq %rax, 0xa8(%rsp)
jmp 0x7fe3
movq %r15, %rbp
movq 0x282a1(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
leaq 0x58(%rsp), %r12
movq %r12, %rsi
movl $0xa, %edx
callq 0x34e0
movl %eax, 0xc0(%rbx)
movl %eax, 0xbc(%rbx)
movq (%r12), %r12
movsbq (%r12), %r15
testq %r15, %r15
je 0x7d59
callq 0x3320
movq (%rax), %rax
testb $0x4, (%rax,%r15,2)
jne 0x7e3d
movq %rbp, %r15
jmp 0x7fdf
andb $-0x2, 0x4c(%rbx)
jmp 0x7fe3
movq 0x28247(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x40(%rbx)
jmp 0x7fe3
movq 0x28230(%rip), %rax     # 0x2ffb8
movq (%rax), %rax
movq %rax, 0x78(%rsp)
jmp 0x7fe3
movq 0x2821c(%rip), %rax     # 0x2ffb8
movq (%rax), %rdi
callq 0x35b0
movl %eax, 0x88(%rbx)
jmp 0x7fe3
leaq 0x1f0b4(%rip), %rsi     # 0x26e6a
callq 0x3380
testq %rax, %rax
je 0x7fe3
movq %rax, %r12
leaq 0x1dbb0(%rip), %rdx     # 0x2597e
leaq 0x1dbb1(%rip), %r8      # 0x25986
movl $0x1, %edi
movl $0x10000, %esi          # imm = 0x10000
movl $0xc7, %ecx
callq 0x2319c
movq %rax, %rbp
movq %rax, %rdi
movl $0xffff, %esi           # imm = 0xFFFF
movq %r12, %rdx
callq 0x35d0
testq %rax, %rax
je 0x7e71
movq %rbp, %rdi
callq 0x3100
decl %eax
cltq
cmpb $0xa, (%rbp,%rax)
jne 0x8d0f
movb $0x0, (%rbp,%rax)
movq %rbp, %rdi
movq %r15, %rsi
callq 0x13795
movq %rax, %r15
movq %rbp, %rdi
jmp 0x7def
xorl %eax, %eax
movl %eax, 0xb0(%rbx)
jmp 0x7fe3
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
movq %rbp, %r15
je 0x7fdf
incq %r12
leaq 0x58(%rsp), %rsi
movq %r12, %rdi
movl $0xa, %edx
callq 0x34e0
movl %eax, 0xc0(%rbx)
jmp 0x7fdf
movq %rbp, %rdi
callq 0x3390
movq %r12, %rdi
callq 0x32f0
jmp 0x7fdf
incq %r12
leaq 0x58(%rsp), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3210
movsd %xmm0, 0x168(%rsp)
movsd 0x160(%rsp), %xmm3
movq (%rbp), %r12
movsd 0x1d8e1(%rip), %xmm2    # 0x25798
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movsd 0x1d8d9(%rip), %xmm1    # 0x257a0
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %ebp
mulsd 0x1d8d1(%rip), %xmm0    # 0x257a8
addsd %xmm3, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl %ebp, 0x154(%rsp)
movl %ecx, 0x150(%rsp)
movsbq (%r12), %r15
testq %r15, %r15
je 0x7fa1
callq 0x3320
movq (%rax), %rax
testb $0x4, (%rax,%r15,2)
je 0x7f58
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x7f58
incq %r12
leaq 0x58(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x3210
addsd 0x1d85f(%rip), %xmm0    # 0x257a0
cvttsd2si %xmm0, %ebp
movl %ebp, 0x154(%rsp)
movq (%r15), %r12
movb (%r12), %r15b
testb %r15b, %r15b
je 0x7fa1
callq 0x3320
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x4, (%rax,%rcx,2)
je 0x7fa1
movsbq 0x1(%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x7fa1
incq %r12
leaq 0x58(%rsp), %rsi
movq %r12, %rdi
callq 0x3210
addsd 0x1d811(%rip), %xmm0    # 0x257a0
cvttsd2si %xmm0, %eax
movl %eax, 0x150(%rsp)
movl 0x154(%rsp), %ebp
movsd 0x160(%rsp), %xmm0
movsd 0x168(%rsp), %xmm1
movl 0x150(%rsp), %r8d
leaq 0x1d9c4(%rip), %rdi     # 0x25986
leaq 0x1d9fc(%rip), %rdx     # 0x259c5
movl $0x3, %esi
movl %ebp, %ecx
movb $0x2, %al
callq 0xde80
movq 0x90(%rsp), %r15
movl 0x28(%rsp), %ebp
leaq 0x1d93e(%rip), %rdx     # 0x25928
movl %ebp, %edi
movq %r13, %rsi
callq 0x3090
testl %eax, %eax
jns 0x76ca
movq %r15, 0x90(%rsp)
movl 0x50(%rsp), %ecx
testl %ecx, %ecx
sete 0x40(%rsp)
movl 0x3c(%rsp), %eax
testl %eax, %eax
sete 0xa0(%rsp)
testl %ecx, %ecx
sete 0x50(%rsp)
testl %eax, %eax
sete 0x3c(%rsp)
cmpl $0x0, 0x48(%rsp)
sete 0x48(%rsp)
xorps %xmm0, %xmm0
movss 0x38(%rsp), %xmm1
cmpeqss %xmm0, %xmm1
movd %xmm1, %ebp
andl $0x1, %ebp
cmpl $0x0, 0x30(%rsp)
sete 0x27(%rsp)
cmpl $0x0, 0x34(%rsp)
sete 0x38(%rsp)
movl 0xb8(%rsp), %eax
testl %eax, %eax
sete 0x30(%rsp)
testl %eax, %eax
sete 0x34(%rsp)
cmpl $0x0, 0x64(%rsp)
sete 0x64(%rsp)
cmpl $0x0, 0x68(%rsp)
sete 0x68(%rsp)
movss 0x6c(%rsp), %xmm1
cmpeqss %xmm0, %xmm1
movd %xmm1, %r14d
andl $0x1, %r14d
cmpl $0x0, 0xbc(%rsp)
sete %r13b
cmpl $0x0, 0xc4(%rsp)
sete %r8b
cmpl $0x0, 0x84(%rsp)
sete %dil
cmpl $0x0, 0xc0(%rsp)
sete %sil
cmpl $0x0, 0x70(%rsp)
sete 0x70(%rsp)
xorl %eax, %eax
cmpl $0x1, 0x88(%rsp)
adcl $0x1, %eax
movl %eax, 0x6c(%rsp)
movq 0xb0(%rsp), %r15
testq %r15, %r15
je 0x81e3
movb %dil, 0x84(%rsp)
movq %r15, %rdi
movl %ebp, 0x88(%rsp)
movl %r14d, %ebp
movl %esi, %r14d
movq 0x90(%rsp), %rsi
movq %rbx, %r12
movl %r8d, %ebx
callq 0x13795
movq %rax, 0x90(%rsp)
movq %r15, %rdi
callq 0x3390
movl %ebx, %r8d
movq %r12, %rbx
movb 0x84(%rsp), %dil
movl %r14d, %esi
movl %ebp, %r14d
movl 0x88(%rsp), %ebp
jmp 0x81e3
movl $0x2, 0x6c(%rsp)
movl $0xffffffff, 0x9c(%rsp) # imm = 0xFFFFFFFF
movb $0x1, 0x70(%rsp)
movq $0x0, 0xc8(%rsp)
movq $0x0, 0xa8(%rsp)
movq $0x0, 0x78(%rsp)
movb $0x1, %r14b
movb $0x1, 0x64(%rsp)
movb $0x1, %bpl
movb $0x1, 0x68(%rsp)
movb $0x1, 0x27(%rsp)
movb $0x1, 0x38(%rsp)
movb $0x1, %r8b
movb $0x1, %r13b
movb $0x1, %dil
movb $0x1, 0x34(%rsp)
movb $0x1, 0x30(%rsp)
movb $0x1, %sil
movb $0x1, 0x3c(%rsp)
movb $0x1, 0x50(%rsp)
movb $0x1, 0xa0(%rsp)
movb $0x1, 0x40(%rsp)
movb $0x1, 0x48(%rsp)
movq $0x0, 0x90(%rsp)
cmpl $0x0, 0x94(%rbx)
jg 0x81f6
movl $0x1, 0x94(%rbx)
movq 0x27ddb(%rip), %rax     # 0x2ffd8
movl (%rax), %eax
leal 0x1(%rax), %ecx
movl 0x28(%rsp), %edx
cmpl %edx, %ecx
jge 0x89f5
addl $0x3, %eax
cmpl %edx, %eax
jl 0x89f5
movq 0x78(%rsp), %r15
testq %r15, %r15
je 0x82c3
leaq 0x1d7cf(%rip), %rsi     # 0x259fd
movq %r15, %rdi
callq 0x34d0
testl %eax, %eax
je 0x8433
leaq 0x1d7c1(%rip), %rsi     # 0x25a06
movq %r15, %rdi
callq 0x34d0
testl %eax, %eax
movq 0xd0(%rsp), %r13
je 0x8381
leaq 0x1d7a9(%rip), %rsi     # 0x25a0d
movq %r15, %rdi
callq 0x34d0
testl %eax, %eax
je 0x8381
leaq 0x1d798(%rip), %rsi     # 0x25a13
movq %r15, %rdi
callq 0x34d0
testl %eax, %eax
je 0x8381
leaq 0x1d788(%rip), %rsi     # 0x25a1a
movq %r15, %rdi
callq 0x34d0
testl %eax, %eax
je 0x8381
leaq 0x1d6dd(%rip), %rdi     # 0x25986
leaq 0x1d770(%rip), %rdx     # 0x25a20
movl $0x1, %r12d
movl $0x1, %esi
movq %r15, %rcx
jmp 0x8b32
testb %r13b, %r13b
movq 0xd0(%rsp), %r13
movq 0x27d03(%rip), %r15     # 0x2ffd8
jne 0x852a
cmpb $0x0, 0x48(%rsp)
je 0x82eb
movl 0x4(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x4(%rbx)
testb %r8b, %r8b
je 0x82f9
movl 0x44(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x44(%rbx)
cmpb $0x0, 0x40(%rsp)
je 0x8309
movl 0x8(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x8(%rbx)
cmpb $0x0, 0xa0(%rsp)
je 0x831c
movl 0xc(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0xc(%rbx)
cmpb $0x0, 0x50(%rsp)
je 0x832c
movl 0x10(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x10(%rbx)
cmpb $0x0, 0x3c(%rsp)
je 0x833c
movl 0x14(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x14(%rbx)
testb %dil, %dil
je 0x834a
movl 0x28(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x28(%rbx)
cmpb $0x0, 0x30(%rsp)
je 0x835a
movl 0x1c(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x1c(%rbx)
cmpb $0x0, 0x34(%rsp)
je 0x836a
movl 0x20(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x20(%rbx)
testb %sil, %sil
je 0x852a
movl 0x18(%rbx), %eax
imull (%rbx), %eax
movl %eax, 0x18(%rbx)
jmp 0x852a
cmpb $0x0, 0x40(%rsp)
je 0x838f
movl $0x1, 0x8(%rbx)
cmpb $0x0, 0xa0(%rsp)
je 0x83a0
movl $0x1, 0xc(%rbx)
cmpb $0x0, 0x50(%rsp)
je 0x83ae
movl $0x1, 0x10(%rbx)
cmpb $0x0, 0x3c(%rsp)
je 0x83bc
movl $0x1, 0x14(%rbx)
cmpb $0x0, 0x48(%rsp)
je 0x83ca
movl $0x1, 0x4(%rbx)
testb %bpl, %bpl
je 0x83d9
movl $0x41200000, 0x84(%rbx) # imm = 0x41200000
leaq 0x1d633(%rip), %rsi     # 0x25a13
movq %r15, %rdi
callq 0x34d0
testl %eax, %eax
je 0x8491
leaq 0x1d623(%rip), %rsi     # 0x25a1a
movq %r15, %rdi
callq 0x34d0
testl %eax, %eax
je 0x84eb
cmpb $0x0, 0x27(%rsp)
movq 0x27bc5(%rip), %r15     # 0x2ffd8
je 0x841c
movl $0x28, 0x7c(%rbx)
cmpb $0x0, 0x38(%rsp)
je 0x850e
movl $0x11, 0x78(%rbx)
jmp 0x850e
cmpb $0x0, 0x40(%rsp)
movq 0xd0(%rsp), %r13
je 0x8449
movl $0x10, 0x8(%rbx)
cmpb $0x0, 0x50(%rsp)
movq 0x27b83(%rip), %r15     # 0x2ffd8
je 0x845e
movl $0x10, 0x10(%rbx)
cmpb $0x0, 0x48(%rsp)
je 0x846c
movl $0x9, 0x4(%rbx)
cmpb $0x0, 0x30(%rsp)
je 0x847a
movl $0x5, 0x1c(%rbx)
cmpb $0x0, 0x34(%rsp)
je 0x852a
movl $0x5, 0x20(%rbx)
jmp 0x852a
orb $-0x38, 0x48(%rbx)
cmpb $0x0, 0x27(%rsp)
movq 0x27b37(%rip), %r15     # 0x2ffd8
je 0x84aa
movl $0x28, 0x7c(%rbx)
cmpb $0x0, 0x64(%rsp)
je 0x84bb
movl $0x3e8, 0x8c(%rbx)      # imm = 0x3E8
cmpb $0x0, 0x38(%rsp)
je 0x84c9
movl $0xd, 0x78(%rbx)
cmpb $0x0, 0x68(%rsp)
je 0x84da
movl $0x19, 0x80(%rbx)
testb %r14b, %r14b
je 0x852a
movl $0x3a83126f, 0xa0(%rbx) # imm = 0x3A83126F
jmp 0x852a
cmpb $0x0, 0x27(%rsp)
movq 0x27ae1(%rip), %r15     # 0x2ffd8
je 0x8500
movl $0x14, 0x7c(%rbx)
cmpb $0x0, 0x38(%rsp)
je 0x850e
movl $0xe, 0x78(%rbx)
cmpb $0x0, 0x30(%rsp)
je 0x851c
movl $0x0, 0x1c(%rbx)
cmpb $0x0, 0x34(%rsp)
je 0x852a
movl $0x0, 0x20(%rbx)
movl 0x4c(%rbx), %eax
notl %eax
testb $0x30, %al
jne 0x8558
leaq 0x1d44c(%rip), %rdi     # 0x25986
leaq 0x1d4f7(%rip), %rdx     # 0x25a38
movl $0x1, %r12d
movl $0x1, %esi
xorl %eax, %eax
callq 0xde80
jmp 0x8ce6
cmpq $0x0, 0x70(%rbx)
jne 0x856f
leaq 0x20160(%rip), %rdi     # 0x286c6
callq 0x906c
movq %rax, 0x70(%rbx)
movl (%rbx), %edi
movl 0x4(%rbx), %esi
movq %rbx, %rdx
addq $0xc4, %rdx
callq 0x12239
movslq (%r15), %rax
movq (%r13,%rax,8), %rdi
callq 0x3100
leaq 0x5(%rax), %rdi
leaq 0x1d3e3(%rip), %r12     # 0x2597e
leaq 0x1d3e4(%rip), %rbp     # 0x25986
movq %r12, %rsi
movl $0x127, %edx            # imm = 0x127
movq %rbp, %rcx
callq 0x23213
movq %rax, %r14
movslq (%r15), %rax
movq 0x8(%r13,%rax,8), %rdi
callq 0x3100
leaq 0x5(%rax), %rdi
movq %r12, %rsi
movl $0x128, %edx            # imm = 0x128
movq %rbp, %rcx
callq 0x23213
movq %rax, %rbp
movslq (%r15), %rax
movq (%r13,%rax,8), %rdx
leaq 0x1ce13(%rip), %r12     # 0x253fb
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3070
movslq (%r15), %rax
movq 0x8(%r13,%rax,8), %rdx
movq %rbp, 0x78(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3070
leaq 0x118(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5807
movq 0x10(%r12), %rax
movq %rax, 0x60(%rbx)
movups (%r12), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x60(%rbx), %rax
movq %rax, 0x10(%rsp)
movdqu 0x50(%rbx), %xmm0
movdqu %xmm0, (%rsp)
callq 0x58d1
cmpl $0x2, %eax
je 0x8689
testl %eax, %eax
movl 0x28(%rsp), %ebp
jne 0x86b2
movl 0x5c(%rbx), %ecx
movl 0x60(%rbx), %r8d
movl 0x64(%rbx), %r9d
leaq 0x1d31b(%rip), %rdi     # 0x25986
leaq 0x1d3f5(%rip), %rdx     # 0x25a67
movl $0x1, %r12d
movl $0x1, %esi
xorl %eax, %eax
callq 0xde80
jmp 0x8ce6
movl 0x5c(%rbx), %ecx
movl 0x60(%rbx), %r8d
movl 0x64(%rbx), %r9d
leaq 0x1d2eb(%rip), %rdi     # 0x25986
leaq 0x1d40c(%rip), %rdx     # 0x25aae
movl $0x2, %esi
xorl %eax, %eax
callq 0xde80
movl 0x28(%rsp), %ebp
movslq (%r15), %rax
movq (%r13,%rax,8), %rdi
callq 0xc007
movq %rax, 0x110(%rsp)
testq %rax, %rax
je 0x86eb
movq %rax, %r12
leaq 0x1d2b0(%rip), %rdi     # 0x25986
leaq 0x1d44f(%rip), %rdx     # 0x25b2c
movl $0x3, %esi
xorl %eax, %eax
callq 0xde80
jmp 0x8733
movslq (%r15), %rax
movq (%r13,%rax,8), %rcx
leaq 0x1d28c(%rip), %rdi     # 0x25986
leaq 0x1d402(%rip), %rdx     # 0x25b03
movl $0x3, %esi
xorl %eax, %eax
callq 0xde80
movslq (%r15), %rax
movq (%r13,%rax,8), %rdi
movl $0x7, %esi
callq 0x12fb8
movq %rax, %r12
movq %rax, 0x110(%rsp)
testq %rax, %rax
je 0x8a05
cmpb $0x0, 0x70(%rsp)
jne 0x885b
movq 0x8(%r12), %rax
movslq 0x8(%rax), %rcx
testq %rcx, %rcx
jle 0x885b
movq 0x10(%rax), %rax
leal 0x3(%rcx), %edx
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %edx
shlq $0x5, %rdx
leaq (%rdx,%rdx,4), %rcx
movdqa 0x1d049(%rip), %xmm1    # 0x257c0
movdqa 0x1d051(%rip), %xmm2    # 0x257d0
xorl %edx, %edx
movdqa 0x1d057(%rip), %xmm3    # 0x257e0
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x1d057(%rip), %xmm5    # 0x257f0
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x87d6
movl $0x0, 0x14(%rax,%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x87ed
movl $0x0, 0x3c(%rax,%rdx)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0x882d
movl $0x0, 0x64(%rax,%rdx)
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x8843
movl $0x0, 0x8c(%rax,%rdx)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0xa0, %rdx
cmpq %rdx, %rcx
jne 0x8799
cmpq $0x0, 0xa8(%rsp)
je 0x89b0
cmpl $0x0, 0x58(%rbx)
je 0x89e2
movq %r14, 0x88(%rsp)
movq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0x3100
leaq 0x5(%rax), %rdi
leaq 0x1d0e7(%rip), %rsi     # 0x2597e
leaq 0x1d0e8(%rip), %r12     # 0x25986
movl $0x159, %edx            # imm = 0x159
movq %r12, %rcx
callq 0x23213
movq %rax, %rbp
movq %r14, %rdi
callq 0x3100
leaq 0x17(%rax), %rdi
leaq 0x1d0bd(%rip), %rsi     # 0x2597e
movl $0x15a, %edx            # imm = 0x15A
movq %r12, %rcx
callq 0x23213
movq %rax, %r12
movq %r14, %rdi
callq 0x3100
leaq 0x17(%rax), %rdi
leaq 0x1d09a(%rip), %rsi     # 0x2597e
movl $0x15b, %edx            # imm = 0x15B
leaq 0x1d096(%rip), %rcx     # 0x25986
callq 0x23213
movq %rax, 0x48(%rsp)
leaq 0x1d285(%rip), %rsi     # 0x25b86
movq %rbp, 0x50(%rsp)
movq %rbp, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3070
leaq 0x1d273(%rip), %rsi     # 0x25b8d
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3070
testb $0x8, 0x48(%rbx)
je 0x895f
leaq 0x1d268(%rip), %rsi     # 0x25b9c
movq %r12, %rdi
movq 0xa8(%rsp), %r14
movq %r14, %rdx
xorl %eax, %eax
callq 0x3070
leaq 0x1d263(%rip), %rsi     # 0x25bb3
movq 0x48(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3070
movq %r12, %r14
leaq 0x1d01d(%rip), %r12     # 0x25986
leaq 0x20bef(%rip), %rbp     # 0x2955f
movq %r12, %rdi
movq 0x50(%rsp), %rsi
movq %rbp, %rdx
callq 0xe023
movq %rax, 0x38(%rbx)
movq %r12, %rdi
movq %r14, 0xb0(%rsp)
movq %r14, %rsi
movq %rbp, %rdx
callq 0xe023
movq %rax, 0x70(%rsp)
testb $0x8, 0x48(%rbx)
jne 0x8a10
movq $0x0, 0x40(%rsp)
jmp 0x8a2d
movq $0x0, 0x70(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0xb0(%rsp)
movq $0x0, 0x48(%rsp)
jmp 0x8a39
leaq 0x1cf9d(%rip), %rdi     # 0x25986
leaq 0x1d165(%rip), %rdx     # 0x25b55
jmp 0x8541
movq %rbx, %rdi
callq 0x3a06
movq %rbx, %rdi
callq 0x3390
movl $0x1, %r12d
jmp 0x8ce6
leaq 0x1cf6f(%rip), %rdi     # 0x25986
leaq 0x20b41(%rip), %rdx     # 0x2955f
movq 0x48(%rsp), %rsi
callq 0xe023
movq %rax, 0x40(%rsp)
movl 0x28(%rsp), %ebp
movq 0x88(%rsp), %r14
movq 0x78(%rsp), %r12
testb $0x10, 0x4c(%rbx)
movslq (%r15), %rax
movq 0x8(%r13,%rax,8), %rsi
jne 0x8a5c
movq %rsi, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xa211
jmp 0x8a64
movq %r12, %rdi
callq 0x32c0
leaq 0x118(%rsp), %rsi
movq %r12, %rdi
callq 0x65b8
testq %rax, %rax
je 0x8b11
movq %rax, 0x28(%rsp)
movl 0x118(%rsp), %edi
leaq 0x1e3da(%rip), %rsi     # 0x26e6a
callq 0x36f0
movq %rax, 0x78(%rsp)
movq %rax, %rdi
callq 0xd7c8
movq %rax, 0xe0(%rsp)
movslq (%r15), %rax
leal 0x2(%rax), %ecx
cmpl %ebp, %ecx
jge 0x8b3e
testb $0x2, 0x48(%rbx)
movq 0x70(%rsp), %rbp
jne 0x8b4b
movq 0x10(%r13,%rax,8), %rdi
leaq 0xdc(%rsp), %rsi
callq 0x65b8
testq %rax, %rax
je 0x8cfb
movq %rax, %r15
movl 0xdc(%rsp), %edi
leaq 0x1e377(%rip), %rsi     # 0x26e6a
callq 0x36f0
movq %rax, %r13
movq %rax, %rdi
callq 0xd7c8
movq %rax, 0xe8(%rsp)
orb $0x2, 0x48(%rbx)
jmp 0x8b6b
movslq (%r15), %rax
movq 0x8(%r13,%rax,8), %rcx
leaq 0x1ce66(%rip), %rdi     # 0x25986
leaq 0x1d0a5(%rip), %rdx     # 0x25bcc
movl $0x1, %r12d
movl $0x1, %esi
xorl %eax, %eax
callq 0xde80
jmp 0x8ce6
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x70(%rsp), %rbp
jmp 0x8b6b
leaq 0x1ce34(%rip), %rdi     # 0x25986
leaq 0x1d08e(%rip), %rdx     # 0x25be7
xorl %r13d, %r13d
movl $0x2, %esi
xorl %eax, %eax
callq 0xde80
xorl %r15d, %r15d
testb $-0x80, 0x48(%rbx)
jne 0x8b8e
movq 0x110(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x38(%rbx), %rdx
movq 0x90(%rsp), %rsi
callq 0x13528
movl 0x9c(%rsp), %eax
testl %eax, %eax
jg 0x8ba6
movl 0x94(%rbx), %eax
imull 0x98(%rbx), %eax
leaq 0xe0(%rsp), %rdx
movl %eax, 0x2c(%rdx)
leaq 0x176(%rip), %rsi       # 0x8d2e
movl 0x6c(%rsp), %edi
movl $0x3, %ecx
callq 0xe99c
movq %rbx, %rdi
callq 0xb5a5
cmpq $0x0, 0xa8(%rsp)
je 0x8c0e
movl 0x40(%rbx), %edi
movl $0x1, %esi
movq %rbp, %rdx
movq 0xc8(%rsp), %rcx
callq 0xadd0
testb $0x8, 0x48(%rbx)
je 0x8c0e
movl 0x40(%rbx), %edi
xorl %esi, %esi
movq 0x40(%rsp), %rdx
movq 0xc8(%rsp), %rcx
callq 0xadd0
testb $0x14, 0x4c(%rbx)
jne 0x8c1c
movq %r12, %rdi
callq 0x36e0
movq 0x38(%rbx), %rdi
movq 0x27381(%rip), %rax     # 0x2ffa8
cmpq (%rax), %rdi
je 0x8c31
callq 0x32f0
testq %rbp, %rbp
je 0x8c3e
movq %rbp, %rdi
callq 0x32f0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8c4d
callq 0x32f0
movq %r14, %rdi
callq 0x3390
movq %r12, %rdi
callq 0x3390
movq 0x50(%rsp), %rdi
callq 0x3390
movq 0xb0(%rsp), %rdi
callq 0x3390
movq 0x48(%rsp), %rdi
callq 0x3390
movq 0x90(%rsp), %rdi
callq 0x3390
movq %rbx, %rdi
callq 0x3390
movq 0x110(%rsp), %rdi
callq 0x12fbd
movq 0xe0(%rsp), %rdi
callq 0xd84e
movq 0x78(%rsp), %rdi
callq 0xe747
movq 0x28(%rsp), %rdi
callq 0x7189
movq 0xe8(%rsp), %rdi
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x8ce6
callq 0xd84e
movq %r13, %rdi
callq 0xe747
movq %r15, %rdi
callq 0x7189
movl %r12d, %eax
addq $0x538, %rsp            # imm = 0x538
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x272d6(%rip), %rax     # 0x2ffd8
movslq (%rax), %rax
movq 0x10(%r13,%rax,8), %rcx
jmp 0x8b19
leaq 0x1cc7e(%rip), %rdi     # 0x25994
leaq 0x1cc61(%rip), %rsi     # 0x2597e
leaq 0x1cc81(%rip), %rcx     # 0x259a5
movl $0xca, %edx
callq 0x31a0