LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: InitializeTimeSetting()
void
InitializeTimeSetting( void )
{
  for (int i = 0; i < S_MAX; i++) {
    remaining_time[i] = default_remaining_time;
  }

  switch (search_setting) {
    case SearchTimeStrategy::ConstantPlayoutMode:
      time_limit = 10000.0;
      po_info.num = playout;
      extend_time = false;
      break;
    case SearchTimeStrategy::ConstantTimeMode:
      time_limit = const_thinking_time;
      po_info.num = 10000000;
      extend_time = false;
      break;
    case SearchTimeStrategy::TimeControlMode:
    case SearchTimeStrategy::TimeControlWithByoYomiMode:
      time_limit = CalculateNextTimeLimit(S_EMPTY, -1);
      po_info.num = static_cast<int>(PLAYOUT_SPEED * time_limit);
      extend_time = true;
      break;
  }
}

// Assembly:
movsd 0x2941a(%rip), %xmm0    # 0x76898
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm0, 0x1aabec06(%rip) # 0x1ab0c090
movapd %xmm0, 0x1aabec0e(%rip) # 0x1ab0c0a0
movl 0x293f0(%rip), %eax     # 0x76888
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jb 0x4d4c4
cmpl $0x1, %eax
je 0x4d4ff
testl %eax, %eax
jne 0x4d522
movabsq $0x40c3880000000000, %rax # imm = 0x40C3880000000000
movq %rax, 0x1aabebbe(%rip)  # 0x1ab0c078
cvttsd2si 0x293ce(%rip), %eax # 0x76890
jmp 0x4d514
movsd 0x1aabebc4(%rip), %xmm0 # 0x1ab0c090
movl 0x293da(%rip), %eax     # 0x768ac
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
addl 0x293c9(%rip), %ecx     # 0x768a8
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x1aabeb89(%rip) # 0x1ab0c078
mulsd 0x12b49(%rip), %xmm0    # 0x60040
cvttsd2si %xmm0, %eax
movb $0x1, %cl
jmp 0x4d516
movsd 0x29399(%rip), %xmm0    # 0x768a0
movsd %xmm0, 0x1aabeb69(%rip) # 0x1ab0c078
movl $0x989680, %eax         # imm = 0x989680
xorl %ecx, %ecx
movl %eax, 0x1aabeb68(%rip)  # 0x1ab0c084
movb %cl, 0x1aabeb5e(%rip)   # 0x1ab0c080
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: SetTimeSettings(int, int, int)
void
SetTimeSettings( const int main_time, const int byoyomi, const int stones )
{
  if (search_setting == SearchTimeStrategy::ConstantPlayoutMode ||
      search_setting == SearchTimeStrategy::ConstantTimeMode ) {
    return ;
  }

  if (main_time == 0) {
    const_thinking_time = static_cast<double>(byoyomi) * 0.85;
    search_setting = SearchTimeStrategy::ConstantTimeMode;
    std::cerr << "Const Thinking Time Mode" << std::endl;
  } else {
    if (byoyomi == 0) {
      default_remaining_time = main_time;
      search_setting = SearchTimeStrategy::TimeControlMode;
      std::cerr << "Time Setting Mode" << std::endl;
    } else {
      default_remaining_time = main_time;
      const_thinking_time = static_cast<double>(byoyomi) / stones;
      search_setting = SearchTimeStrategy::TimeControlWithByoYomiMode;
      std::cerr << "Time Setting Mode (byoyomi)" << std::endl;
    }
  }
}

// Assembly:
cmpl $0x2, 0x29331(%rip)     # 0x76888
jae 0x4d55a
retq
pushq %rbx
testl %edi, %edi
je 0x4d5a5
cvtsi2sd %edi, %xmm0
movsd %xmm0, 0x2932d(%rip)    # 0x76898
testl %esi, %esi
je 0x4d5d8
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x2931a(%rip)    # 0x768a0
movl $0x3, 0x292f8(%rip)     # 0x76888
movq 0x28a51(%rip), %rdi     # 0x75fe8
leaq 0x12c75(%rip), %rsi     # 0x60213
movl $0x1b, %edx
jmp 0x4d5f5
cvtsi2sd %esi, %xmm0
mulsd 0x12c17(%rip), %xmm0    # 0x601c8
movsd %xmm0, 0x292e7(%rip)    # 0x768a0
movl $0x1, 0x292c5(%rip)     # 0x76888
movq 0x28a1e(%rip), %rdi     # 0x75fe8
leaq 0x12c17(%rip), %rsi     # 0x601e8
movl $0x18, %edx
jmp 0x4d5f5
movl $0x2, 0x292a6(%rip)     # 0x76888
movq 0x289ff(%rip), %rdi     # 0x75fe8
leaq 0x12c11(%rip), %rsi     # 0x60201
movl $0x11, %edx
callq 0x6490
movq 0x289e7(%rip), %rbx     # 0x75fe8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x63c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
jmp 0x6290
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: SetTimeManagementParameter()
void
SetTimeManagementParameter( void )
{
  if (!time_c_changed) {
    if (pure_board_size < 11) {
      time_c = TIME_C_9;
    } else if (pure_board_size < 16) {
      time_c = TIME_C_13;
    } else {
      time_c = TIME_C_19;
    }
  }

  if (!time_maxply_changed) {
    if (pure_board_size < 11) {
      time_maxply = TIME_MAXPLY_9;
    } else if (pure_board_size < 16) {
      time_maxply = TIME_MAXPLY_13;
    } else {
      time_maxply = TIME_MAXPLY_19;
    }
  }
}

// Assembly:
cmpb $0x0, 0x1aabe91b(%rip)  # 0x1ab0c0b0
jne 0x4d7c1
leaq 0x29116(%rip), %rax     # 0x768b4
movl (%rax), %eax
cmpl $0x10, %eax
movl $0x1e, %ecx
movl $0x3c, %edx
cmovbl %ecx, %edx
cmpl $0xb, %eax
movl $0x14, %eax
cmovgel %edx, %eax
movl %eax, 0x290e7(%rip)     # 0x768a8
cmpb $0x0, 0x1aabe8e9(%rip)  # 0x1ab0c0b1
jne 0x4d7f1
leaq 0x290e3(%rip), %rax     # 0x768b4
movl (%rax), %eax
cmpl $0x10, %eax
movl $0x1e, %ecx
movl $0x50, %edx
cmovbl %ecx, %edx
xorl %ecx, %ecx
cmpl $0xb, %eax
cmovgel %edx, %ecx
movl %ecx, 0x290bb(%rip)     # 0x768ac
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: CalculatePlayoutSpeed(double, int)
double
CalculatePlayoutSpeed( const double consume_time, const int threads )
{
  if (consume_time < 0.001) {
    return PLAYOUT_SPEED * threads;
  } else {
    return po_info.count / consume_time;
  }
}

