LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Ifc.cpp
// Function: Ifc::PrintIfc(int)
void Ifc::PrintIfc(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "if ";
  cond->PrintCond();
  cout << " then" << endl;
  stmtSeq1->PrintStmtSeq(level + 1);
  for (int i = 0; i < level; i++){
    cout << "\t";
  }

  if (stmtSeq2 == NULL){
    cout << "end;" << endl;
  }
  else {
    cout << "else" << endl;
    stmtSeq2->PrintStmtSeq(level + 1);
    for (int i = 0; i < level; i++){
      cout << "\t";
    }
    
    cout << "end;" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
testl %esi, %esi
jle 0x6bd9
movq 0x541e(%rip), %r14      # 0xbfd8
leaq 0x182d(%rip), %r12      # 0x83ee
movl %ebx, %r13d
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r13d
jne 0x6bc4
movq 0x53f8(%rip), %r14      # 0xbfd8
leaq 0x1d1e(%rip), %rsi      # 0x8905
movl $0x3, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r15), %rdi
callq 0x7180
leaq 0x1d06(%rip), %rsi      # 0x8909
movl $0x5, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r15, %r14
movq 0x8(%r15), %rdi
leal 0x1(%rbx), %esi
movl %esi, -0x2c(%rbp)
callq 0x4c50
testl %ebx, %ebx
jle 0x6c73
movq 0x5384(%rip), %r13      # 0xbfd8
leaq 0x1793(%rip), %r12      # 0x83ee
movl %ebx, %r15d
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r15d
jne 0x6c5e
movq %r14, %r15
cmpq $0x0, 0x10(%r14)
movq 0x5356(%rip), %r14      # 0xbfd8
je 0x6cf1
leaq 0x17a5(%rip), %rsi      # 0x8430
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x10(%r15), %rdi
movl -0x2c(%rbp), %esi
callq 0x4c50
testl %ebx, %ebx
jle 0x6cf1
movq 0x5302(%rip), %r15      # 0xbfd8
leaq 0x1711(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %ebx
jne 0x6cdd
leaq 0x1a71(%rip), %rsi      # 0x8769
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Ifc.cpp
// Function: Ifc::ExecIfc()
void Ifc::ExecIfc(){
  if (cond->EvalCond()){
    stmtSeq1->ExecStmtSeq();
  }
  else{
    if(stmtSeq2 != NULL){
      stmtSeq2->ExecStmtSeq();
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x72a6
testb %al, %al
je 0x6d55
movq 0x8(%rbx), %rdi
jmp 0x6d5e
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x6d69
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c74
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Cond.cpp
// Function: Cond::PrintCond()
void Cond::PrintCond(){
  if (alterId == 1){
    comp->PrintComp();
  }
  else if (alterId == 2){
    cout << "!";
    cond1->PrintCond();
  }
  else if (alterId == 3){
    cout << "[ ";
    cond1->PrintCond();
    cout << " && ";
    cond2->PrintCond();
    cout << " ]";
  }
  else if (alterId == 4){
    cout << "[ ";
    cond1->PrintCond();
    cout << " || ";
    cond2->PrintCond();
    cout << " ]";
  }
  else {
    cout << "PrintError: alterId is not right." << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4e44(%rip), %r14      # 0xbfd8
leaq 0xf28(%rip), %r15       # 0x80c3
movl 0x18(%rbx), %eax
cmpl $0x2, %eax
jne 0x71b9
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movq 0x8(%rbx), %rbx
jmp 0x719b
cmpl $0x4, %eax
je 0x720b
cmpl $0x3, %eax
je 0x71de
cmpl $0x1, %eax
jne 0x726a
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x76f0
movq 0x4df3(%rip), %r14      # 0xbfd8
leaq 0x179b(%rip), %rsi      # 0x8987
movl $0x2, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x7180
leaq 0x1781(%rip), %rsi      # 0x898a
jmp 0x7236
movq 0x4dc6(%rip), %r14      # 0xbfd8
leaq 0x176e(%rip), %rsi      # 0x8987
movl $0x2, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x7180
leaq 0x175c(%rip), %rsi      # 0x8992
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x10(%rbx), %rdi
callq 0x7180
leaq 0x173c(%rip), %rsi      # 0x898f
movl $0x2, %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
movq 0x4d67(%rip), %rbx      # 0xbfd8
leaq 0x171f(%rip), %rsi      # 0x8997
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0xe8b(%rip), %rsi       # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Cond.cpp
// Function: Cond::EvalCond()
bool Cond::EvalCond(){
  if (alterId == 1){
    if (comp->EvalComp())  
      return true;
    else
      return false;
  }
  else if (alterId == 2){
    if (cond1->EvalCond()) return false;
    else return true;
  }
  else if (alterId == 3){
    if (cond1->EvalCond() && cond2->EvalCond()) 
      return true;
    else 
      return false;
  }
  else if (alterId == 4){
    if (cond1->EvalCond() || cond2->EvalCond())
      return true;
    else
      return false;
  } 
  else {
    cout << "EvalCond Error: alterId is not right!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
movl 0x18(%r14), %eax
cmpl $0x4, %eax
jne 0x72ce
movq 0x8(%r14), %rdi
callq 0x72a6
testb %al, %al
jne 0x7312
movq 0x10(%r14), %r14
jmp 0x72b2
cmpl $0x3, %eax
je 0x72f0
cmpl $0x2, %eax
jne 0x72e1
movq 0x8(%r14), %r14
xorb $0x1, %bl
jmp 0x72b2
cmpl $0x1, %eax
jne 0x7320
movq (%r14), %rdi
callq 0x7808
jmp 0x7314
movq 0x8(%r14), %rdi
callq 0x72a6
testb %al, %al
je 0x730e
movq 0x10(%r14), %rdi
callq 0x72a6
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x7314
xorl %eax, %eax
jmp 0x7314
movb $0x1, %al
xorb %al, %bl
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x4cb1(%rip), %rbx      # 0xbfd8
leaq 0x168b(%rip), %rsi      # 0x89b9
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0xdd5(%rip), %rsi       # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Comp.cpp
// Function: Comp::PrintComp()
void Comp::PrintComp(){
  cout << "( ";
  op1->PrintOp();
  if (alterId == 1)
    cout << " != ";
  else if (alterId == 2)
    cout << " == ";
  else if (alterId == 3)
    cout << " < ";
  else if (alterId == 4)
    cout << " > ";
  else if (alterId == 5)
    cout << " <= ";
  else if (alterId == 6)
    cout << " >= ";
  else {
    cout << "Error: PrintComp: alterId is not right!" << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
  op2->PrintOp();
  cout << " )";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48d8(%rip), %rdi      # 0xbfd8
leaq 0xf9d(%rip), %rsi       # 0x86a4
movl $0x2, %edx
callq 0x21d0
movq (%rbx), %rdi
callq 0x5efc
movl 0x10(%rbx), %eax
decl %eax
cmpl $0x5, %eax
ja 0x77cb
leaq 0x1302(%rip), %rcx      # 0x8a30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x489a(%rip), %rdi      # 0xbfd8
leaq 0x131b(%rip), %rsi      # 0x8a60
jmp 0x779a
movq 0x488a(%rip), %rdi      # 0xbfd8
leaq 0x131d(%rip), %rsi      # 0x8a72
jmp 0x779a
movq 0x487a(%rip), %rdi      # 0xbfd8
leaq 0x1305(%rip), %rsi      # 0x8a6a
jmp 0x7775
movq 0x486a(%rip), %rdi      # 0xbfd8
leaq 0x12f9(%rip), %rsi      # 0x8a6e
movl $0x3, %edx
jmp 0x779f
movq 0x4855(%rip), %rdi      # 0xbfd8
leaq 0x12db(%rip), %rsi      # 0x8a65
jmp 0x779a
movq 0x4845(%rip), %rdi      # 0xbfd8
leaq 0x12dd(%rip), %rsi      # 0x8a77
movl $0x4, %edx
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x5efc
movq 0x4824(%rip), %rdi      # 0xbfd8
leaq 0xeec(%rip), %rsi       # 0x86a7
movl $0x2, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
movq 0x4806(%rip), %rbx      # 0xbfd8
leaq 0x12a3(%rip), %rsi      # 0x8a7c
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x9a6(%rip), %rsi       # 0x8196
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Comp.cpp
// Function: Comp::EvalComp()
bool Comp::EvalComp(){
  switch(alterId) {
  case 1:
    if (op1->EvalOp() != op2->EvalOp())
      return true;
    else 
      return false;
  case 2:
    if (op1->EvalOp() == op2->EvalOp())
      return true;
    else 
      return false;
  case 3:
    if (op1->EvalOp() < op2->EvalOp())
      return true;
    else 
      return false;
  case 4:
    if (op1->EvalOp() > op2->EvalOp())
      return true;
    else
      return false;
  case 5:
    if (op1->EvalOp() <= op2->EvalOp())
      return true;
    else 
      return false;
  case 6:
    if (op1->EvalOp() >= op2->EvalOp())
      return true;
    else
      return false;
  default:
    cout << "Error: EvalComp: wrong alterId." << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x10(%rdi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x78de
movq %rdi, %rbx
leaq 0x1221(%rip), %rcx      # 0x8a48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x5faa
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5faa
cmpl %eax, %r14d
setne %al
jmp 0x78d9
movq (%rbx), %rdi
callq 0x5faa
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5faa
cmpl %eax, %r14d
setle %al
jmp 0x78d9
movq (%rbx), %rdi
callq 0x5faa
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5faa
cmpl %eax, %r14d
setl %al
jmp 0x78d9
movq (%rbx), %rdi
callq 0x5faa
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5faa
cmpl %eax, %r14d
setg %al
jmp 0x78d9
movq (%rbx), %rdi
callq 0x5faa
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5faa
cmpl %eax, %r14d
sete %al
jmp 0x78d9
movq (%rbx), %rdi
callq 0x5faa
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5faa
cmpl %eax, %r14d
setge %al
popq %rbx
popq %r14
popq %rbp
retq
movq 0x46f3(%rip), %rbx      # 0xbfd8
leaq 0x11b8(%rip), %rsi      # 0x8aa4
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x817(%rip), %rsi       # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: sgio(int, unsigned char*, int, unsigned char*, int)
bool sgio(int fd, unsigned char* cmdp, int cmd_len, unsigned char* dxferp, int dxfer_len) {

  sg_io_hdr_t sgio_hdr;
  unsigned char sense[32];

  memset(&sgio_hdr, 0, sizeof(sg_io_hdr_t));
  sgio_hdr.interface_id = 'S';
  sgio_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
  sgio_hdr.cmd_len = cmd_len;
  sgio_hdr.mx_sb_len = 32;
  sgio_hdr.dxfer_len = dxfer_len;
  sgio_hdr.dxferp = dxferp;
  sgio_hdr.cmdp = cmdp;
  sgio_hdr.sbp = sense;

  if(ioctl(fd, SG_IO, &sgio_hdr) < 0) {
    cerr << "UNKNOWN: SG_IO ioctl error" << endl;
    exit(NAGIOS_UNKNOWN);
  }

  return !sgio_hdr.status;

}

// Assembly:
subq $0x78, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq $0x0, 0x50(%rax)
movabsq $-0x2ffffffad, %r9      # imm = 0xFFFFFFFD00000053
movq %r9, (%rax)
movb %dl, 0x8(%rax)
movb $0x20, 0x9(%rax)
movl %r8d, 0xc(%rax)
movq %rcx, 0x10(%rax)
movq %rsi, 0x18(%rax)
movq %rsp, %rcx
movq %rcx, 0x20(%rax)
movl $0x2285, %esi           # imm = 0x2285
movq %rax, %rdx
xorl %eax, %eax
callq 0x4200
testl %eax, %eax
js 0x4918
cmpb $0x0, 0x60(%rsp)
sete %al
addq $0x78, %rsp
retq
movq 0x46c9(%rip), %rdi      # 0x8fe8
leaq 0x18c1(%rip), %rsi      # 0x61e7
callq 0x4180
movq %rax, %rdi
callq 0x40b0
movl $0x3, %edi
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O1/spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: ata_identify(int, unsigned char*)
bool ata_identify(int fd, unsigned char* buf) {

  sbc_ata_pass_through ata_pass_through;
  memset(reinterpret_cast<unsigned char*>(&ata_pass_through), 0, sizeof(sbc_ata_pass_through));

  ata_pass_through.operation_code = SBC_ATA_PASS_THROUGH;
  ata_pass_through.protocol       = ATA_PROTOCOL_PIO_DATA_IN;
  ata_pass_through.t_dir          = ATA_TRANSFER_DIRECTION_FROM_DEVICE;
  ata_pass_through.byte_block     = ATA_TRANSFER_SIZE_BLOCK;
  ata_pass_through.t_type         = ATA_TRANSFER_TYPE_SECTOR;
  ata_pass_through.t_length       = ATA_TRANSFER_LENGTH_COUNT;
  ata_pass_through.count_7_0      = 1;
  ata_pass_through.command        = ATA_IDENTIFY_DEVICE;

  return sgio(fd, reinterpret_cast<unsigned char*>(&ata_pass_through), sizeof(ata_pass_through), buf, SECTOR_SIZE);

}

// Assembly:
subq $0x18, %rsp
movq %rsi, %rcx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movb $-0x7b, (%rsi)
movzwl 0x1(%rsi), %eax
andl $0xffffe0e1, %eax       # imm = 0xFFFFE0E1
orl $0xe08, %eax            # imm = 0xE08
movw %ax, 0x1(%rsi)
movb $0x1, 0x6(%rsi)
movb $-0x14, 0xe(%rsi)
movl $0x10, %edx
movl $0x200, %r8d            # imm = 0x200
callq 0x48aa
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: ata_smart_read_data(int, unsigned char*)
bool ata_smart_read_data(int fd, unsigned char* buf) {

  sbc_ata_pass_through ata_pass_through;
  memset(reinterpret_cast<unsigned char*>(&ata_pass_through), 0, sizeof(sbc_ata_pass_through));

  ata_pass_through.operation_code = SBC_ATA_PASS_THROUGH;
  ata_pass_through.protocol       = ATA_PROTOCOL_PIO_DATA_IN;
  ata_pass_through.t_dir          = ATA_TRANSFER_DIRECTION_FROM_DEVICE;
  ata_pass_through.byte_block     = ATA_TRANSFER_SIZE_BLOCK;
  ata_pass_through.t_type         = ATA_TRANSFER_TYPE_SECTOR;
  ata_pass_through.t_length       = ATA_TRANSFER_LENGTH_COUNT;
  ata_pass_through.count_7_0      = 1;
  ata_pass_through.command        = ATA_SMART;
  ata_pass_through.features_7_0   = SMART_READ_DATA;
  ata_pass_through.lba_23_16      = 0xc2;
  ata_pass_through.lba_15_8       = 0x4f;

  return sgio(fd, reinterpret_cast<unsigned char*>(&ata_pass_through), sizeof(ata_pass_through), buf, SECTOR_SIZE);

}

// Assembly:
subq $0x18, %rsp
movq %rsi, %rcx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movb $-0x7b, (%rsi)
movzwl 0x1(%rsi), %eax
andl $0xffffe0e1, %eax       # imm = 0xFFFFE0E1
orl $0xe08, %eax            # imm = 0xE08
movw %ax, 0x1(%rsi)
movb $0x1, 0x6(%rsi)
movb $-0x50, 0xe(%rsi)
movb $-0x30, 0x4(%rsi)
movb $-0x3e, 0xc(%rsi)
movb $0x4f, 0xa(%rsi)
movl $0x10, %edx
movl $0x200, %r8d            # imm = 0x200
callq 0x48aa
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: ata_smart_read_log(int, unsigned char*, int, unsigned short)
bool ata_smart_read_log(int fd, unsigned char* buf, int log, uint16_t sectors) {

  sbc_ata_pass_through ata_pass_through;
  memset(reinterpret_cast<unsigned char*>(&ata_pass_through), 0, sizeof(sbc_ata_pass_through));

  ata_pass_through.operation_code = SBC_ATA_PASS_THROUGH;
  ata_pass_through.protocol       = ATA_PROTOCOL_PIO_DATA_IN;
  ata_pass_through.t_dir          = ATA_TRANSFER_DIRECTION_FROM_DEVICE;
  ata_pass_through.byte_block     = ATA_TRANSFER_SIZE_BLOCK;
  ata_pass_through.t_type         = ATA_TRANSFER_TYPE_SECTOR;
  ata_pass_through.t_length       = ATA_TRANSFER_LENGTH_COUNT;
  ata_pass_through.count_15_8     = sectors >> 8;
  ata_pass_through.count_7_0      = sectors;
  ata_pass_through.command        = ATA_SMART;
  ata_pass_through.features_7_0   = SMART_READ_LOG;
  ata_pass_through.lba_23_16      = 0xc2;
  ata_pass_through.lba_15_8       = 0x4f;
  ata_pass_through.lba_7_0        = log;

  return sgio(fd, reinterpret_cast<unsigned char*>(&ata_pass_through), sizeof(ata_pass_through), buf, sectors * SECTOR_SIZE);

}

// Assembly:
subq $0x18, %rsp
movl %ecx, %eax
movq %rsi, %rcx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movb $-0x7b, (%rsi)
movzwl 0x1(%rsi), %r8d
andl $0xffffe0e1, %r8d       # imm = 0xFFFFE0E1
orl $0xe08, %r8d            # imm = 0xE08
movw %r8w, 0x1(%rsi)
movb %ah, 0x5(%rsp)
movb %al, 0x6(%rsi)
movb $-0x50, 0xe(%rsi)
movb $-0x2b, 0x4(%rsi)
movb $-0x3e, 0xc(%rsi)
movb $0x4f, 0xa(%rsi)
movb %dl, 0x8(%rsi)
shll $0x9, %eax
movl $0x10, %edx
movl %eax, %r8d
callq 0x48aa
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: check_smart_log(int, int&, int&)
void check_smart_log(int fd, int& code, int& logs) {

  // Read the SMART log directory
  smart_log_directory log_directory;
  ata_smart_read_log_directory(fd, reinterpret_cast<unsigned char*>(&log_directory));

  // Calculate the number of SMART log sectors to read and allocate a buffer
  uint16_t smart_log_sectors = StorageEndian::swap(log_directory.data_blocks[ATA_LOG_ADDRESS_SMART]);
  if(!smart_log_sectors)
    return;

  smart_log_summary* summaries = new smart_log_summary[smart_log_sectors];

  // Read the logs in
  ata_smart_read_log(fd, reinterpret_cast<unsigned char*>(summaries), ATA_LOG_ADDRESS_SMART, smart_log_sectors);

  // Check for any logged errors
  for(int i=0; i<smart_log_sectors; i++) {

    // If the index is zero there are no entries
    if(!StorageEndian::swap(summaries[i].index))
      continue;

    logs += StorageEndian::swap(summaries[i].count);

  }

  if(logs)
    code = max(code, NAGIOS_WARNING);

  delete [] summaries;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x4a1b
movzwl 0x2(%r15), %r13d
testq %r13, %r13
je 0x4d21
movl %r13d, %r12d
shll $0x9, %r12d
movq %r12, %rdi
callq 0x4030
movq %rax, %r15
movl %ebp, %edi
movq %rax, %rsi
movl $0x1, %edx
movl %r13d, %ecx
callq 0x4a1b
movl (%r14), %eax
xorl %ecx, %ecx
cmpb $0x0, 0x1(%r15,%rcx)
je 0x4cf8
movzwl 0x1c4(%r15,%rcx), %edx
addl %edx, %eax
movl %eax, (%r14)
addq $0x200, %rcx            # imm = 0x200
cmpq %rcx, %r12
jne 0x4ce2
cmpl $0x0, (%r14)
je 0x4d19
movl (%rbx), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl %ecx, (%rbx)
movq %r15, %rdi
callq 0x41e0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/spjmurray[P]nagios-plugin-check-scsi-smart/smart.cc
// Function: SmartAttribute::SmartAttribute(smart_attribute const&)
SmartAttribute::SmartAttribute(const smart_attribute& attribute)
: id(StorageEndian::swap(attribute.id)),
  pre_fail(StorageEndian::swap(attribute.flags) & 0x1),
  offline(StorageEndian::swap(attribute.flags) & 0x2),
  value(StorageEndian::swap(attribute.value)),
  raw((static_cast<uint64_t>(StorageEndian::swap(attribute.raw_hi)) << 32) |
       static_cast<uint64_t>(StorageEndian::swap(attribute.raw_lo))) {

  // Logic shamelessly lifted from smartmontools
  switch(id) {
    case 3:   // Spin up time
    case 5:   // Reallocated sector count
    case 196: // Reallocated event count
      raw &= 0xffff;
      break;
    case 9:   // Power on hours
    case 240: // Head flying hours
      raw &= 0xffffff;
      break;
    case 190: // Temperature
    case 194: // Temperature
      raw &= 0xff;
      break;
    default:
      break;
  }

}

// Assembly:
movzbl (%rsi), %ecx
movb %cl, (%rdi)
movb 0x1(%rsi), %al
movl %eax, %edx
andb $0x1, %dl
movb %dl, 0x1(%rdi)
shrb %al
andb $0x1, %al
movb %al, 0x2(%rdi)
movb 0x3(%rsi), %al
movb %al, 0x3(%rdi)
movzwl 0x9(%rsi), %edx
shlq $0x20, %rdx
movl 0x5(%rsi), %eax
orq %rax, %rdx
movq %rdx, 0x8(%rdi)
movl $0xffff, %edx           # imm = 0xFFFF
cmpl $0xbd, %ecx
jle 0x5e17
cmpl $0xc3, %ecx
jg 0x5e27
cmpl $0xbe, %ecx
je 0x5e10
cmpl $0xc2, %ecx
jne 0x5e26
movl $0xff, %edx
jmp 0x5e3c
cmpl $0x3, %ecx
je 0x5e3c
cmpl $0x5, %ecx
je 0x5e3c
cmpl $0x9, %ecx
je 0x5e37
retq
cmpl $0xc4, %ecx
je 0x5e3c
cmpl $0xf0, %ecx
jne 0x5e26
movl $0xffffff, %edx         # imm = 0xFFFFFF
andl %eax, %edx
movq %rdx, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/willprice[P]parallel-cpp-workshop/include/filecounter.h
// Function: filecounter::count_lines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int count_lines(const std::string &filename)
{
    std::ifstream file( filename );

    int nlines = 0;

    std::string str;
    while (std::getline(file, str))
    {
        nlines += 1;
    }

    return nlines;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x1140
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
xorl %ebx, %ebx
movq %rsp, %r15
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1180
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1382
incl %ebx
jmp 0x134c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1398
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1100
leaq 0x20(%rsp), %rdi
callq 0x1040
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1100
leaq 0x20(%rsp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/willprice[P]parallel-cpp-workshop/include/filecounter.h
// Function: filecounter::get_arguments[abi:cxx11](int, char**)
std::vector<std::string> get_arguments(int argc, char **argv)
{
    if (argc < 2)
    {
        return std::vector<std::string>();
    }

    auto args = std::vector<std::string>(argc-1);

    for (int i=1; i<argc; ++i)
    {
        args[i-1] = argv[i];
    }

    return args;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
cmpl $0x1, %esi
jg 0x1407
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
jmp 0x1473
movq %rdx, %r14
movl %esi, %r15d
leal -0x1(%r15), %esi
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x17e6
movl %r15d, %eax
addq $0x8, %r14
shlq $0x5, %rax
addq $-0x20, %rax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
movq (%r14), %r15
movq %r12, %rbp
movq (%r12), %r12
movq 0x8(%r12,%rbx), %r13
addq %rbx, %r12
movq %r15, %rdi
callq 0x1060
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x1130
addq $0x8, %r14
addq $0x20, %rbx
cmpq %rbx, 0x10(%rsp)
movq %rbp, %r12
jne 0x1434
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbp, %rdi
callq 0x1870
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/willprice[P]parallel-cpp-workshop/countlines.cpp
// Function: main
int main(int argc, char** argv) {
    auto file_paths = get_arguments(argc, argv);
    auto line_counts = map(count_lines, file_paths);
    auto total_line_count = reduce([](int a, int b) { return a + b; }, line_counts);
    std::cout << "Total line count: " << total_line_count << std::endl;
    for (int i = 0; i < file_paths.size(); i++) {
        std::cout << file_paths[i] << ": " << line_counts[i] << std::endl;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x13de
leaq -0x349(%rip), %rsi      # 0x130c
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x1954
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x168f
movl (%rax), %ebx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq $0x2, %rcx
jb 0x1691
movl $0x1, %edx
addl (%rax,%rdx,4), %ebx
incq %rdx
cmpq %rdx, %rcx
jne 0x1682
jmp 0x1691
xorl %ebx, %ebx
movq 0x2940(%rip), %rdi      # 0x3fd8
leaq 0x9a1(%rip), %rsi       # 0x2040
movl $0x12, %edx
callq 0x1110
movq 0x2928(%rip), %rdi      # 0x3fd8
movl %ebx, %esi
callq 0x1150
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq 0x18(%rsp), %rax
cmpq %rax, 0x20(%rsp)
je 0x1783
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x28d7(%rip), %rbx      # 0x3fd8
leaq 0x948(%rip), %r14       # 0x2050
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x1110
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1110
movq (%rsp), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x1150
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
incq %r13
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r12
cmpq %r13, %rcx
ja 0x1708
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1799
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
leaq 0x18(%rsp), %rdi
callq 0x1870
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x17d3
jmp 0x17ba
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x17d3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
leaq 0x18(%rsp), %rdi
callq 0x1870
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O1/willprice[P]parallel-cpp-workshop/include/part1.h
// Function: auto part1::map<int (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int (*)(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&)
auto map(FUNC func, const std::vector<ARGS>&... args)
{
    typedef typename std::result_of<FUNC(ARGS...)>::type RETURN_TYPE;

    int nvals=detail::get_min_container_size(args...);

    std::vector<RETURN_TYPE> result(nvals);

    for (size_t i=0; i<nvals; ++i)
    {
        result[i] = func(args[i]...);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
movq %rax, %r13
shlq $0x1b, %r13
shrq $0x5, %rax
movslq %eax, %r12
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r12, %rsi
callq 0x1a06
testq %r13, %r13
je 0x19c1
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14), %rdi
addq %r13, %rdi
callq *%r15
movq 0x10(%rsp), %rcx
movl %eax, (%rcx,%rbp,4)
incq %rbp
addq $0x20, %r13
cmpq %rbp, %r12
jne 0x19a4
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19fe
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/src/test-case/unit.cpp
// Function: testMetricMultipliers(std::ostream&)
bool testMetricMultipliers(std::ostream &log) {
  if (metricMultiplier<fraction, 1, 1>::get() != fraction(10)) {
    log << "metric multiplier <1,1> is "
        << metricMultiplier<fraction, 1, 1>::get()
        << " but should have been 10/1\n";
    return false;
  }

  if (metricMultiplier<fraction, 1, 2>::get() != fraction(100)) {
    log << "metric multiplier <1,2> is "
        << metricMultiplier<fraction, 1, 2>::get()
        << " but should have been 100/1\n";
    return false;
  }

  if (metricMultiplier<fraction, 0, 2>::get() != fraction(1)) {
    log << "metric multiplier <0,2> is "
        << metricMultiplier<fraction, 0, 2>::get()
        << " but should have been 1/1\n";
    return false;
  }

  if (metricMultiplier<fraction, 3, 2>::get() != fraction(1000000)) {
    log << "metric multiplier <3,2> is "
        << metricMultiplier<fraction, 3, 2>::get()
        << " but should have been 1000000/1\n";
    return false;
  }

  if (metricMultiplier<fraction, 3, 3>::get() != fraction(1000000000)) {
    log << "metric multiplier <3,3> is "
        << metricMultiplier<fraction, 3, 3>::get()
        << " but should have been 1000000000/1\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x64, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13d6c
cmpq $0x64, (%r14)
jne 0x4f64
cmpq $0x1, 0x10(%rsp)
jne 0x4f64
leaq 0x8(%rsp), %rdi
movq $0xa, (%rdi)
movq $0x1, 0x8(%rdi)
callq 0x13d32
xorq $0xf4240, %rax          # imm = 0xF4240
xorq $0x1, %rdx
orq %rax, %rdx
jne 0x4fb7
leaq 0x8(%rsp), %rdi
movq $0xa, (%rdi)
movq $0x1, 0x8(%rdi)
callq 0x13dec
movq %rax, %rcx
xorq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
xorq $0x1, %rdx
movb $0x1, %al
orq %rcx, %rdx
je 0x5011
leaq 0x104e5(%rip), %rsi     # 0x153fb
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x42b0
leaq 0x8(%rsp), %r14
movq $0xa, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13dec
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x57ac
leaq 0x104bd(%rip), %rsi     # 0x15417
movl $0x23, %edx
jmp 0x5007
leaq 0x1041a(%rip), %rsi     # 0x15385
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x42b0
leaq 0x8(%rsp), %r14
movq $0x64, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13d6c
movups (%r14), %xmm0
movups %xmm0, (%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x57ac
leaq 0x103f1(%rip), %rsi     # 0x153a1
movl $0x1c, %edx
jmp 0x5007
leaq 0x10400(%rip), %rsi     # 0x153be
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x42b0
leaq 0x8(%rsp), %r14
movq $0xa, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13d32
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x57ac
leaq 0x103d8(%rip), %rsi     # 0x153da
movl $0x20, %edx
movq %rax, %rdi
callq 0x42b0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/src/test-case/unit.cpp
// Function: testUnitEMetric(std::ostream&)
bool testUnitEMetric(std::ostream &log) {
  second<fraction, 2>::unit s2_5_7(fraction(5, 7));

  if (fraction(5, 7) != fraction(s2_5_7)) {
    log << "variable was not initialised to the expected value\n";
    return false;
  }

  second<fraction, 2>::milli ms2_5_7 = s2_5_7;

  if (fraction(5000000, 7) != ms2_5_7) {
    log << "variable was not converted to the expected value\n";
    return false;
  }

  second<fraction, -2>::unit si2_5_7(fraction(5, 7));

  if (fraction(5, 7) != fraction(si2_5_7)) {
    log << "variable was not initialised to the expected value\n";
    return false;
  }

  second<fraction, -2>::milli msi2_5_7 = si2_5_7;

  if (fraction(5, 7000000) != msi2_5_7) {
    log << "variable was not converted to the expected value\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x5, %r15d
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movl $0x7, %ebp
movq %rbp, 0x8(%r14)
movq %r14, %rdi
callq 0x13d6c
movq (%r14), %r12
movq 0x8(%r14), %r13
movq %r15, (%r14)
movq %rbp, 0x8(%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x13d6c
cmpq %r12, (%r14)
jne 0x5164
cmpq %r13, 0x10(%rsp)
jne 0x5164
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movq %r13, 0x8(%r15)
movq %r15, %rdi
callq 0x13eaa
movq %rax, %r12
movq %rdx, %r14
movq $0x4c4b40, (%r15)       # imm = 0x4C4B40
movq $0x7, 0x8(%r15)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x13d6c
cmpq %r12, (%r15)
jne 0x5172
cmpq %r14, 0x10(%rsp)
jne 0x5172
movl $0x5, %r13d
leaq 0x8(%rsp), %r14
movq %r13, (%r14)
movl $0x7, %ebp
movq %rbp, 0x8(%r14)
movq %r14, %rdi
callq 0x13d6c
movq (%r14), %r15
movq 0x8(%r14), %r12
movq %r13, (%r14)
movq %rbp, 0x8(%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x13d6c
cmpq %r15, (%r14)
jne 0x5164
cmpq %r12, 0x10(%rsp)
jne 0x5164
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %r12, 0x8(%r14)
movq %r14, %rdi
callq 0x13efc
movq %rax, %r15
movq %rdx, %r12
movq $0x5, (%r14)
movq $0x6acfc0, 0x8(%r14)    # imm = 0x6ACFC0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x13d6c
xorq (%r14), %r15
xorq 0x8(%r14), %r12
orq %r15, %r12
sete %bpl
je 0x5188
leaq 0x1031a(%rip), %rsi     # 0x1546f
movl $0x31, %edx
movq %rbx, %rdi
callq 0x42b0
jmp 0x5188
leaq 0x102d0(%rip), %rsi     # 0x1543b
movl $0x33, %edx
jmp 0x517e
leaq 0x102f6(%rip), %rsi     # 0x1546f
movl $0x31, %edx
movq %rbx, %rdi
callq 0x42b0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/units.h
// Function: efgy::unit::exponentialScaledUnitValue<efgy::unit::unitValue<efgy::math::numeric::fractional<long long>, (char)109, 1>, -3, efgy::unit::metricMultiplier>::convert(efgy::math::numeric::fractional<long long> const&)
static base convert(const base &value) {
    return ((exponent * unitExponent) <= 0) ? value * multiplier < base,
           exponent < 0 ? -exponent : exponent,
           unitExponent < 0 ? -unitExponent : unitExponent > ::get()
                                            : value / multiplier < base,
           exponent < 0 ? -exponent : exponent,
           unitExponent < 0 ? -unitExponent : unitExponent > ::get();
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0xa, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13c2e
imulq (%rbx), %rax
imulq 0x8(%rbx), %rdx
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x13d6c
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/include/stringimploder.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> StringImploder::operator()<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>>>>>(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&, char)
std::string operator() (const CONTAINER &container, char const delimiter){
		std::stringstream ss;

		bool first = true;

		for(const auto &s : container){
			if (first){
				first = false;
			}else{
				ss.put(delimiter);
			}

			ss << s;
		}

		return ss.str();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x10b0
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x16da
leaq 0x10(%rsp), %r14
movb $0x1, %r13b
movsbl %bpl, %ebp
testb $0x1, %r13b
je 0x16b8
xorl %r13d, %r13d
jmp 0x16c2
movq %r14, %rdi
movl %ebp, %esi
callq 0x1030
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x1120
addq $0x20, %r15
cmpq %r12, %r15
jne 0x16ad
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x1140
movq 0x28e2(%rip), %rsi      # 0x3fd0
movq %rsp, %rdi
callq 0x10d0
leaq 0x80(%rsp), %rdi
callq 0x1060
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x171a
movq %rax, %rbx
movq 0x28ac(%rip), %rsi      # 0x3fd0
movq %rsp, %rdi
callq 0x10d0
leaq 0x80(%rsp), %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O1/RasmusFonseca[P]PDBCluster/Matrix.cpp
// Function: Matrix::get(int, int) const
double Matrix::get(int i,int j) const{
    assert ( i>=0 );
    assert ( i<m );
    assert ( j>=0 );
    assert ( j<n );
    return data[j*m+i];
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x25ea
movl 0x8(%rdi), %eax
cmpl %esi, %eax
jle 0x2609
testl %edx, %edx
js 0x2628
cmpl %edx, 0xc(%rdi)
jle 0x2647
movq (%rdi), %rcx
imull %edx, %eax
addl %esi, %eax
movsd (%rcx,%rax,8), %xmm0
popq %rax
retq
leaq 0x3a13(%rip), %rdi      # 0x6004
leaq 0x3a11(%rip), %rsi      # 0x6009
leaq 0x3a15(%rip), %rcx      # 0x6014
movl $0x2f, %edx
callq 0x2130
leaq 0x3a27(%rip), %rdi      # 0x6037
leaq 0x39f2(%rip), %rsi      # 0x6009
leaq 0x39f6(%rip), %rcx      # 0x6014
movl $0x30, %edx
callq 0x2130
leaq 0x3a0c(%rip), %rdi      # 0x603b
leaq 0x39d3(%rip), %rsi      # 0x6009
leaq 0x39d7(%rip), %rcx      # 0x6014
movl $0x31, %edx
callq 0x2130
leaq 0x39f2(%rip), %rdi      # 0x6040
leaq 0x39b4(%rip), %rsi      # 0x6009
leaq 0x39b8(%rip), %rcx      # 0x6014
movl $0x32, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/RasmusFonseca[P]PDBCluster/Matrix.cpp
// Function: Matrix::set(int, int, double)
void Matrix::set(int i,int j, double v){
    assert ( i>=0 );
    assert ( i<m );
    assert ( j>=0 );
    assert ( j<n );
    data[j*m+i] = v;
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x268a
movl 0x8(%rdi), %eax
cmpl %esi, %eax
jle 0x26a9
testl %edx, %edx
js 0x26c8
cmpl %edx, 0xc(%rdi)
jle 0x26e7
movq (%rdi), %rcx
imull %edx, %eax
addl %esi, %eax
movsd %xmm0, (%rcx,%rax,8)
popq %rax
retq
leaq 0x3973(%rip), %rdi      # 0x6004
leaq 0x3971(%rip), %rsi      # 0x6009
leaq 0x39a5(%rip), %rcx      # 0x6044
movl $0x37, %edx
callq 0x2130
leaq 0x3987(%rip), %rdi      # 0x6037
leaq 0x3952(%rip), %rsi      # 0x6009
leaq 0x3986(%rip), %rcx      # 0x6044
movl $0x38, %edx
callq 0x2130
leaq 0x396c(%rip), %rdi      # 0x603b
leaq 0x3933(%rip), %rsi      # 0x6009
leaq 0x3967(%rip), %rcx      # 0x6044
movl $0x39, %edx
callq 0x2130
leaq 0x3952(%rip), %rdi      # 0x6040
leaq 0x3914(%rip), %rsi      # 0x6009
leaq 0x3948(%rip), %rcx      # 0x6044
movl $0x3a, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/RasmusFonseca[P]PDBCluster/Matrix.cpp
// Function: Matrix::getDifferenceSum(Matrix*)
double Matrix::getDifferenceSum(Matrix* A)
{
    assert(m==A->m);
    assert(n==A->n);
	double ret = 0;
    for(int i=0;i<m*n;i++){
        double diff = data[i]-A->data[i];
        ret+=diff*diff;
    }
    return sqrt(ret/(m*n));
}

// Assembly:
pushq %rax
movl 0x8(%rdi), %ecx
cmpl 0x8(%rsi), %ecx
jne 0x2767
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0x2786
imull %ecx, %eax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %eax, %eax
jle 0x274a
movq (%rdi), %rcx
movq (%rsi), %rdx
movl %eax, %esi
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm2
subsd (%rdx,%rdi,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdi
cmpq %rdi, %rsi
jne 0x2730
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x2761
sqrtsd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x2180
leaq 0x38f9(%rip), %rdi      # 0x6067
leaq 0x3894(%rip), %rsi      # 0x6009
leaq 0x38f3(%rip), %rcx      # 0x606f
movl $0x40, %edx
callq 0x2130
leaq 0x390c(%rip), %rdi      # 0x6099
leaq 0x3875(%rip), %rsi      # 0x6009
leaq 0x38d4(%rip), %rcx      # 0x606f
movl $0x41, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/RasmusFonseca[P]PDBCluster/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
ostream& operator<<(ostream& os, const Matrix& m){
	for (unsigned int i=0; i<m.rows(); ++i) {
		for (unsigned int j=0; j<m.cols(); ++j){
            os << m.get(i,j);
			if(j == (m.cols()-1))
                os << endl;
			else
                os << '\t';
		}
	}
	return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x8(%rsi)
je 0x2841
movq %rsi, %r14
xorl %ebp, %ebp
leaq 0xf(%rsp), %r15
cmpl $0x0, 0xc(%r14)
je 0x2839
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x25c6
movq %rbx, %rdi
callq 0x22c0
movl 0xc(%r14), %eax
decl %eax
cmpl %eax, %r12d
jne 0x281b
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
jmp 0x2830
movb $0x9, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
incl %r12d
cmpl 0xc(%r14), %r12d
jb 0x27d2
incl %ebp
cmpl 0x8(%r14), %ebp
jb 0x27c8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/RasmusFonseca[P]PDBCluster/main.cpp
// Function: medoidCosts_distSum(std::vector<int, std::allocator<int>>&, Matrix&)
double medoidCosts_distSum(vector<int> &medoids, Matrix &dMat){
	double ret = 0;
	for(unsigned int i=0;i<dMat.cols();i++){
		double min = 1000000000.0;

		for(unsigned int j=0;j<medoids.size();j++){
			int m = medoids[j];
			double d = dMat.get(m,i);
			if( d<min ) min = d;
		}
		ret+=min;
	}
	return ret/dMat.cols();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25c2
testl %eax, %eax
je 0x3385
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rax
movsd 0x2d97(%rip), %xmm0     # 0x60b0
cmpq %rax, 0x8(%r14)
je 0x3363
movl $0x1, %ebp
xorl %ecx, %ecx
movsd 0x2d82(%rip), %xmm1     # 0x60b0
movsd %xmm1, 0x10(%rsp)
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
movl %r15d, %edx
callq 0x25c6
minsd 0x10(%rsp), %xmm0
movl %ebp, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
movapd %xmm0, %xmm1
cmpq %rcx, %rdx
ja 0x332e
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %r15d
movq %rbx, %rdi
callq 0x25c2
cmpl %eax, %r15d
jb 0x330e
jmp 0x338f
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x25c2
movl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/RasmusFonseca[P]PDBCluster/main.cpp
// Function: medoidCosts_maxDistSum(std::vector<int, std::allocator<int>>&, Matrix&)
double medoidCosts_maxDistSum(vector<int> &medoids, Matrix &dMat){
	double maxDists[medoids.size()];
	for(unsigned int i=0;i<medoids.size(); i++) maxDists[i] = 0;

	for(unsigned int i=0;i<dMat.cols();i++){
		double min = 1000000000.0;
		int minMedoid = -1;

		for(unsigned int j=0;j<medoids.size();j++){
			int m = medoids[j];
			double d = dMat.get(m,i);
			if( d<min ) {
				min = d;
				minMedoid = j;
			}
		}
		if(min>maxDists[minMedoid]) maxDists[minMedoid] = min;
	}
	double ret = 0;
	for(unsigned int j=0;j<medoids.size();j++)
		ret+=maxDists[j];
	return ret/medoids.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rcx
movq (%rdi), %rdx
movq %rcx, %rax
subq %rdx, %rax
leaq 0xf(,%rax,2), %rsi
andq $-0x10, %rsi
movq %rsp, %r14
subq %rsi, %r14
movq %r14, %rsp
cmpq %rdx, %rcx
je 0x340c
sarq $0x2, %rax
xorl %ecx, %ecx
movq $0x0, (%r14,%rcx,8)
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x33fa
movq %r12, %rdi
callq 0x25c2
testl %eax, %eax
je 0x34ca
xorl %ebx, %ebx
movq %r14, -0x38(%rbp)
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x349b
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %rbx, -0x30(%rbp)
movq %r12, %rbx
movl $0x1, %r12d
xorl %ecx, %ecx
movsd 0x2c68(%rip), %xmm0     # 0x60b0
movsd %xmm0, -0x40(%rbp)
leal -0x1(%r12), %r14d
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
movq -0x30(%rbp), %rdx
callq 0x25c6
movsd -0x40(%rbp), %xmm1
ucomisd %xmm0, %xmm1
cmoval %r14d, %r13d
minsd %xmm1, %xmm0
movl %r12d, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x3448
movslq %r13d, %rax
movq -0x38(%rbp), %r14
movq %rbx, %r12
movq -0x30(%rbp), %rbx
jmp 0x34aa
movq $-0x1, %rax
movsd 0x2c06(%rip), %xmm0     # 0x60b0
ucomisd (%r14,%rax,8), %xmm0
jbe 0x34b8
movsd %xmm0, (%r14,%rax,8)
incl %ebx
movq %r12, %rdi
callq 0x25c2
cmpl %eax, %ebx
jb 0x3422
movq 0x8(%r15), %rcx
movq (%r15), %rdx
movq %rcx, %rax
subq %rdx, %rax
sarq $0x2, %rax
xorpd %xmm0, %xmm0
cmpq %rdx, %rcx
je 0x34f6
xorl %ecx, %ecx
addsd (%r14,%rcx,8), %xmm0
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x34e6
movq %rax, %xmm1
punpckldq 0x2bcd(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2bd5(%rip), %xmm1     # 0x60e0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/RasmusFonseca[P]PDBCluster/main.cpp
// Function: medoidCosts(std::vector<int, std::allocator<int>>&, Matrix&, int)
double medoidCosts(vector<int> &medoids, Matrix &dMat, int clusteringType){
	if(clusteringType==0) return medoidCosts_distSum(medoids, dMat);
	if(clusteringType==1) return medoidCosts_maxDistSum(medoids, dMat);
	if(clusteringType==2) return medoidCosts_maxDist(medoids, dMat);
	cerr<<"Unknown clustering type: "<<clusteringType<<endl;
	exit(-1);
}

// Assembly:
pushq %rbx
cmpl $0x2, %edx
je 0x369e
movl %edx, %ebx
cmpl $0x1, %edx
je 0x3698
testl %ebx, %ebx
jne 0x36a4
popq %rbx
jmp 0x32e1
popq %rbx
jmp 0x33b6
popq %rbx
jmp 0x352a
movq 0x5945(%rip), %rdi      # 0x8ff0
leaq 0x2a43(%rip), %rsi      # 0x60f5
callq 0x21d0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2310
movq %rax, %rdi
callq 0x20f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/ekg[P]tsvtools/tsvbootstrap.cpp
// Function: randomsubset(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, unsigned int)
vector<vector<double>* > randomsubset(vector<vector<double> >& lines, unsigned int samplesize) {
    map<int, bool> hits;
    vector<vector<double>* > results;
    if (lines.size() < samplesize) {
        samplesize = lines.size();
    }
    while (results.size() < samplesize) {
        int pos = genrand_int32() % lines.size();
        map<int, bool>::iterator seen = hits.find(pos);
        if (seen == hits.end()) {
            hits[pos] = true;
            results.push_back(&lines.at(pos));
        }
    }
    return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rbp
movl $0x0, (%rbp)
xorl %eax, %eax
movq %rax, 0x8(%rbp)
movq %rbp, 0x10(%rbp)
movq %rbp, 0x18(%rbp)
movq %rax, 0x20(%rbp)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x8(%rsi), %r15
subq (%rsi), %r15
sarq $0x3, %r15
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %r15
movl %edx, %eax
cmpq %rax, %r15
cmovael %edx, %r15d
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jae 0x2c77
movq %rsi, %r14
leaq 0x10(%rsp), %r13
callq 0x2613
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x3, %rcx
imulq %r12, %rcx
xorl %edx, %edx
divq %rcx
movl %edx, 0xc(%rsp)
movq 0x28(%rsp), %rcx
movq %rbp, %rax
testq %rcx, %rcx
je 0x2c06
movq %rbp, %rax
xorl %esi, %esi
cmpl %edx, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x2bef
movq %rbp, %rcx
cmpq %rbp, %rax
je 0x2c18
cmpl %edx, 0x20(%rax)
cmovgq %rbp, %rax
movq %rax, %rcx
cmpq %rbp, %rcx
jne 0x2c63
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3418
movb $0x1, (%rax)
movslq 0xc(%rsp), %rsi
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0x2c93
leaq (%rsi,%rsi,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3cd2
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jb 0x2bc2
leaq 0x18(%rsp), %rdi
callq 0x3634
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2579(%rip), %rdi      # 0x5213
xorl %eax, %eax
callq 0x2260
jmp 0x2ca5
jmp 0x2ca5
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2cbc
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21e0
leaq 0x18(%rsp), %rdi
callq 0x3634
movq %r14, %rdi
callq 0x2300