LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: auton1[P]viterbi/bcf_entry.cpp
// Function: bcf_entry::filter_genotypes_by_depth(int, int)
void bcf_entry::filter_genotypes_by_depth(int min_depth, int max_depth)
{
	if (fully_parsed == false)
		parse_full_entry();

	if (DP_idx != -1)
	{	// Have depth info
		int depth;
		for (unsigned int ui=0; ui<N_indv; ui++)
		{
			if (parsed_DP[ui] == false)
				parse_genotype_entry(ui, false, false, true);
			depth = get_indv_DEPTH(ui);
			if ((depth < min_depth) || (depth > max_depth))
				include_genotype[ui] = false;
		}
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x3d9(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3501b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x18(%rax)
movq 0x8(%rsp), %rax
cmpl $-0x1, 0x638(%rax)
je 0x35101
movl $0x0, 0x30(%rsp)
movq 0x8(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x350ff
movq 0x8(%rsp), %rdi
addq $0x5b0, %rdi            # imm = 0x5B0
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x10310
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3509a
movq 0x8(%rsp), %rdi
movl 0x30(%rsp), %esi
movq (%rdi), %rax
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %edx
movl %r9d, %ecx
callq *0x20(%rax)
movq 0x8(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x4be10
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jl 0x350c0
movl 0x34(%rsp), %eax
cmpl 0x38(%rsp), %eax
jle 0x350ed
movq 0x8(%rsp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x1bd30
jmp 0x350ef
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x35035
jmp 0x35101
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/vcf_entry.cpp
// Function: vcf_entry::parse_full_entry(bool)
void vcf_entry::parse_full_entry(bool parse_FORMAT)
{
	if (fully_parsed)
		return;

	if (basic_parsed == false)
		parse_basic_entry();

	getline(data_stream, FORMAT_str, '\t');

	if (parse_FORMAT)
		set_FORMAT(FORMAT_str);

	string tmpstr; tmpstr.reserve(64);
	GENOTYPE_str.resize(N_indv, tmpstr);

	for (unsigned int ui=0; ui<N_indv; ui++)
		getline(data_stream, GENOTYPE_str[ui], '\t');

	fully_parsed = true;
}

// Assembly:
subq $0x58, %rsp
movb %sil, %al
movq %rdi, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x3d9(%rax)
je 0x3edfa
jmp 0x3ef27
movq 0x10(%rsp), %rax
movb 0x3d8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3ee20
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq *0x10(%rax)
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
addq $0x240, %rdi            # imm = 0x240
addq $0x718, %rsi            # imm = 0x718
movl $0x9, %edx
callq 0x6a80
testb $0x1, 0x4f(%rsp)
je 0x3ee5b
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
addq $0x718, %rsi            # imm = 0x718
callq 0x4ff50
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x67e0
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x68a0
jmp 0x3ee7b
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x758, %rdi            # imm = 0x758
movl 0x8(%rax), %eax
movl %eax, %esi
leaq 0x28(%rsp), %rdx
callq 0x43280
jmp 0x3ee9b
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x3ef11
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x240, %rax            # imm = 0x240
movq %rax, (%rsp)
addq $0x758, %rdi            # imm = 0x758
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x10290
movq (%rsp), %rdi
movq %rax, %rsi
movl $0x9, %edx
callq 0x6a80
jmp 0x3eee8
jmp 0x3eeea
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3eea3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6b50
jmp 0x3ef2c
movq 0x10(%rsp), %rax
movb $0x1, 0x3d9(%rax)
leaq 0x28(%rsp), %rdi
callq 0x6b50
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/entry.cpp
// Function: entry::make_typed_int(std::vector<char, std::allocator<char>>&, int const&, bool)
void entry::make_typed_int(vector<char> &out, const int &in, bool typed)
{
	vector<char> tmp_char;
	out.resize(0);

	int type;
	int8_t size_type = (int8_t)1;
	if (in < 127 and in >-127)
		type = 1;
	else if (in < 32767 and in>-32767)
		type = 2;
	else
		type = 3;

	make_int(tmp_char, in, type);

	if (typed == true)
	{
		size_type = size_type << 4;
		size_type = size_type | type;
		out.push_back(size_type);
	}
	out.insert(out.end(), tmp_char.begin(), tmp_char.end());
}

// Assembly:
subq $0x98, %rsp
movb %cl, %al
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
andb $0x1, %al
movb %al, 0x7f(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2a300
movq 0x88(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20910
jmp 0x45d71
movb $0x1, 0x4f(%rsp)
movq 0x80(%rsp), %rax
cmpl $0x7f, (%rax)
jge 0x45db7
movq 0x80(%rsp), %rax
cmpl $-0x7f, (%rax)
jle 0x45db7
movl $0x1, 0x50(%rsp)
jmp 0x45deb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x267c0
jmp 0x45ed1
movq 0x80(%rsp), %rax
cmpl $0x7fff, (%rax)         # imm = 0x7FFF
jge 0x45de1
movq 0x80(%rsp), %rax
cmpl $0xffff8001, (%rax)     # imm = 0xFFFF8001
jle 0x45de1
movl $0x2, 0x50(%rsp)
jmp 0x45de9
movl $0x3, 0x50(%rsp)
jmp 0x45deb
movq 0x18(%rsp), %rdi
movq 0x80(%rsp), %rdx
movl 0x50(%rsp), %ecx
leaq 0x60(%rsp), %rsi
callq 0x45ee0
jmp 0x45e08
movb 0x7f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x45e4e
movb 0x4f(%rsp), %al
shlb $0x4, %al
movb %al, 0x4f(%rsp)
movzbl 0x4f(%rsp), %eax
movl 0x50(%rsp), %ecx
orl %ecx, %eax
movb %al, 0x4f(%rsp)
movq 0x88(%rsp), %rdi
movb 0x4f(%rsp), %al
movb %al, 0x4e(%rsp)
leaq 0x4e(%rsp), %rsi
callq 0x49620
jmp 0x45e4c
jmp 0x45e4e
movq 0x88(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x27020
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x39b20
leaq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x26ff0
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x27020
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x39a60
movq %rax, 0x10(%rsp)
jmp 0x45eb5
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x267c0
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x69e0
nopl (%rax,%rax)
// File: auton1[P]viterbi/entry.cpp
// Function: entry::make_int(std::vector<char, std::allocator<char>>&, int const&, int)
void entry::make_int(vector<char> &out, const int &in, int type)
{
	out.resize(0);
	if (type == 1)
	{
		int8_t tmp_int;
		if (in == (int)0x80000000 || in >= 128)
			tmp_int = (int8_t)0x80;
		else if (in == (int)0x80000001)
			tmp_int = (int8_t)0x81;
		else
			tmp_int = (int8_t)in;
		out.push_back( (int8_t)tmp_int);
	}
	else if (type == 2)
	{
		int16_t tmp_int;

		if (in == (int)0x80000000 || in >= 32768)
			tmp_int = 0x8000;
		else if (in == (int)0x80000001)
			tmp_int = (int8_t)0x8001;
		else
			tmp_int = (int16_t)in;

		int8_t split;
		for(unsigned int ui=0; ui<2; ui++)
		{
			split = tmp_int & (int16_t)0x00FF;//0000000011111111
			out.push_back(split);
			tmp_int = tmp_int >> 8;
		}
	}
	else
	{
		int32_t tmp_int;
		tmp_int = (int32_t)in;

		int8_t split;
		for(unsigned int ui=0; ui<4; ui++)
		{
			split = tmp_int & (int32_t)0x0000FF;
			out.push_back( (int8_t)split);
			tmp_int = tmp_int >> 8;
		}
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20910
cmpl $0x1, 0x2c(%rsp)
jne 0x45f6a
movq 0x30(%rsp), %rax
cmpl $0x80000000, (%rax)     # imm = 0x80000000
je 0x45f26
movq 0x30(%rsp), %rax
cmpl $0x80, (%rax)
jl 0x45f2d
movb $-0x80, 0x2b(%rsp)
jmp 0x45f4e
movq 0x30(%rsp), %rax
cmpl $0x80000001, (%rax)     # imm = 0x80000001
jne 0x45f41
movb $-0x7f, 0x2b(%rsp)
jmp 0x45f4c
movq 0x30(%rsp), %rax
movl (%rax), %eax
movb %al, 0x2b(%rsp)
jmp 0x45f4e
movq 0x38(%rsp), %rdi
movb 0x2b(%rsp), %al
movb %al, 0x2a(%rsp)
leaq 0x2a(%rsp), %rsi
callq 0x49620
jmp 0x46066
cmpl $0x2, 0x2c(%rsp)
jne 0x4600c
movq 0x30(%rsp), %rax
cmpl $0x80000000, (%rax)     # imm = 0x80000000
je 0x45f8f
movq 0x30(%rsp), %rax
cmpl $0x8000, (%rax)         # imm = 0x8000
jl 0x45f98
movw $0x8000, 0x28(%rsp)     # imm = 0x8000
jmp 0x45fbc
movq 0x30(%rsp), %rax
cmpl $0x80000001, (%rax)     # imm = 0x80000001
jne 0x45fae
movw $0x1, 0x28(%rsp)
jmp 0x45fba
movq 0x30(%rsp), %rax
movl (%rax), %eax
movw %ax, 0x28(%rsp)
jmp 0x45fbc
movl $0x0, 0x20(%rsp)
cmpl $0x2, 0x20(%rsp)
jae 0x4600a
movswl 0x28(%rsp), %eax
andl $0xff, %eax
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rdi
movb 0x27(%rsp), %al
movb %al, 0x1f(%rsp)
leaq 0x1f(%rsp), %rsi
callq 0x49620
movswl 0x28(%rsp), %eax
sarl $0x8, %eax
movw %ax, 0x28(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x45fc4
jmp 0x46064
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x4, 0x10(%rsp)
jae 0x46062
movl 0x18(%rsp), %eax
andl $0xff, %eax
movb %al, 0x17(%rsp)
movq 0x38(%rsp), %rdi
movb 0x17(%rsp), %al
movb %al, 0xf(%rsp)
leaq 0xf(%rsp), %rsi
callq 0x49620
movl 0x18(%rsp), %eax
sarl $0x8, %eax
movl %eax, 0x18(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4601f
jmp 0x46064
jmp 0x46066
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: auton1[P]viterbi/entry.cpp
// Function: entry::encode_genotype(std::vector<char, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
void entry::encode_genotype(vector<char> &out, string &in, int exp_size)
{
	int8_t tmp_int;
	int8_t phased = 0;
	out.resize(0);

	for (unsigned int ui=0; ui<in.length(); ui++)
	{
		if (in[ui] =='|')
			phased = 1;
		else if (in[ui] == '/')
			phased = 0;
		else
		{
			if(in[ui] != '.')
			{
				tmp_int = header::str2int( in.substr(ui,1) );
				tmp_int++;
				tmp_int = tmp_int << 1;
				tmp_int = tmp_int | phased;
			}
			else
				tmp_int = 0x80;

			out.push_back( (int8_t)tmp_int );
		}
	}
	int pad = out.size();
	while (pad<exp_size)
	{
		out.push_back( (int8_t)0x81 );
		pad+=1;
	}
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movb $0x0, 0x5a(%rsp)
movq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20910
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x6850
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x46a0b
movq 0x60(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0x6b20
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x46918
movb $0x1, 0x5a(%rsp)
jmp 0x469f9
movq 0x60(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0x6b20
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x4693a
movb $0x0, 0x5a(%rsp)
jmp 0x469f7
movq 0x60(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0x6b20
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x469db
movq 0x60(%rsp), %rsi
movl 0x54(%rsp), %eax
movl %eax, %edx
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x1, %ecx
callq 0x6580
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2fb70
movl %eax, 0xc(%rsp)
jmp 0x46988
movl 0xc(%rsp), %eax
movb %al, 0x5b(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6b50
movb 0x5b(%rsp), %al
addb $0x1, %al
movb %al, 0x5b(%rsp)
movsbl 0x5b(%rsp), %eax
shll %eax
movb %al, 0x5b(%rsp)
movsbl 0x5b(%rsp), %eax
movsbl 0x5a(%rsp), %ecx
orl %ecx, %eax
movb %al, 0x5b(%rsp)
jmp 0x469e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6b50
jmp 0x46a49
movb $-0x80, 0x5b(%rsp)
movq 0x68(%rsp), %rdi
movb 0x5b(%rsp), %al
movb %al, 0x23(%rsp)
leaq 0x23(%rsp), %rsi
callq 0x49620
jmp 0x469f9
jmp 0x469fb
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x468d2
movq 0x68(%rsp), %rdi
callq 0x249e0
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jge 0x46a44
movq 0x68(%rsp), %rdi
movb $-0x7f, 0x1b(%rsp)
leaq 0x1b(%rsp), %rsi
callq 0x49620
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x46a19
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/entry.cpp
// Function: entry::make_type_size(std::vector<char, std::allocator<char>>&, unsigned int const&, unsigned int const&)
void entry::make_type_size(vector<char> &out, const unsigned int &type, const unsigned int &size)
{
	uint8_t byte;
	vector<char> tmp_vector;
	tmp_vector.resize(0);
	out.resize(0);

	if (size < 15)
	{
		byte = size;
		byte = byte << 4;
	}
	else
	{
		byte = (uint8_t)15;
		make_typed_int(tmp_vector, size, true);
	}

	byte = byte | (uint8_t)type;
	out.push_back(byte);
	out.insert(out.end(), tmp_vector.begin(), tmp_vector.end());
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2a300
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20910
jmp 0x48553
movq 0x98(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20910
jmp 0x48566
movq 0x88(%rsp), %rax
cmpl $0xf, (%rax)
jae 0x485b5
movq 0x88(%rsp), %rax
movl (%rax), %eax
movb %al, 0x87(%rsp)
movzbl 0x87(%rsp), %eax
shll $0x4, %eax
movb %al, 0x87(%rsp)
jmp 0x485e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x267c0
jmp 0x486a5
movq 0x18(%rsp), %rdi
movb $0xf, 0x87(%rsp)
movq 0x88(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x58(%rsp)
leaq 0x68(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movl $0x1, %ecx
callq 0x45d20
jmp 0x485e6
jmp 0x485e8
movzbl 0x87(%rsp), %eax
movq 0x90(%rsp), %rcx
movl (%rcx), %ecx
orl %ecx, %eax
movb %al, 0x87(%rsp)
movq 0x98(%rsp), %rdi
movb 0x87(%rsp), %al
movb %al, 0x57(%rsp)
leaq 0x57(%rsp), %rsi
callq 0x49620
jmp 0x48622
movq 0x98(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x27020
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x39b20
leaq 0x68(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x26ff0
movq (%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x27020
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x39a60
movq %rax, 0x10(%rsp)
jmp 0x48689
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x267c0
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x69e0
nop
// File: auton1[P]viterbi/entry.cpp
// Function: entry::skip_section(unsigned int*, std::vector<char, std::allocator<char>> const&)
void entry::skip_section(unsigned int *line_position, const vector<char> &line)
{
	unsigned int type, size;
	get_type(line_position, line, type, size);

	if ( (type == 1) || (type == 7) )
		*line_position += sizeof(int8_t)*size;
	else if (type == 2)
		*line_position += sizeof(int16_t)*size;
	else if ( (type == 3) || (type == 5) )
		*line_position += sizeof(int32_t)*size;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x489f0
cmpl $0x1, 0xc(%rsp)
je 0x491cf
cmpl $0x7, 0xc(%rsp)
jne 0x491e7
movl 0x8(%rsp), %eax
movl %eax, %edx
shlq $0x0, %rdx
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addq %rdx, %rcx
movl %ecx, (%rax)
jmp 0x4922d
cmpl $0x2, 0xc(%rsp)
jne 0x49205
movl 0x8(%rsp), %eax
movl %eax, %edx
shlq %rdx
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addq %rdx, %rcx
movl %ecx, (%rax)
jmp 0x4922b
cmpl $0x3, 0xc(%rsp)
je 0x49213
cmpl $0x5, 0xc(%rsp)
jne 0x49229
movl 0x8(%rsp), %eax
movl %eax, %edx
shlq $0x2, %rdx
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addq %rdx, %rcx
movl %ecx, (%rax)
jmp 0x4922b
jmp 0x4922d
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_REF[abi:cxx11]() const
string entry::get_REF() const
{
	if (REF == "")
		return ".";
	else
		return REF;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x428, %rdi            # imm = 0x428
leaq 0x2b966(%rip), %rsi     # 0x75d29
callq 0xea20
testb $0x1, %al
jne 0x4a3ce
jmp 0x4a419
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x69f0
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x2acf2(%rip), %rsi     # 0x750de
callq 0x67c0
jmp 0x4a3f3
leaq 0x37(%rsp), %rdi
callq 0x65f0
jmp 0x4a42f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x65f0
jmp 0x4a439
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x428, %rsi            # imm = 0x428
callq 0x61c0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_ALT[abi:cxx11]() const
string entry::get_ALT() const
{
	assert(parsed_ALT == true);

	string out;
	if (ALT.empty())
		out = ".";
	else if (ALT.size() == 1 && ALT[0] == "")
		out = ".";
	else
	{
		out = ALT[0];
		for (unsigned int ui=1; ui<ALT.size(); ui++)
			out += "," + ALT[ui];
	}
	return out;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x3da(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4a487
jmp 0x4a4a6
leaq 0x2ae0f(%rip), %rdi     # 0x7529d
leaq 0x2ae1b(%rip), %rsi     # 0x752b0
movl $0x2d, %edx
leaq 0x2ae21(%rip), %rcx     # 0x752c2
callq 0x6300
movq 0x18(%rsp), %rdi
movb $0x0, 0x67(%rsp)
callq 0x67e0
movq 0x28(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
callq 0x39710
testb $0x1, %al
jne 0x4a4cc
jmp 0x4a4f7
movq 0x18(%rsp), %rdi
leaq 0x2ac06(%rip), %rsi     # 0x750de
callq 0x67b0
jmp 0x4a4df
jmp 0x4a620
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x4a640
movq 0x28(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
cmpq $0x1, %rax
jne 0x4a55a
movq 0x28(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
xorl %eax, %eax
movl %eax, %esi
callq 0x497f0
movq %rax, %rdi
leaq 0x2b7fc(%rip), %rsi     # 0x75d29
callq 0xea20
movb %al, 0x17(%rsp)
jmp 0x4a538
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x4a542
jmp 0x4a55a
movq 0x18(%rsp), %rdi
leaq 0x2ab90(%rip), %rsi     # 0x750de
callq 0x67b0
jmp 0x4a555
jmp 0x4a61e
movq 0x28(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
xorl %eax, %eax
movl %eax, %esi
callq 0x497f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x6060
jmp 0x4a57e
movl $0x1, 0x50(%rsp)
movq 0x28(%rsp), %rdi
movl 0x50(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4a61c
movq 0x28(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
movl 0x50(%rsp), %eax
movl %eax, %esi
callq 0x497f0
movq %rax, %rdx
leaq 0x2a60c(%rip), %rsi     # 0x74bda
leaq 0x30(%rsp), %rdi
callq 0xe8d0
jmp 0x4a5da
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6730
jmp 0x4a5eb
leaq 0x30(%rsp), %rdi
callq 0x6b50
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x4a586
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6b50
jmp 0x4a640
jmp 0x4a61e
jmp 0x4a620
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x4a636
movq 0x18(%rsp), %rdi
callq 0x6b50
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x6b50
movq 0x58(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::is_SNP() const
bool entry::is_SNP() const
{
	assert(parsed_ALT == true);

	if (REF.size() != 1)
		return false;	// Reference isn't a single base

	if (ALT.empty())
		return false;	// No alternative allele

	for (unsigned int ui=0; ui<ALT.size(); ui++)
		if (ALT[ui].size() != 1)
			return false;	// Alternative allele isn't a single base

	return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x3da(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4a685
jmp 0x4a6a4
leaq 0x2ac11(%rip), %rdi     # 0x7529d
leaq 0x2ac1d(%rip), %rsi     # 0x752b0
movl $0x3f, %edx
leaq 0x2ac41(%rip), %rcx     # 0x752e0
callq 0x6300
movq 0x8(%rsp), %rdi
addq $0x428, %rdi            # imm = 0x428
callq 0x6350
cmpq $0x1, %rax
je 0x4a6c5
movb $0x0, 0x27(%rsp)
jmp 0x4a750
movq 0x8(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
callq 0x39710
testb $0x1, %al
jne 0x4a6dc
jmp 0x4a6e3
movb $0x0, 0x27(%rsp)
jmp 0x4a750
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movq %rax, (%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x4a74b
movq 0x8(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x497f0
movq %rax, %rdi
callq 0x6350
cmpq $0x1, %rax
je 0x4a73c
movb $0x0, 0x27(%rsp)
jmp 0x4a750
jmp 0x4a73e
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a6eb
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::is_biallelic_SNP() const
bool entry::is_biallelic_SNP() const
{
	assert(parsed_ALT == true);

	if (REF.size() != 1)
		return false;	// Reference isn't a single base

	if (ALT.size() != 1)
		return false;	// Not biallelic

	if (ALT[0].size() != 1)
		return false;	// Alternative allele isn't a single base

	return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movb 0x3da(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4a784
jmp 0x4a7a3
leaq 0x2ab12(%rip), %rdi     # 0x7529d
leaq 0x2ab1e(%rip), %rsi     # 0x752b0
movl $0x50, %edx
leaq 0x2ab5d(%rip), %rcx     # 0x752fb
callq 0x6300
movq (%rsp), %rdi
addq $0x428, %rdi            # imm = 0x428
callq 0x6350
cmpq $0x1, %rax
je 0x4a7c0
movb $0x0, 0x17(%rsp)
jmp 0x4a80b
movq (%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
cmpq $0x1, %rax
je 0x4a7dd
movb $0x0, 0x17(%rsp)
jmp 0x4a80b
movq (%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
xorl %eax, %eax
movl %eax, %esi
callq 0x497f0
movq %rax, %rdi
callq 0x6350
cmpq $0x1, %rax
je 0x4a806
movb $0x0, 0x17(%rsp)
jmp 0x4a80b
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::is_diploid() const
bool entry::is_diploid() const
{
	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
		{
			assert(parsed_GT[ui] == true);
			if (ploidy[ui] != 2)
				return false;
		}
	}
	return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x4a90c
movq 0x8(%rsp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4a8fa
movq 0x8(%rsp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4a8fa
movq 0x8(%rsp), %rdi
addq $0x560, %rdi            # imm = 0x560
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4a8b6
jmp 0x4a8d5
leaq 0x2aa63(%rip), %rdi     # 0x75320
leaq 0x2a9ec(%rip), %rsi     # 0x752b0
movl $0x64, %edx
leaq 0x2aa66(%rip), %rcx     # 0x75336
callq 0x6300
movq 0x8(%rsp), %rdi
addq $0x4e8, %rdi            # imm = 0x4E8
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xf130
cmpl $0x2, (%rax)
je 0x4a8f8
movb $0x0, 0x27(%rsp)
jmp 0x4a911
jmp 0x4a8fa
jmp 0x4a8fc
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a83b
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_allele(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
void entry::get_allele(int allele_num, string &out) const
{
	assert(parsed_ALT == true);

	if (allele_num == -2)
		out = "";
	else if (allele_num == 0)
		out = REF;
	else if ((allele_num == -1) || (unsigned(allele_num - 1) >=  ALT.size()))
		out = ".";
	else
		out = ALT[allele_num-1];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x3da(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4a94e
jmp 0x4a96d
leaq 0x2a948(%rip), %rdi     # 0x7529d
leaq 0x2a954(%rip), %rsi     # 0x752b0
movl $0x6e, %edx
leaq 0x2a9ed(%rip), %rcx     # 0x75355
callq 0x6300
cmpl $-0x2, 0x1c(%rsp)
jne 0x4a98a
movq 0x10(%rsp), %rdi
leaq 0x2b3a9(%rip), %rsi     # 0x75d29
callq 0x67b0
jmp 0x4aa19
cmpl $0x0, 0x1c(%rsp)
jne 0x4a9a9
movq 0x8(%rsp), %rsi
addq $0x428, %rsi            # imm = 0x428
movq 0x10(%rsp), %rdi
callq 0x6060
jmp 0x4aa17
cmpl $-0x1, 0x1c(%rsp)
je 0x4a9da
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movq %rax, (%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x4a9ed
movq 0x10(%rsp), %rdi
leaq 0x2a6f8(%rip), %rsi     # 0x750de
callq 0x67b0
jmp 0x4aa15
movq 0x8(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x497f0
movq %rax, %rsi
movq 0x10(%rsp), %rdi
callq 0x6060
jmp 0x4aa17
jmp 0x4aa19
addq $0x28, %rsp
retq
nop
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_allele[abi:cxx11](int) const
string entry::get_allele(int allele_num) const
{
	assert(parsed_ALT == true);

	if (allele_num == -2)
		return "";
	else if (allele_num == 0)
		return REF;
	else if ((allele_num < 0) || (unsigned(allele_num - 1) >=  ALT.size()))
		return ".";
	else
		return ALT[allele_num-1];
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x3da(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4aa5b
jmp 0x4aa7a
leaq 0x2a83b(%rip), %rdi     # 0x7529d
leaq 0x2a847(%rip), %rsi     # 0x752b0
movl $0x7c, %edx
leaq 0x2a90c(%rip), %rcx     # 0x75381
callq 0x6300
cmpl $-0x2, 0x44(%rsp)
jne 0x4aad4
leaq 0x43(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x69f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x2b288(%rip), %rsi     # 0x75d29
callq 0x67c0
jmp 0x4aaa8
leaq 0x43(%rsp), %rdi
callq 0x65f0
jmp 0x4ab9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x43(%rsp), %rdi
callq 0x65f0
jmp 0x4aba6
cmpl $0x0, 0x44(%rsp)
jne 0x4aaf6
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x428, %rsi            # imm = 0x428
callq 0x61c0
jmp 0x4ab9c
cmpl $0x0, 0x44(%rsp)
jl 0x4ab29
movq 0x28(%rsp), %rdi
movl 0x44(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movq %rax, 0x8(%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x4ab74
leaq 0x33(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x69f0
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x2a597(%rip), %rsi     # 0x750de
callq 0x67c0
jmp 0x4ab4e
leaq 0x33(%rsp), %rdi
callq 0x65f0
jmp 0x4ab9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x33(%rsp), %rdi
callq 0x65f0
jmp 0x4aba6
movq 0x28(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
movl 0x44(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x497f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x61c0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x69e0
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_ALT_allele[abi:cxx11](int) const
string entry::get_ALT_allele(int allele_num) const
{
	assert(parsed_ALT == true);

	if (allele_num == -2)
		return "";
	else if ((allele_num == -1) || (unsigned(allele_num) >=  ALT.size()))
		return ".";
	return ALT[allele_num];
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x3da(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4abeb
jmp 0x4ac0a
leaq 0x2a6ab(%rip), %rdi     # 0x7529d
leaq 0x2a6b7(%rip), %rsi     # 0x752b0
movl $0x8a, %edx
leaq 0x2a7a0(%rip), %rcx     # 0x753a5
callq 0x6300
cmpl $-0x2, 0x44(%rsp)
jne 0x4ac64
leaq 0x43(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x69f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x2b0f8(%rip), %rsi     # 0x75d29
callq 0x67c0
jmp 0x4ac38
leaq 0x43(%rsp), %rdi
callq 0x65f0
jmp 0x4ad02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x43(%rsp), %rdi
callq 0x65f0
jmp 0x4ad0c
cmpl $-0x1, 0x44(%rsp)
je 0x4ac92
movq 0x28(%rsp), %rdi
movl 0x44(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x4acdd
leaq 0x33(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x69f0
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x2a42e(%rip), %rsi     # 0x750de
callq 0x67c0
jmp 0x4acb7
leaq 0x33(%rsp), %rdi
callq 0x65f0
jmp 0x4ad02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x33(%rsp), %rdi
callq 0x65f0
jmp 0x4ad0c
jmp 0x4acdf
movq 0x28(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
movslq 0x44(%rsp), %rsi
callq 0x497f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x61c0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_alleles_vector(std::vector<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::get_alleles_vector(vector<string> &out) const
{
	assert(parsed_ALT == true);
	out.resize(ALT.size()+1);
	out[0] = REF;
	copy(ALT.begin(), ALT.end(), out.begin()+1);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x3da(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4ad4a
jmp 0x4ad69
leaq 0x2a54c(%rip), %rdi     # 0x7529d
leaq 0x2a558(%rip), %rsi     # 0x752b0
movl $0x95, %edx
leaq 0x2a669(%rip), %rcx     # 0x753cd
callq 0x6300
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x10270
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x2a0f0
movq 0x18(%rsp), %rax
addq $0x428, %rax            # imm = 0x428
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10290
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x6060
movq 0x18(%rsp), %rdi
addq $0x448, %rdi            # imm = 0x448
callq 0x210c0
movq 0x18(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x448, %rdi            # imm = 0x448
callq 0x210f0
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x211d0
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x218a0
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x21160
movq %rax, 0x20(%rsp)
addq $0x58, %rsp
retq
nopl (%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_FILTER[abi:cxx11]() const
string entry::get_FILTER() const
{
	assert(parsed_FILTER == true);

	ostringstream out;
	if (FILTER.empty())
		out << ".";
	else
	{
		out << FILTER[0];
		for (unsigned int ui=1; ui<FILTER.size(); ui++)
			out << ";" << FILTER[ui];
	}
	return out.str();
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq 0x1b8(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x3db(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4ae93
jmp 0x4aeb2
leaq 0x2a56a(%rip), %rdi     # 0x75404
leaq 0x2a40f(%rip), %rsi     # 0x752b0
movl $0xa2, %edx
leaq 0x2a56d(%rip), %rcx     # 0x7541a
callq 0x6300
leaq 0x40(%rsp), %rdi
callq 0x67a0
movq 0x28(%rsp), %rdi
addq $0x468, %rdi            # imm = 0x468
callq 0x39710
testb $0x1, %al
jne 0x4aed3
jmp 0x4af08
leaq 0x2a204(%rip), %rsi     # 0x750de
leaq 0x40(%rsp), %rdi
callq 0x6540
jmp 0x4aee6
jmp 0x4afaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x6b30
jmp 0x4afd2
movq 0x28(%rsp), %rdi
addq $0x468, %rdi            # imm = 0x468
xorl %eax, %eax
movl %eax, %esi
callq 0x497f0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x64a0
jmp 0x4af2c
movl $0x1, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movl 0x30(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x468, %rdi            # imm = 0x468
callq 0x10270
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x4afa8
leaq 0x2a4d9(%rip), %rsi     # 0x7543b
leaq 0x40(%rsp), %rdi
callq 0x6540
movq %rax, 0x8(%rsp)
jmp 0x4af73
movq 0x28(%rsp), %rdi
addq $0x468, %rdi            # imm = 0x468
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x497f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x64a0
jmp 0x4af99
jmp 0x4af9b
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x4af34
jmp 0x4afaa
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6570
jmp 0x4afbb
leaq 0x40(%rsp), %rdi
callq 0x6b30
movq 0x20(%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x38(%rsp), %rdi
callq 0x69e0
nopl (%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_INFO_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string entry::get_INFO_value(const string &key) const
{
	assert(parsed_INFO == true);

	for (unsigned int ui=0; ui<INFO.size(); ui++)
	{
		if (INFO[ui].first == key)
			return INFO[ui].second;
	}
	return "?";
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movb 0x3dc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4b79c
jmp 0x4b7bb
leaq 0x29cd0(%rip), %rdi     # 0x75473
leaq 0x29b06(%rip), %rsi     # 0x752b0
movl $0xf1, %edx
leaq 0x29d5e(%rip), %rcx     # 0x75514
callq 0x6300
movl $0x0, 0x3c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x480, %rdi            # imm = 0x480
callq 0x39a20
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4b850
movq 0x20(%rsp), %rdi
addq $0x480, %rdi            # imm = 0x480
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x4d140
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x2a430
testb $0x1, %al
jne 0x4b814
jmp 0x4b83e
movq 0x20(%rsp), %rdi
addq $0x480, %rdi            # imm = 0x480
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x4d140
movq 0x10(%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x61c0
jmp 0x4b89b
jmp 0x4b840
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x4b7c3
leaq 0x3b(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x69f0
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x2ae02(%rip), %rsi     # 0x76670
callq 0x67c0
jmp 0x4b875
leaq 0x3b(%rsp), %rdi
callq 0x65f0
jmp 0x4b89b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3b(%rsp), %rdi
callq 0x65f0
jmp 0x4b8a5
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x69e0
nop
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_INFO_values(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
vector<string> entry::get_INFO_values(const string &key) const
{
	vector<string> out;
	string tmp;

	tmp = get_INFO_value(key);
	if (tmp != "?")	header::tokenize(tmp, ',', out);

	return out;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x8f(%rsp)
callq 0x10260
leaq 0x68(%rsp), %rdi
callq 0x67e0
movq 0x30(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x4b760
jmp 0x4b919
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x48(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x66c0
movq 0x8(%rsp), %rdi
callq 0x6b50
movq 0x10(%rsp), %rdi
leaq 0x2ad28(%rip), %rsi     # 0x76670
callq 0x30930
movb %al, 0x1f(%rsp)
jmp 0x4b953
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x4b95d
jmp 0x4b999
movq 0x20(%rsp), %rdx
leaq 0x68(%rsp), %rdi
movl $0x2c, %esi
callq 0x2fa70
jmp 0x4b973
jmp 0x4b999
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x6b50
movq 0x20(%rsp), %rdi
callq 0x10cc0
jmp 0x4b9cc
movb $0x1, 0x8f(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x6b50
testb $0x1, 0x8f(%rsp)
jne 0x4b9bf
movq 0x20(%rsp), %rdi
callq 0x10cc0
movq 0x28(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_FORMAT[abi:cxx11]() const
string entry::get_FORMAT() const
{
	assert(parsed_FORMAT == true);

	string out;
	bool first = true;
	for (unsigned int ui=0; ui<FORMAT.size(); ui++)
	{
		if (first == false)
			out += ":";
		out += FORMAT[ui];
		first = false;
	}
	return out;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x3dd(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4ba17
jmp 0x4ba36
leaq 0x29b29(%rip), %rdi     # 0x75547
leaq 0x2988b(%rip), %rsi     # 0x752b0
movl $0x108, %edx            # imm = 0x108
leaq 0x29b2c(%rip), %rcx     # 0x7555d
callq 0x6300
movq 0x8(%rsp), %rdi
movb $0x0, 0x37(%rsp)
callq 0x67e0
movb $0x1, 0x36(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rdi
movl 0x30(%rsp), %eax
movq %rax, (%rsp)
addq $0x498, %rdi            # imm = 0x498
callq 0x10270
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x4baef
movb 0x36(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4bab4
movq 0x8(%rsp), %rdi
leaq 0x2a44e(%rip), %rsi     # 0x75edf
callq 0x6510
jmp 0x4ba98
jmp 0x4bab4
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6b50
jmp 0x4bb0f
movq 0x18(%rsp), %rdi
addq $0x498, %rdi            # imm = 0x498
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x497f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6730
jmp 0x4bada
movb $0x0, 0x36(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x4ba52
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x4bb05
movq 0x8(%rsp), %rdi
callq 0x6b50
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x69e0
nopl (%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_GENOTYPE_strings(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 entry::get_indv_GENOTYPE_strings(unsigned int indv, pair<string, string> &out) const
{
	assert(parsed_GT[indv] == true);

	static string out_allele1, out_allele2;

	get_allele(GENOTYPE[indv].first, out_allele1);
	get_allele(GENOTYPE[indv].second, out_allele2);
	out = make_pair(out_allele1, out_allele2);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x560, %rdi            # imm = 0x560
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4bbca
jmp 0x4bbe9
leaq 0x299fe(%rip), %rdi     # 0x755cf
leaq 0x296d8(%rip), %rsi     # 0x752b0
movl $0x11f, %edx            # imm = 0x11F
leaq 0x29a03(%rip), %rcx     # 0x755e7
callq 0x6300
cmpb $0x0, 0x48400(%rip)     # 0x93ff0
jne 0x4bc35
leaq 0x483f7(%rip), %rdi     # 0x93ff0
callq 0x6a40
cmpl $0x0, %eax
je 0x4bc35
leaq 0x483c6(%rip), %rdi     # 0x93fd0
callq 0x67e0
movq 0x47392(%rip), %rdi     # 0x92fa8
leaq 0x483b3(%rip), %rsi     # 0x93fd0
leaq 0x4797c(%rip), %rdx     # 0x935a0
callq 0x6490
leaq 0x483c0(%rip), %rdi     # 0x93ff0
callq 0x62f0
cmpb $0x0, 0x483dc(%rip)     # 0x94018
jne 0x4bc81
leaq 0x483d3(%rip), %rdi     # 0x94018
callq 0x6a40
cmpl $0x0, %eax
je 0x4bc81
leaq 0x483a2(%rip), %rdi     # 0x93ff8
callq 0x67e0
movq 0x47346(%rip), %rdi     # 0x92fa8
leaq 0x4838f(%rip), %rsi     # 0x93ff8
leaq 0x47930(%rip), %rdx     # 0x935a0
callq 0x6490
leaq 0x4839c(%rip), %rdi     # 0x94018
callq 0x62f0
movq 0x8(%rsp), %rdi
addq $0x4d0, %rdi            # imm = 0x4D0
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x4d300
movq 0x8(%rsp), %rdi
movl (%rax), %esi
leaq 0x4832a(%rip), %rdx     # 0x93fd0
callq 0x4a920
movq 0x8(%rsp), %rdi
addq $0x4d0, %rdi            # imm = 0x4D0
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x4d300
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %esi
leaq 0x48327(%rip), %rdx     # 0x93ff8
callq 0x4a920
leaq 0x10(%rsp), %rdi
leaq 0x482ee(%rip), %rsi     # 0x93fd0
leaq 0x4830f(%rip), %rdx     # 0x93ff8
callq 0x4d320
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4d360
leaq 0x10(%rsp), %rdi
callq 0x3a810
addq $0x68, %rsp
retq
nopl (%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_DEPTH(unsigned int) const
int entry::get_indv_DEPTH(unsigned int indv) const
{
	assert(parsed_DP[indv] == true);
	if (DEPTH.empty())
		return -1;
	return DEPTH[indv];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x5b0, %rdi            # imm = 0x5B0
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4be45
jmp 0x4be64
leaq 0x29864(%rip), %rdi     # 0x756b0
leaq 0x2945d(%rip), %rsi     # 0x752b0
movl $0x136, %edx            # imm = 0x136
leaq 0x29869(%rip), %rcx     # 0x756c8
callq 0x6300
movq 0x8(%rsp), %rdi
addq $0x530, %rdi            # imm = 0x530
callq 0x4d3d0
testb $0x1, %al
jne 0x4be7b
jmp 0x4be85
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x4bea2
movq 0x8(%rsp), %rdi
addq $0x530, %rdi            # imm = 0x530
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xf130
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_GQUALITY(unsigned int) const
double entry::get_indv_GQUALITY(unsigned int indv) const
{
	assert(parsed_GQ[indv] == true);
	if (GQUALITY.empty())
		return -1;
	return GQUALITY[indv];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x588, %rdi            # imm = 0x588
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4bee5
jmp 0x4bf04
leaq 0x2980a(%rip), %rdi     # 0x756f6
leaq 0x293bd(%rip), %rsi     # 0x752b0
movl $0x13e, %edx            # imm = 0x13E
leaq 0x2980f(%rip), %rcx     # 0x7570e
callq 0x6300
movq 0x8(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
callq 0x4d420
testb $0x1, %al
jne 0x4bf1b
jmp 0x4bf2b
movsd 0x2901d(%rip), %xmm0    # 0x74f40
movsd %xmm0, 0x20(%rsp)
jmp 0x4bf4c
movq 0x8(%rsp), %rdi
addq $0x518, %rdi            # imm = 0x518
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xeff0
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_GFILTER_vector(unsigned int, std::vector<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::get_indv_GFILTER_vector(unsigned int indv, vector<string> &out) const
{
	assert(parsed_FT[indv] == true);
	if (!GFILTER.empty())
		out = GFILTER[indv];
	else
		out.resize(0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x5d8, %rdi            # imm = 0x5D8
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4bf9a
jmp 0x4bfb9
leaq 0x297a1(%rip), %rdi     # 0x75742
leaq 0x29308(%rip), %rsi     # 0x752b0
movl $0x146, %edx            # imm = 0x146
leaq 0x297a6(%rip), %rcx     # 0x7575a
callq 0x6300
movq 0x8(%rsp), %rdi
addq $0x548, %rdi            # imm = 0x548
callq 0x4d470
testb $0x1, %al
jne 0x4bff4
movq 0x8(%rsp), %rdi
addq $0x548, %rdi            # imm = 0x548
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x4d4c0
movq %rax, %rsi
movq 0x10(%rsp), %rdi
callq 0x209d0
jmp 0x4c002
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a0f0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_indv_GFILTER(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
void entry::get_indv_GFILTER(unsigned int indv, string &out) const
{
	assert(parsed_FT[indv] == true);

	if ((!GFILTER.empty()) && (GFILTER[indv].size()>0))
	{
		out="";
		for (unsigned int ui=0; ui<GFILTER[indv].size(); ui++)
		{
			if (ui!=0)
				out += ";";
			out += GFILTER[indv][ui];
		}
	}
	else
		out = ".";
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x5d8, %rdi            # imm = 0x5D8
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4c04a
jmp 0x4c069
leaq 0x296f1(%rip), %rdi     # 0x75742
leaq 0x29258(%rip), %rsi     # 0x752b0
movl $0x14f, %edx            # imm = 0x14F
leaq 0x29740(%rip), %rcx     # 0x757a4
callq 0x6300
movq 0x10(%rsp), %rdi
addq $0x548, %rdi            # imm = 0x548
callq 0x4d470
testb $0x1, %al
jne 0x4c155
movq 0x10(%rsp), %rdi
addq $0x548, %rdi            # imm = 0x548
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x4d4c0
movq %rax, %rdi
callq 0x10270
cmpq $0x0, %rax
jbe 0x4c155
movq 0x20(%rsp), %rdi
leaq 0x29c72(%rip), %rsi     # 0x75d29
callq 0x67b0
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x548, %rdi            # imm = 0x548
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x4d4c0
movq %rax, %rdi
callq 0x10270
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4c153
cmpl $0x0, 0x1c(%rsp)
je 0x4c111
movq 0x20(%rsp), %rdi
leaq 0x2932f(%rip), %rsi     # 0x7543b
callq 0x6510
movq 0x10(%rsp), %rdi
addq $0x548, %rdi            # imm = 0x548
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x4d4c0
movq %rax, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x497f0
movq %rax, %rsi
movq 0x20(%rsp), %rdi
callq 0x6730
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4c0c4
jmp 0x4c166
movq 0x20(%rsp), %rdi
leaq 0x28f7d(%rip), %rsi     # 0x750de
callq 0x67b0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: auton1[P]viterbi/entry_getters.cpp
// Function: entry::FORMAT_id_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool entry::FORMAT_id_exists(const string &FORMAT_id)
{
	assert(parsed_FORMAT == true);
	if (FORMAT_to_idx.find(FORMAT_id) != FORMAT_to_idx.end())
		return true;
	return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x3dd(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4c20a
jmp 0x4c229
leaq 0x29336(%rip), %rdi     # 0x75547
leaq 0x29098(%rip), %rsi     # 0x752b0
movl $0x167, %edx            # imm = 0x167
leaq 0x29600(%rip), %rcx     # 0x75824
callq 0x6300
movq 0x8(%rsp), %rdi
addq $0x600, %rdi            # imm = 0x600
movq 0x20(%rsp), %rsi
callq 0x43430
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x600, %rdi            # imm = 0x600
callq 0x3b7e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43410
testb $0x1, %al
jne 0x4c26f
jmp 0x4c276
movb $0x1, 0x37(%rsp)
jmp 0x4c27b
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)