LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-satelite.cc
// Function: google_extremal_sets::AllMaximalSetsSateLite::IsSubsumed(google_extremal_sets::SetProperties const&)
bool AllMaximalSetsSateLite::IsSubsumed(const SetProperties& candidate) {
  const OccursList& occurs = occurs_[candidate[0]];
  for (unsigned int j = 0; j < occurs.size(); ++j) {
    SetProperties* check_me = occurs[j];
    ++subsumption_checks_count_;
    if (IsSubsumedBy(candidate, *check_me))
      return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x30, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2f20
movq -0x38(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x2db0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2dd0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2a7d
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2f40
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2c30
testb $0x1, %al
jne 0x2a6a
jmp 0x2a70
movb $0x1, -0x1(%rbp)
jmp 0x2a81
jmp 0x2a72
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2a13
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-satelite.cc
// Function: google_extremal_sets::AllMaximalSetsSateLite::FoundMaximalSet(google_extremal_sets::SetProperties const&, google_extremal_sets::OutputModeEnum)
void AllMaximalSetsSateLite::FoundMaximalSet(
    const SetProperties& maximal_set, OutputModeEnum output_mode) {
  ++maximal_sets_count_;
  switch (output_mode) {
    case COUNT_ONLY:
      break;
    case ID:
      std::cout << maximal_set.set_id << '\n';
      break;
    case ID_AND_ITEMS:
      std::cout << maximal_set.set_id << ":";
      for (unsigned int i = 0; i < maximal_set.size; ++i) {
        std::cout << ' ' << maximal_set.item[i];
      }
      std::cout << '\n';
      break;
    default:
      std::cout << "Huh?\n";
      assert(0);
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x2ad3
jmp 0x2abc
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x2ad8
jmp 0x2ac6
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x2afc
jmp 0x2b72
jmp 0x2ba4
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq 0x84eb(%rip), %rdi      # 0xafd0
callq 0x22e0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2290
jmp 0x2ba4
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq 0x84c7(%rip), %rdi      # 0xafd0
callq 0x22e0
movq %rax, %rdi
leaq 0x455e(%rip), %rsi      # 0x7076
callq 0x2200
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2b5f
movq 0x8499(%rip), %rdi      # 0xafd0
movl $0x20, %esi
callq 0x2290
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %esi
callq 0x22e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b24
movq 0x846a(%rip), %rdi      # 0xafd0
movl $0xa, %esi
callq 0x2290
jmp 0x2ba4
movq 0x8457(%rip), %rdi      # 0xafd0
leaq 0x44f8(%rip), %rsi      # 0x7078
callq 0x2200
leaq 0x44f2(%rip), %rdi      # 0x707e
leaq 0x44ed(%rip), %rsi      # 0x7080
movl $0x99, %edx
leaq 0x44fe(%rip), %rcx      # 0x709d
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-satelite.cc
// Function: google_extremal_sets::(anonymous namespace)::IsSubsumedBy(google_extremal_sets::SetProperties const&, google_extremal_sets::SetProperties const&)
inline bool IsSubsumedBy(const SetProperties& set1, const SetProperties& set2) {
  if (set1.size >= set2.size)
    return false;
  const uint32_t* it1 = set1.begin();
  const uint32_t* it2 = set2.begin();
  const uint32_t* it1_end = set1.end();
  const uint32_t* it2_end = set2.end();

  while (it1 != it1_end) {
    it2 = std::lower_bound(it2, it2_end, *it1);
    if (it2 == it2_end || *it2 > *it1)
      return false;
    ++it1;
    ++it2;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x2c59
movb $0x0, -0x1(%rbp)
jmp 0x2ce8
movq -0x10(%rbp), %rdi
callq 0x3140
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3140
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3160
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x2ce4
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3180
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x2cc4
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x2cca
movb $0x0, -0x1(%rbp)
jmp 0x2ce8
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x2c8d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]Dsuite/Dsuite_utils.cpp
// Function: Fd_Denom_perVariant(double, double, double, double)
double Fd_Denom_perVariant(double p1, double p2, double p3, double pO) {
    double Fd_Denom = 0;
    if (p2 > p3) Fd_Denom = ((1-p1)*p2*p2*(1-pO)) - (p1*(1-p2)*p2*(1-pO));
    else Fd_Denom = ((1-p1)*p3*p3*(1-pO)) - (p1*(1-p3)*p3*(1-pO));
    return Fd_Denom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x9e82
movsd 0x7e694(%rip), %xmm0    # 0x884a8
subsd -0x8(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd 0x7e67d(%rip), %xmm2    # 0x884a8
subsd -0x20(%rbp), %xmm2
movsd -0x8(%rbp), %xmm1
movsd 0x7e66b(%rip), %xmm3    # 0x884a8
subsd -0x10(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd -0x10(%rbp), %xmm1
movsd 0x7e655(%rip), %xmm3    # 0x884a8
subsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x9ef6
movsd 0x7e61e(%rip), %xmm0    # 0x884a8
subsd -0x8(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd 0x7e607(%rip), %xmm2    # 0x884a8
subsd -0x20(%rbp), %xmm2
movsd -0x8(%rbp), %xmm1
movsd 0x7e5f5(%rip), %xmm3    # 0x884a8
subsd -0x18(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd -0x18(%rbp), %xmm1
movsd 0x7e5df(%rip), %xmm3    # 0x884a8
subsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: millanek[P]Dsuite/Dsuite_utils.cpp
// Function: GeneralSetCounts::findADtagPosition(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
int GeneralSetCounts::findADtagPosition(const std::vector<std::string>& vcfLineFields) {
    
    std::vector<std::string> format = split(vcfLineFields[8], ':');
    if (format.size() == 1) return LikelihoodsProbabilitiesAbsent; // The GT tag must be present in the first place
    
    int ADTagPosition = returnFormatTagPosition(format, "AD");
    if (ADTagPosition == std::numeric_limits<int>::min()) {
        std::cerr << "Could not find the AD tag in the VCF file. This tag is requored to use the pool-seq option. Exiting ...." << std::endl;
        exit(1);
    }
    return ADTagPosition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x10720
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movl $0x3a, %edx
callq 0xaef0
leaq -0x30(%rbp), %rdi
callq 0x10740
cmpq $0x1, %rax
jne 0xf2cc
movl $0x0, -0x4(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0xf3c1
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x8a60
movq -0x80(%rbp), %rdx
leaq 0x793ee(%rip), %rsi     # 0x886d2
leaq -0x58(%rbp), %rdi
callq 0x9a00
jmp 0xf2ef
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0xab40
movl %eax, -0x84(%rbp)
jmp 0xf308
leaq -0x58(%rbp), %rdi
callq 0x8c08
leaq -0x59(%rbp), %rdi
callq 0x8610
movl -0x84(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x88(%rbp)
callq 0x105e0
movl %eax, %ecx
movl -0x88(%rbp), %eax
cmpl %ecx, %eax
jne 0xf3b4
movq 0xafcac(%rip), %rdi     # 0xbeff0
leaq 0x7938a(%rip), %rsi     # 0x886d5
callq 0x8590
movq %rax, -0x90(%rbp)
jmp 0xf359
movq -0x90(%rbp), %rdi
movq 0xafbf9(%rip), %rsi     # 0xbef60
callq 0x85f0
jmp 0xf36e
movl $0x1, %edi
callq 0x86e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xf39b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8c08
leaq -0x59(%rbp), %rdi
callq 0x8610
jmp 0xf3d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xf3d6
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10760
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x10760
movq -0x68(%rbp), %rdi
callq 0x8a50
nopl (%rax,%rax)
// File: millanek[P]Dsuite/Dsuite_utils.cpp
// Function: calculateOneDs(double, double)
double calculateOneDs(double ABBAtotal, double BABAtotal) {
    // Get the D values
    double Dnum1 = ABBAtotal - BABAtotal;
    
    double Ddenom1 = ABBAtotal + BABAtotal;
    double D = Dnum1/Ddenom1;
    return D;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]Dsuite/Dsuite_utils.cpp
// Function: calculateThreeDs(double, double, double)
double* calculateThreeDs(double ABBAtotal, double BABAtotal, double BBAAtotal) {
    // Get the D values
    double Dnum1 = ABBAtotal - BABAtotal;
    double Dnum2 = ABBAtotal - BBAAtotal;
    double Dnum3 = BBAAtotal - BABAtotal;
    
    double Ddenom1 = ABBAtotal + BABAtotal;
    double Ddenom2 = ABBAtotal + BBAAtotal;
    double Ddenom3 = BBAAtotal + BABAtotal;
    static double Ds[3]; Ds[0] = Dnum1/Ddenom1; Ds[1] = Dnum2/Ddenom2; Ds[2] = Dnum3/Ddenom3;
    return Ds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, 0xb0821(%rip)    # 0xbfce0
movsd -0x28(%rbp), %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, 0xb0817(%rip)    # 0xbfce8
movsd -0x30(%rbp), %xmm0
divsd -0x48(%rbp), %xmm0
movsd %xmm0, 0xb080d(%rip)    # 0xbfcf0
leaq 0xb07f6(%rip), %rax     # 0xbfce0
popq %rbp
retq
nopl (%rax)
// File: millanek[P]Dsuite/Dsuite_utils.cpp
// Function: split2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> split2(std::string s, string delim) {
    std::vector<std::string> elems;
    size_t pos = 0;
    std::string token;
    while ((pos = s.find(delim)) != std::string::npos) {
        token = s.substr(0, pos);
        elems.push_back(token);
        s.erase(0, pos + delim.length());
    }
    elems.push_back(s);
    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x98(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x11d80
movq $0x0, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x87d0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x8bd0
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
je 0xf9d3
movq -0x90(%rbp), %rsi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
callq 0x85d0
jmp 0xf93c
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x68(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x86f0
movq -0xa8(%rbp), %rdi
callq 0x8c08
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x11d10
jmp 0xf978
movq -0x98(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x88b0
movq -0xb0(%rbp), %rdx
movq -0x90(%rbp), %rdi
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x8100
jmp 0xf9ab
jmp 0xf8fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8c08
movq -0x88(%rbp), %rdi
callq 0x10760
jmp 0xfa14
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x11d10
jmp 0xf9e8
movb $0x1, -0x19(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8c08
testb $0x1, -0x19(%rbp)
jne 0xfa07
movq -0x88(%rbp), %rdi
callq 0x10760
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x8a50
nopl (%rax)
// File: millanek[P]Dsuite/Dsuite_utils.cpp
// Function: checkGenotypesExist(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, int)
void checkGenotypesExist(const std::vector<std::string>& fields, const int variantNum) {
    if (fields.size() <= NUM_NON_GENOTYPE_COLUMNS) {
        std::cerr << "ERROR: Variant " << variantNum << " in the VCF appears to be truncated."  << std::endl;
        print_vector(fields, std::cerr);
        std::cerr << "Exiting..." << std::endl; exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10740
cmpq $0x9, %rax
ja 0xff98
movq 0xaf107(%rip), %rdi     # 0xbeff0
movq %rdi, -0x40(%rbp)
leaq 0x788d7(%rip), %rsi     # 0x887cb
callq 0x8590
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x8a10
movq %rax, %rdi
leaq 0x788cd(%rip), %rsi     # 0x887db
callq 0x8590
movq %rax, %rdi
movq 0xaf043(%rip), %rsi     # 0xbef60
callq 0x85f0
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x11fc0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x9, %edx
movl $0x1, %ecx
callq 0x11eb0
jmp 0xff4c
leaq -0x28(%rbp), %rdi
callq 0x10760
movq 0xaf094(%rip), %rdi     # 0xbeff0
leaq 0x78943(%rip), %rsi     # 0x888a6
callq 0x8590
movq %rax, %rdi
movq 0xaefee(%rip), %rsi     # 0xbef60
callq 0x85f0
movl $0x1, %edi
callq 0x86e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10760
jmp 0xff9e
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8a50
nopw (%rax,%rax)
// File: millanek[P]Dsuite/Dsuite_utils.cpp
// Function: assignSplits01FromAlleleFrequency(double, double&, double&)
void assignSplits01FromAlleleFrequency(const double p, double& splitA, double& splitB) {
    double r = ((double) rand() / (RAND_MAX));
    if (r <= p) { splitA = 1; }
    double r2 = ((double) rand() / (RAND_MAX));
    if (r2 <= p) { splitB = 1; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x8150
cvtsi2sd %eax, %xmm0
movsd 0x781fa(%rip), %xmm1    # 0x884d0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x102ff
movq -0x10(%rbp), %rax
movsd 0x781ad(%rip), %xmm0    # 0x884a8
movsd %xmm0, (%rax)
callq 0x8150
cvtsi2sd %eax, %xmm0
movsd 0x781c0(%rip), %xmm1    # 0x884d0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x10339
movq -0x18(%rbp), %rax
movsd 0x78173(%rip), %xmm0    # 0x884a8
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: millanek[P]Dsuite/./Dsuite_utils.h
// Function: TrioDinfo::addRegionDs(int)
void addRegionDs(const int arrangement) {
        switch (arrangement) {
            case P3isTrios2: if(localD1denom > 0) regionDs[0].push_back(localD1num/localD1denom); localD1num = 0; localD1denom = 0; usedVars[0] = 0; break;
            case P3isTrios1: if(localD2denom > 0) regionDs[1].push_back(localD2num/localD2denom); localD2num = 0; localD2denom = 0; usedVars[1] = 0; break;
            case P3isTrios0: if(localD3denom > 0) regionDs[2].push_back(localD3num/localD3denom); localD3num = 0; localD3denom = 0; usedVars[2] = 0; break;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x7, %eax
je 0x370c3
jmp 0x370a4
movl -0x2c(%rbp), %eax
subl $0x8, %eax
je 0x37146
jmp 0x370b2
movl -0x2c(%rbp), %eax
subl $0x9, %eax
je 0x371cb
jmp 0x3724b
movq -0x38(%rbp), %rax
movsd 0x180(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x37111
movq -0x38(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
xorl %eax, %eax
movl %eax, %esi
callq 0x39e80
movq %rax, %rdi
movq -0x38(%rbp), %rax
movsd 0x168(%rax), %xmm0
divsd 0x180(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x117b0
movq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x168(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x180(%rdi)
addq $0x1b0, %rdi            # imm = 0x1B0
xorl %eax, %eax
movl %eax, %esi
callq 0x115a0
movl $0x0, (%rax)
jmp 0x3724b
movq -0x38(%rbp), %rax
movsd 0x188(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x37195
movq -0x38(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
movl $0x1, %esi
callq 0x39e80
movq %rax, %rdi
movq -0x38(%rbp), %rax
movsd 0x170(%rax), %xmm0
divsd 0x188(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x117b0
movq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x170(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x188(%rdi)
addq $0x1b0, %rdi            # imm = 0x1B0
movl $0x1, %esi
callq 0x115a0
movl $0x0, (%rax)
jmp 0x3724b
movq -0x38(%rbp), %rax
movsd 0x190(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3721a
movq -0x38(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
movl $0x2, %esi
callq 0x39e80
movq %rax, %rdi
movq -0x38(%rbp), %rax
movsd 0x178(%rax), %xmm0
divsd 0x190(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x117b0
movq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x178(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x190(%rdi)
addq $0x1b0, %rdi            # imm = 0x1B0
movl $0x2, %esi
callq 0x115a0
movl $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: millanek[P]Dsuite/./Dsuite_utils.h
// Function: TrioDinfo::calculateFinalDs()
void calculateFinalDs() {
        double* Ds = calculateThreeDs(ABBAtotal, BABAtotal, BBAAtotal);
        D1 = Ds[0]; D2 = Ds[1]; D3 = Ds[2];
        
        // Get the standard error values:
        double D1stdErr = jackknive_std_err(regionDs[0]); double D2stdErr = jackknive_std_err(regionDs[1]);
        double D3stdErr = jackknive_std_err(regionDs[2]);
        //std::cerr << "Here: " << regionDs[2][0] << std::endl;
        // Get the Z-scores
        D1_Z = std::fabs(D1)/D1stdErr; D2_Z = std::fabs(D2)/D2stdErr; D3_Z = std::fabs(D3)/D3stdErr;
        // And p-values
        D1_p = 2 * (1 - normalCDF(D1_Z)); D2_p = 2 * (1 - normalCDF(D2_Z));
        D3_p = 2 * (1 - normalCDF(D3_Z));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
callq 0xf440
movq -0x40(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rdi)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rdi)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x28(%rdi)
addq $0x198, %rdi            # imm = 0x198
movq %rdi, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x39e80
movq %rax, %rdi
callq 0x3d020
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
movl $0x1, %esi
callq 0x39e80
movq %rax, %rdi
callq 0x3d020
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movl $0x2, %esi
callq 0x39e80
movq %rax, %rdi
callq 0x3d020
movq -0x40(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movsd 0x18(%rax), %xmm0
movapd 0x51710(%rip), %xmm1    # 0x893d0
pand %xmm1, %xmm0
movsd -0x18(%rbp), %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, 0x60(%rax)
movsd 0x20(%rax), %xmm0
pand %xmm1, %xmm0
movsd -0x20(%rbp), %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, 0x68(%rax)
movsd 0x28(%rax), %xmm0
pand %xmm1, %xmm0
movsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
movsd 0x60(%rax), %xmm0
callq 0x9d80
movq -0x40(%rbp), %rax
fld1
fld %st(0)
fstpt -0x34(%rbp)
fsubp %st, %st(1)
fadd %st, %st(0)
fstpt 0x30(%rax)
movsd 0x68(%rax), %xmm0
callq 0x9d80
movq -0x40(%rbp), %rax
fldt -0x34(%rbp)
fsubp %st, %st(1)
fadd %st, %st(0)
fstpt 0x40(%rax)
movsd 0x70(%rax), %xmm0
callq 0x9d80
movq -0x40(%rbp), %rax
fldt -0x34(%rbp)
fsubp %st, %st(1)
fadd %st, %st(0)
fstpt 0x50(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]Dsuite/./Dsuite_utils.h
// Function: TrioDinfo::assignBBAAarrangement()
void assignBBAAarrangement() {
        // Find which topology is in agreement with the counts of the BBAA, BABA, and ABBA patterns
        if (BBAAtotal >= BABAtotal && BBAAtotal >= ABBAtotal) {
            if (D1 >= 0) BBAAarrangement = P3isTrios2_Dpositive; else BBAAarrangement = P3isTrios2_Dnegative;
        } else if (BABAtotal >= BBAAtotal && BABAtotal >= ABBAtotal) {
            if (D2 >= 0) BBAAarrangement = P3isTrios1_Dpositive; else BBAAarrangement = P3isTrios1_Dnegative;
        } else if (ABBAtotal >= BBAAtotal && ABBAtotal >= BABAtotal) {
            if (D3 >= 0) BBAAarrangement = P3isTrios0_Dpositive; else BBAAarrangement = P3isTrios0_Dnegative;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd 0x10(%rax), %xmm0
ucomisd 0x8(%rax), %xmm0
jb 0x37dc0
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
ucomisd (%rax), %xmm0
jb 0x37dc0
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x37dad
movq -0x10(%rbp), %rax
movl $0x1, 0x1fc(%rax)
jmp 0x37dbb
movq -0x10(%rbp), %rax
movl $0x2, 0x1fc(%rax)
jmp 0x37e65
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd 0x10(%rax), %xmm0
jb 0x37e11
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd (%rax), %xmm0
jb 0x37e11
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x37e01
movq -0x10(%rbp), %rax
movl $0x3, 0x1fc(%rax)
jmp 0x37e0f
movq -0x10(%rbp), %rax
movl $0x4, 0x1fc(%rax)
jmp 0x37e63
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd 0x10(%rax), %xmm0
jb 0x37e61
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd 0x8(%rax), %xmm0
jb 0x37e61
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x37e51
movq -0x10(%rbp), %rax
movl $0x5, 0x1fc(%rax)
jmp 0x37e5f
movq -0x10(%rbp), %rax
movl $0x6, 0x1fc(%rax)
jmp 0x37e61
jmp 0x37e63
jmp 0x37e65
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]Dsuite/./Dsuite_utils.h
// Function: TrioDinfo::assignDminArrangement()
void assignDminArrangement() {
        
        if (std::fabs(D1) <= std::fabs(D2) && std::fabs(D1) <= std::fabs(D3)) {
            if (D1 >= 0) DminArrangement = P3isTrios2_Dpositive; else DminArrangement = P3isTrios2_Dnegative;
        } else if (std::fabs(D2) <= std::fabs(D1) && std::fabs(D2) <= std::fabs(D3)) { // (P3 == S2)
            if (D2 >= 0) DminArrangement = P3isTrios1_Dpositive; else DminArrangement = P3isTrios1_Dnegative;
        } else if (std::fabs(D3) <= std::fabs(D1) && std::fabs(D3) <= std::fabs(D2)) { // (P3 == S1)
            if (D3 >= 0) DminArrangement = P3isTrios0_Dpositive; else DminArrangement = P3isTrios0_Dnegative;
        }
        
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd 0x18(%rax), %xmm1
movaps 0x4ff84(%rip), %xmm0    # 0x893d0
pand %xmm0, %xmm1
movsd 0x20(%rax), %xmm0
movaps 0x4ff74(%rip), %xmm2    # 0x893d0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x394c5
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm1
movaps 0x4ff5a(%rip), %xmm0    # 0x893d0
pand %xmm0, %xmm1
movsd 0x28(%rax), %xmm0
movaps 0x4ff4a(%rip), %xmm2    # 0x893d0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x394c5
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x394b2
movq -0x10(%rbp), %rax
movl $0x1, 0x200(%rax)
jmp 0x394c0
movq -0x10(%rbp), %rax
movl $0x2, 0x200(%rax)
jmp 0x395d8
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm1
movaps 0x4fefb(%rip), %xmm0    # 0x893d0
pand %xmm0, %xmm1
movsd 0x18(%rax), %xmm0
movaps 0x4feeb(%rip), %xmm2    # 0x893d0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3954e
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm1
movaps 0x4fed1(%rip), %xmm0    # 0x893d0
pand %xmm0, %xmm1
movsd 0x28(%rax), %xmm0
movaps 0x4fec1(%rip), %xmm2    # 0x893d0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3954e
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3953b
movq -0x10(%rbp), %rax
movl $0x3, 0x200(%rax)
jmp 0x39549
movq -0x10(%rbp), %rax
movl $0x4, 0x200(%rax)
jmp 0x395d6
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm1
movaps 0x4fe72(%rip), %xmm0    # 0x893d0
pand %xmm0, %xmm1
movsd 0x18(%rax), %xmm0
movaps 0x4fe62(%rip), %xmm2    # 0x893d0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x395d4
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm1
movaps 0x4fe48(%rip), %xmm0    # 0x893d0
pand %xmm0, %xmm1
movsd 0x20(%rax), %xmm0
movaps 0x4fe38(%rip), %xmm2    # 0x893d0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x395d4
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x395c4
movq -0x10(%rbp), %rax
movl $0x5, 0x200(%rax)
jmp 0x395d2
movq -0x10(%rbp), %rax
movl $0x6, 0x200(%rax)
jmp 0x395d4
jmp 0x395d6
jmp 0x395d8
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]Dsuite/Dsuite_fBranch.cpp
// Function: Tree::fillSisterBranches()
void Tree::fillSisterBranches() {
    for (std::vector<Branch*>::iterator b = branches.begin(); b != branches.end(); b++) {
        if ((*b)->parentId != "treeOrigin") {
            string sisterId;
            if ((*b)->parentBranch->daughterId1 != (*b)->id)
                sisterId = (*b)->parentBranch->daughterId1;
            else
                sisterId = (*b)->parentBranch->daughterId2;
            for (std::vector<Branch*>::iterator bb = branches.begin(); bb != branches.end(); bb++) {
                if ((*bb)->id == sisterId) {
                    (*b)->sisterBranch = *bb;
                    break;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x18, %rdi
callq 0x49490
movq %rax, -0x10(%rbp)
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x49500
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x494c0
testb $0x1, %al
jne 0x477fb
jmp 0x4796c
leaq -0x10(%rbp), %rdi
callq 0x49530
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x43b32(%rip), %rsi     # 0x8b344
callq 0x22410
testb $0x1, %al
jne 0x47820
jmp 0x47956
leaq -0x38(%rbp), %rdi
callq 0x87d0
leaq -0x10(%rbp), %rdi
callq 0x49530
movq (%rax), %rax
movq 0xb8(%rax), %rax
addq $0x40, %rax
movq %rax, -0x78(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x49530
movq -0x78(%rbp), %rdi
movq (%rax), %rsi
callq 0x49d20
testb $0x1, %al
jne 0x4785f
jmp 0x4789d
leaq -0x10(%rbp), %rdi
callq 0x49530
movq (%rax), %rax
movq 0xb8(%rax), %rsi
addq $0x40, %rsi
leaq -0x38(%rbp), %rdi
callq 0x8070
jmp 0x47881
jmp 0x478c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8c08
jmp 0x47975
leaq -0x10(%rbp), %rdi
callq 0x49530
movq (%rax), %rax
movq 0xb8(%rax), %rsi
addq $0x60, %rsi
leaq -0x38(%rbp), %rdi
callq 0x8070
jmp 0x478bf
jmp 0x478c1
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x49490
movq %rax, -0x50(%rbp)
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x49500
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x494c0
testb $0x1, %al
jne 0x478f6
jmp 0x4794d
leaq -0x50(%rbp), %rdi
callq 0x49530
movq (%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x18dd0
testb $0x1, %al
jne 0x47911
jmp 0x4793a
leaq -0x50(%rbp), %rdi
callq 0x49530
movq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x49530
movq -0x80(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0xc0(%rax)
jmp 0x4794d
jmp 0x4793c
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x49ac0
movq %rax, -0x60(%rbp)
jmp 0x478d2
leaq -0x38(%rbp), %rdi
callq 0x8c08
jmp 0x47958
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x49ac0
movq %rax, -0x68(%rbp)
jmp 0x477d4
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8a50
nop
// File: millanek[P]Dsuite/./Dsuite_utils.h
// Function: double median<__gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>>(__gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>)
double median(RandAccessIter begin, RandAccessIter end) {
  if(begin == end){ throw median_of_empty_list_exception(); }
  std::size_t size = end - begin;
  std::size_t middleIdx = size/2;
  RandAccessIter target = begin + middleIdx;
  std::nth_element(begin, target, end);

  if(size % 2 != 0){ //Odd number of elements
    return *target;
  }else{            //Even number of elements
    double a = *target;
    RandAccessIter targetNeighbor= target-1;
    std::nth_element(begin, targetNeighbor, end);
    return (a+*targetNeighbor)/2.0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x73440
testb $0x1, %al
jne 0x49976
jmp 0x499b3
movl $0x8, %edi
callq 0x82a0
movq %rax, %rdi
movq %rdi, -0x78(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x82f0
movq -0x78(%rbp), %rdi
callq 0x75df0
movq -0x78(%rbp), %rdi
leaq 0x75209(%rip), %rsi     # 0xbebb0
leaq 0x2c482(%rip), %rdx     # 0x75e30
callq 0x89f0
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x18860
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x18120
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x75e50
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x49a2b
leaq -0x30(%rbp), %rdi
callq 0x18a90
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x49aa5
leaq -0x30(%rbp), %rdi
callq 0x18a90
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x18a50
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x75e50
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x18a90
movsd -0x80(%rbp), %xmm0
addsd (%rax), %xmm0
movsd 0x3ea24(%rip), %xmm1    # 0x884c0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]Dsuite/Dsuite_common.cpp
// Function: SetInformation::checkIfTreeNamesMatch(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<int, std::allocator<int>>>>>&)
void SetInformation::checkIfTreeNamesMatch(std::map<string,std::vector<int>>& treeTaxonNamesToLoc) {
        for (int i = 0; i != populations.size(); i++) {
            try { treeTaxonNamesToLoc.at(populations[i]);
            } catch (const std::out_of_range& oor) {
                std::cerr << "Out of Range error: " << oor.what() << '\n';
                std::cerr << "species[i]: " << populations[i] << '\n';
                std::cerr << CHECK_TREE_ERROR_MSG << '\n';
                exit(1);
    }}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10740
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x7f949
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x10b10
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x11850
jmp 0x7f833
jmp 0x7f939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7f94f
movq -0x20(%rbp), %rdi
callq 0x8220
movq %rax, -0x30(%rbp)
movq 0x3f788(%rip), %rdi     # 0xbeff0
leaq 0xdba3(%rip), %rsi      # 0x8d412
callq 0x8590
movq %rax, -0x50(%rbp)
jmp 0x7f87a
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x8590
movq %rax, -0x58(%rbp)
jmp 0x7f899
movq -0x58(%rbp), %rdi
movl $0xa, %esi
callq 0x86c0
jmp 0x7f8a9
movq 0x3f740(%rip), %rdi     # 0xbeff0
leaq 0xdb70(%rip), %rsi      # 0x8d427
callq 0x8590
movq %rax, -0x60(%rbp)
jmp 0x7f8c2
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x10b10
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x8520
movq %rax, -0x68(%rbp)
jmp 0x7f8e1
movq -0x68(%rbp), %rdi
movl $0xa, %esi
callq 0x86c0
jmp 0x7f8f1
movq 0x3f6f8(%rip), %rdi     # 0xbeff0
leaq 0xdb35(%rip), %rsi      # 0x8d434
callq 0x8590
movq %rax, -0x70(%rbp)
jmp 0x7f90a
movq -0x70(%rbp), %rdi
movl $0xa, %esi
callq 0x86c0
jmp 0x7f91a
movl $0x1, %edi
callq 0x86e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8950
jmp 0x7f937
jmp 0x7f94f
jmp 0x7f93b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7f7ef
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8a50
movq %rax, %rdi
callq 0x9d40
// File: millanek[P]Dsuite/Dsuite_common.cpp
// Function: makeHeader[abi:cxx11](bool, bool, bool)
string makeHeader(bool quartet, bool includeFstats, bool includeKSstats) {
    string header = "P1\tP2\tP3"; if (quartet) header += "\tP4";
    header += "\tDstatistic\tZ-score\tp-value";
    if (includeFstats) { header += "\t"; header += F4HEADER; }
    if (includeKSstats) { header += "\t"; header += "clustering_sensitive"; header += "\t"; header += "clustering_robust";}
    header += "\tBBAA\tABBA\tBABA";
    return header;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, %rsi
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %cl
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movb $0x0, -0xc(%rbp)
leaq -0xd(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x8a60
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xdb16(%rip), %rsi      # 0x8d4c5
callq 0x9a00
jmp 0x7f9b6
leaq -0xd(%rbp), %rdi
callq 0x8610
testb $0x1, -0x9(%rbp)
je 0x7fa0d
movq -0x30(%rbp), %rdi
leaq 0xdafe(%rip), %rsi      # 0x8d4ce
callq 0x8560
jmp 0x7f9d7
jmp 0x7fa0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x8610
jmp 0x7faca
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8c08
jmp 0x7faca
movq -0x30(%rbp), %rdi
leaq 0xdaba(%rip), %rsi      # 0x8d4d2
callq 0x8560
jmp 0x7fa1f
testb $0x1, -0xa(%rbp)
je 0x7fa4b
movq -0x30(%rbp), %rdi
leaq 0xb938(%rip), %rsi      # 0x8b368
callq 0x8560
jmp 0x7fa37
movq -0x30(%rbp), %rdi
leaq 0x9f1d(%rip), %rsi      # 0x8995f
callq 0x8560
jmp 0x7fa49
jmp 0x7fa4b
testb $0x1, -0xb(%rbp)
je 0x7fa9b
movq -0x30(%rbp), %rdi
leaq 0xb90c(%rip), %rsi      # 0x8b368
callq 0x8560
jmp 0x7fa63
movq -0x30(%rbp), %rdi
leaq 0xda80(%rip), %rsi      # 0x8d4ee
callq 0x8560
jmp 0x7fa75
movq -0x30(%rbp), %rdi
leaq 0xb8e8(%rip), %rsi      # 0x8b368
callq 0x8560
jmp 0x7fa87
movq -0x30(%rbp), %rdi
leaq 0xda71(%rip), %rsi      # 0x8d503
callq 0x8560
jmp 0x7fa99
jmp 0x7fa9b
movq -0x30(%rbp), %rdi
leaq 0xda6f(%rip), %rsi      # 0x8d515
callq 0x8560
jmp 0x7faad
movb $0x1, -0xc(%rbp)
testb $0x1, -0xc(%rbp)
jne 0x7fac0
movq -0x30(%rbp), %rdi
callq 0x8c08
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8a50
nopw %cs:(%rax,%rax)
// File: millanek[P]Dsuite/Dsuite_common.cpp
// Function: assignNumLinesToAnalyse(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int assignNumLinesToAnalyse(const int providedNumLinesOpt, const int regionLengthOpt,const string& vcfFileOpt) {
    int VCFlineCount;
    if (providedNumLinesOpt > 0) {
        VCFlineCount = providedNumLinesOpt;
    } else if (regionLengthOpt > 0) {
        VCFlineCount = regionLengthOpt;
    } else { // Block to find the number of lines in the VCF file
        std::istream* vcfFile = createReader(vcfFileOpt.c_str());
        // See how big is the VCF file
        vcfFile->unsetf(std::ios_base::skipws); // new lines will be skipped unless we stop it from happening:
        // count the newlines with an algorithm specialized for counting:
        VCFlineCount = (int)std::count(std::istream_iterator<char>(*vcfFile),std::istream_iterator<char>(),'\n');
        //std::cout << "VCF Lines: " << VCFlineCount << "\n";
    }
    return VCFlineCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x805b6
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x806a9
cmpl $0x0, -0x8(%rbp)
jle 0x805c7
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x806a7
movq -0x10(%rbp), %rdi
callq 0x8230
movq %rax, -0x90(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x8a60
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x9a00
jmp 0x80600
leaq -0x40(%rbp), %rdi
movl $0x8, %esi
callq 0xffb0
movq %rax, -0x98(%rbp)
jmp 0x80617
leaq -0x40(%rbp), %rdi
callq 0x8c08
leaq -0x41(%rbp), %rdi
callq 0x8610
movq -0x98(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x80ca0
movq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x80d40
leaq -0x78(%rbp), %rdi
callq 0x80d70
movb $0xa, -0x79(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x79(%rbp), %rdx
callq 0x80ce0
movl %eax, -0x14(%rbp)
jmp 0x806a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8069c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8c08
leaq -0x41(%rbp), %rdi
callq 0x8610
jmp 0x806b5
jmp 0x806a9
movl -0x14(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x8a50
nop
// File: millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: KScdf(int, double)
double KScdf (int n, double x)
{
   const double w = n * x * x;
   double u = cdfSpecial (n, x);
   if (u >= 0.0)
      return u;

   if (n <= NEXACT) {
      if (w < 0.754693)
         return DurbinMatrix (n, x);
      if (w < 4.0)
         return Pomeranz (n, x);
      return 1.0 - KSfbar (n, x);
   }

   /* if (n * x * sqrt(x) <= 1.4) */
   if ((w * x * n <= 2.0) && (n <= NKOLMO))
      return DurbinMatrix(n, x);

   return Pelz(n, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x854d0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x853f3
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x854b8
cmpl $0x8c, -0xc(%rbp)
jg 0x85468
movsd 0x82f4(%rip), %xmm0     # 0x8d6f8
ucomisd -0x20(%rbp), %xmm0
jbe 0x85422
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x856e0
movsd %xmm0, -0x8(%rbp)
jmp 0x854b8
movsd 0x82d6(%rip), %xmm0     # 0x8d700
ucomisd -0x20(%rbp), %xmm0
jbe 0x85445
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x85a60
movsd %xmm0, -0x8(%rbp)
jmp 0x854b8
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x86190
movaps %xmm0, %xmm1
movsd 0x304b(%rip), %xmm0     # 0x884a8
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x854b8
movsd -0x20(%rbp), %xmm1
mulsd -0x18(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x303d(%rip), %xmm0     # 0x884c0
ucomisd %xmm1, %xmm0
jb 0x854a6
cmpl $0x186a0, -0xc(%rbp)    # imm = 0x186A0
jg 0x854a6
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x856e0
movsd %xmm0, -0x8(%rbp)
jmp 0x854b8
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x862b0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: KSfbar(int, double)
double KSfbar (int n, double x)
{
   double w = n * x * x;
   double v = fbarSpecial (n, x);
   if (v >= 0.0)
      return v;

   if (n <= NEXACT) {
      if (w < 4.0)
         return 1.0 - KScdf (n, x);
      else
         return 2.0 * KSPlusbarUpper (n, x);
   }

   if (w >= 2.2)
      return 2.0 * KSPlusbarUpper (n, x);

   return 1.0 - KScdf (n, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x86d00
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x861e3
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x86298
cmpl $0x8c, -0xc(%rbp)
jg 0x86241
movsd 0x750c(%rip), %xmm0     # 0x8d700
ucomisd -0x20(%rbp), %xmm0
jbe 0x8621e
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x853a0
movaps %xmm0, %xmm1
movsd 0x2295(%rip), %xmm0     # 0x884a8
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x86298
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x86f50
movaps %xmm0, %xmm1
movsd 0x228a(%rip), %xmm0     # 0x884c0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x86298
movsd -0x20(%rbp), %xmm0
movsd 0x74da(%rip), %xmm1     # 0x8d728
ucomisd %xmm1, %xmm0
jb 0x86277
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x86f50
movaps %xmm0, %xmm1
movsd 0x2254(%rip), %xmm0     # 0x884c0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x86298
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
callq 0x853a0
movaps %xmm0, %xmm1
movsd 0x2219(%rip), %xmm0     # 0x884a8
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: getLogFactorial(int)
static double getLogFactorial (int n)
{
   /* Returns the natural logarithm of factorial n! */
   if (n <= MFACT) {
      return LnFactorial[n];

   } else {
      double x = (double) (n + 1);
      double y = 1.0 / (x * x);
      double z = ((-(5.95238095238E-4 * y) + 7.936500793651E-4) * y -
         2.7777777777778E-3) * y + 8.3333333333333E-2;
      z = ((x - 0.5) * log (x) - x) + 9.1893853320467E-1 + z / x;
      return z;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
jg 0x8739b
movslq -0xc(%rbp), %rcx
leaq 0x38834(%rip), %rax     # 0xbfbc0
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x87486
movl -0xc(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm1
mulsd -0x18(%rbp), %xmm1
movsd 0x10ec(%rip), %xmm0     # 0x884a8
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x6426(%rip), %xmm1     # 0x8d7f8
mulsd %xmm1, %xmm0
movsd 0x6422(%rip), %xmm1     # 0x8d800
addsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x63fd(%rip), %xmm1     # 0x8d7f0
addsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x63e0(%rip), %xmm1     # 0x8d7e8
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x1092(%rip), %xmm1     # 0x884b0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x8490
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x637b(%rip), %xmm1     # 0x8d7e0
addsd %xmm1, %xmm0
movsd -0x28(%rbp), %xmm1
divsd -0x18(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: millanek[P]Dsuite/KolmogorovSmirnovDist.cpp
// Function: CreateMatrixD(int, int)
static double **CreateMatrixD (int N, int M)
{
   int i;
   double **T2;

   T2 = (double **) malloc (N * sizeof (double *));
   T2[0] = (double *) malloc (N * M * sizeof (double));
   for (i = 1; i < N; i++)
      T2[i] = T2[0] + i * M;
   return T2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x8780
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x8780
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x87519
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movl -0xc(%rbp), %eax
imull -0x8(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x874e3
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)