LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD2Transpose8(unsigned int, unsigned int*)
void
MD2Transpose8( const unsigned int md2, unsigned int *transp )
{
  transp[0] = md2;
  transp[1] = MD2VerticalMirror(md2);
  transp[2] = MD2HorizontalMirror(md2);
  transp[3] = MD2VerticalMirror(transp[2]);
  transp[4] = MD2Rotate90(md2);
  transp[5] = MD2Rotate90(transp[1]);
  transp[6] = MD2Rotate90(transp[2]);
  transp[7] = MD2Rotate90(transp[3]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, (%rsi)
callq 0x373e5
movl %eax, %r14d
movl %eax, 0x4(%rbx)
movl %ebp, %edi
callq 0x37417
movl %eax, %r15d
movl %eax, 0x8(%rbx)
movl %eax, %edi
callq 0x373e5
movl %eax, %r12d
movl %eax, 0xc(%rbx)
movl %ebp, %edi
callq 0x37487
movl %eax, 0x10(%rbx)
movl %r14d, %edi
callq 0x37487
movl %eax, 0x14(%rbx)
movl %r15d, %edi
callq 0x37487
movl %eax, 0x18(%rbx)
movl %r12d, %edi
callq 0x37487
movl %eax, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x375a5
movl %eax, %r14d
movl %eax, 0x4(%rbx)
movl %ebp, %edi
callq 0x37617
movl %eax, %r15d
movl %eax, 0x8(%rbx)
movl %eax, %edi
callq 0x375a5
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 0xfc54(%rip), %xmm1     # 0x471d0
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_O2/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 0x37737
movl %eax, %r14d
movl %eax, 0x4(%rbx)
movl %ebp, %edi
callq 0x377d1
movl %eax, %r15d
movl %eax, 0x8(%rbx)
movl %eax, %edi
callq 0x37737
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_O2/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 0x37963
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x37a5c
movq %rax, %r12
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0x37963
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 0xf8ae(%rip), %xmm1     # 0x471e0
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_O2/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 %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edi, %ebx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6530
leaq 0xf9b3(%rip), %rsi      # 0x475d5
movq %r14, %rdi
callq 0x63c0
movl %ebx, %eax
andl $0x3, %eax
leaq 0xf9a1(%rip), %r14      # 0x475d7
movsbl (%rax,%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf95f(%rip), %rsi      # 0x475d5
movq %rax, %rdi
callq 0x63c0
movl %ebx, %eax
shrl $0x6, %eax
andl $0x3, %eax
movsbl (%rax,%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x6480
leaq 0xf924(%rip), %rsi      # 0x475c0
movq %rax, %rdi
callq 0x63c0
movl %ebx, %ecx
shrl $0x8, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf915(%rip), %rsi      # 0x475d5
movq %rax, %rdi
callq 0x63c0
movl %ebx, %eax
shrl $0xa, %eax
andl $0x3, %eax
movsbl (%rax,%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0xc, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
shrl $0xe, %ebx
andl $0x3, %ebx
movsbl (%rbx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf8c7(%rip), %rsi      # 0x475d5
movq %rax, %rdi
callq 0x63c0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x6640
movq 0x292c6(%rip), %rdi     # 0x60ff0
movq %rsp, %rsi
callq 0x6350
movq %rax, %rdi
callq 0x6280
movq %rsp, %rdi
callq 0x6838
leaq 0x20(%rsp), %rdi
callq 0x60a0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x37d66
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6838
jmp 0x37d69
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x60a0
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: DisplayInputMD2(unsigned int)
void
DisplayInputMD2( const unsigned int md2 )
{
  std::ostringstream oss;

  oss << "\n";
  oss << "  " << Stone(md2, 16) << "  \n";
  oss << " " << Stone(md2, 0) << Stone(md2, 2) << Stone(md2, 4) << " \n";
  oss << Stone(md2, 22) << Stone(md2, 6) << "*" << Stone(md2, 8) << Stone(md2, 18) << "\n";
  oss << " " << Stone(md2, 10) << Stone(md2, 12) << Stone(md2, 14) << " \n";
  oss << "  " << Stone(md2, 20) << "  \n";
  std::cerr << oss.str() << std::flush;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edi, %ebx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6530
leaq 0xf83a(%rip), %rsi      # 0x475d5
movq %r14, %rdi
callq 0x63c0
leaq 0xc6a3(%rip), %rsi      # 0x4444d
leaq 0x20(%rsp), %rdi
callq 0x63c0
movl %ebx, %ecx
shrl $0x10, %ecx
andl $0x3, %ecx
leaq 0xf814(%rip), %r14      # 0x475d7
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf7fc(%rip), %rsi      # 0x475d3
movq %rax, %rdi
callq 0x63c0
leaq 0xc668(%rip), %rsi      # 0x4444e
leaq 0x20(%rsp), %rdi
callq 0x63c0
movl %ebx, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf7a1(%rip), %rsi      # 0x475d4
movq %rax, %rdi
callq 0x63c0
movl %ebx, %eax
shrl $0x16, %eax
andl $0x3, %eax
movsbl (%rax,%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0x6, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf752(%rip), %rsi      # 0x475c0
movq %rax, %rdi
callq 0x63c0
movl %ebx, %ecx
shrl $0x8, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0x12, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf72e(%rip), %rsi      # 0x475d5
movq %rax, %rdi
callq 0x63c0
leaq 0xc598(%rip), %rsi      # 0x4444e
leaq 0x20(%rsp), %rdi
callq 0x63c0
movl %ebx, %ecx
shrl $0xa, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0xc, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
movl %ebx, %ecx
shrl $0xe, %ecx
andl $0x3, %ecx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf6ce(%rip), %rsi      # 0x475d4
movq %rax, %rdi
callq 0x63c0
leaq 0xc538(%rip), %rsi      # 0x4444d
leaq 0x20(%rsp), %rdi
callq 0x63c0
shrl $0x14, %ebx
andl $0x3, %ebx
movsbl (%rbx,%r14), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xf69a(%rip), %rsi      # 0x475d3
movq %rax, %rdi
callq 0x63c0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x6640
movq 0x2909b(%rip), %rdi     # 0x60ff0
movq %rsp, %rsi
callq 0x6350
movq %rax, %rdi
callq 0x6280
movq %rsp, %rdi
callq 0x6838
leaq 0x20(%rsp), %rdi
callq 0x60a0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x37f91
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6838
jmp 0x37f94
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x60a0
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x178, %rsp            # imm = 0x178
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x6530
leaq 0xf013(%rip), %rsi      # 0x475d5
movq %r14, %rdi
callq 0x63c0
leaq 0xbe79(%rip), %rsi      # 0x4444a
movq %rsp, %rdi
callq 0x63c0
andl $0x3, %ebx
leaq 0xeff4(%rip), %rcx      # 0x475d7
movsbl (%rbx,%rcx), %esi
movq %rax, %rdi
callq 0x6480
leaq 0xefda(%rip), %rsi      # 0x475d0
movq %rax, %rdi
callq 0x63c0
leaq 0xbe46(%rip), %rsi      # 0x4444b
movq %rsp, %rdi
callq 0x63c0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x60a0
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/pattern/PatternHash.cpp
// Function: MD2Hash(unsigned int)
static unsigned long long
MD2Hash( const unsigned int md2 )
{
  unsigned long long hash = 0;

  for (int i = 0; i < 12; i++) {
    hash ^= random_bitstrings[i][(md2 >> (i * 2)) & 0x3];
  }

  return hash;
}

// Assembly:
leaq 0xe3df(%rip), %rdx      # 0x475e0
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x18, %rcx
je 0x39220
movl %edi, %esi
shrl %cl, %esi
andl $0x3, %esi
xorq (%rdx,%rsi,8), %rax
addq $0x2, %rcx
addq $0x20, %rdx
jmp 0x39205
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/pattern/PatternHash.cpp
// Function: MD3Hash(unsigned int)
static unsigned long long
MD3Hash( const unsigned int md3 )
{
  unsigned long long hash = 0;

  for (int i = 0; i < 12; i++) {
    hash ^= random_bitstrings[i + 12][(md3 >> (i * 2)) & 0x3];
  }

  return hash;
}

// Assembly:
leaq 0xe538(%rip), %rdx      # 0x47760
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x18, %rcx
je 0x39247
movl %edi, %esi
shrl %cl, %esi
andl $0x3, %esi
xorq (%rdx,%rsi,8), %rax
addq $0x2, %rcx
addq $0x20, %rdx
jmp 0x3922c
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/pattern/PatternHash.cpp
// Function: MD4Hash(unsigned int)
static unsigned long long
MD4Hash( const unsigned int md4 )
{
  unsigned long long hash = 0;

  for (int i = 0; i < 16; i++) {
    hash ^= random_bitstrings[i + 24][(md4 >> (i * 2)) & 0x3];
  }
  
  return hash;
}

// Assembly:
leaq 0xe691(%rip), %rdx      # 0x478e0
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x20, %rcx
je 0x3926e
movl %edi, %esi
shrl %cl, %esi
andl $0x3, %esi
xorq (%rdx,%rsi,8), %rax
addq $0x2, %rcx
addq $0x20, %rdx
jmp 0x39253
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6310
movups 0x43b4(%r14), %xmm0
movups %xmm0, 0x43b4(%rbx)
leaq 0x43cc(%rbx), %rdi
leaq 0x43f8(%r14), %rsi
movl $0x349, %edx            # imm = 0x349
callq 0x6310
leaq 0x4718(%rbx), %rdi
leaq 0x4748(%r14), %rsi
movl $0x4ed8, %edx           # imm = 0x4ED8
callq 0x6310
leaq 0x956f0(%rbx), %rdi
leaq 0x95720(%r14), %rsi
movl $0xae0, %edx            # imm = 0xAE0
callq 0x6310
leaq 0x961d0(%rbx), %rdi
leaq 0x96200(%r14), %rsi
movl $0xae0, %edx            # imm = 0xAE0
callq 0x6310
leaq 0x96cb0(%rbx), %rdi
leaq 0x96ce0(%r14), %rsi
movl $0x349, %edx            # imm = 0x349
callq 0x6310
leaq 0x9620(%r14), %r15
leaq 0x95f0(%rbx), %r12
xorl %r13d, %r13d
cmpq $0x8c100, %r13          # imm = 0x8C100
je 0x393a7
cmpb $0x1, 0x7c4(%r15,%r13)
jne 0x39395
leaq (%r15,%r13), %rsi
leaq (%r12,%r13), %rdi
movl $0x7c8, %edx            # imm = 0x7C8
callq 0x6310
jmp 0x3939e
movb $0x0, 0x7c4(%r12,%r13)
addq $0x7c8, %r13            # imm = 0x7C8
jmp 0x3936d
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 0x61f0
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_O2/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 0x3941e
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 0x37bc6
movl %eax, %eax
leaq 0x1aaf129b(%rip), %rcx  # 0x1ab2a6e0
cmpb $0x0, (%rcx,%rax)
je 0x39474
cmpl %ebp, 0x43c4(%rbx)
jne 0x39467
movl 0x43b0(%rbx), %eax
decl %eax
cmpl %eax, 0x43c8(%rbx)
jne 0x39467
xorl %eax, %eax
jmp 0x39469
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x95f0(%rbx), %r15
movq %rsp, %rdi
movl %ebp, %esi
callq 0x3b128
xorl %eax, %eax
cmpq $0x4, %rax
je 0x39463
movslq (%rsp,%rax,4), %rcx
movsbl 0x43cc(%rbx,%rcx), %edx
movl %edx, %esi
xorl %r14d, %esi
cmpl $0x3, %esi
jne 0x394ba
movslq 0x956f0(%rbx,%rcx,4), %rsi
imulq $0x7c8, %rsi, %rsi      # imm = 0x7C8
cmpl $0x1, 0x4(%r15,%rsi)
je 0x3944b
cmpl %r14d, %edx
jne 0x394da
movslq 0x956f0(%rbx,%rcx,4), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
cmpl $0x1, 0x4(%r15,%rcx)
jg 0x3944b
incq %rax
jmp 0x39487
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x961d0(%rdi), %rcx
imulq $0x16c0, %rax, %rax     # imm = 0x16C0
addq %rdi, %rax
addq $0x96ffc, %rax          # imm = 0x96FFC
movslq %esi, %rdx
imulq $0x7c8, %rdx, %r8       # imm = 0x7C8
leaq (%rdi,%r8), %rdx
addq $0x95f0, %rdx           # imm = 0x95F0
addq %rdi, %r8
addq $0x9dac, %r8            # imm = 0x9DAC
movq %rax, %rdi
movslq (%r8), %r8
cmpq $0x2b7, %r8             # imm = 0x2B7
je 0x39bc7
movslq 0x16b0(%rax), %r9
imulq $0x5a4, %r9, %r9        # imm = 0x5A4
movl %r8d, (%rdi,%r9)
leaq (%rcx,%r8,4), %r8
addq $0x4, %rdi
jmp 0x39b9f
movb (%rdx), %cl
movslq 0x16b0(%rax), %rdi
movb %cl, 0x16b4(%rax,%rdi)
movl 0x7c0(%rdx), %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_O2/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 %edx, %ebp
movq %rdi, %r14
movslq %esi, %rax
movl %ecx, 0x956f0(%rdi,%rax,4)
movl %ecx, 0x4(%rsp)
movslq %ecx, %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
leaq (%rdi,%rcx), %r15
addq $0x95f0, %r15           # imm = 0x95F0
cmpl $0x2b7, %eax            # imm = 0x2B7
je 0x39df8
leaq 0x961d0(%r14), %rcx
movl 0x7bc(%r15), %edx
cmpl %esi, %edx
jle 0x39dde
leaq 0x7bc(%r15), %rdi
jmp 0x39dec
movslq %edx, %rdi
movl (%rcx,%rdi,4), %edx
cmpl %esi, %edx
jl 0x39dde
leaq (%rcx,%rdi,4), %rdi
movl %edx, (%rcx,%rax,4)
movl %esi, (%rdi)
incl 0x7c0(%r15)
leaq 0x95f0(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3b128
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq $0x4, %rbx
je 0x39e78
movl 0x10(%rsp,%rbx,4), %r13d
movslq %r13d, %rax
movsbl 0x43cc(%r14,%rax), %ecx
testl %ecx, %ecx
je 0x39e62
xorl %ebp, %ecx
cmpl $0x3, %ecx
jne 0x39e5d
movslq 0x956f0(%r14,%rax,4), %r13
imulq $0x7c8, %r13, %rdi      # imm = 0x7C8
addq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x3a1dc
movq %r15, %rdi
movl %r13d, %esi
callq 0x3a1dc
movl %r12d, %r13d
jmp 0x39e70
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x3a1ae
incq %rbx
movl %r13d, %r12d
jmp 0x39e13
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/board/String.cpp
// Function: MakeString(game_info_t*, int, int)
void
MakeString( game_info_t *game, const int pos, const int color )
{
  const char *board = game->board;
  const int other = GetOppositeColor(color);
  string_t *string = game->string;
  string_t *new_string;
  int *string_id = game->string_id;
  int id = 1, lib_add = 0, neighbor, neighbor4[4];

  // 未使用の連のインデックスを見つける
  while (string[id].flag) { id++; }

  // 新しく連のデータを格納する箇所を保持
  new_string = &game->string[id];

  // 連のデータの初期化
  std::fill_n(new_string->lib, STRING_LIB_MAX, 0);
  std::fill_n(new_string->neighbor, MAX_NEIGHBOR, 0);
  new_string->lib[0] = LIBERTY_END;
  new_string->neighbor[0] = NEIGHBOR_END;
  new_string->libs = 0;
  new_string->color = static_cast<char>(color);
  new_string->origin = pos;
  new_string->size = 1;
  new_string->neighbors = 0;
  game->string_id[pos] = id;
  game->string_next[pos] = STRING_END;

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

  // 新しく作成した連の上下左右の座標を確認
  // 空点ならば, 作成した連に呼吸点を追加する
  // 敵の連ならば, 隣接する連をお互いに追加する
  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == S_EMPTY) {
      lib_add = AddLiberty(new_string, 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);
    }
  }

  // 連の存在フラグをオンにする
  new_string->flag = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x4(%rsp)
movq %rdi, %r14
leaq 0x9620(%rdi), %r15
xorl %ebp, %ebp
movq %r15, 0x8(%rsp)
incl %ebp
cmpb $0x0, 0xf8c(%r15)
leaq 0x7c8(%r15), %r15
jne 0x3a27f
leaq 0x8(%r15), %rcx
leaq 0x57c(%r15), %rax
movl $0x570, %edx            # imm = 0x570
testq %rdx, %rdx
je 0x3a2b5
andw $0x0, (%rcx)
addq $-0x2, %rdx
addq $0x2, %rcx
jmp 0x3a2a2
movl $0x240, %ecx            # imm = 0x240
testq %rcx, %rcx
je 0x3a2cd
andw $0x0, (%rax)
addq $-0x2, %rcx
addq $0x2, %rax
jmp 0x3a2ba
movw $0x2b7, 0x8(%r15)       # imm = 0x2B7
movw $0x11f, 0x57c(%r15)     # imm = 0x11F
andl $0x0, 0x4(%r15)
movl 0x4(%rsp), %eax
movb %al, (%r15)
movl %esi, 0x7bc(%r15)
movl $0x1, 0x7c0(%r15)
andl $0x0, 0x578(%r15)
movslq %esi, %rsi
movl %ebp, 0x95720(%r14,%rsi,4)
movl $0x2b7, 0x96200(%r14,%rsi,4) # imm = 0x2B7
leaq 0x10(%rsp), %rdi
callq 0x3b128
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq $0x4, %rbx
je 0x3a393
movl 0x10(%rsp,%rbx,4), %r13d
movslq %r13d, %rax
movsbl 0x43f8(%r14,%rax), %ecx
testl %ecx, %ecx
je 0x3a37d
xorl 0x4(%rsp), %ecx
cmpl $0x3, %ecx
jne 0x3a378
movslq 0x95720(%r14,%rax,4), %r13
imulq $0x7c8, %r13, %rdi      # imm = 0x7C8
addq 0x8(%rsp), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x3a3d8
movq %r15, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x3a3d8
movl %r12d, %r13d
jmp 0x3a38b
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x3a3aa
incq %rbx
movl %r13d, %r12d
jmp 0x3a32a
movb $0x1, 0x7c4(%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %edx, %ebp
movq %rdi, %r14
leaq 0x9620(%rdi), %rax
movq %rax, 0x8(%rsp)
movslq %esi, %r12
movl %ecx, 0x95720(%rdi,%r12,4)
movl %ecx, 0x4(%rsp)
movslq %ecx, %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
leaq (%rdi,%rax), %r15
addq $0x9620, %r15           # imm = 0x9620
xorl %ebx, %ebx
movq %r15, %rsi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x3a4ed
leaq 0x10(%rsp), %rdi
movl %r12d, %esi
callq 0x3b128
xorl %r12d, %r12d
cmpq $0x4, %rbx
je 0x3a4de
movl 0x10(%rsp,%rbx,4), %r13d
movslq %r13d, %rax
movsbl 0x43f8(%r14,%rax), %ecx
testl %ecx, %ecx
je 0x3a4c8
xorl %ebp, %ecx
cmpl $0x3, %ecx
jne 0x3a4c3
movslq 0x95720(%r14,%rax,4), %r13
imulq $0x7c8, %r13, %rdi      # imm = 0x7C8
addq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
xorl %edx, %edx
callq 0x3a3d8
movq %r15, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x3a3d8
movl %r12d, %r13d
jmp 0x3a4d6
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x3a3aa
incq %rbx
movl %r13d, %r12d
jmp 0x3a475
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/board/String.cpp
// Function: PoRemoveLiberty(game_info_t*, string_t*, int, int)
void
PoRemoveLiberty( game_info_t *game, string_t *string, const int pos, const int color )
{
  int lib = 0;

  // 既に取り除かれている場合は何もしない
  if (string->lib[pos] == 0) return;

  // 取り除く呼吸点の座標を見つけるまで進める
  while (string->lib[lib] != pos) {
    lib = string->lib[lib];
  }

  // 呼吸点の座標の情報を取り除く
  string->lib[lib] = string->lib[string->lib[lib]];
  string->lib[pos] = 0;

  // 呼吸点の数を1つ減らす
  string->libs--;

  // 連の呼吸点の数を確認
  // 呼吸点が1つならば, その呼吸点を候補手に戻して, レートの更新対象に加える
  // 呼吸点が2つならば, レートの更新対象に加える
  if (string->libs == 1) {
    game->candidates[string->lib[0]] = true;
    game->update_pos[color - 1][game->update_num[color - 1]++] = string->lib[0];
    game->seki[string->lib[0]] = false;
  }
}

// Assembly:
movslq %edx, %rax
cmpw $0x0, 0x8(%rsi,%rax,2)
je 0x3a7e2
xorl %r8d, %r8d
movslq %r8d, %r9
movswl 0x8(%rsi,%r9,2), %r8d
cmpl %edx, %r8d
jne 0x3a771
movslq %r8d, %rdx
movzwl 0x8(%rsi,%rdx,2), %edx
movw %dx, 0x8(%rsi,%r9,2)
andw $0x0, 0x8(%rsi,%rax,2)
movl 0x4(%rsi), %eax
decl %eax
movl %eax, 0x4(%rsi)
cmpl $0x1, %eax
jne 0x3a7e2
movswl 0x8(%rsi), %eax
cltq
movb $0x1, 0x96ce0(%rdi,%rax)
movslq %ecx, %rcx
leaq -0x1(%rcx), %rdx
imulq $0x5a4, %rdx, %rdx      # imm = 0x5A4
addq %rdi, %rdx
movslq 0x99cf4(%rdi,%rcx,4), %rsi
leal 0x1(%rsi), %r8d
movl %r8d, 0x99cf4(%rdi,%rcx,4)
movl %eax, 0x99d00(%rdx,%rsi,4)
movb $0x0, 0x97029(%rdi,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25a92(%rip), %eax     # 0x618bc
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 %eax, %eax
cmpq $0x4, %rax
je 0x3bea6
movslq -0x18(%rsp,%rax,4), %rcx
movsbl 0x43f8(%rdi,%rcx), %r8d
movl %r8d, %r9d
xorl %edx, %r9d
cmpl $0x3, %r9d
jne 0x3be86
movslq 0x95720(%rdi,%rcx,4), %r9
imulq $0x7c8, %r9, %r9        # imm = 0x7C8
cmpl $0x1, 0x4(%rsi,%r9)
je 0x3bea6
cmpl %edx, %r8d
jne 0x3bea1
movslq 0x95720(%rdi,%rcx,4), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
cmpl $0x1, 0x4(%rsi,%rcx)
jg 0x3bea6
incq %rax
jmp 0x3be4f
cmpq $0x4, %rax
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
leaq 0x1aaef351(%rip), %rcx  # 0x1ab2a6e0
cmpq $0x10000, %rax          # imm = 0x10000
je 0x3b3c9
xorl %edx, %edx
testb $0xc, %al
sete %dl
leal 0x1(%rdx), %esi
testb $-0x40, %al
movzbl %sil, %esi
cmovnel %edx, %esi
movl %eax, %edx
andl $0x300, %edx            # imm = 0x300
testw $0x3000, %ax            # imm = 0x3000
sete %dil
cmpl $0x1, %edx
adcb %sil, %dil
movb %dil, (%rax,%rcx)
incq %rax
jmp 0x3b38f
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x4748(%rdi), %r14
leaq 0x1ab0fbb2(%rip), %r15  # 0x1ab4c6f0
movl 0x24d6c(%rip), %eax     # 0x618b0
xorl %r12d, %r12d
leaq 0x1aaddb92(%rip), %r13  # 0x1ab1a6e0
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x3cb88
movslq (%r15), %rsi
movsbq 0x43f8(%rbx,%rsi), %rcx
testq %rcx, %rcx
jne 0x3cb7c
movq %r14, %rdi
callq 0x37bc6
movl %eax, %eax
movzbl (%rax,%r13), %ecx
movl 0x24d34(%rip), %eax     # 0x618b0
incl (%rsp,%rcx,4)
incq %r12
addq $0x4, %r15
jmp 0x3cb4e
movl 0x4(%rsp), %eax
subl 0x8(%rsp), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb24b(%rip), %rsi      # 0x47e40
callq 0x6570
xorl %ebp, %ebp
testl %eax, %eax
je 0x3cc85
leaq 0x7516(%rip), %rsi      # 0x44121
movq %rbx, %rdi
callq 0x6570
testl %eax, %eax
je 0x3cc85
movsbl (%rbx), %edi
callq 0x6790
leaq 0x24c8e(%rip), %rcx     # 0x618b4
movl (%rcx), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
movsbl %al, %eax
negq %rcx
pushq $0x1
popq %rdx
leaq 0xb208(%rip), %rsi      # 0x47e50
leaq (%rcx,%rdx), %rdi
cmpq $0x1, %rdi
je 0x3cc61
movsbl (%rdx,%rsi), %edi
cmpl %edi, %eax
cmovel %edx, %r15d
incq %rdx
jmp 0x3cc48
incq %rbx
movq %rbx, %rdi
callq 0x6600
subl %eax, %r14d
addl $0x5, %r14d
leaq 0x24c42(%rip), %rax     # 0x618bc
imull (%rax), %r14d
leal (%r15,%r14), %ebp
addl $0x4, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3cca6
testl %edi, %edi
jne 0x3ccb4
movb $0x0, 0x4(%rsi)
movl $0x73736170, (%rsi)     # imm = 0x73736170
retq
movl $0x6e6769, 0x3(%rsi)    # imm = 0x6E6769
movl $0x69736572, (%rsi)     # imm = 0x69736572
retq
leaq 0x24c01(%rip), %rcx     # 0x618bc
movl %edi, %eax
cltd
idivl (%rcx)
movslq %edx, %rcx
leaq 0x24bea(%rip), %rdx     # 0x618b4
movl (%rdx), %edx
subl %eax, %edx
leal 0x5(%rdx), %eax
leaq 0xb178(%rip), %rdi      # 0x47e50
movb -0x4(%rcx,%rdi), %cl
movb %cl, (%rsi)
addl $0xe, %edx
cmpl $0x12, %edx
ja 0x3ccf0
addb $0x30, %al
movb %al, 0x1(%rsi)
movb $0x0, 0x2(%rsi)
retq
pushq $0xa
popq %rcx
cltd
idivl %ecx
addb $0x30, %al
movb %al, 0x1(%rsi)
addb $0x30, %dl
movb %dl, 0x2(%rsi)
movb $0x0, 0x3(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/board/Point.cpp
// Function: ParsePoint[abi:cxx11](int)
std::string
ParsePoint( const int pos )
{
  if (pos == PASS) {
    return std::string(pass);
  } else if (pos == RESIGN) {
    return std::string(resign);
  } else {
    return std::string(1, GOGUI_X(pos)) + std::to_string(GOGUI_Y(pos));
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x3cd25
movl %esi, %ebp
testl %esi, %esi
jne 0x3cd39
leaq 0xb11d(%rip), %rsi      # 0x47e40
jmp 0x3cd2c
leaq 0xb13e(%rip), %rsi      # 0x47e6a
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x114b2
jmp 0x3cdac
leaq 0x24b7c(%rip), %r14     # 0x618bc
movl %ebp, %eax
cltd
idivl (%r14)
movslq %edx, %rax
leaq 0xb100(%rip), %rcx      # 0x47e50
movsbl -0x4(%rax,%rcx), %edx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x6470
leaq 0x24b44(%rip), %rax     # 0x618b4
movl (%rax), %ecx
movl %ebp, %eax
cltd
idivl (%r14)
negl %eax
leal (%rcx,%rax), %esi
addl $0x5, %esi
leaq 0x20(%rsp), %rdi
callq 0x26b3b
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x26a5e
leaq 0x20(%rsp), %rdi
callq 0x6838
movq %rsp, %rdi
callq 0x6838
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6838
jmp 0x3cdca
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6838
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/board/Point.cpp
// Function: ParseSgfPoint[abi:cxx11](int, int)
std::string
ParseSgfPoint( const int x, const int y )
{
  std::string sgf_pos;

  if ((x ==  0 && y ==  0) ||
      (x == -1 && y == -1)) {
    sgf_pos = std::string("tt");
  } else {
    sgf_pos  = static_cast<char>(x - 1 + 'a');
    sgf_pos += static_cast<char>(y - 1 + 'a');
  }

  return sgf_pos;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl %edx, %eax
orl %esi, %eax
setne %al
movl %edx, %ecx
andl %esi, %ecx
cmpl $-0x1, %ecx
setne %cl
testb %cl, %al
jne 0x3ce3a
leaq 0xb060(%rip), %rsi      # 0x47e71
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x114b2
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64c0
movq %r14, %rdi
callq 0x6838
jmp 0x3ce5c
movl %edx, %ebp
addb $0x60, %sil
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x66b0
addb $0x60, %bpl
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x6330
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3ce6a
movq %rax, %r14
movq %rbx, %rdi
callq 0x6838
movq %r14, %rdi
callq 0x6740
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/board/ZobristHash.cpp
// Function: SetHashSize(unsigned int)
void
SetHashSize( const unsigned int new_size )
{
  if (!(new_size & (new_size - 1))) {
    uct_hash_size = new_size;
    uct_hash_limit = new_size * 9 / 10;
  } else {
    std::cerr << "Hash size must be 2 ^ n" << std::endl;
    for (int i = 1; i <= 20; i++) {
      std::cerr << "2^" << i << ":" << (1 << i) << std::endl;
    }
    exit(1);
  }

}

// Assembly:
leal -0x1(%rdi), %eax
testl %eax, %edi
jne 0x3ce9e
movl %edi, 0x24a43(%rip)     # 0x618d0
leal (%rdi,%rdi,8), %eax
pushq $0xa
popq %rcx
xorl %edx, %edx
divl %ecx
movl %eax, 0x24a37(%rip)     # 0x618d4
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x24143(%rip), %rbx     # 0x60ff0
leaq 0xafc0(%rip), %rsi      # 0x47e74
movq %rbx, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6190
pushq $0x1
popq %r12
leaq 0xafbd(%rip), %r14      # 0x47e8c
leaq 0x71c0(%rip), %r15      # 0x44096
movl %r12d, %ebp
cmpl $0x15, %ebp
je 0x3cf19
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6700
movq %rax, %rdi
movq %r15, %rsi
callq 0x63c0
movl %r12d, %esi
movl %ebp, %ecx
shll %cl, %esi
movq %rax, %rdi
callq 0x6700
movq %rax, %rdi
callq 0x6190
incl %ebp
jmp 0x3ced9
pushq $0x1
popq %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/board/ZobristHash.cpp
// Function: InitializeHash()
void
InitializeHash( void )
{
  std::random_device rnd;
  std::mt19937_64 mt(rnd());

  for (int i = 0; i < MAX_RECORDS; i++) {
    for (int j = 0; j < BOARD_MAX; j++) {
      move_bit[i][j][HASH_PASS] = mt();
      move_bit[i][j][HASH_BLACK] = mt();
      move_bit[i][j][HASH_WHITE] = mt();
      move_bit[i][j][HASH_KO] = mt();
    }
  }
    
  for (int i = 0; i < BOARD_MAX; i++) {  
    hash_bit[i][HASH_PASS]  = mt();
    hash_bit[i][HASH_BLACK] = mt();
    hash_bit[i][HASH_WHITE] = mt();
    hash_bit[i][HASH_KO]    = mt();
    shape_bit[i] = mt();
  }

  node_hash = new node_hash_t[uct_hash_size];

  if (node_hash == NULL) {
    std::cerr << "Cannot allocate memory" << std::endl;
    exit(1);
  }

  enough_size = true;

  InitializeNakadeHash();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d50, %rsp           # imm = 0x1D50
leaq 0x9c8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25d50
movq %rbx, %rdi
callq 0x6550
movl %eax, %esi
movq %rsp, %rdi
callq 0x25ebc
leaq 0x1ab10352(%rip), %r14  # 0x1ab4d2c0
xorl %r15d, %r15d
pushq $0x18
popq %r12
movq %rsp, %rbx
cmpq $0x43b, %r15            # imm = 0x43B
je 0x3cfd2
movq %r12, %r13
cmpq $0x6938, %r13           # imm = 0x6938
je 0x3cfc6
movq %rbx, %rdi
callq 0x266c6
movq %rax, -0x18(%r14,%r13)
movq %rbx, %rdi
callq 0x266c6
movq %rax, -0x10(%r14,%r13)
movq %rbx, %rdi
callq 0x266c6
movq %rax, -0x8(%r14,%r13)
movq %rbx, %rdi
callq 0x266c6
movq %rax, (%r14,%r13)
addq $0x20, %r13
jmp 0x3cf84
incq %r15
addq $0x6920, %r14           # imm = 0x6920
jmp 0x3cf78
xorl %r14d, %r14d
movq %rsp, %rbx
leaq 0x1c6dbd41(%rip), %r15  # 0x1c718d20
leaq 0x1c6e265a(%rip), %r12  # 0x1c71f640
cmpq $0x1a48, %r14           # imm = 0x1A48
je 0x3d034
movq %rbx, %rdi
callq 0x266c6
movq %rax, (%r15,%r14,4)
movq %rbx, %rdi
callq 0x266c6
movq %rax, 0x8(%r15,%r14,4)
movq %rbx, %rdi
callq 0x266c6
movq %rax, 0x10(%r15,%r14,4)
movq %rbx, %rdi
callq 0x266c6
movq %rax, 0x18(%r15,%r14,4)
movq %rbx, %rdi
callq 0x266c6
movq %rax, (%r14,%r12)
addq $0x8, %r14
jmp 0x3cfe6
movl 0x24896(%rip), %eax     # 0x618d0
imulq $0x18, %rax, %rdi
callq 0x6030
movq %rax, 0x1c6e403e(%rip)  # 0x1c721088
movb $0x1, 0x1c6e403f(%rip)  # 0x1c721090
callq 0x3f508
leaq 0x9c8(%rsp), %rdi
callq 0x25eac
addq $0x1d50, %rsp           # imm = 0x1D50
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3d078
jmp 0x3d078
movq %rax, %rbx
leaq 0x9c8(%rsp), %rdi
callq 0x25eac
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/board/ZobristHash.cpp
// Function: InitializeUctHash()
void
InitializeUctHash( void )
{
  used = 0;
  enough_size = true;
  oldest_move = 1;
  
  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;
  }
}

// Assembly:
andl $0x0, 0x1c6e3ffd(%rip)  # 0x1c721094
movb $0x1, 0x1c6e3ff2(%rip)  # 0x1c721090
movl $0x1, 0x1c6e3ff0(%rip)  # 0x1c721098
movq 0x1c6e3fd9(%rip), %rax  # 0x1c721088
addq $0x10, %rax
xorl %ecx, %ecx
movl 0x24815(%rip), %edx     # 0x618d0
cmpq %rdx, %rcx
jae 0x3d0d5
movb $0x0, (%rax)
andq $0x0, -0x10(%rax)
andl $0x0, -0x8(%rax)
incq %rcx
addq $0x18, %rax
jmp 0x3d0b5
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
andl $0x0, 0x1c6e3fb7(%rip)  # 0x1c721094
movb $0x1, 0x1c6e3fac(%rip)  # 0x1c721090
movq 0x1c6e3f9d(%rip), %rax  # 0x1c721088
movl 0x247df(%rip), %ecx     # 0x618d0
xorl %edx, %edx
xorps %xmm0, %xmm0
cmpq %rcx, %rdx
jae 0x3d10b
incq %rdx
movups %xmm0, (%rax)
movb $0x0, 0x10(%rax)
addq $0x18, %rax
jmp 0x3d0f6
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x43b0(%rdi), %eax
movl 0x1c6e3f28(%rip), %ecx  # 0x1c721098
movl 0x1c6e3f1e(%rip), %edx  # 0x1c721094
movq 0x1c6e3f0b(%rip), %rsi  # 0x1c721088
movl 0x2474d(%rip), %edi     # 0x618d0
addq $0x10, %rsi
xorps %xmm0, %xmm0
cmpl %eax, %ecx
jge 0x3d1cd
movq %rsi, %r8
xorl %r9d, %r9d
cmpq %rdi, %r9
jae 0x3d1c3
cmpb $0x1, (%r8)
jne 0x3d1ba
cmpl %ecx, -0x4(%r8)
jne 0x3d1ba
leaq -0x10(%r8), %r10
decl %edx
movups %xmm0, (%r10)
movb $0x0, 0x10(%r10)
movl %edx, 0x1c6e3eda(%rip)  # 0x1c721094
incq %r9
addq $0x18, %r8
jmp 0x3d194
incl %ecx
movl %ecx, 0x1c6e3ecd(%rip)  # 0x1c721098
jmp 0x3d18a
movb $0x1, 0x1c6e3ebc(%rip)  # 0x1c721090
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x1c6e3e0f(%rip), %eax  # 0x1c7210c8
testl %eax, %eax
je 0x3d2c7
movl %eax, 0x1c6e3e09(%rip)  # 0x1c7210cc
movb $0x1, %al
jmp 0x3d2ee
movl %edi, 0x1c6e3dff(%rip)  # 0x1c7210cc
movb 0x1c6e3dfd(%rip), %al   # 0x1c7210d0
testl %edi, %edi
sete %cl
testb %al, %cl
je 0x3d2e0
xorl %eax, %eax
jmp 0x3d2ee
testl %edi, %edi
sete %cl
orb %al, %cl
movb $0x1, %al
testb $0x1, %cl
jne 0x3d2f4
movb %al, 0x1c6e3ddc(%rip)   # 0x1c7210d0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x1c6e3dd1(%rip), %eax  # 0x1c7210cc
testl %eax, %eax
je 0x3d324
cmpb $0x1, 0x1c6e3dca(%rip)  # 0x1c7210d0
jne 0x3d324
movl 0x43b0(%rdi), %ecx
cmpl $0xba, %ecx
jl 0x3d325
cvtsi2sd %eax, %xmm0
addsd 0x6cee(%rip), %xmm0     # 0x44010
jmp 0x3d344
retq
shll $0x3, %eax
cvtsi2sd %eax, %xmm1
cvtsi2sd %ecx, %xmm0
divsd 0xab58(%rip), %xmm0     # 0x47e90
addsd 0x6cc8(%rip), %xmm0     # 0x44008
mulsd %xmm1, %xmm0
leaq 0x1aababe5(%rip), %rax  # 0x1aaf7f30
movsd %xmm0, (%rax)
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
addpd 0xaa05(%rip), %xmm0     # 0x47d60
movupd %xmm0, 0x8(%rax)
jmp 0x105e4
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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:
leaq 0x241c1(%rip), %rax     # 0x618bc
movl (%rax), %eax
pushq $0x1
popq %rcx
subl %eax, %ecx
movd %eax, %xmm0
notl %eax
movl %eax, 0x1c6e3fb2(%rip)  # 0x1c7216c0
movl %ecx, 0x1c6e3fb0(%rip)  # 0x1c7216c4
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
paddd 0xa77f(%rip), %xmm0     # 0x47ea0
movq %xmm0, 0x1c6e3f9f(%rip) # 0x1c7216c8
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x19c8, %rsp           # imm = 0x19C8
xorl %eax, %eax
cmpq $0x1a48, %rax           # imm = 0x1A48
je 0x3f45f
andq $0x0, -0x80(%rsp,%rax)
addq $0x8, %rax
jmp 0x3f44b
movslq %esi, %r8
xorl %r9d, %r9d
leaq 0x22444(%rip), %r10     # 0x618b0
leaq 0x1ab0d27d(%rip), %rax  # 0x1ab4c6f0
movslq (%r10), %rcx
cmpq %rcx, %r9
jge 0x3f4b3
movslq (%rax,%r9,4), %rcx
movq %rcx, %r11
shlq $0x4, %r11
movl 0x4(%rdx,%r11), %ebp
movl 0x8(%rdx,%r11), %ebx
addl %ebp, %ebx
je 0x3f4ae
addq %rdx, %r11
movl (%r11,%r8,4), %r11d
cvtsi2sd %r11d, %xmm0
cvtsi2sd %ebx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rsp,%rcx,8)
incq %r9
jmp 0x3f473
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %r8d
cmovgl %ecx, %r8d
movsd 0x7ca7(%rip), %xmm0     # 0x47170
cmpq %rdx, %r8
je 0x3f4f6
movslq (%rax,%rdx,4), %r9
movsbl 0x43f8(%rdi,%r9), %r10d
xorl %esi, %r10d
cmpl $0x3, %r10d
jne 0x3f4f1
movsd -0x80(%rsp,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3f4f6
incq %rdx
jmp 0x3f4c9
cmpq %rcx, %rdx
setl %al
addq $0x19c8, %rsp           # imm = 0x19C8
popq %rbx
popq %rbp
retq
nop