LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
callq 0x8f8e0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1c, %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x5808d(%rip)     # 0xe7a1c
jne 0x8f99a
movb $0x0, -0x1(%rbp)
jmp 0x8fa84
callq 0x8f0c0
testb $0x1, %al
jne 0x8f9d2
callq 0x8f800
movsd 0x1f710(%rip), %xmm1    # 0xaf0c0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x8f0a0
movsd -0x38(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8f9d2
movb $0x0, -0x1(%rbp)
jmp 0x8fa84
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x8fa6f
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
cmpl -0x14(%rbp), %eax
jle 0x8fa25
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
movl %eax, -0x14(%rbp)
jmp 0x8fa5f
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
cmpl -0x18(%rbp), %eax
jle 0x8fa5d
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
movl %eax, -0x18(%rbp)
jmp 0x8fa5f
jmp 0x8fa61
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8f9d9
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x8fa80
movb $0x1, -0x1(%rbp)
jmp 0x8fa84
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1c, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
callq 0x8f0b0
testb $0x1, %al
jne 0x8face
jmp 0x8fae2
movl -0x14(%rbp), %eax
leaq 0x57f6c(%rip), %rcx     # 0xe7a44
imull $0x3, (%rcx), %ecx
subl $0x11, %ecx
cmpl %ecx, %eax
jge 0x8faeb
movb $0x0, -0x1(%rbp)
jmp 0x8fbff
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
callq 0x25780
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x25780
movsd -0x40(%rbp), %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x1f7ab(%rip), %xmm1    # 0xaf2d8
ucomisd %xmm1, %xmm0
jbe 0x8fb3c
movb $0x0, -0x1(%rbp)
jmp 0x8fbff
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x8fbd9
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
cmpl -0x24(%rbp), %eax
jle 0x8fb8f
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
movl %eax, -0x24(%rbp)
jmp 0x8fbc9
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
cmpl -0x28(%rbp), %eax
jle 0x8fbc7
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x25780
movl %eax, -0x28(%rbp)
jmp 0x8fbc9
jmp 0x8fbcb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x8fb43
cvtsi2sdl -0x24(%rbp), %xmm1
cvtsi2sdl -0x28(%rbp), %xmm0
movsd 0x1f6f5(%rip), %xmm2    # 0xaf2e0
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8fbfb
movb $0x1, -0x1(%rbp)
jmp 0x8fbff
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: UpdatePat3Empty(pattern_t*, int)
void
UpdatePat3Empty( pattern_t *pat, const int pos )
{
  pat[pos + NW].list[MD_2] &= 0xFF3FFF;
  pat[pos +  N].list[MD_2] &= 0xFFCFFF;
  pat[pos + NE].list[MD_2] &= 0xFFF3FF;
  pat[pos +  W].list[MD_2] &= 0xFFFCFF;
  pat[pos +  E].list[MD_2] &= 0xFFFF3F;
  pat[pos + SW].list[MD_2] &= 0xFFFFCF;
  pat[pos +  S].list[MD_2] &= 0xFFFFF3;
  pat[pos + SE].list[MD_2] &= 0xFFFFFC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
xorl %edx, %edx
leaq 0x57221(%rip), %rsi     # 0xe7a4c
subl (%rsi), %edx
addl $-0x1, %edx
addl %edx, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0xff3fff, %ecx         # imm = 0xFF3FFF
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
xorl %edx, %edx
leaq 0x571f6(%rip), %rsi     # 0xe7a4c
subl (%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0xffcfff, %ecx         # imm = 0xFFCFFF
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
xorl %edx, %edx
leaq 0x571ce(%rip), %rsi     # 0xe7a4c
subl (%rsi), %edx
addl $0x1, %edx
addl %edx, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0xfff3ff, %ecx         # imm = 0xFFF3FF
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0xfffcff, %ecx         # imm = 0xFFFCFF
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0xffff3f, %ecx         # imm = 0xFFFF3F
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
leaq 0x57169(%rip), %rdx     # 0xe7a4c
movl (%rdx), %edx
addl $-0x1, %edx
addl %edx, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0xffffcf, %ecx         # imm = 0xFFFFCF
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
leaq 0x57140(%rip), %rdx     # 0xe7a4c
addl (%rdx), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0xfffff3, %ecx         # imm = 0xFFFFF3
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
leaq 0x5711c(%rip), %rdx     # 0xe7a4c
movl (%rdx), %edx
addl $0x1, %edx
addl %edx, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0xfffffc, %ecx         # imm = 0xFFFFFC
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x1e9c7(%rip), %rax     # 0xaf330
movl (%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
xorl %esi, %esi
leaq 0x570d0(%rip), %rdi     # 0xe7a4c
subl (%rdi), %esi
addl $-0x1, %esi
addl %esi, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1e994(%rip), %rax     # 0xaf330
movl 0xc(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
xorl %esi, %esi
leaq 0x5709c(%rip), %rdi     # 0xe7a4c
subl (%rdi), %esi
addl %esi, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1e963(%rip), %rax     # 0xaf330
movl 0x18(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
xorl %esi, %esi
leaq 0x5706b(%rip), %rdi     # 0xe7a4c
subl (%rdi), %esi
addl $0x1, %esi
addl %esi, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1e92f(%rip), %rax     # 0xaf330
movl 0x24(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
addl $-0x1, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1e908(%rip), %rax     # 0xaf330
movl 0x30(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1e8e1(%rip), %rax     # 0xaf330
movl 0x3c(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
leaq 0x56feb(%rip), %rsi     # 0xe7a4c
movl (%rsi), %esi
addl $-0x1, %esi
addl %esi, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1e8af(%rip), %rax     # 0xaf330
movl 0x48(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
leaq 0x56fb9(%rip), %rsi     # 0xe7a4c
addl (%rsi), %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x1e882(%rip), %rax     # 0xaf330
movl 0x54(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
leaq 0x56f8c(%rip), %rsi     # 0xe7a4c
movl (%rsi), %esi
addl $0x1, %esi
addl %esi, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
orl (%rax), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %edi
callq 0x92c80
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %edi
callq 0x92cb0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x92c80
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x4(%rbp), %edi
callq 0x92d40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x92d40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x92d40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x92d40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: Pat3Rotate90(unsigned int)
unsigned int
Pat3Rotate90( const unsigned int pat3 )
{
  // 1 2 3    3 5 8
  // 4   5 -> 2   7
  // 6 7 8    1 4 6

  return ((pat3 & 0x0003) << 10)
    | ((pat3 & 0x0C0C) << 4)
    | ((pat3 & 0x3030) >> 4)
    | ((pat3 & 0x00C0) << 6)
    | ((pat3 & 0x0300) >> 6)
    | ((pat3 & 0xC000) >> 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x3, %eax
shll $0xa, %eax
movl -0x4(%rbp), %ecx
andl $0xc0c, %ecx            # imm = 0xC0C
shll $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x3030, %ecx           # imm = 0x3030
shrl $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc0, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x300, %ecx            # imm = 0x300
shrl $0x6, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc000, %ecx           # imm = 0xC000
shrl $0xa, %ecx
orl %ecx, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %edi
callq 0x92ed0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %edi
callq 0x92f30
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x92ed0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x4(%rbp), %edi
callq 0x92ff0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x92ff0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x92ff0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x92ff0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD2HorizontalMirror(unsigned int)
unsigned int
MD2HorizontalMirror( const unsigned int md2 )
{
  return (REV3((md2 & 0x00FC00) >> 10) << 10)
    | (REV((md2 & 0x0003C0) >> 6) << 6)
    | REV3((md2 & 0x00003F))
    | (REV2((md2 & 0xCC0000) >> 18) << 18)
    | (md2 & 0x330000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xfc00, %eax           # imm = 0xFC00
shrl $0xa, %eax
shrl $0x4, %eax
movl -0x4(%rbp), %ecx
andl $0xfc00, %ecx           # imm = 0xFC00
shrl $0xa, %ecx
andl $0xc, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xfc00, %ecx           # imm = 0xFC00
shrl $0xa, %ecx
andl $0x3, %ecx
shll $0x4, %ecx
orl %ecx, %eax
shll $0xa, %eax
movl -0x4(%rbp), %ecx
andl $0x3c0, %ecx            # imm = 0x3C0
shrl $0x6, %ecx
shrl $0x2, %ecx
movl -0x4(%rbp), %edx
andl $0x3c0, %edx            # imm = 0x3C0
shrl $0x6, %edx
andl $0x3, %edx
shll $0x2, %edx
orl %edx, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x3f, %ecx
shrl $0x4, %ecx
movl -0x4(%rbp), %edx
andl $0x3f, %edx
andl $0xc, %edx
orl %edx, %ecx
movl -0x4(%rbp), %edx
andl $0x3f, %edx
andl $0x3, %edx
shll $0x4, %edx
orl %edx, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xcc0000, %ecx         # imm = 0xCC0000
shrl $0x12, %ecx
shrl $0x4, %ecx
movl -0x4(%rbp), %edx
andl $0xcc0000, %edx         # imm = 0xCC0000
shrl $0x12, %edx
andl $0x3, %edx
shll $0x4, %edx
orl %edx, %ecx
shll $0x12, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x330000, %ecx         # imm = 0x330000
orl %ecx, %eax
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD2Rotate90(unsigned int)
unsigned int
MD2Rotate90( const unsigned int md2 )
{
  return ((md2 & 0x000003) << 10)
    | ((md2 & 0x000C0C) << 4)
    | ((md2 & 0x003030) >> 4)
    | ((md2 & 0x0300C0) << 6)
    | ((md2 & 0x000300) >> 6)
    | ((md2 & 0x00C000) >> 10)
    | ((md2 & 0xFC0000) >> 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x3, %eax
shll $0xa, %eax
movl -0x4(%rbp), %ecx
andl $0xc0c, %ecx            # imm = 0xC0C
shll $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x3030, %ecx           # imm = 0x3030
shrl $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x300c0, %ecx          # imm = 0x300C0
shll $0x6, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x300, %ecx            # imm = 0x300
shrl $0x6, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc000, %ecx           # imm = 0xC000
shrl $0xa, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xfc0000, %ecx         # imm = 0xFC0000
shrl $0x2, %ecx
orl %ecx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %edi
callq 0x93190
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %edi
callq 0x93260
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x93190
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x4(%rbp), %edi
callq 0x93340
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x93340
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x93340
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x93340
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD3VerticalMirror(unsigned int)
unsigned int
MD3VerticalMirror( const unsigned int md3 )
{
  return (REV6(md3 & 0x003003))             // 13<->19
    | (REV4((md3 & 0x000C0C) >> 2) << 2)    // 14<->18
    | (REV2((md3 & 0x000330) >> 4) << 4)    // 15<->17
    | (REV4((md3 & 0xC0C000) >> 14) << 14)  // 20<->24
    | (REV2((md3 & 0x330000) >> 16) << 16)  // 21<->23
    | (md3 & 0x0C00C0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x3003, %eax           # imm = 0x3003
shrl $0xc, %eax
movl -0x4(%rbp), %ecx
andl $0x3003, %ecx           # imm = 0x3003
andl $0x3, %ecx
shll $0xc, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc0c, %ecx            # imm = 0xC0C
shrl $0x2, %ecx
shrl $0x8, %ecx
movl -0x4(%rbp), %edx
andl $0xc0c, %edx            # imm = 0xC0C
shrl $0x2, %edx
andl $0x3, %edx
shll $0x8, %edx
orl %edx, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x330, %ecx            # imm = 0x330
shrl $0x4, %ecx
shrl $0x4, %ecx
movl -0x4(%rbp), %edx
andl $0x330, %edx            # imm = 0x330
shrl $0x4, %edx
andl $0x3, %edx
shll $0x4, %edx
orl %edx, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc0c000, %ecx         # imm = 0xC0C000
shrl $0xe, %ecx
shrl $0x8, %ecx
movl -0x4(%rbp), %edx
andl $0xc0c000, %edx         # imm = 0xC0C000
shrl $0xe, %edx
andl $0x3, %edx
shll $0x8, %edx
orl %edx, %ecx
shll $0xe, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x330000, %ecx         # imm = 0x330000
shrl $0x10, %ecx
shrl $0x4, %ecx
movl -0x4(%rbp), %edx
andl $0x330000, %edx         # imm = 0x330000
shrl $0x10, %edx
andl $0x3, %edx
shll $0x4, %edx
orl %edx, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc00c0, %ecx          # imm = 0xC00C0
orl %ecx, %eax
popq %rbp
retq
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD3HorizontalMirror(unsigned int)
unsigned int
MD3HorizontalMirror( const unsigned int md3 )
{
  return (md3 & 0x003003)
    | (REV10((md3 & 0xC0000C) >> 2) << 2)   // 14<->24
    | (REV8((md3 & 0x300030) >> 4) << 4)    // 15<->23
    | (REV6((md3 & 0x0C00C0) >> 6) << 6)    // 16<->22
    | (REV4((md3 & 0x030300) >> 8) << 8)    // 17<->21
    | (REV2((md3 & 0x00CC00) >> 10) << 10); // 18<->20
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x3003, %eax           # imm = 0x3003
movl -0x4(%rbp), %ecx
andl $0xc0000c, %ecx         # imm = 0xC0000C
shrl $0x2, %ecx
shrl $0x14, %ecx
movl -0x4(%rbp), %edx
andl $0xc0000c, %edx         # imm = 0xC0000C
shrl $0x2, %edx
andl $0x3, %edx
shll $0x14, %edx
orl %edx, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x300030, %ecx         # imm = 0x300030
shrl $0x4, %ecx
shrl $0x10, %ecx
movl -0x4(%rbp), %edx
andl $0x300030, %edx         # imm = 0x300030
shrl $0x4, %edx
andl $0x3, %edx
shll $0x10, %edx
orl %edx, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc00c0, %ecx          # imm = 0xC00C0
shrl $0x6, %ecx
shrl $0xc, %ecx
movl -0x4(%rbp), %edx
andl $0xc00c0, %edx          # imm = 0xC00C0
shrl $0x6, %edx
andl $0x3, %edx
shll $0xc, %edx
orl %edx, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x30300, %ecx          # imm = 0x30300
shrl $0x8, %ecx
shrl $0x8, %ecx
movl -0x4(%rbp), %edx
andl $0x30300, %edx          # imm = 0x30300
shrl $0x8, %edx
andl $0x3, %edx
shll $0x8, %edx
orl %edx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xcc00, %ecx           # imm = 0xCC00
shrl $0xa, %ecx
shrl $0x4, %ecx
movl -0x4(%rbp), %edx
andl $0xcc00, %edx           # imm = 0xCC00
shrl $0xa, %edx
andl $0x3, %edx
shll $0x4, %edx
orl %edx, %ecx
shll $0xa, %ecx
orl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %edi
callq 0x93490
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %edi
callq 0x935b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x93490
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x4(%rbp), %edi
callq 0x936e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x936e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x936e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x936e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD4VerticalMirror(unsigned int)
unsigned int
MD4VerticalMirror( const unsigned int md4 )
{
  return (REV8(md4 & 0x00030003))             // 25<->33
    | (REV6((md4 & 0x0000C00C) >> 2) << 2)    // 26<->32
    | (REV4((md4 & 0x00003030) >> 4) << 4)    // 27<->31
    | (REV2((md4 & 0x00000CC0) >> 6) << 6)    // 28<->30
    | (REV6((md4 & 0xC00C0000) >> 18) << 18)  // 34<->40
    | (REV4((md4 & 0x30300000) >> 20) << 20)  // 35<->39
    | (REV2((md4 & 0x0CC00000) >> 22) << 22)  // 36<->38
    | (md4 & 0x03000300);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x30003, %eax          # imm = 0x30003
shrl $0x10, %eax
movl -0x4(%rbp), %ecx
andl $0x30003, %ecx          # imm = 0x30003
andl $0x3, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc00c, %ecx           # imm = 0xC00C
shrl $0x2, %ecx
shrl $0xc, %ecx
movl -0x4(%rbp), %edx
andl $0xc00c, %edx           # imm = 0xC00C
shrl $0x2, %edx
andl $0x3, %edx
shll $0xc, %edx
orl %edx, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x3030, %ecx           # imm = 0x3030
shrl $0x4, %ecx
shrl $0x8, %ecx
movl -0x4(%rbp), %edx
andl $0x3030, %edx           # imm = 0x3030
shrl $0x4, %edx
andl $0x3, %edx
shll $0x8, %edx
orl %edx, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xcc0, %ecx            # imm = 0xCC0
shrl $0x6, %ecx
shrl $0x4, %ecx
movl -0x4(%rbp), %edx
andl $0xcc0, %edx            # imm = 0xCC0
shrl $0x6, %edx
andl $0x3, %edx
shll $0x4, %edx
orl %edx, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc00c0000, %ecx       # imm = 0xC00C0000
shrl $0x12, %ecx
shrl $0xc, %ecx
movl -0x4(%rbp), %edx
andl $0xc00c0000, %edx       # imm = 0xC00C0000
shrl $0x12, %edx
andl $0x3, %edx
shll $0xc, %edx
orl %edx, %ecx
shll $0x12, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x30300000, %ecx       # imm = 0x30300000
shrl $0x14, %ecx
shrl $0x8, %ecx
movl -0x4(%rbp), %edx
andl $0x30300000, %edx       # imm = 0x30300000
shrl $0x14, %edx
andl $0x3, %edx
shll $0x8, %edx
orl %edx, %ecx
shll $0x14, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xcc00000, %ecx        # imm = 0xCC00000
shrl $0x16, %ecx
shrl $0x4, %ecx
movl -0x4(%rbp), %edx
andl $0xcc00000, %edx        # imm = 0xCC00000
shrl $0x16, %edx
andl $0x3, %edx
shll $0x4, %edx
orl %edx, %ecx
shll $0x16, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x3000300, %ecx        # imm = 0x3000300
orl %ecx, %eax
popq %rbp
retq
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD4HorizontalMirror(unsigned int)
unsigned int
MD4HorizontalMirror( const unsigned int md4 )
{
  return (md4 & 0x00030003)
    | (REV14((md4 & 0xC000000C) >> 2) << 2)   // 26<->40
    | (REV12((md4 & 0x30000030) >> 4) << 4)   // 27<->39
    | (REV10((md4 & 0x0C0000C0) >> 6) << 6)   // 28<->38
    | (REV8((md4 & 0x03000300) >> 8) << 8)    // 29<->37
    | (REV6((md4 & 0x00C00C00) >> 10) << 10)  // 30<->36
    | (REV4((md4 & 0x00303000) >> 12) << 12)  // 31<->35
    | (REV2((md4 & 0x000CC000) >> 14) << 14); // 32<->34
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x30003, %eax          # imm = 0x30003
movl -0x4(%rbp), %ecx
andl $0xc000000c, %ecx       # imm = 0xC000000C
shrl $0x2, %ecx
shrl $0x1c, %ecx
movl -0x4(%rbp), %edx
andl $0xc000000c, %edx       # imm = 0xC000000C
shrl $0x2, %edx
andl $0x3, %edx
shll $0x1c, %edx
orl %edx, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x30000030, %ecx       # imm = 0x30000030
shrl $0x4, %ecx
shrl $0x18, %ecx
movl -0x4(%rbp), %edx
andl $0x30000030, %edx       # imm = 0x30000030
shrl $0x4, %edx
andl $0x3, %edx
shll $0x18, %edx
orl %edx, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc0000c0, %ecx        # imm = 0xC0000C0
shrl $0x6, %ecx
shrl $0x14, %ecx
movl -0x4(%rbp), %edx
andl $0xc0000c0, %edx        # imm = 0xC0000C0
shrl $0x6, %edx
andl $0x3, %edx
shll $0x14, %edx
orl %edx, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x3000300, %ecx        # imm = 0x3000300
shrl $0x8, %ecx
shrl $0x10, %ecx
movl -0x4(%rbp), %edx
andl $0x3000300, %edx        # imm = 0x3000300
shrl $0x8, %edx
andl $0x3, %edx
shll $0x10, %edx
orl %edx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xc00c00, %ecx         # imm = 0xC00C00
shrl $0xa, %ecx
shrl $0xc, %ecx
movl -0x4(%rbp), %edx
andl $0xc00c00, %edx         # imm = 0xC00C00
shrl $0xa, %edx
andl $0x3, %edx
shll $0xc, %edx
orl %edx, %ecx
shll $0xa, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0x303000, %ecx         # imm = 0x303000
shrl $0xc, %ecx
shrl $0x8, %ecx
movl -0x4(%rbp), %edx
andl $0x303000, %edx         # imm = 0x303000
shrl $0xc, %edx
andl $0x3, %edx
shll $0x8, %edx
orl %edx, %ecx
shll $0xc, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
andl $0xcc000, %ecx          # imm = 0xCC000
shrl $0xe, %ecx
shrl $0x4, %ecx
movl -0x4(%rbp), %edx
andl $0xcc000, %edx          # imm = 0xCC000
shrl $0xe, %edx
andl $0x3, %edx
shll $0x4, %edx
orl %edx, %ecx
shll $0xe, %ecx
orl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x93850
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x93a50
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x93850
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x93c60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x93c60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x93c60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x93c60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD5VerticalMirror(unsigned long long)
unsigned long long
MD5VerticalMirror( const unsigned long long md5 )
{
  return (REV10(md5 & 0x0000300003))
    | (REV8((md5 & 0x00000C000C) >> 2) << 2)
    | (REV6((md5 & 0x0000030030) >> 4) << 4)
    | (REV4((md5 & 0x000000C0C0) >> 6) << 6)
    | (REV2((md5 & 0x0000003300) >> 8) << 8)
    | (REV8((md5 & 0xC000C00000) >> 22) << 22)
    | (REV6((md5 & 0x3003000000) >> 24) << 24)
    | (REV4((md5 & 0x0C0C000000) >> 26) << 26)
    | (REV2((md5 & 0x0330000000) >> 28) << 28)
    | (md5 & 0x00C0000C00);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0x300003, %rax         # imm = 0x300003
shrq $0x14, %rax
movq -0x8(%rbp), %rcx
andq $0x300003, %rcx         # imm = 0x300003
andq $0x3, %rcx
shlq $0x14, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
andq $0xc000c, %rcx          # imm = 0xC000C
shrq $0x2, %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rdx
andq $0xc000c, %rdx          # imm = 0xC000C
shrq $0x2, %rdx
andq $0x3, %rdx
shlq $0x10, %rdx
orq %rdx, %rcx
shlq $0x2, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
andq $0x30030, %rcx          # imm = 0x30030
shrq $0x4, %rcx
shrq $0xc, %rcx
movq -0x8(%rbp), %rdx
andq $0x30030, %rdx          # imm = 0x30030
shrq $0x4, %rdx
andq $0x3, %rdx
shlq $0xc, %rdx
orq %rdx, %rcx
shlq $0x4, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
andq $0xc0c0, %rcx           # imm = 0xC0C0
shrq $0x6, %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rdx
andq $0xc0c0, %rdx           # imm = 0xC0C0
shrq $0x6, %rdx
andq $0x3, %rdx
shlq $0x8, %rdx
orq %rdx, %rcx
shlq $0x6, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
andq $0x3300, %rcx           # imm = 0x3300
shrq $0x8, %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rdx
andq $0x3300, %rdx           # imm = 0x3300
shrq $0x8, %rdx
andq $0x3, %rdx
shlq $0x4, %rdx
orq %rdx, %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movabsq $0xc000c00000, %rcx     # imm = 0xC000C00000
andq -0x8(%rbp), %rcx
shrq $0x16, %rcx
shrq $0x10, %rcx
movabsq $0xc000c00000, %rdx     # imm = 0xC000C00000
andq -0x8(%rbp), %rdx
shrq $0x16, %rdx
andq $0x3, %rdx
shlq $0x10, %rdx
orq %rdx, %rcx
shlq $0x16, %rcx
orq %rcx, %rax
movabsq $0x3003000000, %rcx     # imm = 0x3003000000
andq -0x8(%rbp), %rcx
shrq $0x18, %rcx
shrq $0xc, %rcx
movabsq $0x3003000000, %rdx     # imm = 0x3003000000
andq -0x8(%rbp), %rdx
shrq $0x18, %rdx
andq $0x3, %rdx
shlq $0xc, %rdx
orq %rdx, %rcx
shlq $0x18, %rcx
orq %rcx, %rax
movabsq $0xc0c000000, %rcx      # imm = 0xC0C000000
andq -0x8(%rbp), %rcx
shrq $0x1a, %rcx
shrq $0x8, %rcx
movabsq $0xc0c000000, %rdx      # imm = 0xC0C000000
andq -0x8(%rbp), %rdx
shrq $0x1a, %rdx
andq $0x3, %rdx
shlq $0x8, %rdx
orq %rdx, %rcx
shlq $0x1a, %rcx
orq %rcx, %rax
movabsq $0x330000000, %rcx      # imm = 0x330000000
andq -0x8(%rbp), %rcx
shrq $0x1c, %rcx
shrq $0x4, %rcx
movabsq $0x330000000, %rdx      # imm = 0x330000000
andq -0x8(%rbp), %rdx
shrq $0x1c, %rdx
andq $0x3, %rdx
shlq $0x4, %rdx
orq %rdx, %rcx
shlq $0x1c, %rcx
orq %rcx, %rax
movabsq $0xc0000c00, %rcx       # imm = 0xC0000C00
andq -0x8(%rbp), %rcx
orq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0x980c6
movslq -0x14(%rbp), %rcx
leaq 0x17689(%rip), %rax     # 0xaf720
shlq $0x5, %rcx
addq %rcx, %rax
movl -0x4(%rbp), %edx
movl -0x14(%rbp), %ecx
shll %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x98086
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0x9812b
movl -0x14(%rbp), %eax
addl $0xc, %eax
movslq %eax, %rcx
leaq 0x17624(%rip), %rax     # 0xaf720
shlq $0x5, %rcx
addq %rcx, %rax
movl -0x4(%rbp), %edx
movl -0x14(%rbp), %ecx
shll %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x980e6
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x9819b
movl -0x14(%rbp), %eax
addl $0x18, %eax
movslq %eax, %rcx
leaq 0x175b4(%rip), %rax     # 0xaf720
shlq $0x5, %rcx
addq %rcx, %rax
movl -0x4(%rbp), %edx
movl -0x14(%rbp), %ecx
shll %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x98156
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/pattern/PatternHash.cpp
// Function: MD5Hash(unsigned long long)
static unsigned long long
MD5Hash( const unsigned long long md5 )
{
  unsigned long long hash = 0;

  for (int i = 0; i < 20; i++) {
    hash ^= random_bitstrings[i + 40][(md5 >> (i * 2)) & 0x3];
  }

  return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jge 0x98210
movl -0x14(%rbp), %eax
addl $0x28, %eax
movslq %eax, %rcx
leaq 0x17543(%rip), %rax     # 0xaf720
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rdx
movl -0x14(%rbp), %ecx
shll %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0x3, %rcx
movq (%rax,%rcx,8), %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x981c7
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/pattern/PatternHash.cpp
// Function: SearchIndex(index_hash_t const*, unsigned long long)
int
SearchIndex( const index_hash_t *index, const unsigned long long hash )
{
  const int key = TransHash20(hash);
  int i;

  if (key >= HASH_MAX) std::cerr << "Over Run" << std::endl;

  i = key;
  do{
    if (index[i].hash == 0){
      return index[i].index;
    } else if (index[i].hash == hash) {
      return index[i].index;
    }
    i++;
    if (i >= HASH_MAX) i = 0;
  } while (i != key);

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7caf0
movl %eax, -0x1c(%rbp)
cmpl $0x100000, -0x1c(%rbp)  # imm = 0x100000
jl 0x98267
movq 0x4eda4(%rip), %rdi     # 0xe6ff0
leaq 0x174c2(%rip), %rsi     # 0xaf715
callq 0x7530
movq %rax, %rdi
movq 0x4ed06(%rip), %rsi     # 0xe6f68
callq 0x75b0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x98299
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x982f4
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x982c8
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x982f4
jmp 0x982ca
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x100000, -0x20(%rbp)  # imm = 0x100000
jl 0x982e3
movl $0x0, -0x20(%rbp)
jmp 0x982e5
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x9826d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl 0x43cc(%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x98570
movb $0x0, -0x1(%rbp)
jmp 0x985f1
movq -0x10(%rbp), %rdi
addq $0x4718, %rdi           # imm = 0x4718
movl -0x14(%rbp), %esi
callq 0x93d30
movl %eax, %eax
movl %eax, %ecx
leaq 0x1ab182d2(%rip), %rax  # 0x1abb0860
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x985bd
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x95f0, %rsi           # imm = 0x95F0
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x98600
testb $0x1, %al
jne 0x985b7
jmp 0x985bd
movb $0x0, -0x1(%rbp)
jmp 0x985f1
movq -0x10(%rbp), %rax
movl 0x43c4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x985ed
movq -0x10(%rbp), %rax
movl 0x43c8(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x43b0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x985ed
movb $0x0, -0x1(%rbp)
jmp 0x985f1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/board/SearchBoard.cpp
// Function: IsSuicide(search_game_info_t const*, string_t const*, int, int)
static bool
IsSuicide( const search_game_info_t *game, const string_t *string, const int color, const int pos )
{
  const char *board = game->board;
  const int *string_id = game->string_id;
  const int other = GetOppositeColor(color);
  int neighbor4[4];

  GetNeighbor4(neighbor4, pos);

  // 隣接するの石についての判定
  // 隣接する石が相手でも、その石を含む連の呼吸点が1の時は合法手
  // 隣接する石が自分で、その石を含む連の呼吸点が2以上の時は合法手
  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == other &&
        string[string_id[neighbor4[i]]].libs == 1) {
      return false;
    } else if (board[neighbor4[i]] == color &&
               string[string_id[neighbor4[i]]].libs > 1) {
      return false;
    }
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x43cc, %rax           # imm = 0x43CC
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x956f0, %rax          # imm = 0x956F0
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0x25810
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x9bc90
movl $0x0, -0x54(%rbp)
cmpl $0x4, -0x54(%rbp)
jge 0x986ee
movq -0x28(%rbp), %rax
movslq -0x54(%rbp), %rcx
movslq -0x50(%rbp,%rcx,4), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x34(%rbp), %eax
jne 0x9869b
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0x54(%rbp), %rdx
movslq -0x50(%rbp,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x1, 0x4(%rax)
jne 0x9869b
movb $0x0, -0x1(%rbp)
jmp 0x986f2
movq -0x28(%rbp), %rax
movslq -0x54(%rbp), %rcx
movslq -0x50(%rbp,%rcx,4), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x1c(%rbp), %eax
jne 0x986dc
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0x54(%rbp), %rdx
movslq -0x50(%rbp,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
cmpl $0x1, 0x4(%rax)
jle 0x986dc
movb $0x0, -0x1(%rbp)
jmp 0x986f2
jmp 0x986de
jmp 0x986e0
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x98650
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/board/SearchBoard.cpp
// Function: RemoveLiberty(search_game_info_t*, string_t*, int)
static void
RemoveLiberty( search_game_info_t *game, string_t *string, const int pos )
{
  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] = static_cast<short>(0);

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

  // 呼吸点が1つならば, その連の呼吸点を候補手に追加
  if (string->libs == 1) {
    game->candidates[string->lib[0]] = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movswl 0x8(%rax,%rcx,2), %eax
cmpl $0x0, %eax
jne 0x98b1d
jmp 0x98ba2
jmp 0x98b1f
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movswl 0x8(%rax,%rcx,2), %eax
cmpl -0x14(%rbp), %eax
je 0x98b43
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movswl 0x8(%rax,%rcx,2), %eax
movl %eax, -0x18(%rbp)
jmp 0x98b1f
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movswq 0x8(%rcx,%rdx,2), %rcx
movw 0x8(%rax,%rcx,2), %dx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw %dx, 0x8(%rax,%rcx,2)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw $0x0, 0x8(%rax,%rcx,2)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x98ba2
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movswq 0x8(%rcx), %rcx
movb $0x1, 0x96cb0(%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x43b0(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x95f0, %rax           # imm = 0x95F0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x961d0, %rax          # imm = 0x961D0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x96ffc, %rax          # imm = 0x96FFC
movslq -0x10(%rbp), %rcx
imulq $0x16c0, %rcx, %rcx     # imm = 0x16C0
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2b7, -0x2c(%rbp)     # imm = 0x2B7
je 0x98c68
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq 0x16b0(%rcx), %rcx
imulq $0x5a4, %rcx, %rcx      # imm = 0x5A4
addq %rcx, %rax
movl -0x30(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x30(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
jmp 0x98c22
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movb (%rax), %dl
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq 0x16b0(%rcx), %rcx
movb %dl, 0x16b4(%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
addq %rcx, %rax
movl 0x7c0(%rax), %edx
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq 0x16b0(%rcx), %rcx
movl %edx, 0x1690(%rax,%rcx,4)
movl -0xc(%rbp), %edx
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq 0x16b0(%rcx), %rcx
movl %edx, 0x16a0(%rax,%rcx,4)
movq -0x28(%rbp), %rax
movl 0x16b0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x16b0(%rax)
popq %rbp
retq
nop