// Assembly:
movsd 0x11652(%rip), %xmm1    # 0x5ee68
ucomisd %xmm0, %xmm1
jbe 0x4d82b
imull $0x3e8, %edi, %eax      # imm = 0x3E8
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
jmp 0x4d83c
movl 0x1aabe85b(%rip), %eax  # 0x1ab0c08c
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: CheckInterruption(uct_node_t const&)
bool
CheckInterruption( const uct_node_t &root )
{
  int max = 0, second = 0;
  const int child_num = root.child_num;
  const int rest = GetRestPoCount();
  const child_node_t *child = root.child;

  if (!interruption_flag) {
    return false;
  }

  if (!IsConstPlayoutMode() &&
      CalculateElapsedTime() * 10.0 < GetTimeLimit()) {
    return false;
  }

  for (int i = 0; i < child_num; i++) {
    if (child[i].move_count > max) {
      second = max;
      max = child[i].move_count;
    } else if (child[i].move_count > second) {
      second = child[i].move_count;
    }
  }

  if (max - second > rest) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x18(%rdi), %r14d
movl 0x1aabe762(%rip), %ebp  # 0x1ab0c088
movl 0x1aabe75f(%rip), %r15d # 0x1ab0c08c
cmpb $0x1, 0x28f58(%rip)     # 0x7688c
jne 0x4d98c
movq %rdi, %rbx
cmpl $0x0, 0x28f48(%rip)     # 0x76888
je 0x4d990
callq 0x6070
subq 0x1aabe76a(%rip), %rax  # 0x1ab0c0b8
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
cvtsi2sd %rdx, %xmm0
divsd 0x126ca(%rip), %xmm0    # 0x60040
mulsd 0x126f2(%rip), %xmm0    # 0x60070
movsd 0x1aabe6f2(%rip), %xmm1 # 0x1ab0c078
ucomisd %xmm0, %xmm1
jbe 0x4d990
xorl %eax, %eax
jmp 0x4d9d9
subl %r15d, %ebp
testl %r14d, %r14d
jle 0x4d9d2
leaq (%r14,%r14,8), %rax
leaq (%rax,%rax,2), %rcx
addq %r14, %rcx
xorl %edx, %edx
xorl %eax, %eax
xorl %esi, %esi
movl 0x20(%rbx,%rdx), %r8d
movl 0x20(%rbx,%rdx), %edi
cmpl %eax, %r8d
jle 0x4d9bd
movl %eax, %esi
movl %edi, %eax
jmp 0x4d9c5
cmpl %esi, %edi
jle 0x4d9c5
movl 0x20(%rbx,%rdx), %esi
addq $0x1c, %rdx
cmpq %rdx, %rcx
jne 0x4d9a9
subl %esi, %eax
jmp 0x4d9d4
xorl %eax, %eax
cmpl %ebp, %eax
setg %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: ExtendTime(uct_node_t const&, int)
bool
ExtendTime( const uct_node_t &root, const int moves )
{
  const int child_num = root.child_num;
  const child_node_t *child = root.child;
  int max = 0, second = 0;

  if (!IsTimeExtensionMode() ||
      moves < pure_board_size * 3 - 17) {
    return false;
  }
  
  const double root_wp = static_cast<double>(root.win) / root.move_count;

  if (root_wp > 0.80) {
    return false;
  }

  for (int i = 0; i < child_num; i++) {
    if (child[i].move_count > max) {
      second = max;
      max = child[i].move_count;
    } else if (child[i].move_count > second) {
      second = child[i].move_count;
    }
  }
  if (max < second * 1.2) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
cmpb $0x1, 0x1aabe695(%rip)  # 0x1ab0c080
jne 0x4da1f
leaq 0x28ec0(%rip), %rax     # 0x768b4
movl (%rax), %eax
leal (%rax,%rax,2), %eax
addl $-0x11, %eax
cmpl %esi, %eax
jg 0x4da1f
movl 0x18(%rdi), %ecx
movl 0xc(%rdi), %eax
cvtsi2sd %eax, %xmm0
movl 0x8(%rdi), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
ucomisd 0x127bb(%rip), %xmm0    # 0x601d8
jbe 0x4da22
xorl %eax, %eax
retq
testl %ecx, %ecx
jle 0x4da79
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rcx, %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl %esi, %r8d
movl 0x20(%rdi,%rcx), %r9d
movl 0x20(%rdi,%rcx), %esi
cmpl %r8d, %r9d
jle 0x4da4d
movl %r8d, %edx
jmp 0x4da58
cmpl %edx, %esi
jle 0x4da55
movl 0x20(%rdi,%rcx), %edx
movl %r8d, %esi
addq $0x1c, %rcx
cmpq %rcx, %rax
jne 0x4da37
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd 0x12769(%rip), %xmm1    # 0x601e0
jmp 0x4da81
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
seta %al
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: UpdatePat3Stone(pattern_t*, int, int)
void
UpdatePat3Stone( pattern_t *pat, const int color, const int pos )
{
  pat[pos + NW].list[MD_2] |= update_mask[0][color];
  pat[pos +  N].list[MD_2] |= update_mask[1][color];
  pat[pos + NE].list[MD_2] |= update_mask[2][color];
  pat[pos +  W].list[MD_2] |= update_mask[3][color];
  pat[pos +  E].list[MD_2] |= update_mask[4][color];
  pat[pos + SW].list[MD_2] |= update_mask[5][color];
  pat[pos +  S].list[MD_2] |= update_mask[6][color];
  pat[pos + SE].list[MD_2] |= update_mask[7][color];
}

// Assembly:
movslq %esi, %rax
leaq 0x120c3(%rip), %rsi     # 0x602e0
leaq 0x28698(%rip), %rcx     # 0x768bc
movl (%rcx), %r8d
notl %r8d
addl %edx, %r8d
movslq %r8d, %r8
leaq (%r8,%r8,2), %r8
movl (%rsi,%rax,4), %r9d
movl 0xc(%rsi,%rax,4), %r10d
orl %r9d, (%rdi,%r8,8)
movslq (%rcx), %r8
movslq %edx, %rdx
movq %rdx, %r9
subq %r8, %r9
leaq (%r9,%r9,2), %r8
orl %r10d, (%rdi,%r8,8)
movl 0x18(%rsi,%rax,4), %r8d
leal 0x1(%rdx), %r9d
movl %r9d, %r10d
subl (%rcx), %r10d
movslq %r10d, %r10
leaq (%r10,%r10,2), %r10
orl %r8d, (%rdi,%r10,8)
movl 0x24(%rsi,%rax,4), %r8d
leaq (%rdx,%rdx,2), %r10
orl %r8d, -0x18(%rdi,%r10,8)
movl 0x30(%rsi,%rax,4), %r8d
orl %r8d, 0x18(%rdi,%r10,8)
movl 0x3c(%rsi,%rax,4), %r8d
movl (%rcx), %r10d
addl %edx, %r10d
decl %r10d
movslq %r10d, %r10
leaq (%r10,%r10,2), %r10
orl %r8d, (%rdi,%r10,8)
movl 0x48(%rsi,%rax,4), %r8d
movslq (%rcx), %r10
addq %rdx, %r10
leaq (%r10,%r10,2), %rdx
orl %r8d, (%rdi,%rdx,8)
movl 0x54(%rsi,%rax,4), %eax
addl (%rcx), %r9d
movslq %r9d, %rcx
leaq (%rcx,%rcx,2), %rcx
orl %eax, (%rdi,%rcx,8)
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: UpdateMD2Stone(pattern_t*, int, int)
void
UpdateMD2Stone( pattern_t *pat, const int color, const int pos )
{
  pat[pos + NW].list[MD_2] |= update_mask[0][color];
  pat[pos +  N].list[MD_2] |= update_mask[1][color];
  pat[pos + NE].list[MD_2] |= update_mask[2][color];
  pat[pos +  W].list[MD_2] |= update_mask[3][color];
  pat[pos +  E].list[MD_2] |= update_mask[4][color];
  pat[pos + SW].list[MD_2] |= update_mask[5][color];
  pat[pos +  S].list[MD_2] |= update_mask[6][color];
  pat[pos + SE].list[MD_2] |= update_mask[7][color];
  pat[pos + NN].list[MD_2] |= update_mask[8][color];
  pat[pos + EE].list[MD_2] |= update_mask[9][color];
  pat[pos + SS].list[MD_2] |= update_mask[10][color];
  pat[pos + WW].list[MD_2] |= update_mask[11][color];
}

// Assembly:
movslq %esi, %rax
leaq 0x11f41(%rip), %rcx     # 0x602e0
leaq 0x28516(%rip), %rsi     # 0x768bc
movl (%rsi), %r8d
notl %r8d
addl %edx, %r8d
movslq %r8d, %r8
leaq (%r8,%r8,2), %r8
movl (%rcx,%rax,4), %r9d
movl 0xc(%rcx,%rax,4), %r10d
orl %r9d, (%rdi,%r8,8)
movslq (%rsi), %r8
movslq %edx, %rdx
movq %rdx, %r9
subq %r8, %r9
leaq (%r9,%r9,2), %r8
orl %r10d, (%rdi,%r8,8)
movl 0x18(%rcx,%rax,4), %r8d
leal 0x1(%rdx), %r9d
movl %r9d, %r10d
subl (%rsi), %r10d
movslq %r10d, %r10
leaq (%r10,%r10,2), %r10
orl %r8d, (%rdi,%r10,8)
movl 0x24(%rcx,%rax,4), %r10d
leaq (%rdx,%rdx,2), %r8
orl %r10d, -0x18(%rdi,%r8,8)
movl 0x30(%rcx,%rax,4), %r10d
orl %r10d, 0x18(%rdi,%r8,8)
movl 0x3c(%rcx,%rax,4), %r10d
movl (%rsi), %r11d
addl %edx, %r11d
decl %r11d
movslq %r11d, %r11
leaq (%r11,%r11,2), %r11
orl %r10d, (%rdi,%r11,8)
movl 0x48(%rcx,%rax,4), %r10d
movslq (%rsi), %r11
addq %rdx, %r11
leaq (%r11,%r11,2), %r11
orl %r10d, (%rdi,%r11,8)
movl 0x54(%rcx,%rax,4), %r10d
addl (%rsi), %r9d
movslq %r9d, %r9
leaq (%r9,%r9,2), %r9
orl %r10d, (%rdi,%r9,8)
movl 0x60(%rcx,%rax,4), %r9d
movl (%rsi), %r10d
addl %r10d, %r10d
movl %edx, %r11d
subl %r10d, %r11d
movslq %r11d, %r10
leaq (%r10,%r10,2), %r10
orl %r9d, (%rdi,%r10,8)
movl 0x6c(%rcx,%rax,4), %r9d
orl %r9d, 0x30(%rdi,%r8,8)
movl 0x78(%rcx,%rax,4), %r9d
movslq (%rsi), %rsi
leaq (%rdx,%rsi,2), %rdx
leaq (%rdx,%rdx,2), %rdx
orl %r9d, (%rdi,%rdx,8)
movl 0x84(%rcx,%rax,4), %eax
orl %eax, -0x30(%rdi,%r8,8)
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: Pat3Transpose8(unsigned int, unsigned int*)
void
Pat3Transpose8( const unsigned int pat3, unsigned int *transp )
{
  transp[0] = pat3;
  transp[1] = Pat3VerticalMirror(pat3);
  transp[2] = Pat3HorizontalMirror(pat3);
  transp[3] = Pat3VerticalMirror(transp[2]);
  transp[4] = Pat3Rotate90(pat3);
  transp[5] = Pat3Rotate90(transp[1]);
  transp[6] = Pat3Rotate90(transp[2]);
  transp[7] = Pat3Rotate90(transp[3]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movl %edi, (%rsi)
movq %rsi, (%rsp)
movl %edi, %r12d
shrl $0xa, %r12d
movl %r12d, %eax
andl $0x3f, %eax
movl $0x3c0, %ebx            # imm = 0x3C0
movl %edi, %ecx
andl %ebx, %ecx
movl %edi, %r13d
shll $0xa, %r13d
movl $0xffff, %r14d          # imm = 0xFFFF
movl %r13d, %r15d
andl %r14d, %r15d
orl %ecx, %r15d
orl %eax, %r15d
movl %r15d, 0x4(%rsi)
callq 0x4f0fe
movq (%rsp), %rdx
movl %eax, 0x8(%rdx)
movl %eax, %ecx
shrl $0xa, %ecx
andl %eax, %ebx
movl %eax, %edi
shll $0xa, %edi
andl %edi, %r14d
orl %ebx, %r14d
orl %ecx, %r14d
movl %r14d, 0xc(%rdx)
movl $0xc00, %r8d            # imm = 0xC00
andl %r8d, %r13d
movl %ebp, %r9d
shll $0x4, %r9d
movl $0xc0c0, %esi           # imm = 0xC0C0
andl %esi, %r9d
orl %r13d, %r9d
movl %ebp, %ebx
shrl $0x4, %ebx
movl $0x303, %esi            # imm = 0x303
andl %esi, %ebx
orl %r9d, %ebx
movl %ebp, %r11d
shll $0x6, %r11d
movl $0x3000, %r9d           # imm = 0x3000
andl %r9d, %r11d
orl %r11d, %ebx
movl %ebp, %r10d
shrl $0x6, %r10d
andl $0xc, %r10d
andl $0x30, %r12d
orl %ebx, %r12d
orl %r10d, %r12d
movl %r12d, 0x10(%rdx)
movl %ebp, %ebx
andl %r8d, %ebx
movl %r15d, %r12d
shll $0x4, %r12d
movl $0xc0c0, %r13d          # imm = 0xC0C0
andl %r13d, %r12d
shrl $0x4, %r15d
andl %esi, %r15d
andl $0x30, %ebp
orl %r11d, %ebp
orl %ebx, %ebp
orl %r12d, %ebp
orl %r15d, %ebp
orl %r10d, %ebp
movl %ebp, 0x14(%rdx)
andl %r8d, %edi
movl %eax, %r8d
shll $0x4, %r8d
andl %r13d, %r8d
movl $0xc0c0, %r11d          # imm = 0xC0C0
orl %edi, %r8d
movl %eax, %r10d
shrl $0x4, %r10d
andl %esi, %r10d
orl %r8d, %r10d
movl %eax, %edi
shll $0x6, %edi
andl %r9d, %edi
movl %eax, %r8d
shrl $0x6, %r8d
andl $0xc, %r8d
andl $-0x10, %ecx
orl %r10d, %ecx
orl %edi, %ecx
orl %r8d, %ecx
movl %ecx, 0x18(%rdx)
movl %r14d, %ecx
shll $0x4, %ecx
andl %r11d, %ecx
shrl $0x4, %r14d
andl %esi, %r14d
andl $0xc30, %eax            # imm = 0xC30
orl %ecx, %eax
orl %r14d, %eax
orl %edi, %eax
orl %r8d, %eax
movl %eax, 0x1c(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD3Transpose8(unsigned int, unsigned int*)
void
MD3Transpose8( const unsigned int md3, unsigned int *transp )
{
  transp[0] = md3;
  transp[1] = MD3VerticalMirror(md3);
  transp[2] = MD3HorizontalMirror(md3);
  transp[3] = MD3VerticalMirror(transp[2]);
  transp[4] = MD3Rotate90(md3);
  transp[5] = MD3Rotate90(transp[1]);
  transp[6] = MD3Rotate90(transp[2]);
  transp[7] = MD3Rotate90(transp[3]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, (%rsi)
callq 0x4f5c4
movl %eax, %r14d
movl %eax, 0x4(%rbx)
movl %ebp, %edi
callq 0x4f636
movl %eax, %r15d
movl %eax, 0x8(%rbx)
movl %eax, %edi
callq 0x4f5c4
movl %eax, 0xc(%rbx)
movl %ebp, %ecx
andl $0x3f, %ecx
shll $0x12, %ecx
shrl $0x6, %ebp
andl $0x3ffff, %ebp          # imm = 0x3FFFF
orl %ecx, %ebp
movl %ebp, 0x10(%rbx)
movd %r14d, %xmm0
movd %r15d, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqa %xmm0, %xmm1
pslld $0x12, %xmm1
pand 0x10cd5(%rip), %xmm1    # 0x60270
psrld $0x6, %xmm0
por %xmm1, %xmm0
movq %xmm0, 0x14(%rbx)
movl %eax, %ecx
andl $0x3f, %ecx
shll $0x12, %ecx
shrl $0x6, %eax
orl %ecx, %eax
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD4Transpose8(unsigned int, unsigned int*)
void
MD4Transpose8( const unsigned int md4, unsigned int *transp )
{
  transp[0] = md4;
  transp[1] = MD4VerticalMirror(md4);
  transp[2] = MD4HorizontalMirror(md4);
  transp[3] = MD4VerticalMirror(transp[2]);
  transp[4] = MD4Rotate90(md4);
  transp[5] = MD4Rotate90(transp[1]);
  transp[6] = MD4Rotate90(transp[2]);
  transp[7] = MD4Rotate90(transp[3]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, (%rsi)
callq 0x4f772
movl %eax, %r14d
movl %eax, 0x4(%rbx)
movl %ebp, %edi
callq 0x4f80c
movl %eax, %r15d
movl %eax, 0x8(%rbx)
movl %eax, %edi
callq 0x4f772
movl %eax, 0xc(%rbx)
roll $0x18, %ebp
roll $0x18, %r14d
movl %ebp, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
roll $0x18, %r15d
movl %r15d, 0x18(%rbx)
roll $0x18, %eax
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD5Transpose8(unsigned long long, unsigned long long*)
void
MD5Transpose8( const unsigned long long md5, unsigned long long *transp )
{
  transp[0] = md5;
  transp[1] = MD5VerticalMirror(md5);
  transp[2] = MD5HorizontalMirror(md5);
  transp[3] = MD5VerticalMirror(transp[2]);
  transp[4] = MD5Rotate90(md5);
  transp[5] = MD5Rotate90(transp[1]);
  transp[6] = MD5Rotate90(transp[2]);
  transp[7] = MD5Rotate90(transp[3]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, (%rsi)
callq 0x4f9b7
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x4fab0
movq %rax, %r12
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0x4f9b7
movq %rax, 0x18(%rbx)
movl %r14d, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
shlq $0x1e, %rcx
shrq $0xa, %r14
andl $0x3fffffff, %r14d      # imm = 0x3FFFFFFF
orq %rcx, %r14
movq %r14, 0x20(%rbx)
movq %r15, %xmm0
movq %r12, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movdqa %xmm0, %xmm1
psllq $0x1e, %xmm1
pand 0x1091a(%rip), %xmm1    # 0x602a0
psrlq $0xa, %xmm0
por %xmm1, %xmm0
movdqu %xmm0, 0x28(%rbx)
movl %eax, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
shlq $0x1e, %rcx
shrq $0xa, %rax
orq %rcx, %rax
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: DisplayInputPat3(unsigned int)
void
DisplayInputPat3( const unsigned int pat3 )
{
  std::ostringstream oss;

  oss << "\n";
  oss << Stone(pat3,  0) << Stone(pat3,  2) << Stone(pat3,  4) << "\n";
  oss << Stone(pat3,  6) << "*"             << Stone(pat3,  8) << "\n";
  oss << Stone(pat3, 10) << Stone(pat3, 12) << Stone(pat3, 14) << "\n";
  std::cerr << oss.str() << std::flush;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6550
leaq 0x10a2d(%rip), %rsi     # 0x606b5
movl $0x1, %edx
movq %r14, %rdi
callq 0x6490
movl %ebx, %eax
andl $0x3, %eax
leaq 0x10a16(%rip), %r15     # 0x606b7
movb (%rax,%r15), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x6490
movl %ebx, %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
movb (%rcx,%r15), %cl
leaq 0x8(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
movl %ebx, %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
movb (%rcx,%r15), %cl
leaq 0x8(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
leaq 0x109b3(%rip), %rsi     # 0x606b5
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
movl %ebx, %eax
shrl $0x6, %eax
andl $0x3, %eax
movb (%rax,%r15), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x6490
movq %rax, %r14
leaq 0x10965(%rip), %rsi     # 0x606a0
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
movl %ebx, %eax
shrl $0x8, %eax
andl $0x3, %eax
movb (%rax,%r15), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x6490
leaq 0x10946(%rip), %rsi     # 0x606b5
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
movl %ebx, %eax
shrl $0xa, %eax
andl $0x3, %eax
movb (%rax,%r15), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x6490
movl %ebx, %ecx
shrl $0xc, %ecx
andl $0x3, %ecx
movb (%rcx,%r15), %cl
leaq 0x8(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
shrl $0xe, %ebx
andl $0x3, %ebx
movb (%rbx,%r15), %cl
leaq 0x8(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
leaq 0x108d2(%rip), %rsi     # 0x606b5
movl $0x1, %edx
movq %rax, %rdi
callq 0x6490
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6670
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x261d8(%rip), %rdi     # 0x75fe8
callq 0x6490
movq %rax, %rdi
callq 0x6290
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fe38
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6410
movq 0x26159(%rip), %rsi     # 0x75f98
leaq 0x28(%rsp), %rdi
callq 0x61e0
leaq 0x98(%rsp), %rdi
callq 0x60f0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4fe85
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fe88
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6410
jmp 0x4fe88
movq %rax, %rbx
movq 0x26109(%rip), %rsi     # 0x75f98
leaq 0x28(%rsp), %rdi
callq 0x61e0
leaq 0x98(%rsp), %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x6760
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: DisplayInputMD5(unsigned long long)
void
DisplayInputMD5( const unsigned long long md5 )
{
  std::ostringstream oss;

  oss << "\n";
  oss << "     " << Stone(md5,  0) << "     \n";
  oss << "    " << Stone(md5, 38) << " " << Stone(md5,  2) << "    \n";
  oss << "   " << Stone(md5, 36) << "   " << Stone(md5,  4) << "   \n";
  oss << "  " << Stone(md5, 34) << "     " << Stone(md5,  6) << "  \n";
  oss << " " << Stone(md5, 32) << "       " << Stone(md5,  8) << " \n";
  oss <<       Stone(md5, 30) << "    *    " << Stone(md5, 10) << "\n";
  oss << " " << Stone(md5, 28) << "       " << Stone(md5, 12) << " \n";
  oss << "  " << Stone(md5, 26) << "     " << Stone(md5, 14) << "  \n";
  oss << "   " << Stone(md5, 24) << "   " << Stone(md5, 16) << "   \n";
  oss << "    " << Stone(md5, 22) << " " << Stone(md5, 18) << "    \n";
  oss << "     " << Stone(md5, 20) << "     \n";
  std::cerr << oss.str() << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6550
leaq 0xfb53(%rip), %rsi      # 0x606b5
movl $0x1, %edx
movq %r14, %rdi
callq 0x6490
leaq 0xca86(%rip), %rsi      # 0x5d5fc
leaq 0x10(%rsp), %rdi
movl $0x5, %edx
callq 0x6490
andl $0x3, %ebx
leaq 0xfb28(%rip), %rax      # 0x606b7
movb (%rbx,%rax), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x6490
leaq 0xfb01(%rip), %rsi      # 0x606b0
movl $0x6, %edx
movq %rax, %rdi
callq 0x6490
leaq 0xca3a(%rip), %rsi      # 0x5d5fd
leaq 0x10(%rsp), %rdi
movl $0x4, %edx
callq 0x6490
movq %rax, %rbx
movq 0x253bc(%rip), %rsi     # 0x75f98
leaq 0x10(%rsp), %rdi
callq 0x61e0
leaq 0x80(%rsp), %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x6760
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/SearchBoard.cpp
// Function: search_game_info_t::search_game_info_t(game_info_t const*)
search_game_info_t::search_game_info_t( const game_info_t *src )
{
  memcpy(record,      src->record,      sizeof(record_t) * MAX_RECORDS);
  memcpy(prisoner,    src->prisoner,    sizeof(int) * S_MAX);
  memcpy(board,       src->board,       sizeof(char) * BOARD_MAX);
  memcpy(pat,         src->pat,         sizeof(pattern_t) * BOARD_MAX);
  memcpy(string_id,   src->string_id,   sizeof(int) * STRING_POS_MAX);
  memcpy(string_next, src->string_next, sizeof(int) * STRING_POS_MAX);
  memcpy(candidates,  src->candidates,  sizeof(bool) * BOARD_MAX);

  for (int i = 0; i < MAX_STRING; i++) {
    if (src->string[i].flag) {
      memcpy(&string[i], &src->string[i], sizeof(string_t));
    } else {
      string[i].flag = false;
    }
  }

  moves = src->moves;
  ko_move = src->ko_move;
  ko_pos = src->ko_pos;

  memset(&undo[moves], 0, sizeof(undo_record_t));
  undo[moves].ko_move_record = ko_move;
  undo[moves].ko_pos_record = ko_pos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x43b0, %edx           # imm = 0x43B0
callq 0x6320
movups 0x43b4(%r14), %xmm0
movups %xmm0, 0x43b4(%rbx)
leaq 0x43cc(%rbx), %rdi
leaq 0x43f8(%r14), %rsi
movl $0x349, %edx            # imm = 0x349
callq 0x6320
leaq 0x4718(%rbx), %rdi
leaq 0x4748(%r14), %rsi
movl $0x4ed8, %edx           # imm = 0x4ED8
callq 0x6320
leaq 0x956f0(%rbx), %rdi
leaq 0x95720(%r14), %rsi
movl $0xae0, %edx            # imm = 0xAE0
callq 0x6320
leaq 0x961d0(%rbx), %rdi
leaq 0x96200(%r14), %rsi
movl $0xae0, %edx            # imm = 0xAE0
callq 0x6320
leaq 0x96cb0(%rbx), %rdi
leaq 0x96ce0(%r14), %rsi
movl $0x349, %edx            # imm = 0x349
callq 0x6320
leaq 0x9620(%r14), %r15
leaq 0x95f0(%rbx), %r12
xorl %r13d, %r13d
cmpb $0x1, 0x7c4(%r15,%r13)
jne 0x51e28
leaq (%r15,%r13), %rsi
leaq (%r12,%r13), %rdi
movl $0x7c8, %edx            # imm = 0x7C8
callq 0x6320
jmp 0x51e31
movb $0x0, 0x7c4(%r12,%r13)
addq $0x7c8, %r13            # imm = 0x7C8
cmpq $0x8c100, %r13          # imm = 0x8C100
jne 0x51e09
movslq 0x43b0(%r14), %rax
movl %eax, 0x43b0(%rbx)
movq 0x43c4(%r14), %rcx
movq %rcx, 0x43c4(%rbx)
imulq $0x16c0, %rax, %rax     # imm = 0x16C0
leaq (%rbx,%rax), %rdi
addq $0x96ffc, %rdi          # imm = 0x96FFC
movl $0x16c0, %edx           # imm = 0x16C0
xorl %esi, %esi
callq 0x6200
movslq 0x43b0(%rbx), %rax
imulq $0x16c0, %rax, %rax     # imm = 0x16C0
movq 0x43c4(%rbx), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x986b4(%rbx,%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/SearchBoard.cpp
// Function: IsLegalForSearch(search_game_info_t const*, int, int)
bool
IsLegalForSearch( const search_game_info_t *game, const int pos, const int color )
{
  // 既に石がある
  if (game->board[pos] != S_EMPTY) {
    return false;
  }

  // 自殺手である
  if (nb4_empty[Pat3(game->pat, pos)] == 0 &&
      IsSuicide(game, game->string, color, pos)) {
    return false;
  }

  // 劫である
  if (game->ko_pos == pos &&
      game->ko_move == (game->moves - 1)) {
    return false;
  }

  return true;
}

// Assembly:
movslq %esi, %rax
cmpb $0x0, 0x43cc(%rdi,%rax)
je 0x51eb8
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
addq $0x4718, %rdi           # imm = 0x4718
callq 0x4fc2a
movl %eax, %eax
leaq 0x1aaed801(%rip), %rcx  # 0x1ab3f6e0
cmpb $0x0, (%rcx,%rax)
jne 0x51f5c
leaq 0x95f0(%rbx), %r15
movq %rsp, %rdi
movl %ebp, %esi
callq 0x54386
xorl %eax, %eax
xorl %ecx, %ecx
movslq (%rsp,%rax,4), %rdx
movsbl 0x43cc(%rbx,%rdx), %esi
movl %esi, %edi
xorl %r14d, %edi
cmpl $0x3, %edi
jne 0x51f27
movslq 0x956f0(%rbx,%rdx,4), %rdi
imulq $0x7c8, %rdi, %rdi      # imm = 0x7C8
cmpl $0x1, 0x4(%r15,%rdi)
je 0x51f57
cmpl %r14d, %esi
jne 0x51f43
movslq 0x956f0(%rbx,%rdx,4), %rdx
imulq $0x7c8, %rdx, %rdx      # imm = 0x7C8
cmpl $0x1, 0x4(%r15,%rdx)
jg 0x51f57
cmpq $0x3, %rax
leaq 0x1(%rax), %rdx
setae %cl
movq %rdx, %rax
cmpq $0x4, %rdx
jne 0x51efa
testb $0x1, %cl
jne 0x51f74
cmpl %ebp, 0x43c4(%rbx)
jne 0x51f78
movl 0x43b0(%rbx), %eax
decl %eax
cmpl %eax, 0x43c8(%rbx)
jne 0x51f78
xorl %eax, %eax
jmp 0x51f7a
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/SearchBoard.cpp
// Function: RecordString(search_game_info_t*, int)
static void
RecordString( search_game_info_t *game, int id )
{
  const int moves = game->moves;  
  const string_t *string = game->string;
  const int *string_next = game->string_next;
  undo_record_t* rec = &game->undo[moves];
  int pos, i = 0;

  pos = string[id].origin;
  while (pos != STRING_END) {
    rec->stone[rec->strings][i++] = pos;
    pos = string_next[pos];
  }

  rec->string_color[rec->strings] = string[id].color;
  rec->stones[rec->strings] = string[id].size;
  rec->strings_id[rec->strings] = id;
  rec->strings++;
}

// Assembly:
movslq 0x43b0(%rdi), %rax
imulq $0x16c0, %rax, %rax     # imm = 0x16C0
addq %rdi, %rax
addq $0x96ffc, %rax          # imm = 0x96FFC
movslq %esi, %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rdi, %rcx
addq $0x95f0, %rcx           # imm = 0x95F0
movl 0x7bc(%rcx), %edx
cmpl $0x2b7, %edx            # imm = 0x2B7
je 0x527d7
movq %rax, %r8
movslq 0x16b0(%rax), %r9
imulq $0x5a4, %r9, %r9        # imm = 0x5A4
movl %edx, (%r8,%r9)
movslq %edx, %rdx
movl 0x961d0(%rdi,%rdx,4), %edx
addq $0x4, %r8
cmpl $0x2b7, %edx            # imm = 0x2B7
jne 0x527af
movb (%rcx), %dl
movslq 0x16b0(%rax), %rdi
movb %dl, 0x16b4(%rax,%rdi)
movl 0x7c0(%rcx), %ecx
movslq 0x16b0(%rax), %rdx
movl %ecx, 0x1690(%rax,%rdx,4)
movslq 0x16b0(%rax), %rcx
movl %esi, 0x16a0(%rax,%rcx,4)
incl 0x16b0(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/SearchBoard.cpp
// Function: AddStone(search_game_info_t*, int, int, int)
static void
AddStone( search_game_info_t *game, const int pos, const int color, const int id )
{
  const char *board = game->board;
  string_t *string = game->string;
  string_t *add_str;
  int *string_id = game->string_id;
  int lib_add = 0;
  int other = GetOppositeColor(color);
  int neighbor, neighbor4[4];

  // IDを更新
  string_id[pos] = id;

  // 追加先の連を取り出す
  add_str = &string[id];

  // 石を追加する
  AddStoneToString(game, add_str, pos);

  // 上下左右の座標の導出
  GetNeighbor4(neighbor4, pos);

  // 空点なら呼吸点を追加し
  // 敵の石があれば隣接する敵連の情報を更新
  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == S_EMPTY) {
      lib_add = AddLiberty(add_str, neighbor4[i], lib_add);
    } else if (board[neighbor4[i]] == other) {
      neighbor = string_id[neighbor4[i]];
      AddNeighbor(&string[neighbor], id);
      AddNeighbor(&string[id], neighbor);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movslq %esi, %rax
movl %ecx, 0x956f0(%rdi,%rax,4)
movslq %ecx, %rdx
movq %rdx, (%rsp)
imulq $0x7c8, %rdx, %rcx      # imm = 0x7C8
leaq (%rdi,%rcx), %r12
addq $0x95f0, %r12           # imm = 0x95F0
cmpl $0x2b7, %eax            # imm = 0x2B7
je 0x52abb
leaq 0x961d0(%r14), %rcx
movl 0x7bc(%r12), %edx
cmpl %esi, %edx
jle 0x52aa0
leaq 0x7bc(%r12), %rdi
jmp 0x52aae
movslq %edx, %rdi
movl (%rcx,%rdi,4), %edx
cmpl %esi, %edx
jl 0x52aa0
leaq (%rcx,%rdi,4), %rdi
movl %edx, (%rcx,%rax,4)
movl %esi, (%rdi)
incl 0x7c0(%r12)
leaq 0x95f0(%r14), %r15
leaq 0x10(%rsp), %rdi
callq 0x54386
leaq 0x57c(%r12), %rax
leaq 0x578(%r12), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x8(%r12), %rdx
addq $0x4, %r12
xorl %esi, %esi
xorl %edi, %edi
movl 0x10(%rsp,%rsi,4), %r8d
movslq %r8d, %r9
movsbl 0x43cc(%r14,%r9), %ecx
testl %ecx, %ecx
je 0x52b9b
xorl %ebp, %ecx
cmpl $0x3, %ecx
jne 0x52bcf
movl 0x956f0(%r14,%r9,4), %r8d
movslq %r8d, %r9
imulq $0x7c8, %r9, %r10       # imm = 0x7C8
addq %r15, %r10
movq (%rsp), %rcx
cmpw $0x0, 0x57c(%r10,%rcx,2)
jne 0x52b70
movq %r12, %r13
xorl %ecx, %ecx
movslq %ecx, %r11
movzwl 0x57c(%r10,%r11,2), %r12d
movswl %r12w, %ecx
cmpl %ebx, %ecx
jl 0x52b3c
movq (%rsp), %rcx
movw %r12w, 0x57c(%r10,%rcx,2)
movw %bx, 0x57c(%r10,%r11,2)
incl 0x578(%r10)
movq %r13, %r12
cmpw $0x0, (%rax,%r9,2)
jne 0x52bcf
xorl %ecx, %ecx
movslq %ecx, %r10
movzwl (%rax,%r10,2), %r11d
movswl %r11w, %ecx
cmpl %ecx, %r8d
jg 0x52b7a
leaq (%rax,%r10,2), %r10
movw %r11w, (%rax,%r9,2)
movq 0x8(%rsp), %r9
jmp 0x52bc8
cmpw $0x0, (%rdx,%r9,2)
je 0x52ba8
movl %r8d, %edi
jmp 0x52bcf
movslq %edi, %rcx
movzwl (%rdx,%rcx,2), %r11d
movswl %r11w, %edi
cmpl %edi, %r8d
jg 0x52ba8
leaq (%rdx,%rcx,2), %r10
movw %r11w, (%rdx,%r9,2)
movq %r12, %r9
movl %r8d, %edi
movw %r8w, (%r10)
incl (%r9)
incq %rsi
cmpq $0x4, %rsi
jne 0x52aee
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/String.cpp
// Function: AddStone(game_info_t*, int, int, int)
void
AddStone( game_info_t *game, const int pos, const int color, const int id )
{
  const int other = GetOppositeColor(color);
  string_t *string = game->string;
  string_t *add_str;
  char *board = game->board;
  int *string_id = game->string_id;
  int lib_add = 0;
  int neighbor, neighbor4[4];

  // IDを更新
  string_id[pos] = id;

  // 追加先の連を取り出す
  add_str = &string[id];

  // 石を追加する
  AddStoneToString(game, add_str, pos, 0);

  // 上下左右の座標の導出
  GetNeighbor4(neighbor4, pos);

  // 空点なら呼吸点を追加し
  // 敵の石があれば隣接する敵連の情報を更新
  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == S_EMPTY) {
      lib_add = AddLiberty(add_str, neighbor4[i], lib_add);
    } else if (board[neighbor4[i]] == other) {
      neighbor = string_id[neighbor4[i]];
      AddNeighbor(&string[neighbor], id, 0);
      AddNeighbor(&string[id], neighbor, 0);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movslq %esi, %rax
movl %ecx, 0x95720(%rdi,%rax,4)
movslq %ecx, %rdx
movq %rdx, (%rsp)
imulq $0x7c8, %rdx, %rcx      # imm = 0x7C8
leaq (%rdi,%rcx), %r12
addq $0x9620, %r12           # imm = 0x9620
cmpl $0x2b7, %eax            # imm = 0x2B7
je 0x532af
leaq 0x96200(%r14), %rcx
movl 0x7bc(%r12), %edx
cmpl %esi, %edx
jle 0x53294
leaq 0x7bc(%r12), %rdi
jmp 0x532a2
movslq %edx, %rdi
movl (%rcx,%rdi,4), %edx
cmpl %esi, %edx
jl 0x53294
leaq (%rcx,%rdi,4), %rdi
movl %edx, (%rcx,%rax,4)
movl %esi, (%rdi)
incl 0x7c0(%r12)
leaq 0x9620(%r14), %r15
leaq 0x10(%rsp), %rdi
callq 0x54386
leaq 0x57c(%r12), %rax
leaq 0x578(%r12), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x8(%r12), %rdx
addq $0x4, %r12
xorl %esi, %esi
xorl %edi, %edi
movl 0x10(%rsp,%rsi,4), %r8d
movslq %r8d, %r9
movsbl 0x43f8(%r14,%r9), %ecx
testl %ecx, %ecx
je 0x5338f
xorl %ebp, %ecx
cmpl $0x3, %ecx
jne 0x533c3
movl 0x95720(%r14,%r9,4), %r8d
movslq %r8d, %r9
imulq $0x7c8, %r9, %r10       # imm = 0x7C8
addq %r15, %r10
movq (%rsp), %rcx
cmpw $0x0, 0x57c(%r10,%rcx,2)
jne 0x53364
movq %r12, %r13
xorl %ecx, %ecx
movslq %ecx, %r11
movzwl 0x57c(%r10,%r11,2), %r12d
movswl %r12w, %ecx
cmpl %ebx, %ecx
jl 0x53330
movq (%rsp), %rcx
movw %r12w, 0x57c(%r10,%rcx,2)
movw %bx, 0x57c(%r10,%r11,2)
incl 0x578(%r10)
movq %r13, %r12
cmpw $0x0, (%rax,%r9,2)
jne 0x533c3
xorl %ecx, %ecx
movslq %ecx, %r10
movzwl (%rax,%r10,2), %r11d
movswl %r11w, %ecx
cmpl %ecx, %r8d
jg 0x5336e
leaq (%rax,%r10,2), %r10
movw %r11w, (%rax,%r9,2)
movq 0x8(%rsp), %r9
jmp 0x533bc
cmpw $0x0, (%rdx,%r9,2)
je 0x5339c
movl %r8d, %edi
jmp 0x533c3
movslq %edi, %rcx
movzwl (%rdx,%rcx,2), %r11d
movswl %r11w, %edi
cmpl %edi, %r8d
jg 0x5339c
leaq (%rdx,%rcx,2), %r10
movw %r11w, (%rdx,%r9,2)
movq %r12, %r9
movl %r8d, %edi
movw %r8w, (%r10)
incl (%r9)
incq %rsi
cmpq $0x4, %rsi
jne 0x532e2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/GoBoard.cpp
// Function: IsSuicide(game_info_t const*, string_t const*, int, int)
void
GetNeighbor4( int neighbor4[4], const int pos )
{
  neighbor4[0] = NORTH(pos);
  neighbor4[1] =  WEST(pos);
  neighbor4[2] =  EAST(pos);
  neighbor4[3] = SOUTH(pos);
}

// Assembly:
movl 0x2127f(%rip), %eax     # 0x768bc
movl %ecx, %r8d
subl %eax, %r8d
movl %r8d, -0x18(%rsp)
leal -0x1(%rcx), %r8d
movl %r8d, -0x14(%rsp)
leal 0x1(%rcx), %r8d
movl %r8d, -0x10(%rsp)
addl %ecx, %eax
movl %eax, -0xc(%rsp)
xorl %ecx, %ecx
xorl %eax, %eax
movslq -0x18(%rsp,%rcx,4), %r8
movsbl 0x43f8(%rdi,%r8), %r9d
movl %r9d, %r10d
xorl %edx, %r10d
cmpl $0x3, %r10d
jne 0x55695
movslq 0x95720(%rdi,%r8,4), %r10
imulq $0x7c8, %r10, %r10      # imm = 0x7C8
cmpl $0x1, 0x4(%rsi,%r10)
je 0x556c5
cmpl %edx, %r9d
jne 0x556b1
movslq 0x95720(%rdi,%r8,4), %r8
imulq $0x7c8, %r8, %r8        # imm = 0x7C8
cmpl $0x1, 0x4(%rsi,%r8)
jg 0x556c5
cmpq $0x3, %rcx
leaq 0x1(%rcx), %r8
setae %al
movq %r8, %rcx
cmpq $0x4, %r8
jne 0x55664
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/GoBoard.cpp
// Function: InitializeNeighbor()
static void
InitializeNeighbor( void )
{
  for (int i = 0; i < PAT3_MAX; i++) {
    char empty = 0;

    if (((i >>  2) & 0x3) == S_EMPTY) empty++;
    if (((i >>  6) & 0x3) == S_EMPTY) empty++;
    if (((i >>  8) & 0x3) == S_EMPTY) empty++;
    if (((i >> 12) & 0x3) == S_EMPTY) empty++;

    nb4_empty[i] = empty;
  }
}

// Assembly:
movdqa 0xc88e(%rip), %xmm0     # 0x60e80
movdqa 0xc896(%rip), %xmm1     # 0x60e90
movdqa 0xc89e(%rip), %xmm7     # 0x60ea0
movdqa 0xc8a5(%rip), %xmm8     # 0x60eb0
xorl %eax, %eax
movdqa 0xc8ab(%rip), %xmm4     # 0x60ec0
pxor %xmm5, %xmm5
movdqa 0xc8af(%rip), %xmm6     # 0x60ed0
movdqa 0xc8c6(%rip), %xmm9     # 0x60ef0
movdqa 0xc8cd(%rip), %xmm10    # 0x60f00
movdqa 0xc8d4(%rip), %xmm11    # 0x60f10
leaq 0x1aaeb09d(%rip), %rcx  # 0x1ab3f6e0
movdqa 0xc8d4(%rip), %xmm12    # 0x60f20
movdqa %xmm0, %xmm13
pand %xmm4, %xmm13
movdqa %xmm1, %xmm15
pand %xmm4, %xmm15
movdqa %xmm7, %xmm2
pand %xmm4, %xmm2
movdqa %xmm8, %xmm14
pand %xmm4, %xmm14
pcmpeqd %xmm5, %xmm14
pcmpeqd %xmm5, %xmm2
packssdw %xmm2, %xmm14
pcmpeqd %xmm5, %xmm15
pcmpeqd %xmm5, %xmm13
packssdw %xmm13, %xmm15
packsswb %xmm15, %xmm14
movdqa %xmm0, %xmm2
pand %xmm6, %xmm2
movdqa %xmm1, %xmm13
pand %xmm6, %xmm13
movdqa %xmm7, %xmm15
pand %xmm6, %xmm15
movdqa %xmm8, %xmm3
pand %xmm6, %xmm3
pcmpeqd %xmm5, %xmm3
pcmpeqd %xmm5, %xmm15
packssdw %xmm15, %xmm3
pcmpeqd %xmm5, %xmm13
pcmpeqd %xmm5, %xmm2
packssdw %xmm2, %xmm13
packsswb %xmm13, %xmm3
movdqa %xmm14, %xmm13
pand 0xc7f8(%rip), %xmm13    # 0x60ee0
paddb %xmm14, %xmm13
psubb 0xc83a(%rip), %xmm13    # 0x60f30
pand %xmm3, %xmm13
pandn %xmm14, %xmm3
pand %xmm9, %xmm3
por %xmm3, %xmm13
movdqa %xmm0, %xmm2
pand %xmm10, %xmm2
movdqa %xmm1, %xmm3
pand %xmm10, %xmm3
movdqa %xmm7, %xmm15
pand %xmm10, %xmm15
movdqa %xmm8, %xmm14
pand %xmm10, %xmm14
pcmpeqd %xmm5, %xmm14
pcmpeqd %xmm5, %xmm15
packssdw %xmm15, %xmm14
pcmpeqd %xmm5, %xmm3
pcmpeqd %xmm5, %xmm2
packssdw %xmm2, %xmm3
packsswb %xmm3, %xmm14
movdqa %xmm0, %xmm2
pand %xmm11, %xmm2
movdqa %xmm7, %xmm3
pand %xmm11, %xmm3
movdqa %xmm8, %xmm15
pand %xmm11, %xmm15
pcmpeqd %xmm5, %xmm15
pcmpeqd %xmm5, %xmm3
packssdw %xmm3, %xmm15
movdqa %xmm1, %xmm3
pand %xmm11, %xmm3
pcmpeqd %xmm5, %xmm3
pcmpeqd %xmm5, %xmm2
packssdw %xmm2, %xmm3
packsswb %xmm3, %xmm15
pand %xmm9, %xmm14
psubb %xmm15, %xmm14
paddb %xmm13, %xmm14
movdqa %xmm14, (%rax,%rcx)
addq $0x10, %rax
paddd %xmm12, %xmm8
paddd %xmm12, %xmm7
paddd %xmm12, %xmm1
paddd %xmm12, %xmm0
cmpq $0x10000, %rax          # imm = 0x10000
jne 0x5464c
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/GoBoard.cpp
// Function: CheckBentFourInTheCorner(game_info_t*)
void
CheckBentFourInTheCorner( game_info_t *game )
{
  const string_t *string = game->string;
  const int *string_id = game->string_id;
  const int *string_next = game->string_next;
  char *board = game->board;
  int pos, neighbor;

  // 四隅について隅のマガリ四目が存在するか確認し
  // 存在すれば地を訂正する
  for (int i = 0; i < 4; i++) {
    const int id = string_id[corner[i]];
    if (string[id].size == 3 &&
        string[id].libs == 2 &&
        string[id].neighbors == 1) {
      const int color = string[id].color;
      const int lib1 = string[id].lib[0];
      const int lib2 = string[id].lib[lib1];
      if ((board[corner_neighbor[i][0]] == S_EMPTY ||
          board[corner_neighbor[i][0]] == color) &&
          (board[corner_neighbor[i][1]] == S_EMPTY ||
          board[corner_neighbor[i][1]] == color)) {
        neighbor = string[id].neighbor[0];
        if (string[neighbor].libs == 2 &&
            string[neighbor].size > 6) {
          // 呼吸点を共有しているかの確認
          const int neighbor_lib1 = string[neighbor].lib[0];
          const int neighbor_lib2 = string[neighbor].lib[neighbor_lib1];
          if ((neighbor_lib1 == lib1 && neighbor_lib2 == lib2) ||
              (neighbor_lib1 == lib2 && neighbor_lib2 == lib1)) {
            pos = string[neighbor].origin;
            while (pos != STRING_END) {
              board[pos] = static_cast<char>(color);
              pos = string_next[pos];
            }
            pos = string[neighbor].lib[0];
            board[pos] = static_cast<char>(color);
            pos = string[neighbor].lib[pos];
            board[pos] = static_cast<char>(color);
          }
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %rbx
leaq 0x9620(%rdi), %rax
xorl %ecx, %ecx
leaq 0x1ab0c071(%rip), %rdx  # 0x1ab62270
leaq 0x1ab0c07a(%rip), %rsi  # 0x1ab62280
movslq (%rdx,%rcx,4), %r8
movslq 0x95720(%rdi,%r8,4), %r8
imulq $0x7c8, %r8, %r9        # imm = 0x7C8
cmpl $0x3, 0x7c0(%rax,%r9)
jne 0x56311
addq %rax, %r9
cmpl $0x2, 0x4(%r9)
jne 0x56311
cmpl $0x1, 0x578(%r9)
jne 0x56311
movb (%r9), %r8b
movswq 0x8(%r9), %r10
movzwl 0x8(%r9,%r10,2), %r11d
movslq (%rsi,%rcx,8), %rbx
movb 0x43f8(%rdi,%rbx), %bl
testb %bl, %bl
je 0x5626a
cmpb %r8b, %bl
jne 0x56311
movslq 0x4(%rsi,%rcx,8), %rbx
movb 0x43f8(%rdi,%rbx), %bl
testb %bl, %bl
je 0x56283
cmpb %r8b, %bl
jne 0x56311
movswq 0x57c(%r9), %r9
imulq $0x7c8, %r9, %r9        # imm = 0x7C8
cmpl $0x2, 0x4(%rax,%r9)
jne 0x56311
addq %rax, %r9
cmpl $0x7, 0x7c0(%r9)
jl 0x56311
movswq 0x8(%r9), %rbx
movzwl 0x8(%r9,%rbx,2), %ebp
cmpw %r10w, %bx
jne 0x562be
cmpw %r11w, %bp
je 0x562ca
cmpw %r11w, %bx
jne 0x56311
cmpw %r10w, %bp
jne 0x56311
movl 0x7bc(%r9), %r10d
cmpl $0x2b7, %r10d           # imm = 0x2B7
je 0x562fb
movslq %r10d, %r10
movb %r8b, 0x43f8(%rdi,%r10)
movl 0x96200(%rdi,%r10,4), %r10d
cmpl $0x2b7, %r10d           # imm = 0x2B7
jne 0x562da
movswq 0x8(%r9), %rbx
movb %r8b, 0x43f8(%rdi,%rbx)
movswq 0x8(%r9,%rbx,2), %r9
movb %r8b, 0x43f8(%rdi,%r9)
incq %rcx
cmpq $0x4, %rcx
jne 0x56206
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/GoBoard.cpp
// Function: CalculateScore(game_info_t*)
int
CalculateScore( game_info_t *game )
{
  const char *board = game->board;
  int color;
  int scores[S_MAX] = { 0 };

  // 地の数え上げ
  for (int i = 0; i < pure_board_max; i++) {
    const int pos = onboard_pos[i];
    color = board[pos];
    if (color == S_EMPTY) color = territory[Pat3(game->pat, pos)];
    scores[color]++;
  }

  //  黒−白を返す(コミなし)
  return (scores[S_BLACK] - scores[S_WHITE]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl 0x20575(%rip), %eax     # 0x768b0
testl %eax, %eax
jle 0x5639c
movq %rdi, %rbx
leaq 0x4748(%rdi), %r14
leaq 0x1ab0b3a0(%rip), %r15  # 0x1ab616f0
xorl %r12d, %r12d
leaq 0x1aad9386(%rip), %r13  # 0x1ab2f6e0
movslq (%r15), %rsi
movsbq 0x43f8(%rbx,%rsi), %rcx
testq %rcx, %rcx
jne 0x56380
movq %r14, %rdi
callq 0x4fc2a
movl %eax, %eax
movzbl (%rax,%r13), %ecx
movl 0x20530(%rip), %eax     # 0x768b0
incl (%rsp,%rcx,4)
incq %r12
movslq %eax, %rcx
addq $0x4, %r15
cmpq %rcx, %r12
jl 0x5635a
movl 0x4(%rsp), %eax
subl 0x8(%rsp), %eax
jmp 0x5639e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/Point.cpp
// Function: StringToInteger(char const*)
int
StringToInteger( const char *cpos )
{
  char alphabet;
  int x, y, pos;

  if (strcmp(cpos, "pass") == 0 || 
      strcmp(cpos, "PASS") == 0){
    pos = PASS;
  } else {
    alphabet = (char)toupper(cpos[0]);
    x = 0;
    for (int i = 1; i <= pure_board_size; i++) {
      if (gogui_x[i] == alphabet) {
        x = i;
      }
    }
    y = pure_board_size - atoi(&cpos[1]) + 1;
    pos = POS(x + (OB_SIZE - 1), y + (OB_SIZE - 1));
  }

  return pos;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xac76(%rip), %rsi      # 0x61030
callq 0x6580
xorl %ebx, %ebx
testl %eax, %eax
je 0x5643a
leaq 0x6d55(%rip), %rsi      # 0x5d121
movq %r14, %rdi
callq 0x6580
testl %eax, %eax
je 0x5643a
leaq 0x204d5(%rip), %rax     # 0x768b4
movl (%rax), %ebx
testl %ebx, %ebx
jle 0x56419
movsbl (%r14), %edi
callq 0x67b0
movsbl %al, %eax
leaq 0x1(%rbx), %rcx
xorl %ebp, %ebp
movl $0x1, %edx
leaq 0xac3d(%rip), %rsi      # 0x61040
movsbl (%rdx,%rsi), %edi
cmpl %edi, %eax
cmovel %edx, %ebp
incq %rdx
cmpq %rdx, %rcx
jne 0x56403
addl $0x4, %ebp
jmp 0x5641e
movl $0x4, %ebp
incq %r14
movq %r14, %rdi
callq 0x6630
subl %eax, %ebx
addl $0x5, %ebx
leaq 0x20487(%rip), %rax     # 0x768bc
imull (%rax), %ebx
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kobanium[P]Ray/src/board/Point.cpp
// Function: IntegerToString(int, char*)
void
IntegerToString( const int pos, char *cpos )
{
  int x, y;

  if (pos == PASS) {
#if defined (_WIN32)
    sprintf_s(cpos, 5, "%s", pass);
#else
    snprintf(cpos, 5, "%s", pass);
#endif
  } else if (pos == RESIGN) {
#if defined (_WIN32)
    sprintf_s(cpos, 7, "%s", resign);
#else
    snprintf(cpos, 7, "%s", resign);
#endif
  } else {
    x = X(pos) - (OB_SIZE - 1);
    y = pure_board_size - (Y(pos) - OB_SIZE);
    cpos[0] = gogui_x[x];
    if (y / 10 == 0) {
      cpos[1] = static_cast<char>('0' + y % 10);
      cpos[2] = '\0';
    } else {
      cpos[1] = static_cast<char>('0' + y / 10);
      cpos[2] = static_cast<char>('0' + y % 10);
      cpos[3] = '\0';
    }
  }
}

// Assembly:
cmpl $-0x1, %edi
je 0x56455
testl %edi, %edi
jne 0x56463
movb $0x0, 0x4(%rsi)
movl $0x73736170, (%rsi)     # imm = 0x73736170
retq
movl $0x6e6769, 0x3(%rsi)    # imm = 0x6E6769
movl $0x69736572, (%rsi)     # imm = 0x69736572
retq
leaq 0x20452(%rip), %rcx     # 0x768bc
movl %edi, %eax
cltd
idivl (%rcx)
movslq %edx, %rcx
leaq 0x2043b(%rip), %rdx     # 0x768b4
movl (%rdx), %edx
subl %eax, %edx
leal 0x5(%rdx), %eax
leaq 0xabb9(%rip), %rdi      # 0x61040
movb -0x4(%rcx,%rdi), %cl
movb %cl, (%rsi)
addl $0xe, %edx
cmpl $0x12, %edx
ja 0x5649f
addb $0x30, %al
movb %al, 0x1(%rsi)
movb $0x0, 0x2(%rsi)
retq
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
leal 0x30(%rcx), %edx
movb %dl, 0x1(%rsi)
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
addb $0x30, %al
movb %al, 0x2(%rsi)
movb $0x0, 0x3(%rsi)
retq