LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc4.cc
// Function: Interpreter::expression()
long Interpreter::expression() {
    long result = factor();

    while (_current_token.type == TOKENTYPE::MUL ||
    _current_token.type == TOKENTYPE::DIV ||
    _current_token.type == TOKENTYPE::PLUS ||
    _current_token.type == TOKENTYPE::MINUS) {
        Token token = _current_token;
        if (token.type == TOKENTYPE::MUL) {
            eat(TOKENTYPE::MUL);
            result *= factor();
        } else if (token.type == TOKENTYPE::DIV) {
            eat(TOKENTYPE::DIV);
            long rhs = factor();
            if (rhs == 0) {
                throw("Division by zero");
            }
            result /= rhs;
        } else if (token.type == TOKENTYPE::PLUS) {
            eat(TOKENTYPE::PLUS);
            result += factor();
        } else if (token.type == TOKENTYPE::MINUS) {
            eat(TOKENTYPE::MINUS);
            result -= factor();
        }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2d00
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movb $0x1, %al
cmpl $0x4, 0x8(%rcx)
movb %al, -0x31(%rbp)
je 0x2be8
movq -0x30(%rbp), %rcx
movb $0x1, %al
cmpl $0x5, 0x8(%rcx)
movb %al, -0x31(%rbp)
je 0x2be8
movq -0x30(%rbp), %rcx
movb $0x1, %al
cmpl $0x2, 0x8(%rcx)
movb %al, -0x31(%rbp)
je 0x2be8
movq -0x30(%rbp), %rax
cmpl $0x3, 0x8(%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2bf4
jmp 0x2cf2
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x4, -0x20(%rbp)
jne 0x2c33
movq -0x30(%rbp), %rdi
movl $0x4, %esi
callq 0x2d40
movq -0x30(%rbp), %rdi
callq 0x2d00
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2ced
cmpl $0x5, -0x20(%rbp)
jne 0x2c95
movq -0x30(%rbp), %rdi
movl $0x5, %esi
callq 0x2d40
movq -0x30(%rbp), %rdi
callq 0x2d00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2c82
movl $0x8, %edi
callq 0x20c0
movq %rax, %rdi
leaq 0x13f8(%rip), %rax      # 0x4067
movq %rax, (%rdi)
movq 0x3337(%rip), %rsi      # 0x5fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
jmp 0x2ceb
cmpl $0x2, -0x20(%rbp)
jne 0x2cbc
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x2d40
movq -0x30(%rbp), %rdi
callq 0x2d00
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2ce9
cmpl $0x3, -0x20(%rbp)
jne 0x2ce7
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x2d40
movq -0x30(%rbp), %rdi
callq 0x2d00
movq %rax, %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x2ce9
jmp 0x2ceb
jmp 0x2ced
jmp 0x2bad
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: m1c0l[P]TCP/server.cpp
// Function: printSend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short, int, int, bool)
void printSend(string pktType, uint16_t seq, int cwnd, int ssThresh, bool isRetransmit) {
	cout << "Sending packet " << seq << " " << cwnd << " " << ssThresh;
	if (isRetransmit) {
		cout << " Retransmission";
	}
	if (pktType != "data") {
		// SYN or FIN
		cout << " " << pktType;
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq 0xac4f(%rip), %rdi      # 0xdfc8
leaq 0x5d06(%rip), %rsi      # 0x9086
callq 0x2260
movq %rax, %rdi
movzwl -0xa(%rbp), %esi
callq 0x23d0
movq %rax, %rdi
leaq 0x5d16(%rip), %rsi      # 0x90b1
callq 0x2260
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x23e0
movq %rax, %rdi
leaq 0x5cfc(%rip), %rsi      # 0x90b1
callq 0x2260
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x23e0
testb $0x1, -0x15(%rbp)
je 0x33de
movq 0xabf6(%rip), %rdi      # 0xdfc8
leaq 0x5cbd(%rip), %rsi      # 0x9096
callq 0x2260
movq -0x20(%rbp), %rdi
leaq 0x5cbd(%rip), %rsi      # 0x90a6
callq 0x53c0
testb $0x1, %al
jne 0x33f4
jmp 0x3413
movq 0xabcd(%rip), %rdi      # 0xdfc8
leaq 0x5caf(%rip), %rsi      # 0x90b1
callq 0x2260
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x2230
movq 0xabae(%rip), %rdi      # 0xdfc8
movl $0xa, %esi
callq 0x22f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/ex-over.cc
// Function: main
int main()
{
	int i = 42;
	char c = 'a';
	compute(i);  // compute(int)
	compute(c);  // compute(int)
	compute(&i); // primerLib::compute(const void*)
	compute(&c); // compute(char*, char*)
	compute(3.4);// compute(double, double)
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2a, -0x8(%rbp)
movb $0x61, -0x9(%rbp)
movl -0x8(%rbp), %edi
callq 0x1220
movsbl -0x9(%rbp), %edi
callq 0x1220
leaq -0x8(%rbp), %rdi
callq 0x11e0
leaq -0x9(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12a0
movsd 0xcdf(%rip), %xmm1      # 0x2008
movaps %xmm1, %xmm0
callq 0x1260
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/scope_levels.cc
// Function: main
int main()
{
	int unique = 0; // unique has block scope

	// output #1: uses global reused; prints 42 0
	std::cout << reused << " " << unique << std::endl;   

	int reused = 0; // new, local object named reused hides global reused

	// output #2: uses local reused; prints 0 0
	std::cout << reused << " " <<  unique << std::endl;  

	// output #3: explicitly requests the global reused; prints 42 0
	std::cout << ::reused << " " <<  unique << std::endl;  

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl 0x2e74(%rip), %esi      # 0x4050
movq 0x2df5(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xe12(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2dbc(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq 0x2db6(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xdd3(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d7d(%rip), %rsi      # 0x3fc8
callq 0x1050
movl 0x2dfa(%rip), %esi      # 0x4050
movq 0x2d7b(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xd98(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d42(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: nightmeng[P]net/examples/http/httptest.cpp
// Function: handle_read(int, int, socket&)
void handle_read(int ec, int transfered, socket &sock){
	std::cout << buff << std::endl;
	bzero(buff, 2048);
	sock.async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
				std::placeholders::_2, std::ref(sock)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq 0x1da2c(%rip), %rdi     # 0x20fc8
leaq 0x1dc5d(%rip), %rsi     # 0x21200
movq %rsi, -0x70(%rbp)
callq 0x31f0
movq %rax, %rdi
movq 0x1d9ea(%rip), %rsi     # 0x20fa0
callq 0x3210
movq -0x70(%rbp), %rdi
movl $0x800, %esi            # imm = 0x800
movq %rsi, -0x68(%rbp)
callq 0x3320
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3e80
movq %rax, -0x48(%rbp)
leaq -0x65(%rip), %rsi       # 0x3580
movq 0x1d9cc(%rip), %rdx     # 0x20fb8
movq 0x1d9fd(%rip), %rcx     # 0x20ff0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x48(%rbp), %r8
callq 0x3e30
movq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3eb0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x6780
jmp 0x362c
leaq -0x30(%rbp), %rdi
callq 0x3f50
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3f50
movq -0x50(%rbp), %rdi
callq 0x3330
nopl (%rax)
// File: tsoding[P]cxx-invert-file-tree/generator.cpp
// Function: main
int main(int argc, char **argv)
{
    if (argc < 2) {
        usage(std::cerr);
        std::cerr << "ERROR: folder path is not provided" << std::endl;
        return 1;
    }

    srand(time(nullptr));

    fs::path folder_path(argv[1]);
    fs::create_directory(folder_path);
    std::cout << "Created Folder: " << folder_path << std::endl;
    generate_tree(folder_path);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x6546
movq 0x5add(%rip), %rdi      # 0xbff0
callq 0x60d0
movq 0x5ad1(%rip), %rdi      # 0xbff0
leaq 0x2b21(%rip), %rsi      # 0x9047
callq 0x3220
movq %rax, %rdi
movq 0x5a8b(%rip), %rsi      # 0xbfc0
callq 0x3260
movl $0x1, -0x4(%rbp)
jmp 0x65f1
xorl %eax, %eax
movl %eax, %edi
callq 0x31f0
movl %eax, %edi
callq 0x3210
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x2, %edx
callq 0x6ac0
movq -0x50(%rbp), %rdi
callq 0x30f0
jmp 0x657b
movq 0x5a4e(%rip), %rdi      # 0xbfd0
leaq 0x2a9e(%rip), %rsi      # 0x9027
callq 0x3220
movq %rax, -0x58(%rbp)
jmp 0x6594
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6990
movq %rax, -0x60(%rbp)
jmp 0x65a7
movq -0x60(%rbp), %rdi
movq 0x5a0e(%rip), %rsi      # 0xbfc0
callq 0x3260
jmp 0x65b9
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x6140
jmp 0x65c8
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6960
jmp 0x65f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6960
jmp 0x65fa
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: antoniogarro[P]Hara/engine.cpp
// Function: Engine::Engine(Goban*)
Engine::Engine(Goban *goban):tree(DEF_TREESIZE, goban), amaf(goban->get_size())
{
  main_goban = goban;
  max_playouts = DEF_PLAYOUTS;
  max_time = 10*CLOCKS_PER_SEC;
  max_time = INFINITE;
  tree_size = DEF_TREESIZE;
  rand_movs = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x1, (%rdi)
movb $0x0, 0x1(%rdi)
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rdx
movl $0x4c4b40, %esi         # imm = 0x4C4B40
callq 0x127f0
movq -0x30(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4530
movl %eax, -0x20(%rbp)
jmp 0x387f
movl -0x20(%rbp), %esi
movq -0x28(%rbp), %rdi
callq 0x4550
jmp 0x388d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0xbb8, 0x14(%rax)      # imm = 0xBB8
movq $0x989680, 0x608(%rax) # imm = 0x989680
movq $0x7fffffff, 0x608(%rax) # imm = 0x7FFFFFFF
movl $0x4c4b40, 0x10(%rax)   # imm = 0x4C4B40
movl $0x0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x128b0
movq -0x18(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: antoniogarro[P]Hara/engine.cpp
// Function: Engine::set_times(int, int, int)
void Engine::set_times(int main_time, int byo_time, int stones)
{
  max_playouts = INFINITE;
  this->byo_time = byo_time;
  if (stones) {
    max_time = (main_time/10 + byo_time/stones)*CLOCKS_PER_SEC;
  } else {
    max_time = (0.9*byo_time + main_time/60)*CLOCKS_PER_SEC;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x7fffffff, 0x14(%rax) # imm = 0x7FFFFFFF
movslq -0x10(%rbp), %rcx
movq %rcx, 0x610(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x39f0
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x10(%rbp), %eax
cltd
idivl -0x14(%rbp)
movl %eax, %edx
movq -0x20(%rbp), %rax
addl %edx, %ecx
movslq %ecx, %rcx
imulq $0xf4240, %rcx, %rcx    # imm = 0xF4240
movq %rcx, 0x608(%rax)
jmp 0x3a32
cvtsi2sdl -0x10(%rbp), %xmm0
movl -0xc(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
cvtsi2sd %ecx, %xmm1
movsd 0x105fe(%rip), %xmm2    # 0x14010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x105e6(%rip), %xmm1    # 0x14008
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x608(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/engine.cpp
// Function: Engine::set_times(int, int)
void Engine::set_times(int time_left, int stones)
{
  max_playouts = INFINITE;
  if (stones) max_time = (0.9*time_left/stones)*CLOCKS_PER_SEC;
  else max_time = (0.9*time_left + byo_time)*CLOCKS_PER_SEC;
  std::cerr << max_time << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x7fffffff, 0x14(%rax) # imm = 0x7FFFFFFF
cmpl $0x0, -0x10(%rbp)
je 0x3a9f
movq -0x18(%rbp), %rax
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x10598(%rip), %xmm0    # 0x14010
mulsd %xmm1, %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x1057b(%rip), %xmm1    # 0x14008
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x608(%rax)
jmp 0x3ad9
movq -0x18(%rbp), %rax
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdq 0x610(%rax), %xmm1
movsd 0x10557(%rip), %xmm2    # 0x14010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x1053f(%rip), %xmm1    # 0x14008
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x608(%rax)
movq -0x18(%rbp), %rax
movq 0x608(%rax), %rsi
movq 0x17505(%rip), %rdi     # 0x1aff0
callq 0x3450
movq %rax, %rdi
leaq 0x10b2a(%rip), %rsi     # 0x14624
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/engine.cpp
// Function: Engine::play_random_game(bool)
int Engine::play_random_game(bool heavy)
{
  int pass = 0;
  main_goban->shuffle_empty();
  while (pass < 2) {
    int move = heavy ? main_goban->play_heavy() : main_goban->play_random();
    amaf.play(move, ++simul_len);
    rand_movs++;
    if (move == Goban::PASS) pass++;
    else pass = 0;
#ifdef DEBUG_INFO
      main_goban->print_goban();
#endif
    int mercy = main_goban->mercy();    
    if (mercy != -1) {
      return 1-mercy;
    }
//#ifdef DEBUG_INFO
    if (simul_len > 2*main_goban->get_size2()) {
      std::cerr << "WARNING: Simulation exceeded max length.\n";
      discarded++;
      return -1;
    }
//#endif
  }
    return (main_goban->chinese_count() > 0) ? 1:0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x4600
cmpl $0x2, -0x18(%rbp)
jge 0x3c24
testb $0x1, -0x11(%rbp)
je 0x3b5e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xe8d0
movl %eax, -0x2c(%rbp)
jmp 0x3b6e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xe880
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq %rax, %rdi
addq $0x50, %rdi
movl -0x1c(%rbp), %esi
movl 0x1c(%rax), %edx
addl $0x1, %edx
movl %edx, 0x1c(%rax)
callq 0x4630
movq -0x28(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
cmpl $0x0, -0x1c(%rbp)
jne 0x3bae
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3bb5
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8580
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
je 0x3bd8
movl $0x1, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c44
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %ecx
movl %ecx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x46c0
movl %eax, %ecx
movl -0x30(%rbp), %eax
shll %ecx
cmpl %ecx, %eax
jle 0x3c1f
movq 0x173f3(%rip), %rdi     # 0x1aff0
leaq 0x10430(%rip), %rsi     # 0x14034
callq 0x3270
movq -0x28(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3c44
jmp 0x3b3c
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8390
xorps %xmm1, %xmm1
xorl %eax, %eax
movl $0x1, %ecx
ucomiss %xmm1, %xmm0
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/engine.cpp
// Function: Engine::back_up_results(int, Node**, int, bool)
void Engine::back_up_results(int result, Node *node_history[], int nnodes, bool side)
{
  for (int i = 0; i < nnodes; i++) {
    node_history[i]->set_results(1-result); //Because root node belongs to opponent.
    node_history[i]->set_amaf(result, amaf, side, i+1);
    side = !side;
    result = 1-result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x411a
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
subl -0xc(%rbp), %esi
callq 0x11ed0
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addq $0x50, %rdx
movb -0x1d(%rbp), %al
movl -0x24(%rbp), %r8d
addl $0x1, %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0x11f10
movb -0x1d(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1d(%rbp)
movl $0x1, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x40ad
addq $0x30, %rsp
popq %rbp
retq
// File: antoniogarro[P]Hara/engine.cpp
// Function: Engine::print_PV() const
void Engine::print_PV() const
{
  fin_clock = clock() - fin_clock;
  tree.print();
  int nplayouts = tree.get_root()->get_visits();
  std::cerr << "#Playouts: " << nplayouts
            << ", average length: " << rand_movs/nplayouts
            << ", discarded: " << discarded << ", playouts/sec: "
            << (float)nplayouts/fin_clock*CLOCKS_PER_SEC << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x3170
movq -0x18(%rbp), %rdi
subq 0x600(%rdi), %rax
movq %rax, 0x600(%rdi)
addq $0x28, %rdi
callq 0x12ee0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x46e0
movq %rax, %rdi
callq 0x4700
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movq 0x16e79(%rip), %rdi     # 0x1aff0
leaq 0xfee0(%rip), %rsi      # 0x1405e
callq 0x3270
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3400
movq %rax, %rdi
leaq 0xfed2(%rip), %rsi      # 0x1406a
callq 0x3270
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %esi
callq 0x3400
movq %rax, %rdi
leaq 0xfec1(%rip), %rsi      # 0x1407d
callq 0x3270
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3400
movq %rax, %rdi
leaq 0xfeb1(%rip), %rsi      # 0x1408b
callq 0x3270
movq %rax, %rdi
movq -0x18(%rbp), %rax
cvtsi2ssl -0xc(%rbp), %xmm0
cvtsi2ssq 0x600(%rax), %xmm1
divss %xmm1, %xmm0
movss 0xfe30(%rip), %xmm1     # 0x14030
mulss %xmm1, %xmm0
callq 0x31b0
movq %rax, %rdi
leaq 0x10411(%rip), %rsi     # 0x14624
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nop
// File: antoniogarro[P]Hara/engine.cpp
// Function: Engine::perft(int)
void Engine::perft(int max)
{
  for (int i = 0; i < max; i++) {
    simul_len = 0;
    play_random_game(LIGHT);
    std::cerr << "restoring\n";
    main_goban->restore();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4529
movq -0x18(%rbp), %rdi
movl $0x0, 0x1c(%rdi)
movb 0x1(%rdi), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3b10
movq 0x16aeb(%rip), %rdi     # 0x1aff0
leaq 0xfb90(%rip), %rsi      # 0x1409c
callq 0x3270
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6540
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x44de
addq $0x20, %rsp
popq %rbp
retq
nop
// File: antoniogarro[P]Hara/./amaf.h
// Function: AmafBoard::play(int, int)
int play(int coord, int depth)  //only for coord <= size2
  {
    if (board[coord] == 0) {
      board[coord] = side ? -depth : depth;
      side = !side;
      return 0;
    } else {
      side = !side; //Careful!
      return -1;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x4696
movq -0x20(%rbp), %rax
testb $0x1, 0x5ac(%rax)
je 0x4667
xorl %eax, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x466d
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %edx
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movb 0x5ac(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x5ac(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x46b3
movq -0x20(%rbp), %rax
movb 0x5ac(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x5ac(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::Goban(int)
Goban::Goban(int newsize)
{
  size = (newsize <= MAXSIZE) ? newsize : size;
  size2 = size*size;
  komi = 0.5;
  clear();
  init_adjacent();
  init_diagonals();
  init_vicinity();
  init_distance();
  init_manhattan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0xb68, %rax            # imm = 0xB68
movq %rax, %rcx
addq $0xd5860, %rcx          # imm = 0xD5860
movq %rcx, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x8b80
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x970, %rax            # imm = 0x970
cmpq %rcx, %rax
movq %rax, -0x18(%rbp)
jne 0x589f
movq -0x28(%rbp), %rdi
addq $0xfc120, %rdi          # imm = 0xFC120
callq 0x7140
movq -0x28(%rbp), %rdi
addq $0xfc6d8, %rdi          # imm = 0xFC6D8
callq 0x7190
movq -0x28(%rbp), %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x134a0
cmpl $0x13, -0xc(%rbp)
jg 0x5901
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x590b
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, 0x8(%rdi)
movl 0x8(%rdi), %eax
imull 0x8(%rdi), %eax
movl %eax, 0xc(%rdi)
movss 0xe79d(%rip), %xmm0     # 0x140c4
movss %xmm0, 0x10(%rdi)
callq 0x5970
movq -0x28(%rbp), %rdi
callq 0x59b0
movq -0x28(%rbp), %rdi
callq 0x5b10
movq -0x28(%rbp), %rdi
callq 0x5cb0
movq -0x28(%rbp), %rdi
callq 0x5f50
movq -0x28(%rbp), %rdi
callq 0x6070
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_adjacent()
void Goban::init_adjacent()
{
  for (int k = 1; k <= size2; k++) {
    int nadj = 0;
    if (k <= size*(size-1)) {  //N
      adjacent[k][nadj++] =  k + size;
    }
    if (k % size) {  //E
      adjacent[k][nadj++] =  k + 1;
    }
    if (k > size) {  //S
      adjacent[k][nadj++] = k - size;
    }
    if (k % size != 1) {  //W
      adjacent[k][nadj++] = k -1;
    }
    adjacent[k][nadj] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jg 0x5aff
movq -0x18(%rbp), %rdx
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl 0x8(%rdx), %ecx
movl 0x8(%rdx), %edx
subl $0x1, %edx
imull %edx, %ecx
cmpl %ecx, %eax
jg 0x5a21
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
addl 0x8(%rax), %edx
addq $0xd63e8, %rax          # imm = 0xD63E8
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cltd
idivl 0x8(%rcx)
cmpl $0x0, %edx
je 0x5a5d
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
addl $0x1, %edx
addq $0xd63e8, %rax          # imm = 0xD63E8
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jle 0x5a95
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
subl 0x8(%rax), %edx
addq $0xd63e8, %rax          # imm = 0xD63E8
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cltd
idivl 0x8(%rcx)
cmpl $0x1, %edx
je 0x5ad1
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
subl $0x1, %edx
addq $0xd63e8, %rax          # imm = 0xD63E8
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0xd63e8, %rax          # imm = 0xD63E8
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x59c7
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_diagonals()
void Goban::init_diagonals()
{

  for (int k = 1; k <= size2; k++) {
    int ndiag = 0;
    if (k <= size*(size-1) && k % size != 1) {  //NW
      diagonals[k][ndiag++] =  k + size - 1;
    }  
    if (k <= size*(size-1) && k % size) {  //NE
      diagonals[k][ndiag++] =  k + size + 1;
    }
    if (k > size && k % size) {  //SE
      diagonals[k][ndiag++] = k - size +1;
    }
    if (k > size && k % size != 1) {  //SW
      diagonals[k][ndiag++] = k - size -1;
    }
    diagonals[k][ndiag] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jg 0x5cae
movq -0x18(%rbp), %rdx
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl 0x8(%rdx), %ecx
movl 0x8(%rdx), %edx
subl $0x1, %edx
imull %edx, %ecx
cmpl %ecx, %eax
jg 0x5b94
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cltd
idivl 0x8(%rcx)
cmpl $0x1, %edx
je 0x5b94
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
addl 0x8(%rax), %edx
subl $0x1, %edx
addq $0xd8030, %rax          # imm = 0xD8030
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %eax
movl 0x8(%rdx), %ecx
movl 0x8(%rdx), %edx
subl $0x1, %edx
imull %edx, %ecx
cmpl %ecx, %eax
jg 0x5bea
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cltd
idivl 0x8(%rcx)
cmpl $0x0, %edx
je 0x5bea
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
addl 0x8(%rax), %edx
addl $0x1, %edx
addq $0xd8030, %rax          # imm = 0xD8030
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jle 0x5c35
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cltd
idivl 0x8(%rcx)
cmpl $0x0, %edx
je 0x5c35
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
subl 0x8(%rax), %edx
addl $0x1, %edx
addq $0xd8030, %rax          # imm = 0xD8030
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jle 0x5c80
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cltd
idivl 0x8(%rcx)
cmpl $0x1, %edx
je 0x5c80
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
subl 0x8(%rax), %edx
subl $0x1, %edx
addq $0xd8030, %rax          # imm = 0xD8030
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0xd8030, %rax          # imm = 0xD8030
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5b27
popq %rbp
retq
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_distance()
void Goban::init_distance()
{
  for (int p = 0; p <= size2; p++) {
    int d = (p-1)%size < (p-1)/size ? (p-1)%size : (p-1)/size;
    if (size - (p-1)%size - 1 < d) {
      d = size - (p-1)%size - 1;
    }
    if (size - (p-1)/size - 1 < d) {
      d = size - (p-1)/size - 1;
    }
    distance_to_edge[p] = d;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jg 0x6069
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl 0x8(%rcx)
movl %edx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl 0x8(%rcx)
movl -0x1c(%rbp), %edx
cmpl %eax, %edx
jge 0x5fae
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl 0x8(%rcx)
movl %edx, %eax
movl %eax, -0x20(%rbp)
jmp 0x5fbf
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl 0x8(%rcx)
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movl 0x8(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl 0x8(%rcx)
movl -0x24(%rbp), %eax
subl %edx, %eax
subl $0x1, %eax
cmpl -0x10(%rbp), %eax
jge 0x6005
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl 0x8(%rcx)
movl -0x28(%rbp), %eax
subl %edx, %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl 0x8(%rcx)
movl %eax, %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
subl $0x1, %eax
cmpl -0x10(%rbp), %eax
jge 0x6049
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl 0x8(%rcx)
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %edx
movslq -0xc(%rbp), %rcx
movl %edx, 0xdf6f8(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5f67
popq %rbp
retq
nopl (%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::reset()
void Goban::reset()
{
  side = BLACK;
  ko_point = 0;
#ifdef ZOBRIST
  zobrist.reset();
#endif
  stones_on_board[BLACK] = 0, stones_on_board[WHITE] = 0;
  last_atari[BLACK] = 0, last_atari[WHITE] = 0;
  last_point = 0, last_point2 = 0;
  
  for (int i = 0; i <= size2; i++) {
    if (Group *point = points[i]) {
      point->clear();
    }
    points[i] = 0;
  }
  empty_points.clear();
  for (int j = 0; j < size2; j++) {
    empty_points.add(j+1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x13830
movq -0x28(%rbp), %rax
movl $0x0, 0xd63c8(%rax)
movl $0x0, 0xd63cc(%rax)
movq $0x0, 0xd63d0(%rax)
movq $0x0, 0xd63d8(%rax)
movl $0x0, 0xd63e0(%rax)
movl $0x0, 0xd63e4(%rax)
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jg 0x64ec
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x64d0
movq -0x18(%rbp), %rdi
callq 0x8de0
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, 0x18(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x64a3
movq -0x28(%rbp), %rdi
addq $0xfc120, %rdi          # imm = 0xFC120
callq 0x71e0
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x6530
movq -0x28(%rbp), %rdi
addq $0xfc120, %rdi          # imm = 0xFC120
movl -0x1c(%rbp), %esi
addl $0x1, %esi
callq 0x7200
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6503
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::restore()
void Goban::restore()
{
  reset();
  set_fixed_handicap(handicap);
  for (int i = 0; i < game_history.length(); i++) {
    if (game_history[i]) {
      drop_stone(game_history[i], side);
      side = !side;
    } else {
      side = !side;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x6430
movq -0x18(%rbp), %rdi
movl 0x14(%rdi), %esi
callq 0x6600
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0xfc6d8, %rdi          # imm = 0xFC6D8
callq 0x7280
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x65f6
movq -0x18(%rbp), %rdi
addq $0xfc6d8, %rdi          # imm = 0xFC6D8
movl -0xc(%rbp), %esi
callq 0x72a0
cmpl $0x0, %eax
je 0x65d8
movq -0x18(%rbp), %rdi
addq $0xfc6d8, %rdi          # imm = 0xFC6D8
movl -0xc(%rbp), %esi
callq 0x72a0
movq -0x18(%rbp), %rdi
movl %eax, %esi
movb (%rdi), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x66e0
movq -0x18(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x65e6
movq -0x18(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x65e8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x656c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::set_fixed_handicap(int)
int Goban::set_fixed_handicap(int newhandicap)
{  //Expects newhandicap belonging to [2, 9].
  handicap = newhandicap;
  if (handicap) {
    switch(size) {
      case 19:
        return set_handicap(handicap19[9 - handicap]);
      case 13:
        return set_handicap(handicap13[9 - handicap]);
      case 9:
        return set_handicap(handicap9[9 - handicap]);
      default:
        return -1;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x14(%rax)
je 0x66c7
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x9, %eax
je 0x6698
jmp 0x6638
movl -0x24(%rbp), %eax
subl $0xd, %eax
je 0x6672
jmp 0x6642
movl -0x24(%rbp), %eax
subl $0x13, %eax
jne 0x66be
jmp 0x664c
movq -0x20(%rbp), %rdi
movl $0x9, %eax
subl 0x14(%rdi), %eax
cltq
leaq 0xda6f(%rip), %rsi      # 0x140d0
imulq $0x24, %rax, %rax
addq %rax, %rsi
callq 0x6880
movl %eax, -0x4(%rbp)
jmp 0x66ce
movq -0x20(%rbp), %rdi
movl $0x9, %eax
subl 0x14(%rdi), %eax
cltq
leaq 0xdb69(%rip), %rsi      # 0x141f0
imulq $0x24, %rax, %rax
addq %rax, %rsi
callq 0x6880
movl %eax, -0x4(%rbp)
jmp 0x66ce
movq -0x20(%rbp), %rdi
movl $0x9, %eax
subl 0x14(%rdi), %eax
cltq
leaq 0xdc63(%rip), %rsi      # 0x14310
imulq $0x24, %rax, %rax
addq %rax, %rsi
callq 0x6880
movl %eax, -0x4(%rbp)
jmp 0x66ce
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66ce
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::drop_stone(int, bool)
int Goban::drop_stone(int point, bool color)
{
  if (points[point] != 0) print_goban();
  
  PointSet<5> liberties;
  point_liberties(point, liberties);
  
  groups[point].set_up(point, color, liberties);
  points[point] = &(groups[point]);
  remove_empty(point);
  stones_on_board[color]++;
#ifdef ZOBRIST
  zobrist.update(point, color);
  zobrist.toggle_ko(ko_point);
#endif
  ko_point = handle_neighbours(point);
#ifdef ZOBRIST
  zobrist.toggle_ko(ko_point);
#endif
  if (points[point]->get_nliberties() == 0) {    //suicide.
      erase_neighbour(points[point]);
  } else if (points[point]->has_one_liberty()) { //self-atari.
    last_atari[color] = points[point] ;
  }
  last_point2 = last_point;
  last_point = point;
  return point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x18(%rax,%rcx,8)
je 0x6713
movq -0x38(%rbp), %rdi
callq 0x8600
leaq -0x30(%rbp), %rdi
callq 0x7340
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x7aa0
movq -0x38(%rbp), %rdi
addq $0xb68, %rdi            # imm = 0xB68
movslq -0xc(%rbp), %rax
imulq $0x970, %rax, %rax      # imm = 0x970
addq %rax, %rdi
movl -0xc(%rbp), %esi
movb -0xd(%rbp), %al
leaq -0x30(%rbp), %rcx
andb $0x1, %al
movzbl %al, %edx
callq 0x8bc0
movq -0x38(%rbp), %rdi
movq %rdi, %rcx
addq $0xb68, %rcx            # imm = 0xB68
movslq -0xc(%rbp), %rax
imulq $0x970, %rax, %rax      # imm = 0x970
addq %rax, %rcx
movslq -0xc(%rbp), %rax
movq %rcx, 0x18(%rdi,%rax,8)
movl -0xc(%rbp), %esi
callq 0x69b0
movq -0x38(%rbp), %rdi
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl 0xd63c8(%rdi,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, 0xd63c8(%rdi,%rax,4)
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
movl -0xc(%rbp), %esi
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x13880
movq -0x38(%rbp), %rax
movq %rax, %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
movl 0x4(%rax), %esi
callq 0x13870
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x69e0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq %rax, %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
movl 0x4(%rax), %esi
callq 0x13870
movq -0x38(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x7380
cmpl $0x0, %eax
jne 0x6822
movq -0x38(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq 0x18(%rdi,%rax,8), %rsi
callq 0x6b70
jmp 0x685a
movq -0x38(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x73a0
testb $0x1, %al
jne 0x683a
jmp 0x6858
movq -0x38(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdx
movb -0xd(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movq %rdx, 0xd63d0(%rax,%rcx,8)
jmp 0x685a
movq -0x38(%rbp), %rax
movl 0xd63e0(%rax), %ecx
movl %ecx, 0xd63e4(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xd63e0(%rax)
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::set_handicap(int const*)
int Goban::set_handicap(const int handicap[])
{  
  for (int i = 0; i < 9 && handicap[i]; i++) {
    drop_stone(handicap[i], BLACK);
#ifdef ZOBRIST
    zobrist.update(handicap[i], 0);
#endif
    }
  side = 1;
#ifdef ZOBRIST
  zobrist.toggle_side();
#endif
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x9, -0x14(%rbp)
movb %al, -0x21(%rbp)
jge 0x68bc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x68c5
jmp 0x6903
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x66e0
movq -0x20(%rbp), %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x13880
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x689f
movq -0x20(%rbp), %rdi
movb $0x1, (%rdi)
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x13860
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::set_size(int)
int Goban::set_size(int newsize)
{
  size = (newsize <= MAXSIZE) ? newsize : size;
  size2 = size*size;
  init_adjacent();
  init_diagonals();
  init_vicinity();
  init_distance();
  init_manhattan();
  clear();
  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x13, -0xc(%rbp)
jg 0x6945
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x694f
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, 0x8(%rdi)
movl 0x8(%rdi), %eax
imull 0x8(%rdi), %eax
movl %eax, 0xc(%rdi)
callq 0x59b0
movq -0x18(%rbp), %rdi
callq 0x5b10
movq -0x18(%rbp), %rdi
callq 0x5cb0
movq -0x18(%rbp), %rdi
callq 0x5f50
movq -0x18(%rbp), %rdi
callq 0x6070
movq -0x18(%rbp), %rdi
callq 0x5970
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::handle_neighbours(int)
int Goban::handle_neighbours(int point)
{
  int captured_lone = 0, ncapt_lone = 0;
  GroupSet<4> neighbours;
  int nneigh = neighbour_groups(point, neighbours);
  
  for (int i = 0; i < nneigh; i++) {
    Group *current_neigh = neighbours[i];
    if (current_neigh->get_color() == points[point]->get_color()) {
      merge_neighbour(point, current_neigh);
    } else {
      if (current_neigh->has_one_liberty()) {
        if (current_neigh->get_nstones() == 1) {  
          ncapt_lone++;
          captured_lone = current_neigh->get_stone(0);
        }
        erase_neighbour(current_neigh);
      } else {
        current_neigh->erase_liberties(point);
        if (current_neigh->has_one_liberty()) {
          last_atari[current_neigh->get_color()] = current_neigh;
        }
      }
    }
  }
  if (ncapt_lone == 1 && points[point]->get_nstones()== 1) {
    return captured_lone;  //new ko point.
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x73c0
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x58(%rbp), %rdx
callq 0x7a10
movl %eax, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jge 0x6b2c
movl -0x60(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x73e0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x7400
movb %al, %cl
movq -0x70(%rbp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x74(%rbp)
movslq -0x14(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x7400
movb %al, %cl
movl -0x74(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x6a91
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x68(%rbp), %rdx
callq 0x6d90
jmp 0x6b1c
movq -0x68(%rbp), %rdi
callq 0x73a0
testb $0x1, %al
jne 0x6aa0
jmp 0x6ad4
movq -0x68(%rbp), %rdi
callq 0x7420
cmpl $0x1, %eax
jne 0x6ac5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x7440
movl %eax, -0x18(%rbp)
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x6b70
jmp 0x6b1a
movq -0x68(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8d40
movq -0x68(%rbp), %rdi
callq 0x73a0
testb $0x1, %al
jne 0x6aef
jmp 0x6b18
movq -0x68(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rdi
callq 0x7400
movq -0x80(%rbp), %rdx
movb %al, %cl
movq -0x70(%rbp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
movq %rdx, 0xd63d0(%rax,%rcx,8)
jmp 0x6b1a
jmp 0x6b1c
jmp 0x6b1e
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x6a2b
cmpl $0x1, -0x1c(%rbp)
jne 0x6b51
movq -0x70(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x7420
cmpl $0x1, %eax
jne 0x6b51
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6b58
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::merge_neighbour(int, Group*)
void Goban::merge_neighbour(int point, Group *neigh)
{
  Group *group = points[point];
  neigh->erase_liberties(point);
  group->attach_group(neigh);
  for (Group::StoneIterator st(neigh);  st; ++st) {
    points[*st] = group;
  }
  neigh->clear();
  if (neigh == last_atari[neigh->get_color()]) {
    last_atari[neigh->get_color()] = 0;
    //merged group may still be in atari, but this case is handled in 'drop_stone()'.
  }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x8d40
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8e30
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x7460
leaq -0x28(%rbp), %rdi
callq 0x74a0
testb $0x1, %al
jne 0x6ded
jmp 0x6e1b
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x74c0
movq -0x38(%rbp), %rdx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq %rdx, 0x18(%rax,%rcx,8)
leaq -0x28(%rbp), %rdi
callq 0x74e0
jmp 0x6dde
movq -0x18(%rbp), %rdi
callq 0x8de0
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7400
movq -0x30(%rbp), %rcx
movb %al, %dl
movq -0x40(%rbp), %rax
andb $0x1, %dl
movzbl %dl, %edx
cmpq 0xd63d0(%rcx,%rdx,8), %rax
jne 0x6e70
movq -0x18(%rbp), %rdi
callq 0x7400
movb %al, %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
movq $0x0, 0xd63d0(%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::play_move(int)
int Goban::play_move(int point)  //this move isn't stored in game_history.
{
  if (point) {
    drop_stone(point, side);
  }
  side = !side;
#ifdef ZOBRIST
  zobrist.toggle_side();
  zobrist.record_key();
#endif
  return point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6eb0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movb (%rdi), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x66e0
movq -0x18(%rbp), %rdi
movb (%rdi), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, (%rdi)
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x13860
movq -0x18(%rbp), %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x13990
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: antoniogarro[P]Hara/goban.cpp
// Function: Goban::play_move(int, bool)
int Goban::play_move(int point, bool color)
{
  if (side != color) {      //two consecutive moves of the same color are 
    game_history.add(PASS); //represented by a pass inbetween.
  }
#ifdef ZOBRIST
  else zobrist.toggle_side();
#endif
  if (point > 0) {
    if (!is_occupied(point) && is_legal(point, color)) {
      drop_stone(point, color);
    } else {
      return  -1;
    }
  } else {
    ko_point = 0;
  }
  side = !color;
  game_history.add(point);
#ifdef ZOBRIST
  zobrist.record_key();
#endif
  //print_goban();
  return point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x15(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x6f36
movq -0x20(%rbp), %rdi
addq $0xfc6d8, %rdi          # imm = 0xFC6D8
xorl %esi, %esi
callq 0x7500
jmp 0x6f46
movq -0x20(%rbp), %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x13860
cmpl $0x0, -0x14(%rbp)
jle 0x6f97
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7560
testb $0x1, %al
jne 0x6f8c
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x8140
testb $0x1, %al
jne 0x6f76
jmp 0x6f8c
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x66e0
jmp 0x6f95
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6fd4
jmp 0x6fa2
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rdi
movb -0x15(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, (%rdi)
addq $0xfc6d8, %rdi          # imm = 0xFC6D8
movl -0x14(%rbp), %esi
callq 0x7500
movq -0x20(%rbp), %rdi
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x13990
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)