LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/titusnicolae[P]imgdiff2/imgdiff.cpp
// Function: PNG::hash()
void hash()
    {
        int block_size = 8;

        for(int x=0;x<w-block_size;x++)
        {
            for(int y=0;y<h-block_size;y++)
            {
                long long int crc = 0;
                for(int i=0;i<block_size;i++)
                {
                    for(int j=0;j<block_size;j++)
                    {
                        crc = ((crc*mul) + rgb(x+i, y+j)) % prime;
                    }
                }
                asd[crc].push_back(Point(x,y));
            }
        }
        cout<<(w-block_size)*(h-block_size)<<" "<<asd.size()<<endl;

    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl $0x8, %eax
jne 0x3011
movl 0x24(%rbx), %esi
xorl %ecx, %ecx
jmp 0x3133
leaq 0x40(%rbx), %r14
movl 0x24(%rbx), %esi
xorl %r13d, %r13d
movabsq $0x16f9bedd5c429cc9, %rbp # imm = 0x16F9BEDD5C429CC9
movl %esi, %edi
movl $0x8, %edx
cmpl $0x8, %edi
je 0x3122
xorl %r12d, %r12d
movq $0x0, 0x10(%rsp)
movl 0x20(%rbx), %edi
movq 0x28(%rbx), %r8
movl %edi, %r9d
imull %r12d, %r9d
addl %r13d, %r9d
shll $0x2, %r9d
shll $0x2, %edi
xorl %r10d, %r10d
xorl %esi, %esi
movl $0x8, %r11d
movl %r9d, %r15d
movl %r15d, %eax
movzbl (%r8,%rax), %eax
leal 0x1(%r15), %ecx
movb (%r8,%rcx), %cl
addb $0x10, %cl
shll %cl, %eax
leal 0x2(%r15), %ecx
movb (%r8,%rcx), %cl
addb $0x8, %cl
shll %cl, %eax
imulq $0x167, %rsi, %rcx      # imm = 0x167
movslq %eax, %rsi
addq %rcx, %rsi
movq %rsi, %rax
imulq %rbp
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1b, %rdx
addq %rax, %rdx
imulq $0x59235eb5, %rdx, %rax # imm = 0x59235EB5
subq %rax, %rsi
movq %rsi, 0x10(%rsp)
addl %edi, %r15d
decq %r11
jne 0x3067
incl %r10d
addl $0x4, %r9d
cmpl $0x8, %r10d
jne 0x305e
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3342
movl %r13d, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x30fe
movq 0x8(%rsp), %rcx
movq %rcx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x310b
movq %rax, %rdi
leaq 0x8(%rsp), %rdx
callq 0x362c
incq %r12
movl 0x24(%rbx), %esi
leal -0x8(%rsi), %eax
cmpq %rax, %r12
jb 0x3038
movl 0x20(%rbx), %eax
movl %esi, %edx
incl %r13d
leal -0x8(%rax), %ecx
movl %edx, %edi
cmpl %ecx, %r13d
jb 0x3027
addl $-0x8, %esi
imull %ecx, %esi
movq 0x13e98(%rip), %rdi     # 0x16fd8
callq 0x2120
movq %rax, %r14
leaq 0xdec5(%rip), %rsi      # 0x11014
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
movq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/titusnicolae[P]imgdiff2/lodepng.cpp
// Function: bpmnode_compare(void const*, void const*)
static int bpmnode_compare(const void* a, const void* b)
{
  int wa = ((const BPMNode*)a)->weight;
  int wb = ((const BPMNode*)b)->weight;
  if(wa < wb) return -1;
  if(wa > wb) return 1;
  /*make the qsort a stable sort*/
  return ((const BPMNode*)a)->index < ((const BPMNode*)b)->index ? 1 : -1;
}

// Assembly:
movl (%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, (%rdi)
jl 0x3f2f
movl $0x1, %eax
jg 0x3f2f
movl 0x4(%rdi), %ecx
xorl %eax, %eax
cmpl 0x4(%rsi), %ecx
adcl $-0x1, %eax
orl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/titusnicolae[P]imgdiff2/lodepng.cpp
// Function: lodepng::load_file(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned load_file(std::vector<unsigned char>& buffer, const std::string& filename)
{
  std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);
  if(!file) return 78;

  /*get filesize*/
  std::streamsize size = 0;
  if(file.seekg(0, std::ios::end).good()) size = file.tellg();
  if(file.seekg(0, std::ios::beg).good()) size -= file.tellg();

  /*read contents of the file into the vector*/
  buffer.resize(size_t(size));
  if(size > 0) file.read((char*)(&buffer[0]), size);

  return 0; /* OK */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0xe, %edx
callq 0x2340
movq (%r14), %rax
movq -0x18(%rax), %rax
movl $0x4e, %ebp
testb $0x5, 0x28(%rsp,%rax)
jne 0xcf4c
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2270
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
je 0xcef4
xorl %r14d, %r14d
jmp 0xcf01
leaq 0x8(%rsp), %rdi
callq 0x2310
movq %rax, %r14
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2270
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
jne 0xcf2a
leaq 0x8(%rsp), %rdi
callq 0x2310
subq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd9a
xorl %ebp, %ebp
testq %r14, %r14
jle 0xcf4c
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x2230
leaq 0x8(%rsp), %rdi
callq 0x2060
movl %ebp, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xcf68
jmp 0xcf68
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/titusnicolae[P]imgdiff2/lodepng.cpp
// Function: lodepng::save_file(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned save_file(const std::vector<unsigned char>& buffer, const std::string& filename)
{
  std::ofstream file(filename.c_str(), std::ios::out|std::ios::binary);
  if(!file) return 79;
  file.write(buffer.empty() ? 0 : (char*)&buffer[0], std::streamsize(buffer.size()));
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %r14
movq (%rsi), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x14, %edx
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl $0x4f, %ebx
testb $0x5, 0x28(%rsp,%rax)
jne 0xcfd1
movq (%r14), %rax
movq 0x8(%r14), %rdx
xorl %ebx, %ebx
subq %rax, %rdx
movl $0x0, %esi
cmovneq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x2240
movq 0x9ff8(%rip), %rax      # 0x16fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2170
leaq 0x100(%rsp), %rdi
callq 0x2090
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/test/evaluator_test.cpp
// Function: testEval(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Object *testEval(std::string input)
{
	Lexer lexer;
	lexer.New(input);

	Parser parser;
	parser.New(lexer);

	Program *program = parser.ParseProgram();

	Evaluator evaluator;
	Environment *env = new Environment();

	Object *obj = evaluator.Eval(program, env);
	return obj;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rsi
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rdi
callq 0xce5a
leaq 0x38(%rsp), %rdi
callq 0x1385c
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x13d2c
leaq 0x38(%rsp), %rdi
callq 0x15e8c
movq %rax, %rbx
movl $0x40, %edi
callq 0x51b0
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
leaq 0x7(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1f0e6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xbcec
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xba4a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0xba5e
jmp 0xba5e
jmp 0xba5e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xbcec
jmp 0xba72
jmp 0xba6f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xba89
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/test/evaluator_test.cpp
// Function: testIntegerObject(Object*, int)
void testIntegerObject(Object *obj, int expected)
{
	if (obj->type() != "INTEGER")
		std::cout << "object is not Integer, got=" << obj->type() << std::endl;

	Integer *intObj = (Integer *)obj;

	std::cout << intObj->value << std::endl;

	if (intObj->value != expected)
		std::cout << "object has wrong value, got=" << intObj->value << " want=" << expected << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x1d55b(%rip), %rsi     # 0x29016
movq %r15, %rdi
callq 0x50a0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x18(%rsp), %r13
cmpq %r13, %rdi
je 0xbadf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
testl %ebp, %ebp
je 0xbb60
movq 0x294ee(%rip), %r15     # 0x34fd8
leaq 0x1d5ab(%rip), %rsi     # 0x2909c
movl $0x1b, %edx
movq %r15, %rdi
callq 0x5200
movq (%r14), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x5200
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5130
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xbb60
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movl 0x8(%r14), %esi
movq 0x2946d(%rip), %rdi     # 0x34fd8
callq 0x5320
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5130
cmpl %ebx, 0x8(%r14)
je 0xbc12
movq 0x29431(%rip), %r15     # 0x34fd8
leaq 0x1d50a(%rip), %rsi     # 0x290b8
movl $0x1c, %edx
movq %r15, %rdi
callq 0x5200
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x5320
movq %rax, %r14
leaq 0x1d504(%rip), %rsi     # 0x290d5
movl $0x6, %edx
movq %rax, %rdi
callq 0x5200
movq %r14, %rdi
movl %ebx, %esi
callq 0x5320
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x51a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xbc3b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/tonymugen[P]sampleSNPs/populations.cpp
// Function: sampFiles::PopIndex::PopIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
PopIndex::PopIndex(const string &inFileName){
	ifstream idxFl(inFileName.c_str());
	
	if (!idxFl) {
		cerr << "ERROR: cannot open file " << inFileName << endl;
		exit(1);
	}
	int tmpIn;
	_N = 0;
	while (idxFl >> tmpIn) {
		if (tmpIn < 0) {
			cerr << "ERROR: negative population IDs not allowed when initializing PopIndex" << endl;
			exit(1);
		}
		else if (tmpIn == 0) {
			cerr << "ERROR: population indexes should be base-1 when initializing PopIndex" << endl;
			exit(2);
		}
		if (tmpIn > _popInd.size()) {
			_popInd.resize(tmpIn); // maybe this popID is a few steps ahead of the current
			_popInd[tmpIn - 1].push_back(_N);
			_N++;
		}
		else {
			_popInd[tmpIn - 1].push_back(_N);
			_N++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
leaq 0x8(%rsp), %rdi
movl $0x8, %edx
callq 0x44e0
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x15cda
leaq 0x18(%rbx), %r14
xorl %eax, %eax
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq %rax, (%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x15c63
movslq 0x4(%rsp), %rsi
testq %rsi, %rsi
js 0x15c7e
testl %esi, %esi
je 0x15cac
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r13, %rcx
cmpq %rsi, %rcx
jae 0x15c21
movq %rbx, %rdi
callq 0x15d36
movslq 0x4(%rsp), %rcx
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
jmp 0x15c25
leaq (%rsi,%rsi,2), %rcx
movq -0x10(%rax,%rcx,8), %rsi
cmpq -0x8(%rax,%rcx,8), %rsi
je 0x15c48
leaq (%rax,%rcx,8), %rax
addq $-0x10, %rax
movq (%r14), %rcx
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, (%rax)
jmp 0x15c58
leaq (%rax,%rcx,8), %rdi
addq $-0x18, %rdi
movq %r14, %rdx
callq 0x15f6e
movq (%r14), %rax
incq %rax
jmp 0x15bbe
leaq 0x8(%rsp), %rdi
callq 0x40b0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x936b(%rip), %rdi      # 0x1eff0
leaq 0x2347(%rip), %rsi      # 0x17fd3
movl $0x45, %edx
callq 0x42d0
movq 0x9353(%rip), %rdi      # 0x1eff0
callq 0x4110
movl $0x1, %edi
callq 0x42f0
movq 0x933d(%rip), %rdi      # 0x1eff0
leaq 0x235f(%rip), %rsi      # 0x18019
movl $0x45, %edx
callq 0x42d0
movq 0x9325(%rip), %rdi      # 0x1eff0
callq 0x4110
movl $0x2, %edi
callq 0x42f0
movq 0x930f(%rip), %rdi      # 0x1eff0
leaq 0x22d2(%rip), %rsi      # 0x17fba
movl $0x18, %edx
callq 0x42d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x92f0(%rip), %rdi      # 0x1eff0
callq 0x42d0
movq %rax, %rdi
callq 0x4110
jmp 0x15ca2
jmp 0x15d18
movq %rax, %r14
jmp 0x15d25
jmp 0x15d18
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x40b0
movq %rbx, %rdi
callq 0x55b4
movq %r14, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/viterbi.cpp
// Function: set_genetic_map_at_positions(std::vector<unsigned int, std::allocator<unsigned int>>&, double, std::vector<double, std::allocator<double>>&)
void set_genetic_map_at_positions(vector<unsigned int> &positions, double rate, vector<double> &map_out)
{
	map_out.resize(positions.size());
	map_out[0] = 0;
	for (unsigned int ui=1; ui<map_out.size(); ui++)
	{
		map_out[ui] = map_out[ui-1] + rate * (double(positions[ui] - positions[ui-1]) / 1000000);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x2, %rsi
movq %r14, %rdi
callq 0xb746
movsd (%rsp), %xmm2
movq (%r14), %rax
movq $0x0, (%rax)
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq $0x2, %rcx
jb 0x6a2d
movq (%rbx), %rdx
movl $0x1, %edi
xorl %esi, %esi
movsd 0x31608(%rip), %xmm0    # 0x38008
movl (%rdx,%rdi,4), %r8d
subl (%rdx,%rsi,4), %r8d
xorps %xmm1, %xmm1
cvtsi2sd %r8, %xmm1
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
addsd (%rax,%rsi,8), %xmm1
movsd %xmm1, (%rax,%rdi,8)
leal 0x2(%rsi), %edi
incq %rsi
cmpq %rdi, %rcx
ja 0x6a00
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/viterbi.cpp
// Function: get_haplotype_count(std::vector<std::vector<bool, std::allocator<bool>>, std::allocator<std::vector<bool, std::allocator<bool>>>> const&, int, int, int, int&, int&)
void get_haplotype_count(const vector<vector<bool> > &haps, int indv_idx, int start_idx, int end_idx, int &N_exact_match, int &N_one_prct_mismatch)
{
	N_exact_match = 1;	// Obviously the haplotype itself should count towards the total!
	N_one_prct_mismatch = 1;

	int N_hap = haps.size();
	for (int i=0; i < N_hap; i++)
	{
		if (i == indv_idx)
			continue;

		int N_mismatch = 0;
		double frac_mismatch = 0;
		for (int j=start_idx; j<=end_idx; j++)
		{
			if (haps[indv_idx][j] != haps[i][j])
			{
				N_mismatch++;
				frac_mismatch = ((double)N_mismatch) / (end_idx - start_idx + 1.0);
				if (frac_mismatch > 0.01)
					break;
			}
		}

		if (N_mismatch == 0)
			N_exact_match++;
		if (frac_mismatch <= 0.01)
			N_one_prct_mismatch++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x1, %eax
movq %r8, -0x28(%rsp)
movl %eax, (%r8)
movq %r9, -0x8(%rsp)
movl %eax, (%r9)
movq (%rdi), %rax
movq 0x8(%rdi), %r10
movq %rax, -0x30(%rsp)
subq %rax, %r10
sarq $0x3, %r10
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
imulq %r10, %rdi
testl %edi, %edi
jle 0x9506
movabsq $-0x8000000000000000, %r10 # imm = 0x8000000000000000
movslq %esi, %rsi
leaq (%rsi,%rsi,4), %r11
movl %ecx, %ebx
subl %edx, %ebx
cvtsi2sd %ebx, %xmm0
addsd 0x2ec16(%rip), %xmm0    # 0x38018
movq -0x30(%rsp), %rax
leaq (%rax,%r11,8), %rax
movq %rax, -0x10(%rsp)
movslq %edx, %rax
movq %rax, -0x18(%rsp)
leal 0x1(%rcx), %ebx
movl %esi, %esi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
leaq 0x3f(%r10), %r12
movsd 0x2ec16(%rip), %xmm1    # 0x38048
movq %rsi, -0x20(%rsp)
cmpq %rsi, %r15
je 0x94fa
cmpl %edx, %ecx
jge 0x9450
movq -0x28(%rsp), %rax
incl (%rax)
jmp 0x94f3
movq -0x10(%rsp), %rax
movq (%rax), %r13
leaq (%r15,%r15,4), %rsi
movq -0x30(%rsp), %rax
movq (%rax,%rsi,8), %rsi
xorl %ebp, %ebp
xorpd %xmm2, %xmm2
movq -0x18(%rsp), %r8
leal 0x3f(%r8), %eax
testl %r8d, %r8d
cmovnsl %r8d, %eax
sarl $0x6, %eax
cltq
leaq (,%rax,8), %r14
addq %r13, %r14
movq %r8, %r11
andq %r12, %r11
xorl %r9d, %r9d
cmpq %r10, %r11
setbe %r9b
movq -0x8(%r14,%r9,8), %r11
movl %r8d, %r14d
andl $0x3f, %r14d
btq %r14, %r11
setb %r11b
leaq (%rsi,%rax,8), %rax
movq -0x8(%rax,%r9,8), %rax
btq %r14, %rax
sbbb $0x0, %r11b
je 0x94d5
incl %ebp
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
divsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
ja 0x94dd
incq %r8
cmpl %r8d, %ebx
jne 0x9470
testl %ebp, %ebp
movq -0x20(%rsp), %rsi
jne 0x94ed
movq -0x28(%rsp), %rax
incl (%rax)
ucomisd %xmm2, %xmm1
jb 0x94fa
movq -0x8(%rsp), %rax
incl (%rax)
incq %r15
cmpq %rdi, %r15
jne 0x9437
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bcf_file.cpp
// Function: bcf_file::check_bcf()
void bcf_file::check_bcf()
{
	char magic[5];

	read(magic, 5, 1);
	if ((strcmp(magic, bcf_21) == 0) && (strcmp(magic, bcf_22) == 0))
		LOG.error("Does not appear to be a BCF file\n");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x3(%rsp), %rbx
movl $0x1, %ecx
movq %rbx, %rsi
movl $0x5, %edx
callq 0xf08a
leaq 0x3ab73(%rip), %rsi     # 0x49468
movq %rbx, %rdi
callq 0x55f0
testl %eax, %eax
jne 0xe95d
leaq 0x3ab65(%rip), %rsi     # 0x4946d
leaq 0x3(%rsp), %rdi
callq 0x55f0
testl %eax, %eax
jne 0xe95d
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x29c5d(%rip), %rsi     # 0x38583
leaq 0x29c77(%rip), %rdx     # 0x385a4
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc85e
leaq 0x3ab67(%rip), %rdi     # 0x494a8
movq %rbx, %rsi
movl $0x1, %edx
callq 0x36ec8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe95d
callq 0x5410
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe977
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x10(%rdi), %rdx
addq $-0x4, %rdx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x5480
leaq 0x29808(%rip), %rsi     # 0x38486
movq %r15, %rdi
callq 0x50e0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x78(%rsp), %r12
cmpq %r12, %rdi
je 0xec9a
callq 0x5410
testl %ebp, %ebp
jne 0xece5
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x297dd(%rip), %rsi     # 0x3848b
leaq 0x2980d(%rip), %rdx     # 0x384c2
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xc85e
leaq 0x3a7df(%rip), %rdi     # 0x494a8
movq %r15, %rsi
movl $0x1, %edx
callq 0x36ec8
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xece5
callq 0x5410
movq 0x10(%rbx), %rdx
addq $-0x7, %rdx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x5480
leaq 0x297b8(%rip), %rsi     # 0x384c3
movq %r15, %rdi
callq 0x50e0
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xed22
callq 0x5410
testl %ebp, %ebp
jne 0xed6e
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x29794(%rip), %rsi     # 0x384cb
leaq 0x297c9(%rip), %rdx     # 0x38507
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc85e
leaq 0x3a756(%rip), %rdi     # 0x494a8
movq %r15, %rsi
movl $0x1, %edx
callq 0x36ec8
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xed6e
callq 0x5410
movq 0x8(%rbx), %rdi
callq 0x37d33
cmpl $0x1, %eax
jne 0xed8e
movb $0x1, 0x460(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0xedf9
movb $0x0, 0x460(%rbx)
leaq 0x38(%rbx), %r15
movq 0x8(%rbx), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x5240
leaq 0xb0(%rbx), %rdi
callq 0x50b0
testb %al, %al
jne 0xedf5
leaq 0x29747(%rip), %rsi     # 0x38508
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0xb777
leaq 0x3a6d0(%rip), %rdi     # 0x494a8
movq %r12, %rsi
xorl %edx, %edx
callq 0x36ec8
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xedf5
callq 0x5410
movq %r15, 0x30(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xee3a
jmp 0xee3f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0xee3a
jmp 0xee3f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xee3f
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x460(%rdi)
movl %edx, %r13d
jne 0xf0ca
movq 0x248(%r15), %rdi
movl %ebx, %r12d
imull %ebp, %r12d
movq %r14, %rsi
movl %r12d, %edx
callq 0x5850
cmpl %r12d, %eax
jmp 0xf0ed
movq 0x30(%r15), %rdi
movq %r13, %rdx
imulq %rbx, %rdx
movq %r14, %rsi
callq 0x5580
movq 0x30(%r15), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
sete %r12b
movb 0x461(%r15), %al
xorb $0x1, %al
cmpq $0x2, %rbx
setb %cl
testl %ebp, %ebp
sete %dl
orb %cl, %dl
orb %al, %dl
jne 0xf121
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x11584
addq %rbx, %r14
decq %r13
jne 0xf10c
movzbl %r12b, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x4, %ecx
movl $0x2, %edx
callq 0xf08a
testl %eax, %eax
je 0xf1b6
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
movslq %eax, %r15
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xf332
movq (%rbx), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq (%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdi
movl $0x1, %edx
movq %r15, %rcx
callq 0xf08a
jmp 0xf1c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf332
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf232
pushq %rax
movq 0x248(%rdi), %rdi
callq 0x5110
addq $0x8, %rsp
jmp 0xf244
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_O3/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)
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x27ac9(%rip), %rsi     # 0x385a5
leaq 0x27ada(%rip), %rdx     # 0x385bd
leaq 0x30(%rsp), %rdi
callq 0xc85e
leaq 0x250(%rbx), %r14
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x14a06
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x10b16
callq 0x5410
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testb %al, %al
jne 0x10b65
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11190
movq 0x10(%rsp), %rax
cmpb $0x23, (%rax)
jne 0x10b65
cmpb $0x23, 0x1(%rax)
jne 0x10b58
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x13990
jmp 0x10b20
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x16412
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x10b74
callq 0x5410
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x10b9a
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x10b9d
callq 0x5410
jmp 0x10b9d
jmp 0x10b9a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x10bac
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10f22
movq 0x380a6(%rip), %rax     # 0x48fb0
movq (%rax), %rdi
callq 0x54b0
leaq 0x27cd5(%rip), %rsi     # 0x38bee
movl %eax, %edi
callq 0x5800
jmp 0x10f32
movq 0x8(%rbx), %rdi
leaq 0x275f5(%rip), %rsi     # 0x38522
callq 0x5650
movq %rax, 0x248(%rbx)
testq %rax, %rax
jne 0x10f7a
leaq 0x8(%rbx), %rdx
leaq 0x277f8(%rip), %rsi     # 0x38741
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0xb777
leaq 0x3854b(%rip), %rdi     # 0x494a8
movq %r14, %rsi
xorl %edx, %edx
callq 0x36ec8
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10f7a
callq 0x5410
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x275ba(%rip), %rsi     # 0x38544
leaq 0x275b9(%rip), %rdx     # 0x3854a
leaq 0x20(%rsp), %rdi
callq 0xc85e
leaq 0x275a9(%rip), %rsi     # 0x3854b
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xb777
leaq 0x2719e(%rip), %rsi     # 0x38156
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 0x10fe8
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x10fef
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 0x38498(%rip), %rdi     # 0x494a8
callq 0x36e72
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x11023
callq 0x5410
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11036
callq 0x5410
movq 0x248(%rbx), %rdi
movl 0x240(%rbx), %esi
callq 0x5340
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x11057
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 0x110b1
jmp 0x110bb
jmp 0x110a4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1108f
callq 0x5410
jmp 0x1108f
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x110a7
callq 0x5410
jmp 0x110a7
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x110bb
callq 0x5410
jmp 0x110bb
movq %rax, %rbx
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11105
pushq %rax
movq 0x248(%rdi), %rdi
callq 0x5110
addq $0x8, %rsp
jmp 0x11117
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_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
leaq 0x28d31(%rip), %rcx     # 0x39ed7
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5690
cmpb $0x1, 0x28(%r14)
jne 0x1120f
movq 0x460(%r14), %r15
movl 0x240(%r14), %edx
movq 0x248(%r14), %rdi
movq %r15, %rsi
callq 0x5770
testq %rax, %rax
je 0x11267
movq 0x460(%r14), %rsi
movq %rbx, %rdi
callq 0x5870
movq 0x460(%r14), %r15
movq %r15, %rdi
callq 0x5180
movl 0x240(%r14), %edx
leal -0x1(%rdx), %ecx
cmpq %rcx, %rax
je 0x111c8
jmp 0x11235
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 0x27521(%rip), %rsi     # 0x3875d
movl $0x4, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x56f0
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x1126d
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2734a(%rip), %rdi     # 0x385be
leaq 0x2737a(%rip), %rsi     # 0x385f5
movq %rax, %rdx
xorl %eax, %eax
callq 0x5660
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38485(%rip), %al      # 0x49720
testb %al, %al
je 0x1131d
movq 0x38462(%rip), %rdx     # 0x49708
leaq 0x38453(%rip), %r15     # 0x49700
leaq 0x28c23(%rip), %rcx     # 0x39ed7
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5690
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf332
movq %r14, %rdi
movq %r15, %rsi
callq 0x11190
movq 0x38423(%rip), %rsi     # 0x49700
movq 0x38424(%rip), %rdx     # 0x49708
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
callq 0x11342
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1137c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11313
callq 0x5410
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x59af
jmp 0x1129f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11339
callq 0x5410
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11571
xorl %esi, %esi
xorl %eax, %eax
movl %esi, %edi
shrl $0x6, %edi
movq (%rcx,%rdi,8), %rdi
btq %rsi, %rdi
adcl $0x0, %eax
incq %rsi
movl %esi, %edi
cmpq %rdi, %rdx
ja 0x11556
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x115b0
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 0x11591
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x119e2
movb %al, 0x10(%rsp)
movl $0x1, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x54f0
jmp 0x119b4
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 0x11a13
callq 0x5410
movl $0x4, %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x5580
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x11a95
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
movl %eax, (%rdx,%r12,8)
movl %ebp, %r12d
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x3, %rax
incl %ebp
cmpq %r12, %rax
ja 0x11a41
movq 0x374e4(%rip), %rsi     # 0x48f80
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 0x11acb
jmp 0x11acb
jmp 0x11acb
movq %rax, %rbx
movq 0x374ab(%rip), %rsi     # 0x48f80
leaq 0x30(%rsp), %rdi
callq 0x5330
leaq 0xb0(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11b5f
movb %al, 0x20(%rsp)
movl $0x1, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x54f0
jmp 0x11b31
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 0x11b90
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 0x11c29
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 0x11bdb
movq 0x37350(%rip), %rsi     # 0x48f80
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 0x11c61
jmp 0x11c61
jmp 0x11c61
jmp 0x11c61
movq %rax, %rbx
movq 0x37315(%rip), %rsi     # 0x48f80
leaq 0x40(%rsp), %rdi
callq 0x5330
leaq 0xc0(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1300e
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 0x16a87
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13084
jmp 0x16a5f
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16a95
callq 0x5410
movq 0x3251c(%rip), %rsi     # 0x48fb8
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 0x16ad4
callq 0x5410
movq 0x324dd(%rip), %rsi     # 0x48fb8
leaq 0x20(%rsp), %rdi
callq 0x5610
leaq 0x98(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16b29
movq %rdi, %r14
leaq 0x226dc(%rip), %rsi     # 0x391ed
callq 0x50e0
testl %eax, %eax
je 0x16b29
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_O3/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 0x22e85(%rip), %rdx     # 0x39ed7
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0xc85e
subq %r15, %r14
sarq $0x5, %r14
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0xb(%rsp), %rcx
movq %r14, %rsi
callq 0x17864
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1708c
callq 0x5410
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %r13
subq %r14, %r13
sarq $0x5, %r13
testq %r13, %r13
jle 0x170c4
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
ja 0x170a8
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x1300e
leaq 0x60(%rbx), %rdi
callq 0x18220
leaq 0x180(%rbx), %rdi
callq 0x1824e
leaq 0x90(%rbx), %rdi
callq 0x18220
leaq 0x150(%rbx), %rdi
callq 0x1824e
leaq 0xc0(%rbx), %rdi
callq 0x18220
leaq 0x1b0(%rbx), %rdi
callq 0x1824e
leaq 0xf0(%rbx), %rdi
callq 0x18220
leaq 0x120(%rbx), %rdi
callq 0x1824e
leaq 0x28(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x2146a(%rip), %rsi     # 0x385a5
leaq 0x2147b(%rip), %rdx     # 0x385bd
callq 0xc85e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x14a06
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x17169
callq 0x5410
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x171ad
movl $0x1, %ebp
xorl %esi, %esi
leaq 0xc(%rsp), %r14
shlq $0x5, %rsi
addq %rax, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x13990
movl %ebp, %esi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %ebp
cmpq %rsi, %rcx
ja 0x17181
leaq 0x10(%rsp), %rdi
callq 0xc4da
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 0x171fc
callq 0x5410
jmp 0x171fc
jmp 0x171f9
jmp 0x171f9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x17206
callq 0x5410
jmp 0x17206
movq %rax, %rbx
jmp 0x17206
jmp 0x171f9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc4da
movq %rbx, %rdi
callq 0x57d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1723c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x21fc2(%rip), %rsi     # 0x391ed
leaq 0x21fbc(%rip), %rdx     # 0x391ee
movq %rbx, %rdi
callq 0xc85e
jmp 0x172b5
movl %esi, %ebp
movb 0x3268c(%rip), %al      # 0x498d0
testb %al, %al
je 0x172c1
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x22c7f(%rip), %rdx     # 0x39ed7
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xc85e
leaq 0x324f6(%rip), %rdi     # 0x49760
movq %rsp, %rsi
callq 0x5640
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x17280
callq 0x5410
movq 0x324d1(%rip), %rax     # 0x49758
leaq 0x324ca(%rip), %r14     # 0x49758
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x5750
movq %r14, %rdi
movl %ebp, %esi
callq 0x57a0
leaq 0x324b3(%rip), %rsi     # 0x49760
movq %rbx, %rdi
callq 0x56c0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x32608(%rip), %rdi     # 0x498d0
callq 0x5810
testl %eax, %eax
je 0x17248
leaq 0x3247c(%rip), %rdi     # 0x49758
callq 0x55d0
movq 0x31c88(%rip), %rdi     # 0x48f70
leaq 0x32469(%rip), %rsi     # 0x49758
leaq 0x32162(%rip), %rdx     # 0x49458
callq 0x53d0
leaq 0x325ce(%rip), %rdi     # 0x498d0
callq 0x5270
jmp 0x17248
movq %rax, %rbx
leaq 0x325ba(%rip), %rdi     # 0x498d0
callq 0x5250
jmp 0x17333
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x17333
callq 0x5410
jmp 0x17333
movq %rax, %rbx
movq %rbx, %rdi
callq 0x57d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17374
movq %rdi, %rbx
leaq 0x21e9b(%rip), %rsi     # 0x391ed
movsd %xmm0, 0x8(%rsp)
callq 0x50e0
movsd 0x8(%rsp), %xmm0
testl %eax, %eax
je 0x17374
movq (%rbx), %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x5570
addq $0x10, %rsp
popq %rbx
retq