LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kobanium[P]Ray/src/board/ZobristHash.cpp
// Function: ClearUctHash()
void
ClearUctHash( void )
{
  used = 0;
  enough_size = true;

  for (unsigned int i = 0; i < uct_hash_size; i++) {
    node_hash[i].flag = false;
    node_hash[i].hash = 0;
    node_hash[i].color = 0;
    node_hash[i].moves = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x1c707936(%rip)  # 0x1c7a7214
movb $0x1, 0x1c70792b(%rip)  # 0x1c7a7210
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x4816b(%rip), %eax     # 0xe7a60
jae 0x9f95f
movq 0x1c70790a(%rip), %rax  # 0x1c7a7208
movl -0x4(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x10(%rax)
movq 0x1c7078f5(%rip), %rax  # 0x1c7a7208
movl -0x4(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x1c7078dd(%rip), %rax  # 0x1c7a7208
movl -0x4(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movq 0x1c7078c5(%rip), %rax  # 0x1c7a7208
movl -0x4(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9f8ec
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/board/ZobristHash.cpp
// Function: ClearNotDescendentNodes(std::vector<int, std::allocator<int>>&)
void
ClearNotDescendentNodes( std::vector<int> &indexes )
{
  auto iter = indexes.begin();

  for (int i = 0; i < (int)uct_hash_size; i++) {
    if (*iter == i) {
      iter++;
    } else if (node_hash[i].flag) {
      node_hash[i].flag = false;
      node_hash[i].hash = 0;
      node_hash[i].color = 0;
      node_hash[i].moves = 0;
      used--;
    }
  }

  enough_size = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x558e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x480c7(%rip), %eax     # 0xe7a60
jge 0x9fa5d
leaq -0x10(%rbp), %rdi
callq 0x55980
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x9f9c3
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x9fd80
movq %rax, -0x20(%rbp)
jmp 0x9fa4d
movq 0x1c70783e(%rip), %rax  # 0x1c7a7208
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x10(%rax)
je 0x9fa4b
movq 0x1c707826(%rip), %rax  # 0x1c7a7208
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x10(%rax)
movq 0x1c707810(%rip), %rax  # 0x1c7a7208
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x1c7077f7(%rip), %rax  # 0x1c7a7208
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movq 0x1c7077de(%rip), %rax  # 0x1c7a7208
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movl 0x1c7077d2(%rip), %eax  # 0x1c7a7214
addl $-0x1, %eax
movl %eax, 0x1c7077c9(%rip)  # 0x1c7a7214
jmp 0x9fa4d
jmp 0x9fa4f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9f990
movb $0x1, 0x1c7077ac(%rip)  # 0x1c7a7210
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/board/ZobristHash.cpp
// Function: DeleteOldHash(game_info_t const*)
void
DeleteOldHash( const game_info_t *game )
{
  while (oldest_move < game->moves) {
    for (unsigned int i = 0; i < uct_hash_size; i++) {
      if (node_hash[i].flag && node_hash[i].moves == oldest_move) {
        node_hash[i].flag = false;
        node_hash[i].hash = 0;
        node_hash[i].color = 0;
        node_hash[i].moves = 0;
        used--;
      }
    }
    oldest_move++;
  }

  enough_size = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl 0x1c70779a(%rip), %eax  # 0x1c7a7218
movq -0x8(%rbp), %rcx
cmpl 0x43b0(%rcx), %eax
jge 0x9fb6b
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x47fc2(%rip), %eax     # 0xe7a60
jae 0x9fb57
movq 0x1c70775d(%rip), %rax  # 0x1c7a7208
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x10(%rax)
je 0x9fb47
movq 0x1c707742(%rip), %rax  # 0x1c7a7208
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
cmpl 0x1c70773f(%rip), %eax  # 0x1c7a7218
jne 0x9fb47
movq 0x1c707726(%rip), %rax  # 0x1c7a7208
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x10(%rax)
movq 0x1c707711(%rip), %rax  # 0x1c7a7208
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x1c7076f9(%rip), %rax  # 0x1c7a7208
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movq 0x1c7076e1(%rip), %rax  # 0x1c7a7208
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movl 0x1c7076d6(%rip), %eax  # 0x1c7a7214
addl $-0x1, %eax
movl %eax, 0x1c7076cd(%rip)  # 0x1c7a7214
jmp 0x9fb49
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9fa95
movl 0x1c7076bb(%rip), %eax  # 0x1c7a7218
addl $0x1, %eax
movl %eax, 0x1c7076b2(%rip)  # 0x1c7a7218
jmp 0x9fa78
movb $0x1, 0x1c70769e(%rip)  # 0x1c7a7210
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/board/ZobristHash.cpp
// Function: SearchEmptyIndex(unsigned long long, int, int)
unsigned int
SearchEmptyIndex( const unsigned long long hash, const int color, const int moves )
{
  const unsigned int key = TransHash(hash);
  unsigned int i = key;

  do {
    if (!node_hash[i].flag) {
      node_hash[i].flag = true;
      node_hash[i].hash = hash;
      node_hash[i].moves = moves;
      node_hash[i].color = color;
      used++;
      if (used > uct_hash_limit) enough_size = false;
      return i;
    }
    i++;
    if (i >= uct_hash_size) i = 0;
  } while (i != key);

  return uct_hash_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f450
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq 0x1c70765d(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x10(%rax)
jne 0x9fc46
movq 0x1c707642(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x1c707629(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq 0x1c707612(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movq 0x1c7075fb(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl 0x1c7075f4(%rip), %eax  # 0x1c7a7214
addl $0x1, %eax
movl %eax, 0x1c7075eb(%rip)  # 0x1c7a7214
movl 0x1c7075e5(%rip), %eax  # 0x1c7a7214
cmpl 0x47e2f(%rip), %eax     # 0xe7a64
jbe 0x9fc3e
movb $0x0, 0x1c7075d2(%rip)  # 0x1c7a7210
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9fc78
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x47e08(%rip), %eax     # 0xe7a60
jb 0x9fc61
movl $0x0, -0x20(%rbp)
jmp 0x9fc63
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x9fba4
movl 0x47deb(%rip), %eax     # 0xe7a60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/board/ZobristHash.cpp
// Function: FindSameHashIndex(unsigned long long, int, int)
unsigned int
FindSameHashIndex( const unsigned long long hash, const int color, const int moves)
{
  const unsigned int key = TransHash(hash);
  unsigned int i = key;

  do {
    if (!node_hash[i].flag) {
      return uct_hash_size;
    } else if (node_hash[i].hash == hash &&
               node_hash[i].color == color &&
               node_hash[i].moves == moves) {
      return i;
    }
    i++;
    if (i >= uct_hash_size) i = 0;
  } while (i != key);

  return uct_hash_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f450
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq 0x1c70754d(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x10(%rax)
jne 0x9fcd9
movl 0x47d8f(%rip), %eax     # 0xe7a60
movl %eax, -0x4(%rbp)
jmp 0x9fd61
movq 0x1c707528(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x9fd2d
movq 0x1c70750e(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x9fd2d
movq 0x1c7074f5(%rip), %rax  # 0x1c7a7208
movl -0x20(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x9fd2d
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9fd61
jmp 0x9fd2f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x47d1f(%rip), %eax     # 0xe7a60
jb 0x9fd4a
movl $0x0, -0x20(%rbp)
jmp 0x9fd4c
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x9fcb4
movl 0x47d02(%rip), %eax     # 0xe7a60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/board/DynamicKomi.cpp
// Function: SetHandicapNum(int)
void
SetHandicapNum( const int num )
{
  if (const_handicap_num == 0) {
    handicap_num = num;
    if (dk_mode != DK_OFF && handicap_num == 0) {
      dk_mode = DK_OFF;
    } else if (dk_mode == DK_OFF &&  handicap_num != 0) {
      dk_mode = DK_LINEAR;
    } 
  } else {
    handicap_num = const_handicap_num;
    dk_mode = DK_LINEAR;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x1c70745a(%rip)  # 0x1c7a7248
jne 0x9fe37
movl -0x4(%rbp), %eax
movl %eax, 0x1c707453(%rip)  # 0x1c7a724c
cmpl $0x0, 0x1c707450(%rip)  # 0x1c7a7250
je 0x9fe17
cmpl $0x0, 0x1c707443(%rip)  # 0x1c7a724c
jne 0x9fe17
movl $0x0, 0x1c70743b(%rip)  # 0x1c7a7250
jmp 0x9fe35
cmpl $0x0, 0x1c707432(%rip)  # 0x1c7a7250
jne 0x9fe33
cmpl $0x0, 0x1c707425(%rip)  # 0x1c7a724c
je 0x9fe33
movl $0x1, 0x1c70741d(%rip)  # 0x1c7a7250
jmp 0x9fe35
jmp 0x9fe4d
movl 0x1c70740b(%rip), %eax  # 0x1c7a7248
movl %eax, 0x1c707409(%rip)  # 0x1c7a724c
movl $0x1, 0x1c707403(%rip)  # 0x1c7a7250
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/board/DynamicKomi.cpp
// Function: DynamicKomi(game_info_t const*, uct_node_t const*, int)
void
DynamicKomi( const game_info_t *game, const uct_node_t *root, const int color )
{
  if (handicap_num != 0) {
    switch(dk_mode) {
      case DK_LINEAR:
        LinearHandicap(game);
        break;
      case DK_VALUE:
        ValueSituational(root, color);
        break;
      default:
        break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0x1c7073e2(%rip)  # 0x1c7a724c
je 0x9fea3
movl 0x1c7073de(%rip), %eax  # 0x1c7a7250
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x9fe86
jmp 0x9fe7c
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x9fe91
jmp 0x9fe9f
movq -0x8(%rbp), %rdi
callq 0x9feb0
jmp 0x9fea1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9ff80
jmp 0x9fea1
jmp 0x9fea1
jmp 0x9fea3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/board/DynamicKomi.cpp
// Function: LinearHandicap(game_info_t const*)
static void
LinearHandicap( const game_info_t *game )
{
  if (game->moves > LINEAR_THRESHOLD - 15) {
  // 手数が進んだらコミを変動しない
    dynamic_komi[0] = static_cast<double>(handicap_num) + 0.5;
  } else {
    // 新しいコミの値の計算
    dynamic_komi[0] = HANDICAP_WEIGHT * handicap_num * (1.0 - (static_cast<double>(game->moves) / LINEAR_THRESHOLD));
  }
  // 新しいコミの値を代入
  dynamic_komi[S_BLACK] = dynamic_komi[0] + 1;
  dynamic_komi[S_WHITE] = dynamic_komi[0] - 1;

  PrintKomiValue();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xb9, 0x43b0(%rax)
jle 0x9feed
cvtsi2sdl 0x1c707378(%rip), %xmm0 # 0x1c7a724c
movsd 0xc134(%rip), %xmm1     # 0xac010
addsd %xmm1, %xmm0
leaq 0x1aade1c9(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, (%rax)
jmp 0x9ff2d
movl 0x1c707359(%rip), %eax  # 0x1c7a724c
shll $0x3, %eax
cvtsi2sd %eax, %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl 0x43b0(%rax), %xmm2
movsd 0x100da(%rip), %xmm1    # 0xaffe8
divsd %xmm1, %xmm2
movsd 0xc0ee(%rip), %xmm1     # 0xac008
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
leaq 0x1aade187(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, (%rax)
movsd 0xc0d3(%rip), %xmm0     # 0xac008
leaq 0x1aade174(%rip), %rax  # 0x1ab7e0b0
addsd (%rax), %xmm0
leaq 0x1aade169(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, 0x8(%rax)
leaq 0x1aade15d(%rip), %rax  # 0x1ab7e0b0
movsd (%rax), %xmm0
movsd 0xc0a9(%rip), %xmm1     # 0xac008
subsd %xmm1, %xmm0
leaq 0x1aade146(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, 0x10(%rax)
callq 0x22210
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/board/DynamicKomi.cpp
// Function: ValueSituational(uct_node_t const*, int)
static void
ValueSituational( const uct_node_t *root, const int color )
{
  const double win_rate = static_cast<double>(root->win) / root->move_count;

  // 次の探索の時のコミを求める
  if (color == S_BLACK) {
    if (win_rate < RED) {
      dynamic_komi[0]--;
    } else if (win_rate > GREEN) {
      dynamic_komi[0]++;
    }
  } else if (color == S_WHITE) {
    if (win_rate < RED) {
      dynamic_komi[0]++;
    } else if (win_rate > GREEN) {
      dynamic_komi[0]--;
    }
  }

  dynamic_komi[S_BLACK] = dynamic_komi[0] + 1.0;
  dynamic_komi[S_WHITE] = dynamic_komi[0] - 1.0;

  PrintKomiValue();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc, %rdi
callq 0x25780
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x25780
movsd -0x20(%rbp), %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0xa002e
movsd 0x1001e(%rip), %xmm0    # 0xafff0
ucomisd -0x18(%rbp), %xmm0
jbe 0x9fff9
movsd 0xdf2f(%rip), %xmm0     # 0xadf10
leaq 0x1aade0c8(%rip), %rax  # 0x1ab7e0b0
addsd (%rax), %xmm0
leaq 0x1aade0bd(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, (%rax)
jmp 0xa002c
movsd -0x18(%rbp), %xmm0
movsd 0xfff2(%rip), %xmm1     # 0xafff8
ucomisd %xmm1, %xmm0
jbe 0xa002a
movsd 0xbff4(%rip), %xmm0     # 0xac008
leaq 0x1aade095(%rip), %rax  # 0x1ab7e0b0
addsd (%rax), %xmm0
leaq 0x1aade08a(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, (%rax)
jmp 0xa002c
jmp 0xa009a
cmpl $0x2, -0xc(%rbp)
jne 0xa0098
movsd 0xffb4(%rip), %xmm0     # 0xafff0
ucomisd -0x18(%rbp), %xmm0
jbe 0xa0063
movsd 0xbfbd(%rip), %xmm0     # 0xac008
leaq 0x1aade05e(%rip), %rax  # 0x1ab7e0b0
addsd (%rax), %xmm0
leaq 0x1aade053(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, (%rax)
jmp 0xa0096
movsd -0x18(%rbp), %xmm0
movsd 0xff88(%rip), %xmm1     # 0xafff8
ucomisd %xmm1, %xmm0
jbe 0xa0094
movsd 0xde92(%rip), %xmm0     # 0xadf10
leaq 0x1aade02b(%rip), %rax  # 0x1ab7e0b0
addsd (%rax), %xmm0
leaq 0x1aade020(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, (%rax)
jmp 0xa0096
jmp 0xa0098
jmp 0xa009a
movsd 0xbf66(%rip), %xmm0     # 0xac008
leaq 0x1aade007(%rip), %rax  # 0x1ab7e0b0
addsd (%rax), %xmm0
leaq 0x1aaddffc(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, 0x8(%rax)
leaq 0x1aaddff0(%rip), %rax  # 0x1ab7e0b0
movsd (%rax), %xmm0
movsd 0xbf3c(%rip), %xmm1     # 0xac008
subsd %xmm1, %xmm0
leaq 0x1aaddfd9(%rip), %rax  # 0x1ab7e0b0
movsd %xmm0, 0x10(%rax)
callq 0x22210
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/feature/SimulationFeature.cpp
// Function: SetCrossPosition()
void
SetCrossPosition( void )
{
  cross[0] = -board_size - 1;
  cross[1] = -board_size + 1;
  cross[2] =  board_size - 1;
  cross[3] =  board_size + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x4727f(%rip), %rcx     # 0xe7a4c
subl (%rcx), %eax
subl $0x1, %eax
movl %eax, 0x1c707068(%rip)  # 0x1c7a7840
xorl %eax, %eax
leaq 0x4726b(%rip), %rcx     # 0xe7a4c
subl (%rcx), %eax
addl $0x1, %eax
movl %eax, 0x1c707058(%rip)  # 0x1c7a7844
leaq 0x47259(%rip), %rax     # 0xe7a4c
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x1c70704a(%rip)  # 0x1c7a7848
leaq 0x47247(%rip), %rax     # 0xe7a4c
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0x1c70703c(%rip)  # 0x1c7a784c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/feature/Territory.cpp
// Function: IsRemainingDeadStone(game_info_t const*, int, statistic_t const*)
bool
IsRemainingDeadStone( const game_info_t *game, const int color, const statistic_t statistic[] )
{
  const char *board = game->board;
  const int other = GetOppositeColor(color);
  double owner[BOARD_MAX];

  std::fill_n(owner, BOARD_MAX, 0);

  CalculateOwner(statistic, color, owner);

  for (int i = 0; i < pure_board_max; i++) {
    const int pos = onboard_pos[i];
    if (board[pos] == other && owner[pos] > 0.95) {
      return true;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a90, %rsp           # imm = 0x1A90
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x43f8, %rax           # imm = 0x43F8
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x25810
movl %eax, -0x2c(%rbp)
leaq -0x1a80(%rbp), %rdi
movl $0x0, -0x1a84(%rbp)
movl $0x349, %esi            # imm = 0x349
leaq -0x1a84(%rbp), %rdx
callq 0xa3800
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x1a80(%rbp), %rdx
callq 0xa3730
movl $0x0, -0x1a88(%rbp)
movl -0x1a88(%rbp), %eax
leaq 0x44395(%rip), %rcx     # 0xe7a40
cmpl (%rcx), %eax
jge 0xa3711
movslq -0x1a88(%rbp), %rcx
leaq 0x1ab2f1b3(%rip), %rax  # 0x1abd2870
movl (%rax,%rcx,4), %eax
movl %eax, -0x1a8c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1a8c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x2c(%rbp), %eax
jne 0xa36fe
movslq -0x1a8c(%rbp), %rax
movsd -0x1a80(%rbp,%rax,8), %xmm0
movsd 0xbbde(%rip), %xmm1     # 0xaf2d0
ucomisd %xmm1, %xmm0
jbe 0xa36fe
movb $0x1, -0x1(%rbp)
jmp 0xa3715
jmp 0xa3700
movl -0x1a88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a88(%rbp)
jmp 0xa369e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1a90, %rsp           # imm = 0x1A90
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/feature/Territory.cpp
// Function: CalculateOwner(statistic_t const*, int, double*)
static void
CalculateOwner( const statistic_t statistic[], const int color, double owner[] )
{
  for (int i = 0; i < pure_board_max; i++) {
    const int pos = onboard_pos[i];
    const int sum = statistic[pos].colors[S_BLACK] + statistic[pos].colors[S_WHITE];
    if (sum != 0) {
      owner[pos] = static_cast<double>(statistic[pos].colors[color]) / sum;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x442ec(%rip), %rcx     # 0xe7a40
cmpl (%rcx), %eax
jge 0xa37f9
movslq -0x1c(%rbp), %rcx
leaq 0x1ab2f109(%rip), %rax  # 0x1abd2870
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x25780
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xa37e9
movq -0x8(%rbp), %rdi
movslq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x25780
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xa37eb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa374a
addq $0x30, %rsp
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/feature/Nakade.cpp
// Function: SearchNakade(game_info_t const*, int*, int*)
void
SearchNakade( const game_info_t *game, int *nakade_num, int *nakade_pos )
{
  const int last_color = game->record[game->moves - 1].color;
  const int pos = game->record[game->moves - 1].pos;
  const unsigned int mask[2][4] = {
    {0x0004, 0x0040, 0x0100, 0x1000}, {0x0008, 0x0080, 0x0200, 0x2000},
  };
  const unsigned int all_mask[2] = {
    0x1144, 0x2288
  };
  const int neighbor4[4] = { NORTH(pos), WEST(pos), EAST(pos), SOUTH(pos) };
  const unsigned int pat3 = Pat3(game->pat, pos);

  // ナカデが出現し得ないパターンなら戻る
  if ((nakade_pat3_mask[pat3] & all_mask[last_color - 1]) == 0) return;

  for (int i = 0; i < 4; i++) {
    if ((nakade_pat3_mask[pat3] & mask[last_color - 1][i]) != 0) {
      nakade_pos[(*nakade_num)++] = FindNakadePos(game, neighbor4[i], last_color);
    }
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x43b0(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x43b0(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movq 0xc4e4(%rip), %rax      # 0xb1040
movq %rax, -0x40(%rbp)
movq 0xc4e1(%rip), %rax      # 0xb1048
movq %rax, -0x38(%rbp)
movq 0xc4de(%rip), %rax      # 0xb1050
movq %rax, -0x30(%rbp)
movq 0xc4db(%rip), %rax      # 0xb1058
movq %rax, -0x28(%rbp)
movq 0xc4d8(%rip), %rax      # 0xb1060
movq %rax, -0x48(%rbp)
movl -0x20(%rbp), %eax
leaq 0x42eb6(%rip), %rcx     # 0xe7a4c
subl (%rcx), %eax
movl %eax, -0x60(%rbp)
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x5c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
movl -0x20(%rbp), %eax
leaq 0x42e95(%rip), %rcx     # 0xe7a4c
addl (%rcx), %eax
movl %eax, -0x54(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4748, %rdi           # imm = 0x4748
movl -0x20(%rbp), %esi
callq 0x93d30
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, %ecx
leaq 0x1c702e52(%rip), %rax  # 0x1c7a7a30
movl (%rax,%rcx,4), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
andl -0x48(%rbp,%rcx,4), %eax
cmpl $0x0, %eax
jne 0xa4bf5
jmp 0xa4c6b
movl $0x0, -0x68(%rbp)
cmpl $0x4, -0x68(%rbp)
jge 0xa4c6b
movl -0x64(%rbp), %eax
movl %eax, %ecx
leaq 0x1c702e22(%rip), %rax  # 0x1c7a7a30
movl (%rax,%rcx,4), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
leaq -0x40(%rbp), %rcx
shlq $0x4, %rdx
addq %rdx, %rcx
movslq -0x68(%rbp), %rdx
andl (%rcx,%rdx,4), %eax
cmpl $0x0, %eax
je 0xa4c5e
movq -0x8(%rbp), %rdi
movslq -0x68(%rbp), %rax
movl -0x60(%rbp,%rax,4), %esi
movl -0x1c(%rbp), %edx
callq 0xa4c80
movl %eax, %edx
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xa4c60
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0xa4bfc
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/feature/Nakade.cpp
// Function: Enqueue(nakade_queue_t*, int)
static void
Enqueue( nakade_queue_t *nq, int pos )
{
  nq->pos[nq->tail++] = pos;
  if (nq->tail >= NAKADE_QUEUE_SIZE) {
    nq->tail = 0;
  }
  if (nq->tail == nq->head) {
    std::cerr << "queue  overflow" << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movl 0x7c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x7c(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
cmpl $0x1e, 0x7c(%rax)
jl 0xa5150
movq -0x8(%rbp), %rax
movl $0x0, 0x7c(%rax)
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jne 0xa5182
movq 0x41e89(%rip), %rdi     # 0xe6ff0
leaq 0xae92(%rip), %rsi      # 0xb0000
callq 0x7530
movq %rax, %rdi
movq 0x41deb(%rip), %rsi     # 0xe6f68
callq 0x75b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/feature/Nakade.cpp
// Function: Dequeue(nakade_queue_t*)
static int
Dequeue( nakade_queue_t *nq )
{
  int pos;

  if (nq->head == nq->tail) {
    std::cerr << "queue underflow" << std::endl;
    exit(1);
  } else {
    pos = nq->pos[nq->head++];
    if (nq->head >= NAKADE_QUEUE_SIZE) {
      nq->head = 0;
    }
    return pos;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x7c(%rcx), %eax
jne 0xa51f8
movq 0x41e1d(%rip), %rdi     # 0xe6ff0
leaq 0xae36(%rip), %rsi      # 0xb0010
callq 0x7530
movq %rax, %rdi
movq 0x41d7f(%rip), %rsi     # 0xe6f68
callq 0x75b0
movl $0x1, %edi
callq 0x76a0
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x78(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x78(%rdx)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1e, 0x78(%rax)
jl 0xa5229
movq -0x8(%rbp), %rax
movl $0x0, 0x78(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kobanium[P]Ray/src/feature/UctFeature.cpp
// Function: CheckCaptureAfterKoForTree(game_info_t const*, int, unsigned int*)
void
CheckCaptureAfterKoForTree( const game_info_t *game, const int color, unsigned int *tactical_features )
{
  const string_t *string = game->string;
  const char *board = game->board;
  const int *string_id = game->string_id;
  const int other = GetOppositeColor(color);
  const int previous_move_2 = game->record[game->moves - 2].pos;
  int id, lib, neighbor4[4];
  GetNeighbor4(neighbor4, previous_move_2);

  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == other) {
      id = string_id[neighbor4[i]];
      if (string[id].libs == 1) {
        lib = string[id].lib[0];
        CompareSwapFeature(tactical_features, lib, UCT_CAPTURE_INDEX, UCT_CAPTURE_AFTER_KO);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x9620, %rax           # imm = 0x9620
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x43f8, %rax           # imm = 0x43F8
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x95720, %rax          # imm = 0x95720
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
callq 0x25810
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x43b0(%rcx), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x9bc90
movl $0x0, -0x54(%rbp)
cmpl $0x4, -0x54(%rbp)
jge 0xa7421
movq -0x28(%rbp), %rax
movslq -0x54(%rbp), %rcx
movslq -0x50(%rbp,%rcx,4), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x34(%rbp), %eax
jne 0xa7411
movq -0x30(%rbp), %rax
movslq -0x54(%rbp), %rcx
movslq -0x50(%rbp,%rcx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x1, 0x4(%rax)
jne 0xa740f
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movswl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x40(%rbp), %esi
xorl %edx, %edx
movl $0x7, %ecx
callq 0xa7430
jmp 0xa7411
jmp 0xa7413
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xa739c
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/feature/UctFeature.cpp
// Function: CheckAtariForTree(game_info_t const*, int, int, unsigned int*)
void
CheckAtariForTree( const game_info_t *game, const int color, const int pos, unsigned int *tactical_features )
{
  const char *board = game->board;
  const int other = GetOppositeColor(color);
  const string_t *string = game->string;
  const int *string_id = game->string_id;
  int id, neighbor4[4];

  GetNeighbor4(neighbor4, pos);

  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == other) {
      id = string_id[neighbor4[i]];
      if (string[id].libs == 2) {
        CompareSwapFeature(tactical_features, pos, UCT_ATARI_INDEX, UCT_ATARI);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x43f8, %rax           # imm = 0x43F8
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x25810
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
addq $0x9620, %rax           # imm = 0x9620
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0x95720, %rax          # imm = 0x95720
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x9bc90
movl $0x0, -0x54(%rbp)
cmpl $0x4, -0x54(%rbp)
jge 0xa7aaa
movq -0x20(%rbp), %rax
movslq -0x54(%rbp), %rcx
movslq -0x50(%rbp,%rcx,4), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x24(%rbp), %eax
jne 0xa7a9d
movq -0x38(%rbp), %rax
movslq -0x54(%rbp), %rcx
movslq -0x50(%rbp,%rcx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x2, 0x4(%rax)
jne 0xa7a9b
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movl $0x2, %edx
movl $0x1, %ecx
callq 0xa7430
jmp 0xa7a9d
jmp 0xa7a9f
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xa7a3e
addq $0x60, %rsp
popq %rbp
retq
// File: kobanium[P]Ray/src/feature/UctFeature.cpp
// Function: CheckKoRecaptureForTree(game_info_t const*, int, unsigned int*)
void
CheckKoRecaptureForTree( const game_info_t *game, const int color, unsigned int *tactical_features )
{
  const string_t *string = game->string;
  const char *board = game->board;
  const int *string_id = game->string_id;
  const int pm3 = game->record[game->moves - 3].pos;
  const int other = GetOppositeColor(color);

  if (board[pm3] == other) {
    const int id = string_id[pm3];
    if (string[id].libs == 1) {
      const int lib = string[id].lib[0];
      CompareSwapFeature(tactical_features, lib, UCT_CAPTURE_INDEX, UCT_KO_RECAPTURE);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x9620, %rax           # imm = 0x9620
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x43f8, %rax           # imm = 0x43F8
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x95720, %rax          # imm = 0x95720
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x43b0(%rcx), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %edi
callq 0x25810
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x38(%rbp), %eax
jne 0xa7bce
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x1, 0x4(%rax)
jne 0xa7bcc
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movswl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x40(%rbp), %esi
xorl %edx, %edx
movl $0x6, %ecx
callq 0xa7430
jmp 0xa7bce
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/feature/Semeai.cpp
// Function: CapturableCandidate(game_info_t const*, int)
int
CapturableCandidate( const game_info_t *game, const int id )
{
  const string_t *string = game->string;
  int neighbor = string[id].neighbor[0];
  bool flag = false;
  int capturable_pos = -1;

  // 隣接する呼吸点が1つの敵連が1つだけの時, 候補を返す
  while (neighbor != NEIGHBOR_END) {
    if (string[neighbor].libs == 1) {
      if (string[neighbor].size >= 2) {
        return -1;
      } else {
        if (flag) {
          return -1;
        }
        capturable_pos = string[neighbor].lib[0];
        flag = true;
      }
    }
    neighbor = string[id].neighbor[neighbor];
  }

  return capturable_pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x9620, %rax           # imm = 0x9620
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movswl 0x57c(%rax), %eax
movl %eax, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
cmpl $0x11f, -0x24(%rbp)     # imm = 0x11F
je 0xa832d
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x1, 0x4(%rax)
jne 0xa8307
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x2, 0x7c0(%rax)
jl 0xa82d9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa8333
testb $0x1, -0x25(%rbp)
je 0xa82e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa8333
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movswl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movb $0x1, -0x25(%rbp)
jmp 0xa8307
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
movswl 0x57c(%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
jmp 0xa8290
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/feature/Semeai.cpp
// Function: IsDeadlyExtension(game_info_t const*, int, int)
bool
IsDeadlyExtension( const game_info_t *game, const int color, const int id )
{
  const int other = GetOppositeColor(color);
  int pos = game->string[id].lib[0];

  if (nb4_empty[Pat3(game->pat, pos)] == 0 &&
      IsSuicide(game, game->string, other, pos)) {
    return true;
  }

  std::unique_ptr<search_game_info_t> search_game_data(new search_game_info_t(game));
  search_game_info_t *search_game = search_game_data.get();

  PutStoneForSearch(search_game, pos, other);

  if (search_game->string[search_game->string_id[pos]].libs == 1) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x25810
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x9620, %rax           # imm = 0x9620
movslq -0x18(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movswl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4748, %rdi           # imm = 0x4748
movl -0x20(%rbp), %esi
callq 0x93d30
movl %eax, %eax
movl %eax, %ecx
leaq 0x1ab084c6(%rip), %rax  # 0x1abb0860
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xa83cc
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x9620, %rsi           # imm = 0x9620
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x9d360
testb $0x1, %al
jne 0xa83c3
jmp 0xa83cc
movb $0x1, -0x1(%rbp)
jmp 0xa8498
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x7550
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x98300
jmp 0xa83eb
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xaa250
movq -0x58(%rbp), %rdi
callq 0xaa280
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x98700
jmp 0xa841a
movq -0x40(%rbp), %rax
addq $0x95f0, %rax           # imm = 0x95F0
movq -0x40(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movslq 0x956f0(%rcx,%rdx,4), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x1, 0x4(%rax)
jne 0xa8484
movb $0x1, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0xa848f
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x69ae40, %esi         # imm = 0x69AE40
callq 0x7560
jmp 0xa84a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaa2b0
jmp 0xa84a3
movb $0x0, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaa2b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x79b0
nopl (%rax)
// File: kobanium[P]Ray/src/feature/Semeai.cpp
// Function: IsSelfAtariCapture(game_info_t const*, int, int, int)
bool
IsSelfAtariCapture( const game_info_t *game, const int pos, const int color, const int id )
{
  if (!IsLegal(game, pos, color)) {
    return false;
  }

  std::unique_ptr<search_game_info_t> search_game(new search_game_info_t(game));
  search_game_info_t *capture_game = search_game.get();

  PutStoneForSearch(capture_game, pos, color);

  const string_t *string = capture_game->string;
  const int *string_id = capture_game->string_id;
  const int string_pos = game->string[id].origin;

  if (string[string_id[string_pos]].libs == 1) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9d0b0
testb $0x1, %al
jne 0xa84e1
movb $0x0, -0x1(%rbp)
jmp 0xa85e0
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x7550
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
callq 0x98300
jmp 0xa8500
movq -0x60(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xaa250
movq -0x68(%rbp), %rdi
callq 0xaa280
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x98700
jmp 0xa852f
movq -0x40(%rbp), %rax
addq $0x95f0, %rax           # imm = 0x95F0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x956f0, %rax          # imm = 0x956F0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
addq $0x9620, %rax           # imm = 0x9620
movslq -0x1c(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movslq -0x54(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x1, 0x4(%rax)
jne 0xa85cc
movb $0x1, -0x1(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0xa85d7
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x69ae40, %esi         # imm = 0x69AE40
callq 0x7560
jmp 0xa85eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaa2b0
jmp 0xa85eb
movb $0x0, -0x1(%rbp)
movl $0x1, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaa2b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x79b0
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/feature/Semeai.cpp
// Function: CheckLibertyState(game_info_t const*, int, int, int)
int
CheckLibertyState( const game_info_t *game, const int pos, const int color, const int id )
{
  const int string_pos = game->string[id].origin;
  const int libs = game->string[id].libs;

  if (!IsLegal(game, pos, color)) {
    return L_DECREASE;
  }

  std::unique_ptr<search_game_info_t> search_game(new search_game_info_t(game));
  search_game_info_t *liberty_game = search_game.get();

  PutStoneForSearch(liberty_game, pos, color);

  const string_t *string = liberty_game->string;
  const int *string_id = liberty_game->string_id;
  const int new_libs = string[string_id[string_pos]].libs;

  if (new_libs > libs + 1) {
    return L_INCREASE;
  } else if (new_libs > libs) {
    return L_EVEN;
  } else {
    return L_DECREASE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x9620, %rax           # imm = 0x9620
movslq -0x1c(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x9620, %rax           # imm = 0x9620
movslq -0x1c(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9d0b0
testb $0x1, %al
jne 0xa8673
movl $0x0, -0x4(%rbp)
jmp 0xa877c
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x7550
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
callq 0x98300
jmp 0xa8692
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xaa250
movq -0x70(%rbp), %rdi
callq 0xaa280
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x98700
jmp 0xa86c1
movq -0x48(%rbp), %rax
addq $0x95f0, %rax           # imm = 0x95F0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq $0x956f0, %rax          # imm = 0x956F0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xa874d
movl $0x2, -0x4(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0xa8773
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x69ae40, %esi         # imm = 0x69AE40
callq 0x7560
jmp 0xa8785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xaa2b0
jmp 0xa8785
movl -0x5c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0xa8765
movl $0x1, -0x4(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0xa8773
movl $0x0, -0x4(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xaa2b0
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x79b0
nop
// File: alfanick[P]rest-cpp/src/rest/request.cpp
// Function: REST::Request::Request(int, sockaddr_storage)
Request::Request(int client, struct sockaddr_storage client_addr) : handle(client), addr(client_addr) {
  time = std::chrono::high_resolution_clock::now();

  // TODO config
  struct timeval tv {
    .tv_sec = 30,
    .tv_usec = 0
  };

  // set timeout for reading
  setsockopt(handle, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval));
}

// Assembly:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movl $0x9, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x959e0
movq 0x38(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x18(%rsp)
callq 0x939e0
movq 0x38(%rsp), %rdi
addq $0x58, %rdi
movq %rdi, 0x20(%rsp)
callq 0x92960
movq 0x38(%rsp), %rdi
addq $0x88, %rdi
movq %rdi, 0x28(%rsp)
callq 0x959e0
movq 0x38(%rsp), %rdi
movq $0x0, 0xa8(%rdi)
addq $0xb0, %rdi
movq %rdi, 0x30(%rsp)
callq 0x91aa0
movq 0x38(%rsp), %rdi
addq $0xc0, %rdi
callq 0x991b0
jmp 0x99e08
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x6c(%rsp), %eax
movl %eax, 0xc8(%rdi)
addq $0xd0, %rdi
movl $0x80, %edx
callq 0x91de0
callq 0x8d460
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0xc0(%rax)
movq 0x4a3c6(%rip), %rcx     # 0xe4218
movq %rcx, 0x40(%rsp)
movq 0x4a3c2(%rip), %rcx     # 0xe4220
movq %rcx, 0x48(%rsp)
movl 0xc8(%rax), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq 0x40(%rsp), %rcx
movl $0x10, %r8d
callq 0x982f0
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x90790
movq 0x28(%rsp), %rdi
callq 0x99830
movq 0x20(%rsp), %rdi
callq 0x94e50
movq 0x18(%rsp), %rdi
callq 0x90140
movq 0x10(%rsp), %rdi
callq 0x99830
movq 0x60(%rsp), %rdi
callq 0x981c0
nopw %cs:(%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/request.h
// Function: int REST::Request::header<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&) const
T header(std::string const& key, const T& default_value) const {
      auto h = headers.find(key);
      if (h == headers.end())
        return default_value;
      else
        return Utils::parse_string<T>(h->second);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
callq 0x97dd0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x28, %rdi
callq 0x97690
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x94f80
testb $0x1, %al
jne 0x9b3b6
jmp 0x9b3c3
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x9b3dd
leaq 0x10(%rsp), %rdi
callq 0x99130
movq %rax, %rdi
addq $0x20, %rdi
callq 0x96fe0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/request.h
// Function: REST::Request::header(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) const
std::string header(std::string const& key, const char default_value[]) const {
      auto h = headers.find(key);
      if (h == headers.end())
        return default_value;
      else
        return h->second;
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x28, %rdi
movq 0x60(%rsp), %rsi
callq 0x97dd0
movq 0x28(%rsp), %rdi
movq %rax, 0x50(%rsp)
addq $0x28, %rdi
callq 0x97690
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x94f80
testb $0x1, %al
jne 0x9b4ea
jmp 0x9b53f
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x98200
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x95700
jmp 0x9b519
leaq 0x47(%rsp), %rdi
callq 0x938a0
jmp 0x9b55a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x938a0
jmp 0x9b564
leaq 0x50(%rsp), %rdi
callq 0x99130
movq 0x18(%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x8f440
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x981c0
nop
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::parser::parse()
basic_json parse()
        {
            basic_json result = parse_internal(true);

            expect(lexer::token_type::end_of_input);

            // return parser result and replace it with null in case the
            // top-level value was discarded by the callback function
            return result.is_discarded() ? basic_json() : result;
        }

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x94220
movq 0x10(%rsp), %rdi
movl $0xd, %esi
callq 0x90420
jmp 0x9c6e4
leaq 0x28(%rsp), %rdi
callq 0x913e0
testb $0x1, %al
jne 0x9c6f4
jmp 0x9c70f
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x8ffc0
movq (%rsp), %rdi
callq 0x91aa0
jmp 0x9c721
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x95820
jmp 0x9c71f
jmp 0x9c721
leaq 0x28(%rsp), %rdi
callq 0x90790
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x90790
movq 0x20(%rsp), %rdi
callq 0x981c0
nopw (%rax,%rax)