LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/UctSearch.cpp
// Function: InitializeSearchSetting()
void
InitializeSearchSetting( void )
{
  // Ownerの初期化
  for (int i = 0; i < board_max; i++){
    owner[i] = 50;
    owner_index[i] = 5;
    candidates[i] = true;
  }

  // 乱数の初期化
  std::random_device rand;
  for (int i = 0; i < THREAD_MAX; i++) {
    mt[i].seed(rand());
  }


  SetTimeManagementParameter();
  InitializeTimeSetting();

  pondered = false;
  pondering_stop = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1390, %rsp           # imm = 0x1390
leaq 0x2b3c0(%rip), %rax     # 0x758b8
movslq (%rax), %rbx
testq %rbx, %rbx
jle 0x4a549
leaq 0x1aaba379(%rip), %rdi  # 0x1ab04880
movl $0x1, %esi
movq %rbx, %rdx
callq 0x6210
shlq $0x3, %rbx
leaq 0x1aab9631(%rip), %rax  # 0x1ab03b50
xorl %ecx, %ecx
leaq 0x1aab7bd8(%rip), %rdx  # 0x1ab02100
movabsq $0x4049000000000000, %rsi # imm = 0x4049000000000000
movq %rsi, (%rcx,%rdx)
movl $0x5, (%rax)
addq $0x4, %rax
addq $0x8, %rcx
cmpq %rcx, %rbx
jne 0x4a532
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x39d66
leaq 0x1aa903e3(%rip), %r14  # 0x1aada940
xorl %r15d, %r15d
movabsq $0x5851f42d4c957f2d, %r12 # imm = 0x5851F42D4C957F2D
movq %r14, %r13
movq %rbx, %rdi
callq 0x6570
imulq $0x9c8, %r15, %rdx      # imm = 0x9C8
leaq (%r14,%rdx), %rcx
movl %eax, %esi
movq %rsi, (%rdx,%r14)
movl $0x1, %eax
movq %rsi, %rdx
shrq $0x3e, %rdx
xorq %rsi, %rdx
imulq %r12, %rdx
addq %rax, %rdx
movq %rdx, (%r13,%rax,8)
incq %rax
movq %rdx, %rsi
cmpq $0x138, %rax            # imm = 0x138
jne 0x4a58e
movq $0x138, 0x9c0(%rcx) # imm = 0x138
incq %r15
addq $0x9c8, %r13            # imm = 0x9C8
cmpq $0x40, %r15
jne 0x4a56d
callq 0x4d45e
callq 0x4d13e
movb $0x0, 0x1aaba5ee(%rip)  # 0x1ab04bc9
movb $0x1, 0x1aaba5e8(%rip)  # 0x1ab04bca
leaq 0x8(%rsp), %rdi
callq 0x63b0
addq $0x1390, %rsp           # imm = 0x1390
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4a616
jmp 0x4a601
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x63b0
movq %rbx, %rdi
callq 0x6770
movq %rax, %rdi
callq 0x20303
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/UctSearch.cpp
// Function: StopPondering()
void
StopPondering( void )
{
  if (!pondering_mode) {
    return ;
  }

  if (ponder) {
    pondering_stop = true;
    for (int i = 0; i < threads; i++) {
      worker[i]->join();
      delete worker[i];
    }
    ponder = false;
    pondered = true;
    PrintPonderingCount(GetPoCount());
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x1aa90313(%rip)  # 0x1aada93c
jne 0x4a6a2
cmpb $0x1, 0x1aaba599(%rip)  # 0x1ab04bcb
jne 0x4a6a2
movb $0x1, 0x1aaba58f(%rip)  # 0x1ab04bca
cmpl $0x0, 0x2b236(%rip)     # 0x75878
jle 0x4a681
leaq 0x1aaba585(%rip), %rbx  # 0x1ab04bd0
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x6720
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4a66e
cmpq $0x0, (%rdi)
jne 0x4a6aa
movl $0x8, %esi
callq 0x6420
incq %r14
movslq 0x2b200(%rip), %rax     # 0x75878
addq $0x8, %rbx
cmpq %rax, %r14
jl 0x4a64e
movb $0x0, 0x1aaba543(%rip)  # 0x1ab04bcb
movb $0x1, 0x1aaba53a(%rip)  # 0x1ab04bc9
callq 0x4d5b2
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1eb6e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x60b0
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/UctSearch.cpp
// Function: CorrectDescendentNodes(std::vector<int, std::allocator<int>>&, int)
static void
CorrectDescendentNodes( std::vector<int> &indexes, int index )
{
  child_node_t *uct_child = uct_node[index].child;
  const int child_num = uct_node[index].child_num;

  indexes.push_back(index);

  for (int i = 0; i < child_num; i++) {
    if (uct_child[i].index != NOT_EXPANDED) {
      CorrectDescendentNodes(indexes, uct_child[i].index);
    }
  }   
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movq 0x1aa8ee67(%rip), %r15  # 0x1aada930
movslq %esi, %rax
imulq $0x4548, %rax, %r12     # imm = 0x4548
movl 0x18(%r15,%r12), %r14d
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x4baee
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0x8(%rbx)
jmp 0x4bafe
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4ca08
testl %r14d, %r14d
jle 0x4bb32
addq %r12, %r15
addq $0x2c, %r15
leaq (%r14,%r14,8), %rax
leaq (%rax,%rax,2), %r12
addq %r14, %r12
xorl %r14d, %r14d
movl (%r15,%r14), %esi
cmpl $-0x1, %esi
je 0x4bb29
movq %rbx, %rdi
callq 0x4bab3
addq $0x1c, %r14
cmpq %r14, %r12
jne 0x4bb18
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/MoveSelection.cpp
// Function: SetResignThreshold(double)
void
SetResignThreshold( const double threshold )
{
  if (threshold <= 0.0) {
    PrintResignThresholdIsTooSmall(threshold);
    resign_threshold = 0.0;
  } else if (threshold > 1.0) {
    PrintResignThresholdIsTooLarge(threshold);
  } else {
    resign_threshold = threshold;
  }
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x4cec5
ucomisd 0x10152(%rip), %xmm0    # 0x5d008
ja 0x1ed4d
movsd %xmm0, 0x289bc(%rip)    # 0x75880
retq
pushq %rax
callq 0x1ee84
movq $0x0, 0x289aa(%rip) # 0x75880
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: InitializeTimeSetting()
void
InitializeTimeSetting( void )
{
  for (int i = 0; i < S_MAX; i++) {
    remaining_time[i] = default_remaining_time;
  }

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

// Assembly:
movsd 0x28752(%rip), %xmm0    # 0x75898
xorl %eax, %eax
leaq 0x1aabdf41(%rip), %rcx  # 0x1ab0b090
movsd %xmm0, (%rax,%rcx)
addq $0x8, %rax
cmpq $0x20, %rax
jne 0x4d14f
movl 0x28724(%rip), %eax     # 0x75888
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jb 0x4d18c
testl %eax, %eax
je 0x4d1c7
cmpl $0x1, %eax
jne 0x4d1ee
movsd 0x28723(%rip), %xmm0    # 0x758a0
movsd %xmm0, 0x1aabdef3(%rip) # 0x1ab0b078
movl $0x989680, %eax         # imm = 0x989680
jmp 0x4d1e0
movsd 0x1aabdefc(%rip), %xmm0 # 0x1ab0b090
movl 0x28712(%rip), %eax     # 0x758ac
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
addl 0x28701(%rip), %ecx     # 0x758a8
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x1aabdec1(%rip) # 0x1ab0b078
mulsd 0x12db1(%rip), %xmm0    # 0x5ff70
cvttsd2si %xmm0, %eax
movb $0x1, %cl
jmp 0x4d1e2
movabsq $0x40c3880000000000, %rax # imm = 0x40C3880000000000
movq %rax, 0x1aabdea0(%rip)  # 0x1ab0b078
cvttsd2si 0x286b0(%rip), %eax # 0x75890
xorl %ecx, %ecx
movl %eax, 0x1aabde9c(%rip)  # 0x1ab0b084
movb %cl, 0x1aabde92(%rip)   # 0x1ab0b080
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: SetTimeSettings(int, int, int)
void
SetTimeSettings( const int main_time, const int byoyomi, const int stones )
{
  if (search_setting == SearchTimeStrategy::ConstantPlayoutMode ||
      search_setting == SearchTimeStrategy::ConstantTimeMode ) {
    return ;
  }

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

// Assembly:
cmpl $0x2, 0x28665(%rip)     # 0x75888
jae 0x4d226
retq
pushq %rbx
testl %edi, %edi
je 0x4d271
cvtsi2sd %edi, %xmm0
movsd %xmm0, 0x28661(%rip)    # 0x75898
testl %esi, %esi
je 0x4d2a4
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x2864e(%rip)    # 0x758a0
movl $0x3, 0x2862c(%rip)     # 0x75888
movq 0x27d85(%rip), %rdi     # 0x74fe8
leaq 0x12ed1(%rip), %rsi     # 0x6013b
movl $0x1b, %edx
jmp 0x4d2c1
cvtsi2sd %esi, %xmm0
mulsd 0x12e6b(%rip), %xmm0    # 0x600e8
movsd %xmm0, 0x2861b(%rip)    # 0x758a0
movl $0x1, 0x285f9(%rip)     # 0x75888
movq 0x27d52(%rip), %rdi     # 0x74fe8
leaq 0x12e73(%rip), %rsi     # 0x60110
movl $0x18, %edx
jmp 0x4d2c1
movl $0x2, 0x285da(%rip)     # 0x75888
movq 0x27d33(%rip), %rdi     # 0x74fe8
leaq 0x12e6d(%rip), %rsi     # 0x60129
movl $0x11, %edx
callq 0x64a0
movq 0x27d1b(%rip), %rbx     # 0x74fe8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x63d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
jmp 0x62a0
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: SetTimeManagementParameter()
void
SetTimeManagementParameter( void )
{
  if (!time_c_changed) {
    if (pure_board_size < 11) {
      time_c = TIME_C_9;
    } else if (pure_board_size < 16) {
      time_c = TIME_C_13;
    } else {
      time_c = TIME_C_19;
    }
  }

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

// Assembly:
cmpb $0x0, 0x1aabdc4b(%rip)  # 0x1ab0b0b0
jne 0x4d491
leaq 0x28446(%rip), %rax     # 0x758b4
movl (%rax), %eax
cmpl $0x10, %eax
movl $0x1e, %ecx
movl $0x3c, %edx
cmovll %ecx, %edx
cmpl $0xb, %eax
movl $0x14, %eax
cmovgel %edx, %eax
movl %eax, 0x28417(%rip)     # 0x758a8
cmpb $0x0, 0x1aabdc19(%rip)  # 0x1ab0b0b1
jne 0x4d4c1
leaq 0x28413(%rip), %rax     # 0x758b4
movl (%rax), %eax
cmpl $0x10, %eax
movl $0x1e, %ecx
movl $0x50, %edx
cmovll %ecx, %edx
xorl %ecx, %ecx
cmpl $0xb, %eax
cmovgel %edx, %ecx
movl %ecx, 0x283eb(%rip)     # 0x758ac
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: CalculatePlayoutSpeed(double, int)
double
CalculatePlayoutSpeed( const double consume_time, const int threads )
{
  if (consume_time < 0.001) {
    return PLAYOUT_SPEED * threads;
  } else {
    return po_info.count / consume_time;
  }
}

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

  if (!interruption_flag) {
    return false;
  }

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x18(%rdi), %r14d
movl 0x1aabda92(%rip), %ebp  # 0x1ab0b088
movl 0x1aabda8f(%rip), %r15d # 0x1ab0b08c
cmpb $0x1, 0x28288(%rip)     # 0x7588c
jne 0x4d65c
movq %rdi, %rbx
cmpl $0x0, 0x28278(%rip)     # 0x75888
je 0x4d660
callq 0x6070
subq 0x1aabda9a(%rip), %rax  # 0x1ab0b0b8
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
cvtsi2sd %rdx, %xmm0
divsd 0x1292a(%rip), %xmm0    # 0x5ff70
mulsd 0x12952(%rip), %xmm0    # 0x5ffa0
movsd 0x1aabda22(%rip), %xmm1 # 0x1ab0b078
ucomisd %xmm0, %xmm1
jbe 0x4d660
xorl %eax, %eax
jmp 0x4d6a9
subl %r15d, %ebp
testl %r14d, %r14d
jle 0x4d6a2
leaq (%r14,%r14,8), %rax
leaq (%rax,%rax,2), %rcx
addq %r14, %rcx
xorl %edx, %edx
xorl %eax, %eax
xorl %esi, %esi
movl 0x20(%rbx,%rdx), %r8d
movl 0x20(%rbx,%rdx), %edi
cmpl %eax, %r8d
jle 0x4d68d
movl %eax, %esi
movl %edi, %eax
jmp 0x4d695
cmpl %esi, %edi
jle 0x4d695
movl 0x20(%rbx,%rdx), %esi
addq $0x1c, %rdx
cmpq %rdx, %rcx
jne 0x4d679
subl %esi, %eax
jmp 0x4d6a4
xorl %eax, %eax
cmpl %ebp, %eax
setg %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/mcts/SearchManager.cpp
// Function: ExtendTime(uct_node_t const&, int)
bool
ExtendTime( const uct_node_t &root, const int moves )
{
  const int child_num = root.child_num;
  const child_node_t *child = root.child;
  int max = 0, second = 0;

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

  if (root_wp > 0.80) {
    return false;
  }

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

// Assembly:
cmpb $0x1, 0x1aabd9c5(%rip)  # 0x1ab0b080
jne 0x4d6ef
leaq 0x281f0(%rip), %rax     # 0x758b4
movl (%rax), %eax
leal (%rax,%rax,2), %eax
addl $-0x11, %eax
cmpl %esi, %eax
jg 0x4d6ef
movl 0x18(%rdi), %ecx
movl 0xc(%rdi), %eax
cvtsi2sd %eax, %xmm0
movl 0x8(%rdi), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
ucomisd 0x12a13(%rip), %xmm0    # 0x60100
jbe 0x4d6f2
xorl %eax, %eax
retq
testl %ecx, %ecx
jle 0x4d749
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rcx, %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl %esi, %r8d
movl 0x20(%rdi,%rcx), %r9d
movl 0x20(%rdi,%rcx), %esi
cmpl %r8d, %r9d
jle 0x4d71d
movl %r8d, %edx
jmp 0x4d728
cmpl %edx, %esi
jle 0x4d725
movl 0x20(%rdi,%rcx), %edx
movl %r8d, %esi
addq $0x1c, %rcx
cmpq %rcx, %rax
jne 0x4d707
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd 0x129c1(%rip), %xmm1    # 0x60108
jmp 0x4d751
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
seta %al
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq 0x27a70(%rip), %rax     # 0x758bc
movl (%rax), %ecx
notl %ecx
addl %esi, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
andl $0xff3fff, (%rdi,%rcx,8) # imm = 0xFF3FFF
movslq (%rax), %rcx
movslq %esi, %rdx
movq %rdx, %rsi
subq %rcx, %rsi
leaq (%rsi,%rsi,2), %rcx
andl $0xffcfff, (%rdi,%rcx,8) # imm = 0xFFCFFF
leal 0x1(%rdx), %ecx
movl %ecx, %esi
subl (%rax), %esi
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
andl $0xfff3ff, (%rdi,%rsi,8) # imm = 0xFFF3FF
leaq (%rdx,%rdx,2), %rsi
andl $0xfffcff, -0x18(%rdi,%rsi,8) # imm = 0xFFFCFF
andl $0xffff3f, 0x18(%rdi,%rsi,8) # imm = 0xFFFF3F
movl (%rax), %esi
addl %edx, %esi
decl %esi
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
andl $0xffffcf, (%rdi,%rsi,8) # imm = 0xFFFFCF
movslq (%rax), %rsi
addq %rdx, %rsi
leaq (%rsi,%rsi,2), %rdx
andl $0xfffff3, (%rdi,%rdx,8) # imm = 0xFFFFF3
addl (%rax), %ecx
movslq %ecx, %rax
leaq (%rax,%rax,2), %rax
andl $0xfffffc, (%rdi,%rax,8) # imm = 0xFFFFFC
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: UpdatePat3Stone(pattern_t*, int, int)
void
UpdatePat3Stone( pattern_t *pat, const int color, const int pos )
{
  pat[pos + NW].list[MD_2] |= update_mask[0][color];
  pat[pos +  N].list[MD_2] |= update_mask[1][color];
  pat[pos + NE].list[MD_2] |= update_mask[2][color];
  pat[pos +  W].list[MD_2] |= update_mask[3][color];
  pat[pos +  E].list[MD_2] |= update_mask[4][color];
  pat[pos + SW].list[MD_2] |= update_mask[5][color];
  pat[pos +  S].list[MD_2] |= update_mask[6][color];
  pat[pos + SE].list[MD_2] |= update_mask[7][color];
}

// Assembly:
movslq %esi, %rax
leaq 0x12290(%rip), %rsi     # 0x60170
leaq 0x279d5(%rip), %rcx     # 0x758bc
movl (%rcx), %r8d
notl %r8d
addl %edx, %r8d
movslq %r8d, %r8
leaq (%r8,%r8,2), %r8
movl (%rsi,%rax,4), %r9d
movl 0xc(%rsi,%rax,4), %r10d
orl %r9d, (%rdi,%r8,8)
movslq (%rcx), %r8
movslq %edx, %rdx
movq %rdx, %r9
subq %r8, %r9
leaq (%r9,%r9,2), %r8
orl %r10d, (%rdi,%r8,8)
movl 0x18(%rsi,%rax,4), %r8d
leal 0x1(%rdx), %r9d
movl %r9d, %r10d
subl (%rcx), %r10d
movslq %r10d, %r10
leaq (%r10,%r10,2), %r10
orl %r8d, (%rdi,%r10,8)
movl 0x24(%rsi,%rax,4), %r8d
leaq (%rdx,%rdx,2), %r10
orl %r8d, -0x18(%rdi,%r10,8)
movl 0x30(%rsi,%rax,4), %r8d
orl %r8d, 0x18(%rdi,%r10,8)
movl 0x3c(%rsi,%rax,4), %r8d
movl (%rcx), %r10d
addl %edx, %r10d
decl %r10d
movslq %r10d, %r10
leaq (%r10,%r10,2), %r10
orl %r8d, (%rdi,%r10,8)
movl 0x48(%rsi,%rax,4), %r8d
movslq (%rcx), %r10
addq %rdx, %r10
leaq (%r10,%r10,2), %rdx
orl %r8d, (%rdi,%rdx,8)
movl 0x54(%rsi,%rax,4), %eax
addl (%rcx), %r9d
movslq %r9d, %rcx
leaq (%rcx,%rcx,2), %rcx
orl %eax, (%rdi,%rcx,8)
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: UpdateMD2Empty(pattern_t*, int)
void
UpdateMD2Empty( 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;
  pat[pos + NN].list[MD_2] &= 0xCFFFFF;
  pat[pos + EE].list[MD_2] &= 0x3FFFFF;
  pat[pos + SS].list[MD_2] &= 0xFCFFFF;
  pat[pos + WW].list[MD_2] &= 0xF3FFFF;
}

// Assembly:
leaq 0x2792d(%rip), %rax     # 0x758bc
movl (%rax), %ecx
notl %ecx
addl %esi, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
andl $0xff3fff, (%rdi,%rcx,8) # imm = 0xFF3FFF
movslq (%rax), %rdx
movslq %esi, %rcx
movq %rcx, %rsi
subq %rdx, %rsi
leaq (%rsi,%rsi,2), %rdx
andl $0xffcfff, (%rdi,%rdx,8) # imm = 0xFFCFFF
leal 0x1(%rcx), %esi
movl %esi, %edx
subl (%rax), %edx
movslq %edx, %rdx
leaq (%rdx,%rdx,2), %rdx
andl $0xfff3ff, (%rdi,%rdx,8) # imm = 0xFFF3FF
leaq (%rcx,%rcx,2), %rdx
andl $0xfffcff, -0x18(%rdi,%rdx,8) # imm = 0xFFFCFF
andl $0xffff3f, 0x18(%rdi,%rdx,8) # imm = 0xFFFF3F
movl (%rax), %r8d
addl %ecx, %r8d
decl %r8d
movslq %r8d, %r8
leaq (%r8,%r8,2), %r8
andl $0xffffcf, (%rdi,%r8,8) # imm = 0xFFFFCF
movslq (%rax), %r8
addq %rcx, %r8
leaq (%r8,%r8,2), %r8
andl $0xfffff3, (%rdi,%r8,8) # imm = 0xFFFFF3
addl (%rax), %esi
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
andl $0xfffffc, (%rdi,%rsi,8) # imm = 0xFFFFFC
movl (%rax), %esi
addl %esi, %esi
movl %ecx, %r8d
subl %esi, %r8d
movslq %r8d, %rsi
leaq (%rsi,%rsi,2), %rsi
andl $0xcfffff, (%rdi,%rsi,8) # imm = 0xCFFFFF
andl $0x3fffff, 0x30(%rdi,%rdx,8) # imm = 0x3FFFFF
movslq (%rax), %rax
leaq (%rcx,%rax,2), %rax
leaq (%rax,%rax,2), %rax
andl $0xfcffff, (%rdi,%rax,8) # imm = 0xFCFFFF
andl $0xf3ffff, -0x30(%rdi,%rdx,8) # imm = 0xF3FFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: UpdateMD2Stone(pattern_t*, int, int)
void
UpdateMD2Stone( pattern_t *pat, const int color, const int pos )
{
  pat[pos + NW].list[MD_2] |= update_mask[0][color];
  pat[pos +  N].list[MD_2] |= update_mask[1][color];
  pat[pos + NE].list[MD_2] |= update_mask[2][color];
  pat[pos +  W].list[MD_2] |= update_mask[3][color];
  pat[pos +  E].list[MD_2] |= update_mask[4][color];
  pat[pos + SW].list[MD_2] |= update_mask[5][color];
  pat[pos +  S].list[MD_2] |= update_mask[6][color];
  pat[pos + SE].list[MD_2] |= update_mask[7][color];
  pat[pos + NN].list[MD_2] |= update_mask[8][color];
  pat[pos + EE].list[MD_2] |= update_mask[9][color];
  pat[pos + SS].list[MD_2] |= update_mask[10][color];
  pat[pos + WW].list[MD_2] |= update_mask[11][color];
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movl %edi, (%rsi)
movq %rsi, (%rsp)
movl %edi, %r12d
shrl $0xa, %r12d
movl %r12d, %eax
andl $0x3f, %eax
movl $0x3c0, %ebx            # imm = 0x3C0
movl %edi, %ecx
andl %ebx, %ecx
movl %edi, %r13d
shll $0xa, %r13d
movl $0xffff, %r14d          # imm = 0xFFFF
movl %r13d, %r15d
andl %r14d, %r15d
orl %ecx, %r15d
orl %eax, %r15d
movl %r15d, 0x4(%rsi)
callq 0x4edbe
movq (%rsp), %rdx
movl %eax, 0x8(%rdx)
movl %eax, %ecx
shrl $0xa, %ecx
andl %eax, %ebx
movl %eax, %edi
shll $0xa, %edi
andl %edi, %r14d
orl %ebx, %r14d
orl %ecx, %r14d
movl %r14d, 0xc(%rdx)
movl $0xc00, %r8d            # imm = 0xC00
andl %r8d, %r13d
movl %ebp, %r9d
shll $0x4, %r9d
movl $0xc0c0, %esi           # imm = 0xC0C0
andl %esi, %r9d
orl %r13d, %r9d
movl %ebp, %r11d
shrl $0x4, %r11d
movl $0x303, %esi            # imm = 0x303
andl %esi, %r11d
orl %r9d, %r11d
movl %ebp, %r10d
shll $0x6, %r10d
movl $0x3000, %r9d           # imm = 0x3000
andl %r9d, %r10d
orl %r10d, %r11d
movl %ebp, %ebx
shrl $0x6, %ebx
andl $0xc, %ebx
orl %ebx, %r11d
andl $0x30, %r12d
orl %r11d, %r12d
movl %r12d, 0x10(%rdx)
movl %ebp, %r11d
andl %r8d, %r11d
movl %r15d, %r12d
shll $0x4, %r12d
movl $0xc0c0, %r13d          # imm = 0xC0C0
andl %r13d, %r12d
shrl $0x4, %r15d
andl %esi, %r15d
andl $0x30, %ebp
orl %ebx, %ebp
orl %r10d, %ebp
orl %r11d, %ebp
orl %r12d, %ebp
orl %r15d, %ebp
movl %ebp, 0x14(%rdx)
andl %r8d, %edi
movl %eax, %r8d
shll $0x4, %r8d
andl %r13d, %r8d
movl $0xc0c0, %r10d          # imm = 0xC0C0
orl %edi, %r8d
movl %eax, %edi
shrl $0x4, %edi
andl %esi, %edi
orl %r8d, %edi
movl %eax, %r8d
shll $0x6, %r8d
andl %r9d, %r8d
orl %r8d, %edi
movl %eax, %r9d
shrl $0x6, %r9d
andl $0xc, %r9d
orl %r9d, %edi
andl $-0x10, %ecx
orl %edi, %ecx
movl %ecx, 0x18(%rdx)
movl %r14d, %ecx
shll $0x4, %ecx
andl %r10d, %ecx
shrl $0x4, %r14d
andl %esi, %r14d
andl $0xc30, %eax            # imm = 0xC30
orl %r8d, %eax
orl %r9d, %eax
orl %ecx, %eax
orl %r14d, %eax
movl %eax, 0x1c(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edi, %eax
andl $0x3, %eax
shll $0xa, %eax
movl %edi, %ecx
shll $0x4, %ecx
andl $0xc0c0, %ecx           # imm = 0xC0C0
orl %eax, %ecx
movl %edi, %eax
shrl $0x4, %eax
andl $0x303, %eax            # imm = 0x303
orl %ecx, %eax
movl %edi, %ecx
shll $0x6, %ecx
andl $0x3000, %ecx           # imm = 0x3000
orl %eax, %ecx
movl %edi, %eax
shrl $0x6, %eax
andl $0xc, %eax
orl %ecx, %eax
shrl $0xa, %edi
andl $0x30, %edi
orl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edi, %edx
shrl $0xa, %edx
movl %edi, %eax
shrl $0xe, %eax
movl %eax, %ecx
andl $0x3, %ecx
andl $0xc, %edx
orl %ecx, %edx
movl %edi, %ecx
shrl $0x6, %ecx
andl $0x30, %ecx
orl %edx, %ecx
shll $0xa, %ecx
movl %edi, %edx
shrl $0x8, %edx
andl $0x3, %edx
movl %edi, %esi
shrl $0x4, %esi
movl %esi, %r8d
andl $0xc, %r8d
orl %edx, %r8d
shll $0x6, %r8d
andl $0x3, %esi
movl %edi, %edx
andl $0xc, %edx
orl %esi, %edx
movl %edi, %esi
shll $0x4, %esi
andl $0x30, %esi
orl %edx, %esi
orl %r8d, %esi
movl %edi, %edx
shrl $0x16, %edx
andl $0x3, %edx
andl $0x30, %eax
orl %edx, %eax
shll $0x12, %eax
orl %esi, %eax
orl %ecx, %eax
andl $0x330000, %edi         # imm = 0x330000
orl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edi, %eax
andl $0x3, %eax
shll $0xa, %eax
movl %edi, %ecx
shll $0x4, %ecx
andl $0xc0c0, %ecx           # imm = 0xC0C0
orl %eax, %ecx
movl %edi, %eax
shrl $0x4, %eax
andl $0x303, %eax            # imm = 0x303
orl %ecx, %eax
movl %edi, %ecx
shll $0x6, %ecx
andl $0xc03000, %ecx         # imm = 0xC03000
orl %eax, %ecx
movl %edi, %edx
shrl $0x6, %edx
andl $0xc, %edx
orl %ecx, %edx
movl %edi, %eax
shrl $0xa, %eax
andl $0x30, %eax
orl %edx, %eax
shrl $0x2, %edi
andl $0x3f0000, %edi         # imm = 0x3F0000
orl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15d
movl %edi, (%rsi)
callq 0x4f22d
movl %eax, %r14d
movl %eax, 0x4(%rbx)
movl %r15d, %edi
callq 0x4f29f
movl %eax, %ebp
movl %eax, 0x8(%rbx)
movl %eax, %edi
callq 0x4f22d
movl %eax, 0xc(%rbx)
movl %r15d, %ecx
andl $0x3f, %ecx
shll $0x12, %ecx
shrl $0x6, %r15d
andl $0x3ffff, %r15d         # imm = 0x3FFFF
orl %ecx, %r15d
movl %r15d, 0x10(%rbx)
movl %r14d, %ecx
andl $0x3f, %ecx
shll $0x12, %ecx
shrl $0x6, %r14d
orl %ecx, %r14d
movl %r14d, 0x14(%rbx)
movl %ebp, %ecx
andl $0x3f, %ecx
shll $0x12, %ecx
shrl $0x6, %ebp
orl %ecx, %ebp
movl %ebp, 0x18(%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_O1/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:
movl %edi, %eax
shrl $0xc, %eax
movl %eax, %ecx
andl $0x3, %ecx
movl %edi, %edx
andl $0x3, %edx
shll $0xc, %edx
orl %ecx, %edx
movl %edi, %ecx
shrl $0xa, %ecx
andl $0x3, %ecx
movl %edi, %esi
andl $0xc, %esi
shll $0x6, %esi
orl %ecx, %esi
leal (%rdx,%rsi,4), %ecx
movl %edi, %edx
shrl $0x8, %edx
andl $0x3, %edx
movl %edi, %esi
andl $0x30, %esi
orl %edx, %esi
shll $0x4, %esi
orl %ecx, %esi
movl %edi, %ecx
shrl $0x16, %ecx
andl $0x3, %ecx
movl %edi, %edx
shrl $0x6, %edx
andl $0x300, %edx            # imm = 0x300
orl %ecx, %edx
shll $0xe, %edx
orl %esi, %edx
movl %edi, %ecx
shrl $0x14, %ecx
andl $0x3, %ecx
andl $0x30, %eax
orl %ecx, %eax
shll $0x10, %eax
orl %edx, %eax
andl $0xc00c0, %edi          # imm = 0xC00C0
orl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edi, %eax
andl $0x3003, %eax           # imm = 0x3003
movl %edi, %ecx
shrl $0x16, %ecx
movl %edi, %edx
shll $0x12, %edx
orl %ecx, %edx
andl $0x300003, %edx         # imm = 0x300003
leal (%rax,%rdx,4), %eax
movl %edi, %ecx
roll $0xc, %ecx
andl $0x30003, %ecx          # imm = 0x30003
shll $0x4, %ecx
orl %eax, %ecx
movl %edi, %eax
shrl $0x12, %eax
andl $0x3, %eax
movl %edi, %edx
shll $0x6, %edx
andl $0x3000, %edx           # imm = 0x3000
orl %eax, %edx
shll $0x6, %edx
orl %ecx, %edx
movl %edi, %eax
shrl $0x10, %eax
andl $0x3, %eax
movl %edi, %ecx
andl $0x300, %ecx            # imm = 0x300
orl %eax, %ecx
shll $0x8, %ecx
orl %edx, %ecx
movl %edi, %eax
shrl $0xe, %eax
andl $0x3, %eax
shrl $0x6, %edi
andl $0x30, %edi
orl %edi, %eax
shll $0xa, %eax
orl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f3bd
movl %eax, %r14d
movl %eax, 0x4(%rbx)
movl %ebp, %edi
callq 0x4f457
movl %eax, %r15d
movl %eax, 0x8(%rbx)
movl %eax, %edi
callq 0x4f3bd
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_O1/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:
movl %edi, %eax
roll $0x10, %eax
andl $0x30003, %eax          # imm = 0x30003
movl %edi, %ecx
shrl $0xe, %ecx
andl $0x3, %ecx
movl %edi, %edx
andl $0xc, %edx
shll $0xa, %edx
orl %ecx, %edx
leal (%rax,%rdx,4), %ecx
movl %edi, %eax
shrl $0xc, %eax
movl %eax, %edx
andl $0x3, %edx
movl %edi, %esi
andl $0x30, %esi
shll $0x4, %esi
orl %edx, %esi
shll $0x4, %esi
orl %ecx, %esi
movl %edi, %ecx
shrl $0xa, %ecx
andl $0x3, %ecx
movl %edi, %edx
shrl $0x2, %edx
andl $0x30, %edx
orl %ecx, %edx
shll $0x6, %edx
orl %esi, %edx
movl %edi, %esi
shrl $0x1e, %esi
movl %edi, %ecx
shrl $0x6, %ecx
andl $0x3000, %ecx           # imm = 0x3000
orl %esi, %ecx
shll $0x12, %ecx
orl %edx, %ecx
movl %edi, %edx
shrl $0x1c, %edx
andl $0x3, %edx
andl $0x300, %eax            # imm = 0x300
orl %edx, %eax
shll $0x14, %eax
movl %edi, %edx
shrl $0x1a, %edx
andl $0x3, %edx
movl %edi, %esi
shrl $0x12, %esi
andl $0x30, %esi
orl %edx, %esi
shll $0x16, %esi
andl $0x3000300, %edi        # imm = 0x3000300
orl %edi, %eax
orl %esi, %eax
orl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0x30003, %eax          # imm = 0x30003
movl %edi, %ecx
andl %eax, %ecx
movl %edi, %edx
shrl $0x1e, %edx
movl %edi, %esi
andl $0xc, %esi
shll $0x1a, %esi
orl %edx, %esi
leal (%rcx,%rsi,4), %ecx
movl %edi, %edx
shrl $0x1c, %edx
movl %edi, %esi
shll $0x14, %esi
orl %edx, %esi
andl $0x3000003, %esi        # imm = 0x3000003
shll $0x4, %esi
orl %ecx, %esi
movl %edi, %ecx
shrl $0x1a, %ecx
movl %edi, %edx
shll $0xe, %edx
orl %ecx, %edx
andl $0x300003, %edx         # imm = 0x300003
shll $0x6, %edx
orl %esi, %edx
movl %edi, %ecx
roll $0x8, %ecx
andl %eax, %ecx
shll $0x8, %ecx
orl %edx, %ecx
movl %edi, %eax
shrl $0x16, %eax
leal (,%rdi,4), %edx
orl %eax, %edx
andl $0x3003, %edx           # imm = 0x3003
shll $0xa, %edx
movl %edi, %eax
shrl $0x14, %eax
andl $0x3, %eax
movl %edi, %esi
shrl $0x4, %esi
andl $0x300, %esi            # imm = 0x300
orl %eax, %esi
shll $0xc, %esi
orl %edx, %esi
movl %edi, %eax
shrl $0x12, %eax
andl $0x3, %eax
shrl $0xa, %edi
andl $0x30, %edi
orl %edi, %eax
shll $0xe, %eax
orl %esi, %eax
orl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rdi, (%rsi)
callq 0x4f5ea
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0x4f6e3
movq %rax, %r14
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0x4f5ea
movq %rax, 0x18(%rbx)
movl %r12d, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
shlq $0x1e, %rcx
shrq $0xa, %r12
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
orq %rcx, %r12
movq %r12, 0x20(%rbx)
movl %r15d, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
shlq $0x1e, %rcx
shrq $0xa, %r15
orq %rcx, %r15
movq %r15, 0x28(%rbx)
movl %r14d, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
shlq $0x1e, %rcx
shrq $0xa, %r14
orq %rcx, %r14
movq %r14, 0x30(%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_O1/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:
movq %rdi, %rax
movl %eax, %ecx
shrl $0x14, %ecx
movl %eax, %edx
shll $0x14, %edx
orl %ecx, %edx
andl $0x300003, %edx         # imm = 0x300003
movq %rdi, %rcx
shrq $0x12, %rcx
movl %ecx, %esi
andl $0x3, %esi
andl $0xc, %edi
shll $0xe, %edi
orl %esi, %edi
leal (%rdx,%rdi,4), %edx
movl %eax, %esi
shrl $0x10, %esi
andl $0x3, %esi
movl %eax, %edi
andl $0x30, %edi
shll $0x8, %edi
orl %esi, %edi
shll $0x4, %edi
orl %edx, %edi
movl %eax, %edx
shrl $0xe, %edx
andl $0x3, %edx
movl %eax, %esi
andl $0xc0, %esi
leal (%rdx,%rsi,4), %r8d
shll $0x6, %r8d
orl %edi, %r8d
movq %rax, %rsi
shrq $0xc, %rsi
movl %esi, %edi
andl $0x3, %edi
movl %eax, %edx
shrl $0x4, %edx
andl $0x30, %edx
orl %edi, %edx
shll $0x8, %edx
orl %r8d, %edx
movq %rax, %r8
shrq $0x26, %r8
andl $0x3, %r8d
movl %eax, %edi
shrl $0x6, %edi
andl $0x30000, %edi          # imm = 0x30000
orq %r8, %rdi
shlq $0x16, %rdi
movq %rax, %r8
shrq $0x24, %r8
andl $0x3, %r8d
andl $0x3000, %esi           # imm = 0x3000
orq %r8, %rsi
shlq $0x18, %rsi
movq %rax, %r8
shrq $0x22, %r8
andl $0x3, %r8d
andl $0x300, %ecx            # imm = 0x300
orq %r8, %rcx
shlq $0x1a, %rcx
movq %rax, %r8
shrq $0x20, %r8
andl $0x3, %r8d
movl %eax, %r9d
shrl $0x18, %r9d
andl $0x30, %r9d
orq %r8, %r9
shlq $0x1c, %r9
andl $0xc0000c00, %eax       # imm = 0xC0000C00
orq %rdi, %rax
orq %rsi, %rax
orq %rcx, %rax
orq %r9, %rax
orq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: MD5HorizontalMirror(unsigned long long)
unsigned long long
MD5HorizontalMirror( const unsigned long long md5 )
{
  return (md5 & 0x0000300003)
    | (REV18((md5 & 0xC00000000C) >> 2) << 2)
    | (REV16((md5 & 0x3000000030) >> 4) << 4)
    | (REV14((md5 & 0x0C000000C0) >> 6) << 6)
    | (REV12((md5 & 0x0300000300) >> 8) << 8)
    | (REV10((md5 & 0x00C0000C00) >> 10) << 10)
    | (REV8((md5 & 0x0030003000) >> 12) << 12)
    | (REV6((md5 & 0x000C00C000) >> 14) << 14)
    | (REV4((md5 & 0x0003030000) >> 16) << 16)
    | (REV2((md5 & 0x0000CC0000) >> 18) << 18);
}

// Assembly:
movq %rdi, %rax
movl %eax, %ecx
andl $0x300003, %ecx         # imm = 0x300003
movq %rdi, %rdx
shrq $0x26, %rdx
movq %rdi, %rsi
shlq $0x22, %rsi
orq %rdx, %rsi
movabsq $0x3000000003, %rdx     # imm = 0x3000000003
andq %rsi, %rdx
movq %rdi, %rsi
rolq $0x1c, %rsi
leaq (%rcx,%rdx,4), %rcx
movabsq $0x300000003, %rdx      # imm = 0x300000003
andq %rsi, %rdx
shlq $0x4, %rdx
orq %rcx, %rdx
movq %rdi, %rcx
shrq $0x22, %rcx
andl $0x3, %ecx
movl %eax, %esi
shll $0x16, %esi
andl $0x30000000, %esi       # imm = 0x30000000
orq %rcx, %rsi
shlq $0x6, %rsi
orq %rdx, %rsi
movq %rdi, %rdx
shrq $0x20, %rdx
andl $0x3, %edx
movl %eax, %ecx
shll $0x10, %ecx
andl $0x3000000, %ecx        # imm = 0x3000000
orq %rdx, %rcx
shlq $0x8, %rcx
orq %rsi, %rcx
movl %eax, %edx
shrl $0x1e, %edx
movl %eax, %esi
shll $0xa, %esi
andl $0x300000, %esi         # imm = 0x300000
orl %edx, %esi
movl %eax, %edx
roll $0x4, %edx
shll $0xa, %esi
andl $0x30003, %edx          # imm = 0x30003
shll $0xc, %edx
orl %esi, %edx
movl %eax, %esi
shrl $0x1a, %esi
andl $0x3, %esi
shrl $0x2, %edi
andl $0x3000, %edi           # imm = 0x3000
orl %esi, %edi
shll $0xe, %edi
orl %edx, %edi
movl %eax, %edx
shrl $0x18, %edx
andl $0x3, %edx
movl %eax, %esi
shrl $0x8, %esi
andl $0x300, %esi            # imm = 0x300
orl %edx, %esi
shll $0x10, %esi
orl %edi, %esi
movl %eax, %edx
shrl $0x16, %edx
andl $0x3, %edx
shrl $0xe, %eax
andl $0x30, %eax
orl %edx, %eax
shll $0x12, %eax
orl %esi, %eax
orq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: DisplayInputPat3(unsigned int)
void
DisplayInputPat3( const unsigned int pat3 )
{
  std::ostringstream oss;

  oss << "\n";
  oss << Stone(pat3,  0) << Stone(pat3,  2) << Stone(pat3,  4) << "\n";
  oss << Stone(pat3,  6) << "*"             << Stone(pat3,  8) << "\n";
  oss << Stone(pat3, 10) << Stone(pat3, 12) << Stone(pat3, 14) << "\n";
  std::cerr << oss.str() << std::flush;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6560
leaq 0x10c9c(%rip), %rsi     # 0x60545
movl $0x1, %edx
movq %r14, %rdi
callq 0x64a0
movl %ebx, %eax
andl $0x3, %eax
leaq 0x10c85(%rip), %r15     # 0x60547
movb (%rax,%r15), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x64a0
movl %ebx, %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
movb (%rcx,%r15), %cl
leaq 0x8(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl %ebx, %ecx
shrl $0x4, %ecx
andl $0x3, %ecx
movb (%rcx,%r15), %cl
leaq 0x8(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
leaq 0x10c22(%rip), %rsi     # 0x60545
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl %ebx, %eax
shrl $0x6, %eax
andl $0x3, %eax
movb (%rax,%r15), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x64a0
movq %rax, %r14
leaq 0x10bd4(%rip), %rsi     # 0x60530
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl %ebx, %eax
shrl $0x8, %eax
andl $0x3, %eax
movb (%rax,%r15), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x64a0
leaq 0x10bb5(%rip), %rsi     # 0x60545
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl %ebx, %eax
shrl $0xa, %eax
andl $0x3, %eax
movb (%rax,%r15), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x64a0
movl %ebx, %ecx
shrl $0xc, %ecx
andl $0x3, %ecx
movb (%rcx,%r15), %cl
leaq 0x8(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
shrl $0xe, %ebx
andl $0x3, %ebx
movb (%rbx,%r15), %cl
leaq 0x8(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
leaq 0x10b41(%rip), %rsi     # 0x60545
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6680
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x255b7(%rip), %rdi     # 0x74fe8
callq 0x64a0
movq %rax, %rdi
callq 0x62a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fa59
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6420
movq 0x25538(%rip), %rsi     # 0x74f98
leaq 0x28(%rsp), %rdi
callq 0x61f0
leaq 0x98(%rsp), %rdi
callq 0x60f0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4faa6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4faa9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6420
jmp 0x4faa9
movq %rax, %rbx
movq 0x254e8(%rip), %rsi     # 0x74f98
leaq 0x28(%rsp), %rdi
callq 0x61f0
leaq 0x98(%rsp), %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x6770
// File: /workspace/github_cpp_makefile_star2_O1/kobanium[P]Ray/src/pattern/Pattern.cpp
// Function: DisplayInputMD5(unsigned long long)
void
DisplayInputMD5( const unsigned long long md5 )
{
  std::ostringstream oss;

  oss << "\n";
  oss << "     " << Stone(md5,  0) << "     \n";
  oss << "    " << Stone(md5, 38) << " " << Stone(md5,  2) << "    \n";
  oss << "   " << Stone(md5, 36) << "   " << Stone(md5,  4) << "   \n";
  oss << "  " << Stone(md5, 34) << "     " << Stone(md5,  6) << "  \n";
  oss << " " << Stone(md5, 32) << "       " << Stone(md5,  8) << " \n";
  oss <<       Stone(md5, 30) << "    *    " << Stone(md5, 10) << "\n";
  oss << " " << Stone(md5, 28) << "       " << Stone(md5, 12) << " \n";
  oss << "  " << Stone(md5, 26) << "     " << Stone(md5, 14) << "  \n";
  oss << "   " << Stone(md5, 24) << "   " << Stone(md5, 16) << "   \n";
  oss << "    " << Stone(md5, 22) << " " << Stone(md5, 18) << "    \n";
  oss << "     " << Stone(md5, 20) << "     \n";
  std::cerr << oss.str() << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6560
leaq 0xfdc2(%rip), %rsi      # 0x60545
movl $0x1, %edx
movq %r14, %rdi
callq 0x64a0
leaq 0xce65(%rip), %rsi      # 0x5d5fc
leaq 0x10(%rsp), %rdi
movl $0x5, %edx
callq 0x64a0
andl $0x3, %ebx
leaq 0xfd97(%rip), %rax      # 0x60547
movb (%rbx,%rax), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x64a0
leaq 0xfd70(%rip), %rsi      # 0x60540
movl $0x6, %edx
movq %rax, %rdi
callq 0x64a0
leaq 0xce19(%rip), %rsi      # 0x5d5fd
leaq 0x10(%rsp), %rdi
movl $0x4, %edx
callq 0x64a0
movq %rax, %rbx
movq 0x2479b(%rip), %rsi     # 0x74f98
leaq 0x10(%rsp), %rdi
callq 0x61f0
leaq 0x80(%rsp), %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x6770