LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_play()
static void
GTP_play( void )
{
  char *command;
  char c;
  int color, pos = 0;

  StopPondering();

  command = STRTOK(input_copy, DELIM, &next_token);

  command = STRTOK(NULL, DELIM, &next_token);
  if (command == NULL){
    GTP_response(err_play, false);
    return;
  }
  CHOMP(command);
  c = static_cast<char>(tolower(static_cast<int>(command[0])));
  if (c == 'w') {
    color = S_WHITE;
  } else{
    color = S_BLACK;
  }

  command = STRTOK(NULL, DELIM, &next_token);
  
  CHOMP(command);
  if (command == NULL){
    GTP_response(err_play, false);
    return;
  } else {
    pos = StringToInteger(command);
  }

  if (pos != RESIGN) {
    PutStone(game, pos, color);
  }
  
  GTP_response(blank, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x14(%rbp)
callq 0x892c0
leaq 0xc09a5(%rip), %rdi     # 0xe8410
leaq 0x8512e(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x8511a(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x27aa9
leaq 0x85293(%rip), %rdi     # 0xacd30
xorl %esi, %esi
callq 0x27f30
jmp 0x27bbb
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x27aee
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x77e0
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x77, %eax
jne 0x27b0f
movl $0x2, -0x10(%rbp)
jmp 0x27b16
movl $0x1, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x8507f(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x27b6f
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x8(%rbp)
jne 0x27b86
leaq 0x851b3(%rip), %rdi     # 0xacd30
xorl %esi, %esi
callq 0x27f30
jmp 0x27bbb
movq -0x8(%rbp), %rdi
callq 0x9ee80
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x27baa
movq 0xc0981(%rip), %rdi     # 0xe8520
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x9dbc0
leaq 0x85011(%rip), %rdi     # 0xacbc2
movl $0x1, %esi
callq 0x27f30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_set_free_handicap()
static void
GTP_set_free_handicap( void )
{
  char *command;
  int pos, num = 0;

  StopPondering();
  
  while (1){
    command = STRTOK(NULL, DELIM, &next_token);

    if (command == NULL){
      SetHandicapNum(num);
      SetKomi(0.5);
      GTP_response(blank, true);
      return;
    }
    
    pos = StringToInteger(command);
    
    if (pos > 0 && pos < board_max && IsLegal(game, pos, S_BLACK)) {
      PutStone(game, pos, S_BLACK);
      num++;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x10(%rbp)
callq 0x892c0
xorl %eax, %eax
movl %eax, %edi
leaq 0x84f71(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x27c6b
movl -0x10(%rbp), %edi
callq 0x9fde0
movsd 0x843c1(%rip), %xmm0    # 0xac010
callq 0x9bc10
leaq 0x84f67(%rip), %rdi     # 0xacbc2
movl $0x1, %esi
callq 0x27f30
addq $0x10, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x9ee80
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x27cc2
movl -0xc(%rbp), %eax
leaq 0xbfdc1(%rip), %rcx     # 0xe7a48
cmpl (%rcx), %eax
jge 0x27cc2
movq 0xc088e(%rip), %rdi     # 0xe8520
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x9d0b0
testb $0x1, %al
jne 0x27ca5
jmp 0x27cc2
movq 0xc0874(%rip), %rdi     # 0xe8520
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x9dbc0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x27c24
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_timeleft()
static void
GTP_timeleft( void )
{
  char *str1, *str2;

  str1 = STRTOK(NULL, DELIM, &next_token);
  str2 = STRTOK(NULL, DELIM, &next_token);
  
  if (str1[0] == 'B' || str1[0] == 'b'){
    SetCurrentRemainingTime(S_BLACK, atof(str2));
  } else if (str1[0] == 'W' || str1[0] == 'w'){
    SetCurrentRemainingTime(S_WHITE, atof(str2));
  }
  
  fprintf(stderr, "%f\n", GetRemainingTime(S_BLACK));
  fprintf(stderr, "%f\n", GetRemainingTime(S_WHITE));
  GTP_response(blank, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
leaq 0x84e8d(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x84e79(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x42, %eax
je 0x27d48
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x62, %eax
jne 0x27d5d
movq -0x10(%rbp), %rdi
callq 0x76d0
movl $0x1, %edi
callq 0x8f160
jmp 0x27d8a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x57, %eax
je 0x27d75
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x77, %eax
jne 0x27d88
movq -0x10(%rbp), %rdi
callq 0x76d0
movl $0x2, %edi
callq 0x8f160
jmp 0x27d8a
movq 0xbf227(%rip), %rax     # 0xe6fb8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x8f190
movq -0x20(%rbp), %rdi
leaq 0x84def(%rip), %rsi     # 0xacb9c
movb $0x1, %al
callq 0x77d0
movq 0xbf1fd(%rip), %rax     # 0xe6fb8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0x8f190
movq -0x18(%rbp), %rdi
leaq 0x84dc5(%rip), %rsi     # 0xacb9c
movb $0x1, %al
callq 0x77d0
leaq 0x84ddd(%rip), %rdi     # 0xacbc2
movl $0x1, %esi
callq 0x27f30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_timesettings()
static void
GTP_timesettings( void )
{
  char *str1, *str2, *str3;
  double main_time, byoyomi, stone;

  str1 = STRTOK(NULL, DELIM, &next_token);
  str2 = STRTOK(NULL, DELIM, &next_token);
  str3 = STRTOK(NULL, DELIM, &next_token);

  main_time = atoi(str1);
  byoyomi = atoi(str2);
  stone = atoi(str3);

  std::cerr << main_time << "," << byoyomi << "," << stone << std::endl;

  SetTimeSettings(main_time, byoyomi, stone);
  InitializeSearchSetting();
  
  GTP_response(blank, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
leaq 0x84d8d(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x84d79(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x84d65(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7840
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7840
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7840
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movq 0xbf16a(%rip), %rdi     # 0xe6ff0
callq 0x7a60
movq %rax, %rdi
leaq 0x84c30(%rip), %rsi     # 0xacac5
callq 0x7530
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x7a60
movq %rax, %rdi
leaq 0x84c14(%rip), %rsi     # 0xacac5
callq 0x7530
movq %rax, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x7a60
movq %rax, %rdi
movq 0xbf09b(%rip), %rsi     # 0xe6f68
callq 0x75b0
cvttsd2si -0x20(%rbp), %edi
cvttsd2si -0x28(%rbp), %esi
cvttsd2si -0x30(%rbp), %edx
callq 0x8f310
callq 0x89180
leaq 0x84cd0(%rip), %rdi     # 0xacbc2
movl $0x1, %esi
callq 0x27f30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_response(char const*, bool)
static void
GTP_response( const char *res, const bool success )
{
  if (success){
    if (command_id >= 0) {
      std::cout << "=" << command_id << " " << res << std::endl << std::endl;
    } else {
      std::cout << "= " << res << std::endl << std::endl;
    }
  } else {
    std::cout << "? ";
    if (res != NULL) {
      std::cout << res;
    }
    std::cout << std::endl << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x27ff2
cmpl $0x0, 0xc05c3(%rip)     # 0xe8518
jl 0x27fb3
movq 0xbf04a(%rip), %rdi     # 0xe6fa8
leaq 0x84a82(%rip), %rsi     # 0xac9e7
callq 0x7530
movq %rax, %rdi
movl 0xc05a5(%rip), %esi     # 0xe8518
callq 0x7980
movq %rax, %rdi
leaq 0x844c4(%rip), %rsi     # 0xac446
callq 0x7530
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7530
movq %rax, %rdi
movq 0xbefcb(%rip), %rsi     # 0xe6f68
callq 0x75b0
movq %rax, %rdi
movq 0xbefbc(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x27ff0
movq 0xbefee(%rip), %rdi     # 0xe6fa8
leaq 0x84288(%rip), %rsi     # 0xac249
callq 0x7530
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7530
movq %rax, %rdi
movq 0xbef8c(%rip), %rsi     # 0xe6f68
callq 0x75b0
movq %rax, %rdi
movq 0xbef7d(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x2803e
movq 0xbefaf(%rip), %rdi     # 0xe6fa8
leaq 0x849e9(%rip), %rsi     # 0xac9e9
callq 0x7530
cmpq $0x0, -0x8(%rbp)
je 0x2801c
movq -0x8(%rbp), %rsi
movq 0xbef91(%rip), %rdi     # 0xe6fa8
callq 0x7530
movq 0xbef85(%rip), %rdi     # 0xe6fa8
movq 0xbef3e(%rip), %rsi     # 0xe6f68
callq 0x75b0
movq %rax, %rdi
movq 0xbef2f(%rip), %rsi     # 0xe6f68
callq 0x75b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: InputPending()
static bool
InputPending( void )
{
#if defined (_WIN32)
  static int init = 0, pipe;
  static HANDLE inh;
  DWORD dw;

  if (!init) {
    init = 1;
    inh = GetStdHandle(STD_INPUT_HANDLE);
    pipe = !GetConsoleMode(inh, &dw);
    if (!pipe) {
      SetConsoleMode(inh, dw & ~(ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT));
      FlushConsoleInputBuffer(inh);
    }
  }

  if (pipe) {
    if (!PeekNamedPipe(inh, nullptr, 0, nullptr, &dw, nullptr)) {
      exit(EXIT_FAILURE);
    }

    return dw;
  } else {
    if (!GetNumberOfConsoleInputEvents(inh, &dw)) {
      exit(EXIT_FAILURE);
    }

    return dw > 1;
  }
  return false;
#else 
  fd_set read_fds;
  FD_ZERO(&read_fds);
  FD_SET(0,&read_fds);
  struct timeval timeout{0,0};
  select(1,&read_fds,nullptr,nullptr,&timeout);
  return FD_ISSET(0, &read_fds);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x0, -0x84(%rbp)
movl -0x84(%rbp), %eax
cmpq $0x10, %rax
jae 0x28302
movq -0x90(%rbp), %rax
movl -0x84(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x282d0
jmp 0x28304
movq -0x80(%rbp), %rax
orq $0x1, %rax
movq %rax, -0x80(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x72b0
movl $0x1, %edi
leaq -0x80(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa0(%rbp), %r8
movq %rcx, %rdx
callq 0x74f0
movq -0x80(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/gtp/GtpUtility.cpp
// Function: GetColor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int
GetColor( const std::string &s_color )
{
  const char c = static_cast<char>(tolower(static_cast<int>(s_color[0])));

  if (c == 'b') {
    return S_BLACK;
  } else if (c == 'w') {
    return S_WHITE;
  } else {
    return S_EMPTY;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x75f0
movsbl (%rax), %edi
callq 0x77e0
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x62, %eax
jne 0x2c8e6
movl $0x1, -0x4(%rbp)
jmp 0x2c8ff
movsbl -0x11(%rbp), %eax
cmpl $0x77, %eax
jne 0x2c8f8
movl $0x2, -0x4(%rbp)
jmp 0x2c8ff
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/util/Utility.cpp
// Function: InputTxtFLT(char const*, float*, int)
void
InputTxtFLT( const char *filename, float *ap, const int array_size )
{
  FILE *fp;
#if defined (_WIN32)
  errno_t err;

  err = fopen_s(&fp, filename, "r");
  if (err != 0) {
    std::cerr << "can not open -" << filename << "-" << std::endl;
    exit(1);
  }
  for (int i = 0; i < array_size; i++) {
    if (fscanf_s(fp, "%f", &ap[i]) == EOF) {
      std::cerr << "Read Error : " << filename << std::endl;
    }
  }
#else
  fp = fopen(filename, "r");
  if (fp == NULL) {
    std::cerr << "can not open -" << filename << "-" << std::endl;
  }
  for (int i = 0; i < array_size; i++) {
    if (fscanf(fp, "%f", &ap[i]) == EOF) {
      std::cerr << "Read Error : " << filename << std::endl;
      exit(1);
    }
  }
#endif
  fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8081d(%rip), %rsi     # 0xad52b
callq 0x7680
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2cd5b
movq 0xba2cb(%rip), %rdi     # 0xe6ff0
leaq 0x803d4(%rip), %rsi     # 0xad100
callq 0x7530
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7530
movq %rax, %rdi
leaq 0x7f3b4(%rip), %rsi     # 0xac0fb
callq 0x7530
movq %rax, %rdi
movq 0xba212(%rip), %rsi     # 0xe6f68
callq 0x75b0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2cdd5
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movslq -0x24(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x8038b(%rip), %rsi     # 0xad10f
movb $0x0, %al
callq 0x7a00
cmpl $-0x1, %eax
jne 0x2cdc8
movq 0xba259(%rip), %rdi     # 0xe6ff0
leaq 0x80374(%rip), %rsi     # 0xad112
callq 0x7530
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7530
movq %rax, %rdi
movq 0xba1af(%rip), %rsi     # 0xe6f68
callq 0x75b0
movl $0x1, %edi
callq 0x76a0
jmp 0x2cdca
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2cd62
movq -0x20(%rbp), %rdi
callq 0x7540
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/util/Utility.cpp
// Function: InputTxtDBL(char const*, double*, int)
void
InputTxtDBL( const char *filename, double *ap, const int array_size )
{
  FILE *fp;
#if defined (_WIN32)
  errno_t err;

  err = fopen_s(&fp, filename, "r");
  if (err != 0) {
    std::cerr << "can not open -" << filename << "-" << std::endl;
  }
  for (int i = 0; i < array_size; i++) {
    if (fscanf_s(fp, "%lf", &ap[i]) == EOF) {
      std::cerr << "Read Error : " << filename << std::endl;
    }
  }
#else
  fp = fopen(filename, "r");
  if (fp == NULL) {
    std::cerr << "can not open -" << filename << "-" << std::endl;
  }
  for (int i = 0; i < array_size; i++) {
    if (fscanf(fp, "%lf", &ap[i]) == EOF) {
      std::cerr << "Read Error : " << filename << std::endl;
    }
  }
#endif
  fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8071d(%rip), %rsi     # 0xad52b
callq 0x7680
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2ce5b
movq 0xba1cb(%rip), %rdi     # 0xe6ff0
leaq 0x802d4(%rip), %rsi     # 0xad100
callq 0x7530
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7530
movq %rax, %rdi
leaq 0x7f2b4(%rip), %rsi     # 0xac0fb
callq 0x7530
movq %rax, %rdi
movq 0xba112(%rip), %rsi     # 0xe6f68
callq 0x75b0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2cecb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x7fc9f(%rip), %rsi     # 0xacb23
movb $0x0, %al
callq 0x7a00
cmpl $-0x1, %eax
jne 0x2cebe
movq 0xba159(%rip), %rdi     # 0xe6ff0
leaq 0x80274(%rip), %rsi     # 0xad112
callq 0x7530
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7530
movq %rax, %rdi
movq 0xba0af(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x2cec0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ce62
movq -0x20(%rbp), %rdi
callq 0x7540
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/util/Utility.cpp
// Function: JoinStrings(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, char const*)
std::string
JoinStrings( const std::vector<std::string> &str_vec, const char *delimiter = 0 )
{
  std::string result;

  if (!str_vec.empty()) {
    result += str_vec[0];
    for (decltype(str_vec.size()) i = 1, c = str_vec.size(); i < c; i++) {
      if (delimiter) result += delimiter;
      result += str_vec[i];
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7770
movq -0x10(%rbp), %rdi
callq 0x2c640
testb $0x1, %al
jne 0x2cfaf
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2d1a0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x7700
jmp 0x2cf34
movq $0x1, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29bb0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x2cfad
cmpq $0x0, -0x18(%rbp)
je 0x2cf82
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7510
jmp 0x2cf69
jmp 0x2cf82
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x7ae8
jmp 0x2cfcc
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2d1a0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x7700
jmp 0x2cf9d
jmp 0x2cf9f
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2cf49
jmp 0x2cfaf
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2cfc2
movq -0x50(%rbp), %rdi
callq 0x7ae8
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x79b0
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/util/Utility.cpp
// Function: SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string>
SplitString( const std::string &str, const std::string pattern )
{
  std::vector<std::string> result;
  std::regex reg{pattern};

  std::copy(std::sregex_token_iterator{str.begin(), str.end(), reg, -1},
            std::sregex_token_iterator{},
            std::back_inserter(result));

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, -0x188(%rbp)
movq %rdi, -0x198(%rbp)
movq %rdi, %rax
movq %rax, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x29b60
movq -0x188(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x10, %edx
callq 0x2d1c0
jmp 0x2d02f
movq -0x10(%rbp), %rdi
callq 0x7500
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7a30
movq %rax, -0xe8(%rbp)
movq -0xe0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
leaq -0x40(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x2d3f0
jmp 0x2d078
leaq -0x170(%rbp), %rdi
callq 0x2d500
jmp 0x2d086
movq -0x198(%rbp), %rdi
callq 0x2d580
movq %rax, -0x1a0(%rbp)
jmp 0x2d09b
movq -0x1a0(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x178(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x2d270
movq %rax, -0x1a8(%rbp)
jmp 0x2d0cc
movq -0x1a8(%rbp), %rax
movq %rax, -0x180(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x2d5b0
leaq -0xd8(%rbp), %rdi
callq 0x2d5b0
movb $0x1, -0x19(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2d5e0
testb $0x1, -0x19(%rbp)
jne 0x2d16c
jmp 0x2d160
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d17c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d155
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d149
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x2d5b0
leaq -0xd8(%rbp), %rdi
callq 0x2d5b0
leaq -0x40(%rbp), %rdi
callq 0x2d5e0
jmp 0x2d17c
movq -0x198(%rbp), %rdi
callq 0x29bd0
movq -0x190(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x29bd0
movq -0x48(%rbp), %rdi
callq 0x79b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: TrainBTModelWithFactorizationMachines()
void
TrainBTModelWithFactorizationMachines( void )
{
  SetLearningLogFilePath();
  InitializeOutputFileMap();
  InitializeLearning();
  LearningSecondOrderBradleyTerryModel();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x81070
callq 0x581a0
callq 0x59280
callq 0x5a2b0
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: InitializeWeights(std::vector<btfm_t, std::allocator<btfm_t>>&, int, std::mersenne_twister_engine<unsigned long, 64ul, 312ul, 156ul, 31ul, 13043109905998158313ul, 29ul, 6148914691236517205ul, 17ul, 8202884508482404352ul, 37ul, 18444473444759240704ul, 43ul, 6364136223846793005ul>&, std::normal_distribution<double>&, int&)
static void
InitializeWeights( std::vector<btfm_t> &data, const int size, std::mt19937_64 &mt, std::normal_distribution<> &dist, int &data_id )
{
  data.resize(size);

  for (btfm_t &datum : data) {
    datum.w = 1.0;
    for (int k = 0; k < FM_DIMENSION; k++) {
      datum.v[k] = exp(dist(mt));
    }
    datum.id = data_id++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x64970
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x64a00
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x64a30
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x64a60
testb $0x1, %al
jne 0x5af8d
jmp 0x5b007
leaq -0x38(%rbp), %rdi
callq 0x64aa0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsd 0x51062(%rip), %xmm0    # 0xac008
movsd %xmm0, (%rax)
movl $0x0, -0x4c(%rbp)
cmpl $0x5, -0x4c(%rbp)
jge 0x5afe2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64ac0
callq 0x79d0
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x5afb1
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, (%rax)
movq -0x48(%rbp), %rax
movl %ecx, 0x210(%rax)
leaq -0x38(%rbp), %rdi
callq 0x64af0
jmp 0x5af7a
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: LearningLoop(train_thread_arg_t*)
static void
LearningLoop( train_thread_arg_t *targ )
{
  game_info_t *game = AllocateGame();
  game_info_t *init_game = AllocateGame();

  InitializeBoard(init_game);

  for (int i = TRAIN_KIFU_START_INDEX; i <= TRAIN_KIFU_LAST_INDEX; i++) {
    if (i % thread_num == targ->id) {
      const std::string filename = TRAIN_KIFU_PATH + PATH_SEPARATOR + std::to_string(i) + ".sgf";
      if (i % 1000 == 0) {
        fprintf(stderr, "%d.sgf\n", i);
        fflush(stderr);
      }
      CopyGame(game, init_game);
      PlaybackGame(game, filename.c_str(), targ->id);
    }
  }

  FreeGame(game);
  FreeGame(init_game);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
callq 0x9bce0
movq %rax, -0x10(%rbp)
callq 0x9bce0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9bd70
movl $0x1, -0x1c(%rbp)
cmpl $0x7530, -0x1c(%rbp)    # imm = 0x7530
jg 0x5b1ec
movl -0x1c(%rbp), %eax
cltd
idivl 0x8c948(%rip)           # 0xe79a0
movq -0x8(%rbp), %rax
cmpl (%rax), %edx
jne 0x5b1dc
leaq 0x52fcc(%rip), %rsi     # 0xae037
leaq 0x8e13e(%rip), %rdx     # 0xe91b0
leaq -0x80(%rbp), %rdi
callq 0x668e0
movl -0x1c(%rbp), %esi
leaq -0xa0(%rbp), %rdi
callq 0x669f0
jmp 0x5b08c
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x66810
jmp 0x5b0a2
leaq 0x5301a(%rip), %rdx     # 0xae0c3
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x63310
jmp 0x5b0b8
leaq -0x60(%rbp), %rdi
callq 0x7ae8
leaq -0xa0(%rbp), %rdi
callq 0x7ae8
leaq -0x80(%rbp), %rdi
callq 0x7ae8
movl -0x1c(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5b199
movq 0x8bec7(%rip), %rax     # 0xe6fb8
movq %rax, -0xb8(%rbp)
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
leaq 0x530ec(%rip), %rsi     # 0xae1f1
xorl %eax, %eax
callq 0x77d0
movq -0xb8(%rbp), %rax
movq (%rax), %rdi
callq 0x7670
jmp 0x5b11d
jmp 0x5b199
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x5b16e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x5b162
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7ae8
leaq -0xa0(%rbp), %rdi
callq 0x7ae8
leaq -0x80(%rbp), %rdi
callq 0x7ae8
jmp 0x5b207
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7ae8
jmp 0x5b207
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c660
jmp 0x5b1a8
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x71d0
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rax
movl (%rax), %edx
callq 0x5cec0
jmp 0x5b1d3
leaq -0x40(%rbp), %rdi
callq 0x7ae8
jmp 0x5b1de
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5b041
movq -0x10(%rbp), %rdi
callq 0x9bd30
movq -0x18(%rbp), %rdi
callq 0x9bd30
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x79b0
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: TestingLoop(train_thread_arg_t*)
static void
TestingLoop( train_thread_arg_t *targ )
{
  game_info_t *game = AllocateGame();
  game_info_t *init_game = AllocateGame();

  InitializeBoard(init_game);

  for (int i = TEST_KIFU_START_INDEX; i <= TEST_KIFU_LAST_INDEX; i++) {
    if (i % thread_num == targ->id) {
      const std::string filename = TEST_KIFU_PATH + PATH_SEPARATOR + std::to_string(i) + ".sgf";
      if (i % 1000 == 0) {
        fprintf(stderr, "Test %d.sgf\n", i);
        fflush(stderr);
      }
      CopyGame(game, init_game);
      PlaybackGameForEvaluation(game, filename.c_str());
    }
  }
  
  FreeGame(game);
  FreeGame(init_game);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
callq 0x9bce0
movq %rax, -0x10(%rbp)
callq 0x9bce0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9bd70
movl $0x9c41, -0x1c(%rbp)    # imm = 0x9C41
cmpl $0x11170, -0x1c(%rbp)   # imm = 0x11170
jg 0x5c436
movl -0x1c(%rbp), %eax
cltd
idivl 0x8b6f8(%rip)           # 0xe79a0
movq -0x8(%rbp), %rax
cmpl (%rax), %edx
jne 0x5c426
leaq 0x51d8f(%rip), %rsi     # 0xae04a
leaq 0x8ceee(%rip), %rdx     # 0xe91b0
leaq -0x80(%rbp), %rdi
callq 0x668e0
movl -0x1c(%rbp), %esi
leaq -0xa0(%rbp), %rdi
callq 0x669f0
jmp 0x5c2dc
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x66810
jmp 0x5c2f2
leaq 0x51dca(%rip), %rdx     # 0xae0c3
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x63310
jmp 0x5c308
leaq -0x60(%rbp), %rdi
callq 0x7ae8
leaq -0xa0(%rbp), %rdi
callq 0x7ae8
leaq -0x80(%rbp), %rdi
callq 0x7ae8
movl -0x1c(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5c3e9
movq 0x8ac77(%rip), %rax     # 0xe6fb8
movq %rax, -0xb8(%rbp)
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
leaq 0x51e97(%rip), %rsi     # 0xae1ec
xorl %eax, %eax
callq 0x77d0
movq -0xb8(%rbp), %rax
movq (%rax), %rdi
callq 0x7670
jmp 0x5c36d
jmp 0x5c3e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x5c3be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x5c3b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7ae8
leaq -0xa0(%rbp), %rdi
callq 0x7ae8
leaq -0x80(%rbp), %rdi
callq 0x7ae8
jmp 0x5c451
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7ae8
jmp 0x5c451
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c660
jmp 0x5c3f8
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x71d0
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x5f950
jmp 0x5c41d
leaq -0x40(%rbp), %rdi
callq 0x7ae8
jmp 0x5c428
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5c291
movq -0x10(%rbp), %rdi
callq 0x9bd30
movq -0x18(%rbp), %rdi
callq 0x9bd30
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x79b0
nopl (%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: PlaybackGame(game_info_t*, char const*, int)
static void
PlaybackGame( game_info_t *game, const char *filename, const int id )
{
  SGF_record_t kifu;
  int color = S_BLACK;

  // 棋譜の読み込み
  ExtractKifu(filename, &kifu);

  // 終局するまでループ
  for (int i = 0; i < kifu.moves; i++) {
    // 着手位置を入力
    const int pos = GetKifuMove(&kifu, i);

    // 特徴の抽出
    ProcessPosition(game, pos, color, id);

    // 碁盤に石を置く
    PutStone(game, pos, color);

    // 手番交代
    color = GetOppositeColor(color);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40d0, %rsp           # imm = 0x40D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x40bc(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40b8(%rbp), %rsi
callq 0x818f0
movl $0x0, -0x40c0(%rbp)
movl -0x40c0(%rbp), %eax
cmpl -0x40b4(%rbp), %eax
jge 0x5cf6f
movl -0x40c0(%rbp), %esi
leaq -0x40b8(%rbp), %rdi
callq 0x81830
movl %eax, -0x40c4(%rbp)
movq -0x8(%rbp), %rdi
movl -0x40c4(%rbp), %esi
movl -0x40bc(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x5cf80
movq -0x8(%rbp), %rdi
movl -0x40c4(%rbp), %esi
movl -0x40bc(%rbp), %edx
callq 0x9dbc0
movl -0x40bc(%rbp), %edi
callq 0x25810
movl %eax, -0x40bc(%rbp)
movl -0x40c0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40c0(%rbp)
jmp 0x5cefa
addq $0x40d0, %rsp           # imm = 0x40D0
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: CalculateFirstTerm(std::vector<btfm_t*, std::allocator<btfm_t*>> const&, int)
static double
CalculateFirstTerm( const std::vector<btfm_t*> &t, const int n )
{
  double gamma = 1.0;

  for (int i = 0; i < n; i++) {
    gamma *= t[i]->w;
  }

  return gamma;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd 0x4d101(%rip), %xmm0    # 0xac008
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5ef44
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x690c0
movq (%rax), %rax
movsd (%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ef13
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: CalculateSecondTerm(std::vector<btfm_t*, std::allocator<btfm_t*>> const&, int, int)
static double
CalculateSecondTerm( const std::vector<btfm_t*> &t, const int i, const int j )
{
  double theta = 0.0;

  for (int k = 0; k < FM_DIMENSION; k++) {
    theta += t[i]->v[k] * t[j]->v[k];
  }
  return theta * (1.0 / static_cast<double>(FM_DIMENSION));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x5efd2
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x690c0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x690c0
movsd -0x28(%rbp), %xmm0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ef71
movsd 0x4ef66(%rip), %xmm0    # 0xadf40
mulsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: CorrectTacticalFeature(std::vector<btfm_t*, std::allocator<btfm_t*>>*, std::map<int, btfm_t*, std::less<int>, std::allocator<std::pair<int const, btfm_t*>>>&, std::vector<btfm_t, std::allocator<btfm_t>>&, unsigned int const*, UCT_ALL_FEATURE, int)
static void
CorrectTacticalFeature( std::vector<btfm_t*> feature_list[],
                        std::map<int, btfm_t*> &feature_map,
                        std::vector<btfm_t> &feature,
                        const unsigned int tactical_features[],
                        const UCT_ALL_FEATURE feature_index,
                        const int pos )
{
  if (tactical_features[UctFeatureIndex(pos, feature_index)] > 0) {
    feature_list[pos].push_back(&feature[tactical_features[UctFeatureIndex(pos, feature_index)]]);
    const int id = feature[tactical_features[UctFeatureIndex(pos, feature_index)]].id;
    if (!feature_map.count(id)) {
      feature_map[id] = &feature[tactical_features[UctFeatureIndex(pos, feature_index)]];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x68b50
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jbe 0x5f5a9
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x28(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x68b50
movq -0x68(%rbp), %rdi
movl %eax, %ecx
movq -0x60(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x63540
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x671d0
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x28(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x68b50
movq -0x50(%rbp), %rdi
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x63540
movl 0x210(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x672e0
cmpq $0x0, %rax
jne 0x5f5a7
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x28(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x68b50
movq -0x80(%rbp), %rdi
movl %eax, %ecx
movq -0x78(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x63540
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x67200
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x5f5a9
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: CorrectMoveDistanceFeature(std::vector<btfm_t*, std::allocator<btfm_t*>>*, std::map<int, btfm_t*, std::less<int>, std::allocator<std::pair<int const, btfm_t*>>>&, std::vector<btfm_t, std::allocator<btfm_t>>&, int, int, int)
static void
CorrectMoveDistanceFeature( std::vector<btfm_t*> feature_list[],
                            std::map<int, btfm_t*> &feature_map,
                            std::vector<btfm_t> &move_distance_feature,
                            const int pos,
                            const int previous_move,
                            const int shift )
{
  if (previous_move != PASS) {
    int distance = DIS(previous_move, pos);
    if (distance > MOVE_DISTANCE_MAX - 1) {
      distance = MOVE_DISTANCE_MAX - 1;
    }
    distance += shift;
    feature_list[pos].push_back(&move_distance_feature[distance]);
    const int id = move_distance_feature[distance].id;
    if (!feature_map.count(id)) {
      feature_map[id] = &move_distance_feature[distance];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x5f6e0
movslq -0x20(%rbp), %rcx
leaq 0x1ab1f80c(%rip), %rax  # 0x1ab7ee00
movl (%rax,%rcx,4), %eax
movslq -0x1c(%rbp), %rdx
leaq 0x1ab1f7fe(%rip), %rcx  # 0x1ab7ee00
subl (%rcx,%rdx,4), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movslq %eax, %rcx
leaq 0x1ab72caa(%rip), %rax  # 0x1abd22c0
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rdx
leaq 0x1ab20508(%rip), %rcx  # 0x1ab7fb30
movl (%rcx,%rdx,4), %ecx
movslq -0x1c(%rbp), %rsi
leaq 0x1ab204fa(%rip), %rdx  # 0x1ab7fb30
subl (%rdx,%rsi,4), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
cmpl $0xf, -0x28(%rbp)
jle 0x5f656
movl $0xf, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x63540
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x671d0
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x63540
movl 0x210(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x672e0
cmpq $0x0, %rax
jne 0x5f6de
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x63540
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x67200
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x5f6e0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: OutputFMAdd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, btfm_t&)
static void
OutputFMAdd( std::string filename, btfm_t &t )
{
  std::ofstream ofs(filename, std::ios::app);

  if (ofs.fail()) {
    std::cerr << "cannot open " << filename << std::endl;
    return;
  }

  ofs << std::scientific << t.w;
  for (int j = 0; j < FM_DIMENSION; j++) {
    ofs << " " << std::scientific << t.v[j];
  }
  ofs << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x230(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
movl $0x1, %edx
callq 0x7a90
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x7030
movb %al, -0x225(%rbp)
jmp 0x5f7d1
movb -0x225(%rbp), %al
testb $0x1, %al
jne 0x5f7dd
jmp 0x5f85c
movq 0x8780c(%rip), %rdi     # 0xe6ff0
leaq 0x4e9f4(%rip), %rsi     # 0xae1df
callq 0x7530
movq %rax, -0x238(%rbp)
jmp 0x5f7f9
movq -0x230(%rbp), %rsi
movq -0x238(%rbp), %rdi
callq 0x7480
movq %rax, -0x240(%rbp)
jmp 0x5f815
movq -0x240(%rbp), %rdi
movq 0x87745(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x5f82a
movl $0x1, -0x220(%rbp)
jmp 0x5f92a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x7820
jmp 0x5f93f
leaq 0xc67d(%rip), %rsi      # 0x6bee0
leaq -0x210(%rbp), %rdi
callq 0x7170
movq %rax, -0x248(%rbp)
jmp 0x5f878
movq -0x248(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x7a60
jmp 0x5f88e
movl $0x0, -0x224(%rbp)
cmpl $0x5, -0x224(%rbp)
jge 0x5f90b
leaq 0x4cb9e(%rip), %rsi     # 0xac446
leaq -0x210(%rbp), %rdi
callq 0x7530
movq %rax, -0x250(%rbp)
jmp 0x5f8bd
movq -0x250(%rbp), %rdi
leaq 0xc615(%rip), %rsi      # 0x6bee0
callq 0x7170
movq %rax, -0x258(%rbp)
jmp 0x5f8d9
movq -0x258(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x224(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
callq 0x7a60
jmp 0x5f8f8
jmp 0x5f8fa
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x5f898
movq 0x87656(%rip), %rsi     # 0xe6f68
leaq -0x210(%rbp), %rdi
callq 0x75b0
jmp 0x5f920
movl $0x0, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x7820
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x79b0
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/learn/FactorizationMachines.cpp
// Function: PlaybackGameForEvaluation(game_info_t*, char const*)
static void
PlaybackGameForEvaluation( game_info_t *game, const char *filename )
{
  SGF_record_t kifu;
  int color = S_BLACK;

  ExtractKifu(filename, &kifu);

  for (int i = 0; i < kifu.moves; i++) {
    const int pos = GetKifuMove(&kifu, i);

    EvaluateMovePrediction(game, pos, color);

    PutStone(game, pos, color);

    color = GetOppositeColor(color);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40c0, %rsp           # imm = 0x40C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x40b4(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40b0(%rbp), %rsi
callq 0x818f0
movl $0x0, -0x40b8(%rbp)
movl -0x40b8(%rbp), %eax
cmpl -0x40ac(%rbp), %eax
jge 0x5f9f9
movl -0x40b8(%rbp), %esi
leaq -0x40b0(%rbp), %rdi
callq 0x81830
movl %eax, -0x40bc(%rbp)
movq -0x8(%rbp), %rdi
movl -0x40bc(%rbp), %esi
movl -0x40b4(%rbp), %edx
callq 0x5fa10
movq -0x8(%rbp), %rdi
movl -0x40bc(%rbp), %esi
movl -0x40b4(%rbp), %edx
callq 0x9dbc0
movl -0x40b4(%rbp), %edi
callq 0x25810
movl %eax, -0x40b4(%rbp)
movl -0x40b8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40b8(%rbp)
jmp 0x5f987
addq $0x40c0, %rsp           # imm = 0x40C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/MinorizationMaximization.cpp
// Function: InitializeLearningData(std::vector<std::vector<mm_t, std::allocator<mm_t>>, std::allocator<std::vector<mm_t, std::allocator<mm_t>>>>&, int, int)
static void
InitializeLearningData( std::vector<std::vector<mm_t> > &data, const int threads, const int data_size )
{
  data.resize(threads);

  for (std::vector<mm_t> &vec : data) {
    vec.resize(data_size);
    for (mm_t &datum : vec) {
      datum.gamma = 1.0;
      datum.w = 0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x777e0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x77870
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x778a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x778d0
testb $0x1, %al
jne 0x72f77
jmp 0x73009
leaq -0x20(%rbp), %rdi
callq 0x77910
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x77930
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x779c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x779f0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x77a20
testb $0x1, %al
jne 0x72fc6
jmp 0x72ff9
leaq -0x40(%rbp), %rdi
callq 0x77a60
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movsd 0x39029(%rip), %xmm0    # 0xac008
movsd %xmm0, 0x18(%rax)
movq -0x50(%rbp), %rax
movl $0x0, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x77a80
jmp 0x72fb3
jmp 0x72ffb
leaq -0x20(%rbp), %rdi
callq 0x77aa0
jmp 0x72f61
addq $0x50, %rsp
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/learn/MinorizationMaximization.cpp
// Function: InitializeSigma()
static void
InitializeSigma( void )
{
  ClearSigma(previous_distance);
  ClearSigma(pat3);
  ClearSigma(md2);
  ClearSigma(capture);
  ClearSigma(save_extension);
  ClearSigma(atari);
  ClearSigma(extension);
  ClearSigma(dame);
  ClearSigma(throw_in);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x772c5(%rip), %rdi     # 0xea2e0
callq 0x756e0
leaq 0x772d1(%rip), %rdi     # 0xea2f8
callq 0x756e0
leaq 0x772dd(%rip), %rdi     # 0xea310
callq 0x756e0
leaq 0x772e9(%rip), %rdi     # 0xea328
callq 0x756e0
leaq 0x772f5(%rip), %rdi     # 0xea340
callq 0x756e0
leaq 0x77301(%rip), %rdi     # 0xea358
callq 0x756e0
leaq 0x7730d(%rip), %rdi     # 0xea370
callq 0x756e0
leaq 0x77319(%rip), %rdi     # 0xea388
callq 0x756e0
leaq 0x77325(%rip), %rdi     # 0xea3a0
callq 0x756e0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/MinorizationMaximization.cpp
// Function: SumWin(int)
static void
SumWin( const int threads )
{
  SumUpWinCount(previous_distance, threads);
  SumUpWinCount(pat3, threads);
  SumUpWinCount(md2, threads);
  SumUpWinCount(capture, threads);
  SumUpWinCount(save_extension, threads);
  SumUpWinCount(atari, threads);
  SumUpWinCount(extension, threads);
  SumUpWinCount(dame, threads);
  SumUpWinCount(throw_in, threads);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x76fab(%rip), %rdi     # 0xea2e0
callq 0x76960
movl -0x4(%rbp), %esi
leaq 0x76fb4(%rip), %rdi     # 0xea2f8
callq 0x76960
movl -0x4(%rbp), %esi
leaq 0x76fbd(%rip), %rdi     # 0xea310
callq 0x76960
movl -0x4(%rbp), %esi
leaq 0x76fc6(%rip), %rdi     # 0xea328
callq 0x76960
movl -0x4(%rbp), %esi
leaq 0x76fcf(%rip), %rdi     # 0xea340
callq 0x76960
movl -0x4(%rbp), %esi
leaq 0x76fd8(%rip), %rdi     # 0xea358
callq 0x76960
movl -0x4(%rbp), %esi
leaq 0x76fe1(%rip), %rdi     # 0xea370
callq 0x76960
movl -0x4(%rbp), %esi
leaq 0x76fea(%rip), %rdi     # 0xea388
callq 0x76960
movl -0x4(%rbp), %esi
leaq 0x76ff3(%rip), %rdi     # 0xea3a0
callq 0x76960
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/learn/MinorizationMaximization.cpp
// Function: SumSigma(int)
static void
SumSigma( const int threads )
{
  SumUpSigma(previous_distance, threads);
  SumUpSigma(pat3, threads);
  SumUpSigma(md2, threads);
  SumUpSigma(capture, threads);
  SumUpSigma(save_extension, threads);
  SumUpSigma(atari, threads);
  SumUpSigma(extension, threads);
  SumUpSigma(dame, threads);
  SumUpSigma(throw_in, threads);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x76f0b(%rip), %rdi     # 0xea2e0
callq 0x76a10
movl -0x4(%rbp), %esi
leaq 0x76f14(%rip), %rdi     # 0xea2f8
callq 0x76a10
movl -0x4(%rbp), %esi
leaq 0x76f1d(%rip), %rdi     # 0xea310
callq 0x76a10
movl -0x4(%rbp), %esi
leaq 0x76f26(%rip), %rdi     # 0xea328
callq 0x76a10
movl -0x4(%rbp), %esi
leaq 0x76f2f(%rip), %rdi     # 0xea340
callq 0x76a10
movl -0x4(%rbp), %esi
leaq 0x76f38(%rip), %rdi     # 0xea358
callq 0x76a10
movl -0x4(%rbp), %esi
leaq 0x76f41(%rip), %rdi     # 0xea370
callq 0x76a10
movl -0x4(%rbp), %esi
leaq 0x76f4a(%rip), %rdi     # 0xea388
callq 0x76a10
movl -0x4(%rbp), %esi
leaq 0x76f53(%rip), %rdi     # 0xea3a0
callq 0x76a10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/learn/MinorizationMaximization.cpp
// Function: SumUpWinCount(std::vector<std::vector<mm_t, std::allocator<mm_t>>, std::allocator<std::vector<mm_t, std::allocator<mm_t>>>>&, int)
static void
SumUpWinCount( std::vector<std::vector<mm_t> > &data, const int threads )
{
  const std::size_t data_size = data[0].size();

  for (int i = 1; i < threads; i++) {
    for (size_t j = 0; j < data_size; j++) {
      data[0][j].w += data[i][j].w;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x792c0
movq %rax, %rdi
callq 0x78990
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x76a02
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x769f5
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x792c0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x792e0
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x792c0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x792e0
movl -0x2c(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7699f
jmp 0x769f7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7698f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)