LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4110
movb $-0x7b, -0x20(%rbp)
movw -0x1f(%rbp), %ax
andw $-0x1f, %ax
orw $0x8, %ax
movw %ax, -0x1f(%rbp)
movw -0x1f(%rbp), %ax
andw $0xf7ff, %ax            # imm = 0xF7FF
orw $0x800, %ax             # imm = 0x800
movw %ax, -0x1f(%rbp)
movw -0x1f(%rbp), %ax
andw $0xfbff, %ax            # imm = 0xFBFF
orw $0x400, %ax             # imm = 0x400
movw %ax, -0x1f(%rbp)
movw -0x1f(%rbp), %ax
andw $0xefff, %ax            # imm = 0xEFFF
orw $0x0, %ax
movw %ax, -0x1f(%rbp)
movw -0x1f(%rbp), %ax
andw $0xfcff, %ax            # imm = 0xFCFF
orw $0x200, %ax             # imm = 0x200
movw %ax, -0x1f(%rbp)
movb $0x1, -0x1a(%rbp)
movb $-0x14, -0x12(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rcx
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
movl $0x200, %r8d            # imm = 0x200
callq 0x47d0
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %cx, %ax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movw %ax, -0x16(%rbp)
leaq -0x26(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4110
movb $-0x7b, -0x26(%rbp)
movw -0x25(%rbp), %ax
andw $-0x1f, %ax
orw $0x8, %ax
movw %ax, -0x25(%rbp)
movw -0x25(%rbp), %ax
andw $0xf7ff, %ax            # imm = 0xF7FF
orw $0x800, %ax             # imm = 0x800
movw %ax, -0x25(%rbp)
movw -0x25(%rbp), %ax
andw $0xfbff, %ax            # imm = 0xFBFF
orw $0x400, %ax             # imm = 0x400
movw %ax, -0x25(%rbp)
movw -0x25(%rbp), %ax
andw $0xefff, %ax            # imm = 0xEFFF
orw $0x0, %ax
movw %ax, -0x25(%rbp)
movw -0x25(%rbp), %ax
andw $0xfcff, %ax            # imm = 0xFCFF
orw $0x200, %ax             # imm = 0x200
movw %ax, -0x25(%rbp)
movzwl -0x16(%rbp), %eax
sarl $0x8, %eax
movb %al, -0x21(%rbp)
movw -0x16(%rbp), %ax
movb %al, -0x20(%rbp)
movb $-0x50, -0x18(%rbp)
movb $-0x2b, -0x22(%rbp)
movb $-0x3e, -0x1a(%rbp)
movb $0x4f, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x1e(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rcx
movzwl -0x16(%rbp), %eax
shlq $0x9, %rax
movl %eax, %r8d
leaq -0x26(%rbp), %rsi
movl $0x10, %edx
callq 0x47d0
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq -0x218(%rbp), %rsi
callq 0x4b60
movzwl -0x216(%rbp), %edi
callq 0x5d90
movw %ax, -0x21a(%rbp)
cmpw $0x0, -0x21a(%rbp)
jne 0x4eb7
jmp 0x4fbe
movzwl -0x21a(%rbp), %eax
movl $0x200, %ecx            # imm = 0x200
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, -0x228(%rbp)
movl -0x4(%rbp), %edi
movq -0x228(%rbp), %rsi
movl $0x1, %edx
movzwl -0x21a(%rbp), %ecx
callq 0x4a90
movl $0x0, -0x22c(%rbp)
movl -0x22c(%rbp), %eax
movzwl -0x21a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x4f7d
movq -0x228(%rbp), %rax
movslq -0x22c(%rbp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %edi
callq 0x5db0
cmpb $0x0, %al
jne 0x4f40
jmp 0x4f6c
movq -0x228(%rbp), %rax
movslq -0x22c(%rbp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
movzwl 0x1c4(%rax), %edi
callq 0x5d90
movzwl %ax, %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x4f0b
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4f9e
movq -0x10(%rbp), %rdi
leaq 0x40fb(%rip), %rsi      # 0x908c
callq 0x5d50
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x228(%rbp), %rax
movq %rax, -0x238(%rbp)
cmpq $0x0, %rax
je 0x4fbe
movq -0x238(%rbp), %rdi
callq 0x42c0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x5db0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x5d90
movw %ax, %cx
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x5d90
movw %ax, %dx
movq -0x20(%rbp), %rax
movw %dx, %cx
andl $0x2, %ecx
shrl %ecx
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %edi
callq 0x5db0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
movzwl 0x9(%rax), %edi
callq 0x5d90
movzwl %ax, %eax
shlq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x5(%rax), %edi
callq 0x84e0
movq -0x28(%rbp), %rcx
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %edx, %edx
orq %rdx, %rcx
movq %rcx, 0x8(%rax)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x3, %eax
je 0x8383
jmp 0x833f
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x8383
jmp 0x8349
movl -0x14(%rbp), %eax
subl $0x9, %eax
je 0x8398
jmp 0x8353
movl -0x14(%rbp), %eax
subl $0xbe, %eax
je 0x83ad
jmp 0x835f
movl -0x14(%rbp), %eax
subl $0xc2, %eax
je 0x83ad
jmp 0x836b
movl -0x14(%rbp), %eax
subl $0xc4, %eax
je 0x8383
jmp 0x8377
movl -0x14(%rbp), %eax
subl $0xf0, %eax
je 0x8398
jmp 0x83c2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movq %rcx, 0x8(%rax)
jmp 0x83c4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0xffffff, %rcx         # imm = 0xFFFFFF
movq %rcx, 0x8(%rax)
jmp 0x83c4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0xff, %rcx
movq %rcx, 0x8(%rax)
jmp 0x83c4
jmp 0x83c4
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x258, %rsp            # imm = 0x258
movq %rdi, 0x250(%rsp)
movq 0x250(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x8, %edx
callq 0x2190
movl $0x0, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2160
leaq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2030
movq %rax, 0x8(%rsp)
jmp 0x23ae
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2140
movb %al, 0x7(%rsp)
jmp 0x23c8
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x23d2
jmp 0x2403
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x2398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20b0
leaq 0x48(%rsp), %rdi
callq 0x2040
jmp 0x2429
movl 0x44(%rsp), %eax
movl %eax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20b0
leaq 0x48(%rsp), %rdi
callq 0x2040
movl (%rsp), %eax
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x18(%rsp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
cmpl $0x2, 0x4c(%rsp)
jge 0x2486
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
movq 0x18(%rsp), %rdi
callq 0x2ae0
jmp 0x2565
movb $0x0, 0x3f(%rsp)
movl 0x4c(%rsp), %eax
decl %eax
cltq
movq %rax, 0x8(%rsp)
leaq 0x3e(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2af0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2b00
jmp 0x24bd
leaq 0x3e(%rsp), %rdi
callq 0x2b80
movl $0x1, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x254d
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rcx
movslq 0x28(%rsp), %rdx
movl %edx, %eax
movq (%rcx,%rdx,8), %rcx
movq %rcx, (%rsp)
decl %eax
movslq %eax, %rsi
callq 0x2b90
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x2150
jmp 0x250a
jmp 0x250c
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x24cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3e(%rsp), %rdi
callq 0x2b80
jmp 0x256f
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x2bb0
jmp 0x256f
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x2563
movq 0x18(%rsp), %rdi
callq 0x2bb0
jmp 0x2565
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x21c0
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movl $0x0, 0x94(%rsp)
movl %edi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl 0x90(%rsp), %esi
movq 0x88(%rsp), %rdx
leaq 0x70(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x2440
movq 0x38(%rsp), %rdx
leaq -0x52b(%rip), %rsi      # 0x2360
leaq 0x58(%rsp), %rdi
callq 0x2e10
jmp 0x2897
leaq 0x58(%rsp), %rdi
callq 0x2a10
movl %eax, 0x34(%rsp)
jmp 0x28a7
movl 0x34(%rsp), %eax
movl %eax, 0x48(%rsp)
movq 0x5722(%rip), %rdi      # 0x7fd8
leaq 0x2783(%rip), %rsi      # 0x5040
callq 0x2100
movq %rax, 0x28(%rsp)
jmp 0x28c9
movq 0x28(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x21b0
movq %rax, 0x20(%rsp)
jmp 0x28de
movq 0x20(%rsp), %rdi
movq 0x56de(%rip), %rsi      # 0x7fc8
callq 0x2130
jmp 0x28f1
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x2f50
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x29ca
movslq 0x40(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x2b90
movq %rax, %rsi
movq 0x56a1(%rip), %rdi      # 0x7fd8
callq 0x20f0
movq %rax, 0x10(%rsp)
jmp 0x2943
movq 0x10(%rsp), %rdi
leaq 0x2701(%rip), %rsi      # 0x5050
callq 0x2100
movq %rax, 0x8(%rsp)
jmp 0x295b
movslq 0x40(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x2f70
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x21b0
movq %rax, (%rsp)
jmp 0x297c
movq (%rsp), %rdi
movq 0x5641(%rip), %rsi      # 0x7fc8
callq 0x2130
jmp 0x298e
jmp 0x2990
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x28f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x29f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2f90
jmp 0x29f8
movl $0x0, 0x94(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2f90
leaq 0x70(%rsp), %rdi
callq 0x2bb0
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x2bb0
movq 0x50(%rsp), %rdi
callq 0x21c0
nopl (%rax)
// File: willprice[P]parallel-cpp-workshop/include/part1.h
// Function: int part1::reduce<main::$_0, int>(main::$_0, std::vector<int, std::allocator<int>> const&)
T reduce(FUNC func, const std::vector<T> &values)
{
    if (values.empty())
    {
        return T();
    }
    else
    {
        T result = values[0];

        for (size_t i=1; i<values.size(); ++i)
        {
            result = func(result, values[i]);
        }

        return result;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4c20
testb $0x1, %al
jne 0x2a29
jmp 0x2a36
movl $0x0, 0x34(%rsp)
jmp 0x2ab7
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c70
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4c90
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2aaf
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4c70
movl 0xc(%rsp), %esi
movl (%rax), %edx
leaq 0x33(%rsp), %rdi
callq 0x2ac0
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2a53
movl 0x24(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x3070
movl %eax, 0x6c(%rsp)
movslq 0x6c(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3080
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x3090
jmp 0x2e73
leaq 0x4f(%rsp), %rdi
callq 0x3110
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movslq 0x6c(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2f19
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3120
movq %rax, %rdi
movq (%rsp), %rax
callq *%rax
movl %eax, 0xc(%rsp)
jmp 0x2ec0
movq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x2f70
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x3110
jmp 0x2f3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2f90
jmp 0x2f3f
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3140
leaq 0x50(%rsp), %rdi
callq 0x2f90
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x21c0
nopl (%rax)
// File: Mariotti94[P]BigFloat/./BigFloat.h
// Function: BigFloat::GetError[abi:cxx11]() const
inline std::string GetError() const
    {
        if(error)
            return error_code;
        else
            return "No Error";
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x5c(%rax)
je 0x4220
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x60, %rsi
callq 0x20b0
jmp 0x426b
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2340
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
leaq 0xdf59(%rip), %rsi      # 0x12197
callq 0x22a0
jmp 0x4245
leaq 0x37(%rsp), %rdi
callq 0x2230
jmp 0x426b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x2230
jmp 0x4275
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2330
nop
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x5, %esi
movl $0x7, %edx
callq 0x7480
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x76b0
leaq -0x40(%rbp), %rdi
movl $0x5, %esi
movl $0x7, %edx
callq 0x7480
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x74f0
testb $0x1, %al
jne 0x63f5
jmp 0x640e
movq -0x10(%rbp), %rdi
leaq 0x2f195(%rip), %rsi     # 0x35595
callq 0x5360
movb $0x0, -0x1(%rbp)
jmp 0x6534
leaq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x76e0
leaq -0x70(%rbp), %rdi
movl $0x4c4b40, %esi         # imm = 0x4C4B40
movl $0x7, %edx
callq 0x7480
leaq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7740
testb $0x1, %al
jne 0x6441
jmp 0x645a
movq -0x10(%rbp), %rdi
leaq 0x2f17d(%rip), %rsi     # 0x355c9
callq 0x5360
movb $0x0, -0x1(%rbp)
jmp 0x6534
leaq -0x90(%rbp), %rdi
movl $0x5, %esi
movl $0x7, %edx
callq 0x7480
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x7770
leaq -0xa0(%rbp), %rdi
movl $0x5, %esi
movl $0x7, %edx
callq 0x7480
movq -0x80(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x74f0
testb $0x1, %al
jne 0x64c5
jmp 0x64db
movq -0x10(%rbp), %rdi
leaq 0x2f0c5(%rip), %rsi     # 0x35595
callq 0x5360
movb $0x0, -0x1(%rbp)
jmp 0x6534
leaq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x77a0
leaq -0xd0(%rbp), %rdi
movl $0x5, %esi
movl $0x6acfc0, %edx         # imm = 0x6ACFC0
callq 0x7480
leaq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x7800
testb $0x1, %al
jne 0x651a
jmp 0x6530
movq -0x10(%rbp), %rdi
leaq 0x2f0a4(%rip), %rsi     # 0x355c9
callq 0x5360
movb $0x0, -0x1(%rbp)
jmp 0x6534
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x33d04
jmp 0x33d30
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x33dc0
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x33d70
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x33d5a
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x33dc0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x33e00
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x8(%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movb %al, 0x1df(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x10c0
movb $0x1, 0x4f(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2030
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2060
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2090
testb $0x1, %al
jne 0x1e74
jmp 0x1ee3
leaq 0x38(%rsp), %rdi
callq 0x20d0
movq %rax, 0x28(%rsp)
testb $0x1, 0x4f(%rsp)
je 0x1e91
movb $0x0, 0x4f(%rsp)
jmp 0x1ec1
leaq 0x60(%rsp), %rdi
movsbl 0x1df(%rsp), %esi
callq 0x1030
jmp 0x1ea5
jmp 0x1ec1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x10d0
jmp 0x1f0b
leaq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10f0
jmp 0x1ed2
jmp 0x1ed4
leaq 0x38(%rsp), %rdi
callq 0x20e0
jmp 0x1e5f
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1100
jmp 0x1ef4
leaq 0x50(%rsp), %rdi
callq 0x10d0
movq 0x10(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x20(%rsp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x2753
jmp 0x2772
leaq 0x88aa(%rip), %rdi      # 0xb004
leaq 0x88a8(%rip), %rsi      # 0xb009
movl $0x2f, %edx
leaq 0x88a7(%rip), %rcx      # 0xb014
callq 0x2170
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2781
jmp 0x27a0
leaq 0x88af(%rip), %rdi      # 0xb037
leaq 0x887a(%rip), %rsi      # 0xb009
movl $0x30, %edx
leaq 0x8879(%rip), %rcx      # 0xb014
callq 0x2170
cmpl $0x0, 0x8(%rsp)
jl 0x27a9
jmp 0x27c8
leaq 0x888b(%rip), %rdi      # 0xb03b
leaq 0x8852(%rip), %rsi      # 0xb009
movl $0x31, %edx
leaq 0x8851(%rip), %rcx      # 0xb014
callq 0x2170
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x27d7
jmp 0x27f6
leaq 0x8862(%rip), %rdi      # 0xb040
leaq 0x8824(%rip), %rsi      # 0xb009
movl $0x32, %edx
leaq 0x8823(%rip), %rcx      # 0xb014
callq 0x2170
movq (%rsp), %rdx
movq (%rdx), %rax
movl 0x8(%rsp), %ecx
imull 0x8(%rdx), %ecx
addl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x1c(%rsp)
jl 0x284a
jmp 0x2869
leaq 0x87b3(%rip), %rdi      # 0xb004
leaq 0x87b1(%rip), %rsi      # 0xb009
movl $0x37, %edx
leaq 0x87e0(%rip), %rcx      # 0xb044
callq 0x2170
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2879
jmp 0x2898
leaq 0x87b7(%rip), %rdi      # 0xb037
leaq 0x8782(%rip), %rsi      # 0xb009
movl $0x38, %edx
leaq 0x87b1(%rip), %rcx      # 0xb044
callq 0x2170
cmpl $0x0, 0x18(%rsp)
jl 0x28a1
jmp 0x28c0
leaq 0x8793(%rip), %rdi      # 0xb03b
leaq 0x875a(%rip), %rsi      # 0xb009
movl $0x39, %edx
leaq 0x8789(%rip), %rcx      # 0xb044
callq 0x2170
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x28d0
jmp 0x28ef
leaq 0x8769(%rip), %rdi      # 0xb040
leaq 0x872b(%rip), %rsi      # 0xb009
movl $0x3a, %edx
leaq 0x875a(%rip), %rcx      # 0xb044
callq 0x2170
movq 0x8(%rsp), %rdx
movsd 0x10(%rsp), %xmm0
movq (%rdx), %rax
movl 0x18(%rsp), %ecx
imull 0x8(%rdx), %ecx
addl 0x1c(%rsp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x2947
jmp 0x2966
leaq 0x8719(%rip), %rdi      # 0xb067
leaq 0x86b4(%rip), %rsi      # 0xb009
movl $0x40, %edx
leaq 0x870e(%rip), %rcx      # 0xb06f
callq 0x2170
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x297a
jmp 0x2999
leaq 0x8718(%rip), %rdi      # 0xb099
leaq 0x8681(%rip), %rsi      # 0xb009
movl $0x41, %edx
leaq 0x86db(%rip), %rcx      # 0xb06f
callq 0x2170
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdx
movl 0x1c(%rsp), %eax
movl 0x8(%rdx), %ecx
imull 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x2a15
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movq (%rax), %rax
movslq 0x1c(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x29aa
movq 0x8(%rsp), %rcx
movsd 0x20(%rsp), %xmm0
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x21b0
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2710
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jae 0x2b25
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2720
movl %eax, %ecx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jae 0x2b13
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
callq 0x2730
movq 0x8(%rsp), %rdi
callq 0x23f0
movl 0x20(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2720
movl %eax, %ecx
movl 0x14(%rsp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2af2
movq 0x30(%rsp), %rdi
movq 0xc4d5(%rip), %rsi      # 0xefc0
callq 0x2240
jmp 0x2b01
movq 0x30(%rsp), %rdi
movl $0x9, %esi
callq 0x2260
jmp 0x2b03
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2a7e
jmp 0x2b15
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2a56
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2720
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jae 0x3912
movsd 0x7841(%rip), %xmm0     # 0xb0a8
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5d90
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x38f0
movq 0x50(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x5db0
movl (%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x3c(%rsp), %edx
callq 0x2730
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x38e1
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x38e3
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3875
movsd 0x30(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x383f
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2720
movsd 0x8(%rsp), %xmm0
movl %eax, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x3d60
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3820
movsd %xmm0, 0x20(%rsp)
jmp 0x3dd4
cmpl $0x1, 0xc(%rsp)
jne 0x3d7e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3940
movsd %xmm0, 0x20(%rsp)
jmp 0x3dd4
cmpl $0x2, 0xc(%rsp)
jne 0x3d9c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3b50
movsd %xmm0, 0x20(%rsp)
jmp 0x3dd4
movq 0xb24d(%rip), %rdi      # 0xeff0
leaq 0x736b(%rip), %rsi      # 0xb115
callq 0x2210
movq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x23a0
movq %rax, %rdi
movq 0xb1fb(%rip), %rsi      # 0xefc0
callq 0x2240
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2280
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: RasmusFonseca[P]PDBCluster/main.cpp
// Function: get_wall_time()
double get_wall_time(){
	struct timeval time;
	if (gettimeofday(&time,NULL)){
		//  Handle error
		return 0;
	}
	return (double)time.tv_sec + (double)time.tv_usec * .000001;
}

// Assembly:
subq $0x18, %rsp
movq %rsp, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2350
cmpl $0x0, %eax
je 0x3e00
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x3e23
cvtsi2sdq (%rsp), %xmm1
cvtsi2sdq 0x8(%rsp), %xmm0
movsd 0x729b(%rip), %xmm2     # 0xb0b0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movl %edx, 0x94(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3cf0
movq 0x28(%rsp), %rdi
movb $0x0, 0x5f(%rsp)
callq 0x3d00
movq 0x98(%rsp), %rdi
callq 0x3d10
movl 0x94(%rsp), %ecx
cmpq %rcx, %rax
jae 0x30c1
movq 0x98(%rsp), %rdi
callq 0x3d10
movl %eax, 0x94(%rsp)
jmp 0x30c3
movq 0x28(%rsp), %rdi
callq 0x3d30
movl 0x94(%rsp), %ecx
cmpq %rcx, %rax
jae 0x31c6
callq 0x2860
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
callq 0x3d10
movq %rax, %rcx
movq 0x10(%rsp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3d50
movq %rax, 0x18(%rsp)
jmp 0x311d
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3da0
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3d80
testb $0x1, %al
jne 0x314b
jmp 0x31c1
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3dd0
movq %rax, 0x8(%rsp)
jmp 0x3161
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
movq 0x98(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x3ef0
movq %rax, (%rsp)
jmp 0x3181
movq 0x28(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x3ec0
jmp 0x319b
jmp 0x31c1
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x3f30
leaq 0x60(%rsp), %rdi
callq 0x3f90
jmp 0x31f3
jmp 0x30c3
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x31dc
movq 0x28(%rsp), %rdi
callq 0x3f30
leaq 0x60(%rsp), %rdi
callq 0x3f90
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x23b0
nopl (%rax)
// File: zhangk145[P]video_envalue/Decoder.cpp
// Function: Decoder::open(char const*)
int Decoder::open(const char *input_file) {
    int ret = avformat_open_input(&mFormatCtx, input_file, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open source file %s\n", input_file);
        return ret;
    }

    /* retrieve stream information */
    ret = avformat_find_stream_info(mFormatCtx, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not find stream information\n");
        return ret;
    }
    ret = open_codec_context(&mStreamIndex, &mCodecCtx, mFormatCtx, AVMEDIA_TYPE_VIDEO);
    if (ret >= 0) {
        mStream = mFormatCtx->streams[mStreamIndex];

        /* allocate image where the decoded image will be put */
        mWidth = mCodecCtx->width;
        mHeight = mCodecCtx->height;
        mPixFmt = mCodecCtx->pix_fmt;
        printf("[%s:%d]==mWidth:%d mHeight:%d mPixFmt:%d\n", __FUNCTION__, __LINE__, mWidth, mHeight, mPixFmt);
        // ret = av_image_alloc(mImageData, mImageLinesize,
        //                      mWidth, mHeight, mPixFmt, 1);
        // if (ret < 0) {
        //     fprintf(stderr, "Could not allocate raw video buffer\n");
        //     return ret;
        // }
        // video_dst_bufsize = ret;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x2130
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2578
movq 0x4a88(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2a9e(%rip), %rsi      # 0x5004
movb $0x0, %al
callq 0x2090
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x263d
movq -0x28(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2180
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x25b4
movq 0x4a48(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x2a81(%rip), %rsi      # 0x5023
movb $0x0, %al
callq 0x2090
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x263d
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x18, %rsi
movq %rdi, %rdx
addq $0x8, %rdx
movq (%rdi), %rcx
xorl %r8d, %r8d
callq 0x2650
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x2637
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq 0x30(%rcx), %rcx
movslq 0x18(%rax), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rcx
movl 0x74(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq 0x8(%rax), %rcx
movl 0x78(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq 0x8(%rax), %rcx
movl 0x88(%rcx), %ecx
movl %ecx, 0x1c(%rax)
movl 0x20(%rax), %ecx
movl 0x24(%rax), %r8d
movl 0x1c(%rax), %r9d
leaq 0x2a22(%rip), %rdi      # 0x5046
leaq 0x2a45(%rip), %rsi      # 0x5070
movl $0x34, %edx
movb $0x0, %al
callq 0x2050
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhangk145[P]video_envalue/Decoder.cpp
// Function: Decoder::decode(AVFrame*)
int Decoder::decode(AVFrame *frame) {
    int ret = 0;
    AVPacket pkt;
    int got_frame = 0;
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;
    while (!got_frame) {
        if (!mEof) {
            // printf("[%s:%d]==\n", __FUNCTION__, __LINE__);
            ret = av_read_frame(mFormatCtx, &pkt);
            // printf("[%s:%d]==ret:%d\n", __FUNCTION__, __LINE__, ret);
            if (ret < 0) {
                mEof = true;
                return ret;
            }
        }
        AVPacket orig_pkt = pkt;
        do {
            // printf("[%s:%d]==\n", __FUNCTION__, __LINE__);
            ret = decode_packet(&pkt, frame, &got_frame);
            // printf("[%s:%d]==ret:%d\n", __FUNCTION__, __LINE__, ret);
            if (ret < 0)
                break;
            pkt.data += ret;
            pkt.size -= ret;
        } while (pkt.size > 0);
        av_packet_unref(&orig_pkt);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x7c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x21c0
movq $0x0, -0x60(%rbp)
movl $0x0, -0x58(%rbp)
cmpl $0x0, -0x7c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2ab6
jmp 0x2b5f
movq -0xe0(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0x2af4
movq -0xe0(%rbp), %rax
movq (%rax), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2190
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2af2
movq -0xe0(%rbp), %rax
movb $0x1, 0x28(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b65
jmp 0x2af4
leaq -0xd8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x58, %edx
callq 0x2060
movq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rsi
leaq -0x7c(%rbp), %rcx
callq 0x2860
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2b2c
jmp 0x2b4e
movl -0x1c(%rbp), %ecx
movq -0x60(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x58(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
jg 0x2b09
leaq -0xd8(%rbp), %rdi
callq 0x2270
jmp 0x2aa4
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: zhangk145[P]video_envalue/Envaluer.cpp
// Function: Envaluer::open(int, int, int)
int Envaluer::open(int width, int height, int format) {
    mWidth = width;
    mHeight = height;
    mYuvSize = width * height;
    mYuvOrg = (uint8_t *)malloc(mYuvSize * sizeof(uint8_t));
    mYuvNew = (uint8_t *)malloc(mYuvSize * sizeof(uint8_t));
    mStartClock = clock();
    switch (format) {
        case 420: {
            mYuvSize = (width * height * 3) >> 1;
        }
        break;
        default:break;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %edx
imull %edx, %ecx
movl %ecx, 0xc(%rax)
movslq 0xc(%rax), %rdi
callq 0x2210
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movslq 0xc(%rax), %rdi
callq 0x2210
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x14(%rbp), %eax
subl $0x1a4, %eax            # imm = 0x1A4
jne 0x2c9e
jmp 0x2c89
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
imull $0x3, %ecx, %ecx
sarl %ecx
movl %ecx, 0xc(%rax)
jmp 0x2ca0
jmp 0x2ca0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zhangk145[P]video_envalue/Envaluer.cpp
// Function: Envaluer::close()
void Envaluer::close() {
    end();
    free(mYuvOrg);
    free(mYuvNew);
    free(mYPsnr);
    free(mYSsim);
    mYuvOrg = NULL;
    mYuvNew = NULL;
    mYPsnr = NULL;
    mYSsim = NULL;
    mYuvSize = 0;
    mBufSize = 0;
    mPMean = 0;
    mSMean = 0;
    mCount = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2d50
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2080
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2080
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2080
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2080
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
movl $0x0, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: zhangk145[P]video_envalue/Envaluer.cpp
// Function: Envaluer::ssim_4x4x2_core(unsigned char const*, int, unsigned char const*, int, int (*) [4])
void Envaluer::ssim_4x4x2_core(const uint8_t *pix1, int stride1,
                               const uint8_t *pix2, int stride2,
                               int sums[2][4])
{
    int x, y, z;
    for(z=0; z<2; z++)
    {
        uint32_t s1=0, s2=0, ss=0, s12=0;
        for(y=0; y<4; y++)
            for(x=0; x<4; x++)
            {
                int a = pix1[x+y*stride1];
                int b = pix2[x+y*stride2];
                s1  += a;
                s2  += b;
                ss  += a*a;
                ss  += b*b;
                s12 += a*b;
            }
        sums[z][0] = s1;
        sums[z][1] = s2;
        sums[z][2] = ss;
        sums[z][3] = s12;
        pix1 += 4;
        pix2 += 4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x2, -0x3c(%rbp)
jge 0x30d7
movl $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0x305e
movl $0x0, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x304e
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %edx
imull -0x14(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %edx
imull -0x24(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x54(%rbp)
movl -0x50(%rbp), %eax
addl -0x40(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x54(%rbp), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x50(%rbp), %eax
imull -0x50(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x54(%rbp), %eax
imull -0x54(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x50(%rbp), %eax
imull -0x54(%rbp), %eax
addl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2fd0
jmp 0x3050
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2fbf
movl -0x40(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x44(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0x48(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x4c(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2f92
popq %rbp
retq
nopl (%rax)