// File: /workspace/github_c_makefile_star2_O2/lh3[P]miniprot/format.c
// Function: mp_write_residue
static void mp_write_residue(kstring_t *out, const mp_idx_t *mi, const mp_mapopt_t *opt, const char *aa, const mp_reg1_t *r)
{
	const mp_extra_t *e = r->p;
	int32_t k, w, w4, al = r->qs, nl = 0, l_tmp = 8; // enough to keep "##ATN\t\0"
	int32_t max_flank = opt->max_intron_flank;
	int64_t l_nt;
	uint8_t *nt;
	char *str[5];
	if (e == 0) return;
	for (k = 0; k < e->n_cigar; ++k) { // estimate the string length
		int32_t op = e->cigar[k]&0xf, len = e->cigar[k]>>4, len3 = len * 3;
		if (op == NS_CIGAR_M || op == NS_CIGAR_I || op == NS_CIGAR_D) l_tmp += len3;
		else if (op == NS_CIGAR_F || op == NS_CIGAR_G) l_tmp += len;
		else if (op == NS_CIGAR_N || op == NS_CIGAR_U || op == NS_CIGAR_V) {
			int32_t intron_len = op == NS_CIGAR_N? len : len - 3;
			l_tmp += intron_len <= max_flank * 2? len : max_flank * 2 + 20;
		}
	}
	l_tmp += 3;
	str[0] = Kmalloc(0, char, 5 * l_tmp);
	str[1] = str[0] + l_tmp;
	str[2] = str[1] + l_tmp;
	str[3] = str[2] + l_tmp;
	str[4] = str[3] + l_tmp;
	strcpy(str[0], "##ATN\t");
	strcpy(str[1], "##ATA\t");
	strcpy(str[2], "##AAS\t");
	strcpy(str[3], "##AQA\t");
	strcpy(str[4], "##STA\t");
	nt = Kmalloc(0, uint8_t, r->ve - r->vs + 3);
	l_nt = mp_ntseq_get_by_v(mi->nt, r->vid, r->vs, r->ve + 3, nt);
	assert(l_nt >= r->ve - r->vs);
	for (k = 0, w = w4 = 6; k < e->n_cigar; ++k) {
		int32_t i, j, l, op = e->cigar[k]&0xf, len = e->cigar[k]>>4, len3 = len * 3;
		assert(w < l_tmp);
		if (op == NS_CIGAR_M) {
			for (i = nl, j = al, l = 0; l < len; ++l, ++j, i += 3, w += 3) {
				uint8_t nt_aa, aa_aa, codon = nt[i]<<4 | nt[i+1]<<2 | nt[i+2];
				int32_t s;
				nt_aa = nt[i] > 3 || nt[i+1] > 3 || nt[i+2] > 3? ns_tab_aa20['X'] : ns_tab_codon[codon];
				aa_aa = ns_tab_aa20[(uint8_t)aa[j]];
				s = opt->mat[nt_aa * opt->asize + aa_aa];
				str[0][w] = "ACGTN"[nt[i]], str[0][w+1] = "ACGTN"[nt[i+1]], str[0][w+2] = "ACGTN"[nt[i+2]];
				str[1][w] = str[4][w4++] = ns_tab_aa_i2c[nt_aa], str[1][w+1] = str[1][w+2] = '.';
				str[2][w] = nt_aa == aa_aa? '|' : s > 0? '+' : ' ', str[2][w+1] = ' ', str[2][w+2] = ' ';
				str[3][w] = toupper(aa[j]), str[3][w+1] = str[3][w+2] = ' ';
			}
			nl += len3, al += len;
		} else if (op == NS_CIGAR_I) {
			for (j = 0; j < len; ++j, w += 3) {
				str[0][w] = str[0][w+1] = str[0][w+2] = '-';
				str[1][w] = '-', str[1][w+1] = str[1][w+2] = '.';
				str[2][w] = str[2][w+1] = str[2][w+2] = ' ';
				str[3][w] = toupper(aa[al + j]), str[3][w+1] = str[3][w+2] = ' ';
			}
			al += len;
		} else if (op == NS_CIGAR_D) {
			for (l = 0, i = nl; l < len; ++l, i += 3, w += 3) {
				uint8_t nt_aa, codon = nt[i]<<4 | nt[i+1]<<2 | nt[i+2];
				nt_aa = nt[i] > 3 || nt[i+1] > 3 || nt[i+2] > 3? ns_tab_aa20['X'] : ns_tab_codon[codon];
				str[0][w] = "ACGTN"[nt[i]], str[0][w+1] = "ACGTN"[nt[i+1]], str[0][w+2] = "ACGTN"[nt[i+2]];
				str[1][w] = str[4][w4++] = ns_tab_aa_i2c[nt_aa], str[1][w+1] = str[1][w+2] = '.';
				str[2][w] = str[2][w+1] = str[2][w+2] = ' ';
				str[3][w] = '-', str[3][w+1] = str[3][w+2] = ' ';
			}
			nl += len3;
		} else if (op == NS_CIGAR_F) {
			for (l = 0, i = nl; l < len; ++l, ++i, ++w)
				str[0][w] = "ACGTN"[nt[i]], str[1][w] = '!', str[2][w] = str[3][w] = ' ';
			nl += len;
		} else if (op == NS_CIGAR_G) {
			for (l = 0, i = nl; l < len; ++l, ++i, ++w) {
				str[0][w] = "ACGTN"[nt[i]], str[1][w] = '$', str[2][w] = ' ';
				str[3][w] = l == 0? toupper(aa[al]) : ' ';
			}
			nl += len, ++al;
		} else if (op == NS_CIGAR_N || op == NS_CIGAR_U || op == NS_CIGAR_V) {
			int32_t intron_len = op == NS_CIGAR_N? len : len - 3;
			if (op == NS_CIGAR_U || op == NS_CIGAR_V) { // phase-1 or phase-2 intron; print the first half of split codon
				uint8_t n1, n2, n3, codon, nt_aa, aa_aa;
				int32_t s;
				if (op == NS_CIGAR_U) n1 = nt[nl], n2 = nt[nl + len - 2], n3 = nt[nl + len - 1];
				else n1 = nt[nl], n2 = nt[nl + 1], n3 = nt[nl + len - 1];
				codon = n1<<4 | n2<<2 | n3;
				nt_aa = n1 > 3 || n2 > 3 || n3 > 3? ns_tab_aa20['X'] : ns_tab_codon[codon];
				aa_aa = ns_tab_aa20[(uint8_t)aa[al]];
				s = opt->mat[nt_aa * opt->asize + aa_aa];
				str[0][w] = "ACGTN"[nt[nl]];
				str[1][w] = str[4][w4++] = ns_tab_aa_i2c[nt_aa];
				str[2][w] = nt_aa == aa_aa? '|' : s > 0? '+' : ' ';
				str[3][w] = toupper(aa[al]);
				++w, ++nl;
				if (op == NS_CIGAR_V) {
					str[0][w] = "ACGTN"[nt[nl]], str[1][w] = '.', str[2][w] = str[3][w] = ' ';
					++w, ++nl;
				}
				++al;
			}
			if (intron_len <= max_flank * 2) {
				for (l = 0, i = nl; l < intron_len; ++l, ++i, ++w)
					str[0][w] = "acgtn"[nt[i]], str[1][w] = str[2][w] = str[3][w] = ' ';
			} else {
				int32_t il;
				for (l = 0, i = nl; l < max_flank; ++l, ++i, ++w)
					str[0][w] = "acgtn"[nt[i]], str[1][w] = str[2][w] = str[3][w] = ' ';
				str[0][w] = '~', str[1][w] = str[2][w] = ' ', str[3][w++] = ' ';
				il = snprintf(&str[0][w], l_tmp - w, "%d", intron_len);
				for (l = 0; l < il; ++l, ++w)
					str[1][w] = str[2][w] = str[3][w] = ' ';
				str[0][w] = '~', str[1][w] = str[2][w] = ' ', str[3][w++] = ' ';
				for (l = 0, i = nl + intron_len - max_flank; l < max_flank; ++l, ++i, ++w)
					str[0][w] = "acgtn"[nt[i]], str[1][w] = str[2][w] = str[3][w] = ' ';
			}
			nl += intron_len;
			if (op == NS_CIGAR_U || op == NS_CIGAR_V) { // phase-1 or phase-2 intron; print the second half of split codon
				str[0][w] = "ACGTN"[nt[nl]], str[1][w] = '.', str[2][w] = str[3][w] = ' ';
				++w, ++nl;
				if (op == NS_CIGAR_U) {
					str[0][w] = "ACGTN"[nt[nl]], str[1][w] = '.', str[2][w] = str[3][w] = ' ';
					++w, ++nl;
				}
			}
		}
	}
	assert(nl == r->ve - r->vs);
	if (l_nt == r->ve - r->vs + 3 && str[4][w4-1] != '*') { // then print one more codon
		uint8_t n1 = nt[nl], n2 = nt[nl + 1], n3 = nt[nl + 2], nt_aa, codon;
		codon = n1<<4 | n2<<2 | n3;
		nt_aa = n1 > 3 || n2 > 3 || n3 > 3? ns_tab_aa20['X'] : ns_tab_codon[codon];
		str[0][w] = "ACGTN"[n1], str[0][w+1] = "ACGTN"[n2], str[0][w+2] = "ACGTN"[n3];
		str[1][w] = str[4][w4++] = ns_tab_aa_i2c[nt_aa], str[1][w+1] = str[1][w+2] = '.';
		str[2][w] = str[2][w+1] = str[2][w+2] = ' ';
		str[3][w] = str[3][w+1] = str[3][w+2] = ' ';
		w += 3;
	}
	str[0][w] = str[1][w] = str[2][w] = str[3][w] = 0, str[4][w4] = 0;
	kfree(0, nt);
	if (opt->flag & MP_F_SHOW_RESIDUE)
		mp_sprintf_lite(out, "%s\n%s\n%s\n%s\n", str[0], str[1], str[2], str[3]);
	if (opt->flag & MP_F_SHOW_TRANS)
		mp_sprintf_lite(out, "%s\n", str[4]);
	kfree(0, str[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rcx, 0x78(%rsp)
movq 0x60(%r8), %r11
testq %r11, %r11
je 0x1004e
movq %r8, %rbx
movq %rsi, 0x20(%rsp)
movq %rdi, 0x118(%rsp)
movl 0x34(%r8), %eax
movl %eax, 0x18(%rsp)
movl 0x9c(%rdx), %ecx
movl 0xc(%r11), %eax
leal (%rcx,%rcx), %ebp
movq %rcx, 0xf0(%rsp)
leal 0x14(,%rcx,2), %ecx
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
pushq $0x8
popq %rsi
cmpq %r14, %rax
je 0xf324
movl 0x30(%r11,%r14,4), %r9d
movl %r9d, %r8d
andl $0xf, %r8d
movl %r9d, %edi
shrl $0x4, %edi
cmpl $0x2, %r8d
ja 0xf2ea
leal (%rdi,%rdi,2), %edi
addl %edi, %esi
jmp 0xf31f
andl $0xe, %r9d
cmpl $0xa, %r9d
je 0xf31b
cmpl $0x3, %r8d
setne %r10b
cmpl $0xc, %r9d
setne %r9b
testb %r9b, %r10b
jne 0xf31f
leal -0x3(%rdi), %r9d
cmpl $0x3, %r8d
cmovel %edi, %r9d
cmpl %ebp, %r9d
cmovgl %ecx, %edi
addl %esi, %edi
movl %edi, %esi
incq %r14
jmp 0xf2c6
movq %rdx, 0x80(%rsp)
movl %ebp, 0xec(%rsp)
movq %r11, 0x48(%rsp)
movslq %esi, %r12
leaq 0x3(%r12), %rax
movq %rax, 0x58(%rsp)
leal (%rax,%rax,4), %eax
movslq %eax, %rsi
xorl %edi, %edi
callq 0x7460
movq %rax, %r14
leaq (%rax,%r12), %rdx
addq $0x3, %rdx
leaq 0x3(%r12,%rdx), %rbp
leaq 0x3(%r12,%rbp), %r15
movl $0x54412323, %eax       # imm = 0x54412323
movl %eax, (%r14)
movl $0x94e54, 0x3(%r14)     # imm = 0x94E54
movl $0x94154, %ecx          # imm = 0x94154
movl %ecx, 0x6(%r14,%r12)
movl %eax, 0x3(%r14,%r12)
movl $0x95341, 0x6(%r12,%rdx) # imm = 0x95341
movq %rdx, 0x68(%rsp)
movl $0x41412323, 0x3(%r12,%rdx) # imm = 0x41412323
movl $0x94151, 0x6(%r12,%rbp) # imm = 0x94151
movl $0x51412323, 0x3(%r12,%rbp) # imm = 0x51412323
movl %ecx, 0x6(%r12,%r15)
movl $0x54532323, 0x3(%r12,%r15) # imm = 0x54532323
movq 0x48(%rbx), %rsi
subq 0x40(%rbx), %rsi
addq $0x3, %rsi
xorl %edi, %edi
callq 0x7460
movq %rax, %r8
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x30(%rbx), %esi
movq 0x40(%rbx), %rdx
movq 0x48(%rbx), %rcx
addq $0x3, %rcx
movq %r8, %r13
callq 0xaeb0
movq 0x48(%rbx), %rcx
movq %rbx, 0x120(%rsp)
subq 0x40(%rbx), %rcx
movq %rax, 0x110(%rsp)
cmpq %rcx, %rax
jl 0x101d4
movq %r15, 0x50(%rsp)
leaq (%r12,%r15), %rax
addq $0x3, %rax
movq %rax, 0x60(%rsp)
movq 0xf0(%rsp), %rax
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movq %rcx, 0x108(%rsp)
movq 0x58(%rsp), %rbx
leaq (%r14,%rbx), %rax
movq %rax, 0xb0(%rsp)
leaq (%r14,%rbx,2), %rax
movq %rax, 0xa8(%rsp)
leaq (%rbx,%rbx,2), %rax
leaq (%r14,%rax), %rcx
movq %rcx, 0xa0(%rsp)
leaq 0x2(%r14), %rcx
movq %rcx, 0xd0(%rsp)
leaq 0x2(%r14,%rbx), %rcx
movq %rcx, 0xc8(%rsp)
leaq 0x2(%r14,%rbx,2), %rcx
movq %rcx, 0xc0(%rsp)
leaq 0x2(%r14,%rax), %rcx
movq %rcx, 0xb8(%rsp)
leaq (%r14,%rbx,4), %rcx
movq %rcx, 0x100(%rsp)
movq %r13, 0x28(%rsp)
leaq 0x2(%r13), %rcx
movq %rcx, 0xf8(%rsp)
movq %r12, 0x98(%rsp)
leal 0x2(%r12), %ecx
movl %ecx, 0xe8(%rsp)
leaq 0x1(%r14), %rcx
movq %rcx, 0x148(%rsp)
movq %rax, 0x90(%rsp)
leaq 0x1(%r14,%rax), %rax
movq %rax, 0x140(%rsp)
leaq 0x1(%r14,%rbx,2), %rax
movq %rax, 0x138(%rsp)
movq %r14, 0x40(%rsp)
leaq 0x1(%r14,%rbx), %rax
movq %rax, 0x130(%rsp)
pushq $0x6
popq %rcx
leaq 0x8ff5(%rip), %rax      # 0x18510
addq $0x58, %rax
movq %rax, 0x128(%rsp)
leaq 0x27c2(%rip), %r8       # 0x11cf0
xorl %edx, %edx
movl %ecx, 0x1c(%rsp)
movl %ecx, %eax
movq %rax, 0x8(%rsp)
xorl %ecx, %ecx
movq %rbp, 0xd8(%rsp)
movq 0x48(%rsp), %r15
movslq 0xc(%r15), %rax
movl %edx, 0x4(%rsp)
movslq %edx, %r12
movq 0x8(%rsp), %rdx
movslq %edx, %r14
movslq 0x1c(%rsp), %r11
cmpq %rax, %rcx
jge 0xffc2
movq %r11, 0x38(%rsp)
cmpl %ebx, %edx
jge 0x101b5
movq %rcx, 0x30(%rsp)
movl 0x30(%r15,%rcx,4), %r10d
movl %r10d, %edx
andl $0xf, %edx
movl %r10d, %esi
shrl $0x4, %esi
movslq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $0xb, %edx
ja 0xf76b
leal (%rsi,%rsi,2), %edi
movl %edx, %eax
leaq 0x3d03(%rip), %rcx      # 0x132b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movl %edi, 0x14(%rsp)
jmpq *%rax
movq %rsi, 0x70(%rsp)
movq 0xd0(%rsp), %rax
leaq (%rax,%r14), %rbp
movq 0xc8(%rsp), %rax
addq %r14, %rax
movq %rax, 0x88(%rsp)
movq 0xc0(%rsp), %rax
addq %r14, %rax
movq %rax, 0x150(%rsp)
addq 0xb8(%rsp), %r14
movq 0x38(%rsp), %rax
addq 0x100(%rsp), %rax
movq %rax, 0x38(%rsp)
addq 0xf8(%rsp), %r12
movq 0x20(%rsp), %rax
addq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
shrl $0x4, %r10d
leaq (%r10,%r10,2), %rax
movq %rax, 0xe0(%rsp)
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpl %ebx, 0xe0(%rsp)
je 0xfa61
movzbl -0x2(%r12,%rbx), %eax
movl %eax, %ecx
shlb $0x4, %cl
movb -0x1(%r12,%rbx), %dl
movb (%r12,%rbx), %sil
leal (,%rdx,4), %edi
orb %cl, %dil
orb %sil, %dil
movzbl %dil, %ecx
addq 0x8968(%rip), %rcx      # 0x17fd8
cmpb $0x4, %sil
leaq 0x8e95(%rip), %rdi      # 0x18510
leaq 0x58(%rdi), %rsi
cmovaeq %rsi, %rcx
cmpb $0x4, %dl
cmovaeq %rsi, %rcx
cmpq $0x4, %rax
cmovaeq %rsi, %rcx
movzbl (%rcx), %ecx
movq 0x20(%rsp), %rdx
movzbl (%rdx,%r15), %edx
movzbl (%rdi,%rdx), %edx
movq 0x80(%rsp), %rdi
movl 0x94(%rdi), %esi
imull %ecx, %esi
addl %edx, %esi
movslq %esi, %rsi
cmpb $0x0, 0xa8(%rdi,%rsi)
movb (%rax,%r8), %al
movb %al, -0x2(%rbp,%rbx)
movzbl -0x1(%r12,%rbx), %eax
movb (%rax,%r8), %al
movb %al, -0x1(%rbp,%rbx)
movzbl (%r12,%rbx), %eax
movb (%rax,%r8), %al
movb %al, (%rbp,%rbx)
leaq 0x8aed(%rip), %rax      # 0x181d8
movq (%rax), %rax
movb (%rax,%rcx), %al
movq 0x38(%rsp), %rsi
movb %al, (%rsi,%r15)
movq 0x88(%rsp), %rsi
movb %al, -0x2(%rsi,%rbx)
movw $0x2e2e, -0x1(%rsi,%rbx) # imm = 0x2E2E
pushq $0x2b
popq %rax
jg 0xf715
pushq $0x20
popq %rax
cmpb %dl, %cl
pushq $0x7c
popq %rcx
cmovel %ecx, %eax
movq 0x150(%rsp), %rcx
movb %al, -0x2(%rcx,%rbx)
movw $0x2020, %r13w          # imm = 0x2020
movw %r13w, -0x1(%rcx,%rbx)
callq 0x2030
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movsbq (%rcx,%r15), %rcx
movb (%rax,%rcx,4), %al
movb %al, -0x2(%r14,%rbx)
movw %r13w, -0x1(%r14,%rbx)
addq $0x3, %rbx
incq %r15
leaq 0x258e(%rip), %r8       # 0x11cf0
movl 0x14(%rsp), %edi
jmp 0xf637
cmpl $0x3, %edx
setne %al
andl $0xe, %r10d
cmpl $0xc, %r10d
setne %cl
testb %cl, %al
jne 0xfb65
movq %rsi, %rax
addl $-0x3, %esi
cmpl $0x3, %edx
cmovel %eax, %esi
cmpl $0xc, %r10d
movl %edx, 0x88(%rsp)
movl %esi, 0x14(%rsp)
movq %r10, 0xe0(%rsp)
jne 0xfcbb
addl 0x4(%rsp), %eax
cmpl $0xc, %edx
movslq %eax, %rdx
movq 0x28(%rsp), %rsi
leaq -0x2(%rsi,%rdx), %rax
leaq 0x1(%rsi,%r12), %rcx
cmoveq %rax, %rcx
movzbl (%rsi,%r12), %eax
movq 0x128(%rsp), %rdi
movq %rdi, %rsi
cmpq $0x3, %rax
ja 0xf815
movb (%rcx), %cl
movq %rdi, %rsi
cmpb $0x3, %cl
ja 0xf815
movq 0x28(%rsp), %rsi
movb -0x1(%rsi,%rdx), %dl
movq %rdi, %rsi
cmpb $0x3, %dl
ja 0xf815
movl %eax, %esi
shlb $0x4, %sil
shlb $0x2, %cl
orb %dl, %sil
orb %cl, %sil
movzbl %sil, %esi
addq 0x87c3(%rip), %rsi      # 0x17fd8
movzbl (%rsi), %ecx
movq 0x20(%rsp), %r13
movq 0x78(%rsp), %rdx
movzbl (%rdx,%r13), %edx
leaq 0x8ce2(%rip), %rsi      # 0x18510
movzbl (%rsi,%rdx), %edx
movq 0x80(%rsp), %rdi
movl 0x94(%rdi), %esi
imull %ecx, %esi
addl %edx, %esi
movslq %esi, %rsi
cmpb $0x0, 0xa8(%rdi,%rsi)
movb (%rax,%r8), %al
movq 0x40(%rsp), %r15
movb %al, (%r15,%r14)
pushq $0x20
popq %rax
pushq $0x2b
popq %rsi
cmovgl %esi, %eax
cmpb %dl, %cl
leaq 0x8969(%rip), %rdx      # 0x181d8
movq (%rdx), %rdx
movb (%rdx,%rcx), %cl
movq 0x60(%rsp), %rdx
movq 0x38(%rsp), %rsi
movb %cl, (%rdx,%rsi)
movq 0x68(%rsp), %rbx
movb %cl, (%rbx,%r14)
pushq $0x7c
popq %rcx
cmovel %ecx, %eax
movb %al, (%rbp,%r14)
callq 0x2030
leaq 0x1(%r14), %rcx
incq %r12
movq (%rax), %rax
movq 0x78(%rsp), %rdx
movsbq (%rdx,%r13), %rdx
movb (%rax,%rdx,4), %al
movq 0x50(%rsp), %r11
movb %al, (%r11,%r14)
movq %r11, %r13
cmpl $0xd, 0x88(%rsp)
jne 0xfce4
movq 0x28(%rsp), %r10
movzbl (%r10,%r12), %eax
leaq 0x2413(%rip), %rdx      # 0x11cf0
movb (%rax,%rdx), %al
movb %al, (%r15,%rcx)
movb $0x2e, (%rbx,%rcx)
movb $0x20, %r14b
movb %r14b, (%r13,%rcx)
movb %r14b, (%rbp,%rcx)
movq 0x8(%rsp), %rax
addl $0x2, %eax
movq %rax, 0x8(%rsp)
addl $0x2, 0x4(%rsp)
movq %rbx, %r12
movq 0x98(%rsp), %r8
movq 0x90(%rsp), %r9
jmp 0xfd09
movq 0xd0(%rsp), %rax
addq %r14, %rax
movq 0xc8(%rsp), %rcx
addq %r14, %rcx
movq 0xc0(%rsp), %rdx
addq %r14, %rdx
addq 0xb8(%rsp), %r14
movq 0x38(%rsp), %rdi
addq 0x100(%rsp), %rdi
addq 0xf8(%rsp), %r12
shrl $0x4, %r10d
leaq (%r10,%r10,2), %rsi
movq %rdi, %r13
xorl %edi, %edi
cmpl %edi, %esi
je 0xfa41
movzbl -0x2(%r12,%rdi), %r8d
movl %r8d, %r9d
shlb $0x4, %r9b
movb -0x1(%r12,%rdi), %r10b
movb (%r12,%rdi), %r11b
leal (,%r10,4), %ebx
orb %r9b, %bl
orb %r11b, %bl
movzbl %bl, %r9d
movq 0x58(%rsp), %rbx
addq 0x8632(%rip), %r9       # 0x17fd8
cmpb $0x4, %r11b
leaq 0x8b5f(%rip), %r11      # 0x18510
leaq 0x58(%r11), %r11
cmovaeq %r11, %r9
cmpb $0x4, %r10b
cmovaeq %r11, %r9
cmpq $0x4, %r8
cmovaeq %r11, %r9
movzbl (%r9), %r9d
leaq 0x231c(%rip), %r10      # 0x11cf0
movb (%r8,%r10), %r8b
movb %r8b, -0x2(%rax,%rdi)
movzbl -0x1(%r12,%rdi), %r8d
movb (%r8,%r10), %r8b
movb %r8b, -0x1(%rax,%rdi)
movzbl (%r12,%rdi), %r8d
movb (%r8,%r10), %r8b
movb %r8b, (%rax,%rdi)
leaq 0x87d8(%rip), %r8       # 0x181d8
movq (%r8), %r8
movb (%r8,%r9), %r8b
movb %r8b, (%r13)
movb %r8b, -0x2(%rcx,%rdi)
movw $0x2e2e, -0x1(%rcx,%rdi) # imm = 0x2E2E
movb $0x20, %r8b
movb %r8b, (%rdx,%rdi)
movw $0x2020, -0x2(%rdx,%rdi) # imm = 0x2020
movw $0x202d, -0x2(%r14,%rdi) # imm = 0x202D
movb %r8b, (%r14,%rdi)
addq $0x3, %rdi
incl 0x1c(%rsp)
incq %r13
jmp 0xf96a
movq 0x8(%rsp), %rax
addl %edi, %eax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %edx
addl 0x14(%rsp), %edx
leaq 0x2294(%rip), %r8       # 0x11cf0
jmp 0xfcae
movq 0x8(%rsp), %rax
addl %ebx, %eax
movq %rax, 0x8(%rsp)
addl %r15d, 0x1c(%rsp)
movl 0x4(%rsp), %edx
addl %edi, %edx
movq 0x70(%rsp), %rax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0xfc9c
movq 0x20(%rsp), %rax
addq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xd0(%rsp), %rax
leaq (%rax,%r14), %rbx
movq 0xc8(%rsp), %rax
leaq (%rax,%r14), %r15
movq 0xc0(%rsp), %rax
leaq (%rax,%r14), %r12
addq 0xb8(%rsp), %r14
movq %r14, 0x38(%rsp)
movq %rsi, 0x70(%rsp)
leaq (%rsi,%rsi,2), %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0xfb33
movb $0x2d, (%rbx,%rbp)
movw $0x2d2d, -0x2(%rbx,%rbp) # imm = 0x2D2D
movw $0x2e2d, -0x2(%r15,%rbp) # imm = 0x2E2D
movb $0x2e, (%r15,%rbp)
movb $0x20, (%r12,%rbp)
movw $0x2020, %r14w          # imm = 0x2020
movw %r14w, -0x2(%r12,%rbp)
callq 0x2030
movq (%rax), %rax
movq 0x20(%rsp), %rdx
movsbq (%rdx), %rcx
movb (%rax,%rcx,4), %al
movq 0x38(%rsp), %rcx
movb %al, -0x2(%rcx,%rbp)
movw %r14w, -0x1(%rcx,%rbp)
addq $0x3, %rbp
incq %rdx
movq %rdx, 0x20(%rsp)
jmp 0xfad5
movq 0x8(%rsp), %rax
addl %ebp, %eax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0xd8(%rsp), %rbp
movq 0x48(%rsp), %r15
movq 0x58(%rsp), %rbx
leaq 0x218b(%rip), %r8       # 0x11cf0
movq 0x30(%rsp), %rcx
movl 0x4(%rsp), %edx
jmp 0xfcb3
movq %rsi, %r9
movq 0x40(%rsp), %rax
addq %r14, %rax
movq 0xb0(%rsp), %rcx
addq %r14, %rcx
movq 0xa0(%rsp), %rdx
addq %r14, %rdx
addq 0xa8(%rsp), %r14
addq 0x28(%rsp), %r12
shrl $0x4, %r10d
xorl %esi, %esi
cmpl %esi, %r10d
je 0xfbcd
movzbl (%r12,%rsi), %edi
movb (%rdi,%r8), %dil
movb %dil, (%rax,%rsi)
movb $0x21, (%rcx,%rsi)
movb $0x20, %dil
movb %dil, (%rdx,%rsi)
movb %dil, (%r14,%rsi)
incq %rsi
jmp 0xfba7
movq 0x8(%rsp), %rax
addl %esi, %eax
movq %rax, 0x8(%rsp)
addl 0x4(%rsp), %r9d
movl %r9d, %edx
jmp 0xfcae
movq %rsi, 0x70(%rsp)
movq 0x40(%rsp), %rax
leaq (%rax,%r14), %rcx
movq 0xb0(%rsp), %rax
leaq (%rax,%r14), %rbp
movq 0xa8(%rsp), %rax
leaq (%rax,%r14), %r13
addq 0xa0(%rsp), %r14
addq 0x28(%rsp), %r12
shrl $0x4, %r10d
xorl %ebx, %ebx
movq %r14, 0x38(%rsp)
cmpl %ebx, %r10d
je 0xfc81
movzbl (%r12,%rbx), %eax
movb (%rax,%r8), %al
movb %al, (%rcx,%rbx)
movb $0x24, (%rbp,%rbx)
movb $0x20, (%r13,%rbx)
movb $0x20, %al
testl %ebx, %ebx
jne 0xfc78
movq %rcx, %r14
movq %r10, %r15
callq 0x2030
movq %r15, %r10
leaq 0x2095(%rip), %r8       # 0x11cf0
movq (%rax), %rax
movq 0x78(%rsp), %rcx
movq 0x20(%rsp), %rdx
movsbq (%rcx,%rdx), %rcx
movb (%rax,%rcx,4), %al
movq %r14, %rcx
movq 0x38(%rsp), %r14
movb %al, (%r14,%rbx)
incq %rbx
jmp 0xfc24
movq 0x8(%rsp), %rax
addl %ebx, %eax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
addl 0x4(%rsp), %eax
incl 0x18(%rsp)
movl %eax, %edx
movq 0xd8(%rsp), %rbp
movq 0x48(%rsp), %r15
movq 0x58(%rsp), %rbx
movq 0x30(%rsp), %rcx
incq %rcx
jmp 0xf54a
movq 0x40(%rsp), %r15
movq 0x68(%rsp), %r12
movq 0x50(%rsp), %r13
movq 0x28(%rsp), %r10
movq 0x98(%rsp), %r8
movq 0x90(%rsp), %r9
movb $0x20, %r14b
jmp 0xfd15
movl %r12d, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movq %rbx, %r12
movq 0x28(%rsp), %r10
movq 0x98(%rsp), %r8
movq 0x90(%rsp), %r9
movb $0x20, %r14b
movl 0x14(%rsp), %esi
incl 0x1c(%rsp)
incl 0x18(%rsp)
movslq 0x4(%rsp), %rax
movslq 0x8(%rsp), %rbx
cmpl 0xec(%rsp), %esi
jle 0xfd9b
movq %rbx, %rcx
shlq $0x20, %rcx
leaq (%r15,%rbx), %rsi
movq 0xa0(%rsp), %rdx
leaq (%rdx,%rbx), %rdi
movq 0xa8(%rsp), %rdx
leaq (%rdx,%rbx), %r8
movq 0xb0(%rsp), %rdx
leaq (%rdx,%rbx), %r9
addq %r10, %rax
incl %ebx
xorl %edx, %edx
cmpl %edx, 0x108(%rsp)
je 0xfde4
movzbl (%rax,%rdx), %r10d
leaq 0x36b7(%rip), %r11      # 0x1342a
movb (%r10,%r11), %r10b
movb %r10b, (%rsi,%rdx)
movb %r14b, (%rdi,%rdx)
movb %r14b, (%r8,%rdx)
movb %r14b, (%r9,%rdx)
incq %rdx
movabsq $0x100000000, %r10      # imm = 0x100000000
addq %r10, %rcx
incl %ebx
jmp 0xfd5e
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
leaq (%r15,%rbx), %rdx
negq %rbx
addq %r10, %rax
xorl %esi, %esi
cmpl %esi, %ecx
je 0xfe64
movzbl (%rax,%rsi), %edi
leaq 0x3666(%rip), %r11      # 0x1342a
movb (%rdi,%r11), %dil
movb %dil, (%rdx)
movb %r14b, (%rdx,%r9)
movb %r14b, 0x6(%rdx,%r8,2)
movb %r14b, 0x3(%rdx,%r8)
decq %rbx
incq %rdx
incq %rsi
jmp 0xfdb1
sarq $0x20, %rcx
movb $0x7e, (%r15,%rcx)
movb %r14b, (%rbp,%rcx)
movb %r14b, (%r12,%rcx)
movq 0x8(%rsp), %rsi
leal 0x1(%rsi,%rdx), %eax
movb %r14b, (%r13,%rcx)
movslq %eax, %r14
leaq (%r15,%r14), %rdi
movl 0xe8(%rsp), %eax
subl %esi, %eax
subl %edx, %eax
movslq %eax, %rsi
leaq 0x358d(%rip), %rdx      # 0x133ad
movl 0x14(%rsp), %ecx
xorl %eax, %eax
callq 0x2120
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
shlq $0x20, %rbx
subl $0x1, %eax
jb 0xfe76
movq 0x50(%rsp), %rcx
movb $0x20, %dl
movb %dl, (%rcx,%r14)
movb %dl, (%rbp,%r14)
movb %dl, (%r12,%r14)
incq %r14
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rcx, %rbx
jmp 0xfe39
negq %rbx
movq %rbx, 0x8(%rsp)
movq 0x58(%rsp), %rbx
jmp 0xff26
sarq $0x20, %rbx
movb $0x7e, (%r15,%rbx)
movb $0x20, %cl
movb %cl, (%rbp,%rbx)
movb %cl, (%r12,%rbx)
movq 0x50(%rsp), %rax
movb %cl, (%rax,%rbx)
movl 0x14(%rsp), %eax
subl 0xf0(%rsp), %eax
addl 0x4(%rsp), %eax
cltq
movq 0x148(%rsp), %rcx
addq %r14, %rcx
movq 0x140(%rsp), %rdx
addq %r14, %rdx
movq 0x138(%rsp), %rsi
addq %r14, %rsi
movq 0x130(%rsp), %rdi
addq %r14, %rdi
addq 0x28(%rsp), %rax
xorl %r8d, %r8d
movq 0x58(%rsp), %rbx
cmpl %r8d, 0x108(%rsp)
je 0xff0d
movzbl (%rax,%r8), %r9d
leaq 0x3539(%rip), %r10      # 0x1342a
movb (%r9,%r10), %r9b
movb %r9b, (%rcx,%r8)
movb $0x20, %r9b
movb %r9b, (%rdx,%r8)
movb %r9b, (%rsi,%r8)
movb %r9b, (%rdi,%r8)
incq %r8
jmp 0xfedb
leaq (%r14,%r8), %rax
incq %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %r13
movq 0x28(%rsp), %r10
movb $0x20, %r14b
movl 0x4(%rsp), %esi
addl 0x14(%rsp), %esi
cmpl $0xc, 0xe0(%rsp)
leaq 0x1db3(%rip), %r8       # 0x11cf0
jne 0xffa0
movslq %esi, %rcx
movzbl (%r10,%rcx), %eax
movb (%rax,%r8), %al
movq 0x8(%rsp), %rdi
movslq %edi, %rdx
movb %al, (%r15,%rdx)
movslq %edi, %rax
incq %rax
incq %rcx
movb $0x2e, (%r12,%rdx)
movb %r14b, (%r13,%rdx)
movb %r14b, (%rbp,%rdx)
cmpl $0xc, 0x88(%rsp)
jne 0xffb1
movzbl (%r10,%rcx), %ecx
movb (%rcx,%r8), %cl
movb %cl, (%r15,%rax)
movb $0x2e, (%r12,%rax)
movb %r14b, (%r13,%rax)
movb %r14b, (%rbp,%rax)
addl $0x2, %edi
movq %rdi, 0x8(%rsp)
addl $0x2, %esi
movq 0x48(%rsp), %r15
movq 0x30(%rsp), %rcx
movl %esi, %edx
jmp 0xfcb3
movl %ecx, %edx
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %r15
jmp 0xfcae
movq 0x120(%rsp), %rcx
movq 0x48(%rcx), %rax
subq 0x40(%rcx), %rax
cmpq %r12, %rax
jne 0x101f3
leaq 0x3(%r12), %rax
cmpq %rax, 0x110(%rsp)
jne 0x10060
movq 0x80(%rsp), %rbx
movq 0x60(%rsp), %r9
cmpb $0x2a, -0x1(%r9,%r11)
movq 0x8(%rsp), %rax
je 0x10114
movq 0x28(%rsp), %rdx
movzbl (%rdx,%r12), %eax
cmpq $0x4, %rax
setae %sil
movb 0x1(%rdx,%r12), %cl
movb 0x2(%rdx,%r12), %dil
movzbl %cl, %edx
movzbl %dil, %ecx
cmpb $0x4, %dl
setae %dil
orb %sil, %dil
cmpb $0x4, %cl
setae %sil
orb %dil, %sil
je 0x10077
leaq 0x84c8(%rip), %rsi      # 0x18510
addq $0x58, %rsi
jmp 0x10095
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x80(%rsp), %rbx
movq 0x60(%rsp), %r9
movq 0x8(%rsp), %rax
jmp 0x10114
movl %eax, %esi
shlb $0x4, %sil
leal (,%rdx,4), %edi
orb %cl, %sil
orb %dil, %sil
movzbl %sil, %esi
addq 0x7f43(%rip), %rsi      # 0x17fd8
movq 0x40(%rsp), %rdi
movq 0x68(%rsp), %r8
movq 0x60(%rsp), %r9
movzbl (%rsi), %esi
leaq 0x1c42(%rip), %r10      # 0x11cf0
movb (%rax,%r10), %al
movb %al, (%rdi,%r14)
movb (%rdx,%r10), %al
movb %al, 0x1(%rdi,%r14)
movb (%rcx,%r10), %al
movb %al, 0x2(%rdi,%r14)
leaq 0x8109(%rip), %rax      # 0x181d8
movq (%rax), %rax
movb (%rax,%rsi), %al
leal 0x1(%r11), %ecx
movl %ecx, 0x1c(%rsp)
movb %al, (%r9,%r11)
movb %al, (%r8,%r14)
movw $0x2e2e, 0x1(%r8,%r14)  # imm = 0x2E2E
movb $0x20, %al
movb %al, 0x2(%rbp,%r14)
movw $0x2020, %cx            # imm = 0x2020
movw %cx, (%rbp,%r14)
movq 0x50(%rsp), %rdx
movb %al, 0x2(%rdx,%r14)
movw %cx, (%rdx,%r14)
addl $0x3, %r14d
movl %r14d, %eax
cltq
xorl %ecx, %ecx
movq 0x50(%rsp), %r12
movb %cl, (%r12,%rax)
movb %cl, (%rbp,%rax)
movq 0x68(%rsp), %r15
movb %cl, (%r15,%rax)
movq 0x40(%rsp), %r14
movb %cl, (%r14,%rax)
movslq 0x1c(%rsp), %rax
movb %cl, (%r9,%rax)
xorl %edi, %edi
movq 0x28(%rsp), %rsi
callq 0x736b
movq %rbx, %r13
movl (%rbx), %eax
testb %al, %al
movq 0x118(%rsp), %rbx
jns 0x1017e
leaq 0x33ba(%rip), %rsi      # 0x1351e
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rbp, %r8
movq %r12, %r9
xorl %eax, %eax
callq 0xdd2c
movl (%r13), %eax
btl $0x8, %eax
jae 0x1019a
leaq 0x339c(%rip), %rsi      # 0x13527
movq %rbx, %rdi
movq 0x60(%rsp), %rdx
xorl %eax, %eax
callq 0xdd2c
xorl %edi, %edi
movq %r14, %rsi
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x736b
leaq 0x3358(%rip), %rdi      # 0x13514
leaq 0x3209(%rip), %rsi      # 0x133cc
leaq 0x32df(%rip), %rcx      # 0x134a9
movl $0xdf, %edx
callq 0x2150
leaq 0x32b8(%rip), %rdi      # 0x13493
leaq 0x31ea(%rip), %rsi      # 0x133cc
leaq 0x32c0(%rip), %rcx      # 0x134a9
movl $0xdc, %edx
callq 0x2150
leaq 0x324e(%rip), %rdi      # 0x13448
leaq 0x31cb(%rip), %rsi      # 0x133cc
leaq 0x32a1(%rip), %rcx      # 0x134a9
movl $0x139, %edx            # imm = 0x139
callq 0x2150