LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: attractivechaos[P]udb2/verstable/./verstable.h
// Function: intmap_t_find_insert_location_in_chain
static inline size_t VT_CAT( NAME, _find_insert_location_in_chain )(
  NAME *table,
  size_t home_bucket,
  size_t displacement_to_empty
)
{
  size_t candidate = home_bucket;
  while( true )
  {
    uint16_t displacement = table->metadata[ candidate ] & VT_DISPLACEMENT_MASK;

    if( displacement > displacement_to_empty )
      return candidate;

    candidate = ( home_bucket + VT_QUADRATIC( displacement ) ) & ( table->bucket_count - 1 );
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x7ff, %eax            # imm = 0x7FF
movw %ax, -0x22(%rsp)
movzwl -0x22(%rsp), %eax
cmpq -0x18(%rsp), %rax
jbe 0x2507
movq -0x20(%rsp), %rax
retq
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movzwl -0x22(%rsp), %eax
movzwl -0x22(%rsp), %ecx
imull %ecx, %eax
movzwl -0x22(%rsp), %ecx
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x20(%rsp)
jmp 0x24d9
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/verstable/./verstable.h
// Function: intmap_t_next
VT_CAT( NAME, _next )( VT_CAT( NAME, _itr ) itr )
{
  ++itr.data;
  ++itr.metadatum;
  VT_CAT( NAME, _fast_forward )( &itr );
  return itr;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq (%rdi), %rax
addq $0x8, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
addq $0x2, %rax
movq %rax, 0x8(%rdi)
callq 0x2940
movq (%rsp), %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rdi)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rdi)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/verstable/./verstable.h
// Function: vt_first_nonzero_uint16
static inline int vt_first_nonzero_uint16( uint64_t val )
{
  const uint16_t endian_checker = 0x0001;
  if( *(char *)&endian_checker ) // Little-endian (the compiler will optimize away the check at -O1 and above).
    return __builtin_ctzll( val ) / 16;
  
  return __builtin_clzll( val ) / 16;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movw $0x1, -0x12(%rsp)
cmpb $0x0, -0x12(%rsp)
je 0x2a0b
movq -0x10(%rsp), %rax
tzcntq %rax, %rax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rsp)
jmp 0x2a24
movq -0x10(%rsp), %rax
bsrq %rax, %rax
xorq $0x3f, %rax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x13ae0
movq -0x1e8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0x18360
jmp 0x1342b
leaq -0x1b8(%rbp), %rdi
callq 0x1f710
jmp 0x13439
leaq -0x1b8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1fbd0
jmp 0x1344b
leaq -0x1b8(%rbp), %rdi
callq 0x221e0
movq %rax, -0x1f0(%rbp)
jmp 0x13460
movq -0x1f0(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl $0x40, %edi
callq 0x5290
movq %rax, -0x1f8(%rbp)
jmp 0x13481
movq -0x1f8(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x13b00
movq -0x1f8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x1c0(%rbp), %rsi
movq -0x1d0(%rbp), %rdx
leaq -0x1c1(%rbp), %rdi
callq 0x32dd0
movq %rax, -0x200(%rbp)
jmp 0x134d0
movq -0x200(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x1d8(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x13b20
leaq -0x38(%rbp), %rdi
callq 0x13ba0
movq -0x208(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x13537
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x13b20
leaq -0x38(%rbp), %rdi
callq 0x13ba0
movq -0x40(%rbp), %rdi
callq 0x5490
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq *%rax
movq -0x78(%rbp), %rdi
leaq 0x32a99(%rip), %rsi     # 0x4601a
callq 0x13bc0
movb %al, -0x69(%rbp)
jmp 0x1358b
leaq -0x30(%rbp), %rdi
callq 0x5518
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x135a0
jmp 0x1363b
movq 0x51a21(%rip), %rdi     # 0x64fc8
leaq 0x32b41(%rip), %rsi     # 0x460ef
callq 0x5280
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq *%rax
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x5250
movq %rax, -0x80(%rbp)
jmp 0x135ea
movq -0x80(%rbp), %rdi
movq 0x519ab(%rip), %rsi     # 0x64fa0
callq 0x52c0
jmp 0x135fc
leaq -0x60(%rbp), %rdi
callq 0x5518
jmp 0x1363b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5518
jmp 0x136c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5518
jmp 0x136c5
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movl 0x8(%rax), %esi
movq 0x51977(%rip), %rdi     # 0x64fc8
callq 0x5480
movq %rax, %rdi
movq 0x51940(%rip), %rsi     # 0x64fa0
callq 0x52c0
movq -0x68(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x136bc
movq 0x51950(%rip), %rdi     # 0x64fc8
leaq 0x32a8c(%rip), %rsi     # 0x4610b
callq 0x5280
movq %rax, %rdi
movq -0x68(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x5480
movq %rax, %rdi
leaq 0x32a8b(%rip), %rsi     # 0x46128
callq 0x5280
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x5480
movq %rax, %rdi
movq 0x518e9(%rip), %rsi     # 0x64fa0
callq 0x52c0
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5490
nop
// File: tonymugen[P]sampleSNPs/populations.cpp
// Function: sampFiles::PopIndex::PopIndex(int const*, unsigned long const&)
PopIndex::PopIndex(const int *arr, const size_t &N) : _N(N) {
	for (size_t elInd = 0; elInd < N; elInd++) {
		if (arr[elInd] < 0) {
			cerr << "ERROR: population index #" << elInd << " (base-0) is less than zero (" << arr[elInd] << ") in PopIndex array-based initialization." << endl;
			exit(1);
		}
		
		if (arr[elInd] > _popInd.size()) {
			_popInd.resize(arr[elInd]); // maybe this popID is a few steps ahead of the current
			_popInd[arr[elInd] - 1].push_back(elInd);
		}
		else {
			_popInd[arr[elInd] - 1].push_back(elInd);
		}
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x20e20
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x20b24
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0x20a83
movq 0xc60e(%rip), %rdi      # 0x2cff0
leaq 0x357f(%rip), %rsi      # 0x23f68
callq 0x42f0
movq %rax, -0x40(%rbp)
jmp 0x209f4
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x40c0
movq %rax, -0x48(%rbp)
jmp 0x20a07
movq -0x48(%rbp), %rdi
leaq 0x3570(%rip), %rsi      # 0x23f82
callq 0x42f0
movq %rax, -0x50(%rbp)
jmp 0x20a1d
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x4570
movq %rax, -0x58(%rbp)
jmp 0x20a37
movq -0x58(%rbp), %rdi
leaq 0x355e(%rip), %rsi      # 0x23fa0
callq 0x42f0
movq %rax, -0x60(%rbp)
jmp 0x20a4d
movq -0x60(%rbp), %rdi
movq 0xc558(%rip), %rsi      # 0x2cfb0
callq 0x4320
jmp 0x20a5f
movl $0x1, %edi
callq 0x43b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x58d0
jmp 0x20b2a
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
movq %rax, -0x68(%rbp)
callq 0x1d1f0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jbe 0x20ae8
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rax,%rcx,4), %rsi
callq 0x20e40
jmp 0x20abf
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
decl %eax
movslq %eax, %rsi
callq 0x20ed0
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x20ef0
jmp 0x20ae6
jmp 0x20b11
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
decl %eax
movslq %eax, %rsi
callq 0x20ed0
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x20ef0
jmp 0x20b0f
jmp 0x20b11
jmp 0x20b13
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x209b8
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x45a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
callq 0xe850
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xe7b0
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe870
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x1, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0xe890
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x7b06
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %eax
decl %eax
movl %eax, %esi
callq 0xe870
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe8b0
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x50(%rsp), %rdi
movl 0x3c(%rsp), %eax
decl %eax
movl %eax, %esi
callq 0xe8b0
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rax, %rcx
movl 0x1c(%rsp), %eax
movl (%rcx), %ecx
subl %ecx, %eax
cvtsi2sd %rax, %xmm2
movsd 0x6c53e(%rip), %xmm3    # 0x74008
divsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xe870
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x7a32
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: auton1[P]viterbi/viterbi.cpp
// Function: diff(timespec, timespec)
double diff(timespec start, timespec end)
{
	timespec temp;
	if ((end.tv_nsec-start.tv_nsec)<0) {
		temp.tv_sec = end.tv_sec-start.tv_sec-1;
		temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
	} else {
		temp.tv_sec = end.tv_sec-start.tv_sec;
		temp.tv_nsec = end.tv_nsec-start.tv_nsec;
	}
	return temp.tv_sec + (temp.tv_nsec / 1000000000.0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x8(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x18(%rsp), %rax
subq -0x8(%rsp), %rax
cmpq $0x0, %rax
jge 0x87ae
movq -0x20(%rsp), %rax
subq -0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
subq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x87cc
movq -0x20(%rsp), %rax
subq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
subq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
cvtsi2sdq -0x30(%rsp), %xmm0
cvtsi2sdq -0x28(%rsp), %xmm1
movsd 0x6b82e(%rip), %xmm2    # 0x74010
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl $0x1, (%rax)
movq 0x20(%rsp), %rax
movl $0x1, (%rax)
movq 0x40(%rsp), %rdi
callq 0xf1b0
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0xbd2c
movl 0x18(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jne 0xbc18
jmp 0xbd1c
movl $0x0, 0x14(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x34(%rsp), %eax
jg 0xbceb
movq 0x40(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xf110
movq %rax, %rdi
movslq 0x4(%rsp), %rsi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
movq 0x40(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0xf110
movq %rax, %rdi
movslq 0x4(%rsp), %rsi
callq 0xf150
movb %al, %cl
movl (%rsp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xbcd9
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
cvtsi2sdl 0x14(%rsp), %xmm0
movl 0x34(%rsp), %eax
subl 0x38(%rsp), %eax
cvtsi2sd %eax, %xmm1
movsd 0x68365(%rip), %xmm2    # 0x74018
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x68369(%rip), %xmm1    # 0x74038
ucomisd %xmm1, %xmm0
jbe 0xbcd7
jmp 0xbceb
jmp 0xbcd9
jmp 0xbcdb
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xbc31
cmpl $0x0, 0x14(%rsp)
jne 0xbcfe
movq 0x28(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movsd 0x68332(%rip), %xmm0    # 0x74038
ucomisd 0x8(%rsp), %xmm0
jb 0xbd1a
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xbd1c
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xbbfb
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: auton1[P]viterbi/bcf_file.cpp
// Function: bcf_file::bcf_file(parameters const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
bcf_file::bcf_file(const parameters &p, string &vcf_filename, int idx)
{
	filename = vcf_filename;

	big_endian = is_big_endian();
	is_BGZF = false; stream = p.stream_in;
	N_entries = 0; N_kept_entries = 0;
	meta_data = header();

	if (stream)
	{
		is_BGZF = true;
		open_gz();
	}
	else
		open();

	check_bcf();
	read_header();

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

// Assembly:
subq $0x268, %rsp            # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movl %ecx, 0x24c(%rsp)
movq 0x260(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x20510
movq 0x20(%rsp), %rdi
leaq 0x735fc(%rip), %rax     # 0x92a90
movq %rax, (%rdi)
movq 0x250(%rsp), %rsi
addq $0x8, %rdi
callq 0x6060
jmp 0x1f4aa
callq 0x205c0
movb %al, 0x1f(%rsp)
jmp 0x1f4b5
movq 0x20(%rsp), %rax
movb 0x1f(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x461(%rax)
movb $0x0, 0x460(%rax)
movq 0x258(%rsp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, 0x462(%rax)
movl $0x0, 0x458(%rax)
movl $0x0, 0x45c(%rax)
leaq 0x58(%rsp), %rdi
callq 0x2ba50
jmp 0x1f501
movq 0x20(%rsp), %rdi
addq $0x250, %rdi            # imm = 0x250
leaq 0x58(%rsp), %rsi
callq 0x205e0
jmp 0x1f519
leaq 0x58(%rsp), %rdi
callq 0x20740
movq 0x20(%rsp), %rax
testb $0x1, 0x462(%rax)
je 0x1f586
movq 0x20(%rsp), %rdi
movb $0x1, 0x460(%rdi)
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x1f548
jmp 0x1f597
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
jmp 0x1f63e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x20740
jmp 0x1f63e
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x1f595
jmp 0x1f597
movq 0x20(%rsp), %rdi
callq 0x1f660
jmp 0x1f5a3
movq 0x20(%rsp), %rdi
callq 0x1f750
jmp 0x1f5af
movq 0x20(%rsp), %rax
movl 0x2a8(%rax), %eax
movq %rax, 0x8(%rsp)
movb $0x1, 0x2f(%rsp)
leaq 0x2e(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x20810
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %rdi
leaq 0x2f(%rsp), %rdx
callq 0x20820
jmp 0x1f5ee
movq 0x20(%rsp), %rdi
addq $0x430, %rdi            # imm = 0x430
leaq 0x30(%rsp), %rsi
callq 0x208a0
leaq 0x30(%rsp), %rdi
callq 0x11300
leaq 0x2e(%rsp), %rdi
callq 0x1e6a0
addq $0x268, %rsp            # imm = 0x268
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
leaq 0x2e(%rsp), %rdi
callq 0x1e6a0
movq 0x20(%rsp), %rdi
callq 0x27620
movq 0x240(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x4b(%rsp), %rsi
movl $0x5, %edx
movl $0x1, %ecx
callq 0x20230
leaq 0x4b(%rsp), %rdi
leaq 0x73f22(%rip), %rsi     # 0x935b0
callq 0x67f0
cmpl $0x0, %eax
jne 0x1f73f
leaq 0x4b(%rsp), %rdi
leaq 0x73f0d(%rip), %rsi     # 0x935b5
callq 0x67f0
cmpl $0x0, %eax
jne 0x1f73f
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x69f0
movq 0x8(%rsp), %rdx
leaq 0x54e1d(%rip), %rsi     # 0x744ee
leaq 0x28(%rsp), %rdi
callq 0x67c0
jmp 0x1f6dd
leaq 0x73f1c(%rip), %rdi     # 0x93600
leaq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x712f0
jmp 0x1f6f5
leaq 0x28(%rsp), %rdi
callq 0x6b50
leaq 0x27(%rsp), %rdi
callq 0x65f0
jmp 0x1f73f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x1f733
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6b50
leaq 0x27(%rsp), %rdi
callq 0x65f0
jmp 0x1f744
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x69e0
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x460(%rax)
je 0x202a1
movq 0x8(%rsp), %rax
movq 0x248(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
imulq %rcx, %rax
movl %eax, %edx
callq 0x6a90
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x24(%rsp), %ecx
imulq 0x18(%rsp), %rcx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x202e1
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x24(%rsp), %eax
imulq %rax, %rdx
callq 0x6710
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x6a70
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x461(%rax)
je 0x2033e
cmpq $0x1, 0x18(%rsp)
jbe 0x2033e
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x2033c
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0x10(%rsp), %ecx
imulq %rcx, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rax
movl %eax, %edx
callq 0x27760
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x202ff
jmp 0x2033e
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movl $0x2, %edx
movl $0x4, %ecx
callq 0x20230
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x2042a
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x20910
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x209b0
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
movl $0x8, %esi
callq 0x209b0
movq (%rsp), %rdi
movq %rax, %rsi
movslq 0x8(%rsp), %rcx
movl $0x1, %edx
callq 0x20230
jmp 0x20438
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20910
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x67e0
movq 0x18(%rsp), %rax
movl $0x0, 0x6c(%rsp)
addq $0x250, %rax            # imm = 0x250
movq %rax, 0x20(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x69f0
movq 0x28(%rsp), %rdx
leaq 0x4ed97(%rip), %rsi     # 0x74510
leaq 0x48(%rsp), %rdi
callq 0x67c0
jmp 0x25785
movq 0x20(%rsp), %rdi
movl 0x6c(%rsp), %edx
leaq 0x48(%rsp), %rsi
callq 0x2d200
movl %eax, 0x14(%rsp)
jmp 0x2579e
movl 0x14(%rsp), %eax
addl 0x6c(%rsp), %eax
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6b50
leaq 0x47(%rsp), %rdi
callq 0x65f0
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movb %al, 0x13(%rsp)
jmp 0x257d2
movb 0x13(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x257e1
jmp 0x258cf
movq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x261f0
jmp 0x257f2
xorl %eax, %eax
movl %eax, %esi
leaq 0x70(%rsp), %rdi
callq 0x6b20
movq %rax, 0x8(%rsp)
jmp 0x25807
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x258c0
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
callq 0x6b20
movq %rax, (%rsp)
jmp 0x2582d
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x2589c
movq 0x18(%rsp), %rdi
addq $0x250, %rdi            # imm = 0x250
leaq 0x70(%rsp), %rsi
leaq 0x6c(%rsp), %rdx
callq 0x2bb40
jmp 0x25856
jmp 0x258be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x25880
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6b50
leaq 0x47(%rsp), %rdi
callq 0x65f0
jmp 0x258e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x258e9
movq 0x18(%rsp), %rdi
addq $0x250, %rdi            # imm = 0x250
leaq 0x70(%rsp), %rsi
callq 0x2f1a0
jmp 0x258b4
movl $0x1, 0x30(%rsp)
jmp 0x258d7
jmp 0x258ca
movl $0x1, 0x30(%rsp)
jmp 0x258d7
jmp 0x257be
movl $0x0, 0x30(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x6b50
addq $0x98, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x6b50
movq 0x38(%rsp), %rdi
callq 0x69e0
nopl (%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x100000, 0x240(%rax)  # imm = 0x100000
movl 0x240(%rax), %eax
movl %eax, %edi
callq 0x6030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x460(%rax)
testb $0x1, 0x468(%rax)
je 0x25ea9
movq 0x6d136(%rip), %rax     # 0x92fb8
movq (%rax), %rdi
callq 0x65d0
movl %eax, %edi
leaq 0x4eca9(%rip), %rsi     # 0x74b3c
callq 0x6a20
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x248(%rax)
jmp 0x25ed5
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x61a0
movq %rax, %rdi
leaq 0x4e5cc(%rip), %rsi     # 0x7448d
callq 0x6860
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x248(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x248(%rax)
jne 0x25f50
movq 0x10(%rsp), %rdx
addq $0x8, %rdx
leaq 0x4e76d(%rip), %rsi     # 0x74661
leaq 0x90(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe8d0
movq 0x8(%rsp), %rsi
leaq 0x6d6ee(%rip), %rdi     # 0x93600
xorl %edx, %edx
callq 0x712f0
jmp 0x25f1b
leaq 0x90(%rsp), %rdi
callq 0x6b50
jmp 0x25f50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x6b50
jmp 0x2607f
leaq 0x5f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x69f0
movq (%rsp), %rdx
leaq 0x4e546(%rip), %rsi     # 0x744af
leaq 0x60(%rsp), %rdi
callq 0x67c0
jmp 0x25f75
leaq 0x5f(%rsp), %rdi
callq 0x65f0
leaq 0x4e530(%rip), %rsi     # 0x744b6
leaq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0xe8d0
jmp 0x25f97
leaq 0x4e14d(%rip), %rdx     # 0x740eb
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf4a0
jmp 0x25faf
leaq 0x6d64a(%rip), %rdi     # 0x93600
leaq 0x38(%rsp), %rsi
callq 0x71280
jmp 0x25fc2
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x18(%rsp), %rdi
callq 0x6b50
movq 0x10(%rsp), %rax
movq 0x248(%rax), %rdi
movl 0x240(%rax), %esi
callq 0x63d0
jmp 0x25fef
leaq 0x60(%rsp), %rdi
callq 0x6b50
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x65f0
jmp 0x2607f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x26075
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2606b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x18(%rsp), %rdi
callq 0x6b50
leaq 0x60(%rsp), %rdi
callq 0x6b50
movq 0x88(%rsp), %rdi
callq 0x69e0
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x28(%rax)
jne 0x26114
movq (%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x6a70
andb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x26130
movq (%rsp), %rax
movq 0x248(%rax), %rdi
callq 0x6140
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x4fb15(%rip), %rsi     # 0x75d29
callq 0x67b0
movq 0x10(%rsp), %rax
testb $0x1, 0x28(%rax)
jne 0x26276
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x60c0
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x4e430(%rip), %rsi     # 0x7467d
movq $-0x1, %rdx
callq 0x6a30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x60f0
jmp 0x26331
movb $0x1, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x262f9
movq 0x10(%rsp), %rax
movq 0x248(%rax), %rdi
movq 0x460(%rax), %rsi
movl 0x240(%rax), %edx
callq 0x6980
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x262b6
jmp 0x26331
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdi
movq 0x460(%rax), %rsi
callq 0x6ac0
movq 0x10(%rsp), %rax
movq 0x460(%rax), %rdi
callq 0x61d0
movq 0x10(%rsp), %rcx
movl 0x240(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
je 0x262f7
movb $0x0, 0x1f(%rsp)
jmp 0x2627b
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x4e36f(%rip), %rsi     # 0x7467d
movq $-0x1, %rdx
callq 0x6a30
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x60f0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpb $0x0, 0x6d519(%rip)     # 0x93878
jne 0x263a4
leaq 0x6d510(%rip), %rdi     # 0x93878
callq 0x6a40
cmpl $0x0, %eax
je 0x263a4
leaq 0x6d4df(%rip), %rdi     # 0x93858
callq 0x67e0
movq 0x6cc23(%rip), %rdi     # 0x92fa8
leaq 0x6d4cc(%rip), %rsi     # 0x93858
leaq 0x6d20d(%rip), %rdx     # 0x935a0
callq 0x6490
leaq 0x6d4d9(%rip), %rdi     # 0x93878
callq 0x62f0
leaq 0x6d4ad(%rip), %rdi     # 0x93858
movq %rdi, (%rsp)
leaq 0x4f973(%rip), %rsi     # 0x75d29
callq 0x67b0
movq 0x58(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20910
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x261f0
movq (%rsp), %rdi
callq 0x6470
movq (%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x6270
movq %rax, 0x30(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x69f0
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x26490
jmp 0x2641d
leaq 0x2f(%rsp), %rdi
callq 0x65f0
movq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x26520
jmp 0x26438
leaq 0x40(%rsp), %rdi
callq 0x267c0
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x65f0
jmp 0x26479
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x267c0
movq 0x20(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x430, %rdi            # imm = 0x430
callq 0xf1d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x27715
movq 0x10(%rsp), %rdi
addq $0x430, %rdi            # imm = 0x430
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0xf150
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x27706
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x27708
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x276b3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x277c6
movq 0x18(%rsp), %rdi
movslq 0x10(%rsp), %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movslq 0xc(%rsp), %rax
addq %rax, %rsi
callq 0x2a0c0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x27785
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movq %rcx, 0x1e8(%rsp)
movq %r8, 0x1e0(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x6360
jmp 0x27c7b
movq 0x1f8(%rsp), %rdi
leaq 0x57(%rsp), %rsi
movl $0x1, %edx
callq 0x6710
jmp 0x27c94
movsbl 0x57(%rsp), %eax
cmpl $0xa, %eax
jne 0x27cbd
jmp 0x27cd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x63c0
jmp 0x27e3c
leaq 0x68(%rsp), %rdi
movsbl 0x57(%rsp), %esi
callq 0x6670
jmp 0x27cce
jmp 0x27c79
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x6530
jmp 0x27ce1
movq 0x1f0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x66c0
movq 0x10(%rsp), %rdi
callq 0x6b50
movq 0x1f8(%rsp), %rdi
movq 0x1e8(%rsp), %rsi
movl $0x4, %edx
callq 0x6710
jmp 0x27d1e
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x1e0(%rsp), %rdi
callq 0x2a200
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x27e2a
movq 0x1f8(%rsp), %rdi
leaq 0x1f(%rsp), %rsi
movl $0x1, %edx
callq 0x6710
jmp 0x27d66
movsbl 0x1f(%rsp), %eax
andl $0x3, %eax
movb %al, 0x1e(%rsp)
movsbl 0x1e(%rsp), %eax
cmpl $0x2, %eax
jne 0x27d98
movq 0x1e0(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x2a220
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
jmp 0x27dbb
movsbl 0x1e(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x1e0(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x2a220
movl 0x4(%rsp), %ecx
movl %ecx, 0x4(%rax)
movsbl 0x1f(%rsp), %eax
sarl $0x4, %eax
movb %al, 0x1f(%rsp)
movsbl 0x1f(%rsp), %eax
andl $0x3, %eax
movb %al, 0x1e(%rsp)
movsbl 0x1e(%rsp), %eax
cmpl $0x2, %eax
jne 0x27df8
movq 0x1e0(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x2a220
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x27e18
movsbl 0x1e(%rsp), %eax
movl %eax, (%rsp)
movq 0x1e0(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x2a220
movl (%rsp), %ecx
movl %ecx, (%rax)
jmp 0x27e1a
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x27d26
leaq 0x58(%rsp), %rdi
callq 0x63c0
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x48(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movb %sil, %al
movq %rdi, 0x1d0(%rsp)
movb %al, 0x1cf(%rsp)
movq %rdx, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a0f0
movq 0x1d0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x8, %edx
callq 0x6930
leaq 0x20(%rsp), %rdi
callq 0x67e0
movsbl 0x1cf(%rsp), %edx
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6a80
movq %rax, 0x8(%rsp)
jmp 0x2fae1
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6700
movb %al, 0x7(%rsp)
jmp 0x2fafb
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2fb05
jmp 0x2fb3f
movq 0x1c0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2a190
jmp 0x2fb19
jmp 0x2fac3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6b50
leaq 0x40(%rsp), %rdi
callq 0x6b48
jmp 0x2fb5b
leaq 0x20(%rsp), %rdi
callq 0x6b50
leaq 0x40(%rsp), %rdi
callq 0x6b48
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x18(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movl %edx, 0x68(%rsp)
movl 0x6c(%rsp), %eax
cmpl 0x68(%rsp), %eax
jne 0x3057b
leaq 0x67(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x69f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x44b96(%rip), %rsi     # 0x750de
callq 0x67c0
jmp 0x3054f
leaq 0x67(%rsp), %rdi
callq 0x65f0
jmp 0x306a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x65f0
jmp 0x306ad
cmpb $0x0, 0x634a6(%rip)     # 0x93a28
jne 0x305c9
leaq 0x6349d(%rip), %rdi     # 0x93a28
callq 0x6a40
cmpl $0x0, %eax
je 0x305c9
leaq 0x63314(%rip), %rdi     # 0x938b0
callq 0x67a0
jmp 0x305a3
movq 0x629ce(%rip), %rdi     # 0x92f78
leaq 0x632ff(%rip), %rsi     # 0x938b0
leaq 0x62fe8(%rip), %rdx     # 0x935a0
callq 0x6490
leaq 0x63464(%rip), %rdi     # 0x93a28
callq 0x62f0
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x69f0
movq 0x8(%rsp), %rdx
leaq 0x45745(%rip), %rsi     # 0x75d29
leaq 0x30(%rsp), %rdi
callq 0x67c0
jmp 0x305f0
leaq 0x632b9(%rip), %rdi     # 0x938b0
leaq 0x30(%rsp), %rsi
callq 0x61f0
jmp 0x30603
leaq 0x30(%rsp), %rdi
callq 0x6b50
leaq 0x2f(%rsp), %rdi
callq 0x65f0
movq 0x63292(%rip), %rax     # 0x938b0
leaq 0x6328b(%rip), %rdi     # 0x938b0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x6950
movl 0x6c(%rsp), %esi
leaq 0x63275(%rip), %rdi     # 0x938b0
callq 0x69c0
movq 0x18(%rsp), %rdi
leaq 0x63264(%rip), %rsi     # 0x938b0
callq 0x6570
jmp 0x306a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x633c0(%rip), %rdi     # 0x93a28
callq 0x62d0
jmp 0x306ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x30697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6b50
leaq 0x2f(%rsp), %rdi
callq 0x65f0
jmp 0x306ad
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x69e0
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movsd %xmm1, 0x60(%rsp)
movsd 0x68(%rsp), %xmm0
ucomisd 0x60(%rsp), %xmm0
jne 0x307b5
jp 0x307b5
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x69f0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x4495c(%rip), %rsi     # 0x750de
callq 0x67c0
jmp 0x30789
leaq 0x5f(%rsp), %rdi
callq 0x65f0
jmp 0x308dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x65f0
jmp 0x308e7
cmpb $0x0, 0x633ec(%rip)     # 0x93ba8
jne 0x30803
leaq 0x633e3(%rip), %rdi     # 0x93ba8
callq 0x6a40
cmpl $0x0, %eax
je 0x30803
leaq 0x6325a(%rip), %rdi     # 0x93a30
callq 0x67a0
jmp 0x307dd
movq 0x62794(%rip), %rdi     # 0x92f78
leaq 0x63245(%rip), %rsi     # 0x93a30
leaq 0x62dae(%rip), %rdx     # 0x935a0
callq 0x6490
leaq 0x633aa(%rip), %rdi     # 0x93ba8
callq 0x62f0
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x69f0
movq (%rsp), %rdx
leaq 0x4550d(%rip), %rsi     # 0x75d29
leaq 0x28(%rsp), %rdi
callq 0x67c0
jmp 0x30828
leaq 0x63201(%rip), %rdi     # 0x93a30
leaq 0x28(%rsp), %rsi
callq 0x61f0
jmp 0x3083b
leaq 0x28(%rsp), %rdi
callq 0x6b50
leaq 0x27(%rsp), %rdi
callq 0x65f0
movq 0x631da(%rip), %rax     # 0x93a30
leaq 0x631d3(%rip), %rdi     # 0x93a30
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x6950
movsd 0x68(%rsp), %xmm0
leaq 0x631bb(%rip), %rdi     # 0x93a30
callq 0x6ab0
movq 0x10(%rsp), %rdi
leaq 0x631aa(%rip), %rsi     # 0x93a30
callq 0x6570
jmp 0x308dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x63306(%rip), %rdi     # 0x93ba8
callq 0x62d0
jmp 0x308e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x308d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6b50
leaq 0x27(%rsp), %rdi
callq 0x65f0
jmp 0x308e7
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x69e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x3d9(%rax)
je 0x34dd9
jmp 0x34eaf
movq (%rsp), %rax
movb 0x3d8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x34dfd
movq (%rsp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq *0x10(%rax)
movq (%rsp), %rax
movl 0x6c4(%rax), %ecx
addq $0x8, %rcx
movl %ecx, 0x6f4(%rax)
movq %rax, %rdi
addq $0x640, %rdi            # imm = 0x640
movl 0x6bc(%rax), %eax
movl %eax, %esi
callq 0x393f0
movq (%rsp), %rax
movq %rax, %rdi
addq $0x658, %rdi            # imm = 0x658
movl 0x6bc(%rax), %eax
movl %eax, %esi
callq 0x393f0
movq (%rsp), %rax
movq %rax, %rdi
addq $0x670, %rdi            # imm = 0x670
movl 0x6bc(%rax), %eax
movl %eax, %esi
callq 0x393f0
movq (%rsp), %rax
movq %rax, %rdi
addq $0x688, %rdi            # imm = 0x688
movl 0x6bc(%rax), %eax
movl %eax, %esi
callq 0x393f0
movq (%rsp), %rax
movq %rax, %rdi
addq $0x6a0, %rdi            # imm = 0x6A0
movl 0x6bc(%rax), %eax
movl %eax, %esi
callq 0x393f0
testb $0x1, 0xf(%rsp)
je 0x34ea4
movq (%rsp), %rdi
callq 0x56ee0
movq (%rsp), %rax
movb $0x1, 0x3d9(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movb 0x3d9(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x34ef7
movq (%rsp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x18(%rax)
movq (%rsp), %rax
cmpl $-0x1, 0x634(%rax)
je 0x34fd6
movl $0x0, 0x2c(%rsp)
movq (%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x34fd4
movq (%rsp), %rdi
addq $0x588, %rdi            # imm = 0x588
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x10310
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x34f71
movq (%rsp), %rdi
movl 0x2c(%rsp), %esi
movq (%rdi), %rax
xorl %r9d, %r9d
movl $0x1, %ecx
movl %r9d, %edx
movl %r9d, %r8d
callq *0x20(%rax)
movq (%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x4beb0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x34fc2
movq (%rsp), %rdi
addq $0x218, %rdi            # imm = 0x218
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x102b0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1bd30
jmp 0x34fc4
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x34f10
jmp 0x34fd6
addq $0x48, %rsp
retq
nopl (%rax,%rax)