LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0xf31a
movl (%r14), %r15d
cmpl $0x2, %ebp
je 0x1fec0
cmpl $0x1, %ebp
jne 0x1ff19
leal -0x80(%r15), %eax
cmpl $0x80000001, %r15d      # imm = 0x80000001
movl $0x81, %ecx
cmovnel %r15d, %ecx
cmpl $0x7fffff81, %eax       # imm = 0x7FFFFF81
movl $0x80, %eax
cmovael %ecx, %eax
movb %al, 0x7(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1ff50
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x1ff5d
movl $0xffff8000, %eax       # imm = 0xFFFF8000
leal (%r15,%rax), %ecx
cmpl $0x80000001, %r15d      # imm = 0x80000001
movl $0x1, %ebp
cmovel %ebp, %r15d
cmpl $0x7fff8001, %ecx       # imm = 0x7FFF8001
cmovbl %eax, %r15d
leaq 0x6(%rsp), %r14
movb %r15b, 0x6(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1ff00
movb %r15b, (%rsi)
incq 0x8(%rbx)
jmp 0x1ff0b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x21a92
shll $0x10, %r15d
sarl $0x18, %r15d
decl %ebp
je 0x1fee8
jmp 0x1ff5d
movl $0x4, %ebp
leaq 0x5(%rsp), %r14
movb %r15b, 0x5(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1ff3b
movb %r15b, (%rsi)
incq 0x8(%rbx)
jmp 0x1ff46
movq %rbx, %rdi
movq %r14, %rdx
callq 0x21a92
sarl $0x8, %r15d
decl %ebp
jne 0x1ff23
jmp 0x1ff5d
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a92
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0xf31a
cmpq $0x0, 0x8(%r15)
je 0x2043b
movl $0x1, %r13d
xorl %edx, %edx
xorl %r12d, %r12d
movq (%r15), %rax
movzbl (%rax,%rdx), %ecx
cmpl $0x2e, %ecx
je 0x203fd
cmpl $0x2f, %ecx
je 0x203f9
movb $0x1, %al
cmpl $0x7c, %ecx
je 0x20428
movl $0x1, %ecx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5480
movq %rbp, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x16b6e
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x203e8
callq 0x5410
shll $0x19, %ebp
addl $0x2000000, %ebp        # imm = 0x2000000
shrl $0x18, %ebp
orb %r12b, %bpl
jmp 0x20400
xorl %eax, %eax
jmp 0x20428
movb $-0x80, %bpl
movb %bpl, 0x8(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x20418
movb %bpl, (%rsi)
incq 0x8(%r14)
jmp 0x20425
movq %r14, %rdi
leaq 0x8(%rsp), %rdx
callq 0x21a92
movl %r12d, %eax
movl %r13d, %edx
incl %r13d
movl %eax, %r12d
cmpq %rdx, 0x8(%r15)
ja 0x20398
movq (%r14), %rcx
movq 0x8(%r14), %rax
movl %eax, %edx
subl %ecx, %edx
cmpl %ebx, %edx
jge 0x2047a
addl %ecx, %ebx
subl %eax, %ebx
leaq 0x8(%rsp), %r15
movb $-0x7f, 0x8(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x2046b
movb $-0x7f, (%rsi)
incq 0x8(%r14)
jmp 0x20476
movq %r14, %rdi
movq %r15, %rdx
callq 0x21a92
decl %ebx
jne 0x20453
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x204a0
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0xf31a
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf31a
movl (%r12), %eax
cmpl $0xe, %eax
ja 0x2122b
shll $0x4, %eax
jmp 0x21249
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1fd74
movl $0xf, %eax
orl (%r14), %eax
movb %al, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x21262
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x2126f
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a92
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x1be7e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x21294
callq 0x5410
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x212a6
jmp 0x212a6
jmp 0x212a6
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x212b8
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry.cpp
// Function: entry::get_type(unsigned int*, std::vector<char, std::allocator<char>> const&, unsigned int&, unsigned int&)
void entry::get_type(unsigned int * line_position, const vector<char>& line, unsigned int &type, unsigned int &size)
{
	uint8_t byte = *reinterpret_cast<const uint8_t*>(&line[*line_position]);
	*line_position += sizeof(byte);
	size = byte >> 4;
	type = (byte & (uint8_t)15);

	if (size == 15)
	{
		int type2;
		byte = *reinterpret_cast<const uint8_t*>(&line[*line_position]);
		*line_position += sizeof(byte);

		type2 = (byte & (uint8_t)15);
		if (type2 == 1)
		{
			int8_t tmp;
			tmp = *reinterpret_cast<const int8_t*>(&line[*line_position]);
			*line_position += sizeof(tmp);
			size = (unsigned int)tmp;
		}
		else if (type2 == 2)
		{
			int16_t tmp;
			tmp = *reinterpret_cast<const int16_t*>(&line[*line_position]);
			*line_position += sizeof(tmp);

			size = (int)tmp;
		}
		else if (type2 == 3)
		{
			int32_t tmp;
			tmp = *reinterpret_cast<const int32_t*>(&line[*line_position]);
			*line_position += sizeof(tmp);
			size = (unsigned int)tmp;
		}
		else
		{
			LOG.printLOG("Error: Invalid type for integer size.\n");
			exit(0);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl (%rsi), %edi
movq (%rdx), %rax
movzbl (%rax,%rdi), %edx
incl %edi
movl %edi, (%rsi)
movl %edx, %edi
shrl $0x4, %edi
movl %edi, (%r8)
andl $0xf, %edx
movl %edx, (%rcx)
cmpl $0xf, (%r8)
jne 0x21599
movl (%rsi), %ecx
movzbl (%rax,%rcx), %edi
leal 0x1(%rcx), %edx
movl %edx, (%rsi)
andl $0xf, %edi
cmpl $0x3, %edi
je 0x2158c
cmpl $0x2, %edi
je 0x21581
cmpl $0x1, %edi
jne 0x215a1
movl %edx, %edx
movsbl (%rax,%rdx), %eax
addl $0x2, %ecx
jmp 0x21594
movl %edx, %edx
movswl (%rax,%rdx), %eax
addl $0x3, %ecx
jmp 0x21594
movl %edx, %edx
movl (%rax,%rdx), %eax
addl $0x5, %ecx
movl %ecx, (%rsi)
movl %eax, (%r8)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18e45(%rip), %rsi     # 0x3a3f6
leaq 0x18e64(%rip), %rdx     # 0x3a41c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc868
leaq 0x28edc(%rip), %rdi     # 0x4a4a8
movq %rbx, %rsi
callq 0x371c8
leaq 0x8(%rsp), %rdi
callq 0x58b0
xorl %edi, %edi
callq 0x5540
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x215f7
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry.cpp
// Function: entry::get_typed_int(unsigned int*, std::vector<char, std::allocator<char>> const&, unsigned int&, unsigned int&)
int entry::get_typed_int(unsigned int * line_position, const vector<char>& line, unsigned int &type, unsigned int &size)
{
	int out;

	get_type( line_position, line, type, size );

	if (size > 1)
	{
		LOG.printLOG("Error: Int vector when expected only a single Integer value.\n" );
		exit(0);
	}

	if (type == 1)
	{
		int8_t tmp;
		tmp = *reinterpret_cast<const int8_t*>(&line[*line_position]);
		*line_position += sizeof(tmp);
		out = tmp;
	}
	else if (type == 2)
	{
		int16_t tmp;
		tmp = *reinterpret_cast<const int16_t*>(&line[*line_position]);
		*line_position += sizeof(tmp);
		out = tmp;
	}
	else if (type == 3)
	{
		int32_t tmp;
		tmp = *reinterpret_cast<const int32_t*>(&line[*line_position]);
		*line_position += sizeof(tmp);
		out = tmp;
	}
	else
	{
		LOG.printLOG("Error: Invalid type for integer size.\n");
		exit(0);
	}
	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
callq 0x21532
cmpl $0x2, (%r12)
jae 0x21669
movl (%r15), %eax
cmpl $0x3, %eax
je 0x21650
cmpl $0x2, %eax
je 0x21642
cmpl $0x1, %eax
jne 0x216a3
movl (%rbx), %ecx
movq (%r14), %rax
movsbl (%rax,%rcx), %eax
incl %ecx
jmp 0x2165b
movl (%rbx), %ecx
movq (%r14), %rax
movswl (%rax,%rcx), %eax
addl $0x2, %ecx
jmp 0x2165b
movl (%rbx), %ecx
movq (%r14), %rax
movl (%rax,%rcx), %eax
addl $0x4, %ecx
movl %ecx, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18d3f(%rip), %rsi     # 0x3a3b8
leaq 0x18d75(%rip), %rdx     # 0x3a3f5
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xc868
leaq 0x28e14(%rip), %rdi     # 0x4a4a8
movq %rbx, %rsi
callq 0x371c8
leaq 0x28(%rsp), %rdi
jmp 0x216db
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18d43(%rip), %rsi     # 0x3a3f6
leaq 0x18d62(%rip), %rdx     # 0x3a41c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc868
leaq 0x28dda(%rip), %rdi     # 0x4a4a8
movq %rbx, %rsi
callq 0x371c8
leaq 0x8(%rsp), %rdi
callq 0x58b0
xorl %edi, %edi
callq 0x5540
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x216f9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x21703
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry.cpp
// Function: entry::get_int_vector(unsigned int*, std::vector<char, std::allocator<char>> const&)
vector<int> entry::get_int_vector(unsigned int * line_position, const vector<char>& line)
{
	unsigned int size, type;
	get_type( line_position, line, type, size );
	vector<int> out(size);
	if (type == 1)
	{
		int8_t tmp;
		for (unsigned int ui=0; ui<size; ui++)
		{
			tmp = *reinterpret_cast<const int8_t*>(&line[*line_position]);
			*line_position += sizeof(tmp);
			out[ui] = tmp;
		}
	}
	else if (type == 2)
	{
		int16_t tmp;
		for (unsigned int ui=0; ui<size; ui++)
		{
			tmp = *reinterpret_cast<const int16_t*>(&line[*line_position]);
			*line_position += sizeof(tmp);
			out[ui] = tmp;
		}
	}
	else if (type == 3)
	{
		int32_t tmp;
		for (unsigned int ui=0; ui<size; ui++)
		{
			tmp = *reinterpret_cast<const int32_t*>(&line[*line_position]);
			*line_position += sizeof(tmp);
			out[ui] = tmp;
		}
	}
	else
	{
		LOG.printLOG("Error: Invalid type for integer size.\n");
		exit(0);
	}
	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
leaq 0xc(%rsp), %r15
movq %rdx, %rsi
movq %rcx, %rdx
movq %r13, %rcx
movq %r15, %r8
callq 0x21532
movl (%r15), %r15d
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba90
movl (%r13), %eax
cmpl $0x1, %eax
je 0x217b6
cmpl $0x2, %eax
je 0x2178e
cmpl $0x3, %eax
jne 0x217ec
testq %r15, %r15
je 0x217db
movq (%r12), %rax
movq (%rbx), %rcx
xorl %edx, %edx
movl (%r14), %esi
movl (%rax,%rsi), %edi
addl $0x4, %esi
movl %esi, (%r14)
movl %edi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x21775
jmp 0x217db
testq %r15, %r15
je 0x217db
movq (%r12), %rax
movq (%rbx), %rcx
xorl %edx, %edx
movl (%r14), %esi
movswl (%rax,%rsi), %edi
addl $0x2, %esi
movl %esi, (%r14)
movl %edi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x2179c
jmp 0x217db
testq %r15, %r15
je 0x217db
movq (%r12), %rax
movq (%rbx), %rcx
xorl %edx, %edx
movl (%r14), %esi
movsbl (%rax,%rsi), %edi
incl %esi
movl %esi, (%r14)
movl %edi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x217c4
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18bfa(%rip), %rsi     # 0x3a3f6
leaq 0x18c19(%rip), %rdx     # 0x3a41c
leaq 0x10(%rsp), %rdi
callq 0xc868
leaq 0x28c94(%rip), %rdi     # 0x4a4a8
leaq 0x10(%rsp), %rsi
callq 0x371c8
leaq 0x10(%rsp), %rdi
callq 0x58b0
xorl %edi, %edi
callq 0x5540
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x21846
callq 0x5410
jmp 0x21846
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x21853
callq 0x5410
movq %r14, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4(%rsp), %r14
movq %rsp, %r8
movq %r14, %rcx
callq 0x21532
movl (%r14), %eax
decl %eax
cmpl $0x6, %eax
ja 0x218a5
leaq 0x18a50(%rip), %rcx     # 0x3a2d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rbx), %eax
addl (%rsp), %eax
jmp 0x218a3
movl (%rsp), %eax
shll $0x2, %eax
jmp 0x218a1
movl (%rsp), %eax
addl %eax, %eax
addl (%rbx), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_REF[abi:cxx11]() const
string entry::get_REF() const
{
	if (REF == "")
		return ".";
	else
		return REF;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x428(%rsi), %rdi
leaq 0x1919d(%rip), %rsi     # 0x3aeff
callq 0x50e0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x21d8d
movq 0x428(%r14), %rsi
movq 0x430(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xc7d8
jmp 0x21da3
leaq 0x18479(%rip), %rsi     # 0x3a20d
leaq 0x18473(%rip), %rdx     # 0x3a20e
movq %rbx, %rdi
callq 0xc868
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x3da(%rsi)
je 0x21ee6
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x448(%rsi), %rdi
movq 0x450(%rsi), %rax
cmpq %rax, %rdi
je 0x21eb5
subq %rdi, %rax
cmpq $0x20, %rax
jne 0x21e1a
leaq 0x190f2(%rip), %rsi     # 0x3aeff
callq 0x50e0
testl %eax, %eax
je 0x21eb9
movq 0x448(%r14), %rsi
movq %rbx, %rdi
callq 0x51f0
movq 0x448(%r14), %rax
movq 0x450(%r14), %rcx
subq %rax, %rcx
cmpq $0x21, %rcx
jb 0x21ed4
movl $0x1, %edx
movl $0x2, %r13d
leaq 0x18(%rsp), %rbp
leaq 0x17e4f(%rip), %r15     # 0x39caa
leaq 0x8(%rsp), %r12
shlq $0x5, %rdx
addq %rax, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xb7dd
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50f0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x21e93
callq 0x5410
movl %r13d, %edx
movq 0x448(%r14), %rax
movq 0x450(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %r13d
cmpq %rdx, %rcx
ja 0x21e60
jmp 0x21ed4
xorl %edx, %edx
jmp 0x21ebd
movq 0x8(%rbx), %rdx
leaq 0x18349(%rip), %rcx     # 0x3a20d
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5690
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18530(%rip), %rdi     # 0x3a41d
leaq 0x1853c(%rip), %rsi     # 0x3a430
leaq 0x18547(%rip), %rcx     # 0x3a442
movl $0x2d, %edx
callq 0x5280
jmp 0x21f07
movq %rax, %r14
jmp 0x21f1e
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x21f1e
callq 0x5410
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x21f2c
callq 0x5410
movq %r14, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
cmpb $0x0, 0x3da(%rdi)
je 0x21f8f
cmpq $0x1, 0x430(%rdi)
jne 0x21f8b
movq 0x448(%rdi), %rcx
movq 0x450(%rdi), %rdx
cmpq %rdx, %rcx
je 0x21f8b
cmpq $0x1, 0x8(%rcx)
jne 0x21f8b
subq %rcx, %rdx
sarq $0x5, %rdx
movl $0x1, %esi
movl %esi, %esi
cmpq %rsi, %rdx
setbe %al
jbe 0x21f8d
movq %rsi, %rdi
shlq $0x5, %rdi
incl %esi
cmpq $0x1, 0x8(%rcx,%rdi)
je 0x21f6e
jmp 0x21f8d
xorl %eax, %eax
popq %rcx
retq
leaq 0x18487(%rip), %rdi     # 0x3a41d
leaq 0x18493(%rip), %rsi     # 0x3a430
leaq 0x184bc(%rip), %rcx     # 0x3a460
movl $0x3f, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x0, 0x3da(%rdi)
je 0x21fe4
cmpq $0x1, 0x430(%rdi)
jne 0x21fe1
movq 0x448(%rdi), %rax
movq 0x450(%rdi), %rcx
subq %rax, %rcx
cmpq $0x20, %rcx
jne 0x21fe1
cmpq $0x1, 0x8(%rax)
sete %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x18431(%rip), %rdi     # 0x3a41d
leaq 0x1843d(%rip), %rsi     # 0x3a430
leaq 0x18481(%rip), %rcx     # 0x3a47b
movl $0x50, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movl 0x8(%rdi), %edx
testq %rdx, %rdx
sete %al
je 0x22065
movq 0x1f0(%rdi), %rsi
movq 0x218(%rdi), %r8
movq 0x560(%rdi), %r9
movq 0x4e8(%rdi), %rdi
xorl %ecx, %ecx
movl $0x1, %r10d
shlq %cl, %r10
movq %rcx, %r11
shrq $0x6, %r11
movq (%rsi,%r11,8), %rbx
btq %rcx, %rbx
jae 0x2205a
testq %r10, (%r8,%r11,8)
je 0x2205a
testq %r10, (%r9,%r11,8)
je 0x22069
cmpl $0x2, (%rdi,%rcx,4)
jne 0x22065
incq %rcx
cmpq %rdx, %rcx
setae %al
jne 0x2202e
andb $0x1, %al
popq %rbx
retq
leaq 0x18430(%rip), %rdi     # 0x3a4a0
leaq 0x183b9(%rip), %rsi     # 0x3a430
leaq 0x18438(%rip), %rcx     # 0x3a4b6
movl $0x64, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x0, 0x3da(%rdi)
je 0x22121
movq %rdi, %rax
testl %esi, %esi
je 0x220c1
cmpl $-0x1, %esi
je 0x22103
cmpl $-0x2, %esi
jne 0x220d2
movq 0x8(%rdx), %rax
leaq 0x18e4e(%rip), %rcx     # 0x3aeff
movq %rdx, %rdi
xorl %esi, %esi
movq %rax, %rdx
xorl %r8d, %r8d
jmp 0x5690
addq $0x428, %rax            # imm = 0x428
movq %rdx, %rdi
movq %rax, %rsi
jmp 0x51f0
decl %esi
movq 0x448(%rax), %rcx
movq 0x450(%rax), %rax
subq %rcx, %rax
sarq $0x5, %rax
cmpq %rsi, %rax
jbe 0x22103
movslq %esi, %rax
shlq $0x5, %rax
addq %rax, %rcx
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0x51f0
movq 0x8(%rdx), %rax
leaq 0x180ff(%rip), %rcx     # 0x3a20d
movl $0x1, %r8d
movq %rdx, %rdi
xorl %esi, %esi
movq %rax, %rdx
jmp 0x5690
pushq %rax
leaq 0x182f4(%rip), %rdi     # 0x3a41d
leaq 0x18300(%rip), %rsi     # 0x3a430
leaq 0x1839e(%rip), %rcx     # 0x3a4d5
movl $0x6e, %edx
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
cmpb $0x0, 0x3da(%rsi)
je 0x221f8
movq %rdi, %rbx
testl %edx, %edx
je 0x22172
cmpl $-0x2, %edx
jne 0x22192
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x18d95(%rip), %rdx     # 0x3aeff
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x221ee
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x428(%rsi), %rax
movq 0x430(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x221cf
testl %edx, %edx
js 0x221d6
decl %edx
movq 0x448(%rsi), %rax
movq 0x450(%rsi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rdx, %rcx
jbe 0x221d6
movslq %edx, %rcx
shlq $0x5, %rcx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xc7d8
jmp 0x221f3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x18029(%rip), %rsi     # 0x3a20d
leaq 0x18023(%rip), %rdx     # 0x3a20e
movq %rbx, %rdi
callq 0xc868
movq %rbx, %rax
popq %rbx
retq
leaq 0x1821e(%rip), %rdi     # 0x3a41d
leaq 0x1822a(%rip), %rsi     # 0x3a430
leaq 0x182f4(%rip), %rcx     # 0x3a501
movl $0x7c, %edx
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
cmpb $0x0, 0x3da(%rsi)
je 0x222ab
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x22289
cmpl $-0x2, %edx
jne 0x22249
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x18cbe(%rip), %rdx     # 0x3aeff
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x222a1
movl %edx, %ecx
movq 0x448(%rsi), %rax
movq 0x450(%rsi), %rsi
subq %rax, %rsi
sarq $0x5, %rsi
cmpq %rcx, %rsi
jbe 0x22289
movslq %edx, %rcx
shlq $0x5, %rcx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xc7d8
jmp 0x222a6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x17f76(%rip), %rsi     # 0x3a20d
leaq 0x17f70(%rip), %rdx     # 0x3a20e
movq %rbx, %rdi
callq 0xc868
movq %rbx, %rax
popq %rbx
retq
leaq 0x1816b(%rip), %rdi     # 0x3a41d
leaq 0x18177(%rip), %rsi     # 0x3a430
leaq 0x18265(%rip), %rcx     # 0x3a525
movl $0x8a, %edx
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x3da(%rdi)
je 0x22350
movq %rsi, %r14
movq %rdi, %r15
movq 0x450(%rdi), %rsi
subq 0x448(%rdi), %rsi
sarq $0x5, %rsi
incq %rsi
movq %r14, %rdi
callq 0x1300a
leaq 0x428(%r15), %rsi
movq (%r14), %rdi
callq 0x51f0
movq 0x448(%r15), %rbx
movq 0x450(%r15), %r15
subq %rbx, %r15
sarq $0x5, %r15
testq %r15, %r15
jle 0x2234a
movq (%r14), %r14
incq %r15
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51f0
addq $0x20, %rbx
decq %r15
addq $0x20, %r14
cmpq $0x1, %r15
jg 0x2232e
popq %rbx
popq %r14
popq %r15
retq
leaq 0x180c6(%rip), %rdi     # 0x3a41d
leaq 0x180d2(%rip), %rsi     # 0x3a430
leaq 0x181e8(%rip), %rcx     # 0x3a54d
movl $0x95, %edx
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
cmpb $0x0, 0x3db(%rsi)
je 0x2248b
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x55d0
movq 0x468(%r14), %rax
cmpq 0x470(%r14), %rax
je 0x2243c
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rsp, %rdi
callq 0x54f0
movq 0x470(%r14), %rax
subq 0x468(%r14), %rax
cmpq $0x21, %rax
jb 0x22450
movl $0x1, %r13d
movl $0x2, %ebp
leaq 0x181cc(%rip), %r15     # 0x3a5bb
movq %rsp, %r12
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f0
movq 0x468(%r14), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %r12, %rdi
callq 0x54f0
movq 0x470(%r14), %rax
subq 0x468(%r14), %rax
movl %ebp, %r13d
sarq $0x5, %rax
incl %ebp
cmpq %r13, %rax
ja 0x223f2
jmp 0x22450
leaq 0x17dca(%rip), %rsi     # 0x3a20d
movq %rsp, %rdi
movl $0x1, %edx
callq 0x54f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56c0
movq 0x27b5c(%rip), %rsi     # 0x49fc0
movq %rsp, %rdi
callq 0x51e0
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x180f2(%rip), %rdi     # 0x3a584
leaq 0x17f97(%rip), %rsi     # 0x3a430
leaq 0x180fa(%rip), %rcx     # 0x3a59a
movl $0xa2, %edx
callq 0x5280
jmp 0x224ac
movq %rax, %rbx
movq 0x27b0a(%rip), %rsi     # 0x49fc0
movq %rsp, %rdi
callq 0x51e0
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_INFO_vector(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&, bool) const
vector<pair<string, string> > entry::get_INFO_vector(const set<string> &INFO_to_keep, bool keep_all_INFO) const
{
	assert(parsed_INFO == true);

	vector<pair<string, string> > out_vector;
	if (keep_all_INFO == true)
		return INFO;

	if ( (!INFO.empty()) && (!INFO_to_keep.empty()) )
	{
		string key;
		for (unsigned int ui=0; ui<INFO.size();ui++)
		{
			key = INFO[ui].first;
			if ( keep_all_INFO or (INFO_to_keep.find(key) != INFO_to_keep.end() ) )
				out_vector.push_back( INFO[ui] );
		}
	}

	return out_vector;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x3dc(%rsi)
je 0x2294d
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
addq $0x480, %rsi            # imm = 0x480
testb %cl, %cl
je 0x22847
movq %rbx, %rdi
callq 0x23928
jmp 0x22933
movq 0x480(%r15), %rax
cmpq 0x488(%r15), %rax
je 0x22913
movq %rdx, %r14
cmpq $0x0, 0x28(%rdx)
je 0x22913
movq %rsi, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x480(%r15), %rsi
cmpq %rsi, 0x488(%r15)
je 0x228fa
leaq 0x8(%r14), %rbx
movl $0x1, %r12d
xorl %ebp, %ebp
leaq 0x28(%rsp), %r13
shlq $0x6, %rbp
addq %rbp, %rsi
movq %r13, %rdi
callq 0x51f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x1b9c2
cmpq %rbx, %rax
je 0x228da
movq 0x20(%rsp), %rax
addq (%rax), %rbp
movq %rsp, %rdi
movq %rbp, %rsi
callq 0x239ac
movl %r12d, %ebp
movq 0x480(%r15), %rsi
movq 0x488(%r15), %rax
subq %rsi, %rax
sarq $0x6, %rax
incl %r12d
cmpq %rbp, %rax
ja 0x228a8
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2290e
callq 0x5410
movq 0x18(%rsp), %rbx
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rsp, %rdi
callq 0x1b4a6
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17c9f(%rip), %rdi     # 0x3a5f3
leaq 0x17ad5(%rip), %rsi     # 0x3a430
leaq 0x17cdd(%rip), %rcx     # 0x3a63f
movl $0xdb, %edx
callq 0x5280
movq %rax, %rbx
jmp 0x2298a
jmp 0x22973
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2298a
callq 0x5410
movq %rsp, %rdi
callq 0x1b4a6
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x3dc(%rsi)
jne 0x22a80
movq 0x480(%rsi), %r15
movq 0x488(%rsi), %r12
subq %r15, %r12
setne %bpl
je 0x22a4c
sarq $0x6, %r12
movq (%rdx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdx), %rbx
movl $0x1, %r14d
xorl %r13d, %r13d
shlq $0x6, %r13
movq 0x8(%r15,%r13), %rdx
cmpq %rbx, %rdx
jne 0x22a12
addq %r15, %r13
testq %rdx, %rdx
je 0x22a23
movq (%r13), %rdi
movq 0x10(%rsp), %rsi
callq 0x5470
testl %eax, %eax
je 0x22a23
movl %r14d, %r13d
incl %r14d
cmpq %r13, %r12
seta %bpl
ja 0x229ea
jmp 0x22a4c
movq 0x8(%rsp), %rdi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
addq %rsi, %rdx
callq 0xc7d8
testb $0x1, %bpl
je 0x22a4c
movq 0x8(%rsp), %rax
jmp 0x22a71
movq 0x8(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x18e11(%rip), %rsi     # 0x3b870
leaq 0x18e0b(%rip), %rdx     # 0x3b871
movq %rbx, %rdi
callq 0xc868
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17b6c(%rip), %rdi     # 0x3a5f3
leaq 0x179a2(%rip), %rsi     # 0x3a430
leaq 0x17bff(%rip), %rcx     # 0x3a694
movl $0xf1, %edx
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rdi
callq 0x2299a
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x5550
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x22af5
callq 0x5410
leaq 0x18d74(%rip), %rsi     # 0x3b870
movq %rsp, %rdi
callq 0x50e0
testl %eax, %eax
je 0x22b18
movq %rsp, %rdi
movl $0x2c, %esi
movq %rbx, %rdx
callq 0x16a7e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x22b26
callq 0x5410
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x22b35
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x22b46
callq 0x5410
movq %rbx, %rdi
callq 0xc4f0
movq %r14, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, 0x3dd(%rsi)
je 0x22c03
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x4a0(%rsi), %rax
cmpq 0x498(%rsi), %rax
je 0x22bf1
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0x1850f(%rip), %r15     # 0x3b0b5
xorl %eax, %eax
testb $0x1, %al
je 0x22bb7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5870
movq 0x498(%r14), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x50f0
movl %ebp, %r13d
movq 0x4a0(%r14), %rcx
subq 0x498(%r14), %rcx
sarq $0x5, %rcx
incl %ebp
movb $0x1, %al
cmpq %r13, %rcx
ja 0x22ba8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17abd(%rip), %rdi     # 0x3a6c7
leaq 0x1781f(%rip), %rsi     # 0x3a430
leaq 0x17ac5(%rip), %rcx     # 0x3a6dd
movl $0x108, %edx            # imm = 0x108
callq 0x5280
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x22c32
callq 0x5410
movq %r14, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x560(%rdi), %rax
movl %esi, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %rsi, %rax
jae 0x22d60
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r12d
movb 0x281ec(%rip), %al      # 0x4ae98
testb %al, %al
je 0x22d7f
movb 0x28206(%rip), %al      # 0x4aec0
testb %al, %al
je 0x22d89
movq 0x4d0(%r14), %rax
movl (%rax,%r12,8), %esi
leaq 0x281a4(%rip), %r15     # 0x4ae78
movq %r14, %rdi
movq %r15, %rdx
callq 0x22088
movq 0x4d0(%r14), %rax
movl 0x4(%rax,%r12,8), %esi
leaq 0x281ae(%rip), %r12     # 0x4aea0
movq %r14, %rdi
movq %r12, %rdx
callq 0x22088
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x23c1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5550
leaq 0x28(%rsp), %r14
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5550
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x22d41
callq 0x5410
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22d54
callq 0x5410
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x179e8(%rip), %rdi     # 0x3a74f
leaq 0x176c2(%rip), %rsi     # 0x3a430
leaq 0x179f2(%rip), %rcx     # 0x3a767
movl $0x11f, %edx            # imm = 0x11F
callq 0x5280
callq 0x5c51
jmp 0x22cb4
callq 0x5ca8
jmp 0x22cc2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5d8(%rdi), %rax
movl %esi, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %rsi, %rax
jae 0x23048
movq %rdx, %rbx
movq %rdi, %r14
movq 0x548(%rdi), %rax
cmpq 0x550(%rdi), %rax
je 0x2301f
movl %esi, %r15d
leaq (%r15,%r15,2), %r12
movq 0x8(%rax,%r12,8), %rcx
cmpq (%rax,%r12,8), %rcx
je 0x2301f
movq 0x8(%rbx), %rdx
leaq 0x17f73(%rip), %rcx     # 0x3aeff
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5690
movq 0x548(%r14), %rax
movq 0x8(%rax,%r12,8), %rcx
cmpq (%rax,%r12,8), %rcx
je 0x23010
movl $0x1, %ebp
xorl %r13d, %r13d
shlq $0x3, %r15
leaq (%r15,%r15,2), %r12
leaq 0x175f9(%rip), %r15     # 0x3a5bb
cmpl $0x1, %ebp
je 0x22fd2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5870
movq 0x548(%r14), %rax
movq (%rax,%r12), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x50f0
movq 0x548(%r14), %rax
movq 0x8(%rax,%r12), %rcx
subq (%rax,%r12), %rcx
movl %ebp, %r13d
sarq $0x5, %rcx
incl %ebp
cmpq %r13, %rcx
ja 0x22fc2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdx
leaq 0x171e3(%rip), %rcx     # 0x3a20d
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5690
leaq 0x17873(%rip), %rdi     # 0x3a8c2
leaq 0x173da(%rip), %rsi     # 0x3a430
leaq 0x178c7(%rip), %rcx     # 0x3a924
movl $0x14f, %edx            # imm = 0x14F
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
cmpb $0x0, 0x3dd(%rdi)
je 0x230d4
movq %rdi, %rbx
addq $0x600, %rdi            # imm = 0x600
callq 0x1f7ca
addq $0x608, %rbx            # imm = 0x608
cmpq %rbx, %rax
setne %al
popq %rbx
retq
leaq 0x175ec(%rip), %rdi     # 0x3a6c7
leaq 0x1734e(%rip), %rsi     # 0x3a430
leaq 0x178bb(%rip), %rcx     # 0x3a9a4
movl $0x167, %edx            # imm = 0x167
callq 0x5280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
movl 0x8(%rdi), %edx
testq %rdx, %rdx
je 0x23181
movq 0x1f0(%rdi), %rsi
movq 0x560(%rdi), %r8
movq 0x4e8(%rdi), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl $0x1, %r9d
shlq %cl, %r9
movq %rcx, %r10
shrq $0x6, %r10
movq (%rsi,%r10,8), %r11
btq %rcx, %r11
jae 0x23177
testq %r9, (%r8,%r10,8)
je 0x23185
addl (%rdi,%rcx,4), %eax
incq %rcx
cmpq %rcx, %rdx
jne 0x23154
jmp 0x23183
xorl %eax, %eax
popq %rcx
retq
leaq 0x17314(%rip), %rdi     # 0x3a4a0
leaq 0x1729d(%rip), %rsi     # 0x3a430
leaq 0x17861(%rip), %rcx     # 0x3a9fb
movl $0x17b, %edx            # imm = 0x17B
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_allele_counts(std::vector<int, std::allocator<int>>&, unsigned int&, std::vector<bool, std::allocator<bool>> const&, std::vector<bool, std::allocator<bool>> const&) const
void entry::get_allele_counts(vector<int> &out, unsigned int &N_non_missing_chr_out, const vector<bool> &include_indv, const vector<bool> &include_genotype) const
{
	pair<int,int> genotype;
	vector<int> allele_counts(get_N_alleles(), 0);
	N_non_missing_chr_out = 0;

	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		//FILTERING BY INDIVIDUAL
		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
		{
			assert(parsed_GT[ui] == true);
			get_indv_GENOTYPE_ids(ui, genotype);

			if (genotype.first > -1)
			{
				allele_counts[genotype.first]++;
				N_non_missing_chr_out++;
			}
			if (genotype.second > -1)
			{
				allele_counts[genotype.second]++;
				N_non_missing_chr_out++;
			}
		}
	}
	out = allele_counts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq $0x0, 0x8(%rsp)
callq 0x230f4
movl %eax, %esi
xorl %ebx, %ebx
leaq 0x34(%rsp), %rdx
movl %ebx, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x239d8
movl %ebx, (%r12)
cmpl %ebx, 0x8(%r13)
je 0x2328d
xorl %ebp, %ebp
leaq 0x8(%rsp), %rbx
movq (%r15), %rdx
movl $0x1, %eax
movl %ebp, %ecx
shlq %cl, %rax
movq %rbp, %rcx
shrq $0x6, %rcx
movq (%rdx,%rcx,8), %rdx
btq %rbp, %rdx
jae 0x23281
movq (%r14), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x23281
movq 0x560(%r13), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x232ba
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x22d94
movslq 0x8(%rsp), %rax
testq %rax, %rax
js 0x2326b
movq 0x18(%rsp), %rcx
incl (%rcx,%rax,4)
incl (%r12)
movslq 0xc(%rsp), %rax
testq %rax, %rax
js 0x23281
movq 0x18(%rsp), %rcx
incl (%rcx,%rax,4)
incl (%r12)
incq %rbp
movl 0x8(%r13), %eax
cmpq %rax, %rbp
jb 0x23214
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x23b4c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x232ab
callq 0x5410
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x171df(%rip), %rdi     # 0x3a4a0
leaq 0x17168(%rip), %rsi     # 0x3a430
leaq 0x17752(%rip), %rcx     # 0x3aa21
movl $0x194, %edx            # imm = 0x194
callq 0x5280
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x232eb
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/entry_getters.cpp
// Function: entry::get_multiple_genotype_counts(std::vector<bool, std::allocator<bool>> const&, std::vector<bool, std::allocator<bool>> const&, std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&) const
void entry::get_multiple_genotype_counts(const vector<bool> &include_indv, const vector<bool> &include_genotype, vector<unsigned int> &out_N_hom, vector<unsigned int> &out_N_het) const
{
	out_N_hom.assign(ALT.size()+1, 0);
	out_N_het.assign(ALT.size()+1, 0);
	pair<int, int> genotype;

	for (unsigned int ui=0; ui<N_indv; ui++)
	{
		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
		{
			assert(parsed_GT[ui] == true);
			get_indv_GENOTYPE_ids(ui, genotype);

			for (int uj=0; uj<=(int)ALT.size(); uj++)
			{
				if ((genotype.first == uj) && (genotype.second == uj))
					out_N_hom[uj]++;
				else if (((genotype.first == uj) || (genotype.second == uj)) && (genotype.first != -1) && (genotype.second != -1))
					out_N_het[uj]++;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x450(%rdi), %rsi
subq 0x448(%rdi), %rsi
sarq $0x5, %rsi
incq %rsi
xorl %eax, %eax
leaq 0x8(%rsp), %rbp
movl %eax, (%rbp)
movq %rcx, %rdi
movq %rbp, %rdx
callq 0x23fa4
movq 0x450(%r13), %rsi
subq 0x448(%r13), %rsi
sarq $0x5, %rsi
incq %rsi
xorl %eax, %eax
movl %eax, (%rbp)
leaq 0x8(%rsp), %rbp
movq %r14, 0x10(%rsp)
movq %r14, %rdi
movq %rbx, %r14
movq %rbp, %rdx
callq 0x23fa4
movq $0x0, (%rbp)
xorl %eax, %eax
cmpl %eax, 0x8(%r13)
je 0x23658
xorl %ebp, %ebp
movq (%r12), %rdx
movl $0x1, %eax
movl %ebp, %ecx
shlq %cl, %rax
movq %rbp, %rcx
shrq $0x6, %rcx
movq (%rdx,%rcx,8), %rdx
btq %rbp, %rdx
jae 0x23648
movq (%r15), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x23648
movq 0x560(%r13), %rdx
testq %rax, (%rdx,%rcx,8)
je 0x23667
movq %r13, %rdi
movl %ebp, %esi
leaq 0x8(%rsp), %rdx
callq 0x22d94
movq 0x450(%r13), %rax
subq 0x448(%r13), %rax
btq $0x24, %rax
jb 0x23648
shrq $0x5, %rax
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpq %rsi, %rcx
sete %dil
cmpq %rsi, %rdx
sete %sil
orb %dil, %sil
movq 0x10(%rsp), %rdi
movq (%rdi), %rdi
movq (%r14), %r8
incl %eax
xorl %r9d, %r9d
movq %rcx, %r10
xorq %r9, %r10
movq %rdx, %r11
xorq %r9, %r11
orq %r10, %r11
movq %r8, %r10
jne 0x23622
incl (%r10,%r9,4)
incq %r9
cmpq %r9, %rax
jne 0x23600
jmp 0x23648
cmpq %r9, %rcx
jne 0x23631
movq %rdi, %r10
testb %sil, %sil
je 0x23614
jmp 0x23618
cmpq %r9, %rdx
sete %r11b
cmpl $-0x1, %ecx
setne %bl
movq %rdi, %r10
testb %r11b, %bl
jne 0x23614
jmp 0x23618
incq %rbp
movl 0x8(%r13), %eax
cmpq %rax, %rbp
jb 0x23569
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16e32(%rip), %rdi     # 0x3a4a0
leaq 0x16dbb(%rip), %rsi     # 0x3a430
leaq 0x174ec(%rip), %rcx     # 0x3ab68
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
movq %rbx, %rdi
callq 0xf31a
leaq 0x428(%r14), %r15
leaq 0x17807(%rip), %rsi     # 0x3aeff
movq %r15, %rdi
callq 0x50e0
xorl %ebp, %ebp
testl %eax, %eax
je 0x23733
leaq 0x16b00(%rip), %rsi     # 0x3a20d
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x23733
leaq 0x159ef(%rip), %rsi     # 0x3910f
movq %r15, %rdi
callq 0x50e0
testl %eax, %eax
je 0x23733
movl 0x430(%r14), %ebp
movq (%rbx), %rax
movl %ebp, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
movq %rbx, %rdi
callq 0xf31a
movl 0x450(%r14), %eax
subl 0x448(%r14), %eax
movq 0x488(%r14), %rcx
subq 0x480(%r14), %rcx
shrq $0x6, %rcx
subl 0x4c8(%r14), %ecx
andl $-0x20, %eax
shll $0xb, %eax
addl $0x10000, %eax          # imm = 0x10000
orl %ecx, %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq