LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bcf_file.cpp
// Function: bcf_file::open()
void bcf_file::open()
{
	int ret;

	if (filename.substr(filename.size()-4) == ".vcf")
			LOG.error("Filename ends in '.vcf'. Shouldn't you be using --vcf?\n");

	if (filename.substr(filename.size()-7) == ".vcf.gz")
			LOG.error("Filename ends in '.vcf.gz'. Shouldn't you be using --gzvcf?\n");

	ret = bgzf_is_bgzf(filename.c_str());

	if (ret == 1)
		is_BGZF = true;
	else
		is_BGZF = false;

	if (is_BGZF)
		open_gz();
	else
	{
		file_tmp.open(filename.c_str(), ios::in);
		if (!file_tmp.is_open())
			LOG.error("Could not open VCF file: " + filename, 0);
		file_in = &file_tmp;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x10(%rdi), %rdx
addq $-0x4, %rdx
leaq 0x40(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x54c0
leaq 0x20eeb(%rip), %rsi     # 0x2d411
movq %r15, %rdi
callq 0x96f3
movl %eax, %ebp
movq %r15, %rdi
callq 0x5908
testb %bpl, %bpl
je 0xc571
leaq 0x20ed2(%rip), %rsi     # 0x2d416
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x5160
leaq 0x34f76(%rip), %rdi     # 0x414d0
leaq 0x20(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x2bf18
leaq 0x20(%rsp), %rdi
callq 0x5908
movq 0x10(%rbx), %rdx
addq $-0x7, %rdx
leaq 0x40(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x54c0
leaq 0x20ebb(%rip), %rsi     # 0x2d44e
movq %r15, %rdi
callq 0x96f3
movl %eax, %ebp
movq %r15, %rdi
callq 0x5908
testb %bpl, %bpl
je 0xc5d8
leaq 0x20ea5(%rip), %rsi     # 0x2d456
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x5160
leaq 0x34f0b(%rip), %rdi     # 0x414d0
movq %rsp, %rsi
pushq $0x1
popq %rdx
callq 0x2bf18
movq %rsp, %rdi
callq 0x5908
movq 0x8(%rbx), %rdi
callq 0x2cba8
cmpl $0x1, %eax
jne 0xc5f8
movb $0x1, 0x460(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0xc658
movb $0x0, 0x460(%rbx)
leaq 0x38(%rbx), %r15
movq 0x8(%rbx), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x5260
leaq 0xb0(%rbx), %rdi
callq 0x50d0
testb %al, %al
jne 0xc654
leaq 0x20e6a(%rip), %rsi     # 0x2d493
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x967d
leaq 0x34e90(%rip), %rdi     # 0x414d0
movq %r12, %rsi
xorl %edx, %edx
callq 0x2bf18
leaq 0x60(%rsp), %rdi
callq 0x5908
movq %r15, 0x30(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0xc684
movq %rax, %rbx
movq %rsp, %rdi
jmp 0xc684
jmp 0xc68b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5908
jmp 0xc68e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bcf_file.cpp
// Function: bcf_file::open_gz()
void bcf_file::open_gz()
{
	int ret;
	gzMAX_LINE_LEN = 1024*1024;

	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 BGZF BCF file: " + filename, 0);
	#ifdef ZLIB_VERNUM
		string tmp(ZLIB_VERSION);
		LOG.printLOG("Using zlib version: " + tmp + "\n");
		#if (ZLIB_VERNUM >= 0x1240)
			ret = gzbuffer(gzfile_in, gzMAX_LINE_LEN); // Included in zlib v1.2.4 and makes things MUCH faster
			if (ret != 0)
				LOG.warning("Unable to change zlib buffer size.");
		#else
			LOG.printLOG("Versions of zlib >= 1.2.4 will be *much* faster when reading compressed BCF files.\n");
		#endif
	#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movl $0x100000, 0x240(%rdi)  # imm = 0x100000
cmpb $0x1, 0x462(%rdi)
jne 0xc6d5
movq 0x34903(%rip), %rax     # 0x40fc0
movq (%rax), %rdi
callq 0x54f0
leaq 0x21462(%rip), %rsi     # 0x2db2e
movl %eax, %edi
callq 0x5830
jmp 0xc6e5
movq 0x8(%rbx), %rdi
leaq 0x20dcd(%rip), %rsi     # 0x2d4ad
callq 0x56a0
movq %rax, 0x248(%rbx)
testq %rax, %rax
jne 0xc72a
leaq 0x8(%rbx), %rdx
leaq 0x20db4(%rip), %rsi     # 0x2d4b0
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x967d
leaq 0x34dbd(%rip), %rdi     # 0x414d0
movq %r14, %rsi
xorl %edx, %edx
callq 0x2bf18
leaq 0x88(%rsp), %rdi
callq 0x5908
leaq 0x20d9e(%rip), %rsi     # 0x2d4cf
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5160
leaq 0x20d8f(%rip), %rsi     # 0x2d4d6
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x967d
leaq 0x209ae(%rip), %rdx     # 0x2d10b
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x98b6
leaq 0x34d5d(%rip), %rdi     # 0x414d0
leaq 0x48(%rsp), %rsi
callq 0x2beca
leaq 0x48(%rsp), %rdi
callq 0x5908
leaq 0x8(%rsp), %rdi
callq 0x5908
movq 0x248(%rbx), %rdi
movl 0x240(%rbx), %esi
callq 0x5370
testl %eax, %eax
je 0xc7d8
leaq 0x20d3d(%rip), %rsi     # 0x2d4eb
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5160
leaq 0x34d0c(%rip), %rdi     # 0x414d0
leaq 0x28(%rsp), %rsi
callq 0x2c0bc
leaq 0x28(%rsp), %rdi
callq 0x5908
leaq 0x68(%rsp), %rdi
callq 0x5908
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0xc82e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xc81f
jmp 0xc826
jmp 0xc826
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5908
jmp 0xc81a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0xc829
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
movq %rax, %rbx
jmp 0xc833
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bcf_file.cpp
// Function: bcf_file::read(void*, unsigned int, unsigned long)
int bcf_file::read(void *buffer, unsigned int len, size_t size)
{
	int ret;

	if (is_BGZF)
	{
		ret = gzread(gzfile_in, buffer, size*len);
		ret = (ret == (int)(len*size) );
	}
	else
	{
		file_in->read((char*)buffer, size*len);
		ret = !file_in->eof();
	}

	if ((big_endian) && (size > 1)) // Note: don't both swapping character arrays - BCF is defined as little endian.
	{
		unsigned int ui;
		for (ui=0; ui<len; ui++)
			ByteSwap((unsigned char *)buffer+(size*ui), size);
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x460(%rdi)
movl %edx, %r12d
jne 0xc877
movl %edx, %ebp
movq 0x248(%r15), %rdi
imull %ebx, %ebp
movq %r14, %rsi
movl %ebp, %edx
callq 0x5890
cmpl %ebp, %eax
jmp 0xc89a
movq 0x30(%r15), %rdi
movq %r12, %rdx
imulq %rbx, %rdx
movq %r14, %rsi
callq 0x55b0
movq 0x30(%r15), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
sete %bpl
cmpq $0x2, %rbx
jb 0xc8c6
cmpb $0x0, 0x461(%r15)
jne 0xc8c0
jmp 0xc8c6
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xe986
addq %rbx, %r14
subq $0x1, %r12
jae 0xc8b0
movzbl %bpl, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bcf_file.cpp
// Function: bcf_file::get_entry(std::vector<char, std::allocator<char>>&)
void bcf_file::get_entry(vector<char> &out)
{
	uint32_t size_int[2];
	int ret, read_size = 0;

	ret = read(&size_int[0], 2, sizeof(uint32_t) );
	read_size = size_int[0] + size_int[1];

	if (ret)
	{
		out.resize(read_size+2*sizeof(uint32_t));
		memcpy(&out[0], size_int, 2*sizeof(uint32_t));
		read(&out[2*sizeof(uint32_t)], 1, read_size);
	}
	else
		out.resize(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %rcx
callq 0xc840
testl %eax, %eax
je 0xc950
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
movslq %eax, %r15
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xcc7c
movq (%rbx), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq (%rbx), %rsi
addq $0x8, %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0xc840
jmp 0xc95a
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcc7c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bcf_file.cpp
// Function: bcf_file::eof()
bool bcf_file::eof()
{
	if (is_BGZF)
		return gzeof(gzfile_in);
	else
		return(file_in->eof());
}

// Assembly:
cmpb $0x1, 0x460(%rdi)
jne 0xc9cc
pushq %rax
movq 0x248(%rdi), %rdi
callq 0x5120
addq $0x8, %rsp
jmp 0xc9de
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
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/vcf_file.cpp
// Function: vcf_file::vcf_file(parameters const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
vcf_file::vcf_file(const parameters &p, string &vcf_filename, int idx)
{
	filename = vcf_filename;
	compressed = p.vcf_compressed[idx];
	stream = p.stream_in;

	gzMAX_LINE_LEN = 0;
	N_entries = 0; N_kept_entries = 0;
	meta_data = header();

	if (stream && compressed)
		open_gz();
	else if (stream)
	{
		char first = cin.peek();
		if (first == 0x1f)
			LOG.error("File starts with gzip magic string. Shouldn't you be using --gzvcf?\n");

		file_in = &std::cin;
	}
	else
		open();

	read_header();
	include_indv = vector<bool>(meta_data.N_indv,true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xc9e4
leaq 0x32cec(%rip), %rax     # 0x40b70
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x5210
leaq 0x498(%r14), %rdi
movslq %ebp, %rsi
callq 0x9792
movb %al, 0x28(%rbx)
movb (%r14), %al
movb %al, 0x468(%rbx)
andl $0x0, 0x240(%rbx)
andq $0x0, 0x458(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x103ec
leaq 0x250(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0xca70
leaq 0x28(%rsp), %rdi
callq 0xcb46
cmpb $0x1, 0x468(%rbx)
jne 0xdefa
cmpb $0x1, 0x28(%rbx)
jne 0xdf04
movq (%rbx), %rax
addq $0x8, %rax
jmp 0xdefd
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
jmp 0xdf4f
movq 0x330cd(%rip), %r14     # 0x40fd8
movq %r14, %rdi
callq 0x5150
cmpb $0x1f, %al
jne 0xdf4b
leaq 0x1f64c(%rip), %rsi     # 0x2d56a
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5160
leaq 0x3359c(%rip), %rdi     # 0x414d0
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x2bf18
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %r14, 0x30(%rbx)
movq %rbx, %rdi
callq 0xdfda
movl 0x2a8(%rbx), %esi
leaq 0x7(%rsp), %rdx
movb $0x1, (%rdx)
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rcx
callq 0xcbc6
addq $0x430, %rbx            # imm = 0x430
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcc2a
movq %r14, %rdi
callq 0xa0a6
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0xdfca
jmp 0xdfc7
jmp 0xdfc7
jmp 0xdfc7
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xcb46
jmp 0xdfca
jmp 0xdfc7
movq %rax, %r14
movq %rbx, %rdi
callq 0xe8e0
movq %r14, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x1f530(%rip), %rsi     # 0x2d530
leaq 0x28(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x5160
leaq 0x250(%rbx), %r14
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x110f6
leaq 0x4(%rsp), %r15
movl %eax, (%r15)
leaq 0x28(%rsp), %rdi
callq 0x5908
leaq 0x8(%rsp), %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testb %al, %al
jne 0xe081
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe5a4
movq 0x8(%rsp), %rax
cmpb $0x23, (%rax)
jne 0xe081
cmpb $0x23, 0x1(%rax)
jne 0xe074
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10566
jmp 0xe03c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x12206
leaq 0x8(%rsp), %rdi
callq 0x5908
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xe0aa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5908
jmp 0xe0ad
jmp 0xe0aa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x88, %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 0xe3b6
movq 0x32c22(%rip), %rax     # 0x40fc0
movq (%rax), %rdi
callq 0x54f0
leaq 0x1f781(%rip), %rsi     # 0x2db2e
movl %eax, %edi
callq 0x5830
jmp 0xe3c6
movq 0x8(%rbx), %rdi
leaq 0x1f0ec(%rip), %rsi     # 0x2d4ad
callq 0x56a0
movq %rax, 0x248(%rbx)
testq %rax, %rax
jne 0xe405
leaq 0x8(%rbx), %rdx
leaq 0x1f2a4(%rip), %rsi     # 0x2d681
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x967d
leaq 0x330df(%rip), %rdi     # 0x414d0
movq %r14, %rsi
xorl %edx, %edx
callq 0x2bf18
leaq 0x68(%rsp), %rdi
callq 0x5908
leaq 0x1f0c3(%rip), %rsi     # 0x2d4cf
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5160
leaq 0x1f0b4(%rip), %rsi     # 0x2d4d6
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x967d
leaq 0x1ecd3(%rip), %rdx     # 0x2d10b
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x98b6
leaq 0x33082(%rip), %rdi     # 0x414d0
leaq 0x28(%rsp), %rsi
callq 0x2beca
leaq 0x28(%rsp), %rdi
callq 0x5908
leaq 0x8(%rsp), %rdi
callq 0x5908
movq 0x248(%rbx), %rdi
movl 0x240(%rbx), %esi
callq 0x5370
leaq 0x48(%rsp), %rdi
callq 0x5908
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0xe4c5
jmp 0xe4bd
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5908
jmp 0xe4b1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0xe4c0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5908
movq %rbx, %rdi
callq 0x5800
movq %rax, %rbx
jmp 0xe4ca
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe519
pushq %rax
movq 0x248(%rdi), %rdi
callq 0x5120
addq $0x8, %rsp
jmp 0xe52b
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20882(%rip), %rsi     # 0x2ee37
movq %rbx, %rdi
callq 0x58b0
cmpb $0x1, 0x28(%r14)
jne 0xe60e
movq 0x248(%r14), %rdi
movq 0x460(%r14), %rsi
movl 0x240(%r14), %edx
callq 0x57b0
testq %rax, %rax
je 0xe646
movq 0x460(%r14), %rsi
movq %rbx, %rdi
callq 0x58a0
movq 0x460(%r14), %rdi
callq 0x5190
movl 0x240(%r14), %ecx
decl %ecx
cmpq %rcx, %rax
je 0xe5c4
jmp 0xe61a
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x5090
leaq 0x1f07c(%rip), %rsi     # 0x2d69d
pushq $-0x1
popq %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5840
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x50c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x330e5(%rip), %al      # 0x41748
testb %al, %al
je 0xe6d4
leaq 0x330ba(%rip), %r15     # 0x41728
leaq 0x207c2(%rip), %rsi     # 0x2ee37
movq %r15, %rdi
callq 0x58b0
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcc7c
movq %r14, %rdi
movq %r15, %rsi
callq 0xe5a4
movq 0x3308f(%rip), %rsi     # 0x41728
movq 0x33090(%rip), %rdx     # 0x41730
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
callq 0xe742
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe774
leaq 0x8(%rsp), %rdi
callq 0xe88a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3306d(%rip), %rdi     # 0x41748
callq 0x5850
testl %eax, %eax
je 0xe667
leaq 0x3304d(%rip), %rax     # 0x41738
movq %rax, 0x33036(%rip)     # 0x41728
leaq 0x3302f(%rip), %rsi     # 0x41728
andq $0x0, 0x3302f(%rip)     # 0x41730
movb $0x0, 0x33030(%rip)     # 0x41738
movq 0x32899(%rip), %rdi     # 0x40fa8
leaq 0x32d6a(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x33026(%rip), %rdi     # 0x41748
callq 0x5290
jmp 0xe667
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe88a
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x430(%rdi), %r14
xorl %ebp, %ebp
xorl %eax, %eax
movl %eax, %r15d
movq 0x440(%rbx), %rax
movl 0x448(%rbx), %ecx
subq 0x430(%rbx), %rax
leaq (%rcx,%rax,8), %rax
cmpq %r15, %rax
jbe 0xe969
movq %r14, %rdi
movq %r15, %rsi
callq 0x9792
movzbl %al, %eax
addl %eax, %ebp
leal 0x1(%r15), %eax
jmp 0xe933
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq %edx, %rax
decq %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xe9a9
movb (%rsi,%rcx), %dl
movb (%rsi,%rax), %dil
movb %dil, (%rsi,%rcx)
movb %dl, (%rsi,%rax)
incq %rcx
decq %rax
jmp 0xe98e
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5300
leaq 0x40(%rsp), %r13
leaq 0x7(%rsp), %rbp
pushq $0x1
popq %r15
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x55b0
movb 0x7(%rsp), %al
cmpb $0xa, %al
je 0xec94
movsbl %al, %esi
movq %r13, %rdi
callq 0x5530
jmp 0xec71
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x56f0
leaq 0x10(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x5580
movq %r15, %rdi
callq 0x5908
pushq $0x4
popq %rdx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x55b0
movq (%rbx), %rax
xorl %ecx, %ecx
leaq 0x10(%rsp), %r15
pushq $0x1
popq %r12
pushq $-0x1
popq %rbp
movl %ecx, %r13d
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0xed32
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x55b0
movzbl 0x10(%rsp), %ecx
movl %ecx, %edx
andl $0x3, %edx
cmpl $0x2, %edx
cmovel %ebp, %edx
movq (%rbx), %rax
movl %edx, 0x4(%rax,%r13,8)
sarb $0x4, %cl
movb %cl, 0x10(%rsp)
andb $0x3, %cl
cmpb $0x2, %cl
movzbl %cl, %ecx
cmovel %ebp, %ecx
movl %ecx, (%rax,%r13,8)
leal 0x1(%r13), %ecx
jmp 0xecdc
leaq 0x30(%rsp), %rdi
callq 0x5360
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xed54
jmp 0xed54
jmp 0xed54
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5360
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5300
leaq 0x50(%rsp), %rbp
leaq 0xf(%rsp), %r15
pushq $0x1
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x55b0
movb 0xf(%rsp), %al
cmpb $0xa, %al
je 0xedc9
movsbl %al, %esi
movq %rbp, %rdi
callq 0x5530
jmp 0xeda6
leaq 0x58(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x56f0
leaq 0x20(%rsp), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x5580
movq %r15, %rdi
callq 0x5908
pushq $0x4
popq %rdx
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0x55b0
leaq 0x20(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x55b0
movsbl 0x20(%rsp), %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
leaq 0xe(%rsp), %r15
movb $-0x1, (%r15)
movq (%rbx), %rax
xorl %ecx, %ecx
pushq $0x1
popq %r12
movl %ecx, %r13d
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0xee7c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x55b0
movsbl 0xe(%rsp), %eax
movq (%rbx), %rcx
movl %eax, (%rcx,%r13,8)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x55b0
movsbl 0xe(%rsp), %ecx
movq (%rbx), %rax
movl %ecx, 0x4(%rax,%r13,8)
leal 0x1(%r13), %ecx
jmp 0xee2e
leaq 0x40(%rsp), %rdi
callq 0x5360
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xeea0
jmp 0xeea0
jmp 0xeea0
jmp 0xeea0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5360
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rdi
xorl %esi, %esi
callq 0xfd72
leaq 0x28(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5770
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5870
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x12740
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfda2
jmp 0x12718
leaq 0x8(%rsp), %rdi
callq 0x5908
leaq 0x28(%rsp), %rdi
callq 0x5910
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
leaq 0x28(%rsp), %rdi
callq 0x5910
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x127a2
movq %rdi, %r14
leaq 0x1b994(%rip), %rsi     # 0x2e12d
callq 0x96f3
testb %al, %al
je 0x127ac
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x56d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
andl $0x0, 0x4(%rsp)
movb $0x0, 0x8(%rdi)
andl $0x0, (%rdi)
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %r14
leaq 0x1c30a(%rip), %rsi     # 0x2ee37
leaq 0x8(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x5160
subq %r15, %r14
sarq $0x5, %r14
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x3(%rsp), %rcx
movq %r14, %rsi
callq 0x131d2
leaq 0x8(%rsp), %rdi
callq 0x5908
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x28(%rsp), %rdx
callq 0x13b18
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0xfd72
leaq 0x60(%rbx), %rdi
callq 0x13b20
leaq 0x180(%rbx), %rdi
callq 0x13b4e
leaq 0x90(%rbx), %rdi
callq 0x13b20
leaq 0x150(%rbx), %rdi
callq 0x13b4e
leaq 0xc0(%rbx), %rdi
callq 0x13b20
leaq 0x1b0(%rbx), %rdi
callq 0x13b4e
leaq 0xf0(%rbx), %rdi
callq 0x13b20
leaq 0x120(%rbx), %rdi
callq 0x13b4e
leaq 0x1a94b(%rip), %rsi     # 0x2d530
leaq 0x8(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x5160
leaq 0x8(%rsp), %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x110f6
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x5908
movl %r15d, %r15d
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r15, %rax
jbe 0x12c4b
movq %r15, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10566
incl %r15d
jmp 0x12c18
leaq 0x28(%rsp), %rdi
callq 0x9f1c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0x12c89
jmp 0x12c86
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5908
jmp 0x12c93
movq %rax, %rbx
jmp 0x12c93
jmp 0x12c86
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9f1c
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movq %rdi, %rbx
cmpl %edx, %esi
jne 0x12cc1
leaq 0x1b47b(%rip), %rsi     # 0x2e12d
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x5160
jmp 0x12d33
movl %esi, %ebp
movb 0x2ec2f(%rip), %al      # 0x418f8
testb %al, %al
je 0x12d3f
leaq 0x1c163(%rip), %rsi     # 0x2ee37
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5160
leaq 0x2ea9e(%rip), %rdi     # 0x41788
leaq 0x10(%rsp), %rsi
callq 0x5690
leaq 0x10(%rsp), %rdi
callq 0x5908
leaq 0x2ea7b(%rip), %r14     # 0x41780
movq 0x2ea74(%rip), %rax     # 0x41780
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x5790
movq %r14, %rdi
movl %ebp, %esi
callq 0x57e0
leaq 0x2ea5d(%rip), %rsi     # 0x41788
movq %rbx, %rdi
callq 0x56f0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2ebb2(%rip), %rdi     # 0x418f8
callq 0x5850
testl %eax, %eax
je 0x12ccd
leaq 0x2ea26(%rip), %rdi     # 0x41780
callq 0x5610
movq 0x2e22a(%rip), %rdi     # 0x40f90
leaq 0x2ea13(%rip), %rsi     # 0x41780
leaq 0x2e70c(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x2eb78(%rip), %rdi     # 0x418f8
callq 0x5290
jmp 0x12ccd
movq %rax, %rbx
leaq 0x2eb64(%rip), %rdi     # 0x418f8
callq 0x5270
jmp 0x12dad
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5908
jmp 0x12dad
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5800
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12de1
movq %rdi, %rbx
leaq 0x1b361(%rip), %rsi     # 0x2e12d
movsd %xmm0, 0x8(%rsp)
callq 0x96f3
movsd 0x8(%rsp), %xmm0
testb %al, %al
je 0x12de7
addq $0x10, %rsp
popq %rbx
retq
movq (%rbx), %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x55a0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rdi, %rbx
ucomisd %xmm1, %xmm0
jne 0x12e1c
jp 0x12e1c
leaq 0x1b320(%rip), %rsi     # 0x2e12d
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x5160
jmp 0x12e96
movsd %xmm0, 0x10(%rsp)
movb 0x2ec50(%rip), %al      # 0x41a78
testb %al, %al
je 0x12ea1
leaq 0x1c004(%rip), %rsi     # 0x2ee37
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5160
leaq 0x2eabf(%rip), %rdi     # 0x41908
leaq 0x18(%rsp), %rsi
callq 0x5690
leaq 0x18(%rsp), %rdi
callq 0x5908
leaq 0x2ea9c(%rip), %r14     # 0x41900
movq 0x2ea95(%rip), %rax     # 0x41900
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x5790
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x5720
leaq 0x2ea7a(%rip), %rsi     # 0x41908
movq %rbx, %rdi
callq 0x56f0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x2ebd0(%rip), %rdi     # 0x41a78
callq 0x5850
testl %eax, %eax
je 0x12e2c
leaq 0x2ea44(%rip), %rdi     # 0x41900
callq 0x5610
movq 0x2e0c8(%rip), %rdi     # 0x40f90
leaq 0x2ea31(%rip), %rsi     # 0x41900
leaq 0x2e5aa(%rip), %rdx     # 0x41480
callq 0x53f0
leaq 0x2eb96(%rip), %rdi     # 0x41a78
callq 0x5290
jmp 0x12e2c
movq %rax, %rbx
leaq 0x2eb82(%rip), %rdi     # 0x41a78
callq 0x5270
jmp 0x12f0f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5908
jmp 0x12f0f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
andl $0x0, 0x3db(%rdi)
andl $0x0, 0x3d8(%rdi)
movb $0x1, %bpl
movb %bpl, 0xc(%rdi)
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0xe774
movq 0x560(%rbx), %rdi
movq 0x570(%rbx), %rdx
movl 0x578(%rbx), %ecx
xorl %r14d, %r14d
leaq 0xf(%rsp), %r8
movb %r14b, (%r8)
xorl %esi, %esi
callq 0x16799
movq 0x588(%rbx), %rdi
movq 0x598(%rbx), %rdx
movl 0x5a0(%rbx), %ecx
leaq 0xe(%rsp), %r8
movb %r14b, (%r8)
xorl %esi, %esi
callq 0x16799
movq 0x5b0(%rbx), %rdi
movq 0x5c0(%rbx), %rdx
movl 0x5c8(%rbx), %ecx
leaq 0xd(%rsp), %r8
movb %r14b, (%r8)
xorl %esi, %esi
callq 0x16799
movq 0x5d8(%rbx), %rdi
movq 0x5e8(%rbx), %rdx
movl 0x5f0(%rbx), %ecx
leaq 0xc(%rsp), %r8
movb %r14b, (%r8)
xorl %esi, %esi
callq 0x16799
movq 0x218(%rbx), %rdi
movq 0x228(%rbx), %rdx
movl 0x230(%rbx), %ecx
leaq 0xb(%rsp), %r8
movb %bpl, (%r8)
xorl %esi, %esi
callq 0x16799
xorps %xmm0, %xmm0
movups %xmm0, 0x6e8(%rbx)
movq 0x640(%rbx), %rax
cmpq %rax, 0x648(%rbx)
je 0x13f2f
movq %rax, 0x648(%rbx)
movq 0x658(%rbx), %rax
cmpq %rax, 0x660(%rbx)
je 0x13f46
movq %rax, 0x660(%rbx)
movq 0x670(%rbx), %rax
cmpq %rax, 0x678(%rbx)
je 0x13f5d
movq %rax, 0x678(%rbx)
movq 0x688(%rbx), %rax
cmpq %rax, 0x690(%rbx)
je 0x13f74
movq %rax, 0x690(%rbx)
movq 0x6a0(%rbx), %rax
cmpq %rax, 0x6a8(%rbx)
je 0x13f8b
movq %rax, 0x6a8(%rbx)
andq $0x0, 0x4c8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1435c
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x3d8(%rdi)
jne 0x142d9
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 0x162cc
leaq 0x658(%rbx), %rdi
movl 0x6bc(%rbx), %esi
callq 0x162cc
leaq 0x670(%rbx), %rdi
movl 0x6bc(%rbx), %esi
callq 0x162cc
leaq 0x688(%rbx), %rdi
movl 0x6bc(%rbx), %esi
callq 0x162cc
leaq 0x6a0(%rbx), %rdi
movl 0x6bc(%rbx), %esi
callq 0x162cc
testb %bpl, %bpl
je 0x1434f
movq %rbx, %rdi
callq 0x20588
movb $0x1, 0x3d9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
cmpb $0x0, 0x3d9(%rdi)
jne 0x14388
movq (%rbx), %rax
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq *0x18(%rax)
cmpl $-0x1, 0x634(%rbx)
je 0x14400
leaq 0x588(%rbx), %r14
leaq 0x218(%rbx), %r15
xorl %r12d, %r12d
pushq $0x1
popq %rbp
movl 0x8(%rbx), %eax
cmpq %rax, %r12
jae 0x14400
movq %r14, %rdi
movq %r12, %rsi
callq 0x9cc0
testq %rdx, (%rax)
jne 0x143d3
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x20(%rax)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1cc02
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x143fb
movq %r15, %rdi
movq %r12, %rsi
callq 0x9cc0
notq %rdx
andq %rdx, (%rax)
incq %r12
jmp 0x143a5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14435
movq (%r14), %rax
pushq $0x1
popq %rsi
movq %r14, %rdi
callq *0x18(%rax)
cmpl $-0x1, 0x638(%r14)
je 0x144af
leaq 0x5b0(%r14), %r15
leaq 0x218(%r14), %r12
xorl %r13d, %r13d
movl 0x8(%r14), %eax
cmpq %rax, %r13
jae 0x144af
movq %r15, %rdi
movq %r13, %rsi
callq 0x9cc0
testq %rdx, (%rax)
jne 0x14480
movq (%r14), %rax
movq %r14, %rdi
movl %r13d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
pushq $0x1
popq %r8
xorl %r9d, %r9d
callq *0x20(%rax)
movq %r14, %rdi
movl %r13d, %esi
callq 0x1cba6
cmpl %ebp, %eax
setge %cl
cmpl %ebx, %eax
setle %al
testb %al, %cl
jne 0x144aa
movq %r12, %rdi
movq %r13, %rsi
callq 0x9cc0
notq %rdx
andq %rdx, (%rax)
incq %r13
jmp 0x14450
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0x3d9(%rdi)
jne 0x144eb
movq (%r15), %rax
pushq $0x1
popq %rsi
movq %r15, %rdi
callq *0x18(%rax)
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
cmpl $-0x1, 0x63c(%r15)
je 0x145fe
leaq 0x5d8(%r15), %rax
movq %rax, 0x30(%rsp)
leaq 0x8(%r14), %rbx
leaq 0x218(%r15), %r13
xorl %ebp, %ebp
movl 0x8(%r15), %eax
cmpq %rax, %rbp
jae 0x145fe
movq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0x9cc0
testq %rdx, (%rax)
jne 0x14555
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq $0x1
popq %r9
callq *0x20(%rax)
movq %r15, %rdi
movl %ebp, %esi
leaq 0x10(%rsp), %rdx
callq 0x1cc64
cmpb $0x0, 0xc(%rsp)
je 0x145b5
movq 0x10(%rsp), %rdi
cmpq 0x18(%rsp), %rdi
je 0x145ad
leaq 0x18fc6(%rip), %rsi     # 0x2d544
callq 0x12f17
testb %al, %al
je 0x145ad
movq 0x10(%rsp), %rdi
leaq 0x19b9a(%rip), %rsi     # 0x2e12d
callq 0x12f17
testb %al, %al
je 0x145ad
movq %r13, %rdi
movq %rbp, %rsi
callq 0x9cc0
notq %rdx
andq %rdx, (%rax)
incq %rbp
jmp 0x14520
xorl %r12d, %r12d
movl %r12d, %r12d
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x145ad
movq %r12, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r14, %rdi
callq 0x16988
cmpq %rbx, %rax
je 0x145f9
movq %r13, %rdi
movq %rbp, %rsi
callq 0x9cc0
notq %rdx
andq %rdx, (%rax)
incl %r12d
jmp 0x145b8
leaq 0x10(%rsp), %rdi
callq 0x9f1c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1461f
jmp 0x1461f
jmp 0x1461f
jmp 0x1461f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9f1c
movq %rbx, %rdi
callq 0x5800
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/vcf_entry.cpp
// Function: vcf_entry::reset(std::vector<char, std::allocator<char>> const&)
void vcf_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;

	data_stream.clear();
	line = data_line;

	convert_line.assign(line.begin(), line.end());
	data_stream.str(convert_line);

	fill(parsed_GT.begin(), parsed_GT.end(), 0);
	fill(parsed_GQ.begin(), parsed_GQ.end(), 0);
	fill(parsed_DP.begin(), parsed_DP.end(), 0);
	fill(parsed_FT.begin(), parsed_FT.end(), 0);
	fill(include_genotype.begin(), include_genotype.end(), 1);

	N_INFO_removed = 0; N_FORMAT_removed = 0;
	FORMAT_positions.clear(); FORMAT_types.clear(); FORMAT_sizes.clear(); FORMAT_skip.clear(); FORMAT_keys.clear();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andl $0x0, 0x3db(%rdi)
andl $0x0, 0x3d8(%rdi)
movb $0x1, 0xc(%rdi)
addq $0x240, %rdi            # imm = 0x240
movq 0x240(%rbx), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x5790
leaq 0x3c0(%rbx), %rdi
movq %r14, %rsi
callq 0xe774
movq 0x3c0(%rbx), %rsi
movq 0x3c8(%rbx), %rdx
leaq 0x2a631(%rip), %r14     # 0x41ad0
movq %r14, %rdi
callq 0x197da
leaq 0x250(%rbx), %rdi
movq %r14, %rsi
callq 0x5690
movq 0x560(%rbx), %rdi
movq 0x570(%rbx), %rdx
movl 0x578(%rbx), %ecx
leaq 0x4(%rsp), %r14
andl $0x0, (%r14)
xorl %esi, %esi
movq %r14, %r8
callq 0x19964
movq 0x588(%rbx), %rdi
movq 0x598(%rbx), %rdx
movl 0x5a0(%rbx), %ecx
andl $0x0, (%r14)
leaq 0x4(%rsp), %r14
xorl %esi, %esi
movq %r14, %r8
callq 0x19964
movq 0x5b0(%rbx), %rdi
movq 0x5c0(%rbx), %rdx
movl 0x5c8(%rbx), %ecx
andl $0x0, (%r14)
leaq 0x4(%rsp), %r14
xorl %esi, %esi
movq %r14, %r8
callq 0x19964
movq 0x5d8(%rbx), %rdi
movq 0x5e8(%rbx), %rdx
movl 0x5f0(%rbx), %ecx
andl $0x0, (%r14)
leaq 0x4(%rsp), %r14
xorl %esi, %esi
movq %r14, %r8
callq 0x19964
movq 0x218(%rbx), %rdi
movq 0x228(%rbx), %rdx
movl 0x230(%rbx), %ecx
movl $0x1, (%r14)
leaq 0x4(%rsp), %r8
xorl %esi, %esi
callq 0x19964
andq $0x0, 0x4c8(%rbx)
movq 0x640(%rbx), %rax
cmpq %rax, 0x648(%rbx)
je 0x17598
movq %rax, 0x648(%rbx)
movq 0x658(%rbx), %rax
cmpq %rax, 0x660(%rbx)
je 0x175af
movq %rax, 0x660(%rbx)
movq 0x670(%rbx), %rax
cmpq %rax, 0x678(%rbx)
je 0x175c6
movq %rax, 0x678(%rbx)
movq 0x688(%rbx), %rax
cmpq %rax, 0x690(%rbx)
je 0x175dd
movq %rax, 0x690(%rbx)
movq 0x6a0(%rbx), %rax
cmpq %rax, 0x6a8(%rbx)
je 0x175f4
movq %rax, 0x6a8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
je 0x17681
movb $0x1, 0x3d8(%rbx)
testb %r15b, %r15b
je 0x17641
cmpb $0x0, 0x3da(%rbx)
jne 0x17641
leaq 0x6b8(%rbx), %rsi
movq %rbx, %rdi
callq 0x1def4
testb %r14b, %r14b
je 0x1765e
cmpb $0x0, 0x3db(%rbx)
jne 0x1765e
leaq 0x6d8(%rbx), %rsi
movq %rbx, %rdi
callq 0x1eb28
cmpb $0x0, 0x4(%rsp)
je 0x17672
cmpb $0x0, 0x3dc(%rbx)
je 0x1779c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x240(%rbx), %r12
leaq 0x3e0(%rbx), %rsi
pushq $0x9
popq %r13
movq %r12, %rdi
movl %r13d, %edx
callq 0x5870
leaq 0x408(%rbx), %rbp
movq %r12, %rdi
movq %rbp, %rsi
movl %r13d, %edx
callq 0x5870
movq 0x408(%rbx), %rdi
callq 0x56d0
movl %eax, 0x400(%rbx)
movq %r12, %rdi
movq %rbp, %rsi
movl %r13d, %edx
callq 0x5870
leaq 0x428(%rbx), %rsi
movq %r12, %rdi
movl %r13d, %edx
callq 0x5870
leaq 0x6b8(%rbx), %rsi
movq %r12, %rdi
movl %r13d, %edx
callq 0x5870
leaq 0x738(%rbx), %rbp
movq %r12, %rdi
movq %rbp, %rsi
movl %r13d, %edx
callq 0x5870
leaq 0x6d8(%rbx), %rsi
movq %r12, %rdi
movl %r13d, %edx
callq 0x5870
leaq 0x6f8(%rbx), %rsi
movq %r12, %rdi
movl %r13d, %edx
callq 0x5870
movsd 0x16848(%rip), %xmm0    # 0x2df80
movq %rbp, %rdi
callq 0x12db6
movsd %xmm0, 0x460(%rbx)
movq 0x428(%rbx), %r12
movq 0x430(%rbx), %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x17770
movsbl (%r12,%rbp), %edi
callq 0x5880
movb %al, (%r12,%rbp)
incq %rbp
jmp 0x17758
movq 0x6b8(%rbx), %r12
movq 0x6c0(%rbx), %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x1761d
movsbl (%r12,%rbp), %edi
callq 0x5880
movb %al, (%r12,%rbp)
incq %rbp
jmp 0x17780
leaq 0x6f8(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ec0e
nop