LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dmonaldo[P]simple-network-file-system/FileSys.cpp
// Function: FileSys::cd(char const*)
void FileSys::cd(const char *name)
{
  bool error = false;
  bool found = false;
  char buffer[256];

  //retrieve current directory data block
  dirblock_t dir_ptr;
  bfs.read_block(curr_dir, (void *) &dir_ptr);

  //check if any sub directories exist in current directory
  if(dir_ptr.num_entries > 0){
    //check each sub directory and check directory names for match
    for(int i= 1; i <= dir_ptr.num_entries; i++){
      if(strcmp(dir_ptr.dir_entries[i].name, name) == 0){
        found = true;
        if(!is_directory(dir_ptr.dir_entries[i].block_num)){
          error = true;
          strcat(buffer, "500 File is not a directory\r\n");
        }
        else{
          strcat(buffer, "200 OK\r\n");
          curr_dir = dir_ptr.dir_entries[i].block_num;
        }
      }
    }
  }
  // if this point reached, no matching directory found
  if(found && !error){
    strcat(buffer, "503 File does not exist\r\n");
  }
  cout << buffer << endl;
  send(fs_sock, buffer, sizeof(buffer), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
leaq -0x1a0(%rbp), %rdx
movq %rax, %rdi
movswl 0x4(%rax), %esi
callq 0x3c20
cmpl $0x0, -0x19c(%rbp)
jbe 0x43fc
movl $0x1, -0x1a4(%rbp)
movl -0x1a4(%rbp), %eax
cmpl -0x19c(%rbp), %eax
ja 0x43fa
leaq -0x1a0(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1a4(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3480
cmpl $0x0, %eax
jne 0x43e4
movq -0x1b0(%rbp), %rdi
movb $0x1, -0x12(%rbp)
leaq -0x1a0(%rbp), %rax
addq $0x8, %rax
movslq -0x1a4(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movswl 0xa(%rax), %esi
callq 0x4470
testb $0x1, %al
jne 0x43a7
movb $0x1, -0x11(%rbp)
leaq -0x120(%rbp), %rdi
leaq 0x7d4b(%rip), %rsi      # 0xc0eb
callq 0x3580
jmp 0x43e2
leaq -0x120(%rbp), %rdi
leaq 0x7d54(%rip), %rsi      # 0xc109
callq 0x3580
movq -0x1b0(%rbp), %rax
leaq -0x1a0(%rbp), %rcx
addq $0x8, %rcx
movslq -0x1a4(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movw 0xa(%rcx), %cx
movw %cx, 0x4(%rax)
jmp 0x43e4
jmp 0x43e6
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0x4320
jmp 0x43fc
testb $0x1, -0x12(%rbp)
je 0x441b
testb $0x1, -0x11(%rbp)
jne 0x441b
leaq -0x120(%rbp), %rdi
leaq 0x7cfc(%rip), %rsi      # 0xc112
callq 0x3580
leaq -0x120(%rbp), %rsi
movq 0xbb97(%rip), %rdi      # 0xffc0
callq 0x3340
movq %rax, %rdi
movq 0xbb70(%rip), %rsi      # 0xffa8
callq 0x3390
movq -0x1b0(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
xorl %ecx, %ecx
callq 0x31d0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dmonaldo[P]simple-network-file-system/FileSys.cpp
// Function: FileSys::is_directory(short)
const bool FileSys::is_directory(short block_num)
{
  //create dirblock_t to read block into
  dirblock_t target_dir;
  bfs.read_block(block_num, (void *) &target_dir);

  if (target_dir.magic == DIR_MAGIC_NUM) {
    return true;
  }
  else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x94(%rbp), %rdx
movswl -0x12(%rbp), %esi
callq 0x3c20
cmpl $-0x1, -0x94(%rbp)
jne 0x44a9
movb $0x1, -0x1(%rbp)
jmp 0x44ad
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dmonaldo[P]simple-network-file-system/FileSys.cpp
// Function: FileSys::home()
void FileSys::home(){
  char buffer[1024];
  curr_dir = 1;
  strcpy(buffer, "200 OK\r\n Length: 0\r\n\r\n");
  send(fs_sock, buffer, sizeof(buffer), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x418(%rbp)
movw $0x1, 0x4(%rax)
leaq -0x410(%rbp), %rdi
leaq 0x7c3e(%rip), %rsi      # 0xc12c
callq 0x3320
movq -0x418(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x31d0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::mkdir_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::mkdir_rpc(string dname) {
  string command = "mkdir " + dname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("mkdir", received);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10e0, %rsp           # imm = 0x10E0
movq %rsi, %rdx
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10c0(%rbp)
leaq 0x4e73(%rip), %rsi      # 0xc4eb
leaq -0x50(%rbp), %rdi
movq %rdi, -0x10b8(%rbp)
callq 0xa180
movq -0x10b8(%rbp), %rsi
leaq 0x4a52(%rip), %rdx      # 0xc0e8
leaq -0x30(%rbp), %rdi
callq 0xa130
jmp 0x76a1
leaq -0x50(%rbp), %rdi
callq 0x3628
leaq -0x30(%rbp), %rdi
callq 0x3190
movq %rax, %rsi
leaq -0x860(%rbp), %rdi
movq %rdi, -0x10c8(%rbp)
callq 0x3320
movq -0x10c8(%rbp), %rsi
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x31d0
jmp 0x76e7
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
leaq -0x1060(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3140
jmp 0x7705
leaq -0x1081(%rbp), %rdi
movq %rdi, -0x10d0(%rbp)
callq 0x3570
movq -0x10d0(%rbp), %rdx
leaq 0x4b28(%rip), %rsi      # 0xc24e
leaq -0x1080(%rbp), %rdi
callq 0x69b0
jmp 0x7734
leaq -0x10a9(%rbp), %rdi
movq %rdi, -0x10d8(%rbp)
callq 0x3570
movq -0x10d8(%rbp), %rdx
leaq -0x10a8(%rbp), %rdi
leaq -0x1060(%rbp), %rsi
callq 0x69b0
jmp 0x7763
movq -0x10c0(%rbp), %rdi
leaq -0x1080(%rbp), %rsi
leaq -0x10a8(%rbp), %rdx
callq 0x7850
jmp 0x777f
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
addq $0x10e0, %rsp           # imm = 0x10E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x7847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x783e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7832
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x781a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
movq -0x58(%rbp), %rdi
callq 0x3560
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::cd_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::cd_rpc(string dname) {
  string command = "cd " + dname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("cd", received);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10e0, %rsp           # imm = 0x10E0
movq %rsi, %rdx
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10c0(%rbp)
leaq 0x49ba(%rip), %rsi      # 0xc4f2
leaq -0x50(%rbp), %rdi
movq %rdi, -0x10b8(%rbp)
callq 0xa180
movq -0x10b8(%rbp), %rsi
leaq 0x4592(%rip), %rdx      # 0xc0e8
leaq -0x30(%rbp), %rdi
callq 0xa130
jmp 0x7b61
leaq -0x50(%rbp), %rdi
callq 0x3628
leaq -0x30(%rbp), %rdi
callq 0x3190
movq %rax, %rsi
leaq -0x860(%rbp), %rdi
movq %rdi, -0x10c8(%rbp)
callq 0x3320
movq -0x10c8(%rbp), %rsi
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x31d0
jmp 0x7ba7
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
leaq -0x1060(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3140
jmp 0x7bc5
leaq -0x1081(%rbp), %rdi
movq %rdi, -0x10d0(%rbp)
callq 0x3570
movq -0x10d0(%rbp), %rdx
leaq 0x466e(%rip), %rsi      # 0xc254
leaq -0x1080(%rbp), %rdi
callq 0x69b0
jmp 0x7bf4
leaq -0x10a9(%rbp), %rdi
movq %rdi, -0x10d8(%rbp)
callq 0x3570
movq -0x10d8(%rbp), %rdx
leaq -0x10a8(%rbp), %rdi
leaq -0x1060(%rbp), %rsi
callq 0x69b0
jmp 0x7c23
movq -0x10c0(%rbp), %rdi
leaq -0x1080(%rbp), %rsi
leaq -0x10a8(%rbp), %rdx
callq 0x7850
jmp 0x7c3f
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
addq $0x10e0, %rsp           # imm = 0x10E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x7d07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7cfe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7cf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7cda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
movq -0x58(%rbp), %rdi
callq 0x3560
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::home_rpc()
void Shell::home_rpc() {
  string command = "home\r\n";
  char message[200];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("home", received);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x990, %rsp            # imm = 0x990
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x970(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x968(%rbp)
callq 0x3570
movq -0x968(%rbp), %rdx
leaq 0x47ae(%rip), %rsi      # 0xc4f6
leaq -0x28(%rbp), %rdi
callq 0x69b0
jmp 0x7d53
leaq -0x29(%rbp), %rdi
callq 0x33b0
leaq -0x28(%rbp), %rdi
callq 0x3190
movq %rax, %rsi
leaq -0x110(%rbp), %rdi
movq %rdi, -0x978(%rbp)
callq 0x3320
movq -0x978(%rbp), %rsi
movq -0x970(%rbp), %rax
movl (%rax), %edi
movl $0xc8, %edx
xorl %ecx, %ecx
callq 0x31d0
jmp 0x7d99
movq -0x970(%rbp), %rax
movl (%rax), %edi
leaq -0x910(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3140
jmp 0x7db7
leaq -0x931(%rbp), %rdi
movq %rdi, -0x980(%rbp)
callq 0x3570
movq -0x980(%rbp), %rdx
leaq 0x447f(%rip), %rsi      # 0xc257
leaq -0x930(%rbp), %rdi
callq 0x69b0
jmp 0x7de6
leaq -0x959(%rbp), %rdi
movq %rdi, -0x988(%rbp)
callq 0x3570
movq -0x988(%rbp), %rdx
leaq -0x958(%rbp), %rdi
leaq -0x910(%rbp), %rsi
callq 0x69b0
jmp 0x7e15
movq -0x970(%rbp), %rdi
leaq -0x930(%rbp), %rsi
leaq -0x958(%rbp), %rdx
callq 0x7850
jmp 0x7e31
leaq -0x958(%rbp), %rdi
callq 0x3628
leaq -0x959(%rbp), %rdi
callq 0x33b0
leaq -0x930(%rbp), %rdi
callq 0x3628
leaq -0x931(%rbp), %rdi
callq 0x33b0
leaq -0x28(%rbp), %rdi
callq 0x3628
addq $0x990, %rsp            # imm = 0x990
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x33b0
jmp 0x7ef9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7ef0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7ee4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7ecc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x958(%rbp), %rdi
callq 0x3628
leaq -0x959(%rbp), %rdi
callq 0x33b0
leaq -0x930(%rbp), %rdi
callq 0x3628
leaq -0x931(%rbp), %rdi
callq 0x33b0
leaq -0x28(%rbp), %rdi
callq 0x3628
movq -0x38(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::rmdir_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::rmdir_rpc(string dname) {
  string command = "rmdir " + dname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("rmdir", received);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10e0, %rsp           # imm = 0x10E0
movq %rsi, %rdx
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10c0(%rbp)
leaq 0x45c5(%rip), %rsi      # 0xc4fd
leaq -0x50(%rbp), %rdi
movq %rdi, -0x10b8(%rbp)
callq 0xa180
movq -0x10b8(%rbp), %rsi
leaq 0x4192(%rip), %rdx      # 0xc0e8
leaq -0x30(%rbp), %rdi
callq 0xa130
jmp 0x7f61
leaq -0x50(%rbp), %rdi
callq 0x3628
leaq -0x30(%rbp), %rdi
callq 0x3190
movq %rax, %rsi
leaq -0x860(%rbp), %rdi
movq %rdi, -0x10c8(%rbp)
callq 0x3320
movq -0x10c8(%rbp), %rsi
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x31d0
jmp 0x7fa7
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
leaq -0x1060(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3140
jmp 0x7fc5
leaq -0x1081(%rbp), %rdi
movq %rdi, -0x10d0(%rbp)
callq 0x3570
movq -0x10d0(%rbp), %rdx
leaq 0x4276(%rip), %rsi      # 0xc25c
leaq -0x1080(%rbp), %rdi
callq 0x69b0
jmp 0x7ff4
leaq -0x10a9(%rbp), %rdi
movq %rdi, -0x10d8(%rbp)
callq 0x3570
movq -0x10d8(%rbp), %rdx
leaq -0x10a8(%rbp), %rdi
leaq -0x1060(%rbp), %rsi
callq 0x69b0
jmp 0x8023
movq -0x10c0(%rbp), %rdi
leaq -0x1080(%rbp), %rsi
leaq -0x10a8(%rbp), %rdx
callq 0x7850
jmp 0x803f
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
addq $0x10e0, %rsp           # imm = 0x10E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x8107
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x80fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x80f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x80da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
movq -0x58(%rbp), %rdi
callq 0x3560
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::ls_rpc()
void Shell::ls_rpc() {
  string command = "ls\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("ls", received);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10c0, %rsp           # imm = 0x10C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10a0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x1098(%rbp)
callq 0x3570
movq -0x1098(%rbp), %rdx
leaq 0x43bc(%rip), %rsi      # 0xc504
leaq -0x28(%rbp), %rdi
callq 0x69b0
jmp 0x8153
leaq -0x29(%rbp), %rdi
callq 0x33b0
leaq -0x28(%rbp), %rdi
callq 0x3190
movq %rax, %rsi
leaq -0x840(%rbp), %rdi
movq %rdi, -0x10a8(%rbp)
callq 0x3320
movq -0x10a8(%rbp), %rsi
movq -0x10a0(%rbp), %rax
movl (%rax), %edi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x31d0
jmp 0x8199
movq -0x10a0(%rbp), %rax
movl (%rax), %edi
leaq -0x1040(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3140
jmp 0x81b7
leaq -0x1061(%rbp), %rdi
movq %rdi, -0x10b0(%rbp)
callq 0x3570
movq -0x10b0(%rbp), %rdx
leaq 0x408a(%rip), %rsi      # 0xc262
leaq -0x1060(%rbp), %rdi
callq 0x69b0
jmp 0x81e6
leaq -0x1089(%rbp), %rdi
movq %rdi, -0x10b8(%rbp)
callq 0x3570
movq -0x10b8(%rbp), %rdx
leaq -0x1088(%rbp), %rdi
leaq -0x1040(%rbp), %rsi
callq 0x69b0
jmp 0x8215
movq -0x10a0(%rbp), %rdi
leaq -0x1060(%rbp), %rsi
leaq -0x1088(%rbp), %rdx
callq 0x7850
jmp 0x8231
leaq -0x1088(%rbp), %rdi
callq 0x3628
leaq -0x1089(%rbp), %rdi
callq 0x33b0
leaq -0x1060(%rbp), %rdi
callq 0x3628
leaq -0x1061(%rbp), %rdi
callq 0x33b0
leaq -0x28(%rbp), %rdi
callq 0x3628
addq $0x10c0, %rsp           # imm = 0x10C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x33b0
jmp 0x82f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x82f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x82e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x82cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1088(%rbp), %rdi
callq 0x3628
leaq -0x1089(%rbp), %rdi
callq 0x33b0
leaq -0x1060(%rbp), %rdi
callq 0x3628
leaq -0x1061(%rbp), %rdi
callq 0x33b0
leaq -0x28(%rbp), %rdi
callq 0x3628
movq -0x38(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::create_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::create_rpc(string fname) {
  string command = "create " + fname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("create", received);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10e0, %rsp           # imm = 0x10E0
movq %rsi, %rdx
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10c0(%rbp)
leaq 0x41d1(%rip), %rsi      # 0xc509
leaq -0x50(%rbp), %rdi
movq %rdi, -0x10b8(%rbp)
callq 0xa180
movq -0x10b8(%rbp), %rsi
leaq 0x3d92(%rip), %rdx      # 0xc0e8
leaq -0x30(%rbp), %rdi
callq 0xa130
jmp 0x8361
leaq -0x50(%rbp), %rdi
callq 0x3628
leaq -0x30(%rbp), %rdi
callq 0x3190
movq %rax, %rsi
leaq -0x860(%rbp), %rdi
movq %rdi, -0x10c8(%rbp)
callq 0x3320
movq -0x10c8(%rbp), %rsi
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x31d0
jmp 0x83a7
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
leaq -0x1060(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3140
jmp 0x83c5
leaq -0x1081(%rbp), %rdi
movq %rdi, -0x10d0(%rbp)
callq 0x3570
movq -0x10d0(%rbp), %rdx
leaq 0x3e7f(%rip), %rsi      # 0xc265
leaq -0x1080(%rbp), %rdi
callq 0x69b0
jmp 0x83f4
leaq -0x10a9(%rbp), %rdi
movq %rdi, -0x10d8(%rbp)
callq 0x3570
movq -0x10d8(%rbp), %rdx
leaq -0x10a8(%rbp), %rdi
leaq -0x1060(%rbp), %rsi
callq 0x69b0
jmp 0x8423
movq -0x10c0(%rbp), %rdi
leaq -0x1080(%rbp), %rsi
leaq -0x10a8(%rbp), %rdx
callq 0x7850
jmp 0x843f
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
addq $0x10e0, %rsp           # imm = 0x10E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x8507
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x84fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x84f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x84da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
movq -0x58(%rbp), %rdi
callq 0x3560
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::cat_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::cat_rpc(string fname) {
  // to implement
  string command = "cat " + fname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("cat", received);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10e0, %rsp           # imm = 0x10E0
movq %rsi, %rdx
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10c0(%rbp)
leaq 0x3fb9(%rip), %rsi      # 0xc511
leaq -0x50(%rbp), %rdi
movq %rdi, -0x10b8(%rbp)
callq 0xa180
movq -0x10b8(%rbp), %rsi
leaq 0x3b72(%rip), %rdx      # 0xc0e8
leaq -0x30(%rbp), %rdi
callq 0xa130
jmp 0x8581
leaq -0x50(%rbp), %rdi
callq 0x3628
leaq -0x30(%rbp), %rdi
callq 0x3190
movq %rax, %rsi
leaq -0x860(%rbp), %rdi
movq %rdi, -0x10c8(%rbp)
callq 0x3320
movq -0x10c8(%rbp), %rsi
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x31d0
jmp 0x85c7
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
leaq -0x1060(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3140
jmp 0x85e5
leaq -0x1081(%rbp), %rdi
movq %rdi, -0x10d0(%rbp)
callq 0x3570
movq -0x10d0(%rbp), %rdx
leaq 0x3c6d(%rip), %rsi      # 0xc273
leaq -0x1080(%rbp), %rdi
callq 0x69b0
jmp 0x8614
leaq -0x10a9(%rbp), %rdi
movq %rdi, -0x10d8(%rbp)
callq 0x3570
movq -0x10d8(%rbp), %rdx
leaq -0x10a8(%rbp), %rdi
leaq -0x1060(%rbp), %rsi
callq 0x69b0
jmp 0x8643
movq -0x10c0(%rbp), %rdi
leaq -0x1080(%rbp), %rsi
leaq -0x10a8(%rbp), %rdx
callq 0x7850
jmp 0x865f
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
addq $0x10e0, %rsp           # imm = 0x10E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x8727
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x871e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x86fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
movq -0x58(%rbp), %rdi
callq 0x3560
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::rm_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::rm_rpc(string fname) {
  string command = "rm " + fname + "\r\n";
  char message[2048];
  char received[2048];
  strcpy(message, command.c_str());

  // send to server
  send(cs_sock, message, sizeof(message), 0);
  recv(cs_sock, received, sizeof(received), 0);

  // print
  print_response("rm", received);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10e0, %rsp           # imm = 0x10E0
movq %rsi, %rdx
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10c0(%rbp)
leaq 0x3b24(%rip), %rsi      # 0xc51c
leaq -0x50(%rbp), %rdi
movq %rdi, -0x10b8(%rbp)
callq 0xa180
movq -0x10b8(%rbp), %rsi
leaq 0x36d2(%rip), %rdx      # 0xc0e8
leaq -0x30(%rbp), %rdi
callq 0xa130
jmp 0x8a21
leaq -0x50(%rbp), %rdi
callq 0x3628
leaq -0x30(%rbp), %rdi
callq 0x3190
movq %rax, %rsi
leaq -0x860(%rbp), %rdi
movq %rdi, -0x10c8(%rbp)
callq 0x3320
movq -0x10c8(%rbp), %rsi
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x31d0
jmp 0x8a67
movq -0x10c0(%rbp), %rax
movl (%rax), %edi
leaq -0x1060(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3140
jmp 0x8a85
leaq -0x1081(%rbp), %rdi
movq %rdi, -0x10d0(%rbp)
callq 0x3570
movq -0x10d0(%rbp), %rdx
leaq 0x380d(%rip), %rsi      # 0xc2b3
leaq -0x1080(%rbp), %rdi
callq 0x69b0
jmp 0x8ab4
leaq -0x10a9(%rbp), %rdi
movq %rdi, -0x10d8(%rbp)
callq 0x3570
movq -0x10d8(%rbp), %rdx
leaq -0x10a8(%rbp), %rdi
leaq -0x1060(%rbp), %rsi
callq 0x69b0
jmp 0x8ae3
movq -0x10c0(%rbp), %rdi
leaq -0x1080(%rbp), %rsi
leaq -0x10a8(%rbp), %rdx
callq 0x7850
jmp 0x8aff
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
addq $0x10e0, %rsp           # imm = 0x10E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x8bc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8bbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8bb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8b9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x10a8(%rbp), %rdi
callq 0x3628
leaq -0x10a9(%rbp), %rdi
callq 0x33b0
leaq -0x1080(%rbp), %rdi
callq 0x3628
leaq -0x1081(%rbp), %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x3628
movq -0x58(%rbp), %rdi
callq 0x3560
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::stat_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::stat_rpc(string fname)
{
  string command = "stat " + fname + "\r\n";
  char* buffer[2048];
  send(cs_sock, command.c_str(), strlen(command.c_str()), 0);
  recv(cs_sock, buffer, sizeof(buffer), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4090, %rsp           # imm = 0x4090
movq %rsi, %rdx
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x4070(%rbp)
leaq 0x3928(%rip), %rsi      # 0xc520
leaq -0x50(%rbp), %rdi
movq %rdi, -0x4068(%rbp)
callq 0xa180
movq -0x4068(%rbp), %rsi
leaq 0x34d2(%rip), %rdx      # 0xc0e8
leaq -0x30(%rbp), %rdi
callq 0xa130
jmp 0x8c21
leaq -0x50(%rbp), %rdi
callq 0x3628
movq -0x4070(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x407c(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x4088(%rbp)
callq 0x3190
movq -0x4088(%rbp), %rdi
movq %rax, -0x4078(%rbp)
callq 0x3190
movq %rax, %rdi
callq 0x31b0
movl -0x407c(%rbp), %edi
movq -0x4078(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
jmp 0x8c7d
movq -0x4070(%rbp), %rax
movl (%rax), %edi
leaq -0x4060(%rbp), %rsi
movl $0x4000, %edx           # imm = 0x4000
xorl %ecx, %ecx
callq 0x3140
jmp 0x8c9b
leaq -0x30(%rbp), %rdi
callq 0x3628
addq $0x4090, %rsp           # imm = 0x4090
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x8cd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3628
movq -0x58(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::run()
void Shell::run()
{
  // make sure that the file system is mounted
  if (!is_mounted)
 	return;

  // continue until the user quits
  bool user_quit = false;
  while (!user_quit) {

    // print prompt and get command line
    string command_str;
    cout << PROMPT_STRING;
    getline(cin, command_str);

    // execute the command
    user_quit = execute_command(command_str);
  }

  // unmount the file system
  unmountNFS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, 0x4(%rax)
jne 0x8d0f
jmp 0x8dc5
movb $0x0, -0x9(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8d21
jmp 0x8dbc
leaq -0x30(%rbp), %rdi
callq 0x3470
movq 0x728f(%rip), %rdi      # 0xffc0
leaq 0x7600(%rip), %rsi      # 0x10338
callq 0x3310
jmp 0x8d3f
movq 0x7292(%rip), %rdi      # 0xffd8
leaq -0x30(%rbp), %rsi
callq 0x30c0
jmp 0x8d51
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31a0
jmp 0x8d60
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8de0
movb %al, -0x69(%rbp)
jmp 0x8d72
movb -0x69(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3628
leaq -0x30(%rbp), %rdi
callq 0x3628
jmp 0x8d13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8db1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3628
leaq -0x30(%rbp), %rdi
callq 0x3628
jmp 0x8dcb
movq -0x68(%rbp), %rdi
callq 0x7610
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utilsSt.cpp
// Function: writeSolverInfo(_IO_FILE*, task*)
void writeSolverInfo(FILE *fid, struct task *task) {
    // solver id
    if( task->solver_setting>0 ) {
        fprintf(fid,"SolverId\t%d.%d.%d\n",task->structure,task->solver,task->solver_setting);
    } else {
        fprintf(fid,"SolverId\t%d.%d\n",task->structure,task->solver);
    }
	// nK
    fprintf(fid,"nK\t%d\n",task->nK);
    // nG
    fprintf(fid,"nG\t%d\n",task->nG);
    // nS
    fprintf(fid,"nS\t%d\n",task->nS);
    // nO
    fprintf(fid,"nO\t%d\n",task->nO);
    // nZ
    fprintf(fid,"nZ\t%d\n",task->nZ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x50(%rax), %eax
cmpl $0x0, %eax
jle 0x97da
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x4e(%rax), %edx
movq -0x10(%rbp), %rax
movsbl 0x4f(%rax), %ecx
movq -0x10(%rbp), %rax
movsbl 0x50(%rax), %r8d
leaq 0x12430(%rip), %rsi     # 0x1bc01
movb $0x0, %al
callq 0x33c0
jmp 0x97fc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x4e(%rax), %edx
movq -0x10(%rbp), %rax
movsbl 0x4f(%rax), %ecx
leaq 0x1241f(%rip), %rsi     # 0x1bc14
movb $0x0, %al
callq 0x33c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x908(%rax), %edx
leaq 0x12413(%rip), %rsi     # 0x1bc24
movb $0x0, %al
callq 0x33c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x904(%rax), %edx
leaq 0x123fe(%rip), %rsi     # 0x1bc2b
movb $0x0, %al
callq 0x33c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x900(%rax), %edx
leaq 0x123e8(%rip), %rsi     # 0x1bc32
movb $0x0, %al
callq 0x33c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x901(%rax), %edx
leaq 0x123d2(%rip), %rsi     # 0x1bc39
movb $0x0, %al
callq 0x33c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x910(%rax), %edx
leaq 0x123bc(%rip), %rsi     # 0x1bc40
movb $0x0, %al
callq 0x33c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utilsSt.cpp
// Function: getSkillsAtRow(task*, int, int**, signed char*)
void getSkillsAtRow(struct task *task, NDAT t, NCAT **ar, NPAR *n){
    NCAT k;
    if(task->multiskill==0) {
        k = task->dat_skill[t];
        *ar = &k;
        *n = 1;
    } else {
        k = task->dat_skill_stacked[ task->dat_skill_rix[t] ];
        *ar = &task->dat_skill_stacked[ task->dat_skill_rix[t] ];
        *n = (NPAR)task->dat_skill_rcount[t];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x920(%rax), %eax
cmpl $0x0, %eax
jne 0x9d2c
movq -0x8(%rbp), %rax
movq 0x898(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
leaq -0x24(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
jmp 0x9d96
movq -0x8(%rbp), %rax
movq 0x8a0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8b0(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x8a0(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8b0(%rax), %rax
movslq -0xc(%rbp), %rdx
movslq (%rax,%rdx,4), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSt.cpp
// Function: FitBitSt::~FitBitSt()
FitBitSt::~FitBitSt() {
    // this->PARAM is external reference, do not destroy it
    if(this->PARAMm1 != NULL) free(this->PARAMm1);
    if(this->PARAMm2 != NULL) free(this->PARAMm2);
//    if(this->GRAD != NULL) free(this->GRAD); is external reference, do not destroy it
    if(this->GRADm1 != NULL) free(this->GRADm1);
    if(this->GRADcopy != NULL) free(this->GRADcopy);
    if(this->PARAMcopy != NULL) free(this->PARAMcopy);
    if(this->DIR != NULL) free(this->DIR);
    if(this->DIRm1 != NULL) free(this->DIRm1);
    
    delete [] this->fit_results;

    if(this->sclsmplx_offsets != NULL) free(this->sclsmplx_offsets);
    if(this->sclsmplx_sizes != NULL) free(this->sclsmplx_sizes);
    if(this->sclsmplx_blocks != NULL) free(this->sclsmplx_blocks);
    if(this->param_blocks != NULL) free(this->param_blocks);
    if(this->sclsmplx_bound_offsets != NULL) free(this->sclsmplx_bound_offsets);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x18(%rax)
je 0xae28
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xae40
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xae58
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xae70
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xae88
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xaea0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xaeb8
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xaed3
movq -0x18(%rbp), %rdi
callq 0x3370
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0xaef1
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0xaf0f
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0xaf2d
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0xaf4b
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0xaf69
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x3320
addq $0x20, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/FitBitSt.cpp
// Function: FitBitSt::printFitResult(int)
void FitBitSt::printFitResult(NCAT k) {
    if(k==-1) {
        printf(" all skills, dat %8d, iter#%3d p(O|param)= %15.7f >> %15.7f, conv=%d\n", this->fit_result.ndat, this->fit_result.iter, this->fit_result.pO0_prefit, this->fit_result.pO, this->fit_result.conv);
    } else {
        printf("skill %5d, dat %8d, iter#%3d p(O|param)= %15.7f >> %15.7f, conv=%d\n", k, this->fit_results[k].ndat, this->fit_results[k].iter, this->fit_results[k].pO0_prefit, this->fit_results[k].pO, this->fit_results[k].conv);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0xafbb
movq -0x18(%rbp), %rax
movl 0x84(%rax), %esi
movl 0x60(%rax), %edx
movsd 0x68(%rax), %xmm0
movsd 0x78(%rax), %xmm1
movsbl 0x80(%rax), %ecx
leaq 0x10e17(%rip), %rdi     # 0x1bdc9
movb $0x2, %al
callq 0x3060
jmp 0xb02f
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movl 0x24(%rcx), %edx
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdi
imulq $0x28, %rdi, %rdi
addq %rdi, %rcx
movl (%rcx), %ecx
movq 0x58(%rax), %rdi
movslq -0xc(%rbp), %r8
imulq $0x28, %r8, %r8
addq %r8, %rdi
movsd 0x8(%rdi), %xmm0
movq 0x58(%rax), %rdi
movslq -0xc(%rbp), %r8
imulq $0x28, %r8, %r8
addq %r8, %rdi
movsd 0x18(%rdi), %xmm1
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rdi
imulq $0x28, %rdi, %rdi
addq %rdi, %rax
movsbl 0x20(%rax), %r8d
leaq 0x10de7(%rip), %rdi     # 0x1be0f
movb $0x2, %al
callq 0x3060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSt.cpp
// Function: FitBitSt::checkConvergenceBitSingle(int, int, FitResult*)
NPAR FitBitSt::checkConvergenceBitSingle(NDAT offset, NDAT size, FitResult *fr) {
    NCAT i;
    NUMBER criterion = 0;
    NPAR res = 0;
    if(fr->pO0==fr->pO) {
        res = 1;
    } else {
        switch (this->tol_mode) {
            case 'p':
                for(i=offset; i<(offset+size); i++) {
                    criterion += pow( this->PARAM[i]-this->PARAMm1[i], 2 );
                }
                res = 1*(criterion < this->tol);
                break;
            case 'l':
                criterion = (fr->pO0-fr->pO)/fr->ndat;
                res = 1*(criterion < this->tol);
                break;
        }
    }
    fr->conv = res;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jne 0xb2a9
jp 0xb2a9
movb $0x1, -0x29(%rbp)
jmp 0xb38e
movq -0x38(%rbp), %rax
movsbl 0xd0(%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x6c, %eax
je 0xb345
jmp 0xb2c2
movl -0x3c(%rbp), %eax
subl $0x70, %eax
jne 0xb38c
jmp 0xb2d0
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0xb320
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0xb8b0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb2d6
movq -0x38(%rbp), %rax
movsd -0x28(%rbp), %xmm1
movsd 0xc8(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
shll $0x0, %eax
movb %al, -0x29(%rbp)
jmp 0xb38c
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movq -0x18(%rbp), %rcx
subsd 0x18(%rcx), %xmm0
movq -0x18(%rbp), %rcx
cvtsi2sdl 0x24(%rcx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd 0xc8(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
shll $0x0, %eax
movb %al, -0x29(%rbp)
jmp 0xb38e
movb -0x29(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x20(%rax)
movb -0x29(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSt.cpp
// Function: FitBitSt::checkConvergence(int, int*, int*, int*, signed char*)
NCAT FitBitSt::checkConvergence(NCAT nbits, NDAT *offsets, NDAT* sizes, NCAT* blocks, NPAR *condition){
    NCAT n_conv = 0;
    bool res;
    for(NCAT i=0; i<nbits; i++) {
        if( condition[ blocks[i] ]==1 ) {
            res = checkConvergenceBit(offsets[i], sizes[i], &this->fit_results[i]);
//            if(blocks[i]<0 || blocks[i]>this->nK) {
//                int a = 0;
//            } // DEBUG
            condition[ blocks[i] ] = !res; // set active set value
        } else {
            res = 1;
        }
        n_conv += res;
    }
    return n_conv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb480
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0xb460
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x58(%rdi), %rcx
movslq -0x3c(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
callq 0xb040
cmpb $0x0, %al
setne %al
andb $0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %dl
xorb $-0x1, %dl
andb $0x1, %dl
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x3c(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movb %dl, (%rax,%rcx)
jmp 0xb464
movb $0x1, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb3e5
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBitSt.cpp
// Function: FitBitSt::checkConvergenceSingle(int, int*, int*, int*, signed char*)
NCAT FitBitSt::checkConvergenceSingle(NCAT nbits, NDAT *offsets, NDAT* sizes, NCAT* blocks, NPAR *condition) {
    NCAT n_conv = 0;
    bool res;
    for(NCAT i=0; i<nbits; i++) {
        if( condition[ blocks[i] ]==1 ) {
            res = checkConvergenceBitSingle(offsets[i], sizes[i], &this->fit_results[i]);
//            if(blocks[i]<0 || blocks[i]>this->nK) {
//                int a = 0;
//            } // DEBUG
            condition[ blocks[i] ] = !res; // set active set value
        } else {
            res = 1;
        }
        n_conv += res;
    }
    return n_conv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb560
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0xb540
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x58(%rdi), %rcx
movslq -0x3c(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
callq 0xb260
cmpb $0x0, %al
setne %al
andb $0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %dl
xorb $-0x1, %dl
andb $0x1, %dl
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x3c(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movb %dl, (%rax,%rcx)
jmp 0xb544
movb $0x1, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb4c5
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBitSt.cpp
// Function: FitBitSt::scaleGradients(bool, signed char*)
void FitBitSt::scaleGradients(bool direction, NPAR* condition) {
    NUMBER *TOSCALE = NULL;
    if(!direction) TOSCALE = this->GRAD;
    else TOSCALE = this->DIR;
    
    if(this->sclsmplx_n<=0 || this->sclsmplx_sizes==NULL || this->sclsmplx_offsets==NULL || this->sclsmplx_blocks==NULL) {
        fprintf(stderr,"Error, gradient scaling affordances were nnot created.\n");
        exit(1);
    }
    for(NCAT i=0; i<this->sclsmplx_n; i++) {
        if( condition[ this->sclsmplx_blocks[i] ]>0 ) {
            doLog10Scale1DGentle(&TOSCALE[ this->sclsmplx_offsets[i] ],
                                 &this->PARAM[ this->sclsmplx_offsets[i] ],
                                 this->sclsmplx_sizes[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xb5ac
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xb5b8
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
jle 0xb5ef
movq -0x30(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0xb5ef
movq -0x30(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0xb5ef
movq -0x30(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
jne 0xb611
movq 0x169e2(%rip), %rax     # 0x21fd8
movq (%rax), %rdi
leaq 0x10853(%rip), %rsi     # 0x1be53
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0xc0(%rcx), %eax
jge 0xb6a3
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0xb0(%rcx), %rcx
movslq -0x24(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jle 0xb693
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x98(%rax), %rcx
movslq -0x24(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rsi
movq 0x98(%rax), %rcx
movslq -0x24(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq 0xa8(%rax), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edx
callq 0x81d0
jmp 0xb695
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb618
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/./utilsSt.h
// Function: double** initToValue2D<double>(int, int, double)
T** initToValue2D(NDAT size1, NDAT size2, T val) {
    T** ar = (T **)Calloc(T *, (size_t)size1);
    for(NDAT i=0; i<size1; i++) {
        ar[i] = (T *)Calloc(T, (size_t)size2);
        for(NDAT j=0; j<size2; j++)
            ar[i][j] = val;
    }
    return ar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x3170
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xf422
movslq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3170
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xf415
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xf3e8
jmp 0xf417
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf3bc
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::fromFileToArray(_IO_FILE*, int)
T* StripedArray<T>::fromFileToArray(FILE *f, NDAT N){
    T *result = (T*)malloc( (size_t)N*sizeof(T));
    NDAT nread = (NDAT)fread (result, sizeof(T), (size_t)N, f);
    if(nread != N) {
        fprintf(stderr,"Error reading data from file\n");
        return NULL;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x0, %rdi
callq 0x3380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x33e0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xf6b3
movq 0x12940(%rip), %rax     # 0x21fd8
movq (%rax), %rdi
leaq 0xcc0b(%rip), %rsi      # 0x1c2ad
movb $0x0, %al
callq 0x33c0
movq $0x0, -0x8(%rbp)
jmp 0xf6bb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::HMMProblemSt(task*)
HMMProblemSt::HMMProblemSt(struct task *task) {
//    printf("HMMProblemSt::HMMProblemSt\n");
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    this->model_param_n = task->nK * 4;
    init(task);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x108ad(%rip), %rax     # 0x21bd8
addq $0x10, %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x908(%rax), %eax
shll $0x2, %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x70(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)