// File: /workspace/github_c_makefile_star2_O1/aokad[P]sequeeze/seqtk.c
// Function: stk_seq
int stk_seq(int argc, char *argv[])
{
	gzFile fp;
	kseq_t *seq;
	int c, qual_thres = 0, flag = 0, qual_shift = 33, mask_chr = 0, min_len = 0, max_q = 255, fake_qual = -1;
	unsigned i, line_len = 0;
	int64_t n_seqs = 0;
	double frac = 1.;
	khash_t(reg) *h = 0;
	krand_t *kr = 0;

	while ((c = getopt(argc, argv, "N12q:l:Q:aACrn:s:f:M:L:cVUX:SF:")) >= 0) {
		switch (c) {
			case 'a':
			case 'A': flag |= 1; break;
			case 'C': flag |= 2; break;
			case 'r': flag |= 4; break;
			case 'c': flag |= 8; break;
			case '1': flag |= 16; break;
			case '2': flag |= 32; break;
			case 'V': flag |= 64; break;
			case 'N': flag |= 128; break;
			case 'U': flag |= 256; break;
			case 'S': flag |= 512; break;
			case 'M': h = stk_reg_read(optarg); break;
			case 'n': mask_chr = *optarg; break;
			case 'Q': qual_shift = atoi(optarg); break;
			case 'q': qual_thres = atoi(optarg); break;
			case 'X': max_q = atoi(optarg); break;
			case 'l': line_len = atoi(optarg); break;
			case 'L': min_len = atoi(optarg); break;
			case 's': kr = kr_srand(atol(optarg)); break;
			case 'f': frac = atof(optarg); break;
			case 'F': fake_qual = *optarg; break;
		}
	}
	if (kr == 0) kr = kr_srand(11);
	if (argc == optind && isatty(fileno(stdin))) {
		fprintf(stderr, "\n");
		fprintf(stderr, "Usage:   seqtk seq [options] <in.fq>|<in.fa>\n\n");
		fprintf(stderr, "Options: -q INT    mask bases with quality lower than INT [0]\n");
		fprintf(stderr, "         -X INT    mask bases with quality higher than INT [255]\n");
		fprintf(stderr, "         -n CHAR   masked bases converted to CHAR; 0 for lowercase [0]\n");
		fprintf(stderr, "         -l INT    number of residues per line; 0 for 2^32-1 [%d]\n", line_len);
		fprintf(stderr, "         -Q INT    quality shift: ASCII-INT gives base quality [%d]\n", qual_shift);
		fprintf(stderr, "         -s INT    random seed (effective with -f) [11]\n");
		fprintf(stderr, "         -f FLOAT  sample FLOAT fraction of sequences [1]\n");
		fprintf(stderr, "         -M FILE   mask regions in BED or name list FILE [null]\n");
		fprintf(stderr, "         -L INT    drop sequences with length shorter than INT [0]\n");
		fprintf(stderr, "         -F CHAR   fake FASTQ quality []\n");
		fprintf(stderr, "         -c        mask complement region (effective with -M)\n");
		fprintf(stderr, "         -r        reverse complement\n");
		fprintf(stderr, "         -A        force FASTA output (discard quality)\n");
		fprintf(stderr, "         -C        drop comments at the header lines\n");
		fprintf(stderr, "         -N        drop sequences containing ambiguous bases\n");
		fprintf(stderr, "         -1        output the 2n-1 reads only\n");
		fprintf(stderr, "         -2        output the 2n reads only\n");
		fprintf(stderr, "         -V        shift quality by '(-Q) - 33'\n");
		fprintf(stderr, "         -U        convert all bases to uppercases\n");
		fprintf(stderr, "         -S        strip of white spaces in sequences\n");
		fprintf(stderr, "\n");
		free(kr);
		return 1;
	}
	if (line_len == 0) line_len = UINT_MAX;
	fp = optind < argc && strcmp(argv[optind], "-")? gzopen(argv[optind], "r") : gzdopen(fileno(stdin), "r");
	if (fp == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	seq = kseq_init(fp);
	qual_thres += qual_shift;
	while (kseq_read(seq) >= 0) {
		++n_seqs;
		if (seq->seq.l < min_len) continue; // NB: length filter before taking random
		if (frac < 1. && kr_drand(kr) >= frac) continue;
		if (flag & 48) { // then choose odd/even reads only
			if ((flag&16) && (n_seqs&1) == 0) continue;
			if ((flag&32) && (n_seqs&1) == 1) continue;
		}
		if (flag & 512) { // option -S: squeeze out white spaces
			int k;
			if (seq->qual.l) {
				for (i = k = 0; i < seq->seq.l; ++i)
					if (!isspace(seq->seq.s[i]))
						seq->qual.s[k++] = seq->qual.s[i];
				seq->qual.l = k;
			}
			for (i = k = 0; i < seq->seq.l; ++i)
				if (!isspace(seq->seq.s[i]))
					seq->seq.s[k++] = seq->seq.s[i];
			seq->seq.l = k;
		}
		if (seq->qual.l && qual_thres > qual_shift) {
			if (mask_chr) {
				for (i = 0; i < seq->seq.l; ++i)
					if (seq->qual.s[i] < qual_thres || seq->qual.s[i] > max_q)
						seq->seq.s[i] = mask_chr;
			} else {
				for (i = 0; i < seq->seq.l; ++i)
					if (seq->qual.s[i] < qual_thres || seq->qual.s[i] > max_q)
						seq->seq.s[i] = tolower(seq->seq.s[i]);
			}
		}
		if (flag & 256) // option -U: convert to uppercases
			for (i = 0; i < seq->seq.l; ++i)
				seq->seq.s[i] = toupper(seq->seq.s[i]);
		if (flag & 1) seq->qual.l = 0; // option -a: fastq -> fasta
		else if (fake_qual >= 33 && fake_qual <= 127) {
			if (seq->qual.m < seq->seq.m) {
				seq->qual.m = seq->seq.m;
				seq->qual.s = (char*)realloc(seq->qual.s, seq->qual.m);
			}
			seq->qual.l = seq->seq.l;
			memset(seq->qual.s, fake_qual, seq->qual.l);
			seq->qual.s[seq->qual.l] = 0;
		}
		if (flag & 2) seq->comment.l = 0; // option -C: drop fasta/q comments
		if (h) stk_mask(seq, h, flag&8, mask_chr); // masking
		if (flag & 4) { // option -r: reverse complement
			int c0, c1;
			for (i = 0; i < seq->seq.l>>1; ++i) { // reverse complement sequence
				c0 = comp_tab[(int)seq->seq.s[i]];
				c1 = comp_tab[(int)seq->seq.s[seq->seq.l - 1 - i]];
				seq->seq.s[i] = c1;
				seq->seq.s[seq->seq.l - 1 - i] = c0;
			}
			if (seq->seq.l & 1) // complement the remaining base
				seq->seq.s[seq->seq.l>>1] = comp_tab[(int)seq->seq.s[seq->seq.l>>1]];
			if (seq->qual.l) {
				for (i = 0; i < seq->seq.l>>1; ++i) // reverse quality
					c0 = seq->qual.s[i], seq->qual.s[i] = seq->qual.s[seq->qual.l - 1 - i], seq->qual.s[seq->qual.l - 1 - i] = c0;
			}
		}
		if ((flag & 64) && seq->qual.l && qual_shift != 33)
			for (i = 0; i < seq->qual.l; ++i)
				seq->qual.s[i] -= qual_shift - 33;
		if (flag & 128) { // option -N: drop sequences containing ambiguous bases - Note: this is the last step!
			for (i = 0; i < seq->seq.l; ++i)
				if (seq_nt16to4_table[seq_nt16_table[(int)seq->seq.s[i]]] > 3) break;
			if (i < seq->seq.l) continue;
		}
		stk_printseq(seq, line_len);
	}
	kseq_destroy(seq);
	gzclose(fp);
	stk_reg_destroy(h);
	free(kr);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movl %edi, %r12d
leaq 0x4a26(%rip), %rdx      # 0xbc8a
callq 0x2240
testl %eax, %eax
js 0x7494
movl $0xff, 0x20(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movsd 0x3ddf(%rip), %xmm0     # 0xb068
movsd %xmm0, 0x48(%rsp)
movl $0x21, %r13d
movq $0x0, 0x40(%rsp)
leaq 0x3e47(%rip), %rbx      # 0xb0ec
leaq 0x49de(%rip), %r14      # 0xbc8a
leaq 0x3e99(%rip), %rbp      # 0xb14c
movl $0x0, 0xc(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x38(%rsp)
cmpl $0x60, %eax
jg 0x7305
leal -0x41(%rax), %ecx
cmpl $0x17, %ecx
ja 0x7325
movslq (%rbx,%rcx,4), %rax
addq %rbx, %rax
jmpq *%rax
orl $0x2, 0xc(%rsp)
jmp 0x7468
addl $-0x61, %eax
cmpl $0x12, %eax
ja 0x7468
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
orl $0x1, 0xc(%rsp)
jmp 0x7468
cmpl $0x31, %eax
je 0x7463
cmpl $0x32, %eax
jne 0x7468
orl $0x20, 0xc(%rsp)
jmp 0x7468
orl $0x4, 0xc(%rsp)
jmp 0x7468
movq 0x8c86(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x2250
movq %rax, 0x40(%rsp)
jmp 0x7468
orl $0x8, 0xc(%rsp)
jmp 0x7468
movq 0x8c63(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x20a0
movsd %xmm0, 0x48(%rsp)
jmp 0x7468
movq 0x8c49(%rip), %rax      # 0xffd8
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x7468
movq 0x8c33(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x2250
movl %eax, 0x10(%rsp)
jmp 0x7468
movq 0x8c1b(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x2230
movq %rax, %rdi
callq 0x37bc
movq %rax, 0x30(%rsp)
jmp 0x7468
movq 0x8bfa(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x2250
movl %eax, %r13d
jmp 0x7468
orl $0x200, 0xc(%rsp)       # imm = 0x200
jmp 0x7468
movq 0x8bdc(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x314c
movq %rax, 0x28(%rsp)
jmp 0x7468
movq 0x8bc6(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x2250
movl %eax, 0x38(%rsp)
jmp 0x7468
movq 0x8bb1(%rip), %rax      # 0xffd8
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x7468
orl $0x80, 0xc(%rsp)
jmp 0x7468
orl $0x40, 0xc(%rsp)
jmp 0x7468
orl $0x100, 0xc(%rsp)       # imm = 0x100
jmp 0x7468
movq 0x8b83(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x2250
movl %eax, 0x20(%rsp)
jmp 0x7468
orl $0x10, 0xc(%rsp)
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2240
testl %eax, %eax
jns 0x72e5
movslq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x28(%rsp), %rbp
movq 0x30(%rsp), %r14
jmp 0x74e7
movl $0x21, %r13d
movsd 0x3bc6(%rip), %xmm0     # 0xb068
movsd %xmm0, 0x48(%rsp)
movq $0x0, 0x38(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movl $0xff, 0x20(%rsp)
movl $0x0, 0x10(%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
movl $0x0, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq $0x0, 0x40(%rsp)
testq %r14, %r14
jne 0x74f9
movl $0xb, %edi
callq 0x37bc
movq %rax, %r14
movq 0x8ad0(%rip), %rbx      # 0xffd0
cmpl %r12d, (%rbx)
jne 0x7523
movq 0x8abc(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
movl %eax, %edi
callq 0x2090
testl %eax, %eax
jne 0x7ac0
movq %r14, 0x30(%rsp)
xorl %eax, %eax
cmpl $0x1, 0x10(%rsp)
sbbl %eax, %eax
movl %eax, 0x24(%rsp)
movslq (%rbx), %rax
cmpl %r12d, %eax
jge 0x7565
movq (%r15,%rax,8), %r14
leaq 0x4e66(%rip), %rsi      # 0xc3ae
movq %r14, %rdi
callq 0x2170
testl %eax, %eax
je 0x7565
leaq 0x3c3d(%rip), %rsi      # 0xb198
movq %r14, %rdi
callq 0x2220
jmp 0x7582
movq 0x8a5c(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x3c1d(%rip), %rsi      # 0xb198
movl %eax, %edi
callq 0x20b0
testq %rax, %rax
je 0x7ab9
movq %rax, 0x60(%rsp)
movq %rax, %rdi
callq 0x3e57
movq %rax, %r15
movq %rax, %rdi
callq 0x3ea1
testl %eax, %eax
js 0x7a84
movl 0x10(%rsp), %eax
orl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rax
leal (%rax,%r13), %ebx
leaq 0x30(%r15), %r14
movq %r15, %rax
addq $0x48, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
andl $0x8, %eax
movl %eax, 0x54(%rsp)
xorl %r12d, %r12d
movq %r13, 0x58(%rsp)
movq %rbp, 0x28(%rsp)
movq 0x38(%rsp), %rax
cmpq %rax, (%r14)
jb 0x7a71
movsd 0x3a6e(%rip), %xmm0     # 0xb068
ucomisd 0x48(%rsp), %xmm0
jbe 0x762c
movq 0x30(%rsp), %rdi
callq 0x3818
shrq $0xb, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x3a60(%rip), %xmm0     # 0xb080
ucomisd 0x48(%rsp), %xmm0
jae 0x7a71
testb $0x30, 0xc(%rsp)
je 0x765c
testb $0x10, 0xc(%rsp)
sete %cl
testb $0x1, %r12b
sete %al
orb %al, %cl
cmpb $0x1, %cl
jne 0x7a71
movl 0xc(%rsp), %ecx
shrb $0x5, %cl
andb %al, %cl
jne 0x7a71
btl $0x9, 0xc(%rsp)
leaq 0x8d77(%rip), %r9       # 0x103e0
jae 0x7719
cmpq $0x0, 0x48(%r15)
je 0x76cc
cmpq $0x0, (%r14)
je 0x76c6
xorl %ebp, %ebp
movl $0x1, %r13d
callq 0x2290
xorl %ecx, %ecx
movq (%rax), %rdx
movq 0x40(%r15), %rsi
movsbq (%rsi,%rbp), %rsi
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x76af
movq 0x58(%r15), %rdx
movb (%rdx,%rbp), %sil
movslq %ecx, %rdi
incl %ecx
movb %sil, (%rdx,%rdi)
movl %r13d, %ebp
incl %r13d
cmpq %rbp, (%r14)
ja 0x768b
movslq %ecx, %rax
leaq 0x8d1c(%rip), %r9       # 0x103e0
jmp 0x76c8
xorl %eax, %eax
movq %rax, 0x48(%r15)
cmpq $0x0, (%r14)
je 0x7714
xorl %ebp, %ebp
movl $0x1, %r13d
callq 0x2290
leaq 0x8cfa(%rip), %r9       # 0x103e0
xorl %ecx, %ecx
movq (%rax), %rdi
movq 0x40(%r15), %rdx
movsbq (%rdx,%rbp), %rsi
testb $0x20, 0x1(%rdi,%rsi,2)
jne 0x7704
movslq %ecx, %rdi
incl %ecx
movb %sil, (%rdx,%rdi)
movl %r13d, %ebp
incl %r13d
cmpq %rbp, (%r14)
ja 0x76e8
movslq %ecx, %rax
jmp 0x7716
xorl %eax, %eax
movq %rax, (%r14)
cmpl $0x0, 0x40(%rsp)
setg %al
movq 0x10(%rsp), %rcx
cmpq $0x0, (%rcx)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x77bf
movq (%r14), %rax
cmpl $0x0, 0x18(%rsp)
je 0x7777
testq %rax, %rax
je 0x77bf
movl $0x1, %eax
xorl %ecx, %ecx
movq 0x58(%r15), %rdx
movsbl (%rdx,%rcx), %edx
cmpl %edx, %ebx
jg 0x7760
cmpl %edx, 0x20(%rsp)
jge 0x776c
movq 0x40(%r15), %rdx
movl 0x18(%rsp), %esi
movb %sil, (%rdx,%rcx)
movl %eax, %ecx
incl %eax
cmpq %rcx, (%r14)
ja 0x774e
jmp 0x77bf
testq %rax, %rax
je 0x77bf
movl $0x1, %r13d
xorl %ebp, %ebp
movq 0x58(%r15), %rax
movsbl (%rax,%rbp), %eax
cmpl %eax, %ebx
jg 0x7796
cmpl %eax, 0x20(%rsp)
jge 0x77b4
callq 0x2280
leaq 0x8c3e(%rip), %r9       # 0x103e0
movq (%rax), %rax
movq 0x40(%r15), %rcx
movsbq (%rcx,%rbp), %rdx
movb (%rax,%rdx,4), %al
movb %al, (%rcx,%rbp)
movl %r13d, %ebp
incl %r13d
cmpq %rbp, (%r14)
ja 0x7784
btl $0x8, 0xc(%rsp)
jae 0x77fc
cmpq $0x0, (%r14)
je 0x77fc
movl $0x1, %ebp
callq 0x2030
leaq 0x8c02(%rip), %r9       # 0x103e0
xorl %ecx, %ecx
movq (%rax), %rdx
movq 0x40(%r15), %rsi
movsbq (%rsi,%rcx), %rdi
movb (%rdx,%rdi,4), %dl
movb %dl, (%rsi,%rcx)
movl %ebp, %ecx
incl %ebp
cmpq %rcx, 0x30(%r15)
ja 0x77e0
testb $0x1, 0xc(%rsp)
jne 0x785a
cmpl $0x21, 0x1c(%rsp)
movq 0x58(%rsp), %r13
movq 0x28(%rsp), %rbp
jl 0x7870
movq 0x38(%r15), %rsi
cmpq %rsi, 0x50(%r15)
jae 0x782f
movq %rsi, 0x50(%r15)
movq 0x58(%r15), %rdi
callq 0x2200
movq %rax, 0x58(%r15)
movq 0x30(%r15), %rdx
movq 0x58(%r15), %rdi
movq %rdx, 0x48(%r15)
movzbl 0x1c(%rsp), %esi
callq 0x2120
movq 0x48(%r15), %rax
movq 0x58(%r15), %rcx
movb $0x0, (%rcx,%rax)
leaq 0x8b88(%rip), %r9       # 0x103e0
jmp 0x7870
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x58(%rsp), %r13
movq 0x28(%rsp), %rbp
testb $0x2, 0xc(%rsp)
je 0x787f
movq $0x0, 0x18(%r15)
testq %rbp, %rbp
je 0x789e
movq %r15, %rdi
movq %rbp, %rsi
movl 0x54(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x6f2a
leaq 0x8b42(%rip), %r9       # 0x103e0
testb $0x4, 0xc(%rsp)
je 0x7967
movq (%r14), %rax
cmpq $0x2, %rax
jae 0x78ba
movq %rax, %rsi
shrq %rsi
jmp 0x7902
movl $0x1, %ecx
xorl %edx, %edx
movq 0x40(%r15), %rsi
movsbq (%rsi,%rdx), %rdi
movb (%rdi,%r9), %dil
movq %rdx, %r8
notq %r8
addq %rsi, %rax
movsbq (%r8,%rax), %rax
movb (%rax,%r9), %al
movb %al, (%rsi,%rdx)
movq 0x40(%r15), %rax
addq 0x30(%r15), %rax
movb %dil, (%r8,%rax)
movl %ecx, %edx
movq 0x30(%r15), %rax
movq %rax, %rsi
shrq %rsi
incl %ecx
cmpq %rdx, %rsi
ja 0x78c1
testb $0x1, %al
je 0x7916
movq 0x40(%r15), %rax
movsbq (%rax,%rsi), %rcx
movb (%rcx,%r9), %cl
movb %cl, (%rax,%rsi)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x7967
cmpq $0x2, (%r14)
jb 0x7967
movl $0x1, %eax
xorl %ecx, %ecx
movq 0x58(%r15), %rdx
movb (%rdx,%rcx), %sil
movq %rcx, %rdi
notq %rdi
movq 0x48(%r15), %r8
addq %rdx, %r8
movb (%rdi,%r8), %r8b
movb %r8b, (%rdx,%rcx)
movq 0x58(%r15), %rcx
addq 0x48(%r15), %rcx
movb %sil, (%rdi,%rcx)
movl %eax, %ecx
movq 0x30(%r15), %rdx
shrq %rdx
incl %eax
cmpq %rcx, %rdx
ja 0x792e
testb $0x40, 0xc(%rsp)
je 0x79b7
cmpl $0x21, %r13d
setne %al
movq 0x10(%rsp), %rcx
cmpq $0x0, (%rcx)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x79b7
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x79b7
movl $0x1, %eax
xorl %ecx, %ecx
movq 0x58(%r15), %rdx
movb (%rdx,%rcx), %sil
subb %r13b, %sil
addb $0x21, %sil
movb %sil, (%rdx,%rcx)
movl %eax, %ecx
incl %eax
cmpq %rcx, 0x48(%r15)
ja 0x799a
cmpb $0x0, 0xc(%rsp)
jns 0x7a1d
movq (%r14), %rax
testq %rax, %rax
setne %dl
je 0x7a1d
movq 0x40(%r15), %rcx
movsbq (%rcx), %rsi
leaq 0x8798(%rip), %rdi      # 0x10170
movzbl (%rsi,%rdi), %esi
leaq 0x899d(%rip), %rdi      # 0x10380
cmpb $0x3, (%rsi,%rdi)
ja 0x7a19
movl $0x1, %esi
movl %esi, %esi
cmpq %rsi, %rax
seta %dl
jbe 0x7a1d
movsbq (%rcx,%rsi), %rdi
leaq 0x876c(%rip), %r8       # 0x10170
movzbl (%rdi,%r8), %edi
incl %esi
leaq 0x896e(%rip), %r8       # 0x10380
cmpb $0x4, (%rdi,%r8)
jb 0x79ee
testb %dl, %dl
jne 0x7a71
xorl %eax, %eax
cmpq $0x0, 0x48(%r15)
setne %al
leal 0x3e(,%rax,2), %edi
callq 0x2060
movq 0x10(%r15), %rdi
movq 0x8582(%rip), %rax      # 0xffc0
movq (%rax), %rsi
callq 0x2110
movq %r14, %rdi
movl 0x24(%rsp), %esi
callq 0xa459
cmpq $0x0, 0x48(%r15)
je 0x7a71
movl $0x2b, %edi
callq 0x2060
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xa459
incq %r12
movq %r15, %rdi
callq 0x3ea1
testl %eax, %eax
jns 0x75e4
movq %r15, %rdi
callq 0x4229
movq 0x60(%rsp), %rdi
callq 0x2040
movq %rbp, %rdi
callq 0x3739
movq 0x30(%rsp), %rdi
callq 0x2050
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b4d
jmp 0x7acf
movl 0x10(%rsp), %edi
movl %r13d, %esi
movq %r14, %rdx
callq 0x293f
movl $0x1, %eax
jmp 0x7aaa