LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::set_position(PList const&)
bool Goban::set_position(const PList &moves)
{
  for (int i = 0; i < moves.length(); i++) {
    if (moves[i]) {
      if (!points[moves[i]] && is_legal(moves[i], side)) {
        drop_stone(moves[i], side);
        game_history.add(moves[i]);
        side = !side;
      } else {
        return false;
      }
    } else {
      side = !side;
    }
  #ifdef ZOBRIST
    zobrist.record_key();
  #endif
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x70fe
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, %eax
je 0x70d2
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
cmpq $0x0, 0x18(%rax,%rcx,8)
jne 0x70ca
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movl %eax, %esi
movb (%rdi), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x8140
testb $0x1, %al
jne 0x7075
jmp 0x70ca
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movl %eax, %esi
movb (%rdi), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x66e0
movq -0x28(%rbp), %rax
addq $0xfc6d8, %rax          # imm = 0xFC6D8
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x7500
movq -0x28(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x70d0
movb $0x0, -0x1(%rbp)
jmp 0x7102
jmp 0x70e0
movq -0x28(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x28(%rbp), %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x13990
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6fff
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/./group.h
// Function: PointList<362>::add(int)
virtual void add(int p)
  {
    if (len == S) {
    #ifdef DEBUG_INFO
      std::cerr << "long list\n";
    #endif
      return;
    }
    points[len++] = p;
    points[len] = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x16a, 0x5b0(%rax)     # imm = 0x16A
jne 0x7221
jmp 0x724f
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movl 0x5b0(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x5b0(%rax)
movslq %ecx, %rcx
movl %edx, 0x8(%rax,%rcx,4)
movslq 0x5b0(%rax), %rcx
movl $0x0, 0x8(%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: antoniogarro[P]Hara/./group.h
// Function: PointList<362>::remove(int)
void remove(int p)
  {
    for (int j = 0; j < len; j++) {
      if (points[j] == p) {
        points[j] = points[--len];
        points[len] = 0;
        break;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x5b0(%rcx), %eax
jge 0x733a
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x732d
movq -0x18(%rbp), %rax
movl 0x5b0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x5b0(%rax)
movslq %ecx, %rcx
movl 0x8(%rax,%rcx,4), %edx
movslq -0x10(%rbp), %rcx
movl %edx, 0x8(%rax,%rcx,4)
movslq 0x5b0(%rax), %rcx
movl $0x0, 0x8(%rax,%rcx,4)
jmp 0x733a
jmp 0x732f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x72da
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/./group.h
// Function: PointSet<5>::add(int)
void add(int p)
  {
    if (PointList<S>::len == S) {
    #ifdef DEBUG_INFO
      std::cerr << "long set\n";
    #endif
      return;
    }
    for (int i = 0; i < PointList<S>::len; i++) {
      if (PointList<S>::points[i] == p) return;
    }
    PointList<S>::points[PointList<S>::len++] = p;
    PointList<S>::points[PointList<S>::len] = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x5, 0x1c(%rax)
jne 0x75db
jmp 0x7633
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x760e
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x7601
jmp 0x7633
jmp 0x7603
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x75e2
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movl 0x1c(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x1c(%rax)
movslq %ecx, %rcx
movl %edx, 0x8(%rax,%rcx,4)
movslq 0x1c(%rax), %rcx
movl $0x0, 0x8(%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: antoniogarro[P]Hara/gobanconst.cpp
// Function: Goban::get_zobrist(int) const
unsigned long long Goban::get_zobrist(int move)const
{
  unsigned long long zob_backup = get_zobrist();
  unsigned long long new_zobrist = set_zobrist(move);
  zobrist.set_key(zob_backup);
  return new_zobrist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x7840
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x78c0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
movq -0x18(%rbp), %rsi
callq 0x13810
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: antoniogarro[P]Hara/gobanconst.cpp
// Function: Goban::set_zobrist(int) const
unsigned long long Goban::set_zobrist(int move) const
{
  if (move) {
    zobrist.update(move, side);
    
    GroupSet<4> neighbours;
    int nneigh = neighbour_groups(move, neighbours);
    
    for (int i = 0; i < nneigh; i++) {
      Group *current_neigh = neighbours[i];
      if (current_neigh->get_color() != side) {
        if (current_neigh->has_one_liberty()) {
          for (Group::StoneIterator st(current_neigh); st; ++st) {
            zobrist.update(*st, current_neigh->get_color());
          }
        }
      }
    }
  }
  zobrist.toggle_side();
  return get_zobrist();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x79df
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
movl -0xc(%rbp), %esi
movb (%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x13880
leaq -0x48(%rbp), %rdi
callq 0x73c0
movq -0x68(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x48(%rbp), %rdx
callq 0x7a10
movl %eax, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x79dd
movl -0x50(%rbp), %esi
leaq -0x48(%rbp), %rdi
callq 0x73e0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x7400
movq -0x68(%rbp), %rcx
andb $0x1, %al
movzbl %al, %eax
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x79cd
movq -0x58(%rbp), %rdi
callq 0x73a0
testb $0x1, %al
jne 0x796d
jmp 0x79cb
movq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x7460
leaq -0x60(%rbp), %rdi
callq 0x74a0
testb $0x1, %al
jne 0x7989
jmp 0x79c9
movq -0x68(%rbp), %rax
addq $0xfd7d0, %rax          # imm = 0xFD7D0
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x74c0
movl %eax, -0x6c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x7400
movq -0x78(%rbp), %rdi
movl -0x6c(%rbp), %esi
movzbl %al, %edx
andl $0x1, %edx
callq 0x13880
leaq -0x60(%rbp), %rdi
callq 0x74e0
jmp 0x797a
jmp 0x79cb
jmp 0x79cd
jmp 0x79cf
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x7924
jmp 0x79df
movq -0x68(%rbp), %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x13860
movq -0x68(%rbp), %rdi
callq 0x7840
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/./group.h
// Function: GroupSet<4>::add(Group*)
bool add(Group *gr)
  {
    if (gr == 0) return false;
    for (int i = 0; i < len; i++) {
      if (groups[i] == gr) {
        multiplicity[i]++;
        return  false;
      }
    }
    multiplicity[len] = 1;
    groups[len++] = gr;
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8a01
movb $0x0, -0x1(%rbp)
jmp 0x8a76
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0x8a4c
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x8a3f
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0x20(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x20(%rax,%rcx,4)
movb $0x0, -0x1(%rbp)
jmp 0x8a76
jmp 0x8a41
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8a08
movq -0x28(%rbp), %rax
movslq 0x30(%rax), %rcx
movl $0x1, 0x20(%rax,%rcx,4)
movq -0x18(%rbp), %rdx
movl 0x30(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x30(%rax)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/group.cpp
// Function: Group::Group()
Group::Group()
{
  color = 0;
  stones[0] = 0;
  liberties[0] = 0;
  nsts = 0;
  nlibs = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x5ac(%rax)
movl $0x0, 0x5a8(%rax)
movl $0x0, 0x96c(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/group.cpp
// Function: Group::set_up(int, bool, PList const&)
void Group::set_up(int point, bool new_color, const PList &new_liberties)
{
  color = new_color;
  nsts = 0;
  stones[nsts++] = point;
  stones[nsts] = 0;
  nlibs = 0;
  for (int i = 0; i < new_liberties.length(); i++) {
    liberties[nlibs++] = new_liberties[i];
    liberties[nlibs] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0xd(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movl $0x0, 0x5a8(%rax)
movl -0xc(%rbp), %edx
movl 0x5a8(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x5a8(%rax)
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,4)
movslq 0x5a8(%rax), %rcx
movl $0x0, 0x4(%rax,%rcx,4)
movl $0x0, 0x96c(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x8c93
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %edx
movq -0x28(%rbp), %rax
movl 0x96c(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x96c(%rax)
movslq %ecx, %rcx
movl %edx, 0x5ac(%rax,%rcx,4)
movslq 0x96c(%rax), %rcx
movl $0x0, 0x5ac(%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8c2f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/group.cpp
// Function: Group::add_liberties(int)
int Group::add_liberties(int i)
{
  for (int j = 0; j < nlibs; j++) {
    if (liberties[j] == i) return 0;
  }
  liberties[nlibs++] = i;
  liberties[nlibs] = 0;
  return nlibs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x96c(%rcx), %eax
jge 0x8cf3
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl 0x5ac(%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x8ce6
movl $0x0, -0x4(%rbp)
jmp 0x8d30
jmp 0x8ce8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8cba
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
movl 0x96c(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x96c(%rax)
movslq %ecx, %rcx
movl %edx, 0x5ac(%rax,%rcx,4)
movslq 0x96c(%rax), %rcx
movl $0x0, 0x5ac(%rax,%rcx,4)
movl 0x96c(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/group.cpp
// Function: Group::erase_liberties(int)
int Group::erase_liberties(int lib)
{
  for (int j = 0; j < nlibs; j++) {
    if (liberties[j] == lib) {
      liberties[j] = liberties[--nlibs];
      liberties[nlibs]  = 0;
      return nlibs;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x96c(%rcx), %eax
jge 0x8dcf
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl 0x5ac(%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x8dc2
movq -0x20(%rbp), %rax
movl 0x96c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x96c(%rax)
movslq %ecx, %rcx
movl 0x5ac(%rax,%rcx,4), %edx
movslq -0x18(%rbp), %rcx
movl %edx, 0x5ac(%rax,%rcx,4)
movslq 0x96c(%rax), %rcx
movl $0x0, 0x5ac(%rax,%rcx,4)
movl 0x96c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x8dd6
jmp 0x8dc4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8d5a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: antoniogarro[P]Hara/group.cpp
// Function: Group::clear()
void Group::clear()
{
  nsts = 0;
  stones[nsts] = 0;
  nlibs = 0;
  liberties[nlibs] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x5a8(%rax)
movslq 0x5a8(%rax), %rcx
movl $0x0, 0x4(%rax,%rcx,4)
movl $0x0, 0x96c(%rax)
movslq 0x96c(%rax), %rcx
movl $0x0, 0x5ac(%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/group.cpp
// Function: Group::attach_group(Group*)
void Group::attach_group(Group *attached)
{  
  for (int i = 0; i < attached->nsts; i++) {
    this->stones[nsts++] = attached->stones[i];
    this->stones[nsts] = 0;
  }
  for (int i = 0; i < attached->nlibs; i++) {
    this->add_liberties(attached->liberties[i]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x5a8(%rcx), %eax
jge 0x8ea0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl 0x4(%rcx,%rdx,4), %edx
movl 0x5a8(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x5a8(%rax)
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,4)
movslq 0x5a8(%rax), %rcx
movl $0x0, 0x4(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8e4f
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x96c(%rcx), %eax
jge 0x8ed9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl 0x5ac(%rax,%rcx,4), %esi
callq 0x8ca0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8ea7
addq $0x20, %rsp
popq %rbp
retq
nop
// File: antoniogarro[P]Hara/gtp.cpp
// Function: GTP::GTP_loop()
int GTP::GTP_loop()
{
  
#ifdef LOG
  std::string filename = "log";
  filename.append(PROGVERSION);
  filename.append(".txt");
  engine_log.open(filename);
#endif
  loop = true;
  while (loop && getline(cin, command_string)) {
#ifdef LOG
    engine_log << command_std::string;
    engine_log.flush();
#endif
    parse(command_string);  
    exec();
  }
#ifdef LOG
  engine_log.close();
#endif
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x1, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, -0x11(%rbp)
je 0x992b
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
movq 0x116bc(%rip), %rdi     # 0x1afd0
callq 0x3070
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3340
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x9934
jmp 0x994f
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x78, %rsi
callq 0x9960
movq -0x10(%rbp), %rdi
callq 0x9d10
jmp 0x98f7
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: antoniogarro[P]Hara/gtp.cpp
// Function: GTP::exec()
int GTP::exec(){
  response = "=";
  response.append(cmd_id);
  
  switch (cmd) {
    case PROTOCOL_VERSION:
      protocol_version();
      break;
    case NAME:
      name();
      break;
    case VERSION:
      version();
      break;
    case KNOWN_COMMAND:
      known_command();
      break;
    case LIST_COMMANDS:
      list_commands();
      break;
    case QUIT:
      quit();
      break;
    case BOARDSIZE:
      boardsize();
      break;
    case CLEAR_BOARD:
      clear_board();
      break;
    case KOMI:
      komi();
      break;
    case PLAY:
      play();
      break;
    case GENMOVE:
      genmove();
      break;
    case SHOWBOARD:
      showboard();
      break;
    case FIXED_HANDICAP:
      fixed_handicap();
      break;
    case LEVEL:
      level();
      break;
    case TIME_SETTINGS:
      time_settings();
      break;
    case TIME_LEFT:
      time_left();
      break;
    case FINAL_SCORE:
      final_score();
      break;
    case FINAL_STATUS_LIST:
      final_status_list();
      break;
    case KGS_TIME_SETTINGS:
      kgs_time_settings();
      break;
    case KGS_GENMOVE_CLEANUP:
      kgs_genmove_cleanup();
      break;
    default:
      unknown_command();
      break;
  }
  response.append("\n\n");
  std::cout << response;
  
#ifdef LOG
  engine_log << response;
  engine_log.flush();
#endif
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x98, %rdi
movq %rdi, -0x20(%rbp)
leaq 0xa8eb(%rip), %rsi      # 0x14621
callq 0x3370
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x3480
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x13, %rax
ja 0x9e6c
movq -0x10(%rbp), %rax
leaq 0xa794(%rip), %rcx      # 0x14500
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0xce80
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xceb0
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xcee0
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xcf10
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xcfb0
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd020
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd040
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd140
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd180
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd210
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd390
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd520
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd550
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd650
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd700
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd9a0
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xda60
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xdc60
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd7c0
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd360
jmp 0x9e75
movq -0x18(%rbp), %rdi
callq 0xd4d0
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
leaq 0xa79c(%rip), %rsi      # 0x14623
callq 0x3470
movq -0x18(%rbp), %rsi
addq $0x98, %rsi
movq 0x1111a(%rip), %rdi     # 0x1afb8
callq 0x3240
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: antoniogarro[P]Hara/gtp.cpp
// Function: GTP::string_to_cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int GTP::string_to_cmd(const std::string &command_str)
{
  for (int cmd = 0; cmd < NCOMMANDS; cmd++) {
    if (!command_str.compare(COMMANDS[cmd])) {
      return cmd;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x14, -0x1c(%rbp)
jge 0x9f0e
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x1000c0, %rsi         # imm = 0x1000C0
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3040
cmpl $0x0, %eax
jne 0x9f01
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9f15
jmp 0x9f03
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9ecf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: antoniogarro[P]Hara/gtp.cpp
// Function: GTP::char_to_color(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int GTP::char_to_color(std::string &color)
{
  transform(color.begin(), color.end(), color.begin(), ::tolower);
  
  if (!color.compare("white") || !color.compare("w")) return 1;
  else {
    if (!color.compare("black") || !color.compare("b")) return 0;
    else return -1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3220
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3130
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3220
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x11056(%rip), %rcx     # 0x1afc0
callq 0xac70
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xa6a8(%rip), %rsi      # 0x14626
callq 0x30b0
cmpl $0x0, %eax
je 0x9f9d
movq -0x18(%rbp), %rdi
leaq 0xa699(%rip), %rsi      # 0x1462c
callq 0x30b0
cmpl $0x0, %eax
jne 0x9fa6
movl $0x1, -0x4(%rbp)
jmp 0x9fe0
movq -0x18(%rbp), %rdi
leaq 0xa67d(%rip), %rsi      # 0x1462e
callq 0x30b0
cmpl $0x0, %eax
je 0x9fd0
movq -0x18(%rbp), %rdi
leaq 0xa66e(%rip), %rsi      # 0x14634
callq 0x30b0
cmpl $0x0, %eax
jne 0x9fd9
movl $0x0, -0x4(%rbp)
jmp 0x9fe0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/gtp.cpp
// Function: GTP::print_coordinate(int)
void GTP::print_coordinate(int coord)
{
  if (coord == -1) {
    response.append("resign");
  } else {
    coord_to_char(coord, response, main_goban.get_size());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0xa306
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
leaq 0xa33c(%rip), %rsi      # 0x1463b
callq 0x3470
jmp 0xa337
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq %rdi, %rax
addq $0x98, %rax
movq %rax, -0x20(%rbp)
addq $0xb8, %rdi
callq 0x4530
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movl %eax, %edx
callq 0xa340
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/./size.h
// Function: coord_to_char(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
static void coord_to_char(int coord, std::string &response, int size){
  if(coord == 0){
    response.append("pass");
  }
  else{
    int y = (coord - 1)/size + 1;
    int x = (coord - 1) % size;
    std::string auxstring;
    std::stringstream auxstream;
    auxstream << COORDINATES[x];
    auxstream >> auxstring;
    response.append(auxstring);

    auxstream.clear();
    auxstream << y;
    auxstream >> auxstring;

    response.append(auxstring);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xa370
movq -0x10(%rbp), %rdi
leaq 0xa2ec(%rip), %rsi      # 0x14652
callq 0x3470
jmp 0xa485
movl -0x4(%rbp), %eax
decl %eax
movl -0x14(%rbp), %ecx
cltd
idivl %ecx
incl %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl -0x14(%rbp), %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3380
leaq -0x1c8(%rbp), %rdi
callq 0x3190
jmp 0xa3a5
leaq -0x1b8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
leaq 0xa199(%rip), %rcx      # 0x14550
movsbl (%rax,%rcx), %esi
callq 0x3310
jmp 0xa3c2
leaq -0x1c8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3350
jmp 0xa3d4
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3480
jmp 0xa3e3
movq -0x1c8(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1c8(%rbp,%rax), %rdi
xorl %esi, %esi
callq 0x33e0
jmp 0xa3ff
leaq -0x1b8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3400
jmp 0xa410
leaq -0x1c8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3350
jmp 0xa422
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3480
jmp 0xa431
leaq -0x1c8(%rbp), %rdi
callq 0x31c0
leaq -0x40(%rbp), %rdi
callq 0x3160
jmp 0xa485
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xa47a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x31c0
leaq -0x40(%rbp), %rdi
callq 0x3160
jmp 0xa48e
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: antoniogarro[P]Hara/gtp.cpp
// Function: GTP::perft(int)
void GTP::perft(int max)
{
  clock_t t = clock();
  go_engine.perft(max);
  t = clock() - t;
  float ts = (float)t/CLOCKS_PER_SEC;
  std::cerr << "Finish " << ts << ":" << max/ts << "pps.\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3170
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0xffaa8, %rdi          # imm = 0xFFAA8
movl -0xc(%rbp), %esi
callq 0x44c0
callq 0x3170
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cvtsi2ssq -0x18(%rbp), %xmm0
movss 0x9b42(%rip), %xmm1     # 0x14030
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movq 0x10af2(%rip), %rdi     # 0x1aff0
leaq 0xa13d(%rip), %rsi      # 0x14642
callq 0x3270
movq %rax, %rdi
movss -0x1c(%rbp), %xmm0
callq 0x31b0
movq %rax, %rdi
leaq 0xa129(%rip), %rsi      # 0x1464a
callq 0x3270
movq %rax, %rdi
cvtsi2ssl -0xc(%rbp), %xmm0
divss -0x1c(%rbp), %xmm0
callq 0x31b0
movq %rax, %rdi
leaq 0xa10a(%rip), %rsi      # 0x1464c
callq 0x3270
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::known_command()
void GTP::known_command()
{
  for(int i = 0; i < NCOMMANDS; i++){
    if(!cmd_args[0].compare(COMMANDS[i])){
      response.append("true");
    }
  }
  response.append("false");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0xcf89
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf30
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x1000c0, %rsi         # imm = 0x1000C0
movslq -0xc(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3040
cmpl $0x0, %eax
jne 0xcf7c
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
leaq 0x7734(%rip), %rsi      # 0x146ab
callq 0x3470
jmp 0xcf7e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcf2b
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
leaq 0x7715(%rip), %rsi      # 0x146b0
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::boardsize()
void GTP::boardsize()
{
  if(cmd_args.size() > 0){
    if(cmd_int_args[0] != main_goban.set_size(cmd_int_args[0])){
      response[0] = '?';
      response.append("unacceptable size");
    } else {
      go_engine.reset();
    }
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x48, %rdi
callq 0xbfa0
cmpq $0x0, %rax
jbe 0xd100
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movq -0x10(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq %rdi, %rax
addq $0xb8, %rax
movq %rax, -0x20(%rbp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movq -0x20(%rbp), %rdi
cvttss2si (%rax), %esi
callq 0x6920
movss -0x14(%rbp), %xmm0
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jne 0xd0be
jp 0xd0be
jmp 0xd0ee
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x10(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x75cf(%rip), %rsi      # 0x146b6
callq 0x3470
jmp 0xd0fe
movq -0x10(%rbp), %rdi
addq $0xffaa8, %rdi          # imm = 0xFFAA8
callq 0x38f0
jmp 0xd12e
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x10(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x759f(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::komi()
void GTP::komi()
{
  if(cmd_args.size() > 0){
    main_goban.set_komi(cmd_int_args[0]);
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x48, %rdi
callq 0xbfa0
cmpq $0x0, %rax
jbe 0xd1d0
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xb8, %rax
movq %rax, -0x18(%rbp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movq -0x18(%rbp), %rdi
movss (%rax), %xmm0
callq 0xdf70
jmp 0xd1fe
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x10(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x74cf(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::play()
void GTP::play()
{
  int color, coord;
  if(cmd_args.size() > 1){
    color = char_to_color(cmd_args[0]);
    coord = char_to_coordinate(cmd_args[1]);
    
    if(color > -1 && coord > -1){
      //Check legality.
      if(main_goban.play_move(coord, color) == -1){
        response[0] = '?';
        response.append("illegal move");
      } else {
        go_engine.report_move(coord);
      }
    } else {
      response[0] = '?';
      response.append("invalid color or coordinate");
    }
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x48, %rdi
callq 0xbfa0
cmpq $0x1, %rax
jbe 0xd31e
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x9f20
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0x48, %rdi
movl $0x1, %esi
callq 0xdf30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x9ff0
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0xc(%rbp)
jle 0xd2ee
cmpl $-0x1, -0x10(%rbp)
jle 0xd2ee
movq -0x18(%rbp), %rdi
addq $0xb8, %rdi
movl -0x10(%rbp), %esi
cmpl $0x0, -0xc(%rbp)
setne %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x6ef0
cmpl $-0x1, %eax
jne 0xd2d9
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x18(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x7403(%rip), %rsi      # 0x146d5
callq 0x3470
jmp 0xd2ec
movq -0x18(%rbp), %rdi
addq $0xffaa8, %rdi          # imm = 0xFFAA8
movl -0x10(%rbp), %esi
callq 0xdf90
jmp 0xd31c
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x18(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x73cb(%rip), %rsi      # 0x146e2
callq 0x3470
jmp 0xd34c
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x18(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x7381(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::genmove()
void GTP::genmove()
{
  if(cmd_args.size() > 0){
    bool color = char_to_color(cmd_args[0]);
    if(color != main_goban.get_side()){
      main_goban.play_move(0, !color);
      go_engine.report_move(0);
    }
    int move = go_engine.generate_move(early_pass);
    main_goban.play_move(move, color);
    go_engine.report_move(move);
    print_coordinate(move);
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x48, %rdi
callq 0xbfa0
cmpq $0x0, %rax
jbe 0xd494
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x9f20
movq -0x18(%rbp), %rdi
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
addq $0xb8, %rdi
callq 0x45e0
movb %al, %cl
movl -0x1c(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xd43a
movq -0x18(%rbp), %rdi
addq $0xb8, %rdi
movb -0x9(%rbp), %al
xorb $-0x1, %al
xorl %ecx, %ecx
movzbl %al, %edx
andl $0x1, %edx
xorl %esi, %esi
callq 0x6ef0
movq -0x18(%rbp), %rdi
addq $0xffaa8, %rdi          # imm = 0xFFAA8
xorl %esi, %esi
callq 0xdf90
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0xffaa8, %rdi          # imm = 0xFFAA8
movb 0x1(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3c50
movq -0x18(%rbp), %rdi
movl %eax, -0x10(%rbp)
addq $0xb8, %rdi
movl -0x10(%rbp), %esi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x6ef0
movq -0x18(%rbp), %rdi
addq $0xffaa8, %rdi          # imm = 0xFFAA8
movl -0x10(%rbp), %esi
callq 0xdf90
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xa2d0
jmp 0xd4c2
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x18(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x720b(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::fixed_handicap()
void GTP::fixed_handicap()
{
  
  if(cmd_int_args.size() > 0 && cmd_int_args[0] > 1 && cmd_int_args[0] < 10){
    if(main_goban.set_fixed_handicap(cmd_int_args[0]) != cmd_int_args[0]){
    }
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x60, %rdi
callq 0xcb90
cmpq $0x0, %rax
jbe 0xd60e
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movss (%rax), %xmm0
movss 0x70f0(%rip), %xmm1     # 0x14684
ucomiss %xmm1, %xmm0
jbe 0xd60e
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movss 0x70d6(%rip), %xmm0     # 0x14688
ucomiss (%rax), %xmm0
jbe 0xd60e
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xb8, %rax
movq %rax, -0x20(%rbp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movq -0x20(%rbp), %rdi
cvttss2si (%rax), %esi
callq 0x6600
movq -0x10(%rbp), %rdi
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x14(%rbp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movss -0x14(%rbp), %xmm0
ucomiss (%rax), %xmm0
jne 0xd60a
jp 0xd60a
jmp 0xd60c
jmp 0xd60c
jmp 0xd63c
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x10(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x7091(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::level()
void GTP::level()
{
  if(cmd_int_args.size() > 0 && cmd_int_args[0] > 0){
    go_engine.set_playouts(10000*cmd_int_args[0]);
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x60, %rdi
callq 0xcb90
cmpq $0x0, %rax
jbe 0xd6c9
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xd6c9
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xffaa8, %rax          # imm = 0xFFAA8
movq %rax, -0x18(%rbp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movq -0x18(%rbp), %rdi
movss 0x6fd2(%rip), %xmm0     # 0x1468c
mulss (%rax), %xmm0
cvttss2si %xmm0, %esi
callq 0x3960
jmp 0xd6f7
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x10(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x6fd6(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::time_settings()
void GTP::time_settings()
{
  if(cmd_int_args.size() > 2){
    go_engine.set_times(cmd_int_args[0], cmd_int_args[1], cmd_int_args[2]);
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x60, %rdi
callq 0xcb90
cmpq $0x2, %rax
jbe 0xd788
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xffaa8, %rax          # imm = 0xFFAA8
movq %rax, -0x20(%rbp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf50
movq -0x10(%rbp), %rdi
cvttss2si (%rax), %eax
movl %eax, -0x18(%rbp)
addq $0x60, %rdi
movl $0x1, %esi
callq 0xdf50
movq -0x10(%rbp), %rdi
cvttss2si (%rax), %eax
movl %eax, -0x14(%rbp)
addq $0x60, %rdi
movl $0x2, %esi
callq 0xdf50
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
cvttss2si (%rax), %ecx
callq 0x3990
jmp 0xd7b6
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x10(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x6f17(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::kgs_time_settings()
void GTP::kgs_time_settings()
{
  if (cmd_int_args.size() > 3
      && (!cmd_args[0].compare("byoyomi")
          || !cmd_args[0].compare("canadian"))) {
    go_engine.set_times(cmd_int_args[1], cmd_int_args[2], cmd_int_args[3]);
  } else if (cmd_int_args.size() > 1 && !cmd_args[0].compare("absolute")) {
    go_engine.set_times(cmd_int_args[1], 0, 0);
  } else if (cmd_int_args.size() > 0 && !cmd_args[0].compare("none")) {
    go_engine.set_times(30, 0, 0); //To be adjusted.
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x60, %rdi
callq 0xcb90
cmpq $0x3, %rax
jbe 0xd89a
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf30
movq %rax, %rdi
leaq 0x6f0c(%rip), %rsi      # 0x1470e
callq 0x30b0
cmpl $0x0, %eax
je 0xd831
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf30
movq %rax, %rdi
leaq 0x6eef(%rip), %rsi      # 0x14716
callq 0x30b0
cmpl $0x0, %eax
jne 0xd89a
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xffaa8, %rax          # imm = 0xFFAA8
movq %rax, -0x20(%rbp)
addq $0x60, %rdi
movl $0x1, %esi
callq 0xdf50
movq -0x10(%rbp), %rdi
cvttss2si (%rax), %eax
movl %eax, -0x18(%rbp)
addq $0x60, %rdi
movl $0x2, %esi
callq 0xdf50
movq -0x10(%rbp), %rdi
cvttss2si (%rax), %eax
movl %eax, -0x14(%rbp)
addq $0x60, %rdi
movl $0x3, %esi
callq 0xdf50
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
cvttss2si (%rax), %ecx
callq 0x3990
jmp 0xd98c
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xcb90
cmpq $0x1, %rax
jbe 0xd907
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf30
movq %rax, %rdi
leaq 0x6e57(%rip), %rsi      # 0x1471f
callq 0x30b0
cmpl $0x0, %eax
jne 0xd907
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xffaa8, %rax          # imm = 0xFFAA8
movq %rax, -0x28(%rbp)
addq $0x60, %rdi
movl $0x1, %esi
callq 0xdf50
movq -0x28(%rbp), %rdi
cvttss2si (%rax), %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3990
jmp 0xd98a
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xcb90
cmpq $0x0, %rax
jbe 0xd95a
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf30
movq %rax, %rdi
leaq 0x6df3(%rip), %rsi      # 0x14728
callq 0x30b0
cmpl $0x0, %eax
jne 0xd95a
movq -0x10(%rbp), %rdi
addq $0xffaa8, %rdi          # imm = 0xFFAA8
movl $0x1e, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3990
jmp 0xd988
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x10(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x6d45(%rip), %rsi      # 0x146c8
callq 0x3470
jmp 0xd98a
jmp 0xd98c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::time_left()
void GTP::time_left()
{
  if (cmd_args.size() > 2 && cmd_int_args.size() > 1) {
    go_engine.set_times(cmd_int_args[1], cmd_int_args[2]);
  } else {
    response[0] = '?';
    response.append("syntax error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x48, %rdi
callq 0xbfa0
cmpq $0x2, %rax
jbe 0xda20
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xcb90
cmpq $0x1, %rax
jbe 0xda20
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xffaa8, %rax          # imm = 0xFFAA8
movq %rax, -0x20(%rbp)
addq $0x60, %rdi
movl $0x1, %esi
callq 0xdf50
movq -0x10(%rbp), %rdi
cvttss2si (%rax), %eax
movl %eax, -0x14(%rbp)
addq $0x60, %rdi
movl $0x2, %esi
callq 0xdf50
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
cvttss2si (%rax), %edx
callq 0x3a40
jmp 0xda4e
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x10(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x6c7f(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::final_score()
void GTP::final_score()
{
  std::stringstream auxstream;
  float score = go_engine.score(0);
  
  if (score > 0) {
    auxstream << score;
    response.append("B+");
    response.append(auxstream.str());
  } else {
    auxstream << -score;
    response.append("W+");
    response.append(auxstream.str());
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x3190
movq -0x1f8(%rbp), %rdi
addq $0xffaa8, %rdi          # imm = 0xFFAA8
xorl %eax, %eax
movl %eax, %esi
callq 0x4220
movss %xmm0, -0x1ec(%rbp)
jmp 0xdaa7
movss -0x1ec(%rbp), %xmm0
movss %xmm0, -0x194(%rbp)
movss -0x194(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xdb86
leaq -0x180(%rbp), %rdi
movss -0x194(%rbp), %xmm0
callq 0x31b0
jmp 0xdae1
movq -0x1f8(%rbp), %rdi
addq $0x98, %rdi
leaq 0x6c37(%rip), %rsi      # 0x1472d
callq 0x3470
jmp 0xdafd
movq -0x1f8(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x200(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x3260
jmp 0xdb26
movq -0x200(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x3480
jmp 0xdb3b
leaq -0x1c8(%rbp), %rdi
callq 0x3160
jmp 0xdc2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0xdc44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3160
jmp 0xdc44
leaq -0x180(%rbp), %rdi
movaps 0x6afc(%rip), %xmm1     # 0x14690
movss -0x194(%rbp), %xmm0
pxor %xmm1, %xmm0
callq 0x31b0
jmp 0xdba7
movq -0x1f8(%rbp), %rdi
addq $0x98, %rdi
leaq 0x6b74(%rip), %rsi      # 0x14730
callq 0x3470
jmp 0xdbc3
movq -0x1f8(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x208(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x3260
jmp 0xdbec
movq -0x208(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x3480
jmp 0xdc01
leaq -0x1e8(%rbp), %rdi
callq 0x3160
jmp 0xdc2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x3160
jmp 0xdc44
leaq -0x190(%rbp), %rdi
callq 0x31c0
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0x31c0
movq -0x1a0(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: antoniogarro[P]Hara/gtpcommands.cpp
// Function: GTP::final_status_list()
void GTP::final_status_list()
{
  if (cmd_args.size() > 0 && !cmd_args[0].compare("dead")) {
    std::vector<int> list;
    go_engine.score(&list);
    //TODO: support 'alive' status.
    for(std::vector<int>::iterator it = list.begin(); it != list.end(); ++it){
      coord_to_char(*it, response, main_goban.get_size());
      response.append("\n");
    }
  } else {
    response[0] = '?';
    response.append("syntax error");
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x48, %rdi
callq 0xbfa0
cmpq $0x0, %rax
jbe 0xdd8f
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdf30
movq %rax, %rdi
leaq 0x6a91(%rip), %rsi      # 0x14733
callq 0x30b0
cmpl $0x0, %eax
jne 0xdd8f
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xdfc0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0xffaa8, %rdi          # imm = 0xFFAA8
callq 0x4220
jmp 0xdcd3
leaq -0x20(%rbp), %rdi
callq 0x4c00
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4980
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xdfe0
testb $0x1, %al
jne 0xdd03
jmp 0xdd84
leaq -0x38(%rbp), %rdi
callq 0x50f0
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movq %rdi, %rax
addq $0x98, %rax
movq %rax, -0x60(%rbp)
addq $0xb8, %rdi
callq 0x4530
movl %eax, -0x54(%rbp)
jmp 0xdd33
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rsi
movl -0x64(%rbp), %edi
callq 0xddd0
jmp 0xdd44
movq -0x48(%rbp), %rdi
addq $0x98, %rdi
leaq 0x68ce(%rip), %rsi      # 0x14624
callq 0x3470
jmp 0xdd5d
jmp 0xdd5f
leaq -0x38(%rbp), %rdi
callq 0xe020
jmp 0xdce0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe040
jmp 0xddc3
leaq -0x20(%rbp), %rdi
callq 0xe040
jmp 0xddbd
movq -0x48(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34a0
movq -0x48(%rbp), %rdi
movb $0x3f, (%rax)
addq $0x98, %rdi
leaq 0x6910(%rip), %rsi      # 0x146c8
callq 0x3470
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3410
nopl (%rax)