LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_n_fmt_sample(std::vector<char, std::allocator<char>>&) const
void entry::get_n_fmt_sample(vector<char> &out) const
{
	out.resize(sizeof(uint32_t));
	uint32_t n_fmt_sample = (uint32_t)(FORMAT.size()-N_FORMAT_removed);
	uint32_t n_sample = (uint32_t)N_indv;

	n_fmt_sample = n_fmt_sample << 24;
	n_fmt_sample = n_fmt_sample | n_sample;

	memcpy(&out[0], &n_fmt_sample, sizeof(n_fmt_sample));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
movq %rbx, %rdi
callq 0xf31a
movl 0x4a0(%r14), %eax
subl 0x498(%r14), %eax
shrl $0x5, %eax
subl 0x4cc(%r14), %eax
shll $0x18, %eax
orl 0x8(%r14), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_ALLELES_binary(std::vector<char, std::allocator<char>>&)
void entry::get_ALLELES_binary(vector<char> &out)
{
	vector<char> tmp;
	out.resize(0);

	make_typed_string(tmp, REF, true );
	out.insert(out.end(), tmp.begin(), tmp.end());

	for (unsigned int ui=0; ui<ALT.size(); ui++)
	{
		tmp.resize(0);
		make_typed_string(tmp, ALT[ui], true );
		out.insert(out.end(), tmp.begin(), tmp.end());
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0xf31a
leaq 0x428(%r14), %rdx
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %ecx
callq 0x1fbdc
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x1be7e
movq 0x450(%r14), %rax
cmpq 0x448(%r14), %rax
je 0x238ee
movl $0x1, %ebp
xorl %r12d, %r12d
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xf31a
shlq $0x5, %r12
addq 0x448(%r14), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x1fbdc
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x1be7e
movq 0x450(%r14), %rax
subq 0x448(%r14), %rax
movl %ebp, %r12d
sarq $0x5, %rax
incl %ebp
cmpq %r12, %rax
ja 0x23895
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x238fc
callq 0x5410
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2390f
jmp 0x2390f
jmp 0x2390f
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x23920
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_setters.cpp
// Function: entry::add_ALT_allele(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void entry::add_ALT_allele(const string &in)
{
	if (in != ".")
	{
		if (find(ALT.begin(), ALT.end(),in) == ALT.end())
		{
			ALT.push_back(in);
		}
		else
		{
			LOG.warning(" Duplicate alternate alleles found at " + CHROM + ":" + LOG.int2str(POS));
			ALT.push_back(in);
		}
	}
	parsed_ALT = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15d18(%rip), %rsi     # 0x3a20d
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x246b4
movq 0x448(%rbx), %rdi
movq 0x450(%rbx), %rsi
movq %r14, %rdx
callq 0x247a0
cmpq 0x450(%rbx), %rax
je 0x246a5
leaq 0x3e0(%rbx), %rdx
leaq 0x166bd(%rip), %rsi     # 0x3abf3
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0xb7dd
leaq 0x16b6b(%rip), %rsi     # 0x3b0b5
movq %r15, %rdi
callq 0x5870
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x24579
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x24580
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x400(%rbx), %esi
leaq 0x40(%rsp), %rdi
callq 0x375de
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x48(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r15, %rcx
je 0x245ca
movq 0x30(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x245e9
leaq 0x50(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x245e4
movq 0x50(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x245fa
movq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x50f0
jmp 0x24608
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x54d0
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x2462b
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x24631
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x25e53(%rip), %rdi     # 0x4a4a8
movq %rsp, %rsi
callq 0x3749c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24670
callq 0x5410
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24683
callq 0x5410
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x24692
callq 0x5410
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x246a5
callq 0x5410
leaq 0x448(%rbx), %rdi
movq %r14, %rsi
callq 0x13080
movb $0x1, 0x3da(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x246e3
callq 0x5410
jmp 0x246e3
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x246fb
callq 0x5410
jmp 0x246fb
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2470f
callq 0x5410
jmp 0x2470f
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24722
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_setters.cpp
// Function: entry::set_indv_DEPTH(unsigned int, int)
void entry::set_indv_DEPTH(unsigned int indv, int in)
{
	parsed_DP[indv] = true;
	if (in == -1)
	{
		if (!DEPTH.empty())
			DEPTH[indv] = -1;
		return;
	}
	if (DEPTH.empty())
		DEPTH.resize(N_indv, -1);

	DEPTH[indv] = in;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl $0x1, %eax
movl %ebx, %ecx
shlq %cl, %rax
movq 0x5b0(%rdi), %rcx
shrl $0x6, %esi
orq %rax, (%rcx,%rsi,8)
movq 0x530(%rdi), %rax
movq 0x538(%rdi), %rcx
cmpl $-0x1, %edx
je 0x24788
movl %edx, %ebp
leaq 0x530(%rdi), %r14
cmpq %rcx, %rax
jne 0x24783
movl 0x8(%rdi), %esi
leaq 0xc(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0xbb1a
movq (%r14), %rax
jmp 0x24792
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x24797
movl %ebx, %ecx
movl %ebp, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_ALT(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vcf_entry::set_ALT(const string &in)
{
	istringstream ss(in);
	string tmpstr;
	ALT.resize(0);
	while(!ss.eof())
	{
		getline(ss, tmpstr, ',');
		add_ALT_allele(tmpstr);
	}
	parsed_ALT = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movl $0x8, %edx
callq 0x5730
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x448(%rbx), %rdi
xorl %esi, %esi
callq 0x1300a
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x48(%rsp,%rax)
jne 0x24951
movq %r14, %rdi
movq %r15, %rsi
movl $0x2c, %edx
callq 0x5830
movq %rbx, %rdi
movq %r15, %rsi
callq 0x244dc
jmp 0x24924
movb $0x1, 0x3da(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24967
callq 0x5410
movq 0x2564a(%rip), %rsi     # 0x49fb8
leaq 0x28(%rsp), %rdi
callq 0x5610
leaq 0xa0(%rsp), %rdi
callq 0x5100
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x24996
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x249a8
callq 0x5410
movq 0x25609(%rip), %rsi     # 0x49fb8
leaq 0x28(%rsp), %rdi
callq 0x5610
leaq 0xa0(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_PHASE(unsigned int, char)
void vcf_entry::set_indv_PHASE(unsigned int indv, char in)
{
	if (PHASE.size() == 0)
		PHASE.resize(N_indv, '/');

	PHASE[indv] = in;
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movq 0x508(%rdi), %rax
cmpq 0x500(%rdi), %rax
jne 0x25349
leaq 0x500(%r14), %rdi
movl 0x8(%r14), %esi
leaq 0xf(%rsp), %rdx
movb $0x2f, (%rdx)
callq 0x25d74
movl %ebx, %eax
movq 0x500(%r14), %rcx
movb %bpl, (%rcx,%rax)
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GENOTYPE_alleles(unsigned int, char, char)
void vcf_entry::set_indv_GENOTYPE_alleles(unsigned int indv, char a1, char a2)
{
	if (GENOTYPE.size() == 0)
		GENOTYPE.resize(N_indv, make_pair(-1,-1));

	pair<int, int> a(-1,-1);

	if (a1 != '.')
		a.first = a1 - '0';

	if (a2 != '.')
		a.second = a2 - '0';

	GENOTYPE[indv] = a;
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
movq 0x4d8(%rdi), %rax
cmpq 0x4d0(%rdi), %rax
jne 0x253b5
leaq 0x4d0(%r14), %rdi
movl 0x8(%r14), %esi
movq %rsp, %rdx
movq $-0x1, (%rdx)
callq 0x25d40
movsbl %r15b, %eax
leal -0x30(%rax), %ecx
cmpb $0x2e, %al
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %eax, %ecx
movsbl %bpl, %edx
leal -0x30(%rdx), %esi
cmpb $0x2e, %dl
cmovel %eax, %esi
movl %ebx, %eax
movq 0x4d0(%r14), %rdx
movl %ecx, (%rdx,%rax,8)
movl %esi, 0x4(%rdx,%rax,8)
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GENOTYPE_alleles(unsigned int, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void vcf_entry::set_indv_GENOTYPE_alleles(unsigned int indv, const pair<string, string> &in)
{
	if (GENOTYPE.size() == 0)
		GENOTYPE.resize(N_indv, make_pair(-1,-1));

	pair<int, int> a(-1,-1);

	if (in.first != ".")
		a.first = header::str2int(in.first);

	if (in.second != ".")
		a.second = header::str2int(in.second);

	GENOTYPE[indv] = a;
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq 0x4d8(%rdi), %rax
cmpq 0x4d0(%rdi), %rax
jne 0x25448
leaq 0x4d0(%r14), %rdi
movl 0x8(%r14), %esi
leaq 0x8(%rsp), %rdx
movq $-0x1, (%rdx)
callq 0x25d40
leaq 0x14dbe(%rip), %rsi     # 0x3a20d
movq %r15, %rdi
callq 0x50e0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x25476
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16b6e
movl %eax, %r12d
addq $0x20, %r15
leaq 0x14d8c(%rip), %rsi     # 0x3a20d
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x2549c
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16b6e
movl %eax, %ebp
movl %ebx, %eax
movq 0x4d0(%r14), %rcx
movl %r12d, (%rcx,%rax,8)
movl %ebp, 0x4(%rcx,%rax,8)
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int, std::pair<int, int> const&, char)
void vcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int indv, const pair<int, int> &genotype, char phase)
{
	ploidy.resize(N_indv);
	ploidy[indv] = 2;
	set_indv_GENOTYPE_ids(indv, genotype);
	set_indv_PHASE(indv, phase);
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
addq $0x4e8, %rdi            # imm = 0x4E8
movl 0x8(%r15), %esi
callq 0xc1c0
movl %ebx, %eax
movq 0x4e8(%r15), %rcx
movl $0x2, (%rcx,%rax,4)
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x25544
movq %r15, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x25312
movq 0x560(%r15), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GQUALITY(unsigned int, double)
void vcf_entry::set_indv_GQUALITY(unsigned int indv, double in)
{
	parsed_GQ[indv] = true;
	if (in == -1)
	{
		if (GQUALITY.size() > 0)
			GQUALITY[indv] = -1;
		return;
	}
	if (GQUALITY.size() == 0)
		GQUALITY.resize(N_indv, -1);

	if (in > 99)
		in = 99;
	GQUALITY[indv] = in;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq 0x588(%rdi), %rax
movl %esi, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
ucomisd 0x14a31(%rip), %xmm0    # 0x3a060
movq 0x518(%rdi), %rax
movq 0x520(%rdi), %rcx
jne 0x25650
jp 0x25650
cmpq %rax, %rcx
je 0x2569b
movsd 0x14a12(%rip), %xmm1    # 0x3a060
jmp 0x25694
leaq 0x518(%rdi), %r14
cmpq %rax, %rcx
jne 0x25685
movl 0x8(%rdi), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xbb4e
movsd 0x8(%rsp), %xmm0
movsd 0x15593(%rip), %xmm1    # 0x3ac20
minsd %xmm0, %xmm1
movq (%r14), %rax
movl %ebx, %ecx
movsd %xmm1, (%rax,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_indv_GFILTER(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vcf_entry::set_indv_GFILTER(unsigned int indv, const string &in)
{
	parsed_FT[indv] = true;

	if (GFILTER.size() == 0)
		GFILTER.resize(N_indv);

	GFILTER[indv].resize(0);
	if ((in.size() == 0) || (in == "."))
		return;

	static istringstream ss;
	static string ith_FILTER;
	ss.clear();
	ss.str(in);
	while (!ss.eof())
	{
		getline(ss, ith_FILTER, ';');

		if ((ith_FILTER.size()==0) || (ith_FILTER == "."))
			continue;	// Don't bother storing "unfiltered" state.

		GFILTER[indv].push_back(ith_FILTER);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ecx
movl %esi, %r15d
movq 0x5d8(%rdi), %rax
movl %esi, %edx
movl $0x1, %esi
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
leaq 0x548(%rdi), %rbx
movq 0x550(%rdi), %rax
cmpq 0x548(%rdi), %rax
jne 0x256ef
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x25da2
leaq (%r15,%r15,2), %r13
shlq $0x3, %r13
movq (%rbx), %rdi
addq %r13, %rdi
xorl %esi, %esi
callq 0x1300a
cmpq $0x0, 0x8(%r14)
je 0x257d8
leaq 0x14af7(%rip), %rsi     # 0x3a20d
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x257d8
movb 0x2596c(%rip), %al      # 0x4b098
testb %al, %al
je 0x257e2
movb 0x25986(%rip), %al      # 0x4b0c0
testb %al, %al
je 0x2582d
movq 0x257cf(%rip), %rax     # 0x4af18
leaq 0x257c8(%rip), %r15     # 0x4af18
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x5750
leaq 0x257c3(%rip), %rdi     # 0x4af28
movq %r14, %rsi
callq 0x5640
movq 0x257a4(%rip), %rax     # 0x4af18
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rax,%r15)
jne 0x257d8
leaq 0x25919(%rip), %r14     # 0x4b0a0
leaq 0x14a7f(%rip), %r12     # 0x3a20d
movq %r15, %rdi
movq %r14, %rsi
movl $0x3b, %edx
callq 0x5830
cmpq $0x0, 0x25902(%rip)     # 0x4b0a8
je 0x257c5
movq %r14, %rdi
movq %r12, %rsi
callq 0x50e0
testl %eax, %eax
je 0x257c5
movq (%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x13080
movq 0x2574c(%rip), %rax     # 0x4af18
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rax,%r15)
je 0x2578e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x258af(%rip), %rdi     # 0x4b098
callq 0x5810
testl %eax, %eax
je 0x25734
leaq 0x2571b(%rip), %rdi     # 0x4af18
callq 0x5310
movq 0x2478f(%rip), %rdi     # 0x49f98
leaq 0x25708(%rip), %rsi     # 0x4af18
leaq 0x24c41(%rip), %rdx     # 0x4a458
callq 0x53d0
leaq 0x25875(%rip), %rdi     # 0x4b098
callq 0x5270
jmp 0x25734
callq 0x5d65
jmp 0x25742
movq %rax, %rbx
leaq 0x25857(%rip), %rdi     # 0x4b098
callq 0x5250
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_FILTER(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vcf_entry::set_FILTER(const string &FILTER_str)
{
	FILTER.resize(0);

	if (FILTER_str != ".")
	{
		istringstream ss(FILTER_str);
		string ith_FILTER;
		while (!ss.eof())
		{
			getline(ss, ith_FILTER, ';');
			FILTER.push_back(ith_FILTER);
		}
	}
	sort(FILTER.begin(), FILTER.end());
	parsed_FILTER = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x468(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1300a
leaq 0x14991(%rip), %rsi     # 0x3a20d
movq %r12, %rdi
callq 0x50e0
testl %eax, %eax
je 0x25913
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x5730
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %rsp, %r12
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x258e7
movq %r15, %rdi
movq %r12, %rsi
movl $0x3b, %edx
callq 0x5830
movq %r14, %rdi
movq %r12, %rsi
callq 0x13080
jmp 0x258ba
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x258f5
callq 0x5410
movq 0x246bc(%rip), %rsi     # 0x49fb8
leaq 0x20(%rsp), %rdi
callq 0x5610
leaq 0x98(%rsp), %rdi
callq 0x5100
movq 0x468(%rbx), %r14
movq 0x470(%rbx), %r15
cmpq %r15, %r14
je 0x25953
movq %r15, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x265a7
movq %r14, %rdi
movq %r15, %rsi
callq 0x2668b
movb $0x1, 0x3db(%rbx)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2597c
callq 0x5410
movq 0x24635(%rip), %rsi     # 0x49fb8
leaq 0x20(%rsp), %rdi
callq 0x5610
leaq 0x98(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_ALT(int)
void bcf_entry::set_ALT(const int n_allele)
{
	ALT.resize(n_allele-1);
	unsigned int pos = ALT_pos;
	string allele;
	for (int ui=0; ui<(n_allele-1); ui++)
	{
		allele = get_typed_string( &pos, line );
		std::transform(allele.begin(), allele.end(), allele.begin(), ::toupper);
		ALT[ui] = allele;
	}

	parsed_ALT = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r15d
movq %rdi, %rbx
addq $0x448, %rdi            # imm = 0x448
leal -0x1(%r15), %ebp
movslq %ebp, %rsi
movq %rdi, 0x20(%rsp)
callq 0x1300a
movq %rbx, (%rsp)
movl 0x6f0(%rbx), %eax
movl %eax, 0xc(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpl $0x2, %r15d
jl 0x27016
movq (%rsp), %rax
addq $0x3c0, %rax            # imm = 0x3C0
movq %rax, 0x18(%rsp)
movl %ebp, %eax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0x48(%rsp), %r12
leaq 0x28(%rsp), %rbp
movq %r12, %rdi
movq (%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x212c0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x5550
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x26fcc
callq 0x5410
movq 0x30(%rsp), %r15
testq %r15, %r15
je 0x26ff5
movq 0x28(%rsp), %r13
xorl %ebx, %ebx
movsbl (%r13,%rbx), %edi
callq 0x5840
movb %al, (%r13,%rbx)
incq %rbx
cmpq %rbx, %r15
jne 0x26fdd
movq %r14, %rdi
shlq $0x5, %rdi
movq 0x20(%rsp), %rax
addq (%rax), %rdi
movq %rbp, %rsi
callq 0x51f0
incq %r14
cmpq 0x10(%rsp), %r14
jne 0x26f97
movq (%rsp), %rax
movb $0x1, 0x3da(%rax)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x27035
callq 0x5410
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27046
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2705d
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::add_FORMAT_entry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&)
void bcf_entry::add_FORMAT_entry(const string &in, const unsigned int &fmt_key, const unsigned int &pos, const unsigned int &line_pos, const unsigned int &type, const unsigned int &size)
{
	FORMAT.push_back(in);
	FORMAT_to_idx[in] = pos;
	FORMAT_positions[pos] = line_pos;
	FORMAT_types[pos] = type;
	FORMAT_sizes[pos] = size;
	FORMAT_keys[pos] = fmt_key;

	if ( (type==1) or (type==7) )
		FORMAT_skip[pos] = ( sizeof(int8_t)*size );
	else if ( type==2 )
		FORMAT_skip[pos] = ( sizeof(int16_t)*size );
	else if ( (type==3) or (type==5) )
		FORMAT_skip[pos] = ( sizeof(int32_t)*size );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %rbp
movq %rdi, %r14
addq $0x498, %rdi            # imm = 0x498
callq 0x13080
movl (%rbx), %r12d
leaq 0x600(%r14), %rdi
movq %rbp, %rsi
callq 0x1b42a
movq 0x40(%rsp), %rsi
movl %r12d, (%rax)
movl (%r13), %eax
movl (%rbx), %ecx
movq 0x640(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movl (%r15), %eax
movl (%rbx), %ecx
movq 0x658(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movl (%rsi), %eax
movl (%rbx), %ecx
movq 0x670(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movq (%rsp), %rax
movl (%rax), %eax
movl (%rbx), %ecx
movq 0x6a0(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movl (%r15), %eax
decl %eax
cmpl $0x6, %eax
ja 0x27dce
leaq 0x12ef2(%rip), %rcx     # 0x3ac9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rsi), %eax
jmp 0x27dc2
movl (%rsi), %eax
shll $0x2, %eax
jmp 0x27dc2
movl (%rsi), %eax
addl %eax, %eax
movl (%rbx), %ecx
movq 0x688(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_indv_GENOTYPE_alleles(unsigned int, std::pair<int, int> const&)
void bcf_entry::set_indv_GENOTYPE_alleles(unsigned int indv, const pair<int, int> &in)
{
	if (GENOTYPE.size() == 0)
		GENOTYPE.resize(N_indv, make_pair(-1,-1));

	pair<int, int> a(-1,-1);

	if (in.first == 0x81)
		a.first = -2;
	else if (in.first != 0x80)
		a.first = in.first;

	if (in.second == 0x81)
		a.second = -2;
	else if (in.second != 0x80)
		a.second = in.second;

	GENOTYPE[indv] = in;
	parsed_GT[indv] = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq 0x4d8(%rdi), %rax
cmpq 0x4d0(%rdi), %rax
jne 0x281cd
leaq 0x4d0(%r14), %rdi
movl 0x8(%r14), %esi
leaq 0x8(%rsp), %rdx
movq $-0x1, (%rdx)
callq 0x25d40
movl %ebx, %eax
movq 0x4d0(%r14), %rcx
movq (%r15), %rdx
movq %rdx, (%rcx,%rax,8)
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, char)
void bcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int indv, const pair<string, string> &genotype, char phase)
{
	pair<int, int> a(-1,-1);
	if (genotype.first != ".")
		a.first = header::str2int(genotype.first);
	if (genotype.second != ".")
		a.second = header::str2int(genotype.second);

	set_indv_GENOTYPE_alleles(indv, a);
	set_indv_PHASE(indv, phase);
	parsed_GT[indv] = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq $-0x1, (%rsp)
leaq 0x11ef1(%rip), %rsi     # 0x3a20d
movq %rdx, %rdi
callq 0x50e0
testl %eax, %eax
je 0x28338
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16b6e
movl %eax, (%rsp)
addq $0x20, %r15
leaq 0x11eca(%rip), %rsi     # 0x3a20d
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x28360
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16b6e
movl %eax, 0x4(%rsp)
movq %rsp, %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x28190
movsbl %bpl, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x28202
movq 0x560(%r14), %rax
movl %ebx, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_indv_GQUALITY(unsigned int, std::vector<char, std::allocator<char>> const&)
void bcf_entry::set_indv_GQUALITY(unsigned int indv, const vector<char> &in)
{
	float tmp;
	memcpy(&tmp, &in[0], sizeof(tmp));

	parsed_GQ[indv] = true;
	if (tmp == 0x7F800001)
	{
		if (GQUALITY.size() > 0)
			GQUALITY[indv] = -1;
		return;
	}
	if (GQUALITY.size() == 0)
		GQUALITY.resize(N_indv, -1);

	if (tmp > 99.0)
		tmp = 99;
	GQUALITY[indv] = tmp;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq (%rdx), %rax
movss (%rax), %xmm1
movq 0x588(%rdi), %rax
movl %esi, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
ucomiss 0x11eef(%rip), %xmm1    # 0x3a2c0
movq 0x518(%rdi), %rax
movq 0x520(%rdi), %rcx
jne 0x283f2
jp 0x283f2
cmpq %rax, %rcx
je 0x28441
movsd 0x11c70(%rip), %xmm0    # 0x3a060
jmp 0x2843a
leaq 0x518(%rdi), %r14
cmpq %rax, %rcx
jne 0x28427
movl 0x8(%rdi), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %r14, %rdi
movss %xmm1, 0xc(%rsp)
callq 0xbb4e
movss 0xc(%rsp), %xmm1
movss 0x1288d(%rip), %xmm0    # 0x3acbc
minss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_indv_GQUALITY(unsigned int, float const&)
void bcf_entry::set_indv_GQUALITY(unsigned int indv, const float &in)
{
	parsed_GQ[indv] = true;
	if ( (in == -1) or (in == 0x7F800001) )
	{
		if (GQUALITY.size() > 0)
			GQUALITY[indv] = -1;
		return;
	}
	if (GQUALITY.size() == 0)
		GQUALITY.resize(N_indv, -1);

	if (in > 99)
		GQUALITY[indv] = 99;
	else
		GQUALITY[indv] = in;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq 0x588(%rdi), %rax
movl %esi, %edx
movl $0x1, %esi
movl %ebx, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
orq %rsi, (%rax,%rdx,8)
movss (%r14), %xmm0
ucomiss 0x12842(%rip), %xmm0    # 0x3acc0
movq 0x518(%rdi), %rax
movq 0x520(%rdi), %rcx
jne 0x28490
jnp 0x284df
ucomiss 0x11e29(%rip), %xmm0    # 0x3a2c0
jne 0x2849b
jnp 0x284df
leaq 0x518(%rdi), %r15
cmpq %rax, %rcx
jne 0x284c4
movl 0x8(%rdi), %esi
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r15, %rdi
callq 0xbb4e
movss (%r14), %xmm0
ucomiss 0x127ec(%rip), %xmm0    # 0x3acbc
jbe 0x284ee
movq (%r15), %rax
movsd 0x12743(%rip), %xmm0    # 0x3ac20
jmp 0x284f5
cmpq %rax, %rcx
je 0x284fc
movsd 0x11b74(%rip), %xmm0    # 0x3a060
jmp 0x284f5
cvtss2sd %xmm0, %xmm0
movq (%r15), %rax
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry_setters.cpp
// Function: bcf_entry::set_FILTER()
void bcf_entry::set_FILTER()
{
	FILTER_str = get_int_vector( &FILTER_pos, line );
	FILTER.resize(0);

	if ( (FILTER_str.size() == 1) and entry_header.FILTER_map[ FILTER_str[0] ].ID == "")
	{
		FILTER.push_back("PASS");
		return;
	}

	for (unsigned int ui=0; ui<FILTER_str.size(); ui++)
	{
		if ((int8_t)FILTER_str[ui] != (int8_t)0x80)
			FILTER.push_back( entry_header.FILTER_map[ FILTER_str[ui] ].ID );
		else
			FILTER.push_back( "." );
	}
	sort(FILTER.begin(), FILTER.end());
	parsed_FILTER = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x6ec(%rdi), %rdx
leaq 0x3c0(%rdi), %rcx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2170c
movq 0x6d0(%rbx), %rdi
movaps (%r14), %xmm0
movq 0x10(%r14), %rax
movq %rdi, (%r14)
movups 0x6d8(%rbx), %xmm1
movups %xmm0, 0x6d0(%rbx)
movq %rax, 0x6e0(%rbx)
movups %xmm1, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x289a6
callq 0x5410
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x289b4
callq 0x5410
leaq 0x468(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1300a
movq 0x6d0(%rbx), %rsi
movq 0x6d8(%rbx), %rax
subq %rsi, %rax
cmpq $0x4, %rax
jne 0x28a00
leaq 0xa0(%rbx), %rdi
callq 0x177f8
leaq 0x20(%rax), %rdi
leaq 0x1250c(%rip), %rsi     # 0x3aeff
callq 0x50e0
testl %eax, %eax
je 0x28afc
movq 0x6d0(%rbx), %rax
cmpq %rax, 0x6d8(%rbx)
je 0x28aa6
leaq 0xa0(%rbx), %r15
movl $0x1, %r13d
xorl %r12d, %r12d
movq %rsp, %rbp
xorl %ecx, %ecx
cmpb (%rax,%rcx,4), %r12b
jno 0x28a6e
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
leaq 0x117cb(%rip), %rsi     # 0x3a20d
leaq 0x117c5(%rip), %rdx     # 0x3a20e
callq 0xc868
movq %r14, %rdi
movq %rbp, %rsi
callq 0x13458
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x28a86
callq 0x5410
jmp 0x28a86
leaq (%rax,%rcx,4), %rsi
movq %r15, %rdi
callq 0x177f8
leaq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0x13080
movl %r13d, %ecx
movq 0x6d0(%rbx), %rax
movq 0x6d8(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %r13d
cmpq %rcx, %rdx
ja 0x28a29
movq 0x468(%rbx), %r14
movq 0x470(%rbx), %r15
cmpq %r15, %r14
je 0x28ae6
movq %r15, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x265a7
movq %r14, %rdi
movq %r15, %rsi
callq 0x2668b
movb $0x1, 0x3db(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10aad(%rip), %rsi     # 0x395b9
leaq 0x10aaa(%rip), %rdx     # 0x395bd
movq %rsp, %rdi
callq 0xc868
movq %rsp, %rsi
movq %r14, %rdi
callq 0x13458
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x28aed
callq 0x5410
jmp 0x28aed
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x28b5c
jmp 0x28b61
jmp 0x28b46
movq %rax, %rbx
jmp 0x28b61
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x28b61
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_allele_type(bool, bool)
void entry::filter_sites_by_allele_type(bool keep_only_indels, bool remove_indels)
{
	if (passed_filters == false)
		return;

	if ((keep_only_indels == false) && (remove_indels == false))
		return;
	if ((keep_only_indels == true) && (remove_indels == true))
		LOG.error("Can't both keep and remove all indels!");

	string allele;
	unsigned int ref_len, N_alleles;
	bool is_indel;

	parse_basic_entry(true);
	is_indel = false;
	allele = REF;
	ref_len = allele.size();
	if (ref_len != 1)
		is_indel = true;
	N_alleles = get_N_alleles();
	for (unsigned int ui=1; ui<N_alleles; ui++)
	{
		get_allele(ui, allele);
		if (allele.size() != ref_len)
		{
			is_indel = true;
			break;
		}
	}

	if (keep_only_indels == true)
	{
		if (is_indel == false)
			passed_filters = false;
	}
	else if (remove_indels == true)
	{
		if (is_indel == true)
			passed_filters = false;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, (%rsp)
movl %esi, %eax
orb %bpl, %al
cmpb $0x1, %al
jne 0x28f6b
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x28f6b
movl (%rsp), %eax
andb %bpl, %al
cmpb $0x1, %al
jne 0x28eb2
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x120cf(%rip), %rsi     # 0x3af4a
leaq 0x120ee(%rip), %rdx     # 0x3af70
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xc868
leaq 0x21612(%rip), %rdi     # 0x4a4a8
movq %r15, %rsi
movl $0x1, %edx
callq 0x3721e
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x28eb2
callq 0x5410
movl %ebp, 0x4(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x428(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x51f0
movl 0x10(%rsp), %r14d
cmpq $0x1, %r14
setne %bpl
movq %rbx, %rdi
callq 0x230f4
movl %eax, %r15d
cmpl $0x2, %eax
jb 0x28f40
movl $0x1, %r12d
leaq 0x8(%rsp), %r13
movq %rbx, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x22088
cmpq %r14, 0x10(%rsp)
jne 0x28f38
incl %r12d
cmpl %r12d, %r15d
jne 0x28f19
jmp 0x28f3b
movb $0x1, %bpl
leaq 0x18(%rsp), %r12
cmpb $0x0, (%rsp)
je 0x28f4d
testb %bpl, %bpl
je 0x28f58
jmp 0x28f5c
andb 0x4(%rsp), %bpl
cmpb $0x1, %bpl
jne 0x28f5c
movb $0x0, 0xc(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x28f6b
callq 0x5410
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
jne 0x28f9d
jmp 0x28fa2
jmp 0x28f8b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x28fa2
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void entry::filter_sites(const set<string> &snps_to_keep, const string &snps_to_keep_file, const string &snps_to_exclude_file, bool keep_then_exclude)
{
	// Filter sites by user provided lists
	if (keep_then_exclude)
	{
		filter_sites_to_keep(snps_to_keep, snps_to_keep_file);
		filter_sites_to_exclude(snps_to_exclude_file);
	}
	else
	{
		filter_sites_to_exclude(snps_to_exclude_file);
		filter_sites_to_keep(snps_to_keep, snps_to_keep_file);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
testl %r8d, %r8d
je 0x28fe4
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2c12c
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2c328
movq %r14, %rsi
callq 0x2c328
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2c12c
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_position(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
void entry::filter_sites_by_position(const string &chr, int start_pos, int end_pos)
{
	// Filter sites by user provided position range
	if (passed_filters == false)
		return;

	if ((chr == "") || ((start_pos == -1) && (end_pos==numeric_limits<int>::max())))
		return;

	parse_basic_entry();

	if (CHROM == chr)
	{
		if ((POS < start_pos) || (POS > end_pos))
			passed_filters = false;
	}
	else
		passed_filters = false;
}

// Assembly:
cmpb $0x0, 0xc(%rdi)
je 0x2922b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x11d48(%rip), %rsi     # 0x3aeff
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x29221
movl %r14d, %eax
notl %eax
movl %ebp, %ecx
xorl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl %eax, %ecx
je 0x29221
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movq 0x3e8(%rbx), %rdx
cmpq 0x8(%r15), %rdx
jne 0x2921d
testq %rdx, %rdx
je 0x29208
movq (%r15), %rsi
movq 0x3e0(%rbx), %rdi
callq 0x5470
testl %eax, %eax
jne 0x2921d
movl 0x400(%rbx), %eax
cmpl %r14d, %eax
setge %cl
cmpl %ebp, %eax
setle %al
testb %al, %cl
jne 0x29221
movb $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_chromosome(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void entry::filter_sites_by_chromosome(const set<string> &chrs_to_keep, const set<string> &chrs_to_exclude)
{
	if (passed_filters == false)
		return;

	if (chrs_to_keep.empty() && chrs_to_exclude.empty())
		return;

	parse_basic_entry();

	if (!chrs_to_keep.empty())
	{
		if (chrs_to_keep.find(CHROM) == chrs_to_keep.end())
			passed_filters = false;
	}
	else
	{
		if (chrs_to_exclude.find(CHROM) != chrs_to_exclude.end())
			passed_filters = false;
	}
}

// Assembly:
cmpb $0x0, 0xc(%rdi)
je 0x2a2c0
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x28(%rdx), %rax
orq 0x28(%rsi), %rax
je 0x2a2bb
movq %rdi, %rbx
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x3e0(%rbx), %rsi
cmpq $0x0, 0x28(%r15)
je 0x2a2c1
movq %r15, %rdi
callq 0x1b9c2
addq $0x8, %r15
cmpq %r15, %rax
jne 0x2a2bb
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1b9c2
addq $0x8, %r14
cmpq %r14, %rax
jne 0x2a2b7
jmp 0x2a2bb
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_number_of_alleles(int, int)
void entry::filter_sites_by_number_of_alleles(int min_alleles, int max_alleles)
{
	// Filter sites by the number of alleles (e.g. 2 for bi-allelic)
	if (passed_filters == false)
		return;

	if ((min_alleles <= 0) && (max_alleles == numeric_limits<int>::max()))
		return;

	int N_alleles;
	parse_basic_entry(true);
	N_alleles = get_N_alleles();
	if ((N_alleles < min_alleles) || (N_alleles > max_alleles))
		passed_filters = false;
}

// Assembly:
cmpb $0x0, 0xc(%rdi)
je 0x2ae5c
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
testl %esi, %esi
setle %al
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %cl
testb %cl, %al
jne 0x2ae58
movq %rdi, %rbx
movq (%rdi), %rax
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movq %rbx, %rdi
callq 0x230f4
cmpl %r14d, %eax
setge %cl
cmpl %ebp, %eax
setle %al
testb %al, %cl
jne 0x2ae58
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_quality(double)
void entry::filter_sites_by_quality(double min_quality)
{
	// Filter sites by quality
	if (passed_filters == false)
		return;

	if (min_quality < 0)
		return;

	parse_basic_entry(true);

	string alt_allele = get_ALT_allele(0);
	// The QUAL field has different definitions depending on the state of the
	// alternative allele. Here I treat them separately, although in this case
	// it is unnecessary.
	if ((alt_allele == ".") || (alt_allele == ""))
	{	// The case that the alternative allele is unknown
		// QUAL is -10log_10 p(variant)
			if (QUAL < min_quality)
				passed_filters = false;
	}
	else
	{	// The normal case
		// QUAL is -10log_10 p(no variant)
		if (QUAL < min_quality)
			passed_filters = false;
	}
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x2b310
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2b309
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x22218
leaq 0xef49(%rip), %rsi      # 0x3a20d
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x2b2e3
leaq 0xfc28(%rip), %rsi      # 0x3aeff
leaq 0x8(%rsp), %rdi
callq 0x50e0
testl %eax, %eax
movsd (%rsp), %xmm0
ucomisd 0x460(%rbx), %xmm0
jbe 0x2b2f6
movb $0x0, 0xc(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b309
callq 0x5410
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_mean_depth(double, double)
void entry::filter_sites_by_mean_depth(double min_mean_depth, double max_mean_depth)
{
	// Filter sites by mean depth
	if (passed_filters == false)
		return;

	if ((min_mean_depth <= 0) && (max_mean_depth == numeric_limits<double>::max()))
		return;

	int depth;

	unsigned int N_indv_included = 0;
	double depth_sum = 0.0;
	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if (include_indv[ui] == false)
			continue;

		if (include_genotype[ui] == true)
		{
			parse_genotype_entry(ui, false, false, true);

			if (entry_header.has_genotypes == false)
				LOG.error("Require Genotypes in VCF file in order to filter sites by mean depth");

			depth = get_indv_DEPTH(ui);
			if (depth >= 0)
			{
				depth_sum += depth;
			}
			N_indv_included++;
		}
	}
	double mean_depth = depth_sum / N_indv_included;

	if ((mean_depth < min_mean_depth) || (mean_depth > max_mean_depth))
		passed_filters = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
cmpb $0x0, 0xc(%rdi)
je 0x2b47f
movq %rdi, %rbx
xorpd %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
jb 0x2b359
movsd (%rsp), %xmm0
ucomisd 0xdcef(%rip), %xmm0     # 0x39040
jne 0x2b359
jnp 0x2b47f
cmpl $0x0, 0x8(%rbx)
je 0x2b460
xorpd %xmm1, %xmm1
xorl %r14d, %r14d
leaq 0x28(%rsp), %r15
leaq 0x18(%rsp), %r13
leaq 0x1f12d(%rip), %rbp     # 0x4a4a8
xorl %r12d, %r12d
movq 0x1f0(%rbx), %rdx
movl $0x1, %eax
movl %r14d, %ecx
shlq %cl, %rax
movq %r14, %rcx
shrq $0x6, %rcx
movq (%rdx,%rcx,8), %rdx
btq %r14, %rdx
jae 0x2b440
movq 0x218(%rbx), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x2b440
movsd %xmm1, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq *0x20(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x2b415
movq %r15, 0x18(%rsp)
movq %r13, %rdi
leaq 0xfa5e(%rip), %rsi      # 0x3ae48
leaq 0xfa9b(%rip), %rdx      # 0x3ae8c
callq 0xc868
movq %rbp, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x3721e
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b415
callq 0x5410
movq %rbx, %rdi
movl %r14d, %esi
callq 0x22e20
testl %eax, %eax
js 0x2b437
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
jmp 0x2b43d
movsd 0x10(%rsp), %xmm1
incl %r12d
incq %r14
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x2b37e
movl %r12d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
jmp 0x2b468
movsd 0xf8a8(%rip), %xmm1     # 0x3ad10
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x2b47b
ucomisd (%rsp), %xmm1
jbe 0x2b47f
movb $0x0, 0xc(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b4a0
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_sites_by_phase()
void entry::filter_sites_by_phase()
{
	// Filter out sites with unphased entries
	// TODO: Alter this to allow for a max/min level of unphased-ness.
	if (passed_filters == false)
		return;

	unsigned int count_unphased = 0;
	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if (include_indv[ui] == false)
			continue;

		parse_genotype_entry(ui, true);

		if (get_indv_PHASE(ui) != '|')
			count_unphased++;
	}

	if (count_unphased > 0)
		passed_filters = false;
}

// Assembly:
cmpb $0x0, 0xc(%rdi)
je 0x2b8ea
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x2b8e6
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x1f0(%rbx), %rax
movq %r14, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r14, %rax
jae 0x2b8d3
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x20(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x22ddc
xorl %ecx, %ecx
cmpb $0x7c, %al
setne %cl
addl %ecx, %ebp
incq %r14
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x2b88e
testl %ebp, %ebp
je 0x2b8e6
movb $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_genotypes_by_quality_value(double)
void entry::filter_genotypes_by_quality_value(double min_genotype_quality)
{
	// Filter genotypes by quality
	if (passed_filters == false)
		return;

	if (min_genotype_quality <= 0)
		return;

	parse_genotype_entries(false, true);

	if (entry_header.has_genotypes == false)
		LOG.error("Require Genotypes in variant file in order to filter genotypes by Quality.");

	filter_genotypes_by_quality(min_genotype_quality);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x2b983
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
je 0x2b983
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x28(%rax)
cmpb $0x0, 0x15(%rbx)
jne 0x2b974
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf3e3(%rip), %rsi      # 0x3ad20
leaq 0xf426(%rip), %rdx      # 0x3ad6a
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xc868
leaq 0x1eb50(%rip), %rdi     # 0x4a4a8
movq %r14, %rsi
movl $0x1, %edx
callq 0x3721e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b974
callq 0x5410
movq (%rbx), %rax
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq *0x58(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b99f
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_filters.cpp
// Function: entry::filter_genotypes_by_depth_range(int, int)
void entry::filter_genotypes_by_depth_range(int min_depth, int max_depth)
{
	// Filter genotypes by depth
	if (passed_filters == false)
		return;

	if ((min_depth <= 0) && (max_depth == numeric_limits<int>::max()))
		return;
	if (entry_header.has_genotypes == false)
		LOG.error("Require Genotypes in variant file in order to filter genotypes by Depth.");

	parse_genotype_entries(false, false, true);
	filter_genotypes_by_depth(min_depth, max_depth);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0xc(%rdi)
je 0x2ba44
movl %edx, %ebx
movl %esi, %ebp
testl %esi, %esi
setle %al
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
sete %cl
testb %cl, %al
jne 0x2ba44
movq %rdi, %r14
cmpb $0x0, 0x15(%rdi)
jne 0x2ba22
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xf37d(%rip), %rsi      # 0x3ad6b
leaq 0xf3be(%rip), %rdx      # 0x3adb3
movq %rsp, %r15
movq %r15, %rdi
callq 0xc868
leaq 0x1eaa1(%rip), %rdi     # 0x4a4a8
movq %r15, %rsi
movl $0x1, %edx
callq 0x3721e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2ba22
callq 0x5410
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq *0x50(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2ba62
callq 0x5410
movq %rbx, %rdi
callq 0x57d0