LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_file.cpp
// Function: vcf_file::read_header()
void vcf_file::read_header()
{
	string line;
	unsigned int line_index = 0;
	line_index += meta_data.add_FILTER_descriptor("ID=PASS,Description=PASS", line_index);

	while (!eof())
	{
		read_line(line);
		if (line[0] == '#')
			if (line[1] == '#')
				meta_data.parse_meta(line, line_index);
			else
			{
				meta_data.parse_header(line);
				return;
			}
		else
			return;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movl $0x0, 0xc(%rsp)
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x28b15(%rip), %rsi     # 0x395a5
leaq 0x28b26(%rip), %rdx     # 0x395bd
leaq 0x30(%rsp), %rdi
callq 0xc868
leaq 0x250(%rbx), %r14
movl 0xc(%rsp), %edx
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x14a0a
addl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x10acc
callq 0x5410
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testb %al, %al
jne 0x10b1b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11146
movq 0x10(%rsp), %rax
cmpb $0x23, (%rax)
jne 0x10b1b
cmpb $0x23, 0x1(%rax)
jne 0x10b0e
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x139bc
jmp 0x10ad6
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x163ee
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x10b2a
callq 0x5410
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x10b50
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x10b53
callq 0x5410
jmp 0x10b53
jmp 0x10b50
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x10b62
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_file.cpp
// Function: vcf_file::open_gz()
void vcf_file::open_gz()
{
	gzMAX_LINE_LEN = 1024*1024;
	gz_readbuffer = new char[gzMAX_LINE_LEN];

	if (stream)
		gzfile_in = gzdopen(fileno(stdin), "r");
	else
		gzfile_in = gzopen(filename.c_str(), "rb");

	if (gzfile_in == NULL)
		LOG.error("Could not open GZVCF file: " + filename, 0);
	#ifdef ZLIB_VERNUM
		string tmp(ZLIB_VERSION);
		LOG.printLOG("Using zlib version: " + tmp + "\n");
		#if (ZLIB_VERNUM >= 0x1240)
			gzbuffer(gzfile_in, gzMAX_LINE_LEN); // Included in zlib v1.2.4 and makes things MUCH faster
		#else
			LOG.printLOG("Versions of zlib >= 1.2.4 will be *much* faster when reading zipped VCF files.\n");
		#endif
	#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl $0x100000, 0x240(%rdi)  # imm = 0x100000
movl $0x100000, %edi         # imm = 0x100000
callq 0x5030
movq %rax, 0x460(%rbx)
cmpb $0x1, 0x468(%rbx)
jne 0x10ed8
movq 0x390f0(%rip), %rax     # 0x49fb0
movq (%rax), %rdi
callq 0x54b0
leaq 0x28d3d(%rip), %rsi     # 0x39c0c
movl %eax, %edi
callq 0x5800
jmp 0x10ee8
movq 0x8(%rbx), %rdi
leaq 0x2863f(%rip), %rsi     # 0x39522
callq 0x5650
movq %rax, 0x248(%rbx)
testq %rax, %rax
jne 0x10f30
leaq 0x8(%rbx), %rdx
leaq 0x28842(%rip), %rsi     # 0x39741
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0xb7dd
leaq 0x39595(%rip), %rdi     # 0x4a4a8
movq %r14, %rsi
xorl %edx, %edx
callq 0x3721e
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10f30
callq 0x5410
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x28604(%rip), %rsi     # 0x39544
leaq 0x28603(%rip), %rdx     # 0x3954a
leaq 0x20(%rsp), %rdi
callq 0xc868
leaq 0x285f3(%rip), %rsi     # 0x3954b
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xb7dd
leaq 0x281e8(%rip), %rsi     # 0x39156
leaq 0x40(%rsp), %rdi
callq 0x5870
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x10f9e
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x10fa5
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x394e2(%rip), %rdi     # 0x4a4a8
callq 0x371c8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x10fd9
callq 0x5410
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10fec
callq 0x5410
movq 0x248(%rbx), %rdi
movl 0x240(%rbx), %esi
callq 0x5340
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x1100d
callq 0x5410
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x11067
jmp 0x11071
jmp 0x1105a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x11045
callq 0x5410
jmp 0x11045
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1105d
callq 0x5410
jmp 0x1105d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x11071
callq 0x5410
jmp 0x11071
movq %rax, %rbx
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_file.cpp
// Function: vcf_file::eof()
bool vcf_file::eof()
{
	bool out;
	if (!compressed)
		out = file_in->eof();
	else
		out = gzeof(gzfile_in);	// Returns 1 when EOF has previously been detected reading the given input stream, otherwise zero.
	return out;
}

// Assembly:
cmpb $0x0, 0x28(%rdi)
je 0x110bb
pushq %rax
movq 0x248(%rdi), %rdi
callq 0x5110
addq $0x8, %rsp
jmp 0x110cd
movq 0x30(%rdi), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %eax
andl $0x2, %eax
testl %eax, %eax
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_file.cpp
// Function: vcf_file::read_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void vcf_file::read_line(string &out)
{
	char * tmp;
	out = "";
	if (!compressed)
	{
		getline(*file_in, out);
		out.erase( out.find_last_not_of(" \t\n\r") + 1);	// Trim whitespace at end of line
	}
	else
	{
		bool again = true;
		while (again == true)
		{
			tmp = gzgets(gzfile_in, gz_readbuffer, gzMAX_LINE_LEN);
			if (tmp == NULL)
				return;

			out.append(gz_readbuffer);
			if (strlen(gz_readbuffer) != gzMAX_LINE_LEN-1)
				again = false;
		}
		out.erase( out.find_last_not_of(" \t\n\r") + 1);	// Trim whitespace at end of line (required in gzipped case!)
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
leaq 0x29da1(%rip), %rcx     # 0x3aeff
xorl %r15d, %r15d
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5690
cmpb $0x1, 0x28(%r14)
jne 0x111d2
movb $0x1, %bpl
movq 0x248(%r14), %rdi
movq 0x460(%r14), %rsi
movl 0x240(%r14), %edx
callq 0x5770
testq %rax, %rax
je 0x1122a
movq 0x460(%r14), %rsi
movq %rbx, %rdi
callq 0x5870
movq 0x460(%r14), %rdi
callq 0x5180
movl 0x240(%r14), %ecx
decl %ecx
cmpq %rcx, %rax
movzbl %bpl, %ebp
cmovnel %r15d, %ebp
testb $0x1, %bpl
jne 0x11178
jmp 0x111f8
movq 0x30(%r14), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5440
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5830
leaq 0x2855e(%rip), %rsi     # 0x3975d
movl $0x4, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x56f0
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x11235
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28382(%rip), %rdi     # 0x395be
leaq 0x283b2(%rip), %rsi     # 0x395f5
movq %rax, %rdx
xorl %eax, %eax
callq 0x5660
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_file.cpp
// Function: vcf_file::read_line(std::vector<char, std::allocator<char>>&)
void vcf_file::read_line(vector<char> &out)
{
	static string tmp;
	tmp="";
	out.resize(0);
	read_line(tmp);
	vector<char> tmp_char(tmp.begin(),tmp.end());
	out = tmp_char;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x394bd(%rip), %al      # 0x4a720
testb %al, %al
je 0x112e5
movq 0x3949a(%rip), %rdx     # 0x4a708
leaq 0x3948b(%rip), %r15     # 0x4a700
leaq 0x29c83(%rip), %rcx     # 0x3aeff
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5690
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf31a
movq %r14, %rdi
movq %r15, %rsi
callq 0x11146
movq 0x3945b(%rip), %rsi     # 0x4a700
movq 0x3945c(%rip), %rdx     # 0x4a708
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
callq 0x1130a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11344
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x112db
callq 0x5410
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x59af
jmp 0x11267
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11301
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/variant_file.cpp
// Function: variant_file::N_kept_individuals() const
int variant_file::N_kept_individuals() const
{
	int N_kept = 0;
	for (unsigned int ui=0; ui<include_indv.size(); ui++)
		if (include_indv[ui] == true)
			N_kept++;
	return N_kept;
}

// Assembly:
movq 0x430(%rdi), %rcx
movq 0x440(%rdi), %rdx
movl 0x448(%rdi), %eax
subq %rcx, %rdx
shlq $0x3, %rdx
addq %rax, %rdx
je 0x11527
xorl %esi, %esi
xorl %eax, %eax
movq %rsi, %rdi
shrq $0x6, %rdi
movq (%rcx,%rdi,8), %rdi
btq %rsi, %rdi
adcl $0x0, %eax
incq %rsi
movl %esi, %edi
cmpq %rdi, %rdx
ja 0x1150a
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/variant_file.cpp
// Function: variant_file::ByteSwap(unsigned char*, int) const
void variant_file::ByteSwap(unsigned char *b, int n) const
{
   register int i = 0;
   register int j = n-1;
   while (i<j)
   {
      std::swap(b[i], b[j]);
      i++, j--;
   }
}

// Assembly:
cmpl $0x2, %edx
jl 0x11566
movl %edx, %eax
addq $-0x2, %rax
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
movb 0x1(%rsi,%rax), %dil
movb %dil, (%rsi,%rcx)
movb %dl, 0x1(%rsi,%rax)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rax, %rcx
movq %rdx, %rax
jl 0x11547
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/variant_file.cpp
// Function: variant_file::read_temp_site(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void variant_file::read_temp_site(ifstream &tmp_file, string &CHROM, int &POS, vector< pair<int,int> > &GTs)
{
	stringstream chr;
	char tmp_char;
	while(true)
	{
		tmp_file.read(&tmp_char,sizeof(char));
		if (tmp_char == '\n')
			break;
		chr << tmp_char;
	}
	CHROM = chr.str();

	tmp_file.read((char*)&POS,sizeof(POS));

	char in_byte, tmp_gt;
	for(unsigned int ui=0; ui<GTs.size(); ui++)
	{
		tmp_file.read(&in_byte,sizeof(in_byte));
		tmp_gt = in_byte & 0x03;
		if (tmp_gt == 0x02)
			GTs[ui].second = -1;
		else
			GTs[ui].second = (int)tmp_gt;
		in_byte = in_byte >> 4;
		tmp_gt = in_byte & 0x03;
		if (tmp_gt == 0x02)
			GTs[ui].first = -1;
		else
			GTs[ui].first = (int)tmp_gt;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r14
leaq 0x30(%rsp), %rdi
callq 0x52e0
leaq 0x40(%rsp), %r13
leaq 0x7(%rsp), %rbp
leaq 0x10(%rsp), %r15
movl $0x1, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5580
movb 0x7(%rsp), %al
cmpb $0xa, %al
je 0x11998
movb %al, 0x10(%rsp)
movl $0x1, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x54f0
jmp 0x1196a
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x56c0
leaq 0x10(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x5550
movq (%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x119c9
callq 0x5410
movl $0x4, %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x5580
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x11a4e
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5580
movzbl 0x10(%rsp), %eax
movl %eax, %ecx
andl $0x3, %ecx
cmpl $0x2, %ecx
cmovel %r13d, %ecx
movq (%rbx), %rdx
movl %ecx, 0x4(%rdx,%r12,8)
sarb $0x4, %al
movb %al, 0x10(%rsp)
andb $0x3, %al
cmpb $0x2, %al
movzbl %al, %eax
cmovel %r13d, %eax
movq (%rbx), %rcx
movl %eax, (%rcx,%r12,8)
movl %ebp, %r12d
movq 0x8(%rbx), %rax
subq %rcx, %rax
sarq $0x3, %rax
incl %ebp
cmpq %r12, %rax
ja 0x119f7
movq 0x3852b(%rip), %rsi     # 0x49f80
leaq 0x30(%rsp), %rdi
callq 0x5330
leaq 0xb0(%rsp), %rdi
callq 0x5100
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11a84
jmp 0x11a84
jmp 0x11a84
movq %rax, %rbx
movq 0x384f2(%rip), %rsi     # 0x49f80
leaq 0x30(%rsp), %rdi
callq 0x5330
leaq 0xb0(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/variant_file.cpp
// Function: variant_file::read_big_temp_site(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&, int&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void variant_file::read_big_temp_site(ifstream &tmp_file, string &CHROM, int &POS, int &alleles, vector< pair<int,int> > &GTs)
{
	stringstream chr;
	char tmp_char;
	while(true)
	{
		tmp_file.read(&tmp_char,sizeof(char));
		if (tmp_char == '\n')
			break;
		chr << tmp_char;
	}
	CHROM = chr.str();

	tmp_file.read((char*)&POS,sizeof(POS));

	int8_t tmp_alleles;
	tmp_file.read((char*)&tmp_alleles,sizeof(tmp_alleles));
	alleles = (int)tmp_alleles;

	char in_byte = 0xFF;
	for(unsigned int ui=0; ui<GTs.size(); ui++)
	{
		tmp_file.read(&in_byte,sizeof(in_byte));
		if (in_byte == (char)0xFF)
			GTs[ui].first = -1;
		else
			GTs[ui].first = (int)in_byte;

		tmp_file.read(&in_byte,sizeof(in_byte));
		if (in_byte == (char)0xFF)
			GTs[ui].second = -1;
		else
			GTs[ui].second = (int)in_byte;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r13
movq %rsi, %r14
leaq 0x40(%rsp), %rdi
callq 0x52e0
leaq 0x50(%rsp), %rbp
leaq 0xf(%rsp), %r15
leaq 0x20(%rsp), %r12
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5580
movb 0xf(%rsp), %al
cmpb $0xa, %al
je 0x11b19
movb %al, 0x20(%rsp)
movl $0x1, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x54f0
jmp 0x11aeb
leaq 0x58(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x56c0
leaq 0x20(%rsp), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x5550
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x11b4a
callq 0x5410
movl $0x4, %edx
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0x5580
leaq 0x20(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x5580
movsbl 0x20(%rsp), %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movb $-0x1, 0xe(%rsp)
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x11be3
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0xe(%rsp), %r15
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5580
movsbl 0xe(%rsp), %eax
movq (%rbx), %rcx
movl %eax, (%rcx,%r12,8)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5580
movsbl 0xe(%rsp), %eax
movq (%rbx), %rcx
movl %eax, 0x4(%rcx,%r12,8)
movl %ebp, %r12d
movq 0x8(%rbx), %rax
subq %rcx, %rax
sarq $0x3, %rax
incl %ebp
cmpq %r12, %rax
ja 0x11b95
movq 0x38396(%rip), %rsi     # 0x49f80
leaq 0x40(%rsp), %rdi
callq 0x5330
leaq 0xc0(%rsp), %rdi
callq 0x5100
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11c1b
jmp 0x11c1b
jmp 0x11c1b
jmp 0x11c1b
movq %rax, %rbx
movq 0x3835b(%rip), %rsi     # 0x49f80
leaq 0x40(%rsp), %rdi
callq 0x5330
leaq 0xc0(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/header.cpp
// Function: header::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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 header::tokenize(const string &in, char token, vector<string> &out)
{
	out.resize(0);
	istringstream ss(in);
	string tmp;
	while( getline(ss, tmp, token) )
	{
		out.push_back(tmp);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rdi
xorl %esi, %esi
callq 0x1300a
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x5730
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movsbl %bpl, %ebp
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5830
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x16afb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13080
jmp 0x16ad3
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16b09
callq 0x5410
movq 0x334a8(%rip), %rsi     # 0x49fb8
leaq 0x20(%rsp), %rdi
callq 0x5610
leaq 0x98(%rsp), %rdi
callq 0x5100
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16b48
callq 0x5410
movq 0x33469(%rip), %rsi     # 0x49fb8
leaq 0x20(%rsp), %rdi
callq 0x5610
leaq 0x98(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/header.cpp
// Function: header::str2int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
int header::str2int(const string &in, const int missing_value)
{
	if ((in.size() == 0) || (in == "."))
		return missing_value;
	else
		return atoi(in.c_str());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpq $0x0, 0x8(%rdi)
je 0x16b9d
movq %rdi, %r14
leaq 0x23688(%rip), %rsi     # 0x3a20d
callq 0x50e0
testl %eax, %eax
je 0x16b9d
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x56a0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/header.cpp
// Function: header::reparse()
void header::reparse()
{
	unsigned int index = 0;
	has_idx = false; contig_index = 0;
	vector<string> old_lines(lines.size(),"");
	copy(lines.begin(), lines.end(), old_lines.begin());
	lines.resize(0);

	INFO_map.clear(); INFO_reverse_map.clear();
	FILTER_map.clear(); FILTER_reverse_map.clear();
	FORMAT_map.clear(); FORMAT_reverse_map.clear();
	CONTIG_map.clear(); CONTIG_reverse_map.clear();

	index += add_FILTER_descriptor("ID=PASS,Description=PASS", index);
	for (unsigned int ui=0; ui<old_lines.size(); ui++)
		parse_meta(old_lines[ui],index);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0xc(%rsp)
movb $0x0, 0x8(%rdi)
movl %eax, (%rdi)
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x23e37(%rip), %rdx     # 0x3aeff
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0xc868
subq %r15, %r14
sarq $0x5, %r14
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0xb(%rsp), %rcx
movq %r14, %rsi
callq 0x178d8
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x17102
callq 0x5410
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %r13
subq %r14, %r13
sarq $0x5, %r13
testq %r13, %r13
jle 0x1713a
movq 0x10(%rsp), %r15
incq %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x51f0
addq $0x20, %r14
addq $0x20, %r15
decq %r13
cmpq $0x1, %r13
jg 0x1711e
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x1300a
leaq 0x60(%rbx), %rdi
callq 0x1826e
leaq 0x180(%rbx), %rdi
callq 0x1829c
leaq 0x90(%rbx), %rdi
callq 0x1826e
leaq 0x150(%rbx), %rdi
callq 0x1829c
leaq 0xc0(%rbx), %rdi
callq 0x1826e
leaq 0x1b0(%rbx), %rdi
callq 0x1829c
leaq 0xf0(%rbx), %rdi
callq 0x1826e
leaq 0x120(%rbx), %rdi
callq 0x1829c
leaq 0x28(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x223f4(%rip), %rsi     # 0x395a5
leaq 0x22405(%rip), %rdx     # 0x395bd
callq 0xc868
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x14a0a
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x171df
callq 0x5410
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x17223
movl $0x1, %ebp
xorl %esi, %esi
leaq 0xc(%rsp), %r14
shlq $0x5, %rsi
addq %rax, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139bc
movl %ebp, %esi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %ebp
cmpq %rsi, %rcx
ja 0x171f7
leaq 0x10(%rsp), %rdi
callq 0xc4f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x17272
callq 0x5410
jmp 0x17272
jmp 0x1726f
jmp 0x1726f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1727c
callq 0x5410
jmp 0x1727c
movq %rax, %rbx
jmp 0x1727c
jmp 0x1726f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc4f0
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/header.cpp
// Function: header::int2str[abi:cxx11](int, int)
string header::int2str(const int in, const int missing_value)
{
	if (in == missing_value)
		return ".";
	else
	{
		static ostringstream out;
		out.str(""); out.clear();
		out << in;
		return out.str();
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl %edx, %esi
jne 0x172b2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x22f6c(%rip), %rsi     # 0x3a20d
leaq 0x22f66(%rip), %rdx     # 0x3a20e
movq %rbx, %rdi
callq 0xc868
jmp 0x1732b
movl %esi, %ebp
movb 0x33616(%rip), %al      # 0x4a8d0
testb %al, %al
je 0x17337
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x23c31(%rip), %rdx     # 0x3aeff
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xc868
leaq 0x33480(%rip), %rdi     # 0x4a760
movq %rsp, %rsi
callq 0x5640
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x172f6
callq 0x5410
movq 0x3345b(%rip), %rax     # 0x4a758
leaq 0x33454(%rip), %r14     # 0x4a758
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x5750
movq %r14, %rdi
movl %ebp, %esi
callq 0x57a0
leaq 0x3343d(%rip), %rsi     # 0x4a760
movq %rbx, %rdi
callq 0x56c0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x33592(%rip), %rdi     # 0x4a8d0
callq 0x5810
testl %eax, %eax
je 0x172be
leaq 0x33406(%rip), %rdi     # 0x4a758
callq 0x55d0
movq 0x32c12(%rip), %rdi     # 0x49f70
leaq 0x333f3(%rip), %rsi     # 0x4a758
leaq 0x330ec(%rip), %rdx     # 0x4a458
callq 0x53d0
leaq 0x33558(%rip), %rdi     # 0x4a8d0
callq 0x5270
jmp 0x172be
movq %rax, %rbx
leaq 0x33544(%rip), %rdi     # 0x4a8d0
callq 0x5250
jmp 0x173a9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x173a9
callq 0x5410
jmp 0x173a9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/header.cpp
// Function: header::str2double(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
double header::str2double(const string &in, const double missing_value)
{
	if ((in.size() == 0) || (in == "."))
		return missing_value;
	else
		return atof(in.c_str());
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x173ea
movq %rdi, %rbx
leaq 0x22e45(%rip), %rsi     # 0x3a20d
movsd %xmm0, 0x8(%rsp)
callq 0x50e0
movsd 0x8(%rsp), %xmm0
testl %eax, %eax
je 0x173ea
movq (%rbx), %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x5570
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/header.cpp
// Function: header::double2str[abi:cxx11](double, double)
string header::double2str(const double in, const double missing_value)
{
	if (in == missing_value)
		return ".";
	else
	{
		static ostringstream out;
		out.str(""); out.clear();
		out << in;
		return out.str();
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
ucomisd %xmm1, %xmm0
jne 0x17424
jp 0x17424
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x22dfd(%rip), %rsi     # 0x3a20d
leaq 0x22df7(%rip), %rdx     # 0x3a20e
movq %rbx, %rdi
callq 0xc868
jmp 0x174ac
movsd %xmm0, (%rsp)
movb 0x33621(%rip), %al      # 0x4aa50
testb %al, %al
je 0x174b7
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x23ab8(%rip), %rdx     # 0x3aeff
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xc868
leaq 0x33485(%rip), %rdi     # 0x4a8e0
leaq 0x8(%rsp), %rsi
callq 0x5640
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x17474
callq 0x5410
movq 0x3345d(%rip), %rax     # 0x4a8d8
leaq 0x33456(%rip), %r14     # 0x4a8d8
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x5750
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x56e0
leaq 0x3343c(%rip), %rsi     # 0x4a8e0
movq %rbx, %rdi
callq 0x56c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x33592(%rip), %rdi     # 0x4aa50
callq 0x5810
testl %eax, %eax
je 0x17437
leaq 0x33406(%rip), %rdi     # 0x4a8d8
callq 0x55d0
movq 0x32a92(%rip), %rdi     # 0x49f70
leaq 0x333f3(%rip), %rsi     # 0x4a8d8
leaq 0x32f6c(%rip), %rdx     # 0x4a458
callq 0x53d0
leaq 0x33558(%rip), %rdi     # 0x4aa50
callq 0x5270
jmp 0x17437
movq %rax, %rbx
leaq 0x33544(%rip), %rdi     # 0x4aa50
callq 0x5250
jmp 0x1752a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1752a
callq 0x5410
jmp 0x1752a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry.cpp
// Function: bcf_entry::reset(std::vector<char, std::allocator<char>> const&)
void bcf_entry::reset(const vector<char> &data_line)
{
	basic_parsed = false;
	fully_parsed = false;
	parsed_ALT = false;
	parsed_FILTER = false;
	parsed_INFO = false;
	parsed_FORMAT = false;
	parsed_FORMAT_binary = false;
	passed_filters = true;

	line = data_line;

	fill(parsed_GT.begin(), parsed_GT.end(), false);
	fill(parsed_GQ.begin(), parsed_GQ.end(), false);
	fill(parsed_DP.begin(), parsed_DP.end(), false);
	fill(parsed_FT.begin(), parsed_FT.end(), false);
	fill(include_genotype.begin(), include_genotype.end(), true);

	INFO_pos = 0; FILTER_pos = 0; ALT_pos = 0; FORMAT_pos = 0;
	FORMAT_positions.clear(); FORMAT_types.clear(); FORMAT_sizes.clear(); FORMAT_skip.clear(); FORMAT_keys.clear();
	N_INFO_removed = 0; N_FORMAT_removed = 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x3db(%rdi)
movl %eax, 0x3d8(%rdi)
movb $0x1, 0xc(%rdi)
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x11344
movq 0x560(%rbx), %rdi
movq 0x570(%rbx), %r14
movl 0x578(%rbx), %ebp
cmpq %r14, %rdi
je 0x18769
movq %r14, %rdx
subq %rdi, %rdx
xorl %esi, %esi
callq 0x5200
jmp 0x1876c
movq %rdi, %r14
testl %ebp, %ebp
je 0x18785
negb %bpl
movq $-0x1, %rax
movl %ebp, %ecx
shrq %cl, %rax
notq %rax
andq %rax, (%r14)
movq 0x588(%rbx), %rdi
movq 0x598(%rbx), %r14
movl 0x5a0(%rbx), %ebp
cmpq %r14, %rdi
je 0x187ad
movq %r14, %rdx
subq %rdi, %rdx
xorl %esi, %esi
callq 0x5200
jmp 0x187b0
movq %rdi, %r14
testl %ebp, %ebp
je 0x187c9
negb %bpl
movq $-0x1, %rax
movl %ebp, %ecx
shrq %cl, %rax
notq %rax
andq %rax, (%r14)
movq 0x5b0(%rbx), %rdi
movq 0x5c0(%rbx), %r14
movl 0x5c8(%rbx), %ebp
cmpq %r14, %rdi
je 0x187f1
movq %r14, %rdx
subq %rdi, %rdx
xorl %esi, %esi
callq 0x5200
jmp 0x187f4
movq %rdi, %r14
testl %ebp, %ebp
je 0x1880d
negb %bpl
movq $-0x1, %rax
movl %ebp, %ecx
shrq %cl, %rax
notq %rax
andq %rax, (%r14)
movq 0x5d8(%rbx), %rdi
movq 0x5e8(%rbx), %r14
movl 0x5f0(%rbx), %ebp
cmpq %r14, %rdi
je 0x18835
movq %r14, %rdx
subq %rdi, %rdx
xorl %esi, %esi
callq 0x5200
jmp 0x18838
movq %rdi, %r14
testl %ebp, %ebp
je 0x18851
negb %bpl
movq $-0x1, %rax
movl %ebp, %ecx
shrq %cl, %rax
notq %rax
andq %rax, (%r14)
movq 0x218(%rbx), %rdi
movq 0x228(%rbx), %r14
movl 0x230(%rbx), %ebp
cmpq %r14, %rdi
je 0x1887c
movq %r14, %rdx
subq %rdi, %rdx
movl $0xff, %esi
callq 0x5200
jmp 0x1887f
movq %rdi, %r14
testl %ebp, %ebp
je 0x18895
negb %bpl
movq $-0x1, %rax
movl %ebp, %ecx
shrq %cl, %rax
orq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x6e8(%rbx)
movq 0x640(%rbx), %rax
cmpq %rax, 0x648(%rbx)
je 0x188b6
movq %rax, 0x648(%rbx)
movq 0x658(%rbx), %rax
cmpq %rax, 0x660(%rbx)
je 0x188cd
movq %rax, 0x660(%rbx)
movq 0x670(%rbx), %rax
cmpq %rax, 0x678(%rbx)
je 0x188e4
movq %rax, 0x678(%rbx)
movq 0x688(%rbx), %rax
cmpq %rax, 0x690(%rbx)
je 0x188fb
movq %rax, 0x690(%rbx)
movq 0x6a0(%rbx), %rax
cmpq %rax, 0x6a8(%rbx)
je 0x18912
movq %rax, 0x6a8(%rbx)
movq $0x0, 0x4c8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry.cpp
// Function: bcf_entry::parse_full_entry(bool)
void bcf_entry::parse_full_entry(bool parse_FORMAT)
{
	if (fully_parsed)
		return;

	if (basic_parsed == false)
		parse_basic_entry();

	FORMAT_pos = L_shared + 2*sizeof(uint32_t);
	FORMAT_positions.resize(N_format);
	FORMAT_types.resize(N_format);
	FORMAT_sizes.resize(N_format);
	FORMAT_skip.resize(N_format);
	FORMAT_keys.resize(N_format);

	if (parse_FORMAT)
		set_FORMAT();

	fully_parsed = true;
}

// Assembly:
cmpb $0x0, 0x3d9(%rdi)
jne 0x18d04
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x3d8(%rdi)
jne 0x18c81
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x10(%rax)
movl 0x6bc(%rbx), %esi
movl 0x6c4(%rbx), %eax
addl $0x8, %eax
movl %eax, 0x6f4(%rbx)
leaq 0x640(%rbx), %rdi
callq 0x1b394
leaq 0x658(%rbx), %rdi
movl 0x6bc(%rbx), %esi
callq 0x1b394
leaq 0x670(%rbx), %rdi
movl 0x6bc(%rbx), %esi
callq 0x1b394
leaq 0x688(%rbx), %rdi
movl 0x6bc(%rbx), %esi
callq 0x1b394
leaq 0x6a0(%rbx), %rdi
movl 0x6bc(%rbx), %esi
callq 0x1b394
testb %bpl, %bpl
je 0x18cf7
movq %rbx, %rdi
callq 0x277b0
movb $0x1, 0x3d9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry.cpp
// Function: bcf_entry::filter_genotypes_by_quality(double)
void bcf_entry::filter_genotypes_by_quality(double min_genotype_quality)
{
	if (fully_parsed == false)
		parse_full_entry();

	if (GQ_idx != -1)
	{	// Have quality info
		double quality;
		for (unsigned int ui=0; ui<N_indv; ui++)
		{
			if (parsed_GQ[ui] == false)
				parse_genotype_entry(ui, false, true);
			quality = get_indv_GQUALITY(ui);
			if (quality < min_genotype_quality)
				include_genotype[ui] = false;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %rbx
cmpb $0x0, 0x3d9(%rdi)
jne 0x18d2d
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x18(%rax)
cmpl $-0x1, 0x634(%rbx)
je 0x18dab
cmpl $0x0, 0x8(%rbx)
je 0x18dab
xorl %r14d, %r14d
movq 0x588(%rbx), %rax
movl $0x1, %r15d
movl %r14d, %ecx
shlq %cl, %r15
movq %r14, %r12
shrq $0x6, %r12
movq (%rax,%r12,8), %rax
btq %r14, %rax
jb 0x18d7c
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x20(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x22e72
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x18da0
movq 0x218(%rbx), %rax
notq %r15
andq %r15, (%rax,%r12,8)
incq %r14
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x18d3f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry.cpp
// Function: bcf_entry::filter_genotypes_by_depth(int, int)
void bcf_entry::filter_genotypes_by_depth(int min_depth, int max_depth)
{
	if (fully_parsed == false)
		parse_full_entry();

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x0, 0x3d9(%rdi)
jne 0x18de1
movq (%r14), %rax
movq %r14, %rdi
movl $0x1, %esi
callq *0x18(%rax)
cmpl $-0x1, 0x638(%r14)
je 0x18e65
cmpl $0x0, 0x8(%r14)
je 0x18e65
xorl %r15d, %r15d
movq 0x5b0(%r14), %rax
movl $0x1, %r12d
movl %r15d, %ecx
shlq %cl, %r12
movq %r15, %r13
shrq $0x6, %r13
movq (%rax,%r13,8), %rax
btq %r15, %rax
jb 0x18e32
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq *0x20(%rax)
movq %r14, %rdi
movl %r15d, %esi
callq 0x22e20
cmpl %ebp, %eax
setge %cl
cmpl %ebx, %eax
setle %al
testb %al, %cl
jne 0x18e59
movq 0x218(%r14), %rax
notq %r12
andq %r12, (%rax,%r13,8)
incq %r15
movl 0x8(%r14), %eax
cmpq %rax, %r15
jb 0x18df5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/bcf_entry.cpp
// Function: bcf_entry::filter_genotypes_by_filter_status(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)
void bcf_entry::filter_genotypes_by_filter_status(const set<string> &filter_flags_to_remove, bool remove_all)
{
	if (fully_parsed == false)
		parse_full_entry();

	vector<string> GFILTERs;
	if (FT_idx != -1)
	{	// Have GFilter info
		for (unsigned int ui=0; ui<N_indv; ui++)
		{
			if (parsed_FT[ui] == false)
				parse_genotype_entry(ui, false, false, false, true);
			get_indv_GFILTER_vector(ui, GFILTERs);

			if (remove_all == true)
			{	// If removing all filters, only keep things with label PASS
				if (!GFILTERs.empty())
					if ((GFILTERs[0] != "PASS") && (GFILTERs[0] != "."))
						include_genotype[ui] = false;
			}
			else
			{	// Only removing specific filters
				for (unsigned int uj=0; uj<GFILTERs.size(); uj++)
					if (filter_flags_to_remove.find(GFILTERs[uj]) != filter_flags_to_remove.end())
							include_genotype[ui] = false;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x1c(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r15
cmpb $0x0, 0x3d9(%rdi)
jne 0x18ea5
movq (%r15), %rax
movq %r15, %rdi
movl $0x1, %esi
callq *0x18(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpl $-0x1, 0x63c(%r15)
je 0x18fcd
cmpl $0x0, 0x8(%r15)
je 0x18fcd
movq 0x20(%rsp), %rax
leaq 0x8(%rax), %rbp
xorl %ebx, %ebx
movq 0x5d8(%r15), %rax
movl $0x1, %r13d
movl %ebx, %ecx
shlq %cl, %r13
movq %rbx, %r12
shrq $0x6, %r12
movq (%rax,%r12,8), %rax
btq %rbx, %rax
jb 0x18f14
movq (%r15), %rax
movq %r15, %rdi
movl %ebx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq *0x20(%rax)
movq %r15, %rdi
movl %ebx, %esi
movq %rsp, %rdx
callq 0x22eca
cmpb $0x0, 0x1c(%rsp)
je 0x18f6b
movq (%rsp), %rdi
cmpq 0x8(%rsp), %rdi
je 0x18fbd
leaq 0x2067b(%rip), %rsi     # 0x395b9
callq 0x50e0
testl %eax, %eax
je 0x18fbd
movq (%rsp), %rdi
leaq 0x212bb(%rip), %rsi     # 0x3a20d
callq 0x50e0
testl %eax, %eax
je 0x18fbd
movq 0x218(%r15), %rax
notq %r13
andq %r13, (%rax,%r12,8)
jmp 0x18fbd
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x18fbd
notq %r13
movl $0x1, %r14d
xorl %esi, %esi
shlq $0x5, %rsi
addq %rax, %rsi
movq 0x20(%rsp), %rdi
callq 0x1b9c2
cmpq %rbp, %rax
je 0x18fa2
movq 0x218(%r15), %rax
andq %r13, (%rax,%r12,8)
movl %r14d, %esi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %r14d
cmpq %rsi, %rcx
ja 0x18f81
incq %rbx
movl 0x8(%r15), %eax
cmpq %rax, %rbx
jb 0x18ed9
movq %rsp, %rdi
callq 0xc4f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18fe6
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc4f0
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]viterbi/vcf_entry.cpp
// Function: vcf_entry::parse_basic_entry(bool, bool, bool)
void vcf_entry::parse_basic_entry(bool parse_ALT, bool parse_FILTER, bool parse_INFO)
{
	if(!basic_parsed)
	{
		getline(data_stream, CHROM, '\t');

		getline(data_stream, ID, '\t');
		POS = atoi(ID.c_str());
		getline(data_stream, ID, '\t');
		getline(data_stream, REF, '\t');
		getline(data_stream, ALT_str, '\t');
		getline(data_stream, QUAL_str, '\t');
		getline(data_stream, FILTER_str, '\t');
		getline(data_stream, INFO_str, '\t');

		QUAL = header::str2double(QUAL_str);

		// Convert to uppercase for consistency
		// Note that VCF v4.1 allows mixtures of lower/upper case in REF and ALT.
		// However, the spec specifically states that tools using VCF are not required
		// to preserve the case.
		std::transform(REF.begin(), REF.end(), REF.begin(), ::toupper);
		std::transform(ALT_str.begin(), ALT_str.end(),ALT_str.begin(), ::toupper);
	}
	basic_parsed = true;

	if (parse_ALT && !parsed_ALT)
		set_ALT(ALT_str);
	if (parse_FILTER && !parsed_FILTER)
		set_FILTER(FILTER_str);
	if (parse_INFO && !parsed_INFO)
		set_INFO(INFO_str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
cmpb $0x0, 0x3d8(%rdi)
jne 0x1cab2
leaq 0x240(%rbx), %r12
leaq 0x3e0(%rbx), %rsi
movq %r12, %rdi
movl $0x9, %edx
callq 0x5830
leaq 0x408(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0x9, %edx
callq 0x5830
movq 0x408(%rbx), %rdi
callq 0x56a0
movl %eax, 0x400(%rbx)
movq %r12, %rdi
movq %r13, %rsi
movl $0x9, %edx
callq 0x5830
leaq 0x428(%rbx), %rsi
movq %r12, %rdi
movl $0x9, %edx
callq 0x5830
leaq 0x6b8(%rbx), %rsi
movq %r12, %rdi
movl $0x9, %edx
callq 0x5830
leaq 0x738(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0x9, %edx
callq 0x5830
leaq 0x6d8(%rbx), %rsi
movq %r12, %rdi
movl $0x9, %edx
callq 0x5830
leaq 0x6f8(%rbx), %rsi
movq %r12, %rdi
movl $0x9, %edx
callq 0x5830
movsd 0x1d618(%rip), %xmm0    # 0x3a060
movq %r13, %rdi
callq 0x173b2
movsd %xmm0, 0x460(%rbx)
movq 0x430(%rbx), %r12
testq %r12, %r12
je 0x1ca85
movq 0x428(%rbx), %r13
xorl %ebp, %ebp
movsbl (%r13,%rbp), %edi
callq 0x5840
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %r12
jne 0x1ca6d
movq 0x6c0(%rbx), %r12
testq %r12, %r12
je 0x1cab2
movq 0x6b8(%rbx), %r13
xorl %ebp, %ebp
movsbl (%r13,%rbp), %edi
callq 0x5840
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %r12
jne 0x1ca9a
movb $0x1, 0x3d8(%rbx)
testb %r15b, %r15b
je 0x1cad6
cmpb $0x0, 0x3da(%rbx)
jne 0x1cad6
leaq 0x6b8(%rbx), %rsi
movq %rbx, %rdi
callq 0x248d4
testb %r14b, %r14b
je 0x1caf3
cmpb $0x0, 0x3db(%rbx)
jne 0x1caf3
leaq 0x6d8(%rbx), %rsi
movq %rbx, %rdi
callq 0x2584e
cmpb $0x0, 0x4(%rsp)
je 0x1cb03
cmpb $0x0, 0x3dc(%rbx)
je 0x1cb12
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6f8(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x259a2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1cc17
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x3d8(%rdi)
jne 0x1cb68
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
movq %r14, %rdi
movq %r15, %rsi
movl $0x9, %edx
callq 0x5830
testb %bpl, %bpl
je 0x1cb96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x249ce
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x56b0
leaq 0x758(%rbx), %r15
movl 0x8(%rbx), %esi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x1f0bc
cmpl $0x0, 0x8(%rbx)
je 0x1cc01
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r15), %rsi
addq %r13, %rsi
movq %r14, %rdi
movl $0x9, %edx
callq 0x5830
incq %rbp
movl 0x8(%rbx), %eax
addq $0x20, %r13
cmpq %rax, %rbp
jb 0x1cbdf
movb $0x1, 0x3d9(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1cc17
callq 0x5410
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1cc28
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1cc3a
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ef32
movq (%r14), %rax
movq %r14, %rdi
movl $0x1, %esi
callq *0x18(%rax)
cmpb $0x0, 0x3dd(%r14)
jne 0x1ef4b
leaq 0x718(%r14), %rsi
movq %r14, %rdi
callq 0x249ce
movq 0x8(%rbx), %rdx
leaq 0x1b2b7(%rip), %rcx     # 0x3a20d
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5690
leaq 0x600(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f7ca
leaq 0x608(%r14), %rcx
cmpq %rcx, %rax
je 0x1f046
movq %r12, %rdi
movq %r15, %rsi
callq 0x1b42a
movl (%rax), %r12d
movb 0x2bcfc(%rip), %al      # 0x4ac98
testb %al, %al
je 0x1f04f
movb 0x2be76(%rip), %al      # 0x4ae20
testb %al, %al
je 0x1f059
movq 0x2bce7(%rip), %rax     # 0x4aca0
leaq 0x2bce0(%rip), %r15     # 0x4aca0
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x5750
movl %ebp, %esi
shlq $0x5, %rsi
addq 0x758(%r14), %rsi
leaq 0x2bcce(%rip), %rdi     # 0x4acb0
callq 0x5640
leaq 0x2bc8a(%rip), %rsi     # 0x4ac78
movq %r15, %rdi
movl $0x3a, %edx
callq 0x5830
testl %r12d, %r12d
je 0x1f02f
leaq 0x2bc71(%rip), %r14     # 0x4ac78
movq 0x2bc92(%rip), %rax     # 0x4aca0
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rax,%r15)
jne 0x1f046
movq %r15, %rdi
movq %r14, %rsi
movl $0x3a, %edx
callq 0x5830
decl %r12d
jne 0x1f007
leaq 0x2bc42(%rip), %rsi     # 0x4ac78
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x51f0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5b71
jmp 0x1efa4
leaq 0x2bdc0(%rip), %rdi     # 0x4ae20
callq 0x5810
testl %eax, %eax
je 0x1efb2
leaq 0x2bc2c(%rip), %rdi     # 0x4aca0
callq 0x5310
movq 0x2af18(%rip), %rdi     # 0x49f98
leaq 0x2bc19(%rip), %rsi     # 0x4aca0
leaq 0x2b3ca(%rip), %rdx     # 0x4a458
callq 0x53d0
leaq 0x2bd86(%rip), %rdi     # 0x4ae20
callq 0x5270
jmp 0x1efb2
movq %rax, %rbx
leaq 0x2bd72(%rip), %rdi     # 0x4ae20
callq 0x5250
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x20(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0xf31a
leaq 0x1a5fa(%rip), %rsi     # 0x3a20d
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x1fc70
leaq 0x194e9(%rip), %rsi     # 0x3910f
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x1fc70
leaq 0x1b2c6(%rip), %rsi     # 0x3aeff
movq %r14, %rdi
callq 0x50e0
testl %eax, %eax
je 0x1fc70
testb %bpl, %bpl
je 0x1fd10
movq 0x8(%r14), %rax
cmpq $0xf, %rax
jb 0x1fca6
movb $-0x9, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1fcc1
movb $-0x9, (%rsi)
incq 0x8(%rbx)
jmp 0x1fcce
testb %bpl, %bpl
je 0x1fd35
movb $0x7, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1fc94
movb $0x7, (%rsi)
incq 0x8(%rbx)
jmp 0x1fd35
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a92
jmp 0x1fd35
shlb $0x4, %al
orb $0x7, %al
movb %al, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1fd03
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x1fd10
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a92
movl 0x8(%r14), %eax
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %ecx
callq 0x1fd74
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x1be7e
jmp 0x1fd10
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a92
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
addq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x21a08
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
movq %rbx, %rdx
callq 0x21b80
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1fd44
callq 0x5410
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1fd59
jmp 0x1fd59
jmp 0x1fd59
jmp 0x1fd59
jmp 0x1fd59
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1fd6b
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x20(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0xf31a
movl (%r14), %eax
leal 0x7e(%rax), %ecx
addl $0x7ffe, %eax           # imm = 0x7FFE
cmpl $0xfffd, %eax           # imm = 0xFFFD
movl $0x3, %eax
sbbl $0x0, %eax
cmpl $0xfd, %ecx
movl $0x1, %r15d
cmovael %eax, %r15d
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x1fe58
testb %bpl, %bpl
je 0x1fe07
orb $0x10, %r15b
movb %r15b, 0xf(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1fdfa
movb %r15b, (%rsi)
incq 0x8(%rbx)
jmp 0x1fe07
leaq 0xf(%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 0x1fe2c
callq 0x5410
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1fe3d
jmp 0x1fe3d
jmp 0x1fe3d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1fe4f
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop