LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x38af(%rip), %rsi      # 0xa504
leaq 0x38ac(%rip), %rdx      # 0xa508
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x5d16
movq (%r14), %rsi
leaq 0x860(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x60(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x35b2(%rip), %rsi      # 0xa262
leaq 0x35ad(%rip), %rdx      # 0xa264
leaq 0x20(%rsp), %rdi
callq 0x5d16
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x60, %rdx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5d16
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x6418
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6d0e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6d25
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x6d3c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6d69
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6d69
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6d87
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6d87
jmp 0x6d84
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x6d9e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x3748(%rip), %rsi      # 0xa509
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8ae7
leaq 0x3313(%rip), %rsi      # 0xa0e8
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6e03
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6e0a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e3d
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x33e0(%rip), %rsi      # 0xa265
leaq 0x33df(%rip), %rdx      # 0xa26b
leaq 0x40(%rsp), %rdi
callq 0x5d16
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d16
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x6418
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6eee
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x6f05
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6f1b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6f49
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6f49
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x6f7f
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x6f7f
jmp 0x6f7c
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6f95
movq 0x70(%rsp), %rsi
jmp 0x6f8d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6f95
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x3556(%rip), %rsi      # 0xa511
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8ae7
leaq 0x3119(%rip), %rsi      # 0xa0e8
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6ffd
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x7004
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7037
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x31f4(%rip), %rsi      # 0xa273
leaq 0x31f0(%rip), %rdx      # 0xa276
leaq 0x40(%rsp), %rdi
callq 0x5d16
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d16
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x6418
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x70e8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x70ff
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7115
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7143
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x7143
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x7179
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x7179
jmp 0x7176
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x718f
movq 0x70(%rsp), %rsi
jmp 0x7187
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x718f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2f9d(%rip), %rsi      # 0xa51c
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x8ae7
leaq 0x2b55(%rip), %rsi      # 0xa0e8
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x75c1
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x75c8
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75fb
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3270
movl (%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x860(%rsp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x3110
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2c70(%rip), %rsi      # 0xa2b3
leaq 0x2c6b(%rip), %rdx      # 0xa2b5
leaq 0x40(%rsp), %rdi
callq 0x5d16
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x860(%rsp), %rbx
movq %rbx, %rdi
callq 0x3160
leaq (%rsp,%rax), %rdx
addq $0x860, %rdx            # imm = 0x860
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x5d16
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x6418
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x76ac
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x76c3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x76d9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7707
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x7707
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x773d
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x773d
jmp 0x773a
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7753
movq 0x70(%rsp), %rsi
jmp 0x774b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7753
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x4028, %rsp           # imm = 0x4028
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2daa(%rip), %rsi      # 0xa520
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x8ae7
leaq 0x295e(%rip), %rsi      # 0xa0e8
movq %r14, %rdi
callq 0x3490
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x77b8
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x77bf
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x77f2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32c0
movl (%rbx), %ebp
movq (%rsp), %r14
movq %r14, %rdi
callq 0x3160
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3180
movl (%rbx), %edi
leaq 0x20(%rsp), %rsi
movl $0x4000, %edx           # imm = 0x4000
xorl %ecx, %ecx
callq 0x3110
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7838
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
addq $0x4028, %rsp           # imm = 0x4028
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7877
movq 0x30(%rsp), %rsi
jmp 0x786f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7877
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7971
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
leaq 0x38(%rsp), %r12
movq 0x572c(%rip), %r15      # 0xcfd8
leaq 0x28(%rsp), %r13
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x59b5(%rip), %rsi      # 0xd280
movq 0x59b6(%rip), %rdx      # 0xd288
movq 0x56ef(%rip), %rdi      # 0xcfc8
callq 0x3310
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %edx
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3470
movq %r12, 0x28(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x5c86
movq %rbx, %rdi
movq %r13, %rsi
callq 0x79be
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x7940
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32c0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7957
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32c0
testb %bpl, %bpl
je 0x78b1
cmpb $0x1, 0x4(%rbx)
jne 0x7971
movl (%rbx), %edi
callq 0x34a0
movb $0x0, 0x4(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x799f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32c0
jmp 0x799f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x79b6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7393
movsbl 0x4e(%r14), %edx
movsbl 0x4f(%r14), %ecx
leaq 0xa74a(%rip), %rsi      # 0x11ad1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
jmp 0x73ae
movsbl 0x4e(%r14), %edx
movsbl 0x4f(%r14), %ecx
leaq 0xa740(%rip), %rsi      # 0x11ae4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movl 0x908(%r14), %edx
leaq 0xa738(%rip), %rsi      # 0x11af4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movl 0x904(%r14), %edx
leaq 0xa727(%rip), %rsi      # 0x11afb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movsbl 0x900(%r14), %edx
leaq 0xa715(%rip), %rsi      # 0x11b02
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movsbl 0x901(%r14), %edx
leaq 0xa703(%rip), %rsi      # 0x11b09
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movsbl 0x910(%r14), %edx
leaq 0xa6f1(%rip), %rsi      # 0x11b10
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0xa6b4(%rip), %rsi      # 0x11b17
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0x23a0
movb 0xc(%rsp), %al
leaq 0x4e(%r14), %rdx
movb %al, 0x4e(%r14)
movb 0x8(%rsp), %al
leaq 0x4f(%r14), %rcx
movb %al, 0x4f(%r14)
leaq 0xa693(%rip), %rsi      # 0x11b26
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
leaq 0x50(%r14), %r12
leaq 0xa691(%rip), %rsi      # 0x11b39
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x23a0
testl %eax, %eax
jg 0x74cf
leaq 0x9dba(%rip), %rsi      # 0x1127a
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
movb $-0x1, (%r12)
incl (%rbx)
leaq 0x908(%r14), %rdx
leaq 0xa661(%rip), %rsi      # 0x11b40
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
leaq 0x904(%r14), %rdx
leaq 0xa64e(%rip), %rsi      # 0x11b47
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
leaq 0x900(%r14), %rdx
leaq 0xa63b(%rip), %rsi      # 0x11b4e
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
leaq 0x901(%r14), %rdx
leaq 0xa62a(%rip), %rsi      # 0x11b57
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
addq $0x910, %r14            # imm = 0x910
leaq 0xa619(%rip), %rsi      # 0x11b60
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x23a0
incl (%rbx)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x756d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21d0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x7595
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/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 0x772b
movq 0x8a0(%rdi), %rax
movq 0x8b0(%rdi), %r8
movslq %esi, %rsi
movslq (%r8,%rsi,4), %r9
movl (%rax,%r9,4), %r9d
movl %r9d, -0x4(%rsp)
movslq (%r8,%rsi,4), %r8
leaq (%rax,%r8,4), %rax
movq %rax, (%rdx)
movq 0x8a8(%rdi), %rax
movb (%rax,%rsi,4), %al
jmp 0x7744
movq 0x898(%rdi), %rax
movslq %esi, %rsi
movl (%rax,%rsi,4), %eax
leaq -0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rsi, (%rdx)
movb $0x1, %al
movb %al, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdi, %rdi
je 0x7ba8
callq 0x2240
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x7bb6
callq 0x2240
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x7bc4
callq 0x2240
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x7bd2
callq 0x2240
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x7be0
callq 0x2240
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x7bee
callq 0x2240
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x7bfc
callq 0x2240
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x7c0a
callq 0x2290
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x7c1b
callq 0x2240
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x7c2c
callq 0x2240
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x7c3d
callq 0x2240
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x7c4e
callq 0x2240
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x7c60
popq %rbx
jmp 0x2240
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7e32
jnp 0x7ea1
movzbl 0xd0(%rdi), %eax
cmpl $0x6c, %eax
je 0x7e78
cmpl $0x70, %eax
jne 0x7e8a
testl %edx, %edx
jle 0x7e8e
addl %esi, %edx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r8
movslq %esi, %rsi
movslq %edx, %rdx
xorpd %xmm0, %xmm0
movsd (%rax,%rsi,8), %xmm1
subsd (%r8,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rdx, %rsi
jl 0x7e5b
jmp 0x7e92
subsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x24(%rcx), %xmm1
divsd %xmm1, %xmm0
jmp 0x7e92
xorl %eax, %eax
jmp 0x7ea1
xorpd %xmm0, %xmm0
movsd 0xc8(%rdi), %xmm1
ucomisd %xmm0, %xmm1
seta %al
movb %al, 0x20(%rcx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, 0x10(%rsp)
testl %esi, %esi
jle 0x7f2c
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rdx, 0x8(%rsp)
movslq (%r14), %rax
movl $0x1, %ecx
cmpb $0x1, (%rbx,%rax)
jne 0x7f13
movl (%r12), %esi
movl (%r15), %edx
movq 0x10(%rsp), %rdi
movq 0x58(%rdi), %rcx
addq %r13, %rcx
callq 0x7cc2
movzbl %al, %ecx
xorb $0x1, %al
movslq (%r14), %rdx
movb %al, (%rbx,%rdx)
movq 0x8(%rsp), %rdx
addl %ecx, %ebp
addq $0x28, %r13
addq $0x4, %r15
addq $0x4, %r12
addq $0x4, %r14
cmpq %r13, %rdx
jne 0x7edd
jmp 0x7f2e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, 0x10(%rsp)
testl %esi, %esi
jle 0x7fc6
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rdx, 0x8(%rsp)
movslq (%r14), %rax
movl $0x1, %ecx
cmpb $0x1, (%rbx,%rax)
jne 0x7fad
movl (%r12), %esi
movl (%r15), %edx
movq 0x10(%rsp), %rdi
movq 0x58(%rdi), %rcx
addq %r13, %rcx
callq 0x7e1e
movzbl %al, %ecx
xorb $0x1, %al
movslq (%r14), %rdx
movb %al, (%rbx,%rdx)
movq 0x8(%rsp), %rdx
addl %ecx, %ebp
addq $0x28, %r13
addq $0x4, %r15
addq $0x4, %r12
addq $0x4, %r14
cmpq %r13, %rdx
jne 0x7f77
jmp 0x7fc8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
leaq 0x48(%rdi), %rcx
testl %esi, %esi
cmovneq %rcx, %rax
cmpl $0x0, 0xc0(%rdi)
jle 0x8085
movq %rdi, %r14
cmpq $0x0, 0xa8(%rdi)
je 0x8085
cmpq $0x0, 0x98(%r14)
je 0x8085
cmpq $0x0, 0xb0(%r14)
je 0x8085
cmpl $0x0, 0xc0(%r14)
jle 0x8079
movq %rdx, %rbx
movq (%rax), %r15
xorl %r12d, %r12d
movq 0xb0(%r14), %rax
movslq (%rax,%r12,4), %rax
cmpb $0x0, (%rbx,%rax)
jle 0x806a
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 0x669f
incq %r12
movslq 0xc0(%r14), %rax
cmpq %rax, %r12
jl 0x8031
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x27a3
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSt.cpp
// Function: FitBitSt::projectToSimplex(bool, signed char*)
void FitBitSt::projectToSimplex(bool hasNon01Constraints, NPAR* condition) {
    if(this->sclsmplx_n<=0 || this->sclsmplx_sizes==NULL || this->sclsmplx_offsets==NULL || this->sclsmplx_blocks==NULL) {
        fprintf(stderr,"Error, projection to simplex affordances were nnot created.\n");
        exit(1);
    };
    if(hasNon01Constraints) {
        for(NCAT i=0; i<this->sclsmplx_n; i++) {
//            if(this->sclsmplx_blocks[i]<0 || this->sclsmplx_blocks[i]>this->nK) {
//                int a = 0;
//            } // DEBUG
            if( condition[ this->sclsmplx_blocks[i] ]>0 )
                projectsimplexbounded(&this->PARAM[ this->sclsmplx_offsets[i] ],
                                      &this->task->param_values_lb[ this->sclsmplx_bound_offsets[i] ],
                                      &this->task->param_values_ub[ this->sclsmplx_bound_offsets[i] ],
                                      this->sclsmplx_sizes[i]);
        }
    } else {
        for(NCAT i=0; i<this->sclsmplx_n; i++) {
//            if(this->sclsmplx_blocks[i]<0 || this->sclsmplx_blocks[i]>this->nK) {
//                int a = 0;
//            } // DEBUG
            if( condition[ this->sclsmplx_blocks[i] ] )
                projectsimplex(&this->PARAM[ this->sclsmplx_offsets[i] ], this->sclsmplx_sizes[i]);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0xc0(%rdi)
jle 0x819b
movq %rdi, %r14
cmpq $0x0, 0xa8(%rdi)
je 0x819b
cmpq $0x0, 0x98(%r14)
je 0x819b
cmpq $0x0, 0xb0(%r14)
je 0x819b
movq %rdx, %rbx
movl 0xc0(%r14), %eax
testb %sil, %sil
je 0x814a
testl %eax, %eax
jle 0x8195
xorl %r15d, %r15d
movq 0xb0(%r14), %rax
movslq (%rax,%r15,4), %rax
cmpb $0x0, (%rbx,%rax)
jle 0x8139
movq 0x88(%r14), %rax
movq 0x98(%r14), %rcx
movslq (%rcx,%r15,4), %rdi
shlq $0x3, %rdi
addq 0x10(%r14), %rdi
movq 0xa0(%r14), %rcx
movslq (%rcx,%r15,4), %rdx
shlq $0x3, %rdx
movq 0x10(%rax), %rsi
addq %rdx, %rsi
addq 0x18(%rax), %rdx
movq 0xa8(%r14), %rax
movsbl (%rax,%r15), %ecx
callq 0x4ca0
incq %r15
movslq 0xc0(%r14), %rax
cmpq %rax, %r15
jl 0x80e3
jmp 0x8195
testl %eax, %eax
jle 0x8195
xorl %r15d, %r15d
movq 0xb0(%r14), %rax
movslq (%rax,%r15,4), %rax
cmpb $0x0, (%rbx,%rax)
je 0x8186
movq 0x98(%r14), %rax
movq 0xa8(%r14), %rcx
movslq (%rax,%r15,4), %rdi
shlq $0x3, %rdi
addq 0x10(%r14), %rdi
movsbl (%rcx,%r15), %esi
callq 0x3d55
incq %r15
movslq 0xc0(%r14), %rax
cmpq %rax, %r15
jl 0x8151
popq %rbx
popq %r14
popq %r15
retq
callq 0x27c8
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %esi, %r14d
movl %edi, %ebp
movslq %edi, %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x2110
movq %rax, %rbx
testl %r15d, %r15d
jle 0xa5a3
movslq %r14d, %r14
movl %ebp, %r15d
movl %r14d, %r12d
xorl %r13d, %r13d
movl $0x8, %esi
movq %r14, %rdi
callq 0x2110
movq %rax, (%rbx,%r13,8)
testl %r14d, %r14d
movsd (%rsp), %xmm0
jle 0xa59b
xorl %ecx, %ecx
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0xa58e
incq %r13
cmpq %r15, %r13
jne 0xa571
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movslq %esi, %r15
movq %r15, %rdi
callq 0x22a0
movq %rax, %rbx
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22d0
cmpl %r15d, %eax
jne 0xa76d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2913
xorl %ebx, %ebx
jmp 0xa764
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::checkSkillConstraints(double*)
bool HMMProblemSt::checkSkillConstraints(NUMBER* param_skill) {
    NPAR nS = this->task->nS, nO = this->task->nO;
	NCAT skill1_n = nS * (1 + nS + nO); // number of params per 1 skill slot
    NUMBER sum = 0.0;
    
    for(NPAR l=0; l<skill1_n; l++) {
        if( param_skill[l]>1.0 || param_skill[l]<0.0)
            return false;
        sum += param_skill[l];
    }
    if( sum/(skill1_n/2) != 1.0 )
        return false;
    return true;
}

// Assembly:
movq 0x68(%rdi), %rax
movsbl 0x900(%rax), %edx
movsbl 0x901(%rax), %eax
leal (%rdx,%rax), %ecx
incl %ecx
imull %edx, %ecx
testl %ecx, %ecx
jle 0xb1e2
xorpd %xmm1, %xmm1
xorl %edx, %edx
movsd 0x6798(%rip), %xmm2     # 0x11950
xorpd %xmm0, %xmm0
movsbq %dl, %rax
movsd (%rsi,%rax,8), %xmm3
xorl %eax, %eax
ucomisd %xmm2, %xmm3
ja 0xb20b
ucomisd %xmm3, %xmm1
ja 0xb20b
addsd %xmm3, %xmm0
incb %dl
movsbl %dl, %eax
cmpl %eax, %ecx
jg 0xb1bc
jmp 0xb1e6
xorpd %xmm0, %xmm0
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
cmpeqsd 0x674d(%rip), %xmm0     # 0x11950
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::readModel(char const*, bool)
void HMMProblemSt::readModel(const char *filename, bool overwrite) {
	FILE *fid = fopen(filename,"r");
	if(fid == NULL)
	{
		fprintf(stderr,"Can't read model file %s\n",filename);
		exit(1);
	}
	int max_line_length = 1024;
	char *line = Malloc(char,(size_t)max_line_length);
	NDAT line_no = 0;
    struct task inittask;
    set_task_defaults(&inittask);
    
    //
    // read solver info
    //
    if(overwrite)
        readSolverInfo(fid, this->task, &line_no);
    else
        readSolverInfo(fid, &inittask, &line_no);
    //
    // read model
    //
    readModelBody(fid, &inittask, &line_no, overwrite);
		
	fclose(fid);
	free(line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x998, %rsp            # imm = 0x998
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x5e10(%rip), %rsi      # 0x11038
movq %r15, %rdi
callq 0x2230
testq %rax, %rax
je 0xb297
movq %rax, %rbx
movl $0x0, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x6e8e
testb %bpl, %bpl
je 0xb255
movq 0x68(%r14), %rsi
jmp 0xb25a
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x7430
movq (%r14), %rax
movzbl %bpl, %r8d
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x60(%rax)
movq %rbx, %rdi
callq 0x21b0
addq $0x998, %rsp            # imm = 0x998
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x29a8
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getA(int)
NUMBER* HMMProblemSt::getA(NCAT x) {
    NPAR nS = this->task->nS;
    NCAT nK = this->task->nK;
	if( x > (nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
		exit(1);
	}
	return &this->param_skill[this->skill1_n*x + nS];
}

// Assembly:
movq 0x68(%rdi), %rcx
movl 0x908(%rcx), %eax
cmpl %esi, %eax
jle 0xb4b5
movsbq 0x900(%rcx), %rcx
movslq 0x38(%rdi), %rdx
movslq %esi, %rax
imulq %rdx, %rax
addq %rcx, %rax
shlq $0x3, %rax
addq 0x28(%rdi), %rax
retq
pushq %rax
movl %eax, %edi
callq 0x29f3
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getB(int)
NUMBER* HMMProblemSt::getB(NCAT x) {
    NPAR nS = this->task->nS;
    NCAT nK = this->task->nK;
	if( x > (nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
		exit(1);
	}
	return &this->param_skill[ this->skill1_n*x + nS*(nS+1) ];
}

// Assembly:
movq 0x68(%rdi), %rcx
movl 0x908(%rcx), %eax
cmpl %esi, %eax
jle 0xb4eb
movsbl 0x900(%rcx), %eax
imull 0x38(%rdi), %esi
leal 0x1(%rax), %ecx
imull %eax, %ecx
addl %esi, %ecx
movslq %ecx, %rax
shlq $0x3, %rax
addq 0x28(%rdi), %rax
retq
pushq %rax
movl %eax, %edi
callq 0x2a1a
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getPI(int, signed char)
NUMBER HMMProblemSt::getPI(NCAT x, NPAR i) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    NCAT nK = this->task->nK;
    if( x > (this->task->nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
        exit(1);
    }
    // checks done
    return this->param_skill[this->skill1_n*x + i];
}

// Assembly:
movq 0x68(%rdi), %rax
movl 0x908(%rax), %eax
cmpl %esi, %eax
jle 0xb518
movq 0x28(%rdi), %rax
imull 0x38(%rdi), %esi
movsbl %dl, %ecx
addl %esi, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
retq
pushq %rax
movl %eax, %edi
callq 0x2a41
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getA(int, signed char, signed char)
NUMBER HMMProblemSt::getA(NCAT x, NPAR i, NPAR j) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    NPAR nS = this->task->nS;
    NCAT nK = this->task->nK;
    if( x > (nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
        exit(1);
    }
    // checks done
    return this->param_skill[this->skill1_n*x + nS + i*nS + j];
}

// Assembly:
movq 0x68(%rdi), %r8
movl 0x908(%r8), %eax
cmpl %esi, %eax
jle 0xb558
movsbl 0x900(%r8), %eax
movq 0x28(%rdi), %r8
imull 0x38(%rdi), %esi
movsbl %dl, %edx
imull %eax, %edx
movsbl %cl, %ecx
addl %eax, %ecx
addl %esi, %ecx
addl %edx, %ecx
movslq %ecx, %rax
movsd (%r8,%rax,8), %xmm0
retq
pushq %rax
movl %eax, %edi
callq 0x2a68
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getB(int, signed char, signed char)
NUMBER HMMProblemSt::getB(NCAT x, NPAR i, NPAR m) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    NPAR nS = this->task->nS;
    NPAR nO = this->task->nO;
    NCAT nK = this->task->nK;
    if( x > (nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
        exit(1);
    }
    if(m<0)
        return 1;
    // checks done
    return this->param_skill[this->skill1_n*x + nS * (1 + nS )+ i*nO + m];
}

// Assembly:
movq 0x68(%rdi), %r8
movl 0x908(%r8), %eax
cmpl %esi, %eax
jle 0xb5b3
testb %cl, %cl
js 0xb5aa
movsbl 0x900(%r8), %eax
movsbl 0x901(%r8), %r8d
movzbl %cl, %ecx
movq 0x28(%rdi), %r9
imull 0x38(%rdi), %esi
leal 0x1(%rax), %edi
imull %eax, %edi
movsbl %dl, %eax
imull %r8d, %eax
addl %ecx, %eax
addl %edi, %eax
addl %esi, %eax
cltq
movsd (%r9,%rax,8), %xmm0
retq
movsd 0x639e(%rip), %xmm0     # 0x11950
retq
pushq %rax
movl %eax, %edi
callq 0x2a8f
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getA(context*, signed char, signed char)
NUMBER HMMProblemSt::getA (struct context* ctx, NPAR i, NPAR j) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    // checks done
    NPAR nS = this->task->nS;
    return this->param_skill[this->skill1_n*ctx->k + nS + i*nS + j];
}

// Assembly:
movq 0x28(%rdi), %rax
movq 0x68(%rdi), %r8
movl (%rsi), %esi
imull 0x38(%rdi), %esi
movsbl 0x900(%r8), %edi
imull %edi, %edx
addl %edi, %ecx
addl %esi, %ecx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getB(context*, signed char, signed char)
NUMBER HMMProblemSt::getB (struct context* ctx, NPAR i, NPAR m) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    // checks done
    NPAR nS = this->task->nS;
    NPAR nO = this->task->nO;
    // special attention for "unknonw" observations, i.e. the observation was there but we do not know what it is
    // in this case we simply return 1, effectively resulting in no change in \alpha or \beta vatiables
    if(m<0)
        return 1;
    return this->param_skill[this->skill1_n*ctx->k + nS * (1 + nS )+ i*nO + m];
}

// Assembly:
testb %cl, %cl
js 0xb63d
movzbl %cl, %eax
movq 0x28(%rdi), %rcx
movq 0x68(%rdi), %r8
movsbl 0x901(%r8), %r9d
movsbl 0x900(%r8), %r8d
movl (%rsi), %esi
imull 0x38(%rdi), %esi
leal 0x1(%r8), %edi
imull %r8d, %edi
movsbl %dl, %edx
imull %r9d, %edx
addl %eax, %edx
addl %edi, %edx
addl %esi, %edx
movslq %edx, %rax
movsd (%rcx,%rax,8), %xmm0
retq
movsd 0x630b(%rip), %xmm0     # 0x11950
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::initAlphaEtAl()
void HMMProblemSt::initAlphaEtAl() {
    NPAR nS = this->task->nS;
    NCAT nK = this->task->nK, nG = this->task->nG;
    NDAT Nst = this->task->Nst;
    NPAR f_is_scaled = this->task->is_scaled==1;
    toZero2D(this->alpha, Nst, nS);
    // if scaled, new parameter values are multiplied, if not scaled – added
    if(f_is_scaled)
        toValue2D(this->po_param_gk, nG, nK, 1.0);
    else
        toZero2D(this->po_param_gk, nG, nK);
    toZero1D(this->loglik_k, nK);
    
    toValue3D(this->group_skill_map, (NDAT)nG, (NDAT)nK, (NDAT)nS, -1.0); // -1 means not set (use pLo)
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x68(%rdi), %rax
movsbl 0x900(%rax), %ebp
movl 0x908(%rax), %r15d
movl 0x904(%rax), %r9d
movslq 0x8fc(%rax), %rbx
movb 0x41(%rax), %al
movb %al, 0xf(%rsp)
movl %ebp, %r13d
testq %rbx, %rbx
movq %r9, 0x18(%rsp)
jle 0xb6cb
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x20(%rsp)
leaq (,%r13,8), %r14
xorl %r12d, %r12d
testb %bpl, %bpl
jle 0xb6c3
movq 0x20(%rsp), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
movq 0x18(%rsp), %r9
incq %r12
cmpq %r12, %rbx
jne 0xb6a6
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rbx
cmpb $0x1, 0xf(%rsp)
jne 0xb70d
testl %r9d, %r9d
jle 0xb73d
xorl %eax, %eax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
testl %r15d, %r15d
jle 0xb703
movq (%rbx,%rax,8), %rdx
xorl %esi, %esi
movq %rcx, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %r15
jne 0xb6f7
incq %rax
cmpq %r9, %rax
jne 0xb6ec
jmp 0xb73d
testl %r9d, %r9d
jle 0xb73d
leaq (,%r15,8), %r14
xorl %r12d, %r12d
testl %r15d, %r15d
jle 0xb735
movq (%rbx,%r12,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
movq 0x18(%rsp), %r9
incq %r12
cmpq %r12, %r9
jne 0xb71d
testl %r15d, %r15d
jle 0xb762
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
leaq (,%r15,8), %rdx
xorl %esi, %esi
callq 0x2100
movq 0x18(%rsp), %r9
testl %r9d, %r9d
jle 0xb7b2
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rax
xorl %ecx, %ecx
movabsq $-0x4010000000000000, %rdx # imm = 0xBFF0000000000000
testl %r15d, %r15d
jle 0xb7aa
xorl %esi, %esi
testb %bpl, %bpl
jle 0xb7a2
movq (%rax,%rcx,8), %rdi
movq (%rdi,%rsi,8), %rdi
xorl %r8d, %r8d
movq %rdx, (%rdi,%r8,8)
incq %r8
cmpq %r8, %r13
jne 0xb796
incq %rsi
cmpq %r15, %rsi
jne 0xb786
incq %rcx
cmpq %r9, %rcx
jne 0xb77f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::fit()
void HMMProblemSt::fit() {
    FitNullSkill(/*loglik_rmse, false do RMSE*/);
    switch(this->task->solver)
    {
        case METHOD_BW: // Baum Welch Method
        case METHOD_GD: // Gradient Descent
        case METHOD_CGD: // Conjugate Gradient Descent
        case METHOD_GDL: // Gradient Descent, Lagrange
        case METHOD_GBB: // Brzilai Borwein Gradient Method
            Cycle();
            break;
        default:
            fprintf(stderr,"Solver specified is not supported.\n");
            break;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xe2f0
movq 0x68(%rbx), %rax
movb 0x4f(%rax), %al
decb %al
cmpb $0x4, %al
ja 0xe2e9
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x90(%rax)
callq 0x2b8d
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::FitNullSkill()
void HMMProblemSt::FitNullSkill() {
    if(this->task->N_null==0) {
        this->null_obs_ratios[0] = 1; // set first obs to 1, simplex preserved
        return; // 0 loglik
    }
    NDAT t;
    NPAR o, m;
    // count distribution of onservations
    for(t=this->task->first_null_skill; t<=this->task->last_null_skill; t++) {
        o = this->task->dat_obs[ t ];
        this->null_obs_ratios[ o ]++;
    }
    // produce per-observation means
    this->null_skill_obs = 0;
    this->null_skill_obs_prob = 0;
    for(m=0;m<this->task->nO;m++) {
        this->null_obs_ratios[ m ] /= this->task->N_null;
        if( this->null_obs_ratios[m] > this->null_skill_obs_prob ) {
            this->null_skill_obs_prob = this->null_obs_ratios[m];
            this->null_skill_obs = m;
        }
    }
    this->null_skill_obs_prob = safe01num(this->null_skill_obs_prob); // safety for logging
    // metrics don't need to be computed it's handled in computeAlpha... -- main negative log-ikelihood computation
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rcx
movl 0x914(%rcx), %eax
testl %eax, %eax
je 0xe3b7
movslq 0x918(%rcx), %rdx
movl 0x91c(%rcx), %esi
cmpl %esi, %edx
jg 0xe352
movl %edx, %r8d
movq 0x10(%rbx), %rdi
addq 0x880(%rcx), %rdx
subl %r8d, %esi
incl %esi
xorl %r8d, %r8d
movsd 0x361b(%rip), %xmm0     # 0x11950
movsbq (%rdx,%r8), %r9
movsd (%rdi,%r9,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%r9,8)
incq %r8
cmpl %r8d, %esi
jne 0xe335
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rbx)
movsbq 0x901(%rcx), %rcx
testq %rcx, %rcx
jle 0xe3a6
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x10(%rbx), %rax
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
ucomisd 0x20(%rbx), %xmm1
jbe 0xe39e
movsd %xmm1, 0x20(%rbx)
movsbl %dl, %esi
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
movsd %xmm1, 0x18(%rbx)
incq %rdx
cmpq %rdx, %rcx
jne 0xe375
movsd 0x20(%rbx), %xmm0
callq 0x6020
movsd %xmm0, 0x20(%rbx)
jmp 0xe3c8
movq 0x10(%rbx), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
popq %rbx
retq