LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/andersonfernandes[P]sm-chat/src/shm_queue.cpp
// Function: create_queue()
ShmQueue* create_queue() {
  ShmQueue* shmq = new ShmQueue();
  shmq->capacity = MAX_MESSAGES;  
  shmq->front = shmq->size = 0;  
  shmq->rear = MAX_MESSAGES - 1;
  shmq->locked = false;
  shmq->messages_list_shmid = shmget(generate_key(), MAX_MESSAGES * sizeof(Message), 0666|IPC_CREAT);

  return shmq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x18, %edi
callq 0x1120
movq %rax, %rbx
movq $0x0, 0x10(%rax)
movaps 0xc62(%rip), %xmm0      # 0x2010
movups %xmm0, (%rax)
xorl %edi, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10f0
callq 0x1040
movl $0x284880, %esi         # imm = 0x284880
movl %eax, %edi
movl $0x3b6, %edx            # imm = 0x3B6
callq 0x1080
movl %eax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/andersonfernandes[P]sm-chat/src/server.cpp
// Function: main
int main() {
  init();

  while (1) {
    process_new_users();

    if(kill_server_flag) {
      cout << "\nCleaning shared memory segments" << endl;

      User *users = att_users(users_shmid);
      int *users_count = att_users_count(users_count_shmid);
      for (int i = 0; i < (*users_count); i++) {

        ShmQueue* shmq = (ShmQueue*) shmat(users[i].shmq_id, NULL, 0);
        shmctl(shmq->messages_list_shmid, IPC_RMID, NULL);
        shmdt(shmq);

        shmctl(users[i].shmq_id, IPC_RMID, NULL);
      }

      shmdt(users_count);
      shmdt(users);

      shmctl(users_shmid, IPC_RMID, NULL);
      shmctl(users_count_shmid, IPC_RMID, NULL);

      cout << "\nBye!" << endl;
      exit(0);
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1642
callq 0x170f
cmpb $0x1, 0x2baa(%rip)      # 0x40f1
jne 0x153b
movq 0x2a88(%rip), %rbx      # 0x3fd8
leaq 0xac9(%rip), %rsi       # 0x2020
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movl 0x2b63(%rip), %edi      # 0x40f4
callq 0x150c
movq %rax, %rbx
movl 0x2b59(%rip), %edi      # 0x40f8
callq 0x151a
movq %rax, %r14
cmpl $0x0, (%rax)
jle 0x15f2
xorl %r12d, %r12d
movq %rbx, %r13
movl (%r13), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1160
movq %rax, %r15
movl 0x10(%rax), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10b0
movq %r15, %rdi
callq 0x1190
movl (%r13), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10b0
incq %r12
movslq (%r14), %rax
addq $0x38, %r13
cmpq %rax, %r12
jl 0x15b2
movq %r14, %rdi
callq 0x1190
movq %rbx, %rdi
callq 0x1190
movl 0x2aec(%rip), %edi      # 0x40f4
xorl %esi, %esi
xorl %edx, %edx
callq 0x10b0
movl 0x2ae1(%rip), %edi      # 0x40f8
xorl %esi, %esi
xorl %edx, %edx
callq 0x10b0
movq 0x29b1(%rip), %rdi      # 0x3fd8
leaq 0xa13(%rip), %rsi       # 0x2041
callq 0x1110
movq %rax, %rdi
callq 0x1070
xorl %edi, %edi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/andersonfernandes[P]sm-chat/src/server.cpp
// Function: init()
void init() {
  srand(time(NULL));

  system("clear");
  cout << "\n> Starting the server \n" <<  endl;

  int *users_count = att_users_count(users_count_shmid);
  *users_count = 0;
  shmdt(users_count);

  cout << "Use Ctrl-C to stop\n" << endl;
  signal(SIGINT, sigint_handler);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10f0
leaq 0x9ea(%rip), %rdi       # 0x2047
callq 0x10c0
movq 0x296f(%rip), %rbx      # 0x3fd8
leaq 0x9dd(%rip), %rsi       # 0x204d
movl $0x18, %edx
movq %rbx, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movl 0x2a4e(%rip), %edi      # 0x40f8
callq 0x151a
movl $0x0, (%rax)
movq %rax, %rdi
callq 0x1190
leaq 0x9a2(%rip), %rsi       # 0x2066
movl $0x13, %edx
movq %rbx, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
leaq 0x17f(%rip), %rsi       # 0x187e
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1140
// File: /workspace/github_cpp_makefile_star2_O3/andersonfernandes[P]sm-chat/src/server.cpp
// Function: process_new_users()
void process_new_users() {
  User *users = att_users(users_shmid);
  int *users_count = att_users_count(users_count_shmid);

  if(old_count != *users_count) {
    for (int i = old_count; i < *users_count; i++) {
      User user = users[i];

      time_t now = time(0);
      cout << ctime(&now) << " > ";
      cout << user.name << " logged on the server\n" <<  endl;  
    }

    old_count = (*users_count);
  }

  shmdt(users_count);
  shmdt(users);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x29ce(%rip), %edi      # 0x40f4
callq 0x150c
movq %rax, %r15
movl 0x29c4(%rip), %edi      # 0x40f8
callq 0x151a
movq %rax, %r14
movslq 0x29b9(%rip), %r12      # 0x40fc
movl (%rax), %eax
cmpl %eax, %r12d
je 0x185f
cmpl %eax, %r12d
jge 0x1859
imulq $0x38, %r12, %rax
movq %r15, -0x30(%rbp)
addq %rax, %r15
movq 0x286f(%rip), %r13      # 0x3fd8
movq 0x30(%r15), %rax
movq %rax, -0x40(%rbp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movaps %xmm2, -0x50(%rbp)
movaps %xmm1, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
xorl %edi, %edi
callq 0x10e0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1050
testq %rax, %rax
je 0x17bf
movq %rax, %rbx
movq %rax, %rdi
callq 0x1060
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1130
jmp 0x17d8
movq (%r13), %rax
movq -0x18(%rax), %rax
leaq (%rax,%r13), %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x1180
movl $0x3, %edx
movq %r13, %rdi
leaq 0x893(%rip), %rsi       # 0x207a
callq 0x1130
leaq -0x6c(%rbp), %rbx
movq %rbx, %rdi
callq 0x1060
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1130
movl $0x16, %edx
movq %r13, %rdi
leaq 0x869(%rip), %rsi       # 0x207e
callq 0x1130
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %r13, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
incq %r12
movslq (%r14), %rax
addq $0x38, %r15
cmpq %rax, %r12
jl 0x1769
movq -0x30(%rbp), %r15
movl %eax, 0x289d(%rip)      # 0x40fc
movq %r14, %rdi
callq 0x1190
movq %r15, %rdi
callq 0x1190
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-satelite.cc
// Function: google_extremal_sets::AllMaximalSetsSateLite::PrepareForDataScan(google_extremal_sets::DataSourceIterator*, unsigned int, long)
bool AllMaximalSetsSateLite::PrepareForDataScan(
    DataSourceIterator* data, uint32_t max_item_id, off_t resume_offset) {
  occurs_.clear();
  occurs_.resize(max_item_id);
  std::cerr << "; Starting new dataset scan at offset: "
            << resume_offset << std::endl;
  return data->Seek(resume_offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rsi
addq $0x30, %r15
movq %r15, %rdi
callq 0x2b94
movl %ebp, %esi
movq %r15, %rdi
callq 0x2a10
movq 0x4883(%rip), %r15      # 0x6ff0
leaq 0x18da(%rip), %rsi      # 0x404e
movl $0x27, %edx
movq %r15, %rdi
callq 0x2200
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32fa
nop
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-satelite.cc
// Function: google_extremal_sets::AllMaximalSetsSateLite::IsSubsumed(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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x8(%rsi), %eax
movq 0x30(%rdi), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
xorl %r8d, %r8d
subq %rcx, %rdx
je 0x28a9
sarq $0x3, %rdx
movl 0x4(%rsi), %r10d
addq $0x8, %rsi
leaq (%rsi,%r10,4), %r11
movq %rdi, -0x8(%rsp)
movq 0x10(%rdi), %r9
movq %rcx, %rdi
movq (%rdi,%r8,8), %rbx
incq %r9
movl 0x4(%rbx), %r14d
cmpl %r14d, %r10d
jae 0x2890
movb $0x1, %al
testl %r10d, %r10d
je 0x289e
leaq (%rbx,%r14,4), %rcx
addq $0x8, %rcx
addq $0x8, %rbx
movq %rsi, %r15
movq %rcx, %r14
subq %rbx, %r14
sarq $0x2, %r14
testq %r14, %r14
jle 0x2875
movl (%r15), %ebp
movq %r14, %r12
shrq %r12
movq %r12, %r13
notq %r13
addq %r14, %r13
leaq (%rbx,%r12,4), %r14
addq $0x4, %r14
cmpl %ebp, -0x4(%r14)
cmovaeq %r12, %r13
cmovbq %r14, %rbx
movq %r13, %r14
testq %r13, %r13
jg 0x284a
cmpq %rcx, %rbx
je 0x2890
movl (%rbx), %ebp
cmpl (%r15), %ebp
ja 0x2890
addq $0x4, %r15
addq $0x4, %rbx
cmpq %r11, %r15
jne 0x2838
jmp 0x289e
incl %r8d
cmpq %r8, %rdx
ja 0x2812
xorl %eax, %eax
movq -0x8(%rsp), %rcx
movq %r9, 0x10(%rcx)
jmp 0x28ab
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
incq (%rdi)
testl %edx, %edx
je 0x2977
movq %rsi, %rbx
cmpl $0x2, %edx
je 0x28fa
cmpl $0x1, %edx
jne 0x2983
movl (%rbx), %esi
movq 0x46ed(%rip), %rdi      # 0x6fd0
callq 0x2110
leaq 0x6(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
jmp 0x2972
movl (%rbx), %esi
movq 0x46cd(%rip), %rdi      # 0x6fd0
callq 0x2110
leaq 0x1767(%rip), %rsi      # 0x4076
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
cmpl $0x0, 0x4(%rbx)
je 0x295e
xorl %r12d, %r12d
movq 0x46a4(%rip), %r14      # 0x6fd0
leaq 0x5(%rsp), %r15
movb $0x20, 0x5(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movl 0x8(%rbx,%r12,4), %esi
movq %rax, %rdi
callq 0x2110
incq %r12
movl 0x4(%rbx), %eax
cmpq %rax, %r12
jb 0x2931
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x4663(%rip), %rdi      # 0x6fd0
movl $0x1, %edx
callq 0x2200
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4646(%rip), %rdi      # 0x6fd0
leaq 0x16e7(%rip), %rsi      # 0x4078
callq 0x21b0
leaq 0x16e1(%rip), %rdi      # 0x407e
leaq 0x16dc(%rip), %rsi      # 0x4080
leaq 0x16f2(%rip), %rcx      # 0x409d
movl $0x99, %edx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movapd %xmm0, %xmm4
ucomisd %xmm2, %xmm1
movsd 0x38ae7(%rip), %xmm5    # 0x41470
movapd %xmm5, %xmm0
subsd %xmm4, %xmm0
movapd %xmm5, %xmm6
subsd %xmm3, %xmm6
jbe 0x89b1
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
subsd %xmm1, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm1, %xmm5
jmp 0x89c5
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
subsd %xmm2, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm2, %xmm5
mulsd %xmm6, %xmm5
mulsd %xmm6, %xmm0
subsd %xmm5, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]Dsuite/Dsuite_utils.cpp
// Function: FdM_Denom_perVariant(double, double, double, double)
double FdM_Denom_perVariant(double p1, double p2, double p3, double pO) {
    double FdM_Denom = 0;
    if (p1 <= p2) {
        if (p2 > p3) FdM_Denom = ((1-p1) * p2 * p2 * (1-pO)) - (p1 * (1-p2) * p2 * (1-pO));
        else FdM_Denom = ((1-p1) * p3 * p3 * (1-pO)) - (p1 * (1-p3) * p3 * (1-pO));
    } else {
        if (p1 > p3) FdM_Denom = -(((1-p1)*p2*p1*(1-pO)) - (p1*(1-p2)*p1*(1-pO)));
        else FdM_Denom = -(((1-p3)*p2*p3*(1-pO)) - (p3*(1-p2)*p3*(1-pO)));
    }
    return FdM_Denom;
}

// Assembly:
movapd %xmm0, %xmm4
ucomisd %xmm0, %xmm1
jae 0x8a66
ucomisd %xmm2, %xmm4
movsd 0x38a3a(%rip), %xmm0    # 0x41470
movapd %xmm0, %xmm5
subsd %xmm3, %xmm5
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
xorpd 0x38a62(%rip), %xmm3    # 0x414b0
jbe 0x8a9a
subsd %xmm4, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm4, %xmm0
mulsd %xmm4, %xmm3
mulsd %xmm4, %xmm3
jmp 0x8aae
ucomisd %xmm2, %xmm1
movsd 0x389fe(%rip), %xmm5    # 0x41470
movapd %xmm5, %xmm0
subsd %xmm4, %xmm0
movapd %xmm5, %xmm6
subsd %xmm3, %xmm6
jbe 0x8ac3
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
subsd %xmm1, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm1, %xmm5
jmp 0x8ad7
subsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm5, %xmm3
mulsd %xmm5, %xmm0
addsd %xmm3, %xmm0
xorpd 0x389ee(%rip), %xmm0    # 0x414b0
retq
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
subsd %xmm2, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm2, %xmm5
mulsd %xmm6, %xmm5
mulsd %xmm6, %xmm0
subsd %xmm5, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0x100, %eax            # imm = 0x100
addq (%rsi), %rax
movq %rsp, %rbx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3a, %edx
callq 0x91c1
movq 0x8(%rbx), %rax
subq (%rbx), %rax
xorl %ebx, %ebx
cmpq $0x20, %rax
je 0xc5f9
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3517d(%rip), %rsi     # 0x4171a
leaq 0x35178(%rip), %rdx     # 0x4171c
leaq 0x18(%rsp), %rdi
callq 0x88ba
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xf357
movq %rax, %r14
movq 0x8(%rsp), %r12
movq (%rsp), %rax
movq %r14, %rbx
subq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xc5ea
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7420
cmpq %r12, %r14
je 0xc60f
shrq $0x5, %rbx
movl %ebx, %eax
negl %eax
jo 0xc60f
movq %rsp, %rdi
callq 0xd1ac
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4b9d2(%rip), %rdi     # 0x57fe8
leaq 0x35100(%rip), %rsi     # 0x4171d
movl $0x68, %edx
callq 0x74b0
movq 0x4b9ba(%rip), %rdi     # 0x57fe8
callq 0x71b0
movl $0x1, %edi
callq 0x7510
jmp 0xc65b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xc65e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xc65e
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd1ac
movq %rbx, %rdi
callq 0x7740
// File: /workspace/github_cpp_makefile_star2_O3/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:
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm1, %xmm3
unpcklpd %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0]
movapd %xmm0, %xmm4
subpd %xmm3, %xmm4
movapd %xmm2, %xmm5
subsd %xmm1, %xmm5
addpd %xmm0, %xmm3
divpd %xmm3, %xmm4
addsd %xmm2, %xmm1
divsd %xmm1, %xmm5
movapd %xmm4, 0x4c229(%rip)    # 0x588e0
leaq 0x4c222(%rip), %rax     # 0x588e0
movsd %xmm5, 0x4c22a(%rip)    # 0x588f0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x7720
cmpq $-0x1, %rax
je 0xcad5
movq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x7450
movq %r13, %rdi
movq %r12, %rsi
callq 0x7520
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xcab7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7420
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd894
addq 0x8(%r15), %rbp
movq %r14, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x70a0
jmp 0xca66
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd894
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xcafc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcb12
jmp 0xcb12
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xcb31
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
movq %rbx, %rdi
callq 0xd1ac
movq %r14, %rdi
callq 0x7740
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]Dsuite/Dsuite_utils.cpp
// Function: locateSet(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&, 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&)
std::vector<size_t> locateSet(const std::vector<std::string>& sample_names, const std::vector<std::string>& set) {
    std::vector<size_t> setLocs;
    for (std::vector<std::string>::size_type i = 0; i != set.size(); i++) {
        std::vector<std::string>::const_iterator it = std::find(sample_names.begin(), sample_names.end(), set[i]);
        if (it == sample_names.end()) {
            std::cerr << "Did not find the sample: \"" << set[i] << "\"" << std::endl;
            print_vector(sample_names, std::cerr,',');
        } else {
            size_t loc = std::distance(sample_names.begin(), it);
            setLocs.push_back(loc);
        }
    }
    return setLocs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rdx
cmpq %rdx, 0x8(%r14)
je 0xcc87
movq %rsi, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15), %rdi
movq 0x8(%r15), %rsi
addq %r12, %rdx
callq 0xfb03
cmpq 0x8(%r15), %rax
je 0xcbb8
subq (%r15), %rax
sarq $0x5, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xcc5c
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xcc69
movl $0x1a, %edx
movq 0x4b424(%rip), %rdi     # 0x57fe8
leaq 0x34bbb(%rip), %rsi     # 0x41786
callq 0x74b0
movq (%r14), %rax
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq 0x4b405(%rip), %rdi     # 0x57fe8
callq 0x74b0
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x34ba5(%rip), %rsi     # 0x4179f
callq 0x74b0
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x73f0
movsbl %al, %esi
movq %rbp, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x72e0
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xd99e
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq 0x4b3a5(%rip), %rsi     # 0x57fe8
movl $0x2c, %edx
movl $0x1, %ecx
callq 0xd8d1
movq %rbp, %rdi
callq 0xd1ac
jmp 0xcc69
movq %rbx, %rdi
leaq 0x8(%rsp), %rdx
callq 0xfcb0
incq %r13
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %rax, %r13
jne 0xcb79
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xccaa
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xd1ac
jmp 0xccad
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xccc1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x7420
movq %r14, %rdi
callq 0x7740
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
callq 0x70d0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x3440a(%rip), %xmm0    # 0x414a0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
jb 0xd0af
movq %r15, (%r14)
callq 0x70d0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x343dd(%rip), %xmm0    # 0x414a0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jb 0xd0d2
movq %r15, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]Dsuite/./Dsuite_utils.h
// Function: double vector_sum<std::deque<double, std::allocator<double>>>(std::deque<double, std::allocator<double>>)
double vector_sum(T vector) {
    double sum = 0;
    for (int i = 0; i < vector.size(); i++) {
        sum += vector[i];
    }
    return sum;
}

// Assembly:
movq 0x48(%rdi), %rcx
movq 0x28(%rdi), %rax
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
movq 0x30(%rdi), %rsi
subq 0x38(%rdi), %rsi
shlq $0x6, %rdx
sarq $0x3, %rsi
addq %rdx, %rsi
movq 0x10(%rdi), %rcx
movq 0x20(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
addq %rsi, %rdx
je 0x147b6
movq %rcx, %rsi
subq 0x18(%rdi), %rsi
sarq $0x3, %rsi
xorpd %xmm0, %xmm0
xorl %edi, %edi
movq %rsi, %r8
testq %r8, %r8
js 0x14784
movq %rcx, %r9
cmpq $0x40, %r8
jb 0x147a1
movq %r8, %r10
shrq $0x6, %r10
jmp 0x1478b
movq %r8, %r10
sarq $0x6, %r10
leaq (%rsi,%rdi), %r9
movq %r10, %r11
shlq $0x6, %r11
subq %r11, %r9
shlq $0x3, %r9
addq (%rax,%r10,8), %r9
addsd (%r9), %xmm0
incq %rdi
addq $0x8, %rcx
incq %r8
decq %rdx
jne 0x1476d
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x9, %esi
je 0x1d654
cmpl $0x8, %esi
je 0x1d60d
cmpl $0x7, %esi
jne 0x1d714
movsd 0x180(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1d6f7
movq 0x198(%rbx), %rdi
movsd 0x168(%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1d6ed
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x1d6f7
movsd 0x188(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1d6a5
movq 0x198(%rbx), %rdi
movsd 0x170(%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0x20(%rdi), %rsi
cmpq 0x28(%rdi), %rsi
je 0x1d697
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x20(%rdi)
jmp 0x1d6a5
movsd 0x190(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1d6d0
movq 0x198(%rbx), %rdi
movsd 0x178(%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0x38(%rdi), %rsi
cmpq 0x40(%rdi), %rsi
je 0x1d6c2
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rdi)
jmp 0x1d6d0
addq $0x18, %rdi
leaq 0x8(%rsp), %rdx
callq 0xf234
xorl %eax, %eax
movq %rax, 0x170(%rbx)
movq %rax, 0x188(%rbx)
movq 0x1b0(%rbx), %rax
addq $0x4, %rax
jmp 0x1d70e
addq $0x30, %rdi
leaq 0x8(%rsp), %rdx
callq 0xf234
xorl %eax, %eax
movq %rax, 0x178(%rbx)
movq %rax, 0x190(%rbx)
movq 0x1b0(%rbx), %rax
addq $0x8, %rax
jmp 0x1d70e
leaq 0x8(%rsp), %rdx
callq 0xf234
xorl %eax, %eax
movq %rax, 0x168(%rbx)
movq %rax, 0x180(%rbx)
movq 0x1b0(%rbx), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rdi), %xmm2
callq 0xc683
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rbx)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rbx)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x28(%rbx)
movq 0x198(%rbx), %rdi
callq 0x1fed3
movapd %xmm0, 0x10(%rsp)
movq 0x198(%rbx), %rdi
addq $0x18, %rdi
callq 0x1fed3
movapd %xmm0, (%rsp)
movq 0x198(%rbx), %rdi
addq $0x30, %rdi
callq 0x1fed3
movupd 0x18(%rbx), %xmm1
movapd 0x243f4(%rip), %xmm2    # 0x42280
andpd %xmm2, %xmm1
movapd 0x10(%rsp), %xmm3
unpcklpd (%rsp), %xmm3           # xmm3 = xmm3[0],mem[0]
divpd %xmm3, %xmm1
movapd %xmm1, 0x60(%rbx)
movsd 0x28(%rbx), %xmm3
andpd %xmm2, %xmm3
divsd %xmm0, %xmm3
movsd %xmm3, 0x70(%rbx)
movapd %xmm1, %xmm0
callq 0x8950
fld1
fsubp %st, %st(1)
fadd %st, %st(0)
fstpt 0x30(%rbx)
movsd 0x68(%rbx), %xmm0
callq 0x8950
fld1
fsubp %st, %st(1)
fadd %st, %st(0)
fstpt 0x40(%rbx)
movsd 0x70(%rbx), %xmm0
callq 0x8950
fld1
fsubp %st, %st(1)
fadd %st, %st(0)
fstpt 0x50(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movsd 0x10(%rdi), %xmm2
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
ucomisd %xmm1, %xmm2
jb 0x1df28
ucomisd %xmm0, %xmm2
jb 0x1df28
movsd 0x18(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1df74
movl $0x2, 0x1fc(%rdi)
retq
ucomisd %xmm2, %xmm1
jb 0x1df4e
ucomisd %xmm0, %xmm1
jb 0x1df4e
movsd 0x20(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1df7f
movl $0x4, 0x1fc(%rdi)
retq
ucomisd %xmm2, %xmm0
jb 0x1df73
ucomisd %xmm1, %xmm0
jb 0x1df73
movsd 0x28(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1df8a
movl $0x6, 0x1fc(%rdi)
retq
movl $0x1, 0x1fc(%rdi)
retq
movl $0x3, 0x1fc(%rdi)
retq
movl $0x5, 0x1fc(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movdqu 0x18(%rdi), %xmm0
movdqa 0x233c3(%rip), %xmm1    # 0x42280
pand %xmm0, %xmm1
pshufd $0xee, %xmm1, %xmm2     # xmm2 = xmm1[2,3,2,3]
ucomisd %xmm1, %xmm2
jb 0x1eedf
movsd 0x28(%rdi), %xmm3
andpd 0x233a7(%rip), %xmm3    # 0x42280
ucomisd %xmm1, %xmm3
jae 0x1ef36
ucomisd %xmm2, %xmm1
movsd 0x28(%rdi), %xmm3
movapd 0x23390(%rip), %xmm4    # 0x42280
andpd %xmm3, %xmm4
jb 0x1ef15
ucomisd %xmm2, %xmm4
jb 0x1ef15
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1ef4b
movl $0x4, 0x200(%rdi)
retq
ucomisd %xmm4, %xmm1
jb 0x1ef35
ucomisd %xmm4, %xmm2
jb 0x1ef35
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jae 0x1ef61
movl $0x6, 0x200(%rdi)
retq
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1ef56
movl $0x2, 0x200(%rdi)
retq
movl $0x3, 0x200(%rdi)
retq
movl $0x1, 0x200(%rdi)
retq
movl $0x5, 0x200(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rsi
cmpq %rsi, 0x8(%rdi)
je 0x3c1de
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rsi
movq %r14, %rdi
callq 0xd6ba
incq %r12
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rax, %r12
jne 0x3c1b9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x3c2c6
movq %r14, %rdi
callq 0x7170
movq %rax, %r14
movq 0x1bde0(%rip), %rdi     # 0x57fe8
leaq 0x9f76(%rip), %rsi      # 0x46185
movl $0x14, %edx
callq 0x74b0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x1bdbf(%rip), %rdi     # 0x57fe8
movq %rax, %rsi
callq 0x7400
leaq 0x6(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x74b0
movq 0x1bd9b(%rip), %rdi     # 0x57fe8
leaq 0x9f46(%rip), %rsi      # 0x4619a
movl $0xc, %edx
callq 0x74b0
movq (%rbx), %rax
movq (%rax,%r15), %rsi
movq 0x8(%rax,%r15), %rdx
movq 0x1bd77(%rip), %rdi     # 0x57fe8
callq 0x74b0
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x74b0
movq 0x1bd56(%rip), %rdi     # 0x57fe8
leaq 0x9f0e(%rip), %rsi      # 0x461a7
movl $0x90, %edx
callq 0x74b0
movq 0x1bd3e(%rip), %rdi     # 0x57fe8
movl $0xa, %esi
callq 0x74f0
movl $0x1, %edi
callq 0x7510
movq %rax, %r14
callq 0x76a0
movq %r14, %rdi
callq 0x7740
movq %rax, %rdi
callq 0xd5b6
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x9f41(%rip), %rsi      # 0x46238
leaq 0x9f42(%rip), %rdx      # 0x46240
callq 0x88ba
testl %r15d, %r15d
je 0x3c317
leaq 0x9f32(%rip), %rsi      # 0x46241
movq %rbx, %rdi
callq 0x77f0
leaq 0x9f27(%rip), %rsi      # 0x46245
movq %rbx, %rdi
callq 0x77f0
testb %r14b, %r14b
je 0x3c349
leaq 0x7d0e(%rip), %rsi      # 0x44040
movq %rbx, %rdi
callq 0x77f0
leaq 0x6516(%rip), %rsi      # 0x42857
movq %rbx, %rdi
callq 0x77f0
testb %bpl, %bpl
je 0x3c38a
leaq 0x7ceb(%rip), %rsi      # 0x44040
movq %rbx, %rdi
callq 0x77f0
leaq 0x9efd(%rip), %rsi      # 0x46261
movq %rbx, %rdi
callq 0x77f0
leaq 0x7ccd(%rip), %rsi      # 0x44040
movq %rbx, %rdi
callq 0x77f0
leaq 0x9ef4(%rip), %rsi      # 0x46276
movq %rbx, %rdi
callq 0x77f0
leaq 0x9ef7(%rip), %rsi      # 0x46288
movq %rbx, %rdi
callq 0x77f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3c3bc
movq (%r12), %rsi
incq %rsi
callq 0x7420
movq %r14, %rdi
callq 0x7740
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
testl %edi, %edi
jg 0x3d13c
movl %esi, %ebx
testl %esi, %esi
jg 0x3d13c
movq (%rdx), %rsi
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x887c
movq %rbx, %rdi
movl $0x8, %esi
callq 0xcf0f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d0da
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x18(%rbx,%rax) # imm = 0xFFFFEFFF
leaq 0x28(%rsp), %r14
movq %rbx, (%r14)
movb $0x1, 0x9(%r14)
movq %r14, %rdi
callq 0x3d9a8
movq (%r14), %rax
movq %rax, 0x8(%rsp)
movb 0x8(%r14), %al
movb %al, 0x10(%rsp)
movb 0x9(%r14), %al
movb %al, 0x11(%rsp)
xorl %ebx, %ebx
testb %al, %al
je 0x3d13c
leaq 0x8(%rsp), %r14
xorl %eax, %eax
cmpb $0xa, 0x10(%rsp)
sete %al
addl %eax, %ebx
movq %r14, %rdi
callq 0x3d9a8
cmpb $0x0, 0x11(%rsp)
jne 0x3d121
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d164
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
movq %rbx, %rdi
callq 0x7740
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
ucomisd 0x1249(%rip), %xmm0     # 0x41470
xorpd %xmm3, %xmm3
jae 0x403d0
movapd %xmm0, %xmm2
movl %edi, %ebx
cvtsi2sd %edi, %xmm1
movapd %xmm1, %xmm4
mulsd %xmm0, %xmm4
mulsd %xmm0, %xmm4
ucomisd 0x6311(%rip), %xmm4     # 0x46560
jae 0x403d0
movsd 0x121b(%rip), %xmm0     # 0x41478
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
movsd 0x1203(%rip), %xmm3     # 0x41470
jae 0x403d0
movsd 0x62ed(%rip), %xmm0     # 0x46568
ucomisd %xmm4, %xmm0
jae 0x403d0
cmpl $0x1, %ebx
jne 0x402a3
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
movsd 0x61f6(%rip), %xmm3     # 0x46490
subsd %xmm0, %xmm3
jmp 0x4037a
movsd 0x11c5(%rip), %xmm0     # 0x41470
movapd %xmm0, %xmm3
divsd %xmm1, %xmm3
ucomisd %xmm2, %xmm3
jae 0x402f9
movapd %xmm0, %xmm5
subsd %xmm3, %xmm5
ucomisd %xmm5, %xmm2
jb 0x40384
subsd %xmm2, %xmm0
movsd %xmm2, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
callq 0x7730
movsd 0x8(%rsp), %xmm4
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
jmp 0x4037a
movsd %xmm4, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
addsd %xmm2, %xmm2
subsd %xmm3, %xmm2
cmpl $0x14, %ebx
jg 0x4032d
movslq %ebx, %r14
leaq 0x62f4(%rip), %r15      # 0x46610
movapd %xmm2, %xmm0
callq 0x7730
mulsd (%r15,%r14,8), %xmm0
jmp 0x40362
movl %ebx, %edi
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x18(%rsp)
callq 0x407bc
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x7360
mulsd 0x28(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
callq 0x7750
movsd 0x1106(%rip), %xmm3     # 0x41470
subsd %xmm0, %xmm3
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm4
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jae 0x403d0
cmpl $0x8c, %ebx
jg 0x403af
movsd 0x61a4(%rip), %xmm0     # 0x46538
ucomisd %xmm4, %xmm0
ja 0x403b9
movl %ebx, %edi
movapd %xmm2, %xmm0
callq 0x403de
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
jmp 0x403d0
ucomisd 0x61b9(%rip), %xmm4     # 0x46570
jae 0x4039a
movl %ebx, %edi
movapd %xmm2, %xmm0
callq 0x3e8f0
movsd 0x10a4(%rip), %xmm3     # 0x41470
subsd %xmm0, %xmm3
movapd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x1e, %edi
jg 0x407d1
movslq %edi, %rax
leaq 0x5ef5(%rip), %rcx      # 0x466c0
movsd (%rcx,%rax,8), %xmm0
retq
subq $0x18, %rsp
incl %edi
cvtsi2sd %edi, %xmm2
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
movsd 0xc85(%rip), %xmm1      # 0x41470
divsd %xmm0, %xmm1
movsd 0x5d91(%rip), %xmm0     # 0x46588
mulsd %xmm1, %xmm0
addsd 0x5d8d(%rip), %xmm0     # 0x46590
mulsd %xmm1, %xmm0
addsd 0x5d89(%rip), %xmm0     # 0x46598
mulsd %xmm1, %xmm0
addsd 0x5d85(%rip), %xmm0     # 0x465a0
movsd %xmm0, 0x10(%rsp)
movsd 0x5d7f(%rip), %xmm1     # 0x465a8
movapd %xmm2, %xmm0
movsd %xmm2, (%rsp)
addsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x7360
mulsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm2
subsd %xmm2, %xmm0
addsd 0x5d58(%rip), %xmm0     # 0x465b0
movsd 0x10(%rsp), %xmm1
divsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r14d
movl %edi, %r15d
leaq (,%r15,8), %rdi
callq 0x7570
movq %rax, %rbx
movl %ebp, %eax
imull %r14d, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x7570
movq %rax, (%rbx)
cmpl $0x2, %r14d
jl 0x408c8
movslq %ebp, %rcx
leaq (%rax,%rcx,8), %rax
shlq $0x3, %rcx
movl $0x1, %edx
movq %rax, (%rbx,%rdx,8)
incq %rdx
addq %rcx, %rax
cmpq %rdx, %r15
jne 0x408b9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/interface.cc
// Function: Interface::cmdExtract(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Interface::cmdExtract(int& step, std::string& cmd){
    step = 1;
    int lastDiIndex = -1;
    for(unsigned i = 0; i < cmd.size(); i++){
        if(cmd.at(i) >= '0' && cmd.at(i) <= '9'){
            lastDiIndex = i;
        }
        else {
            break;
        }
    }
    if(lastDiIndex >= 0){
        step = std::stoi(cmd);
        cmd = cmd.substr(lastDiIndex + 1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x1, (%rsi)
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x6b2f
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rcx
movb (%rcx), %dl
addb $-0x30, %dl
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpb $0x9, %dl
ja 0x6a90
xorl %edx, %edx
movl %edx, %r15d
leal 0x1(%r15), %edx
cmpq %rdx, %rax
jbe 0x6a90
movb (%rcx,%rdx), %sil
addb $-0x30, %sil
cmpb $0xa, %sil
jb 0x6a76
testl %r15d, %r15d
js 0x6b2f
movq (%rbx), %r13
callq 0x5050
movq %rax, %r12
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl $0x0, (%r12)
leaq 0x8(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x53d0
cmpq %r13, (%rbp)
je 0x6b3e
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x6b4a
movl (%r12), %ecx
cmpl $0x22, %ecx
je 0x6b4a
testl %ecx, %ecx
jne 0x6aea
movl 0x4(%rsp), %ecx
movl %ecx, (%r12)
movl %eax, (%r14)
incl %r15d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x52f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5350
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6b2f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc572(%rip), %rdi      # 0x130b7
callq 0x51e0
leaq 0xc566(%rip), %rdi      # 0x130b7
callq 0x53f0
cmpl $0x0, (%r12)
jne 0x6b65
movl 0x4(%rsp), %ecx
movl %ecx, (%r12)
movq %rax, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/blinddecorator.cc
// Function: BlindDecorator::display()
std::vector<std::vector<char>> BlindDecorator::display() {
	std::vector<std::vector<char>> a = board->display();
	for (int i = 6; i < 16; ++i) {
		for (int j = 0; j < 11; ++j) {
			a[i][j] = '?';
		}		
	}
	for (int i = 0; i < 18; ++i) {
		for (int j = 2; j < 9; ++j) {
			a[i][j] = '?';
		}
	}
	return a;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rsi), %rsi
movq (%rsi), %rax
callq *0x50(%rax)
movl $0x6, %eax
leaq (%rax,%rax,2), %rcx
xorl %edx, %edx
movq (%rbx), %rsi
movq (%rsi,%rcx,8), %rsi
movb $0x3f, (%rsi,%rdx)
incq %rdx
cmpq $0xb, %rdx
jne 0x7945
incq %rax
cmpq $0x10, %rax
jne 0x793f
xorl %eax, %eax
leaq (%rax,%rax,2), %rcx
xorl %edx, %edx
movq (%rbx), %rsi
movq (%rsi,%rcx,8), %rsi
movb $0x3f, 0x2(%rsi,%rdx)
incq %rdx
cmpq $0x7, %rdx
jne 0x796a
incq %rax
cmpq $0x12, %rax
jne 0x7964
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MatthewZMD[P]TetrisDual/block.cc
// Function: Block::recaliBtmLft()
void Block::recaliBtmLft(){
    Coordinate newBtmLft = Coordinate{0, 200};
    Coordinate cellPos;
    for(unsigned i = 0; i < cells.size(); ++i) {
        cellPos = cells.at(i)->pos;
        if(cellPos.col < newBtmLft.col) newBtmLft.col = cellPos.col;
        if(cellPos.row > newBtmLft.row) newBtmLft.row = cellPos.row;
    }
    btmLft = newBtmLft;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x7b11
sarq $0x3, %rcx
xorl %r8d, %r8d
movl $0xc8, %edx
xorl %esi, %esi
movq (%rax,%r8,8), %r9
movl 0x5c(%r9), %r10d
cmpl %edx, %r10d
cmovll %r10d, %edx
movl 0x58(%r9), %r9d
cmpl %esi, %r9d
cmovgl %r9d, %esi
incq %r8
movl %r8d, %r9d
cmpq %r9, %rcx
ja 0x7aea
jmp 0x7b18
xorl %esi, %esi
movl $0xc8, %edx
movl %esi, 0x18(%rdi)
movl %edx, 0x1c(%rdi)
retq
nop