LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x408, %rsp            # imm = 0x408
movw $0x1, 0x4(%rdi)
movups 0x43cb(%rip), %xmm0     # 0x8123
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movabsq $0xa0d0a0d30203a, %rax  # imm = 0xA0D0A0D30203A
movq %rax, 0xf(%rsi)
movl 0x8(%rdi), %edi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x3170
addq $0x408, %rsp            # imm = 0x408
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dmonaldo[P]simple-network-file-system/FileSys.cpp
// Function: FileSys::ls()
void FileSys::ls()
{
  char bufferStart[] = "200 OK\r\n";
  string buffer = "";
  char msg[2048];
  char msgLength[80];
  dirblock_t curr_block_ptr;
  char curr_file_name[MAX_FNAME_SIZE + 1];
  //read the data held at the current directory from the disk
  bfs.read_block(curr_dir, (void*)&curr_block_ptr);
  for (unsigned int i = 0; i < MAX_DIR_ENTRIES; i++){
    if(curr_block_ptr.dir_entries[i].block_num > 0){
      if(is_directory(curr_block_ptr.dir_entries[i].block_num)){
        string temp(curr_block_ptr.dir_entries[i].name);
        buffer += temp;
        buffer += "/ ";
      }
      else{
        string temp2(curr_block_ptr.dir_entries[i].name);
        buffer += temp2;
        buffer += " ";
      }
    }
  }
  strcpy(msg, bufferStart);
  sprintf(msgLength, "Length: %d", sizeof(buffer.c_str()));
  strcat(msg, msgLength);
  strcat(msg, "\r\n\r\n");
  strcat(msg, buffer.c_str());
  send(fs_sock, msg, sizeof(msg), 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x928, %rsp            # imm = 0x928
movq %rdi, %rbx
leaq 0x417b(%rip), %rsi      # 0x80ea
leaq 0x10(%rsp), %rdi
leaq 0x120(%rsp), %rdx
callq 0x5296
movswl 0x4(%rbx), %esi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x380e
pushq $-0x78
popq %r13
leaq 0x30(%rsp), %r14
leaq 0xf(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x41e7(%rip), %rbp      # 0x8193
testq %r13, %r13
je 0x4036
movzwl 0xda(%rsp,%r13), %eax
testw %ax, %ax
jle 0x402d
movswl %ax, %esi
movq %rbx, %rdi
callq 0x3d22
leaq (%rsp,%r13), %rsi
addq $0xd0, %rsi
testb %al, %al
je 0x4004
movq %r14, %rdi
movq %r15, %rdx
callq 0x5296
movq %r12, %rdi
movq %r14, %rsi
callq 0x3470
movq %r12, %rdi
leaq 0x4195(%rip), %rsi      # 0x8192
callq 0x3460
jmp 0x4025
movq %r14, %rdi
movq %r15, %rdx
callq 0x5296
movq %r12, %rdi
movq %r14, %rsi
callq 0x3470
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3460
movq %r14, %rdi
callq 0x3498
addq $0xc, %r13
jmp 0x3fac
movabsq $0xa0d4b4f20303032, %rax # imm = 0xA0D4B4F20303032
leaq 0x120(%rsp), %r14
movq %rax, (%r14)
xorl %ebp, %ebp
movb %bpl, 0x8(%r14)
leaq 0x413d(%rip), %rsi      # 0x8195
leaq 0xd0(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x3070
movq %r14, %rdi
movq %r15, %rsi
callq 0x3420
movq %r14, %rdi
callq 0x3140
movb %bpl, 0x124(%rsp,%rax)
movl $0xa0d0a0d, 0x120(%rsp,%rax) # imm = 0xA0D0A0D
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x3420
movl 0x8(%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
leaq 0x10(%rsp), %rdi
callq 0x3498
addq $0x928, %rsp            # imm = 0x928
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40e5
jmp 0x40e5
jmp 0x40e5
jmp 0x40d6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x40e8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::mountNFS(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::mountNFS(string fs_loc) {
  struct sockaddr_in server;

  // parse filesystem location into array with servername and port
  vector<string> fs_address;
  size_t pos = 0, found;
  while((found = fs_loc.find_first_of(':', pos)) != string::npos) {
    fs_address.push_back(fs_loc.substr(pos, found - pos));
    pos = found+1;
  }
  fs_address.push_back(fs_loc.substr(pos));

  // create the socket
  cs_sock = socket(AF_INET, SOCK_STREAM, 0);
  if (cs_sock < 0) {
    perror("ERROR creating socket");
    exit(0);
  }
  cout << "Socket created\n";

  // construct server address
  server.sin_addr.s_addr = inet_addr(fs_address[0].c_str());
  server.sin_family = AF_INET;
  server.sin_port = htons(stoi(fs_address[1]));

  // connect to remote server
  if (connect(cs_sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
    perror("ERROR connection failed");
    exit(0);
  }

  cout << "Connected\n";
  is_mounted = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
xorl %ebx, %ebx
pushq $0x3a
popq %rbp
leaq 0x28(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x3330
cmpq $-0x1, %rax
je 0x56e0
movq %rax, %r13
movq %rax, %rcx
subq %rbx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x32b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x713a
movq %r12, %rdi
callq 0x3498
incq %r13
movq %r13, %rbx
jmp 0x569b
leaq 0x28(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x32b0
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x713a
movq 0x20(%rsp), %rbx
leaq 0x28(%rsp), %rdi
callq 0x3498
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x30a0
movl %eax, (%rbx)
testl %eax, %eax
js 0x57ab
movq 0x5893(%rip), %rdi      # 0xafc0
leaq 0x2d84(%rip), %rsi      # 0x84b8
callq 0x3270
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x3290
movl %eax, 0x4c(%rsp)
movw $0x2, 0x48(%rsp)
movq (%rsp), %rdi
addq $0x20, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x6dfe
rolw $0x8, %ax
leaq 0x48(%rsp), %rsi
movw %ax, 0x2(%rsi)
movl (%rbx), %edi
pushq $0x10
popq %rdx
callq 0x3220
testl %eax, %eax
js 0x57b4
movq 0x583c(%rip), %rdi      # 0xafc0
leaq 0x2d55(%rip), %rsi      # 0x84e0
callq 0x3270
movb $0x1, 0x4(%rbx)
movq %rsp, %rdi
callq 0x6e1a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cf0(%rip), %rdi      # 0x84a2
jmp 0x57bb
leaq 0x2d0d(%rip), %rdi      # 0x84c8
callq 0x3230
xorl %edi, %edi
callq 0x32f0
jmp 0x57d2
jmp 0x57cd
jmp 0x57cd
movq %rax, %rbx
jmp 0x57df
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3498
movq %rsp, %rdi
callq 0x6e1a
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2ccc(%rip), %rsi      # 0x84eb
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x6e5a
leaq 0x28b5(%rip), %rdx      # 0x80e8
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x6e3b
leaq 0x70(%rsp), %rdi
callq 0x3498
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x870(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x29c4(%rip), %rsi      # 0x824e
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x10(%rsp), %rdi
leaq 0x870(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5928
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x58fa
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x5915
jmp 0x5912
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x591a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::print_response(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Shell::print_response(string command, string response)
{
  stringstream ss(response);
  string item;
  vector<string> splitResponse;

  // split response by line breaks into an array of strings
  while (getline(ss, item, '\n')) {
     splitResponse.push_back(item);
  }

  // check if response was successful
  if (stoi(response.substr(0,3)) == 200) {
    if (command == "ls" ||
        command == "head" ||
        command == "stat" ||
        command == "cat") {
      cout << splitResponse[3] << endl;
    }
  } else {
    cout << response << endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x60(%rsp), %r15
pushq $0x18
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x33c0
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %r12
andq $0x0, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
leaq 0x40(%rsp), %r13
pushq $0xa
popq %rbp
movq %r15, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x3440
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x59a4
movq %r12, %rdi
movq %r13, %rsi
callq 0x6fe6
jmp 0x597c
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0x32b0
leaq 0x20(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x6dfe
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x3498
cmpl $0xc8, %ebp
jne 0x5a2d
leaq 0x2882(%rip), %rsi      # 0x8262
movq %rbx, %rdi
callq 0x52d1
testb %al, %al
jne 0x5a25
leaq 0x2884(%rip), %rsi      # 0x8277
movq %rbx, %rdi
callq 0x52d1
testb %al, %al
jne 0x5a25
leaq 0x28b0(%rip), %rsi      # 0x82b6
movq %rbx, %rdi
callq 0x52d1
testb %al, %al
jne 0x5a25
leaq 0x285a(%rip), %rsi      # 0x8273
movq %rbx, %rdi
callq 0x52d1
testb %al, %al
je 0x5a44
movq (%rsp), %r14
addq $0x60, %r14
movq 0x558c(%rip), %rdi      # 0xafc0
movq %r14, %rsi
callq 0x3250
movq %rax, %rdi
callq 0x3160
movq %rsp, %rdi
callq 0x6e1a
leaq 0x40(%rsp), %rdi
callq 0x3498
leaq 0x60(%rsp), %rdi
callq 0x31f0
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3498
jmp 0x5a88
jmp 0x5a85
jmp 0x5a85
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6e1a
leaq 0x40(%rsp), %rdi
callq 0x3498
leaq 0x60(%rsp), %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2a2f(%rip), %rsi      # 0x84f2
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x6e5a
leaq 0x2611(%rip), %rdx      # 0x80e8
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x6e3b
leaq 0x70(%rsp), %rdi
callq 0x3498
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x870(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x2726(%rip), %rsi      # 0x8254
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x10(%rsp), %rdi
leaq 0x870(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5928
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x5b9e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x5bb9
jmp 0x5bb6
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x5bbe
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x948, %rsp            # imm = 0x948
movq %rdi, %rbx
leaq 0x2916(%rip), %rsi      # 0x84f6
leaq 0x50(%rsp), %r14
leaq 0x140(%rsp), %rdx
movq %r14, %rdi
callq 0x5296
movq (%r14), %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0xc8, %edx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x140(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x2624(%rip), %rsi      # 0x8257
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x10(%rsp), %rdi
leaq 0x140(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5928
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
addq $0x948, %rsp            # imm = 0x948
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x5ca3
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x5cb4
jmp 0x5cb1
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2820(%rip), %rsi      # 0x84fd
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x6e5a
leaq 0x23f7(%rip), %rdx      # 0x80e8
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x6e3b
leaq 0x70(%rsp), %rdi
callq 0x3498
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x870(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x2514(%rip), %rsi      # 0x825c
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x10(%rsp), %rdi
leaq 0x870(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5928
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x5db8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x5dd3
jmp 0x5dd0
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x5dd8
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movq %rdi, %rbx
leaq 0x270a(%rip), %rsi      # 0x8504
leaq 0x50(%rsp), %r14
leaq 0x870(%rsp), %rdx
movq %r14, %rdi
callq 0x5296
movq (%r14), %rsi
leaq 0x870(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x70(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x2415(%rip), %rsi      # 0x8262
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5928
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x5eba
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x5ecb
jmp 0x5ec8
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2614(%rip), %rsi      # 0x8509
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x6e5a
leaq 0x21df(%rip), %rdx      # 0x80e8
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x6e3b
leaq 0x70(%rsp), %rdi
callq 0x3498
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x870(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x2305(%rip), %rsi      # 0x8265
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x10(%rsp), %rdi
leaq 0x870(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5928
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x5fd0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x5feb
jmp 0x5fe8
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x5ff0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x24fa(%rip), %rsi      # 0x8511
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x6e5a
leaq 0x20bd(%rip), %rdx      # 0x80e8
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x6e3b
leaq 0x70(%rsp), %rdi
callq 0x3498
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x870(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x21f1(%rip), %rsi      # 0x8273
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x10(%rsp), %rdi
leaq 0x870(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5928
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x60f2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x610d
jmp 0x610a
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x6112
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::head_rpc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Shell::head_rpc(string fname, int n) {
  // to implement
  string command = "head " + fname + to_string(n) + "\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("head", received);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1090, %rsp           # imm = 0x1090
movl %edx, %ebp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x23dc(%rip), %rsi      # 0x8516
leaq 0x90(%rsp), %rdi
callq 0x6e5a
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x6f37
leaq 0x890(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x6ed0
leaq 0x1f74(%rip), %rdx      # 0x80e8
leaq 0x70(%rsp), %rdi
leaq 0x890(%rsp), %rsi
callq 0x6e3b
leaq 0x890(%rsp), %rdi
callq 0x3498
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x90(%rsp), %rdi
callq 0x3498
movq 0x70(%rsp), %rsi
leaq 0x890(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x90(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x208a(%rip), %rsi      # 0x8277
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x5928
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
leaq 0x70(%rsp), %rdi
callq 0x3498
addq $0x1090, %rsp           # imm = 0x1090
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x625e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
jmp 0x629d
jmp 0x629a
movq %rax, %rbx
leaq 0x890(%rsp), %rdi
callq 0x3498
jmp 0x6281
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x6290
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x62a2
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2255(%rip), %rsi      # 0x851c
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x6e5a
leaq 0x1e0d(%rip), %rdx      # 0x80e8
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x6e3b
leaq 0x70(%rsp), %rdi
callq 0x3498
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x3260
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x870(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3100
leaq 0x1f81(%rip), %rsi      # 0x82b3
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5296
leaq 0x10(%rsp), %rdi
leaq 0x870(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x5296
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5928
leaq 0x10(%rsp), %rdi
callq 0x3498
leaq 0x30(%rsp), %rdi
callq 0x3498
leaq 0x50(%rsp), %rdi
callq 0x3498
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3498
jmp 0x63a2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3498
jmp 0x63bd
jmp 0x63ba
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x63c2
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x4020, %rsp           # imm = 0x4020
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2138(%rip), %rsi      # 0x8520
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6e5a
leaq 0x1cec(%rip), %rdx      # 0x80e8
movq %rsp, %rdi
movq %r14, %rsi
callq 0x6e3b
leaq 0x20(%rsp), %rdi
callq 0x3498
movl (%rbx), %ebp
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3140
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3170
movl (%rbx), %edi
leaq 0x20(%rsp), %rsi
movl $0x4000, %edx           # imm = 0x4000
xorl %ecx, %ecx
callq 0x3100
movq %rsp, %rdi
callq 0x3498
addq $0x4020, %rsp           # imm = 0x4020
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x6465
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x1, 0x4(%rdi)
jne 0x650a
movq %rdi, %rbx
leaq 0x4ddc(%rip), %r15      # 0xb270
movq 0x4b3d(%rip), %r12      # 0xafd8
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %rbp
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x4aff(%rip), %rdi      # 0xafc0
movq %r15, %rsi
callq 0x3250
movq %r12, %rdi
movq %r13, %rsi
callq 0x3080
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3340
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x653e
movl %eax, %r14d
movq %rbp, %rdi
callq 0x3498
movq %r13, %rdi
callq 0x3498
testb %r14b, %r14b
je 0x64a5
movq %rbx, %rdi
callq 0x57f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3498
jmp 0x652b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/dmonaldo[P]simple-network-file-system/Shell.cpp
// Function: Shell::run_script(char*)
void Shell::run_script(char *file_name)
{
  // make sure that the file system is mounted
  if (!is_mounted)
  	return;
  // open script file
  ifstream infile;
  infile.open(file_name);
  if (infile.fail()) {
    cerr << "Could not open script file" << endl;
    return;
  }


  // execute each line in the script
  bool user_quit = false;
  string command_str;
  getline(infile, command_str, '\n');
  while (!infile.eof() && !user_quit) {
    cout << PROMPT_STRING << command_str << endl;
    user_quit = execute_command(command_str);
    getline(infile, command_str);
  }

  // clean up
  unmountNFS();
  infile.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
cmpb $0x1, 0x4(%rdi)
jne 0x6a36
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x32d0
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x31b0
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rsp,%rax)
je 0x6972
movq 0x4697(%rip), %rdi      # 0xaff0
leaq 0x1bc6(%rip), %rsi      # 0x8526
callq 0x3270
movq %rax, %rdi
callq 0x3160
jmp 0x6a2c
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
pushq $0xa
popq %rdx
callq 0x3440
xorl %r14d, %r14d
leaq 0x48d3(%rip), %r15      # 0xb270
movq %rsp, %r12
leaq 0x20(%rsp), %r13
leaq 0x40(%rsp), %rbp
testb $0x1, %r14b
jne 0x6a12
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x60(%rsp,%rax), %eax
andl $0x2, %eax
jne 0x6a12
movq 0x45f7(%rip), %rdi      # 0xafc0
movq %r15, %rsi
callq 0x3250
movq %rax, %rdi
movq %r12, %rsi
callq 0x3250
movq %rax, %rdi
callq 0x3160
movq %r13, %rdi
movq %r12, %rsi
callq 0x3340
movq %rbx, %rdi
movq %r13, %rsi
callq 0x653e
movl %eax, %r14d
movq %r13, %rdi
callq 0x3498
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3080
jmp 0x69aa
movq %rbx, %rdi
callq 0x57f0
leaq 0x40(%rsp), %rdi
callq 0x3090
movq %rsp, %rdi
callq 0x3498
leaq 0x40(%rsp), %rdi
callq 0x30b0
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a5e
movq %rax, %rbx
jmp 0x6a69
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3498
jmp 0x6a61
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3498
leaq 0x40(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0x50(%rsi), %r8d
testl %r8d, %r8d
jle 0x66d2
movsbl 0x4e(%r14), %edx
movsbl 0x4f(%r14), %ecx
leaq 0xa49b(%rip), %rsi      # 0x10b61
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32d0
jmp 0x66ed
movsbl 0x4e(%r14), %edx
movsbl 0x4f(%r14), %ecx
leaq 0xa491(%rip), %rsi      # 0x10b74
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32d0
movl 0x908(%r14), %edx
leaq 0xa489(%rip), %rsi      # 0x10b84
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32d0
movl 0x904(%r14), %edx
leaq 0xa478(%rip), %rsi      # 0x10b8b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32d0
movsbl 0x900(%r14), %edx
leaq 0xa466(%rip), %rsi      # 0x10b92
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32d0
movsbl 0x901(%r14), %edx
leaq 0xa454(%rip), %rsi      # 0x10b99
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32d0
movsbl 0x910(%r14), %edx
leaq 0xa442(%rip), %rsi      # 0x10ba0
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/utilsSt.cpp
// Function: readSolverInfo(_IO_FILE*, task*, int*)
void readSolverInfo(FILE *fid, struct task *task, NDAT *line_no) {
    string s;
    int c, i1, i2;
    // SolverId
    fscanf(fid,"SolverId\t%i.%i", &i1, &i2);
    task->structure = (NPAR) i1;
    task->solver    = (NPAR) i2;
    fscanf(fid,"SolverId\t%hhu.%hhu", &task->structure, &task->solver);
    c = fscanf(fid,".%hhu\n", &task->solver_setting);
    if( c<1 ) {
        fscanf(fid,"\n");
        task->solver_setting = -1;
    }
    (*line_no)++;
	// nK
    fscanf(fid,"nK\t%i\n",&task->nK);
    (*line_no)++;
    // nG
    fscanf(fid,"nG\t%i\n",&task->nG);
    (*line_no)++;
    // nS
    fscanf(fid,"nS\t%hhu\n",&task->nS);
    (*line_no)++;
    // nO
    fscanf(fid,"nO\t%hhu\n",&task->nO);
    (*line_no)++;
    // nZ
    fscanf(fid,"nZ\t%hhu\n",&task->nZ);
    (*line_no)++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xa40c(%rip), %rsi      # 0x10ba7
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
xorl %eax, %eax
callq 0x33c0
movb 0x4(%rsp), %al
leaq 0x4e(%r14), %rdx
movb %al, 0x4e(%r14)
movb (%rsp), %al
leaq 0x4f(%r14), %rcx
movb %al, 0x4f(%r14)
leaq 0xa3ee(%rip), %rsi      # 0x10bb6
movq %r15, %rdi
xorl %eax, %eax
callq 0x33c0
leaq 0x50(%r14), %r12
leaq 0xa3ec(%rip), %rsi      # 0x10bc9
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x33c0
testl %eax, %eax
jg 0x6804
leaq 0x9a85(%rip), %rsi      # 0x1027a
movq %r15, %rdi
xorl %eax, %eax
callq 0x33c0
movb $-0x1, (%r12)
incl (%rbx)
leaq 0x908(%r14), %rdx
leaq 0xa3bc(%rip), %rsi      # 0x10bd0
movq %r15, %rdi
xorl %eax, %eax
callq 0x33c0
incl (%rbx)
leaq 0x904(%r14), %rdx
leaq 0xa3a9(%rip), %rsi      # 0x10bd7
movq %r15, %rdi
xorl %eax, %eax
callq 0x33c0
incl (%rbx)
leaq 0x900(%r14), %rdx
leaq 0xa396(%rip), %rsi      # 0x10bde
movq %r15, %rdi
xorl %eax, %eax
callq 0x33c0
incl (%rbx)
leaq 0x901(%r14), %rdx
leaq 0xa385(%rip), %rsi      # 0x10be7
movq %r15, %rdi
xorl %eax, %eax
callq 0x33c0
incl (%rbx)
addq $0x910, %r14            # imm = 0x910
leaq 0xa374(%rip), %rsi      # 0x10bf0
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x33c0
incl (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x30e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x0, 0x920(%rdi)
je 0x6a4a
movq 0x8b0(%rdi), %rax
movslq %esi, %rsi
movslq (%rax,%rsi,4), %rax
shlq $0x2, %rax
addq 0x8a0(%rdi), %rax
movq %rax, (%rdx)
movq 0x8a8(%rdi), %rax
movb (%rax,%rsi,4), %al
jmp 0x6a54
leaq -0x4(%rsp), %rax
movq %rax, (%rdx)
movb $0x1, %al
movb %al, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x3230
movq 0x20(%rbx), %rdi
callq 0x3230
movq 0x38(%rbx), %rdi
callq 0x3230
movq 0x40(%rbx), %rdi
callq 0x3230
movq 0x28(%rbx), %rdi
callq 0x3230
movq 0x48(%rbx), %rdi
callq 0x3230
movq 0x50(%rbx), %rdi
callq 0x3230
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x7081
callq 0x3280
movq 0x98(%rbx), %rdi
callq 0x3230
movq 0xa8(%rbx), %rdi
callq 0x3230
movq 0xb0(%rbx), %rdi
callq 0x3230
movq 0xb8(%rbx), %rdi
callq 0x3230
movq 0xa0(%rbx), %rdi
popq %rbx
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/FitBitSt.cpp
// Function: FitBitSt::checkConvergenceBit(int, int, FitResult*)
NPAR FitBitSt::checkConvergenceBit(NDAT offset, NDAT size, FitResult *fr) {
    NUMBER criterion = 0;
    NUMBER criterion_oscil = 0; // oscillation between PAR and PARm1, i.e. PAR is close to PARm2
    NCAT i;
    NPAR res = 0;
    if (fr->iter >= this->task->first_iteration_qualify) {
        if( fr->pO0<=fr->pO) { // rough, won't go up
            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 );
                    }
                    if( (!(sqrt(criterion) < this->tol)) && ( this->PARAMm2 != NULL ) ) {
                        for(i=offset; i<(offset+size); i++) {
                            criterion_oscil += pow( this->PARAM[i]-this->PARAMm2[i], 2 )/*:0*/;
                        }
                        res = 1*(sqrt(criterion_oscil) < this->tol); // double the truth or false
                    }
                    else
                        res = 1*(sqrt(criterion) < this->tol); // double the truth or false
                    break;
                case 'l':
                    criterion = (fr->pO0-fr->pO)/fr->ndat;
                    res = 1*(criterion < this->tol);
                    break;
            }
        }
    }
    fr->conv = res;
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x88(%rdi), %rax
movsbl 0x980(%rax), %eax
cmpl %eax, (%rcx)
jge 0x7142
xorl %eax, %eax
jmp 0x724a
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
movb $0x1, %al
ucomisd %xmm0, %xmm1
jae 0x724a
movq %rdi, %r14
movzbl 0xd0(%rdi), %eax
cmpl $0x6c, %eax
je 0x71af
cmpl $0x70, %eax
jne 0x713b
addl %esi, %edx
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movslq %esi, %r15
movslq %edx, %r12
xorpd %xmm2, %xmm2
movq %r15, %rdx
cmpq %r12, %rdx
jge 0x719f
movsd (%rax,%rdx,8), %xmm0
subsd (%rcx,%rdx,8), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm2
incq %rdx
jmp 0x7183
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x71be
sqrtsd %xmm2, %xmm0
jmp 0x71d1
subsd %xmm1, %xmm0
cvtsi2sdl 0x24(%rbx), %xmm1
divsd %xmm1, %xmm0
jmp 0x723a
movapd %xmm2, %xmm0
movsd %xmm2, (%rsp)
callq 0x3160
movsd (%rsp), %xmm2
movsd 0xc8(%r14), %xmm1
ucomisd %xmm0, %xmm1
ja 0x720f
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x720f
movq 0x10(%r14), %rcx
xorpd %xmm0, %xmm0
cmpq %r12, %r15
jge 0x7225
movsd (%rcx,%r15,8), %xmm1
subsd (%rax,%r15,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r15
jmp 0x71f1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x721f
sqrtsd %xmm2, %xmm0
jmp 0x723a
movapd %xmm2, %xmm0
jmp 0x7235
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7235
sqrtsd %xmm0, %xmm0
jmp 0x723a
callq 0x3160
movsd 0xc8(%r14), %xmm1
ucomisd %xmm0, %xmm1
seta %al
movb %al, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd 0x10(%rcx), %xmm0
movsd 0x18(%rcx), %xmm1
movb $0x1, %al
ucomisd %xmm1, %xmm0
jne 0x726e
jnp 0x72d0
movzbl 0xd0(%rdi), %eax
cmpl $0x6c, %eax
je 0x72b0
cmpl $0x70, %eax
jne 0x72ce
addl %esi, %edx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r8
movslq %esi, %rsi
movslq %edx, %rdx
xorpd %xmm0, %xmm0
cmpq %rdx, %rsi
jge 0x72bd
movsd (%rax,%rsi,8), %xmm1
subsd (%r8,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0x7293
subsd %xmm1, %xmm0
cvtsi2sdl 0x24(%rcx), %xmm1
divsd %xmm1, %xmm0
movsd 0xc8(%rdi), %xmm1
ucomisd %xmm0, %xmm1
seta %al
jmp 0x72d0
xorl %eax, %eax
movb %al, 0x20(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r13
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %esi, %ebx
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %ebx
movq %rdi, (%rsp)
pushq $0x1
popq %rdx
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq %rbp, %rbx
je 0x7359
movslq (%r13,%rbp,4), %rax
cmpb $0x1, (%r14,%rax)
movl %edx, %ecx
jne 0x734d
movq 0x8(%rsp), %rax
movl (%rax,%rbp,4), %esi
movq 0x10(%rsp), %rax
movl (%rax,%rbp,4), %edx
movq (%rsp), %rdi
movq 0x58(%rdi), %rcx
addq %r12, %rcx
callq 0x711e
movzbl %al, %ecx
xorb $0x1, %al
movslq (%r13,%rbp,4), %rdx
movb %al, (%r14,%rdx)
pushq $0x1
popq %rdx
addl %ecx, %r15d
incq %rbp
addq $0x28, %r12
jmp 0x7309
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r13
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %esi, %ebx
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %ebx
movq %rdi, (%rsp)
pushq $0x1
popq %rdx
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq %rbp, %rbx
je 0x73f1
movslq (%r13,%rbp,4), %rax
cmpb $0x1, (%r14,%rax)
movl %edx, %ecx
jne 0x73e5
movq 0x8(%rsp), %rax
movl (%rax,%rbp,4), %esi
movq 0x10(%rsp), %rax
movl (%rax,%rbp,4), %edx
movq (%rsp), %rdi
movq 0x58(%rdi), %rcx
addq %r12, %rcx
callq 0x725a
movzbl %al, %ecx
xorb $0x1, %al
movslq (%r13,%rbp,4), %rdx
movb %al, (%r14,%rdx)
pushq $0x1
popq %rdx
addl %ecx, %r15d
incq %rbp
addq $0x28, %r12
jmp 0x73a1
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x30(%rdi), %rcx
leaq 0x48(%rdi), %rax
testl %esi, %esi
cmovneq %rax, %rcx
movl 0xc0(%rdi), %eax
testl %eax, %eax
jle 0x74ab
movq %rdi, %r14
cmpq $0x0, 0xa8(%rdi)
je 0x74ab
cmpq $0x0, 0x98(%r14)
je 0x74ab
cmpq $0x0, 0xb0(%r14)
je 0x74ab
movq %rdx, %rbx
movq (%rcx), %r15
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x749f
movq 0xb0(%r14), %rcx
movslq (%rcx,%r12,4), %rcx
cmpb $0x0, (%rbx,%rcx)
jle 0x749a
movq 0x98(%r14), %rax
movq 0xa8(%r14), %rcx
movslq (%rax,%r12,4), %rsi
leaq (%r15,%rsi,8), %rdi
shlq $0x3, %rsi
addq 0x10(%r14), %rsi
movsbl (%rcx,%r12), %edx
callq 0x5b77
movl 0xc0(%r14), %eax
incq %r12
jmp 0x7452
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xeb26(%rip), %rax      # 0x15fd8
movq (%rax), %rcx
leaq 0x98f7(%rip), %rdi      # 0x10db3
pushq $0x37
popq %rsi
pushq $0x1
popq %rdx
callq 0x3400
pushq $0x1
popq %rdi
callq 0x3240
nop