LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x3d9(%rdi)
jne 0x1788e
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x3d8(%rdi)
jne 0x177f2
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
leaq 0x240(%rbx), %r14
leaq 0x718(%rbx), %r15
pushq $0x9
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5870
testb %bpl, %bpl
je 0x1781e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1dfb2
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
pushq $0x40
popq %rsi
callq 0x56e0
leaq 0x758(%rbx), %r15
movl 0x8(%rbx), %esi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x197f0
xorl %r12d, %r12d
pushq $0x9
popq %rbp
xorl %r13d, %r13d
movl 0x8(%rbx), %eax
cmpq %rax, %r13
jae 0x1787d
movq (%r15), %rsi
addq %r12, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x5870
incq %r13
addq $0x20, %r12
jmp 0x1785c
movb $0x1, 0x3d9(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x5908
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1789f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/vcf_entry.cpp
// Function: vcf_entry::read_indv_generic_entry(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void vcf_entry::read_indv_generic_entry(unsigned int indv, const string &FORMAT_id, string &out)
{
	if (fully_parsed == false)
		parse_full_entry(true);

	if (parsed_FORMAT == false)
		set_FORMAT(FORMAT_str);

	out = ".";

	if (FORMAT_to_idx.find(FORMAT_id) != FORMAT_to_idx.end())
	{
		unsigned int idx = FORMAT_to_idx[FORMAT_id];
		static string tmpstr;
		static istringstream ss;
		ss.clear();
		ss.str(GENOTYPE_str[indv]);

		for (unsigned int ui=0; ui <= idx; ui++)
		{
			getline(ss, tmpstr, ':');
			if (ui == idx)
			{
				out = tmpstr;
				break;
			}
			if (!ss.good())
				break;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x0, 0x3d9(%rdi)
jne 0x19620
movq (%r14), %rax
pushq $0x1
popq %rsi
movq %r14, %rdi
callq *0x18(%rax)
cmpb $0x0, 0x3dd(%r14)
jne 0x19639
leaq 0x718(%r14), %rsi
movq %r14, %rdi
callq 0x1dfb2
leaq 0x14aed(%rip), %rsi     # 0x2e12d
movq %rbx, %rdi
callq 0x58b0
leaq 0x600(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x19dea
leaq 0x608(%r14), %rcx
cmpq %rcx, %rax
je 0x196fb
movq %r12, %rdi
movq %r15, %rsi
callq 0x1634c
movl (%rax), %r12d
movb 0x28642(%rip), %al      # 0x41cc0
testb %al, %al
je 0x1971b
movb 0x287bc(%rip), %al      # 0x41e48
testb %al, %al
je 0x19777
movq 0x2862d(%rip), %rax     # 0x41cc8
leaq 0x28626(%rip), %r15     # 0x41cc8
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x5790
movl %ebp, %esi
shlq $0x5, %rsi
addq 0x758(%r14), %rsi
leaq 0x28614(%rip), %rdi     # 0x41cd8
callq 0x5690
incl %r12d
leaq 0x285cd(%rip), %r14     # 0x41ca0
pushq $0x3a
popq %rbp
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5870
decl %r12d
je 0x19704
movq 0x285d9(%rip), %rax     # 0x41cc8
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rax,%r15)
je 0x196d6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28595(%rip), %rsi     # 0x41ca0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5210
leaq 0x2859e(%rip), %rdi     # 0x41cc0
callq 0x5850
testl %eax, %eax
je 0x19686
leaq 0x2857a(%rip), %rax     # 0x41cb0
movq %rax, 0x28563(%rip)     # 0x41ca0
leaq 0x2855c(%rip), %rsi     # 0x41ca0
andq $0x0, 0x2855c(%rip)     # 0x41ca8
movb $0x0, 0x2855d(%rip)     # 0x41cb0
movq 0x2784e(%rip), %rdi     # 0x40fa8
leaq 0x27d1f(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x28553(%rip), %rdi     # 0x41cc0
callq 0x5290
jmp 0x19686
leaq 0x286ca(%rip), %rdi     # 0x41e48
callq 0x5850
testl %eax, %eax
je 0x19694
leaq 0x28536(%rip), %rdi     # 0x41cc8
callq 0x5330
movq 0x27812(%rip), %rdi     # 0x40fb0
leaq 0x28523(%rip), %rsi     # 0x41cc8
leaq 0x27cd4(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x28690(%rip), %rdi     # 0x41e48
callq 0x5290
jmp 0x19694
movq %rax, %rbx
leaq 0x2867c(%rip), %rdi     # 0x41e48
callq 0x5270
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/entry.cpp
// Function: entry::make_typed_string(std::vector<char, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void entry::make_typed_string(vector<char> &out, const string &in, bool typed)
{
	vector<char> tmp_vector;
	out.resize(0);

	if (in == "." or in == " " or in == "")
	{
		if (typed == false)
			return;

		int8_t tmp = (int8_t)0;
		tmp = tmp << 4;
		tmp = tmp | (int8_t)7;
		out.push_back( tmp );

		return;
	}

	if (typed == true)
	{
		if (in.length() >= 15)
		{
			int8_t tmp = (int8_t)15;
			tmp = tmp << 4;
			tmp = tmp | (int8_t)7;
			out.push_back( tmp );

			make_typed_int(tmp_vector, in.length(), typed);
			out.insert( out.end(), tmp_vector.begin(), tmp_vector.end() );
		}
		else
		{
			int8_t tmp = (int8_t)in.length();
			tmp = tmp << 4;
			tmp = tmp | (int8_t)7;
			out.push_back( tmp );
		}
	}
	out.reserve(out.size()+in.size());
	copy(in.begin(), in.end(), back_inserter(out));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0xcc7c
leaq 0x13fcb(%rip), %rsi     # 0x2e12d
movq %r14, %rdi
callq 0x96f3
testb %al, %al
jne 0x1a194
leaq 0x12f4f(%rip), %rsi     # 0x2d0c4
movq %r14, %rdi
callq 0x96f3
testb %al, %al
jne 0x1a194
leaq 0x14caf(%rip), %rsi     # 0x2ee37
movq %r14, %rdi
callq 0x96f3
testb %al, %al
je 0x1a1b2
testb %bpl, %bpl
je 0x1a23d
leaq 0xc(%rsp), %rsi
movb $0x7, (%rsi)
movq %rbx, %rdi
callq 0x1ba5c
jmp 0x1a23d
testb %bpl, %bpl
je 0x1a218
movq 0x8(%r14), %rax
cmpq $0xf, %rax
jb 0x1a204
leaq 0xc(%rsp), %rsi
movb $-0x9, (%rsi)
movq %rbx, %rdi
callq 0x1ba5c
movl 0x8(%r14), %eax
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x1a272
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x163d4
jmp 0x1a218
shlb $0x4, %al
orb $0x7, %al
leaq 0xc(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x1ba5c
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
addq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x1b926
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
movq %rbx, %rdx
callq 0x1bb2c
leaq 0x10(%rsp), %rdi
callq 0xe88a
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a25c
jmp 0x1a25c
jmp 0x1a25c
jmp 0x1a25c
jmp 0x1a25c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe88a
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0xcc7c
movl (%r14), %eax
leal 0x7e(%rax), %ecx
addl $0x7ffe, %eax           # imm = 0x7FFE
cmpl $0xfffd, %eax           # imm = 0xFFFD
pushq $0x3
popq %rax
sbbl $0x0, %eax
cmpl $0xfd, %ecx
pushq $0x1
popq %r15
cmovael %eax, %r15d
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x1a330
testb %bpl, %bpl
je 0x1a2e9
orb $0x10, %r15b
leaq 0xf(%rsp), %rsi
movb %r15b, (%rsi)
movq %rbx, %rdi
callq 0x1ba5c
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x163d4
leaq 0x10(%rsp), %rdi
callq 0xe88a
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a31a
jmp 0x1a31a
jmp 0x1a31a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe88a
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xcc7c
movl (%r14), %r15d
cmpl $0x1, %ebp
je 0x1a3a2
cmpl $0x2, %ebp
jne 0x1a3dd
movl $0xffff8000, %eax       # imm = 0xFFFF8000
leal (%r15,%rax), %ecx
cmpl $0x80000001, %r15d      # imm = 0x80000001
pushq $0x1
popq %rbp
cmovnel %r15d, %ebp
cmpl $0x7fff8001, %ecx       # imm = 0x7FFF8001
cmovbl %eax, %ebp
pushq $0x2
popq %r15
leaq 0x6(%rsp), %r14
subl $0x1, %r15d
jb 0x1a3d2
movb %bpl, 0x6(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ba5c
shrl $0x8, %ebp
movsbl %bpl, %ebp
jmp 0x1a383
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
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x1ba5c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rbp
leaq 0x5(%rsp), %r14
subl $0x1, %ebp
jb 0x1a3d2
movb %r15b, 0x5(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ba5c
sarl $0x8, %r15d
jmp 0x1a3e5
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/entry.cpp
// Function: entry::make_typed_GT_vector(std::vector<char, std::allocator<char>>&, 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>>>>&)
void entry::make_typed_GT_vector(vector<char> &out, vector<string> &in )
{
	vector<char> tmp_vector;
	int8_t size_type;
	int max_ploidy = 0;
	out.resize(0);

	max_ploidy = *max_element(ploidy.begin(), ploidy.end());

	if (max_ploidy < 15)
	{
		size_type = (int8_t)max_ploidy;
		size_type = size_type << 4;
		size_type = size_type | (int8_t)1;

		out.push_back( size_type );
	}
	else
	{
		size_type = (int8_t)15;
		size_type = size_type << 4;
		size_type = size_type | (int8_t)1;

		out.push_back( size_type );

		make_typed_int(tmp_vector, max_ploidy, true);
		out.insert( out.end(), tmp_vector.begin(), tmp_vector.end() );
		tmp_vector.resize(0);
	}

	for (unsigned int ui=0; ui<in.size(); ui++)
	{
		encode_genotype(tmp_vector, in[ui], max_ploidy);
		out.insert( out.end(), tmp_vector.begin(), tmp_vector.end() );
		tmp_vector.resize(0);
	}
	out.insert( out.end(), tmp_vector.begin(), tmp_vector.end() );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0xcc7c
movq 0x4e8(%r15), %rdi
movq 0x4f0(%r15), %rsi
callq 0x1bc13
movl (%rax), %ebp
movl %ebp, 0x2c(%rsp)
cmpl $0xe, %ebp
jg 0x1a605
movl %ebp, %eax
shlb $0x4, %al
incb %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x1ba5c
jmp 0x1a64c
leaq 0xf(%rsp), %rsi
movb $-0xf, (%rsi)
movq %rbx, %rdi
callq 0x1ba5c
leaq 0x10(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x1a272
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x163d4
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xcc7c
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movl %r12d, %r12d
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x1a6a3
movq %r12, %rax
shlq $0x5, %rax
addq %rax, %rdx
movq %r15, %rsi
movl %ebp, %ecx
callq 0x1a6f4
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x163d4
movq %r15, %rdi
xorl %esi, %esi
callq 0xcc7c
incl %r12d
jmp 0x1a654
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x163d4
leaq 0x10(%rsp), %rdi
callq 0xe88a
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a6de
jmp 0x1a6de
jmp 0x1a6de
jmp 0x1a6de
jmp 0x1a6de
jmp 0x1a6de
jmp 0x1a6de
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe88a
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x4(%rsp)
movq %rdx, %r15
movq %rsi, %r14
xorl %r12d, %r12d
movq %rsi, %rdi
xorl %esi, %esi
callq 0xcc7c
leaq 0x8(%rsp), %rbx
xorl %r13d, %r13d
movl %r12d, %r12d
cmpq %r12, 0x8(%r15)
jbe 0x1a79c
movq (%r15), %rax
movzbl (%rax,%r12), %ecx
cmpl $0x2e, %ecx
je 0x1a77e
cmpl $0x2f, %ecx
je 0x1a77a
movb $0x1, %al
cmpl $0x7c, %ecx
je 0x1a794
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
pushq $0x1
popq %rcx
callq 0x54c0
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0x12782
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5908
shll $0x19, %ebp
addl $0x2000000, %ebp        # imm = 0x2000000
shrl $0x18, %ebp
orb %r13b, %bpl
jmp 0x1a781
xorl %eax, %eax
jmp 0x1a794
movb $-0x80, %bpl
movb %bpl, 0x8(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ba5c
movl %r13d, %eax
incl %r12d
movl %eax, %r13d
jmp 0x1a721
movl 0x8(%r14), %ebp
subl (%r14), %ebp
leaq 0x8(%rsp), %r15
movl 0x4(%rsp), %ebx
cmpl %ebx, %ebp
jge 0x1a7c4
movb $-0x7f, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ba5c
incl %ebp
jmp 0x1a7ac
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/entry.cpp
// Function: entry::make_typed_int_vector(std::vector<char, std::allocator<char>>&, std::vector<int, std::allocator<int>> const&)
void entry::make_typed_int_vector(vector<char> &out, const vector<int> &in )
{
	vector<char> tmp_char;
	int type;
	int8_t size_type;
	unsigned int max = 0;
	out.resize(0);

	for (unsigned int ui=0; ui<in.size(); ui++)
	{
		if ((abs(in[ui]) > (int)max) and ( (int8_t)in[ui] != (int8_t)0x80))
			max = abs(in[ui]);
	}

	if (max < 127)
		type = 1;
	else if (max < 32767)
		type = 2;
	else
		type = 3;

	if (in.size() < 15)
	{
		size_type = (int8_t)in.size();
		size_type = size_type << 4;
		size_type = size_type | (int8_t)type;

		out.push_back( size_type );
	}
	else
	{
		size_type = (int8_t)15;
		size_type = size_type << 4;
		size_type = size_type | (int8_t)type;

		out.push_back( size_type );

		make_typed_int(tmp_char, in.size(), true);
		out.insert( out.end(), tmp_char.begin(), tmp_char.begin() );
	}

	for (unsigned int ui=0; ui<in.size(); ui++)
	{
		make_int(tmp_char, in[ui], type);
		out.insert( out.end(), tmp_char.begin(), tmp_char.end() );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
xorl %r12d, %r12d
movq %rsi, %rdi
xorl %esi, %esi
callq 0xcc7c
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
sarq $0x2, %rax
xorl %edx, %edx
movl %r12d, %esi
cmpq %rsi, %rax
jbe 0x1ad69
movl (%rcx,%rsi,4), %edi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
cmpl %edx, %r8d
cmovlel %edx, %r8d
negb %dil
cmovnol %r8d, %edx
leal 0x1(%rsi), %r12d
jmp 0x1ad40
cmpl $0x7fff, %edx           # imm = 0x7FFF
pushq $0x3
popq %rcx
sbbl $0x0, %ecx
cmpl $0x7f, %edx
pushq $0x1
popq %rbp
cmovael %ecx, %ebp
cmpq $0xf, %rax
jae 0x1ad9a
shll $0x4, %eax
orl %ebp, %eax
leaq 0xc(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0x1ba5c
jmp 0x1ade3
movl %ebp, %eax
orb $-0x10, %al
leaq 0xc(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0x1ba5c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x1a272
movq 0x8(%r14), %rsi
movq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rcx, %rdx
callq 0x163d4
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movl %r12d, %r12d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x1ae2a
leaq (%rax,%r12,4), %rdx
movq %r15, %rsi
movl %ebp, %ecx
callq 0x1a330
movq 0x8(%r14), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %r14, %rdi
callq 0x163d4
incl %r12d
jmp 0x1adeb
leaq 0x10(%rsp), %rdi
callq 0xe88a
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ae4d
jmp 0x1ae4d
jmp 0x1ae4d
jmp 0x1ae4d
jmp 0x1ae4d
jmp 0x1ae4d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe88a
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0xcc7c
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcc7c
movl (%r12), %eax
cmpl $0xe, %eax
ja 0x1b2e2
shll $0x4, %eax
jmp 0x1b2fc
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x1a272
pushq $0xf
popq %rax
orl (%r14), %eax
leaq 0xc(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x1ba5c
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x163d4
leaq 0x10(%rsp), %rdi
callq 0xe88a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1b340
jmp 0x1b340
jmp 0x1b340
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe88a
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/entry.cpp
// Function: entry::get_typed_string[abi:cxx11](unsigned int*, std::vector<char, std::allocator<char>> const&)
string entry::get_typed_string(unsigned int * line_position, const vector<char>& line)
{
	unsigned int size, type;
	string out;

	get_type( line_position, line, type, size );
	if (type != 7)
	{
		LOG.printLOG("Error: Expected type 7 for string. Found type " + header::int2str(type) + ".\n");
	}

	char * tmp = new char[size];
	memcpy(tmp, &line[*line_position], size*sizeof(char));
	*line_position += size;
	out = string( tmp, size );

	if (out == "" or out == " ")
		out = ".";

	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsp, %rcx
leaq 0x4(%rsp), %r8
movq %rdx, %rsi
movq %r15, %rdx
callq 0x1b4ec
movl (%rsp), %esi
cmpl $0x7, %esi
je 0x1b400
leaq 0x28(%rsp), %rdi
pushq $-0x1
popq %rdx
callq 0x12c9c
leaq 0x12ef9(%rip), %rsi     # 0x2e2a5
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x98d5
leaq 0x12c5f(%rip), %rdx     # 0x2e021
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x98b6
leaq 0x260f8(%rip), %rdi     # 0x414d0
leaq 0x48(%rsp), %rsi
callq 0x2beca
leaq 0x48(%rsp), %rdi
callq 0x5908
leaq 0x8(%rsp), %rdi
callq 0x5908
leaq 0x28(%rsp), %rdi
callq 0x5908
movl 0x4(%rsp), %r12d
movq %r12, %rdi
callq 0x5030
movq %rax, %r13
movl (%r14), %ebp
movq %rbp, %rsi
addq (%r15), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x53b0
leal (%r12,%rbp), %eax
movl %eax, (%r14)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, %rdx
addq %r12, %rdx
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x1b9c6
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5580
movq %r14, %rdi
callq 0x5908
leaq 0x139d1(%rip), %rsi     # 0x2ee37
movq %rbx, %rdi
callq 0x96f3
testb %al, %al
jne 0x1b485
leaq 0x11c4b(%rip), %rsi     # 0x2d0c4
movq %rbx, %rdi
callq 0x96f3
testb %al, %al
je 0x1b494
leaq 0x12ca1(%rip), %rsi     # 0x2e12d
movq %rbx, %rdi
callq 0x58b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5908
jmp 0x1b4b8
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0x1b4c7
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5908
jmp 0x1b4dc
jmp 0x1b4d9
jmp 0x1b4d9
jmp 0x1b4d9
movq %rax, %r14
movq %rbx, %rdi
callq 0x5908
movq %r14, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %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 0x1b551
movl (%rsi), %ecx
movzbl (%rax,%rcx), %edi
leal 0x1(%rcx), %edx
movl %edx, (%rsi)
andl $0xf, %edi
cmpl $0x3, %edi
je 0x1b544
cmpl $0x2, %edi
je 0x1b539
cmpl $0x1, %edi
jne 0x1b557
movl %edx, %edx
movsbl (%rax,%rdx), %eax
addl $0x2, %ecx
jmp 0x1b54c
movl %edx, %edx
movswl (%rax,%rdx), %eax
addl $0x3, %ecx
jmp 0x1b54c
movl %edx, %edx
movl (%rax,%rdx), %eax
addl $0x5, %ecx
movl %ecx, (%rsi)
movl %eax, (%r8)
addq $0x30, %rsp
popq %rbx
retq
leaq 0x12db4(%rip), %rsi     # 0x2e312
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5160
leaq 0x25f59(%rip), %rdi     # 0x414d0
movq %rbx, %rsi
callq 0x2beca
leaq 0x10(%rsp), %rdi
callq 0x5908
xorl %edi, %edi
callq 0x5570
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b4ec
cmpl $0x2, (%r12)
jae 0x1b60f
movl (%r15), %eax
cmpl $0x3, %eax
je 0x1b5f6
cmpl $0x2, %eax
je 0x1b5e8
cmpl $0x1, %eax
jne 0x1b63d
movl (%rbx), %ecx
movq (%r14), %rax
movsbl (%rax,%rcx), %eax
incl %ecx
jmp 0x1b601
movl (%rbx), %ecx
movq (%r14), %rax
movswl (%rax,%rcx), %eax
addl $0x2, %ecx
jmp 0x1b601
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 0x12cbe(%rip), %rsi     # 0x2e2d4
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5160
leaq 0x25ea4(%rip), %rdi     # 0x414d0
leaq 0x28(%rsp), %rsi
callq 0x2beca
leaq 0x28(%rsp), %rdi
jmp 0x1b669
leaq 0x12cce(%rip), %rsi     # 0x2e312
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5160
leaq 0x25e76(%rip), %rdi     # 0x414d0
leaq 0x8(%rsp), %rsi
callq 0x2beca
leaq 0x8(%rsp), %rdi
callq 0x5908
xorl %edi, %edi
callq 0x5570
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x1b689
jmp 0x1b690
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5908
jmp 0x1b693
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b4ec
movl (%r15), %r15d
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x985c
movl (%r13), %eax
cmpl $0x1, %eax
je 0x1b738
cmpl $0x2, %eax
je 0x1b715
cmpl $0x3, %eax
jne 0x1b76b
movq (%r12), %rax
movq (%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x1b75a
movl (%r14), %esi
movl (%rax,%rsi), %edi
addl $0x4, %esi
movl %esi, (%r14)
movl %edi, (%rcx,%rdx,4)
incq %rdx
jmp 0x1b6fc
movq (%r12), %rax
movq (%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x1b75a
movl (%r14), %esi
movswl (%rax,%rsi), %edi
addl $0x2, %esi
movl %esi, (%r14)
movl %edi, (%rcx,%rdx,4)
incq %rdx
jmp 0x1b71e
movq (%r12), %rax
movq (%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x1b75a
movl (%r14), %esi
movsbl (%rax,%rsi), %edi
incl %esi
movl %esi, (%r14)
movl %edi, (%rcx,%rdx,4)
incq %rdx
jmp 0x1b741
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12ba0(%rip), %rsi     # 0x2e312
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5160
leaq 0x25d48(%rip), %rdi     # 0x414d0
leaq 0x10(%rsp), %rsi
callq 0x2beca
leaq 0x10(%rsp), %rdi
callq 0x5908
xorl %edi, %edi
callq 0x5570
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5908
jmp 0x1b7b5
movq %rax, %r14
movq %rbx, %rdi
callq 0xa18e
movq %r14, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b4ec
movl (%r14), %eax
decl %eax
cmpl $0x6, %eax
ja 0x1b80f
leaq 0x12a06(%rip), %rcx     # 0x2e1f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rbx), %eax
addl (%rsp), %eax
jmp 0x1b80d
movl (%rsp), %eax
shll $0x2, %eax
jmp 0x1b80b
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_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0x3da(%rsi)
je 0x1be01
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x448(%rsi), %rsi
movq 0x450(%r14), %rax
cmpq %rax, %rsi
je 0x1bd7a
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x1bda1
leaq 0x130cc(%rip), %rax     # 0x2ee37
movq %rsi, %rdi
movq %rax, %rsi
callq 0x96f3
testb %al, %al
je 0x1bd9a
leaq 0x123ac(%rip), %rsi     # 0x2e12d
movq %rbx, %rdi
callq 0x58b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x448(%r14), %rsi
movq %rbx, %rdi
callq 0x5210
pushq $0x1
popq %r13
leaq 0x11e18(%rip), %r15     # 0x2dbcc
movq %rsp, %r12
movl %r13d, %r13d
movq 0x448(%r14), %rdx
movq 0x450(%r14), %rax
subq %rdx, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x1bd89
movq %r13, %rax
shlq $0x5, %rax
addq %rax, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x967d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x58d0
movq %r12, %rdi
callq 0x5908
incl %r13d
jmp 0x1bdb7
leaq 0x1255b(%rip), %rdi     # 0x2e363
leaq 0x12567(%rip), %rsi     # 0x2e376
leaq 0x12572(%rip), %rcx     # 0x2e388
pushq $0x2d
popq %rdx
callq 0x52a0
jmp 0x1be20
movq %rax, %r14
jmp 0x1be30
movq %rax, %r14
movq %rsp, %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5908
movq %r14, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1be91
cmpq $0x1, 0x430(%rdi)
jne 0x1be8d
movq 0x448(%rdi), %rcx
movq 0x450(%rdi), %rdx
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x1be8d
subq %rcx, %rdx
sarq $0x5, %rdx
movl %esi, %esi
cmpq %rsi, %rdx
setbe %al
jbe 0x1be8f
movq %rsi, %rdi
shlq $0x5, %rdi
incl %esi
cmpq $0x1, 0x8(%rcx,%rdi)
je 0x1be70
jmp 0x1be8f
xorl %eax, %eax
popq %rcx
retq
leaq 0x124cb(%rip), %rdi     # 0x2e363
leaq 0x124d7(%rip), %rsi     # 0x2e376
leaq 0x12500(%rip), %rcx     # 0x2e3a6
pushq $0x3f
popq %rdx
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1bee4
cmpq $0x1, 0x430(%rdi)
jne 0x1bee1
movq 0x448(%rdi), %rax
movq 0x450(%rdi), %rcx
subq %rax, %rcx
cmpq $0x20, %rcx
jne 0x1bee1
cmpq $0x1, 0x8(%rax)
sete %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x12477(%rip), %rdi     # 0x2e363
leaq 0x12483(%rip), %rsi     # 0x2e376
leaq 0x124c7(%rip), %rcx     # 0x2e3c1
pushq $0x50
popq %rdx
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1f0(%rdi), %r14
leaq 0x218(%rdi), %r15
leaq 0x560(%rdi), %r13
xorl %r12d, %r12d
movl 0x8(%rbx), %ebp
cmpq %rbp, %r12
jae 0x1bf70
movq %r14, %rdi
movq %r12, %rsi
callq 0x9792
testb %al, %al
je 0x1bf6b
movq %r15, %rdi
movq %r12, %rsi
callq 0x9792
testb %al, %al
je 0x1bf6b
movq %r13, %rdi
movq %r12, %rsi
callq 0x9792
testb %al, %al
je 0x1bf85
movq 0x4e8(%rbx), %rax
cmpl $0x2, (%rax,%r12,4)
jne 0x1bf70
incq %r12
jmp 0x1bf28
cmpq %rbp, %r12
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1245a(%rip), %rdi     # 0x2e3e6
leaq 0x123e3(%rip), %rsi     # 0x2e376
leaq 0x12462(%rip), %rcx     # 0x2e3fc
pushq $0x64
popq %rdx
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c016
movq %rdi, %rax
testl %esi, %esi
je 0x1bfc5
cmpl $-0x1, %esi
je 0x1c007
cmpl $-0x2, %esi
jne 0x1bfd6
leaq 0x12e74(%rip), %rsi     # 0x2ee37
jmp 0x1c00e
addq $0x428, %rax            # imm = 0x428
movq %rdx, %rdi
movq %rax, %rsi
jmp 0x5210
decl %esi
movq 0x448(%rax), %rcx
movq 0x450(%rax), %rax
subq %rcx, %rax
sarq $0x5, %rax
cmpq %rsi, %rax
jbe 0x1c007
movslq %esi, %rax
shlq $0x5, %rax
addq %rax, %rcx
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0x5210
leaq 0x1211f(%rip), %rsi     # 0x2e12d
movq %rdx, %rdi
jmp 0x58b0
pushq %rax
leaq 0x12345(%rip), %rdi     # 0x2e363
leaq 0x12351(%rip), %rsi     # 0x2e376
leaq 0x123ef(%rip), %rcx     # 0x2e41b
pushq $0x6e
popq %rdx
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
cmpb $0x0, 0x3da(%rsi)
je 0x1c0b9
movq %rdi, %rbx
testl %edx, %edx
je 0x1c05c
cmpl $-0x2, %edx
jne 0x1c068
leaq 0x12de2(%rip), %rsi     # 0x2ee37
leaq 0xf(%rsp), %rdx
jmp 0x1c0a8
addq $0x428, %rsi            # imm = 0x428
movq %rbx, %rdi
jmp 0x1c095
testl %edx, %edx
js 0x1c09c
decl %edx
movq 0x448(%rsi), %rax
movq 0x450(%rsi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rdx, %rcx
jbe 0x1c09c
shlq $0x5, %rdx
addq %rdx, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5630
jmp 0x1c0b0
leaq 0x1208a(%rip), %rsi     # 0x2e12d
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x122a3(%rip), %rdi     # 0x2e363
leaq 0x122af(%rip), %rsi     # 0x2e376
leaq 0x12379(%rip), %rcx     # 0x2e447
pushq $0x7c
popq %rdx
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
cmpb $0x0, 0x3da(%rsi)
je 0x1c14f
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x1c132
cmpl $-0x2, %edx
jne 0x1c0ff
leaq 0x12d3f(%rip), %rsi     # 0x2ee37
leaq 0xf(%rsp), %rdx
jmp 0x1c13e
movl %edx, %ecx
movq 0x448(%rsi), %rax
movq 0x450(%rsi), %rsi
subq %rax, %rsi
sarq $0x5, %rsi
cmpq %rcx, %rsi
jbe 0x1c132
movslq %edx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5630
jmp 0x1c146
leaq 0x11ff4(%rip), %rsi     # 0x2e12d
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1220d(%rip), %rdi     # 0x2e363
leaq 0x12219(%rip), %rsi     # 0x2e376
leaq 0x12307(%rip), %rcx     # 0x2e46b
movl $0x8a, %edx
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x3da(%rdi)
je 0x1c1ce
movq %rsi, %rbx
movq %rdi, %r14
movq 0x450(%rdi), %rsi
subq 0x448(%rdi), %rsi
sarq $0x5, %rsi
incq %rsi
movq %rbx, %rdi
callq 0xfd72
leaq 0x428(%r14), %rsi
movq (%rbx), %rdi
callq 0x5210
movq 0x448(%r14), %rdi
movq 0x450(%r14), %rsi
movq (%rbx), %rdx
addq $0x20, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcf5d
leaq 0x1218e(%rip), %rdi     # 0x2e363
leaq 0x1219a(%rip), %rsi     # 0x2e376
leaq 0x122b0(%rip), %rcx     # 0x2e493
movl $0x95, %edx
callq 0x52a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
cmpb $0x0, 0x3db(%rsi)
je 0x1c2cb
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5610
movq 0x468(%r14), %rsi
cmpq 0x470(%r14), %rsi
je 0x1c28f
leaq 0x8(%rsp), %rdi
callq 0x5400
pushq $0x1
popq %r13
leaq 0x122b7(%rip), %r15     # 0x2e501
leaq 0x8(%rsp), %r12
movl %r13d, %r13d
movq 0x470(%r14), %rax
subq 0x468(%r14), %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x1c2a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x5480
movq %r13, %rsi
shlq $0x5, %rsi
addq 0x468(%r14), %rsi
movq %rax, %rdi
callq 0x5400
incl %r13d
jmp 0x1c24f
leaq 0x11e97(%rip), %rsi     # 0x2e12d
leaq 0x8(%rsp), %rdi
callq 0x5480
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56f0
leaq 0x8(%rsp), %rdi
callq 0x58f0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x121f8(%rip), %rdi     # 0x2e4ca
leaq 0x1209d(%rip), %rsi     # 0x2e376
leaq 0x12200(%rip), %rcx     # 0x2e4e0
movl $0xa2, %edx
callq 0x52a0
jmp 0x1c2ec
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x58f0
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c6d8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x480(%rsi), %rdx
testb %cl, %cl
je 0x1c5f0
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1d610
jmp 0x1c6be
movq 0x480(%r15), %rsi
movq 0x488(%r15), %rax
xorl %ecx, %ecx
cmpq %rax, %rsi
je 0x1c6aa
cmpq $0x0, 0x28(%r14)
je 0x1c6aa
movq %rdx, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x8(%r14), %rbp
xorl %r12d, %r12d
leaq 0x28(%rsp), %r13
movl %r12d, %r12d
subq %rsi, %rax
sarq $0x6, %rax
cmpq %r12, %rax
jbe 0x1c692
movq %r12, %rbx
shlq $0x6, %rbx
addq %rbx, %rsi
movq %r13, %rdi
callq 0x5210
movq %r14, %rdi
movq %r13, %rsi
callq 0x16988
cmpq %rbp, %rax
je 0x1c67f
movq 0x20(%rsp), %rax
addq (%rax), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x1d664
incl %r12d
movq 0x480(%r15), %rsi
movq 0x488(%r15), %rax
jmp 0x1c63b
leaq 0x28(%rsp), %rdi
callq 0x5908
movaps (%rsp), %xmm0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rbx
movups %xmm0, (%rbx)
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rsp, %rdi
callq 0x163b2
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11e5a(%rip), %rdi     # 0x2e539
leaq 0x11c90(%rip), %rsi     # 0x2e376
leaq 0x11e98(%rip), %rcx     # 0x2e585
movl $0xdb, %edx
callq 0x52a0
movq %rax, %rbx
jmp 0x1c70b
jmp 0x1c6fe
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5908
movq %rsp, %rdi
callq 0x163b2
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0x3dc(%rsi)
jne 0x1c7b6
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %ecx, %ecx
movl %ecx, %r12d
movq 0x480(%r14), %rdi
movq 0x488(%r14), %rax
subq %rdi, %rax
sarq $0x6, %rax
cmpq %r12, %rax
jbe 0x1c791
movl %r12d, %r13d
shlq $0x6, %r12
addq %r12, %rdi
movq %r15, %rsi
callq 0xfe37
leal 0x1(%r13), %ecx
testb %al, %al
je 0x1c741
movq 0x480(%r14), %rax
leaq (%rax,%r12), %rsi
addq $0x20, %rsi
movq %rbx, %rdi
callq 0x5630
jmp 0x1c7a5
leaq 0x13008(%rip), %rsi     # 0x2f7a0
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x11d7c(%rip), %rdi     # 0x2e539
leaq 0x11bb2(%rip), %rsi     # 0x2e376
leaq 0x11e0f(%rip), %rcx     # 0x2e5da
movl $0xf1, %edx
callq 0x52a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x1c71c
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5580
movq %r15, %rdi
callq 0x5908
leaq 0x12f76(%rip), %rsi     # 0x2f7a0
movq %r14, %rdi
callq 0x12f17
testb %al, %al
je 0x1c844
movq %rsp, %rdi
pushq $0x2c
popq %rsi
movq %rbx, %rdx
callq 0x126cc
movq %rsp, %rdi
callq 0x5908
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1c85b
movq %rax, %r14
movq %rsp, %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x9f1c
movq %r14, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, 0x3dd(%rsi)
je 0x1c905
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
leaq 0x12746(%rip), %r15     # 0x2efed
xorl %ecx, %ecx
movl %r12d, %r12d
movq 0x498(%r14), %rax
movq 0x4a0(%r14), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r12, %rdx
jbe 0x1c8f6
testb $0x1, %cl
je 0x1c8dd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58a0
movq 0x498(%r14), %rax
movq %r12, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x58d0
incl %r12d
movb $0x1, %cl
jmp 0x1c8a9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x11d01(%rip), %rdi     # 0x2e60d
leaq 0x11a63(%rip), %rsi     # 0x2e376
leaq 0x11d09(%rip), %rcx     # 0x2e623
movl $0x108, %edx            # imm = 0x108
callq 0x52a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5908
movq %r14, %rdi
callq 0x5800
nop