LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_N_chr() const
unsigned int entry::get_N_chr() const
{
	unsigned int out=0;

	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if (include_indv[ui] == true)
		{
			assert(parsed_GT[ui] == true);
			out += ploidy[ui];
		}
	}
	return out;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x4c3b6
movq (%rsp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
movl 0x8(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4c3a4
movq (%rsp), %rdi
addq $0x560, %rdi            # imm = 0x560
movl 0x8(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4c365
jmp 0x4c384
leaq 0x28fb4(%rip), %rdi     # 0x75320
leaq 0x28f3d(%rip), %rsi     # 0x752b0
movl $0x17b, %edx            # imm = 0x17B
leaq 0x294fc(%rip), %rcx     # 0x7587b
callq 0x6300
movq (%rsp), %rdi
addq $0x4e8, %rdi            # imm = 0x4E8
movl 0x8(%rsp), %eax
movl %eax, %esi
callq 0xf130
movl (%rax), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x4c3a6
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c312
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_rlen(std::vector<char, std::allocator<char>>&) const
void entry::get_rlen(vector<char> &out) const
{
	out.resize(sizeof(int32_t));
	int32_t rlen;
	if (REF != "" and REF != "." and REF != " ")
		rlen = (int32_t)REF.length();
	else
		rlen = (int32_t)0;
	memcpy(&out[0], &rlen, sizeof(rlen));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0x20910
movq 0x8(%rsp), %rdi
addq $0x428, %rdi            # imm = 0x428
leaq 0x290ef(%rip), %rsi     # 0x75d29
callq 0x30930
testb $0x1, %al
jne 0x4cc45
jmp 0x4cc98
movq 0x8(%rsp), %rdi
addq $0x428, %rdi            # imm = 0x428
leaq 0x28486(%rip), %rsi     # 0x750de
callq 0x30930
testb $0x1, %al
jne 0x4cc63
jmp 0x4cc98
movq 0x8(%rsp), %rdi
addq $0x428, %rdi            # imm = 0x428
leaq 0x2742e(%rip), %rsi     # 0x740a4
callq 0x30930
testb $0x1, %al
jne 0x4cc81
jmp 0x4cc98
movq 0x8(%rsp), %rdi
addq $0x428, %rdi            # imm = 0x428
callq 0x6850
movl %eax, 0x14(%rsp)
jmp 0x4cca0
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x209b0
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_n_allele_info(std::vector<char, std::allocator<char>>&) const
void entry::get_n_allele_info(vector<char> &out) const
{
	out.resize(sizeof(uint32_t));
	uint32_t n_allele_info = (uint32_t)ALT.size() + 1;
	uint32_t n_info = (uint32_t)(INFO.size()-N_INFO_removed);

	n_allele_info = n_allele_info << 16;
	n_allele_info = n_allele_info | n_info;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0x20910
movq 0x8(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
movq 0x8(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x14(%rsp)
addq $0x480, %rdi            # imm = 0x480
callq 0x39a20
movq 0x8(%rsp), %rcx
movslq 0x4c8(%rcx), %rcx
subq %rcx, %rax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
shll $0x10, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
orl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x209b0
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0x20910
movq 0x8(%rsp), %rdi
addq $0x498, %rdi            # imm = 0x498
callq 0x10270
movq %rax, %rcx
movq 0x8(%rsp), %rax
movslq 0x4cc(%rax), %rdx
subq %rdx, %rcx
movl %ecx, 0x14(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
shll $0x18, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
orl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x209b0
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x2a300
movq 0xc8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20910
jmp 0x4ced4
movq 0x40(%rsp), %rdi
movq %rdi, %rdx
addq $0x428, %rdx            # imm = 0x428
leaq 0xb0(%rsp), %rsi
movl $0x1, %ecx
callq 0x45960
jmp 0x4cef7
movq 0xc8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x27020
movq %rax, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x39b20
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x26ff0
movq 0x28(%rsp), %rdi
movq %rax, 0x88(%rsp)
callq 0x27020
movq 0x30(%rsp), %rdi
movq %rax, 0x80(%rsp)
movq 0x98(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rcx
callq 0x39a60
movq %rax, 0x38(%rsp)
jmp 0x4cf7b
movq 0x38(%rsp), %rax
movq %rax, 0x78(%rsp)
movl $0x0, 0x74(%rsp)
movq 0x40(%rsp), %rdi
movl 0x74(%rsp), %eax
movq %rax, 0x20(%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x4d0a7
xorl %eax, %eax
movl %eax, %esi
leaq 0xb0(%rsp), %rdi
callq 0x20910
jmp 0x4cfcb
movq 0x40(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
movl 0x74(%rsp), %eax
movl %eax, %esi
callq 0x10290
movq 0x40(%rsp), %rdi
movq %rax, %rdx
leaq 0xb0(%rsp), %rsi
movl $0x1, %ecx
callq 0x45960
jmp 0x4cffe
movq 0xc8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x27020
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x39b20
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x26ff0
movq 0x8(%rsp), %rdi
movq %rax, 0x58(%rsp)
callq 0x27020
movq 0x10(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x39a60
movq %rax, 0x18(%rsp)
jmp 0x4d06a
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x4cf8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x267c0
jmp 0x4d0bc
leaq 0xb0(%rsp), %rdi
callq 0x267c0
addq $0xd8, %rsp
retq
movq 0xa8(%rsp), %rdi
callq 0x69e0
nopl (%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0x2595b(%rip), %rsi     # 0x750de
callq 0x30930
testb $0x1, %al
jne 0x4f791
jmp 0x4f96d
movq 0x10(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
callq 0x211d0
movq 0x10(%rsp), %rdi
movq %rax, 0xb8(%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x21200
movq %rax, 0xb0(%rsp)
movq 0xc8(%rsp), %rdx
movq 0xb8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x4fac0
movq 0x10(%rsp), %rdi
movq %rax, 0xc0(%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x21200
movq %rax, 0xa8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x4fa80
testb $0x1, %al
jne 0x4f81c
jmp 0x4f83a
movq 0x10(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
movq 0xc8(%rsp), %rsi
callq 0x2a190
jmp 0x4f96b
movq 0x10(%rsp), %rdx
addq $0x3e0, %rdx            # imm = 0x3E0
leaq 0x26237(%rip), %rsi     # 0x75a84
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe8d0
movq 0x8(%rsp), %rsi
leaq 0x26677(%rip), %rdx     # 0x75edf
leaq 0x68(%rsp), %rdi
callq 0xf4a0
jmp 0x4f874
movq 0x10(%rsp), %rax
movl 0x400(%rax), %esi
leaq 0x18(%rsp), %rdi
callq 0x71730
jmp 0x4f88b
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xffb0
jmp 0x4f8a4
leaq 0x43d55(%rip), %rdi     # 0x93600
leaq 0x88(%rsp), %rsi
callq 0x715a0
jmp 0x4f8ba
leaq 0x88(%rsp), %rdi
callq 0x6b50
leaq 0x18(%rsp), %rdi
callq 0x6b50
leaq 0x68(%rsp), %rdi
callq 0x6b50
leaq 0x48(%rsp), %rdi
callq 0x6b50
movq 0x10(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
movq 0xc8(%rsp), %rsi
callq 0x2a190
jmp 0x4f96b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4f95f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4f955
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4f94b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x6b50
leaq 0x18(%rsp), %rdi
callq 0x6b50
leaq 0x68(%rsp), %rdi
callq 0x6b50
leaq 0x48(%rsp), %rdi
callq 0x6b50
jmp 0x4f981
jmp 0x4f96d
movq 0x10(%rsp), %rax
movb $0x1, 0x3da(%rax)
addq $0xd8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x69e0
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x5b0, %rdi            # imm = 0x5B0
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
cmpl $-0x1, 0x28(%rsp)
jne 0x4fa11
movq 0x8(%rsp), %rdi
addq $0x530, %rdi            # imm = 0x530
callq 0x4d3d0
testb $0x1, %al
jne 0x4fa0f
movq 0x8(%rsp), %rdi
addq $0x530, %rdi            # imm = 0x530
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xecf0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x4fa73
movq 0x8(%rsp), %rdi
addq $0x530, %rdi            # imm = 0x530
callq 0x4d3d0
testb $0x1, %al
jne 0x4fa28
jmp 0x4fa4e
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x530, %rdi            # imm = 0x530
movl 0x8(%rax), %eax
movl %eax, %esi
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %rdx
callq 0xf540
movq 0x8(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x530, %rdi            # imm = 0x530
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xecf0
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x1c8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x8, %edx
callq 0x6930
leaq 0x28(%rsp), %rdi
callq 0x67e0
movq 0x10(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
xorl %eax, %eax
movl %eax, %esi
callq 0x2a0f0
jmp 0x4fe9c
jmp 0x4fe9e
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x48(%rsp,%rax), %rdi
callq 0x6a70
movb %al, 0xf(%rsp)
jmp 0x4feb7
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4fec3
jmp 0x4ff10
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x2c, %edx
callq 0x6a80
jmp 0x4fed9
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4f750
jmp 0x4feea
jmp 0x4fe9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6b50
leaq 0x48(%rsp), %rdi
callq 0x6b48
jmp 0x4ff38
movq 0x10(%rsp), %rax
movb $0x1, 0x3da(%rax)
leaq 0x28(%rsp), %rdi
callq 0x6b50
leaq 0x48(%rsp), %rdi
callq 0x6b48
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x20(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movb %al, 0x2b(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x500, %rdi            # imm = 0x500
callq 0x249e0
cmpq $0x0, %rax
jne 0x50f52
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x500, %rdi            # imm = 0x500
movl 0x8(%rax), %eax
movl %eax, %esi
movb $0x2f, 0x2a(%rsp)
leaq 0x2a(%rsp), %rdx
callq 0x51eb0
movq 0x10(%rsp), %rdi
movb 0x2b(%rsp), %al
movb %al, 0xf(%rsp)
addq $0x500, %rdi            # imm = 0x500
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x209b0
movb 0xf(%rsp), %cl
movq 0x10(%rsp), %rdi
movb %cl, (%rax)
addq $0x560, %rdi            # imm = 0x560
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movb %cl, 0x4b(%rsp)
movb %al, 0x4a(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x4d0, %rdi            # imm = 0x4D0
callq 0x2a200
cmpq $0x0, %rax
jne 0x51037
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4d0, %rcx            # imm = 0x4D0
movq %rcx, (%rsp)
movl 0x8(%rax), %eax
movq %rax, 0x8(%rsp)
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
leaq 0x3c(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x397b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdx
callq 0x51df0
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x28(%rsp) # imm = 0xFFFFFFFF
leaq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x3a680
movsbl 0x4b(%rsp), %eax
cmpl $0x2e, %eax
je 0x51071
movsbl 0x4b(%rsp), %eax
subl $0x30, %eax
movl %eax, 0x30(%rsp)
movsbl 0x4a(%rsp), %eax
cmpl $0x2e, %eax
je 0x51087
movsbl 0x4a(%rsp), %eax
subl $0x30, %eax
movl %eax, 0x34(%rsp)
movq 0x10(%rsp), %rdi
addq $0x4d0, %rdi            # imm = 0x4D0
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x2a220
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x4d3a0
movq 0x10(%rsp), %rdi
addq $0x560, %rdi            # imm = 0x560
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
addq $0x58, %rsp
retq
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x4d0, %rdi            # imm = 0x4D0
callq 0x2a200
cmpq $0x0, %rax
jne 0x51162
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4d0, %rcx            # imm = 0x4D0
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %eax
movq %rax, 0x10(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x40(%rsp) # imm = 0xFFFFFFFF
leaq 0x44(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x397b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rdx
callq 0x51df0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x30(%rsp) # imm = 0xFFFFFFFF
leaq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3a680
movq 0x50(%rsp), %rdi
leaq 0x23f4c(%rip), %rsi     # 0x750de
callq 0x30930
testb $0x1, %al
jne 0x5119d
jmp 0x511b0
movq 0x50(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2fb70
movl %eax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
addq $0x20, %rdi
leaq 0x23f1e(%rip), %rsi     # 0x750de
callq 0x30930
testb $0x1, %al
jne 0x511cb
jmp 0x511e2
movq 0x50(%rsp), %rdi
addq $0x20, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2fb70
movl %eax, 0x3c(%rsp)
movq 0x18(%rsp), %rdi
addq $0x4d0, %rdi            # imm = 0x4D0
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x2a220
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x4d3a0
movq 0x18(%rsp), %rdi
addq $0x560, %rdi            # imm = 0x560
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rdi
addq $0x4e8, %rdi            # imm = 0x4E8
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10140
movq (%rsp), %rdi
addq $0x4e8, %rdi            # imm = 0x4E8
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xecf0
movq (%rsp), %rdi
movl $0x2, (%rax)
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x512f0
movq (%rsp), %rdi
movl 0x2c(%rsp), %esi
movsbl 0x1f(%rsp), %edx
callq 0x50f00
movq (%rsp), %rdi
addq $0x560, %rdi            # imm = 0x560
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x588, %rdi            # imm = 0x588
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
movsd 0x30(%rsp), %xmm0
movsd 0x23a8a(%rip), %xmm1    # 0x74f40
ucomisd %xmm1, %xmm0
jne 0x514fd
jp 0x514fd
movq 0x10(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
callq 0xe890
cmpq $0x0, %rax
jbe 0x514f8
movq 0x10(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe870
movsd 0x23a4c(%rip), %xmm0    # 0x74f40
movsd %xmm0, (%rax)
jmp 0x5158f
movq 0x10(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
callq 0xe890
cmpq $0x0, %rax
jne 0x51540
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x518, %rdi            # imm = 0x518
movl 0x8(%rax), %eax
movl %eax, %esi
movsd 0x23a10(%rip), %xmm0    # 0x74f40
movsd %xmm0, 0x18(%rsp)
leaq 0x18(%rsp), %rdx
callq 0xf600
movsd 0x30(%rsp), %xmm0
movsd 0x24562(%rip), %xmm1    # 0x75ab0
ucomisd %xmm1, %xmm0
jbe 0x51562
movsd 0x24554(%rip), %xmm0    # 0x75ab0
movsd %xmm0, 0x30(%rsp)
movq 0x10(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x518, %rdi            # imm = 0x518
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe870
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x468, %rdi            # imm = 0x468
xorl %eax, %eax
movl %eax, %esi
callq 0x2a0f0
movq 0x1d8(%rsp), %rdi
leaq 0x238ab(%rip), %rsi     # 0x750de
callq 0x30930
testb $0x1, %al
jne 0x51841
jmp 0x518ef
movq 0x1d8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movl $0x8, %edx
callq 0x6930
leaq 0x38(%rsp), %rdi
callq 0x67e0
movq 0x58(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x58(%rsp,%rax), %rdi
callq 0x6a70
movb %al, 0xf(%rsp)
jmp 0x5187b
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x51887
jmp 0x518db
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl $0x3b, %edx
callq 0x6a80
jmp 0x5189d
movq 0x10(%rsp), %rdi
addq $0x468, %rdi            # imm = 0x468
leaq 0x38(%rsp), %rsi
callq 0x2a190
jmp 0x518b5
jmp 0x51862
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x58(%rsp), %rdi
callq 0x6b48
jmp 0x5193e
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x58(%rsp), %rdi
callq 0x6b48
movq 0x10(%rsp), %rdi
addq $0x468, %rdi            # imm = 0x468
callq 0x211d0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x468, %rdi            # imm = 0x468
callq 0x21200
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x52030
movq 0x10(%rsp), %rax
movb $0x1, 0x3db(%rax)
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x30(%rsp), %rdi
callq 0x69e0
nopl (%rax,%rax)
// File: auton1[P]viterbi/vcf_entry_setters.cpp
// Function: vcf_entry::set_INFO(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vcf_entry::set_INFO(const string &INFO_str)
{
	INFO.resize(0);
	if ((INFO_str.size() > 0) && (INFO_str != "."))
	{
		istringstream ss(INFO_str);
		string tmpstr;
		while(!ss.eof())
		{
			getline(ss, tmpstr, ';');

			istringstream ss2(tmpstr);
			getline(ss2, tmpstr, '=');
			pair<string, string> INFO_entry(tmpstr, ".");

			if (!ss2.eof())
			{	// If there is a value entry, read it now
				getline(ss2, tmpstr);
				INFO_entry.second = tmpstr;
			}
			else	// Otherwise, set it equal to 1
				INFO_entry.second = "1";

			INFO.push_back(INFO_entry);
		}
	}
	parsed_INFO = true;
}

// Assembly:
subq $0x398, %rsp            # imm = 0x398
movq %rdi, 0x390(%rsp)
movq %rsi, 0x388(%rsp)
movq 0x390(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x480, %rdi            # imm = 0x480
xorl %eax, %eax
movl %eax, %esi
callq 0x52070
movq 0x388(%rsp), %rdi
callq 0x6350
cmpq $0x0, %rax
jbe 0x51b9c
movq 0x388(%rsp), %rdi
leaq 0x23734(%rip), %rsi     # 0x750de
callq 0x30930
testb $0x1, %al
jne 0x519b8
jmp 0x51b9c
movq 0x388(%rsp), %rsi
leaq 0x208(%rsp), %rdi
movl $0x8, %edx
callq 0x6930
leaq 0x1e8(%rsp), %rdi
callq 0x67e0
movq 0x208(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x208(%rsp,%rax), %rdi
callq 0x6a70
movb %al, 0xf(%rsp)
jmp 0x519fe
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x51a0d
jmp 0x51b64
leaq 0x208(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
movl $0x3b, %edx
callq 0x6a80
jmp 0x51a29
leaq 0x58(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
movl $0x8, %edx
callq 0x6930
jmp 0x51a42
leaq 0x58(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
movl $0x3d, %edx
callq 0x6a80
jmp 0x51a5b
leaq 0x2367c(%rip), %rdx     # 0x750de
leaq 0x18(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x52110
jmp 0x51a76
movq 0x58(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x58(%rsp,%rax), %rdi
callq 0x6a70
movb %al, 0xe(%rsp)
jmp 0x51a8f
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x51b12
jmp 0x51a99
leaq 0x58(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x60c0
jmp 0x51aad
leaq 0x38(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x6060
jmp 0x51ac1
jmp 0x51b27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
jmp 0x51b80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
jmp 0x51b58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3a810
jmp 0x51b58
leaq 0x38(%rsp), %rdi
leaq 0x22535(%rip), %rsi     # 0x74053
callq 0x67b0
jmp 0x51b25
jmp 0x51b27
movq 0x10(%rsp), %rdi
addq $0x480, %rdi            # imm = 0x480
leaq 0x18(%rsp), %rsi
callq 0x4d260
jmp 0x51b3f
leaq 0x18(%rsp), %rdi
callq 0x3a810
leaq 0x58(%rsp), %rdi
callq 0x6b48
jmp 0x519df
leaq 0x58(%rsp), %rdi
callq 0x6b48
jmp 0x51b80
leaq 0x1e8(%rsp), %rdi
callq 0x6b50
leaq 0x208(%rsp), %rdi
callq 0x6b48
jmp 0x51b9c
leaq 0x1e8(%rsp), %rdi
callq 0x6b50
leaq 0x208(%rsp), %rdi
callq 0x6b48
jmp 0x51bb0
movq 0x10(%rsp), %rax
movb $0x1, 0x3dc(%rax)
addq $0x398, %rsp            # imm = 0x398
retq
movq 0x1e0(%rsp), %rdi
callq 0x69e0
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movl %esi, 0x9c(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x448, %rdi            # imm = 0x448
movl 0x9c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2a0f0
movq 0x18(%rsp), %rax
movl 0x6f0(%rax), %eax
movl %eax, 0x98(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x67e0
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
movl 0x9c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x56654
movq 0x18(%rsp), %rsi
movq %rsi, %rcx
addq $0x3c0, %rcx            # imm = 0x3C0
leaq 0x50(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x486b0
jmp 0x56589
leaq 0x78(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x50(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x66c0
movq (%rsp), %rdi
callq 0x6b50
movq 0x8(%rsp), %rdi
callq 0x6470
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x6270
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x6470
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x3c9eb(%rip), %rcx     # 0x92fd8
callq 0x39680
movq %rax, 0x10(%rsp)
jmp 0x565f9
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x448, %rdi            # imm = 0x448
movslq 0x74(%rsp), %rsi
callq 0x10290
movq %rax, %rdi
leaq 0x78(%rsp), %rsi
callq 0x6060
jmp 0x56628
jmp 0x5662a
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x56550
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x6b50
jmp 0x56672
movq 0x18(%rsp), %rax
movb $0x1, 0x3da(%rax)
leaq 0x78(%rsp), %rdi
callq 0x6b50
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x69e0
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x4d0, %rdi            # imm = 0x4D0
callq 0x2a200
cmpq $0x0, %rax
jne 0x58252
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4d0, %rcx            # imm = 0x4D0
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %eax
movq %rax, 0x10(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x40(%rsp) # imm = 0xFFFFFFFF
leaq 0x44(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x397b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rdx
callq 0x51df0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x30(%rsp) # imm = 0xFFFFFFFF
leaq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3a680
movq 0x50(%rsp), %rax
cmpl $0x81, (%rax)
jne 0x5828d
movl $0xfffffffe, 0x38(%rsp) # imm = 0xFFFFFFFE
jmp 0x582a7
movq 0x50(%rsp), %rax
cmpl $0x80, (%rax)
je 0x582a5
movq 0x50(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x38(%rsp)
jmp 0x582a7
movq 0x50(%rsp), %rax
cmpl $0x81, 0x4(%rax)
jne 0x582bf
movl $0xfffffffe, 0x3c(%rsp) # imm = 0xFFFFFFFE
jmp 0x582db
movq 0x50(%rsp), %rax
cmpl $0x80, 0x4(%rax)
je 0x582d9
movq 0x50(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x3c(%rsp)
jmp 0x582db
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
addq $0x4d0, %rdi            # imm = 0x4D0
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x2a220
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x4d3a0
movq 0x18(%rsp), %rdi
addq $0x560, %rdi            # imm = 0x560
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
callq 0x3a680
movq 0x30(%rsp), %rdi
leaq 0x1cb5d(%rip), %rsi     # 0x750de
callq 0x30930
testb $0x1, %al
jne 0x5858c
jmp 0x5859f
movq 0x30(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2fb70
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
leaq 0x1cb2f(%rip), %rsi     # 0x750de
callq 0x30930
testb $0x1, %al
jne 0x585ba
jmp 0x585d1
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2fb70
movl %eax, 0x28(%rsp)
movq (%rsp), %rdi
movl 0x3c(%rsp), %esi
leaq 0x24(%rsp), %rdx
callq 0x581d0
movq (%rsp), %rdi
movl 0x3c(%rsp), %esi
movsbl 0x2f(%rsp), %edx
callq 0x58340
movq (%rsp), %rdi
addq $0x560, %rdi            # imm = 0x560
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49920
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
addq $0x588, %rdi            # imm = 0x588
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
movss 0x2c(%rsp), %xmm0
movss 0x1cb02(%rip), %xmm1    # 0x751a0
ucomiss %xmm1, %xmm0
jne 0x586e4
jp 0x586e4
movq 0x8(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
callq 0xe890
cmpq $0x0, %rax
jbe 0x586df
movq 0x8(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe870
movsd 0x1c865(%rip), %xmm0    # 0x74f40
movsd %xmm0, (%rax)
jmp 0x5877c
movq 0x8(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
callq 0xe890
cmpq $0x0, %rax
jne 0x58727
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x518, %rdi            # imm = 0x518
movl 0x8(%rax), %eax
movl %eax, %esi
movsd 0x1c829(%rip), %xmm0    # 0x74f40
movsd %xmm0, 0x10(%rsp)
leaq 0x10(%rsp), %rdx
callq 0xf600
movss 0x2c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1d377(%rip), %xmm1    # 0x75ab0
ucomisd %xmm1, %xmm0
jbe 0x5874d
movss 0x1d3ad(%rip), %xmm0    # 0x75af4
movss %xmm0, 0x2c(%rsp)
movq 0x8(%rsp), %rdi
movss 0x2c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
addq $0x518, %rdi            # imm = 0x518
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe870
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x588, %rdi            # imm = 0x588
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x1bd30
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
movss 0x1d310(%rip), %xmm1    # 0x75af8
ucomiss %xmm1, %xmm0
jne 0x587f1
jp 0x587f1
jmp 0x58809
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
movss 0x1c99e(%rip), %xmm1    # 0x751a0
ucomiss %xmm1, %xmm0
jne 0x58848
jp 0x58848
movq 0x10(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
callq 0xe890
cmpq $0x0, %rax
jbe 0x58843
movq 0x10(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe870
movsd 0x1c701(%rip), %xmm0    # 0x74f40
movsd %xmm0, (%rax)
jmp 0x588fa
movq 0x10(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
callq 0xe890
cmpq $0x0, %rax
jne 0x5888b
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x518, %rdi            # imm = 0x518
movl 0x8(%rax), %eax
movl %eax, %esi
movsd 0x1c6c5(%rip), %xmm0    # 0x74f40
movsd %xmm0, 0x18(%rsp)
leaq 0x18(%rsp), %rdx
callq 0xf600
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
movss 0x1d258(%rip), %xmm1    # 0x75af4
ucomiss %xmm1, %xmm0
jbe 0x588c6
movq 0x10(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe870
movsd 0x1d1f0(%rip), %xmm0    # 0x75ab0
movsd %xmm0, (%rax)
jmp 0x588fa
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x518, %rdi            # imm = 0x518
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe870
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x17(%rsp)
je 0x59c67
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x5e6b0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5e9d0
jmp 0x59c8a
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5e9d0
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x5e6b0
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5a032
jmp 0x5a0ca
movq 0x18(%rsp), %rdi
leaq 0x1bceb(%rip), %rsi     # 0x75d29
callq 0xea20
testb $0x1, %al
jne 0x5a065
cmpl $-0x1, 0x14(%rsp)
jne 0x5a067
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x10bd0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jne 0x5a067
jmp 0x5a0ca
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
movq 0x18(%rsp), %rsi
callq 0x2a430
testb $0x1, %al
jne 0x5a094
jmp 0x5a0c1
movq 0x8(%rsp), %rax
movl 0x400(%rax), %eax
cmpl 0x14(%rsp), %eax
jl 0x5a0b6
movq 0x8(%rsp), %rax
movl 0x400(%rax), %eax
cmpl 0x10(%rsp), %eax
jle 0x5a0bf
movq 0x8(%rsp), %rax
movb $0x0, 0xc(%rax)
jmp 0x5a0ca
movq 0x8(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5bb4f
jmp 0x5bc27
movq 0x38(%rsp), %rdi
callq 0x4d120
testb $0x1, %al
jne 0x5bb5f
jmp 0x5bb74
movq 0x30(%rsp), %rdi
callq 0x4d120
testb $0x1, %al
jne 0x5bb6f
jmp 0x5bb74
jmp 0x5bc27
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq *0x10(%rax)
movq 0x38(%rsp), %rdi
callq 0x4d120
testb $0x1, %al
jne 0x5bbdd
movq 0x8(%rsp), %rsi
movq 0x38(%rsp), %rdi
addq $0x3e0, %rsi            # imm = 0x3E0
callq 0x39780
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x10ba0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x10b40
testb $0x1, %al
jne 0x5bbd2
jmp 0x5bbdb
movq 0x8(%rsp), %rax
movb $0x0, 0xc(%rax)
jmp 0x5bc27
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rdi
addq $0x3e0, %rsi            # imm = 0x3E0
callq 0x39780
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x10ba0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x39760
testb $0x1, %al
jne 0x5bc1c
jmp 0x5bc25
movq 0x8(%rsp), %rax
movb $0x0, 0xc(%rax)
jmp 0x5bc27
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5ca6a
jmp 0x5cac9
cmpl $0x0, 0x1c(%rsp)
jg 0x5ca8a
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x10bd0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jne 0x5ca8a
jmp 0x5cac9
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
callq 0x4c290
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jl 0x5cac0
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jle 0x5cac9
movq 0x8(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5d06b
jmp 0x5d15e
xorps %xmm0, %xmm0
ucomisd 0x58(%rsp), %xmm0
jbe 0x5d07b
jmp 0x5d15e
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, 0xc(%rsp)
movl %ecx, %edx
callq *%rax
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4abb0
movq 0x10(%rsp), %rdi
leaq 0x18024(%rip), %rsi     # 0x750de
callq 0xea20
movb %al, 0x1f(%rsp)
jmp 0x5d0c5
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x5d0f0
jmp 0x5d0cf
leaq 0x18c53(%rip), %rsi     # 0x75d29
leaq 0x38(%rsp), %rdi
callq 0xea20
movb %al, 0xb(%rsp)
jmp 0x5d0e6
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x5d0f0
jmp 0x5d130
movq 0x20(%rsp), %rax
movsd 0x460(%rax), %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5d12e
movq 0x20(%rsp), %rax
movb $0x0, 0xc(%rax)
jmp 0x5d12e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6b50
jmp 0x5d163
jmp 0x5d154
movq 0x20(%rsp), %rax
movsd 0x460(%rax), %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5d152
movq 0x20(%rsp), %rax
movb $0x0, 0xc(%rax)
jmp 0x5d154
leaq 0x38(%rsp), %rdi
callq 0x6b50
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x69e0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movb 0xc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5d8e4
jmp 0x5d998
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq (%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x5d989
movq (%rsp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x10310
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5d93b
jmp 0x5d979
movq (%rsp), %rdi
movl 0x18(%rsp), %esi
movq (%rdi), %rax
movl $0x1, %edx
xorl %r9d, %r9d
movl %r9d, %ecx
movl %r9d, %r8d
callq *0x20(%rax)
movq (%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x4bda0
movsbl %al, %eax
cmpl $0x7c, %eax
je 0x5d977
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5d979
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5d8f4
cmpl $0x0, 0x1c(%rsp)
jbe 0x5d998
movq (%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x28, %rsp
retq
nopl (%rax)