LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: adamnovak[P]rlcsa/misc/parameters.cpp
// Function: CSA::Parameters::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void
Parameters::write(const std::string& file_name) const
{
  std::ofstream file(file_name.c_str(), std::ios_base::binary);
  if(!file)
  {
    std::cerr << "Cannot open parameter file " << file_name << " for writing!" << std::endl;
    return;
  }
  this->write(file);
  file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0x4, %edx
callq 0x3330
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x3160
movb %al, -0x221(%rbp)
jmp 0x21fdb
movb -0x221(%rbp), %al
testb $0x1, %al
jne 0x21fea
jmp 0x2207c
movq 0x15fff(%rip), %rdi     # 0x37ff0
leaq 0x7970(%rip), %rsi      # 0x29968
callq 0x32a0
movq %rax, -0x238(%rbp)
jmp 0x22006
movq -0x238(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3280
movq %rax, -0x240(%rbp)
jmp 0x2201f
movq -0x240(%rbp), %rdi
leaq 0x7969(%rip), %rsi      # 0x29996
callq 0x32a0
movq %rax, -0x248(%rbp)
jmp 0x2203b
movq -0x248(%rbp), %rdi
movq 0x15f67(%rip), %rsi     # 0x37fb0
callq 0x3300
jmp 0x22050
movl $0x1, -0x220(%rbp)
jmp 0x220a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3450
jmp 0x220be
movq -0x230(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x21d00
jmp 0x22091
leaq -0x210(%rbp), %rdi
callq 0x3430
jmp 0x2209f
movl $0x0, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3450
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x3530
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::fileSize(std::basic_ifstream<char, std::char_traits<char>>&)
std::streamoff
fileSize(std::ifstream& file)
{
  std::streamoff curr = file.tellg();

  file.seekg(0, std::ios::end);
  std::streamoff size = file.tellg();
  file.seekg(0, std::ios::beg);
  size -= file.tellg();

  file.seekg(curr, std::ios::beg);
  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3520
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x24b60
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3410
movq -0x8(%rbp), %rdi
callq 0x3520
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x24b60
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3410
movq -0x8(%rbp), %rdi
callq 0x3520
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x24b60
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3410
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::fileSize(std::basic_ofstream<char, std::char_traits<char>>&)
std::streamoff
fileSize(std::ofstream& file)
{
  std::streamoff curr = file.tellp();

  file.seekp(0, std::ios::end);
  std::streamoff size = file.tellp();
  file.seekp(0, std::ios::beg);
  size -= file.tellp();

  file.seekp(curr, std::ios::beg);
  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3260
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x24b60
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x32b0
movq -0x8(%rbp), %rdi
callq 0x3260
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x24b60
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x32b0
movq -0x8(%rbp), %rdi
callq 0x3260
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x24b60
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x32b0
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::largeWrite(std::basic_ofstream<char, std::char_traits<char>>&, char*, long, long)
void
largeWrite(std::ofstream& file, char* data, std::streamoff size, std::streamoff block_size)
{
	block_size = std::max(block_size, (std::streamoff)1);
	block_size *= MEGABYTE;

	for(std::streamoff i = 0; i < size; i += block_size)
	{
		file.write(data + i, std::min(size - i, block_size));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24b80
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq $0x14, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x2374d
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x24bc0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq (%rax), %rdx
callq 0x33f0
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x236f8
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::readRows(std::basic_ifstream<char, std::char_traits<char>>&, 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)
void
readRows(std::ifstream& file, std::vector<std::string>& rows, bool skipEmptyRows)
{
  while(file)
  {
    std::string buf;
    std::getline(file, buf);
    if(skipEmptyRows && buf.length() == 0) { continue; }
    rows.push_back(buf);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x33b0
testb $0x1, %al
jne 0x23790
jmp 0x23813
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3420
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x30b0
jmp 0x237ac
testb $0x1, -0x11(%rbp)
je 0x237e1
leaq -0x38(%rbp), %rdi
callq 0x3470
cmpq $0x0, %rax
jne 0x237e1
movl $0x2, -0x48(%rbp)
jmp 0x237f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35d8
jmp 0x23819
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24c00
jmp 0x237f0
movl $0x0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35d8
movl -0x48(%rbp), %eax
testl %eax, %eax
je 0x2380e
jmp 0x23809
jmp 0x23777
jmp 0x23777
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::initialSort(std::pair<unsigned int, unsigned int>*, unsigned int*, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&, unsigned int, unsigned int, unsigned int)
uint
initialSort(short_pair* pairs, uint* keys, std::vector<ss_range>& unsorted, uint n, uint threads, uint h)
{
  // Sort according to first h characters.
  parallelSort(pairs, pairs + n, key_comparator);
  unsorted.push_back(ss_range(0, n - 1));
  uint total = setRanks(pairs, keys, n, unsorted, threads, 1);
//  std::cout << "Sorted with h = " << h << ", unsorted total = " << total << " (" << unsorted.size() << " ranges)" << std::endl;

  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rsi
leaq 0x14d60(%rip), %rdx     # 0x388d8
callq 0x24ca0
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0xe260
movq -0x40(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x14df0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
movl -0x20(%rbp), %r8d
movl $0x1, %r9d
callq 0x24cd0
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::packPairs(std::pair<unsigned int, unsigned int>*, unsigned int)
short_pair*
packPairs(skew_pair* old_pairs, uint n)
{
  short_pair* new_pairs = (short_pair*)old_pairs;
  for(uint i = 0; i < n; i++)
  {
    new_pairs[i].first = old_pairs[i].first;
    new_pairs[i].second = old_pairs[i].second;
  }
  return new_pairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x23c37
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,8), %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, 0x4(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23bfa
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::simpleSuffixSort(std::pair<unsigned int, unsigned int>*, unsigned int, unsigned int)
short_pair*
simpleSuffixSort(short_pair* pairs, uint n, uint threads)
{
  if(pairs == 0 || n == 0) { return 0; }

  uint* keys = new uint[n];   // In text order.
  std::vector<ss_range> unsorted;
  threads = std::max(threads, (uint)1);
  #ifdef MULTITHREAD_SUPPORT
  omp_set_num_threads(threads);
  #endif

  // Initialize pairs.
  #pragma omp parallel for schedule(static)
  for(uint i = 0; i < n; i++) { pairs[i].first = i; }

  uint total = initialSort(pairs, keys, unsorted, n, threads, 1);
  return prefixDoubling(pairs, keys, unsorted, n, threads, total, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24362
cmpl $0x0, -0x14(%rbp)
jne 0x2436f
movq $0x0, -0x8(%rbp)
jmp 0x24450
movl -0x14(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x14dd0
movl $0x1, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x6360
movq %rax, -0x60(%rbp)
jmp 0x243a4
movq -0x60(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x243eb
movl -0x50(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x50(%rbp), %ecx
movl %edx, (%rax,%rcx,8)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x243b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x14ec0
jmp 0x2445d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
leaq -0x38(%rbp), %rdx
movl $0x1, %r9d
callq 0x23b40
movl %eax, -0x64(%rbp)
jmp 0x2440e
movl -0x64(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x54(%rbp), %r9d
movq %rsp, %rax
movl $0x1, (%rax)
leaq -0x38(%rbp), %rdx
callq 0x23c40
movq %rax, -0x70(%rbp)
jmp 0x2443f
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x14ec0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::mergeRanges(std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>*, bool)
void
mergeRanges(std::vector<pair_type>* vec, bool parallel)
{
  if(vec == 0 || vec->size() <= 1) { return; }
  if(parallel) { parallelSort(vec->begin(), vec->end()); }
  else         { sequentialSort(vec->begin(), vec->end()); }

  std::vector<pair_type>::iterator prev = vec->begin();
  for(std::vector<pair_type>::iterator curr = prev + 1; curr != vec->end(); ++curr)
  {
    if(prev->second + 1 >= curr->first) { prev->second = std::max(curr->second, prev->second); }
    else { ++prev; *prev = *curr; }
  }
  vec->resize((prev - vec->begin()) + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x249ea
movq -0x8(%rbp), %rdi
callq 0x157f0
cmpq $0x1, %rax
ja 0x249ef
jmp 0x24b59
testb $0x1, -0x9(%rbp)
je 0x24a1e
movq -0x8(%rbp), %rdi
callq 0xe2e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe350
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14e20
jmp 0x24a45
movq -0x8(%rbp), %rdi
callq 0xe2e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe350
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x25070
movq -0x8(%rbp), %rdi
callq 0xe2e0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x161f0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe350
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe310
testb $0x1, %al
jne 0x24a87
jmp 0x24b27
leaq -0x38(%rbp), %rdi
callq 0x250b0
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x250b0
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl (%rcx), %eax
jb 0x24aec
leaq -0x40(%rbp), %rdi
callq 0x250b0
addq $0x4, %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x250b0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
addq $0x4, %rsi
callq 0x6360
movl (%rax), %eax
movl %eax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x250b0
movl -0x58(%rbp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x24b17
leaq -0x38(%rbp), %rdi
callq 0xe3a0
leaq -0x40(%rbp), %rdi
callq 0xe380
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe380
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0xe630
jmp 0x24b19
leaq -0x40(%rbp), %rdi
callq 0xe3a0
jmp 0x24a64
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe2e0
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x156a0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x250d0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: yangwanyuan[P]HLKVDS/tools/CreateDb.cc
// Function: CreateExample(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void CreateExample(string filename) {

    Options opts;
    if (!hlkvds::DB::CreateDB(filename, opts)) {
        std::cout << "CreateDB Failed!" << std::endl;
        return;
    }

}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x60(%rsp)
movq %rdi, 0x140(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x36160
movq 0x60(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0x81a0
movq 0x68(%rsp), %rdi
movups 0x130(%rsp), %xmm0
movaps %xmm0, 0xc0(%rsp)
movups 0xf0(%rsp), %xmm0
movups 0x100(%rsp), %xmm1
movups 0x110(%rsp), %xmm2
movups 0x120(%rsp), %xmm3
movaps %xmm3, 0xb0(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps 0xc0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movaps 0xa0(%rsp), %xmm2
movaps 0xb0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x26770
movb %al, 0x73(%rsp)
jmp 0x8d56
movb 0x73(%rsp), %al
xorb $-0x1, %al
movb %al, 0x5f(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x8908
movb 0x5f(%rsp), %al
testb $0x1, %al
jne 0x8d77
jmp 0x8db8
movq 0x67252(%rip), %rdi     # 0x6ffd0
leaq 0x4827f(%rip), %rsi     # 0x51004
callq 0x84c0
movq %rax, %rdi
movq 0x6720c(%rip), %rsi     # 0x6ffa0
callq 0x8500
jmp 0x8db8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x8908
jmp 0x8dc0
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x78(%rsp), %rdi
callq 0x8800
nopw (%rax,%rax)
// File: nikolausmayer[P]SimplePlot/./Sparkline.h
// Function: Sparkline::Sparkline(float const*, unsigned long, unsigned long, unsigned long, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double)
std::string Sparkline( const float* const data,
                         size_t number_of_data_points,
                         size_t this_many_lines_high,
                         size_t this_many_characters_wide,
                         bool enclose_in_box,
                         bool print_colored,
                         std::string title,
                         double max,
                         double min
                       ) 
  {
    return Sparkline( data,
                      number_of_data_points,
                      this_many_lines_high,
                      this_many_characters_wide,
                      enclose_in_box,
                      print_colored,
                      title,
                      (float)max,
                      (float)min
                    );
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %r9d, %eax
movq %rcx, -0xc0(%rbp)
movq %rdx, %rcx
movq -0xc0(%rbp), %rdx
movq %rcx, -0xb8(%rbp)
movq %rsi, %r9
movq %rdi, %r10
movq -0xb8(%rbp), %rdi
movq %r10, -0x98(%rbp)
movb %al, %cl
movq %r10, %rax
movq %rax, -0xb0(%rbp)
movq 0x18(%rbp), %rsi
movb 0x10(%rbp), %al
movq %r10, -0x8(%rbp)
movq %r9, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %cl
movb %cl, -0x29(%rbp)
andb $0x1, %al
movb %al, -0x2a(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movzbl -0x29(%rbp), %eax
movl %eax, -0x9c(%rbp)
movzbl -0x2a(%rbp), %eax
movl %eax, -0xa0(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2120
movq -0xa8(%rbp), %r11
movl -0xa0(%rbp), %r10d
movl -0x9c(%rbp), %r9d
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %r8
movsd -0x38(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd -0x40(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
movq %rsp, %rax
movq %r11, 0x8(%rax)
andl $0x1, %r10d
movl %r10d, (%rax)
andl $0x1, %r9d
callq 0x4a70
jmp 0x2ebd
leaq -0x60(%rbp), %rdi
callq 0x23f8
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x23f8
movq -0x68(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: nikolausmayer[P]SimplePlot/./Sparkline.h
// Function: Sparkline::Sparkline(std::vector<float, std::allocator<float>> const&, unsigned long, unsigned long, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double)
std::string Sparkline( const std::vector<float>& data,
                         size_t this_many_lines_high,
                         size_t this_many_characters_wide,
                         bool enclose_in_box,
                         bool print_colored,
                         std::string title,
                         double max,
                         double min
                       ) 
  {
    return Sparkline( data,
                      this_many_lines_high,
                      this_many_characters_wide,
                      enclose_in_box,
                      print_colored,
                      title,
                      (float)max,
                      (float)min
                    );
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %r9d, %eax
movl %r8d, -0xb4(%rbp)
movq %rcx, %r8
movl -0xb4(%rbp), %ecx
movq %r8, -0xb0(%rbp)
movq %rdx, %r8
movq -0xb0(%rbp), %rdx
movq %r8, -0xa8(%rbp)
movq %rsi, %r8
movq %rdi, %r9
movq -0xa8(%rbp), %rdi
movq %r9, -0x88(%rbp)
movq %r9, %rsi
movq %rsi, -0xa0(%rbp)
movq 0x10(%rbp), %rsi
movq %r9, -0x8(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movzbl -0x22(%rbp), %eax
movl %eax, -0x8c(%rbp)
movzbl -0x21(%rbp), %eax
movl %eax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2120
movq -0x98(%rbp), %r10
movl -0x90(%rbp), %r8d
movl -0x8c(%rbp), %r9d
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
movsd -0x30(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd -0x38(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
movq %rsp, %rax
movq %r10, (%rax)
andl $0x1, %r8d
andl $0x1, %r9d
callq 0x5e60
jmp 0x3008
leaq -0x58(%rbp), %rdi
callq 0x23f8
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x23f8
movq -0x60(%rbp), %rdi
callq 0x23a0
nop
// File: nikolausmayer[P]SimplePlot/./Sparkline.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Sparkline::Sparkline<float>(std::vector<float, std::allocator<float>> const&, unsigned long, unsigned long, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, float)
std::string Sparkline( const std::vector<T>& data,
                         size_t this_many_lines_high=1,
                         size_t this_many_characters_wide=0,
                         bool enclose_in_box=false,
                         bool print_colored=true,
                         std::string title="",
                         T minv=std::numeric_limits<T>::max(),
                         T maxv=std::numeric_limits<T>::min()
                       )
  {
    /// TODO The standard guarantees that vector elements are
    /// stored contiguously, but does that hold for all compiler
    /// and language versions (VERY young issue; May 2014)?
    /// (www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69)
    const T* const ptr = &data[0];
    return Sparkline( ptr,
                      (size_t)data.size(),
                      this_many_lines_high,
                      this_many_characters_wide,
                      enclose_in_box,
                      print_colored,
                      title,
                      minv,
                      maxv );
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %r8d, -0xcc(%rbp)
movq %rcx, %rax
movl -0xcc(%rbp), %ecx
movq %rax, -0xc8(%rbp)
movq %rdx, %rax
movq -0xc8(%rbp), %rdx
movq %rax, -0xc0(%rbp)
movq %rsi, %rax
movq -0xc0(%rbp), %rsi
movq %rax, -0xb8(%rbp)
movq %rdi, %r8
movq -0xb8(%rbp), %rdi
movq %r8, -0x90(%rbp)
movb %r9b, %al
movq %r8, %r9
movq %r9, -0xb0(%rbp)
movq 0x10(%rbp), %r9
movq %r9, -0xa8(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movss %xmm0, -0x28(%rbp)
movss %xmm1, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x69f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6480
movq -0xa8(%rbp), %rsi
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movzbl -0x21(%rbp), %eax
movl %eax, -0x94(%rbp)
movzbl -0x22(%rbp), %eax
movl %eax, -0x98(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2120
movq -0xa0(%rbp), %r11
movl -0x98(%rbp), %r10d
movl -0x94(%rbp), %r9d
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq -0x70(%rbp), %r8
movss -0x28(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
movq %rsp, %rax
movq %r11, 0x8(%rax)
andl $0x1, %r10d
movl %r10d, (%rax)
andl $0x1, %r9d
callq 0x4a70
jmp 0x5fa8
leaq -0x58(%rbp), %rdi
callq 0x23f8
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x23f8
movq -0x60(%rbp), %rdi
callq 0x23a0
nop
// File: nikolausmayer[P]SimplePlot/./Sparkline.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Sparkline::Sparkline<float>(std::vector<float, std::allocator<float>> const&, Sparkline::Configuration<float> const&)
std::string Sparkline( const std::vector<T>& data,
                         const Configuration<T>& config
                       )
  {
    return Sparkline( data,
                      config.this_many_lines_high,
                      config.this_many_characters_wide,
                      config.enclose_in_box,
                      config.print_colored,
                      config.title,
                      config.minv,
                      config.maxv 
                    );
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, %rsi
addq $0x18, %rsi
movzbl 0x11(%rax), %ecx
movl %ecx, -0x6c(%rbp)
movzbl 0x10(%rax), %eax
movl %eax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2120
movq -0x78(%rbp), %r10
movl -0x70(%rbp), %r8d
movl -0x6c(%rbp), %r9d
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movss 0x38(%rax), %xmm0
movss 0x3c(%rax), %xmm1
movq %rsp, %rax
movq %r10, (%rax)
andl $0x1, %r8d
andl $0x1, %r9d
callq 0x5e60
jmp 0x62be
leaq -0x38(%rbp), %rdi
callq 0x23f8
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23f8
movq -0x40(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kobanium[P]Ray/src/common/Message.cpp
// Function: PrintPoint(int)
void
PrintPoint( const int pos )
{
  if (!debug_message) return;

  if (pos == PASS) {
    std::cerr << "PASS" << std::endl;
  } else if (pos == RESIGN) {
    std::cerr << "RESIGN" << std::endl;
  } else {
    std::cerr << GOGUI_X(pos) << GOGUI_Y(pos) << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
testb $0x1, 0xc543e(%rip)     # 0xe7580
jne 0x22149
jmp 0x22209
cmpl $0x0, -0x4(%rbp)
jne 0x22176
movq 0xc4e9a(%rip), %rdi     # 0xe6ff0
leaq 0x89fc4(%rip), %rsi     # 0xac121
callq 0x7530
movq %rax, %rdi
movq 0xc4dfc(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x22209
cmpl $-0x1, -0x4(%rbp)
jne 0x221a0
movq 0xc4e6d(%rip), %rdi     # 0xe6ff0
leaq 0x8a04f(%rip), %rsi     # 0xac1d9
callq 0x7530
movq %rax, %rdi
movq 0xc4dcf(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x22207
movl -0x4(%rbp), %eax
leaq 0xc58a2(%rip), %rcx     # 0xe7a4c
cltd
idivl (%rcx)
movl %edx, %eax
subl $0x5, %eax
addl $0x1, %eax
movslq %eax, %rcx
movq 0xc4e31(%rip), %rdi     # 0xe6ff0
leaq 0x8a1da(%rip), %rax     # 0xac3a0
movsbl (%rax,%rcx), %esi
callq 0x7660
movq %rax, %rdi
leaq 0xc586b(%rip), %rax     # 0xe7a44
movl (%rax), %esi
addl $0x1, %esi
movl -0x4(%rbp), %eax
leaq 0xc5864(%rip), %rcx     # 0xe7a4c
cltd
idivl (%rcx)
subl $0x5, %eax
addl $0x1, %eax
subl %eax, %esi
callq 0x7980
movq %rax, %rdi
movq 0xc4d66(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x22209
addq $0x10, %rsp
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/common/Message.cpp
// Function: PrintResignThresholdIsTooLarge(double)
void
PrintResignThresholdIsTooLarge( const double threshold )
{
  std::ostringstream oss;

  oss << "Resign threshold = " << threshold << " is too large.\n";
  oss << "Resign threshold must be larger than or equal to 0.0, smaller than or equal to 1.0.\n";
  oss << "Ignore this setting.\n";
  std::cerr << oss.str() << std::flush;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movsd %xmm0, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x7750
movq -0x1c0(%rbp), %rdi
leaq 0x89e27(%rip), %rsi     # 0xac238
callq 0x7530
movq %rax, -0x1b8(%rbp)
jmp 0x2241f
movq -0x1b8(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x7a60
movq %rax, -0x1c8(%rbp)
jmp 0x22439
movq -0x1c8(%rbp), %rdi
leaq 0x89e05(%rip), %rsi     # 0xac24c
callq 0x7530
jmp 0x2244e
leaq 0x89e07(%rip), %rsi     # 0xac25c
leaq -0x180(%rbp), %rdi
callq 0x7530
jmp 0x22463
leaq 0x89e47(%rip), %rsi     # 0xac2b1
leaq -0x180(%rbp), %rdi
callq 0x7530
jmp 0x22478
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x7580
jmp 0x2248d
movq 0xc4b5c(%rip), %rdi     # 0xe6ff0
leaq -0x1b0(%rbp), %rsi
callq 0x7480
movq %rax, -0x1d0(%rbp)
jmp 0x224a9
movq -0x1d0(%rbp), %rdi
movq 0xc4af9(%rip), %rsi     # 0xe6fb0
callq 0x75b0
jmp 0x224be
leaq -0x1b0(%rbp), %rdi
callq 0x7ae8
leaq -0x180(%rbp), %rdi
callq 0x7110
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x22511
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x7ae8
leaq -0x180(%rbp), %rdi
callq 0x7110
movq -0x188(%rbp), %rdi
callq 0x79b0
nopl (%rax)
// File: kobanium[P]Ray/src/common/Message.cpp
// Function: PrintResignThresholdIsTooSmall(double)
void
PrintResignThresholdIsTooSmall( const double threshold )
{
  std::ostringstream oss;

  oss << "Resign threshold = " << threshold << " is too small.\n";
  oss << "Resign threshold is set to 0.0.\n";
  oss << "Ray never resigns.\n";
  std::cerr << oss.str() << std::flush;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movsd %xmm0, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x7750
movq -0x1c0(%rbp), %rdi
leaq 0x89cd7(%rip), %rsi     # 0xac238
callq 0x7530
movq %rax, -0x1b8(%rbp)
jmp 0x2256f
movq -0x1b8(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x7a60
movq %rax, -0x1c8(%rbp)
jmp 0x22589
movq -0x1c8(%rbp), %rdi
leaq 0x89d30(%rip), %rsi     # 0xac2c7
callq 0x7530
jmp 0x2259e
leaq 0x89d32(%rip), %rsi     # 0xac2d7
leaq -0x180(%rbp), %rdi
callq 0x7530
jmp 0x225b3
leaq 0x89d3e(%rip), %rsi     # 0xac2f8
leaq -0x180(%rbp), %rdi
callq 0x7530
jmp 0x225c8
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x7580
jmp 0x225dd
movq 0xc4a0c(%rip), %rdi     # 0xe6ff0
leaq -0x1b0(%rbp), %rsi
callq 0x7480
movq %rax, -0x1d0(%rbp)
jmp 0x225f9
movq -0x1d0(%rbp), %rdi
movq 0xc49a9(%rip), %rsi     # 0xe6fb0
callq 0x75b0
jmp 0x2260e
leaq -0x1b0(%rbp), %rdi
callq 0x7ae8
leaq -0x180(%rbp), %rdi
callq 0x7110
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x22661
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x7ae8
leaq -0x180(%rbp), %rdi
callq 0x7110
movq -0x188(%rbp), %rdi
callq 0x79b0
nopl (%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_boardsize()
static void
GTP_boardsize( void )
{
  char *command;
  int size;
  char buf[1024];

  StopPondering();

  command = STRTOK(NULL, DELIM, &next_token);

#if defined (_WIN32)
  sscanf_s(command, "%d", &size);
  sprintf_s(buf, 1024, " ");
#else
  sscanf(command, "%d", &size);
  snprintf(buf, 1024, " ");
#endif

  if (pure_board_size != size &&
      size <= PURE_BOARD_SIZE && size > 0) {
    SetBoardSize(size);
    SetParameter();
    SetNeighbor();
    InitializeNakadeHash();
  }

  FreeGame(game);
  game = AllocateGame();
  InitializeBoard(game);
  InitializeSearchSetting();
  InitializeUctHash();

  GTP_response(blank, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
callq 0x892c0
xorl %eax, %eax
movl %eax, %edi
leaq 0x86d55(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x86b85(%rip), %rsi     # 0xac9e4
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x7520
leaq -0x410(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
leaq 0x865c9(%rip), %rdx     # 0xac446
movb $0x0, %al
callq 0x78a0
leaq 0xc1bb9(%rip), %rax     # 0xe7a44
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x25eb5
cmpl $0x13, -0xc(%rbp)
jg 0x25eb5
cmpl $0x0, -0xc(%rbp)
jle 0x25eb5
movl -0xc(%rbp), %edi
callq 0x9b560
callq 0x88eb0
callq 0x82c60
callq 0xa3920
movq 0xc2664(%rip), %rdi     # 0xe8520
callq 0x9bd30
callq 0x9bce0
movq %rax, 0xc2653(%rip)     # 0xe8520
movq 0xc264c(%rip), %rdi     # 0xe8520
callq 0x9bd70
callq 0x89180
callq 0x9f840
leaq 0x86cd8(%rip), %rdi     # 0xacbc2
movl $0x1, %esi
callq 0x27f30
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_clearboard()
static void
GTP_clearboard( void )
{
  StopPondering();

  player_color = S_BLACK;
  SetHandicapNum(0);
  FreeGame(game);
  game = AllocateGame();
  InitializeBoard(game);
  InitializeSearchSetting();
  InitializeUctHash();

  GTP_response(blank, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x892c0
movl $0x1, 0xc124d(%rip)     # 0xe7590
xorl %edi, %edi
callq 0x9fde0
movq 0xc21cf(%rip), %rdi     # 0xe8520
callq 0x9bd30
callq 0x9bce0
movq %rax, 0xc21be(%rip)     # 0xe8520
movq 0xc21b7(%rip), %rdi     # 0xe8520
callq 0x9bd70
callq 0x89180
callq 0x9f840
leaq 0x86843(%rip), %rdi     # 0xacbc2
movl $0x1, %esi
callq 0x27f30
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_finalscore()
static void
GTP_finalscore( void )
{
  char buf[10];

  StopPondering();

  double score = UctAnalyze(game, S_BLACK) - komi[0];

#if defined(_WIN32)  
  if (abs(score) < 0.1) {
    sprintf_s(buf, 10, "0");
  } else if (score > 0) {
    sprintf_s(buf, 10, "B+%.1lf", score);
  } else {
    sprintf_s(buf, 10, "W+%.1lf", -score);
  }
#else
  if (abs(score) < 0.1) {
    snprintf(buf, 10, "0");
  } else if (score > 0) {
    snprintf(buf, 10, "B+%.1lf", score);
  } else {
    snprintf(buf, 10, "W+%.1lf", -score);
  }
#endif

  GTP_response(buf, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x892c0
movq 0xc217c(%rip), %rdi     # 0xe8520
movl $0x1, %esi
callq 0x8a4f0
cvtsi2sd %eax, %xmm0
leaq 0x1ab57cd7(%rip), %rax  # 0x1ab7e090
subsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
cvttsd2si -0x18(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2sd %eax, %xmm1
movsd 0x85fe6(%rip), %xmm0    # 0xac3c0
ucomisd %xmm1, %xmm0
jbe 0x263f9
leaq -0xa(%rbp), %rdi
movl $0xa, %esi
leaq 0x86710(%rip), %rdx     # 0xacb00
movb $0x0, %al
callq 0x78a0
jmp 0x2645a
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x26425
leaq -0xa(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movl $0xa, %esi
leaq 0x866e6(%rip), %rdx     # 0xacb02
movb $0x1, %al
callq 0x78a0
jmp 0x26458
leaq -0xa(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movl $0xa, %esi
leaq 0x866b9(%rip), %rdx     # 0xacb0a
movb $0x1, %al
callq 0x78a0
jmp 0x2645a
leaq -0xa(%rbp), %rdi
movl $0x1, %esi
callq 0x27f30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_genmove()
static void
GTP_genmove( void )
{
  char *command;
  char c;
  char pos[10];
  int color;
  int point = PASS;

  StopPondering();

  command = STRTOK(input_copy, DELIM, &next_token);
  
  CHOMP(command);

  command = STRTOK(NULL, DELIM, &next_token);
  if (command == NULL){
    GTP_response(err_genmove, true);
    return;
  }
  CHOMP(command);
  c = static_cast<char>(tolower(static_cast<int>(command[0])));
  if (c == 'w') {
    color = S_WHITE;
  } else if (c == 'b') {
    color = S_BLACK;
  } else {
    GTP_response(err_genmove, true);
    return;
  }

  player_color = color;
  
  point = UctSearchGenmove(game, color, -1);
  if (point != RESIGN) {
    PutStone(game, point, color);
  }
  
  IntegerToString(point, pos);
  
  GTP_response(pos, true);

  UctSearchPondering(game, GetOppositeColor(color), -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x1c(%rbp)
callq 0x892c0
leaq 0xc1755(%rip), %rdi     # 0xe8410
leaq 0x85ede(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x26d10
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
movl %eax, %edi
leaq 0x85e85(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x26d41
leaq 0x85e91(%rip), %rdi     # 0xacbc3
movl $0x1, %esi
callq 0x27f30
jmp 0x26e43
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x26d86
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x77e0
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x77, %eax
jne 0x26da7
movl $0x2, -0x18(%rbp)
jmp 0x26dce
movsbl -0x9(%rbp), %eax
cmpl $0x62, %eax
jne 0x26db9
movl $0x1, -0x18(%rbp)
jmp 0x26dcc
leaq 0x85e03(%rip), %rdi     # 0xacbc3
movl $0x1, %esi
callq 0x27f30
jmp 0x26e43
jmp 0x26dce
movl -0x18(%rbp), %eax
movl %eax, 0xc07b9(%rip)     # 0xe7590
movq 0xc1742(%rip), %rdi     # 0xe8520
movl -0x18(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x89370
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x26e06
movq 0xc1725(%rip), %rdi     # 0xe8520
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9dbc0
movl -0x1c(%rbp), %edi
leaq -0x13(%rbp), %rsi
callq 0x9ef70
leaq -0x13(%rbp), %rdi
movl $0x1, %esi
callq 0x27f30
movq 0xc16f9(%rip), %rax     # 0xe8520
movq %rax, -0x48(%rbp)
movl -0x18(%rbp), %edi
callq 0x25810
movq -0x48(%rbp), %rdi
movl %eax, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8a080
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_knowncommand()
static void
GTP_knowncommand( void )
{
  char *command;
  
  command = STRTOK(NULL, DELIM, &next_token);
  
  if (command == NULL){
    GTP_response("known_command command", false);
    return;
  }
  CHOMP(command);
  for (const auto& cmd : gtpcmd) {
    if (!strcmp(command, cmd.command)) {
      GTP_response("true", true);
      return;
    }
  }
  GTP_response("false", false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
xorl %eax, %eax
movl %eax, %edi
leaq 0x85b1d(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x270a6
leaq 0x85aa9(%rip), %rdi     # 0xacb43
xorl %esi, %esi
callq 0x27f30
jmp 0x27167
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x270eb
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
leaq 0xbf1ce(%rip), %rax     # 0xe62c0
movq %rax, -0x10(%rbp)
leaq 0xbf1c3(%rip), %rax     # 0xe62c0
movq %rax, -0x18(%rbp)
leaq 0xbf1b8(%rip), %rax     # 0xe62c0
addq $0x708, %rax            # imm = 0x708
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x27159
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x77a0
cmpl $0x0, %eax
jne 0x27149
leaq 0x85a1c(%rip), %rdi     # 0xacb59
movl $0x1, %esi
callq 0x27f30
jmp 0x27167
jmp 0x2714b
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x18(%rbp)
jmp 0x27112
leaq 0x859fe(%rip), %rdi     # 0xacb5e
xorl %esi, %esi
callq 0x27f30
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_komi()
static void
GTP_komi( void )
{
  char* c_komi;

  StopPondering();

  c_komi = STRTOK(NULL, DELIM, &next_token);

  if (c_komi != NULL) {
    SetKomi(atof(c_komi));
    PrintKomiValue();
    GTP_response(blank, true);
  } else {
    GTP_response(err_komi, false);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x892c0
xorl %eax, %eax
movl %eax, %edi
leaq 0x85a18(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x271be
movq -0x8(%rbp), %rdi
callq 0x76d0
callq 0x9bc10
callq 0x22210
leaq 0x85a10(%rip), %rdi     # 0xacbc2
movl $0x1, %esi
callq 0x27f30
jmp 0x271cc
leaq 0x85b5b(%rip), %rdi     # 0xacd20
xorl %esi, %esi
callq 0x27f30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_listcommands()
static void
GTP_listcommands( void )
{
  char list[2048];
  int i;

  i = 0;
  for (const auto& cmd : gtpcmd) {
    list[i++] = '\n';
    for (unsigned int k = 0; k < strlen(cmd.command); k++){
      list[i++] = cmd.command[k];
    }
  }
  list[i++] = '\0';

  GTP_response(list, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x840, %rsp            # imm = 0x840
movl $0x0, -0x804(%rbp)
leaq 0xbf0c4(%rip), %rax     # 0xe62c0
movq %rax, -0x810(%rbp)
leaq 0xbf0b6(%rip), %rax     # 0xe62c0
movq %rax, -0x818(%rbp)
leaq 0xbf0a8(%rip), %rax     # 0xe62c0
addq $0x708, %rax            # imm = 0x708
movq %rax, -0x820(%rbp)
movq -0x818(%rbp), %rax
cmpq -0x820(%rbp), %rax
je 0x272e8
movq -0x818(%rbp), %rax
movq %rax, -0x828(%rbp)
movl -0x804(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x804(%rbp)
cltq
movb $0xa, -0x800(%rbp,%rax)
movl $0x0, -0x82c(%rbp)
movl -0x82c(%rbp), %eax
movq %rax, -0x838(%rbp)
movq -0x828(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x838(%rbp), %rax
cmpq %rcx, %rax
jae 0x272cf
movq -0x828(%rbp), %rax
movl -0x82c(%rbp), %ecx
movb (%rax,%rcx), %cl
movl -0x804(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x804(%rbp)
cltq
movb %cl, -0x800(%rbp,%rax)
movl -0x82c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x82c(%rbp)
jmp 0x2726c
jmp 0x272d1
movq -0x818(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x818(%rbp)
jmp 0x27225
movl -0x804(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x804(%rbp)
cltq
movb $0x0, -0x800(%rbp,%rax)
leaq -0x800(%rbp), %rdi
movl $0x1, %esi
callq 0x27f30
addq $0x840, %rsp            # imm = 0x840
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_lz_analyze()
void GTP_lz_analyze( void )
{
  char *command;
  int color = S_EMPTY, centi_second = 100;

  StopPondering();

  command = STRTOK(input_copy, DELIM, &next_token);
  CHOMP(command);

  ParseAnalysisTag(color, centi_second);

  bool old_pondering_mode = pondering_mode;
  SetPonderingMode(true);

  if (color == S_EMPTY) {
    color = player_color;
  } else {
    player_color = color;
  }

  if (command_id >= 0) {
    std::cout << "=" << command_id << " " << std::endl;
  } else {
    std::cout << "= " << std::endl;
  }

  UctSearchPondering(game, color, centi_second);

  while (!InputPending()) {
    std::this_thread::yield();
  }

  StopPondering();
  SetPonderingMode(old_pondering_mode);

  std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0xc(%rbp)
movl $0x64, -0x10(%rbp)
callq 0x892c0
leaq 0xc0cee(%rip), %rdi     # 0xe8410
leaq 0x85477(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x27777
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x28050
leaq 0x1ab25331(%rip), %rax  # 0x1ab4cabc
movb (%rax), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x1, %edi
callq 0x88e50
cmpl $0x0, -0xc(%rbp)
jne 0x277ad
movl 0xbfde8(%rip), %eax     # 0xe7590
movl %eax, -0xc(%rbp)
jmp 0x277b6
movl -0xc(%rbp), %eax
movl %eax, 0xbfdda(%rip)     # 0xe7590
cmpl $0x0, 0xc0d5b(%rip)     # 0xe8518
jl 0x27800
movq 0xbf7e2(%rip), %rdi     # 0xe6fa8
leaq 0x8521a(%rip), %rsi     # 0xac9e7
callq 0x7530
movq %rax, %rdi
movl 0xc0d3d(%rip), %esi     # 0xe8518
callq 0x7980
movq %rax, %rdi
leaq 0x84c5c(%rip), %rsi     # 0xac446
callq 0x7530
movq %rax, %rdi
movq 0xbf76f(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x27822
movq 0xbf7a1(%rip), %rdi     # 0xe6fa8
leaq 0x84a3b(%rip), %rsi     # 0xac249
callq 0x7530
movq %rax, %rdi
movq 0xbf74b(%rip), %rsi     # 0xe6f68
callq 0x75b0
movq 0xc0cf7(%rip), %rdi     # 0xe8520
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x8a080
callq 0x282b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x27841
jmp 0x27848
callq 0x2c890
jmp 0x27834
callq 0x892c0
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x88e50
movq 0xbf747(%rip), %rdi     # 0xe6fa8
movq 0xbf700(%rip), %rsi     # 0xe6f68
callq 0x75b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/gtp/Gtp.cpp
// Function: GTP_lz_genmove_analyze()
static void
GTP_lz_genmove_analyze( void )
{
  char *command;
  char pos[10];
  int color = S_EMPTY, centi_second = 100;
  int point = PASS;

  StopPondering();

  command = STRTOK(input_copy, DELIM, &next_token);
  CHOMP(command);

  ParseAnalysisTag(color, centi_second);

  if (color == S_EMPTY) {
    color = player_color;
  } else {
    player_color = color;
  }

  if (command_id >= 0) {
    std::cout << "=" << command_id << " " << std::endl;
  } else {
    std::cout << "= " << std::endl;
  }

  point = UctSearchGenmove(game, color, centi_second);

  if (point != RESIGN) {
    PutStone(game, point, color);
  }
  IntegerToString(point, pos);
  std::cout << "play " << pos << std::endl << std::endl;

  UctSearchPondering(game, GetOppositeColor(color), -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x18(%rbp)
movl $0x64, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
callq 0x892c0
leaq 0xc0b67(%rip), %rdi     # 0xe8410
leaq 0x852f0(%rip), %rsi     # 0xacba0
callq 0x7850
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x278fe
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x28050
cmpl $0x0, -0x18(%rbp)
jne 0x2791c
movl 0xbfc79(%rip), %eax     # 0xe7590
movl %eax, -0x18(%rbp)
jmp 0x27925
movl -0x18(%rbp), %eax
movl %eax, 0xbfc6b(%rip)     # 0xe7590
cmpl $0x0, 0xc0bec(%rip)     # 0xe8518
jl 0x2796f
movq 0xbf673(%rip), %rdi     # 0xe6fa8
leaq 0x850ab(%rip), %rsi     # 0xac9e7
callq 0x7530
movq %rax, %rdi
movl 0xc0bce(%rip), %esi     # 0xe8518
callq 0x7980
movq %rax, %rdi
leaq 0x84aed(%rip), %rsi     # 0xac446
callq 0x7530
movq %rax, %rdi
movq 0xbf600(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x27991
movq 0xbf632(%rip), %rdi     # 0xe6fa8
leaq 0x848cc(%rip), %rsi     # 0xac249
callq 0x7530
movq %rax, %rdi
movq 0xbf5dc(%rip), %rsi     # 0xe6f68
callq 0x75b0
movq 0xc0b88(%rip), %rdi     # 0xe8520
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x89370
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
je 0x279be
movq 0xc0b6d(%rip), %rdi     # 0xe8520
movl -0x20(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9dbc0
movl -0x20(%rbp), %edi
leaq -0x12(%rbp), %rsi
callq 0x9ef70
movq 0xbf5d7(%rip), %rdi     # 0xe6fa8
leaq 0x85014(%rip), %rsi     # 0xac9ec
callq 0x7530
movq %rax, %rdi
leaq -0x12(%rbp), %rsi
callq 0x7530
movq %rax, %rdi
movq 0xbf575(%rip), %rsi     # 0xe6f68
callq 0x75b0
movq %rax, %rdi
movq 0xbf566(%rip), %rsi     # 0xe6f68
callq 0x75b0
movq 0xc0b12(%rip), %rax     # 0xe8520
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %edi
callq 0x25810
movq -0x38(%rbp), %rdi
movl %eax, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8a080
addq $0x40, %rsp
popq %rbp
retq