LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/main.cpp
// Function: main
int main(int argc, char* argv[]){
  if(argc != 5){
    cout << "The number of argument is invalid." << endl;
    exit(1);
  }

  LogicomeProfiler temp_logicome_profiler;
  temp_logicome_profiler.SetParameters(argv);
  temp_logicome_profiler.Run();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
cmpl $0x5, %edi
jne 0x24f1
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2528
movq %r14, %rdi
movq %rbx, %rsi
callq 0x466a
movq %rsp, %rdi
callq 0x29b2
movq %rsp, %rdi
callq 0x2668
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
movq 0xaae0(%rip), %rdi      # 0xcfd8
leaq 0x5b05(%rip), %rsi      # 0x8004
callq 0x21b0
movq %rax, %rdi
callq 0x2100
pushq $0x1
popq %rdi
callq 0x2210
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2668
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/./logicome_profiler.h
// Function: LogicomeProfiler::LogicomeProfiler()
LogicomeProfiler(){
    _input_data_file_name = "";
    _output_file_name = "";
    _number_of_samples = 0;
    _number_of_elements = 0;
    _criteria = 0;
    _alpha = 0.0;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc0(%rdi), %r14
leaq 0xd0(%rdi), %r15
xorl %ebp, %ebp
movl $0xc0, %edx
xorl %esi, %esi
callq 0x2120
movq %r15, 0xc0(%rbx)
andq $0x0, 0xc8(%rbx)
movb %bpl, 0xd0(%rbx)
leaq 0xe0(%rbx), %r12
leaq 0xf0(%rbx), %rax
movq %rax, 0xe0(%rbx)
andq $0x0, 0xe8(%rbx)
movb %bpl, 0xf0(%rbx)
leaq 0x5b30(%rip), %rsi      # 0x80c6
movq %r14, %rdi
callq 0x2340
leaq 0x5b21(%rip), %rsi      # 0x80c6
movq %r12, %rdi
callq 0x2340
andl $0x0, 0x114(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x20(%rsp)
leaq 0xa8(%rbx), %r15
leaq 0x90(%rbx), %r13
leaq 0x78(%rbx), %rbp
leaq 0x60(%rbx), %rax
movq %rax, (%rsp)
leaq 0x48(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %r12, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x20f0
movq %r15, %rdi
callq 0x26d2
movq %r13, %rdi
callq 0x27ba
movq %rbp, %rdi
callq 0x26f4
movq (%rsp), %rdi
callq 0x2716
movq 0x8(%rsp), %rdi
callq 0x2890
movq 0x10(%rsp), %rdi
callq 0x289e
movq 0x18(%rsp), %rdi
callq 0x2738
movq %rbx, %rdi
callq 0x275a
movq 0x20(%rsp), %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/logicome_profiler.cpp
// Function: LogicomeProfiler::Run()
void LogicomeProfiler::Run(){
  ReadData();
  CountElements();
  MakeLogicOccurrenceTensor();
  CalcLogFact();
  if(_criteria == 0){
    FirstScreeningForFWER();
    SecondScreeningForFWER();
  }else if(_criteria == 1){
    CalcPVForFDR();
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x29fe
movq %rbx, %rdi
callq 0x2c90
movq %rbx, %rdi
callq 0x2d1c
movq %rbx, %rdi
callq 0x2e36
movl 0x114(%rbx), %eax
cmpl $0x1, %eax
je 0x29f3
testl %eax, %eax
jne 0x29fc
movq %rbx, %rdi
callq 0x2ebe
movq %rbx, %rdi
popq %rbx
jmp 0x30e0
movq %rbx, %rdi
popq %rbx
jmp 0x331e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/logicome_profiler.cpp
// Function: LogicomeProfiler::CountElements()
void LogicomeProfiler::CountElements(){
  _count_vector.reserve(_number_of_elements);
  for(int i = 0; i < _number_of_elements; i++){
    int count = 0;
    for(int j = 0; j < _number_of_samples;j++){
      if(_dataset[j][i]==true){
	count += 1;
      }
    }
    _count_vector.push_back(count);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movslq 0x104(%rdi), %rsi
movq %r14, %rdi
callq 0x4ad0
xorl %r15d, %r15d
leaq 0x4(%rsp), %r12
movslq 0x104(%rbx), %rax
cmpq %rax, %r15
jge 0x2d0c
andl $0x0, 0x4(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq 0x100(%rbx), %rax
cmpq %rax, %rbp
jge 0x2cfc
movq 0x18(%rbx), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
je 0x2cf3
incl 0x4(%rsp)
incq %rbp
addq $0x28, %r13
jmp 0x2ccf
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b60
incq %r15
jmp 0x2cb9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/logicome_profiler.cpp
// Function: LogicomeProfiler::MakeLogicOccurrenceTensor()
void LogicomeProfiler::MakeLogicOccurrenceTensor(){
  
  
  for(int i = 0; i < _number_of_elements; i++){
    vector<vector<int> > temp_matrix; temp_matrix.reserve(_number_of_elements);
    for(int j = 0; j < _number_of_elements;j++){
      vector<int> temp_vector; temp_vector.reserve(7);
      temp_vector.push_back(0);
      
      for(int k = 1;k <= 6;k++){
	int count = CountLogicOccurrence(i,j,k);
	temp_vector.push_back(count);
      }
      temp_matrix.push_back(temp_vector);
    }
    _logic_occurrence_tensor.push_back(temp_matrix);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
leaq 0x30(%rsp), %r15
leaq 0xc(%rsp), %r13
movslq 0x104(%rbx), %rsi
cmpl %esi, %ebp
jge 0x2dff
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %r14, %rdi
callq 0x4a3a
xorl %r12d, %r12d
cmpl 0x104(%rbx), %r12d
jge 0x2de0
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movq %r15, %rdi
pushq $0x7
popq %rsi
callq 0x4ad0
andl $0x0, 0xc(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x65da
pushq $0x1
popq %r14
cmpl $0x7, %r14d
je 0x2dc6
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x4528
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x4b60
incl %r14d
jmp 0x2d9c
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x4b7e
movq %r15, %rdi
callq 0x289e
incl %r12d
jmp 0x2d66
movq %rbx, %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x4baa
movq %r14, %rdi
callq 0x294e
incl %ebp
jmp 0x2d3e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2e24
jmp 0x2e17
jmp 0x2e17
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x289e
leaq 0x10(%rsp), %rdi
callq 0x294e
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/logicome_profiler.cpp
// Function: LogicomeProfiler::CalcLogFact()
void LogicomeProfiler::CalcLogFact(){
  int N = _number_of_samples;
  _log_fact.resize(N+1,0.0);

  double temp = 0.0;
  for(int i = 1; i<=N;i++){
    temp += log(i);
    _log_fact[i] = temp;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq 0x100(%rdi), %r14
addq $0x90, %rbx
movq %r14, %rsi
incq %rsi
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
movq %rbx, %rdi
callq 0x49e0
xorl %r15d, %r15d
testl %r14d, %r14d
cmovgl %r14d, %r15d
negq %r15
xorpd %xmm0, %xmm0
pushq $0x1
popq %r14
leaq (%r15,%r14), %rax
cmpq $0x1, %rax
je 0x2eb4
movl %r14d, %edi
movsd %xmm0, (%rsp)
callq 0x4a13
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
movq (%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x2e7c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/logicome_profiler.cpp
// Function: LogicomeProfiler::CountLogicOccurrence(int, int, int, int)
int LogicomeProfiler::CountLogicOccurrence(int a, int b, int c, int l){
  int z  = 0;
  for(int i = 0; i < _number_of_samples;i++){
    switch(l){
    case 1:
      if(_dataset[i][a]==true && _dataset[i][b]==true && _dataset[i][c]==true){
	z += 1;
      }
      break;
    case 2:
      if(!(_dataset[i][a]==true && _dataset[i][b]==true) && _dataset[i][c]==true){
	z += 1;
      }
      break;
    case 3:
      if((_dataset[i][a]==true || _dataset[i][b]==true) && _dataset[i][c]==true){
	z += 1;
      }
      break;
    case 4:
      if((!(_dataset[i][a]==true || _dataset[i][b]==true)) && _dataset[i][c]==true){
	z += 1;
      }
      break;
    case 5:
      if(_dataset[i][a]==true && _dataset[i][b]!=true && _dataset[i][c]==true){
	z += 1;
      }
      break;
    case 6:
      if((_dataset[i][a]!=true || _dataset[i][b]==true) && _dataset[i][c]==true){
	z += 1;
      }
      break;
    }
  }
  return z;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rdi, %r14
movslq %esi, %r15
movslq %edx, %rax
movq %rax, 0x8(%rsp)
movslq %ecx, %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
decl %ebx
xorl %r12d, %r12d
xorl %ebp, %ebp
movslq 0x100(%r14), %rax
cmpq %rax, %r12
jge 0x4023
cmpl $0x5, %ebx
ja 0x4017
leaq 0x4145(%rip), %rcx      # 0x8080
movslq (%rcx,%rbx,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
jne 0x3fe6
jmp 0x4017
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
jne 0x3fba
jmp 0x4017
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
jne 0x3ffc
jmp 0x3fe6
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
jne 0x4017
jmp 0x3fba
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
je 0x3ffc
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x4a1c
testq %rdx, (%rax)
jne 0x4017
jmp 0x3ffc
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
je 0x3ffc
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x4a1c
testq %rdx, (%rax)
je 0x4017
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x4a1c
andq (%rax), %rdx
cmpq $0x1, %rdx
sbbl $-0x1, %ebp
incq %r12
addq $0x28, %r13
jmp 0x3f1b
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/logicome_profiler.cpp
// Function: LogicomeProfiler::CalcProb(int, int, int, int, double)
double LogicomeProfiler::CalcProb(int x, int y, int z, int N, double threshold){
  int z_max = x > y ? y : x;
  double sum = 0.0;
  double temp = CalcCombination(N,y);
  for(int k = z; k<=z_max; k++){
    double prob = -temp;
    prob = prob + CalcCombination(x,k)+CalcCombination(N-x,y-k);
    prob = exp(prob);
    sum += prob;
    if(sum > threshold){
      return(sum);
    }
  }
  return(sum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
cmpl %edx, %esi
movl %edx, %r13d
cmovll %esi, %r13d
movl %r8d, %esi
callq 0x4502
movsd %xmm0, 0x10(%rsp)
subl %r15d, %ebx
subl %ebp, %r14d
xorpd %xmm0, %xmm0
cmpl %r13d, %ebp
jg 0x40d6
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
movsd %xmm0, 0x8(%rsp)
callq 0x4502
subsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movl %ebx, %esi
movl %r14d, %edx
callq 0x4502
addsd 0x20(%rsp), %xmm0
callq 0x2320
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incl %ebp
decl %r14d
ucomisd 0x18(%rsp), %xmm0
jbe 0x4077
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/logicome_profiler.cpp
// Function: LogicomeProfiler::CountLogicOccurrence(int, int, int)
int LogicomeProfiler::CountLogicOccurrence(int a, int b, int l){
  int x = 0;
  for(int i = 0; i < _number_of_samples;i++){
    switch(l){
    case 1:
      if(_dataset[i][a]==true && _dataset[i][b]==true){
	x += 1;
      }
      break;
    case 2:
      if(!(_dataset[i][a]==true && _dataset[i][b]==true)){
	x += 1;
      }
      break;
    case 3:
      if(_dataset[i][a]==true || _dataset[i][b]==true){
	x += 1;
      }
      break;
    case 4:
      if(!(_dataset[i][a]==true || _dataset[i][b]==true)){
	x += 1;
      }
      break;
    case 5:
      if(_dataset[i][a]==true && _dataset[i][b]!=true){
	x += 1;
      }
      break;
    case 6:
      if(_dataset[i][a] !=true || _dataset[i][b]==true){
	x += 1;
      }
      break;
    }
  }
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
movslq %esi, %r15
movslq %edx, %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
decl %ebx
xorl %r12d, %r12d
xorl %ebp, %ebp
movslq 0x100(%r14), %rax
cmpq %rax, %r12
jge 0x4658
cmpl $0x5, %ebx
ja 0x464c
leaq 0x3b2c(%rip), %rcx      # 0x8098
movslq (%rcx,%rbx,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
je 0x464c
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq (%rsp), %rsi
callq 0x4a1c
andq (%rax), %rdx
cmpq $0x1, %rdx
sbbl $-0x1, %ebp
jmp 0x464c
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
jne 0x4605
jmp 0x464c
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
jne 0x464a
jmp 0x4635
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
jne 0x464c
jmp 0x4605
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
je 0x464a
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq (%rsp), %rsi
callq 0x4a1c
andq (%rax), %rdx
cmpq $0x1, %rdx
adcl $0x0, %ebp
jmp 0x464c
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x4a1c
testq %rdx, (%rax)
je 0x464a
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq (%rsp), %rsi
callq 0x4a1c
testq %rdx, (%rax)
je 0x464c
incl %ebp
incq %r12
addq $0x28, %r13
jmp 0x454c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fukunagatsu[P]LogicomeProfiler/logicome_profiler.cpp
// Function: LogicomeProfiler::SetParameters(char**)
void LogicomeProfiler::SetParameters(char* argv[]){
  _input_data_file_name = argv[1];
  _output_file_name = argv[2];
  _criteria = atoi(argv[3]);
  _alpha = atof(argv[4]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
addq $0xc0, %rdi
callq 0x2340
movq 0x10(%rbx), %rsi
leaq 0xe0(%r14), %rdi
callq 0x2340
movq 0x18(%rbx), %rdi
callq 0x2290
movl %eax, 0x114(%r14)
movq 0x20(%rbx), %rdi
callq 0x2220
movsd %xmm0, 0x108(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/counters.cpp
// Function: scancount(std::vector<std::vector<unsigned int, std::allocator<unsigned int>> const*, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>> const*>> const&, std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned long)
void scancount(const std::vector<const std::vector<uint32_t>*> &data,
               std::vector<uint32_t> &out, size_t threshold) {
  uint64_t largest = 0;
  for(auto z : data) {
    const std::vector<uint32_t> & v = *z;
    if(v[v.size() - 1] > largest) largest = v[v.size() - 1];
  }
  std::vector<uint8_t> counters(largest+1);
  out.clear();
  for (size_t c = 0; c < data.size(); c++) {
    const std::vector<uint32_t> &v = *data[c];
    for (size_t i = 0; i < v.size(); i++) {
      counters[v[i]]++;
    }
  }
  for (uint32_t i = 0; i < counters.size(); i++) {
    if (counters[i] > threshold)
      out.push_back(i);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x272b
movq (%rax), %rdx
movq 0x8(%rdx), %rdx
movl -0x4(%rdx), %edx
cmpq %rdx, %rsi
cmovbeq %rdx, %rsi
addq $0x8, %rax
jmp 0x270f
incq %rsi
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x48c4
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x274a
movq %rax, 0x8(%r14)
xorl %eax, %eax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x278d
movq (%rcx,%rax,8), %rcx
xorl %edx, %edx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
subq %rsi, %rdi
sarq $0x2, %rdi
cmpq %rdi, %rdx
jae 0x2788
movl (%rsi,%rdx,4), %esi
movq 0x8(%rsp), %rdi
incb (%rdi,%rsi)
incq %rdx
jmp 0x2765
incq %rax
jmp 0x274c
xorl %eax, %eax
leaq 0x4(%rsp), %r15
movl %eax, 0x4(%rsp)
movl %eax, %ecx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
subq %rdx, %rsi
cmpq %rcx, %rsi
jbe 0x27c8
movzbl (%rdx,%rcx), %ecx
cmpq %rbx, %rcx
jbe 0x27c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x499a
movl 0x4(%rsp), %eax
incl %eax
jmp 0x2794
leaq 0x8(%rsp), %rdi
callq 0x5b82
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5b82
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/counters.cpp
// Function: calc_boundaries(unsigned int, unsigned int, std::vector<unsigned int, std::allocator<unsigned int>> const&, std::vector<unsigned int, std::allocator<unsigned int>>&)
void calc_boundaries(uint32_t largest, uint32_t range_size, 
                    const std::vector<uint32_t>& data, 
                    std::vector<uint32_t>& range_ends) {
  if (!range_size) {
    throw std::runtime_error("range_size must be > 0");
  }
  uint32_t end = 0;
  range_ends.clear();
  
  for (uint32_t start = 0; start <= largest; start += range_size) {
    uint32_t curr_max = std::min(largest, start + range_size - 1);
    while (end < data.size() && data[end] <= curr_max) {
      end++;
    }
    range_ends.push_back(end);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x287c
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %ebp
andl $0x0, 0x4(%rsp)
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x281d
movq %rax, 0x8(%rbx)
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
cmpl %ebp, %r13d
ja 0x286d
movl %r13d, %eax
addl %r15d, %r13d
addl %r15d, %eax
decl %eax
cmpl %ebp, %eax
cmovael %ebp, %eax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movl 0x4(%rsp), %esi
movl %esi, %esi
cmpq %rsi, %rdx
jbe 0x2860
cmpl %eax, (%rcx,%rsi,4)
ja 0x2860
incl %esi
movl %esi, 0x4(%rsp)
jmp 0x284c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x499a
jmp 0x2825
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x57ba(%rip), %rsi      # 0x8048
movq %rax, %rdi
callq 0x20c0
movq 0xa753(%rip), %rsi      # 0xcff0
movq 0xa714(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x2350
movq %rax, %r14
movq %rbx, %rdi
callq 0x2180
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/counters.cpp
// Function: calc_alldata_boundaries(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>> const&, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>&, unsigned long)
void calc_alldata_boundaries(const std::vector<std::vector<uint32_t>>& data,
                             std::vector<std::vector<uint32_t>>& range_ends,
                             size_t range_size) {
  uint32_t largest = 0;
  range_ends.clear();
  range_ends.resize(data.size());
  for(const auto& v : data) {
    if (!v.empty() && v[v.size() - 1] > largest) largest = v[v.size() - 1];
  }
  for (unsigned i = 0; i < data.size(); ++i) {
    calc_boundaries(largest, range_size, data[i], range_ends[i]); 
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x49b8
movq 0x8(%r15), %rax
subq (%r15), %rax
pushq $0x18
popq %r12
cqto
idivq %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x49c0
movq (%r15), %r8
movq 0x8(%r15), %rax
xorl %ebp, %ebp
movq %r8, %rcx
cmpq %rax, %rcx
je 0x291e
movq 0x8(%rcx), %rdx
cmpq %rdx, (%rcx)
je 0x2918
movl -0x4(%rdx), %edx
cmpl %ebp, %edx
cmoval %edx, %ebp
addq $0x18, %rcx
jmp 0x2902
xorl %ecx, %ecx
movl %ecx, %r13d
subq %r8, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x2953
imulq $0x18, %r13, %rcx
addq %rcx, %r8
addq (%r14), %rcx
movl %ebp, %edi
movl %ebx, %esi
movq %r8, %rdx
callq 0x27f1
leal 0x1(%r13), %ecx
movq (%r15), %r8
movq 0x8(%r15), %rax
jmp 0x2920
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/maropuparser.h
// Function: MaropuGapReader::open()
bool open() {
    close();
    fd = ::fopen(mFilename.c_str(), "rb");
    if (fd == NULL) {
      return false;
    }
    setvbuf(fd, NULL, _IOFBF, 1024 * 4); // large buffer
    return true;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5b18
movq (%r14), %rdi
leaq 0x3514(%rip), %rsi      # 0x8238
callq 0x2220
movq %rax, %rbx
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x4d46
movl $0x1000, %ecx           # imm = 0x1000
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2030
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/maropuparser.h
// Function: bool MaropuGapReader::loadIntegers<std::vector<unsigned int, std::allocator<unsigned int>>>(std::vector<unsigned int, std::allocator<unsigned int>>&)
bool loadIntegers(container &buffer) {
    uint32_t qty = 0;
    if (!ReadQty(qty))
      return false; // EOF
    buffer.resize(qty);
    errno = 0;
    size_t result = fread(buffer.data(), sizeof(uint32_t), buffer.size(), fd);
    if (result != buffer.size()) {
      if (!errno) {
        // If we can't read, the file maybe truncated, i.e., corrupt
        throw std::runtime_error("The file appears to be truncated/corrupt!");
      }
      std::stringstream err;
      err << "Error reading from file, IO status: " << strerror(errno);
      throw std::runtime_error(err.str());
    }
    return true;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
callq 0x6f90
movl %eax, %ebp
testb %al, %al
je 0x4e31
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x4916
callq 0x2040
movq %rax, %rbx
andl $0x0, (%rax)
movq (%r14), %rdi
movq 0x8(%r14), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
movq 0x20(%r15), %rcx
pushq $0x4
popq %rsi
callq 0x22a0
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x2, %rcx
cmpq %rcx, %rax
jne 0x4e41
movl %ebp, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%rbx)
jne 0x4e76
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x352f(%rip), %rsi      # 0x8387
movq %rax, %rdi
callq 0x20c0
movq 0x8189(%rip), %rsi      # 0xcff0
movq 0x814a(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x2350
leaq 0x30(%rsp), %rdi
callq 0x2160
leaq 0x40(%rsp), %rdi
leaq 0x3525(%rip), %rsi      # 0x83b1
callq 0x21e0
movq %rax, %r14
movl (%rbx), %edi
callq 0x20a0
movq %r14, %rdi
movq %rax, %rsi
callq 0x21e0
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x22e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2320
xorl %ebp, %ebp
movq 0x8117(%rip), %rsi      # 0xcff0
movq 0x80d8(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x2350
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2100
testb %bpl, %bpl
jne 0x4eff
jmp 0x4f19
movq %rax, %r14
movq %rbx, %rdi
callq 0x2180
jmp 0x4f19
movq %rax, %r14
movq %rbx, %rdi
callq 0x2180
jmp 0x4f23
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x2190
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/linux-perf-events.h
// Function: LinuxEvents<0>::LinuxEvents(int)
LinuxEvents(int config) : fd(0) {
        memset(&attribs, 0, sizeof(attribs));
        attribs.type        = TYPE;
        attribs.size        = sizeof(attribs);
        attribs.config      = config;
        attribs.disabled        = 1;
        attribs.exclude_kernel  = 1;
        attribs.exclude_hv      = 1;

        const int pid = 0;    // the current process
        const int cpu = -1;   // all CPUs
        const int group = -1; // no group
        const unsigned long flags = 0;
        fd = syscall(__NR_perf_event_open, &attribs, pid, cpu, group, flags);
        if (fd == -1) {
            report_error("perf_event_open");
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andl $0x0, (%rdi)
leaq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movl $0x80, 0xc(%rdi)
movslq %esi, %rcx
movq %rcx, 0x10(%rdi)
movq $0x61, 0x30(%rdi)
pushq $-0x1
popq %rcx
movl $0x12a, %edi            # imm = 0x12A
movq %rax, %rsi
xorl %edx, %edx
movl %ecx, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x2050
movl %eax, (%rbx)
cmpl $-0x1, %eax
jne 0x5017
leaq 0x320e(%rip), %rsi      # 0x81fe
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x4c2c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53f4
leaq 0x8(%rsp), %rdi
callq 0x2100
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/linux-perf-events-wrapper.h
// Function: LinuxEventsWrapper::start()
void start() {
#ifdef __linux__
      for (const auto& [ecode, ptr]: event_obj) {
        ptr->start();  
      }
#endif
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x66cb
movq 0x10(%rbx), %rdi
callq 0x674a
jmp 0x66b8
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/linux-perf-events-wrapper.h
// Function: LinuxEventsWrapper::end()
void end() {
#ifdef __linux__
      for (const auto& [ecode, ptr]: event_obj) {
        event_res[ecode] = ptr->end();  
      }
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
addq $0x38, %rbx
movq (%r12), %r12
testq %r12, %r12
je 0x670c
leaq 0x8(%r12), %r14
movq 0x10(%r12), %rdi
callq 0x67fa
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68b0
movq %r15, (%rax)
jmp 0x66e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/linux-perf-events-wrapper.h
// Function: LinuxEventsWrapper::get_result(int)
unsigned long get_result(int ecode) {
#ifdef __linux__
      return event_res.at(ecode);
#else
      return 0;
#endif
    }

// Assembly:
pushq %rax
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
addq $0x38, %rdi
movq %rax, %rsi
callq 0x699a
movq (%rax), %rax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/linux-perf-events.h
// Function: LinuxEvents<0>::start()
void start() {
        if (ioctl(fd, PERF_EVENT_IOC_RESET, 0) == -1) {
            report_error("ioctl(PERF_EVENT_IOC_RESET)");
        }

        if (ioctl(fd, PERF_EVENT_IOC_ENABLE, 0) == -1) {
            report_error("ioctl(PERF_EVENT_IOC_ENABLE)");
        }
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl (%rdi), %edi
movl $0x2403, %esi           # imm = 0x2403
xorl %edx, %edx
xorl %eax, %eax
callq 0x2260
cmpl $-0x1, %eax
jne 0x6794
leaq 0x1baf(%rip), %rsi      # 0x831d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4c2c
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x53f4
leaq 0x10(%rsp), %rdi
callq 0x2100
movl (%rbx), %edi
movl $0x2400, %esi           # imm = 0x2400
xorl %edx, %edx
xorl %eax, %eax
callq 0x2260
cmpl $-0x1, %eax
jne 0x67d6
leaq 0x1b89(%rip), %rsi      # 0x8339
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4c2c
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x53f4
leaq 0x10(%rsp), %rdi
callq 0x2100
addq $0x30, %rsp
popq %rbx
retq
jmp 0x67de
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0x67f2
jmp 0x67ef
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/linux-perf-events.h
// Function: LinuxEvents<0>::end()
unsigned long end() {
        if (ioctl(fd, PERF_EVENT_IOC_DISABLE, 0) == -1) {
            report_error("ioctl(PERF_EVENT_IOC_DISABLE)");
        }

        unsigned long result;
        if (read(fd, &result, sizeof(result)) == -1) {
            report_error("read");
        }

        return result;
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl (%rdi), %edi
movl $0x2401, %esi           # imm = 0x2401
xorl %edx, %edx
xorl %eax, %eax
callq 0x2260
cmpl $-0x1, %eax
jne 0x6844
leaq 0x1b38(%rip), %rsi      # 0x8356
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x4c2c
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x53f4
leaq 0x10(%rsp), %rdi
callq 0x2100
movl (%rbx), %edi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x2270
cmpq $-0x1, %rax
jne 0x6886
leaq 0x1b14(%rip), %rsi      # 0x8374
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x4c2c
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x53f4
leaq 0x10(%rsp), %rdi
callq 0x2100
movq 0x8(%rsp), %rax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x6893
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0x68a7
jmp 0x68a4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]fastscancount/benchmark/maropuparser.h
// Function: MaropuGapReader::ReadQty(unsigned int&)
bool ReadQty(uint32_t &qty) {
    qty = 0;
    if (fd == NULL) {
      throw std::runtime_error("You forgot to open the file.");
    }
    errno = 0;
    size_t result = fread(&qty, sizeof(qty), 1, fd);
    if (errno) {
      std::stringstream err;
      err << "Error opening file, IO status: " << strerror(errno);
      throw std::runtime_error(err.str());
    }
    if (result != 1) {
      return false;
    }
    if (qty > 1 << 29) {
      std::cout << "warning: reading a very large array (" << qty
                << " integers) : is your input file in the right format?" << std::endl;
    }
    return true;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
andl $0x0, (%rsi)
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x7030
movq %rsi, %rbx
callq 0x2040
movq %rax, %r15
andl $0x0, (%rax)
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x22a0
cmpl $0x0, (%r15)
jne 0x7060
movq %rax, %r14
cmpq $0x1, %rax
jne 0x701b
cmpl $0x20000001, (%rbx)     # imm = 0x20000001
jb 0x701b
movq 0x5fda(%rip), %rdi      # 0xcfc8
leaq 0x141e(%rip), %rsi      # 0x8413
callq 0x21e0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2150
leaq 0x142e(%rip), %rsi      # 0x8439
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2110
cmpq $0x1, %r14
sete %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x1394(%rip), %rsi      # 0x83d6
movq %rax, %rdi
callq 0x20c0
movq 0x5f9f(%rip), %rsi      # 0xcff0
movq 0x5f60(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x2350
leaq 0x20(%rsp), %rdi
callq 0x2160
leaq 0x30(%rsp), %rdi
leaq 0x137d(%rip), %rsi      # 0x83f3
callq 0x21e0
movq %rax, %rbx
movl (%r15), %edi
callq 0x20a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21e0
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x22e0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2320
xorl %ebp, %ebp
movq 0x5f30(%rip), %rsi      # 0xcff0
movq 0x5ef1(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x2350
movq %rax, %r14
movq %rsp, %rdi
callq 0x2100
testb %bpl, %bpl
jne 0x70e4
jmp 0x70fe
movq %rax, %r14
movq %rbx, %rdi
callq 0x2180
jmp 0x70fe
movq %rax, %r14
movq %rbx, %rdi
callq 0x2180
jmp 0x7108
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2190
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]pentagod/./gtp.h
// Function: GTPclient::cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
GTPResponse cmd(string line){
		vecstr parts = explode(line, " ");
		string id;

		if(parts.size() > 1 && atoi(parts[0].c_str())){
			id = parts[0];
			parts.erase(parts.begin());
		}

		string name = parts[0];
		parts.erase(parts.begin());

		int cb = find_callback(name);
		GTPResponse response;

		if(cb < 0){
			response = GTPResponse(false, "Unknown command");
		}else{
			response = callbacks[cb].func(parts);
		}

		response.id = id;

		return response;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x19330(%rip), %rsi     # 0x1f7bd
leaq 0xa0(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x40f0
leaq 0x10(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
movq %r15, %rsi
callq 0xf48a
leaq 0xa0(%rsp), %rdi
callq 0x4130
leaq 0x38(%rsp), %rax
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rcx
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
subq %r15, %rcx
cmpq $0x21, %rcx
jb 0x6510
movq (%r15), %rdi
callq 0x4490
testl %eax, %eax
je 0x6510
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x4160
leaq 0x10(%rsp), %rdi
movq (%rdi), %rsi
callq 0x8966
movq 0x10(%rsp), %r15
leaq 0x80(%rsp), %rdi
movq %r15, %rsi
callq 0x43f0
leaq 0x10(%rsp), %rdi
movq (%rdi), %rsi
callq 0x8966
leaq 0x80(%rsp), %rsi
movq %r14, %rdi
callq 0x896c
movl %eax, %ebp
leaq 0x18(%rbx), %rax
leaq 0x38(%rbx), %rcx
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
movq %rcx, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movb %al, 0x38(%rbx)
testl %ebp, %ebp
js 0x65bc
movq 0x18(%r14), %r14
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8a0c
movl %ebp, %eax
imulq $0x60, %rax, %rax
leaq 0x40(%r14,%rax), %rsi
leaq 0xa0(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x89f4
leaq 0xa0(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x89be
movq %r14, %rdi
callq 0x66c6
leaq 0x48(%rsp), %rdi
callq 0x77a0
jmp 0x660b
leaq 0x164e4(%rip), %rsi     # 0x1caa7
leaq 0x60(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x40f0
leaq 0xa0(%rsp), %rdi
leaq 0x60(%rsp), %rdx
xorl %esi, %esi
callq 0x761c
leaq 0xa0(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x89be
movq %r14, %rdi
callq 0x66c6
leaq 0x60(%rsp), %rdi
callq 0x4130
leaq 0x8(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4160
leaq 0x80(%rsp), %rdi
callq 0x4130
leaq 0x28(%rsp), %rdi
callq 0x4130
leaq 0x10(%rsp), %rdi
callq 0x77a0
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6690
jmp 0x6690
leaq 0x60(%rsp), %rdi
movq %rax, %r14
callq 0x4130
jmp 0x6674
jmp 0x6671
leaq 0x48(%rsp), %rdi
movq %rax, %r14
callq 0x77a0
jmp 0x6674
jmp 0x6671
movq %rax, %r14
movq %rbx, %rdi
callq 0x66c6
jmp 0x6681
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x4130
jmp 0x6693
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x4130
leaq 0x10(%rsp), %rdi
callq 0x77a0
movq %r14, %rdi
callq 0x4590
leaq 0xa0(%rsp), %rdi
movq %rax, %r14
callq 0x4130
jmp 0x66a7
movq %rax, %r14
jmp 0x66a7
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]pentagod/./gtp.h
// Function: GTPclient::run()
bool run(){
		running = true;
		char buf[1001];

		while(running && fgets(buf, 1000, in)){
			string line(buf);

			trim(line);

			if(line.length() == 0 || line[0] == '#')
				continue;

			GTPResponse response = cmd(line);

			if(out){
				string output = response.to_s();

				fwrite(output.c_str(), 1, output.length(), out);
				fflush(out);
			}
		}
		return running;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
movb $0x1, %al
leaq 0xb0(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x68(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq 0x28(%rsp), %rbp
movq %rdi, %rbx
movb $0x1, 0x34(%rdi)
testb $0x1, %al
je 0x67d1
movq (%rbx), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdi
callq 0x44c0
testq %rax, %rax
je 0x67d5
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x40f0
movq %r15, %rdi
callq 0xf3ee
cmpq $0x0, 0x10(%rsp)
je 0x67c1
movq 0x8(%rsp), %rax
cmpb $0x23, (%rax)
je 0x67c1
movq %r13, %rdi
movq %r15, %rsi
callq 0x43f0
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x6470
movq %r13, %rdi
callq 0x4130
cmpq $0x0, 0x8(%rbx)
je 0x67b9
movq %rbp, %rdi
movq %r12, %rsi
callq 0x8be6
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x8(%rbx), %rcx
pushq $0x1
popq %rsi
callq 0x4600
movq 0x8(%rbx), %rdi
callq 0x4370
movq %rbp, %rdi
callq 0x4130
movq %r12, %rdi
callq 0x66c6
movq %r15, %rdi
callq 0x4130
movb 0x34(%rbx), %al
jmp 0x6716
xorl %eax, %eax
jmp 0x67d8
movb 0x34(%rbx), %al
andb $0x1, %al
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x68(%rsp), %rdi
movq %rax, %rbx
callq 0x66c6
jmp 0x680f
leaq 0x48(%rsp), %rdi
movq %rax, %rbx
callq 0x4130
jmp 0x680f
jmp 0x680c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]pentagod/./gtp.h
// Function: GTPclient::gtp_list_commands(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, bool)
GTPResponse gtp_list_commands(vecstr args, bool showdesc){
		string ret = "\n";
		for(unsigned int i = 0; i < callbacks.size(); i++){
			ret += callbacks[i].name;
			if(showdesc && callbacks[i].desc.length() > 0){
				ret += string(longest_cmd + 2 - callbacks[i].name.length(), ' ');
				ret += callbacks[i].desc;
			}
			ret += "\n";
		}
		return GTPResponse(true, ret);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
leaq 0x38(%rsp), %rbp
leaq 0x15987(%rip), %rsi     # 0x1cab8
leaq 0x58(%rsp), %r12
movq %rdi, 0x10(%rsp)
movl %ecx, %r13d
movq %r12, %rdi
movq %rbp, %rdx
callq 0x40f0
xorl %ebx, %ebx
movl %r13d, 0xc(%rsp)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rax
movl %ebx, %ebx
subq %rsi, %rax
cqto
pushq $0x60
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x71f3
imulq $0x60, %rbx, %r15
addq %r15, %rsi
movq %r12, %rdi
callq 0x4610
testb %r13b, %r13b
je 0x71dd
movq 0x18(%r14), %rax
cmpq $0x0, 0x28(%rax,%r15)
je 0x71dd
movl 0x30(%r14), %esi
addq %r15, %rax
addl $0x2, %esi
subq 0x8(%rax), %rsi
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rbp, %r13
movq %rbp, %rdi
pushq $0x20
popq %rdx
callq 0x4350
movq %r12, %rdi
movq %r13, %rsi
callq 0x4610
movq %r13, %rdi
callq 0x4130
movq 0x18(%r14), %rax
leaq 0x20(%rax,%r15), %rsi
movq %r12, %rdi
callq 0x4610
movl 0xc(%rsp), %r13d
leaq 0x158d4(%rip), %rsi     # 0x1cab8
movq %r12, %rdi
callq 0x45e0
incl %ebx
jmp 0x7150
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x43f0
pushq $0x1
popq %rsi
movq 0x10(%rsp), %rbx
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x761c
leaq 0x18(%rsp), %rdi
callq 0x4130
leaq 0x58(%rsp), %rdi
callq 0x4130
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %rdi
movq %rax, %rbx
jmp 0x7253
jmp 0x725a
jmp 0x725a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4130
jmp 0x725d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]pentagod/./gtp.h
// Function: GTPclient::gtp_logfile(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse gtp_logfile(vecstr args){
		if(args.size() != 1)
			return GTPResponse(false, "Wrong number of arguments");

		FILE * fd = fopen(args[0].c_str(), "w");
		if(!fd)
			return GTPResponse(false, "Couldn't open file " + args[0]);

		setlogfile(fd);

		return GTPResponse(true);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rdi, %rbx
subq %rax, %rcx
cmpq $0x20, %rcx
jne 0x742a
movq (%rax), %rdi
movq %rsi, %r14
leaq 0x1685d(%rip), %rsi     # 0x1dc42
movq %rdx, %r15
callq 0x4380
testq %rax, %rax
je 0x7456
movq %r14, %rdi
movq %rax, %rsi
callq 0x6840
leaq 0x156b5(%rip), %rsi     # 0x1cab9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x40f0
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x761c
leaq 0x10(%rsp), %rdi
jmp 0x747f
leaq 0x15544(%rip), %rsi     # 0x1c975
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x40f0
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x761c
leaq 0x30(%rsp), %rdi
jmp 0x747f
movq (%r15), %rdx
leaq 0x50(%rsp), %r14
leaq 0x1552a(%rip), %rsi     # 0x1c98f
movq %r14, %rdi
callq 0x6864
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x761c
leaq 0x50(%rsp), %rdi
callq 0x4130
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x50(%rsp), %rdi
jmp 0x74a6
leaq 0x10(%rsp), %rdi
jmp 0x74a6
jmp 0x74b0
leaq 0x30(%rsp), %rdi
movq %rax, %rbx
callq 0x4130
jmp 0x74b3
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]pentagod/./game.h
// Function: Game::getboard(int) const
Board getboard(int offset = 0) const {
		Board board;
		if(offset <= 0)
			offset += hist.size();
		for(int i = 0; i < offset; i++)
			board.move(hist[i]);
		return board;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, %r14
movq %rdi, %rbx
vmovups %xmm0, 0x9(%rdi)
vmovups %xmm0, (%rdi)
movw $0xfc01, 0x19(%rdi)     # imm = 0xFC01
movb $0x8, 0x1b(%rdi)
movw $0xdead, 0x1c(%rdi)     # imm = 0xDEAD
andq $0x0, 0x20(%rdi)
testl %edx, %edx
jg 0x7aa5
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
addl %edx, %eax
movl %eax, %edx
movl %edx, %eax
sarl $0x1f, %eax
xorl %r12d, %r12d
andnl %edx, %eax, %r15d
cmpq %r12, %r15
je 0x7acb
movq (%r14), %rax
movq %rbx, %rdi
movl (%rax,%r12,4), %esi
callq 0x7ada
incq %r12
jmp 0x7ab2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]pentagod/./board.h
// Function: Board::move(Move)
bool move(Move mo){
		assert(outcome < 0);

		orient();
		Move m = mo.rotate(orientation);

		//TODO: only call valid_move if the move didn't come from an iterator?
		if(!valid_move(m))
			return false;

		if(m == M_SWAP){
			swap(sides[1], sides[2]);
			to_play = 1;
			return true;
		}

		sides[to_play] |= xybits[m.l];

		if (m.direction() == 0) {
			sides[1] = rotate_quad_ccw(sides[1], m.quadrant());
			sides[2] = rotate_quad_ccw(sides[2], m.quadrant());
		} else {
			sides[1] = rotate_quad_cw(sides[1], m.quadrant());
			sides[2] = rotate_quad_cw(sides[2], m.quadrant());
		}
		sides[0] = sides[1] | sides[2];

		nummoves++;
		to_play = 3 - to_play;
		outcome = -4;
		cached_score = default_score;
		cached_hash = 0;
		orientation = 8; //start with an unoriented board


//		if(m != mo)
//			logerr(mo.to_s(true) + " -> " + m.to_s(true) + " -> " + to_str(orient()) + "\n");

		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
cmpb $0x0, 0x1a(%rdi)
jns 0x7bd9
movq %rdi, %rbx
callq 0x7bf8
movzbl 0x1b(%rbx), %esi
leaq 0xc(%rsp), %rdi
callq 0x7c12
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movw %ax, (%rsi)
callq 0x7ea6
movl %eax, %ebp
testb %al, %al
je 0x7bce
movzwl 0x8(%rsp), %eax
movl %eax, %ecx
shll $0x8, %ecx
cmpw $0xff00, %cx            # imm = 0xFF00
jne 0x7b46
vpermilps $0x4e, 0x8(%rbx), %xmm0 # xmm0 = mem[2,3,0,1]
vmovups %xmm0, 0x8(%rbx)
movb $0x1, 0x19(%rbx)
jmp 0x7bce
leaq 0x16403(%rip), %rdx     # 0x1df50
movswl %cx, %ecx
movl $0x309, %r14d           # imm = 0x309
shrl $0x8, %ecx
bextrl %r14d, %eax, %esi
movswq %cx, %rcx
movq (%rdx,%rcx,8), %rcx
movzbl 0x19(%rbx), %edx
orq %rcx, (%rbx,%rdx,8)
btl $0x8, %eax
movq 0x8(%rbx), %rdi
jb 0x7b93
callq 0x7ebe
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
bextrl %r14d, 0x8(%rsp), %esi
callq 0x7ebe
jmp 0x7bac
callq 0x7ee8
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
bextrl %r14d, 0x8(%rsp), %esi
callq 0x7ee8
movq %rax, 0x10(%rbx)
orq 0x8(%rbx), %rax
movq %rax, (%rbx)
incb 0x18(%rbx)
movb $0x3, %al
subb 0x19(%rbx), %al
movb %al, 0x19(%rbx)
movl $0xdead08fc, 0x1a(%rbx) # imm = 0xDEAD08FC
andq $0x0, 0x20(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x14dc3(%rip), %rdi     # 0x1c9a3
leaq 0x14dc8(%rip), %rsi     # 0x1c9af
leaq 0x14dcb(%rip), %rcx     # 0x1c9b9
movl $0x9d, %edx
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]pentagod/./board.h
// Function: Board::full_hash() const
uint64_t full_hash() const {
		//make sure this matches Move::rotate
		Board b(*this);

		uint64_t h, m = ~0;
		uint8_t o = 0;
		choose(m, (h = b.simple_hash()), o, 0);
		choose(m, (h = rotate_hash(h) ), o, 1);
		choose(m, (h = rotate_hash(h) ), o, 2);
		choose(m, (    rotate_hash(h) ), o, 3);
		b.flip_board();
		choose(m, (h = b.simple_hash()), o, 4);
		choose(m, (h = rotate_hash(h) ), o, 5);
		choose(m, (h = rotate_hash(h) ), o, 6);
		choose(m, (    rotate_hash(h) ), o, 7);

		orientation = o;
		return m;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x20(%rdi), %rax
movq %rsp, %r15
movq %rdi, %rbx
movq %rax, 0x20(%r15)
vmovups (%rdi), %ymm0
movq %r15, %rdi
vmovups %ymm0, (%r15)
vzeroupper
callq 0x806e
movq %rax, %r14
movl %r14d, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
movl $0x2d0f, %r12d          # imm = 0x2D0F
movl %r14d, %esi
bextrq %r12, %rax, %rax
shlq $0x2d, %rcx
orq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %r14
movq %rcx, %rdx
seta %al
cmovbq %r14, %rdx
andl $0x3fff8000, %esi       # imm = 0x3FFF8000
shrq $0xf, %rcx
shlq $0x1e, %rsi
orq %rcx, %rsi
cmpq %rsi, %rdx
cmovaeq %rsi, %rdx
pushq $0x2
popq %rcx
cmovbel %eax, %ecx
shlq $0xf, %r14
movabsq $0xfffe00000000000, %r13 # imm = 0xFFFE00000000000
shrq $0xf, %rsi
andq %r13, %r14
orq %rsi, %r14
cmpq %r14, %rdx
cmovbq %rdx, %r14
pushq $0x3
popq %rbp
movq %r15, %rdi
cmovbel %ecx, %ebp
callq 0x810a
movq %r15, %rdi
callq 0x806e
cmpq %rax, %r14
cmovaeq %rax, %r14
pushq $0x4
popq %rcx
cmovbel %ebp, %ecx
movl %eax, %esi
andl $0x7fff, %esi           # imm = 0x7FFF
bextrq %r12, %rax, %rdx
shlq $0x2d, %rsi
orq %rdx, %rsi
cmpq %rsi, %r14
cmovaeq %rsi, %r14
pushq $0x5
popq %rdx
cmovbel %ecx, %edx
movl %eax, %ecx
andl $0x3fff8000, %ecx       # imm = 0x3FFF8000
shrq $0xf, %rsi
shlq $0x1e, %rcx
orq %rsi, %rcx
cmpq %rcx, %r14
cmovaeq %rcx, %r14
pushq $0x6
popq %rsi
cmovbel %edx, %esi
shlq $0xf, %rax
shrq $0xf, %rcx
andq %r13, %rax
orq %rcx, %rax
cmpq %rax, %r14
cmovbq %r14, %rax
pushq $0x7
popq %rcx
cmovbel %esi, %ecx
movb %cl, 0x1b(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]pentagod/./board.h
// Function: Board::simple_hash() const
uint64_t simple_hash() const {
		//Take 9 bits at a time from each player, merge them, convert to base 2
		//results in a 60 bit hash when only 48 bits are needed, but much more efficient to compute
		uint64_t h = 0;
		uint64_t w = sides[1] << 9;
		uint64_t b = sides[2];
		h |= ((uint64_t)(lookup3to2[((w & (0x1FFull <<  9)) | (b & (0x1FFull <<  0))) >>  0])) <<  0;
		h |= ((uint64_t)(lookup3to2[((w & (0x1FFull << 18)) | (b & (0x1FFull <<  9))) >>  9])) << 15;
		h |= ((uint64_t)(lookup3to2[((w & (0x1FFull << 27)) | (b & (0x1FFull << 18))) >> 18])) << 30;
		h |= ((uint64_t)(lookup3to2[((w & (0x1FFull << 36)) | (b & (0x1FFull << 27))) >> 27])) << 45;
		orientation = 8;
		return h;
	}

// Assembly:
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rax
leaq 0x2366b(%rip), %r11     # 0x2b6e8
movl $0x3fe00, %ecx          # imm = 0x3FE00
movabsq $0x1ff000000000, %r9    # imm = 0x1FF000000000
shlq $0x9, %rdx
movl %eax, %r10d
andl $0x1ff, %r10d           # imm = 0x1FF
movl %edx, %esi
movq %rdx, %r8
andq %rdx, %r9
andl %ecx, %edx
andl $0x7fc0000, %esi        # imm = 0x7FC0000
andl %eax, %ecx
orl %edx, %r10d
movq (%r11), %rdx
orl %esi, %ecx
movabsq $0xff8000000, %rsi      # imm = 0xFF8000000
shrl $0x8, %ecx
andq %rsi, %r8
movzwl (%rdx,%rcx), %ecx
movzwl (%rdx,%r10,2), %r10d
shll $0xf, %ecx
orq %r10, %rcx
movl %eax, %r10d
andl $0x7fc0000, %r10d       # imm = 0x7FC0000
andq %rsi, %rax
orq %r8, %r10
orq %r9, %rax
shrq $0x1a, %rax
shrq $0x11, %r10
movzwl (%rdx,%r10), %r8d
movzwl (%rdx,%rax), %eax
movb $0x8, 0x1b(%rdi)
shlq $0x1e, %r8
shlq $0x2d, %rax
orq %r8, %rax
orq %rcx, %rax
retq