LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lemire[P]fastscancount/benchmark/linux-perf-events-wrapper.h
// Function: LinuxEventsWrapper::LinuxEventsWrapper(std::vector<int, std::allocator<int>>)
LinuxEventsWrapper(const std::vector<int> event_codes) {
#ifdef __linux__
      for(int ecode: event_codes) {
        event_obj.emplace(ecode, std::shared_ptr<EventClass>(new EventClass(ecode)));
        event_res.emplace(ecode, 0);
      }
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x9000
movq -0x90(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x88(%rbp)
callq 0x9020
movq -0x80(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9040
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9070
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x90a0
testb $0x1, %al
jne 0x8336
jmp 0x845f
leaq -0x20(%rbp), %rdi
callq 0x90e0
movq %rax, %rcx
movq -0x90(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x2c(%rbp)
movq %rax, -0xa0(%rbp)
movl $0x88, %edi
callq 0x32a0
movq %rax, -0x98(%rbp)
jmp 0x8368
movq -0x98(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x9150
jmp 0x8379
movq -0x98(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x92a0
jmp 0x838b
movq -0xa0(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x9100
movb %dl, -0xa9(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x83ae
movb -0xa9(%rbp), %al
movq -0xa8(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x92d0
movq -0x90(%rbp), %rdi
addq $0x38, %rdi
movl $0x0, -0x64(%rbp)
leaq -0x2c(%rbp), %rsi
leaq -0x64(%rbp), %rdx
callq 0x92f0
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x83f9
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movb %al, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9340
jmp 0x8320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8468
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x88, %esi
callq 0x32b0
jmp 0x8468
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x92d0
jmp 0x8468
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x9360
movq -0x90(%rbp), %rdi
callq 0x9380
movq -0x48(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: lemire[P]fastscancount/benchmark/maropuparser.h
// Function: MaropuGapReader::open()
bool open() {
    close();
    fd = ::fopen(mFilename.c_str(), "rb");
    if (fd == NULL) {
      return false;
    }
    setvbuf(fd, NULL, _IOFBF, 1024 * 4); // large buffer
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xcb10
movq -0x18(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
leaq 0xb706(%rip), %rsi      # 0x14202
callq 0x3310
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x8b19
movb $0x0, -0x1(%rbp)
jmp 0x8b35
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x3040
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: lemire[P]fastscancount/benchmark/linux-perf-events.h
// Function: LinuxEvents<0>::LinuxEvents(int)
LinuxEvents(int config) : fd(0) {
        memset(&attribs, 0, sizeof(attribs));
        attribs.type        = TYPE;
        attribs.size        = sizeof(attribs);
        attribs.config      = config;
        attribs.disabled        = 1;
        attribs.exclude_kernel  = 1;
        attribs.exclude_hv      = 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x0, (%rdi)
addq $0x8, %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3180
movq -0x60(%rbp), %rsi
movl $0x0, 0x8(%rsi)
movl $0x80, 0xc(%rsi)
movslq -0xc(%rbp), %rax
movq %rax, 0x10(%rsi)
movq 0x30(%rsi), %rax
andq $-0x2, %rax
orq $0x1, %rax
movq %rax, 0x30(%rsi)
movq 0x30(%rsi), %rax
andq $-0x21, %rax
orq $0x20, %rax
movq %rax, 0x30(%rsi)
movq 0x30(%rsi), %rax
andq $-0x41, %rax
orq $0x40, %rax
movq %rax, 0x30(%rsi)
movl $0x0, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x20(%rbp)
addq $0x8, %rsi
movl $0x12a, %edi            # imm = 0x12A
xorl %edx, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
movl %r8d, %ecx
movb $0x0, %al
callq 0x3060
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
cmpl $-0x1, (%rax)
jne 0x9286
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3480
movq -0x68(%rbp), %rdx
leaq 0xafc8(%rip), %rsi      # 0x141f2
leaq -0x40(%rbp), %rdi
callq 0x8660
jmp 0x9235
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xaca0
jmp 0x9244
leaq -0x40(%rbp), %rdi
callq 0x31b0
leaq -0x41(%rbp), %rdi
callq 0x32e0
jmp 0x9286
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x927b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31b0
leaq -0x41(%rbp), %rdi
callq 0x32e0
jmp 0x928c
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
nop
// File: lemire[P]fastscancount/benchmark/linux-perf-events-wrapper.h
// Function: LinuxEventsWrapper::start()
void start() {
#ifdef __linux__
      for (const auto& [ecode, ptr]: event_obj) {
        ptr->start();  
      }
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11490
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x114c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x114f0
testb $0x1, %al
jne 0x11331
jmp 0x11374
leaq -0x18(%rbp), %rdi
callq 0x11520
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa370
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11550
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x11570
movq %rax, %rdi
callq 0x11590
leaq -0x18(%rbp), %rdi
callq 0x116e0
jmp 0x1131e
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lemire[P]fastscancount/benchmark/linux-perf-events-wrapper.h
// Function: LinuxEventsWrapper::end()
void end() {
#ifdef __linux__
      for (const auto& [ecode, ptr]: event_obj) {
        event_res[ecode] = ptr->end();  
      }
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11490
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x114c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x114f0
testb $0x1, %al
jne 0x113c5
jmp 0x11424
leaq -0x18(%rbp), %rdi
callq 0x11520
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa370
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11550
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x11570
movq %rax, %rdi
callq 0x11800
movq -0x40(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x38, %rdi
movq -0x30(%rbp), %rsi
callq 0x11950
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x116e0
jmp 0x113b2
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lemire[P]fastscancount/benchmark/linux-perf-events.h
// Function: LinuxEvents<0>::start()
void start() {
        if (ioctl(fd, PERF_EVENT_IOC_RESET, 0) == -1) {
            report_error("ioctl(PERF_EVENT_IOC_RESET)");
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl (%rax), %edi
movl $0x2403, %esi           # imm = 0x2403
xorl %edx, %edx
movb $0x0, %al
callq 0x3370
cmpl $-0x1, %eax
jne 0x11633
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3480
movq -0x78(%rbp), %rdx
leaq 0x2d3d(%rip), %rsi      # 0x14311
leaq -0x28(%rbp), %rdi
callq 0x8660
jmp 0x115df
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaca0
jmp 0x115ee
leaq -0x28(%rbp), %rdi
callq 0x31b0
leaq -0x29(%rbp), %rdi
callq 0x32e0
jmp 0x11633
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11625
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31b0
leaq -0x29(%rbp), %rdi
callq 0x32e0
jmp 0x116c9
movq -0x70(%rbp), %rax
movl (%rax), %edi
movl $0x2400, %esi           # imm = 0x2400
xorl %edx, %edx
movb $0x0, %al
callq 0x3370
cmpl $-0x1, %eax
jne 0x116c0
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3480
movq -0x80(%rbp), %rdx
leaq 0x2cc9(%rip), %rsi      # 0x1432d
leaq -0x60(%rbp), %rdi
callq 0x8660
jmp 0x1166f
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xaca0
jmp 0x1167e
leaq -0x60(%rbp), %rdi
callq 0x31b0
leaq -0x61(%rbp), %rdi
callq 0x32e0
jmp 0x116c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x116b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31b0
leaq -0x61(%rbp), %rdi
callq 0x32e0
jmp 0x116c9
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lemire[P]fastscancount/benchmark/linux-perf-events.h
// Function: LinuxEvents<0>::end()
unsigned long end() {
        if (ioctl(fd, PERF_EVENT_IOC_DISABLE, 0) == -1) {
            report_error("ioctl(PERF_EVENT_IOC_DISABLE)");
        }

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

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl (%rax), %edi
movl $0x2401, %esi           # imm = 0x2401
xorl %edx, %edx
movb $0x0, %al
callq 0x3370
cmpl $-0x1, %eax
jne 0x118a3
leaq -0x29(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3480
movq -0x80(%rbp), %rdx
leaq 0x2b06(%rip), %rsi      # 0x1434a
leaq -0x28(%rbp), %rdi
callq 0x8660
jmp 0x1184f
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaca0
jmp 0x1185e
leaq -0x28(%rbp), %rdi
callq 0x31b0
leaq -0x29(%rbp), %rdi
callq 0x32e0
jmp 0x118a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31b0
leaq -0x29(%rbp), %rdi
callq 0x32e0
jmp 0x11944
movq -0x78(%rbp), %rax
movl (%rax), %edi
leaq -0x48(%rbp), %rsi
movl $0x8, %edx
callq 0x3380
cmpq $-0x1, %rax
jne 0x11937
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3480
movq -0x88(%rbp), %rdx
leaq 0x2a8d(%rip), %rsi      # 0x14368
leaq -0x68(%rbp), %rdi
callq 0x8660
jmp 0x118e6
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xaca0
jmp 0x118f5
leaq -0x68(%rbp), %rdi
callq 0x31b0
leaq -0x69(%rbp), %rdi
callq 0x32e0
jmp 0x11937
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1192c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31b0
leaq -0x69(%rbp), %rdi
callq 0x32e0
jmp 0x11944
movq -0x48(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: tewalds[P]pentagod/./gtp.h
// Function: GTPclient::run()
bool run(){
		running = true;
		char buf[1001];

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

			trim(line);

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

			GTPResponse response = cmd(line);

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

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

// Assembly:
subq $0x4e8, %rsp            # imm = 0x4E8
movq %rdi, 0x4e0(%rsp)
movq 0x4e0(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x1, 0x34(%rax)
movq 0x28(%rsp), %rcx
xorl %eax, %eax
testb $0x1, 0x34(%rcx)
movb %al, 0x27(%rsp)
je 0x9156
movq 0x28(%rsp), %rax
leaq 0xf0(%rsp), %rdi
movq (%rax), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x45c0
cmpq $0x0, %rax
setne %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x9163
jmp 0x9386
leaq 0xcf(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4670
movq 0x18(%rsp), %rdx
leaq 0xd0(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x44d0
jmp 0x9191
leaq 0xcf(%rsp), %rdi
callq 0x43f0
leaq 0xd0(%rsp), %rdi
callq 0x1e970
jmp 0x91ad
leaq 0xd0(%rsp), %rdi
callq 0x4570
cmpq $0x0, %rax
je 0x91e5
xorl %eax, %eax
movl %eax, %esi
leaq 0xd0(%rsp), %rdi
callq 0x4720
movq %rax, 0x10(%rsp)
jmp 0x91d8
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x9234
movl $0x2, 0xb8(%rsp)
jmp 0x9349
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xcf(%rsp), %rdi
callq 0x43f0
jmp 0x9398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x9377
leaq 0x50(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x4170
jmp 0x9248
movq 0x28(%rsp), %rsi
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x8bc0
jmp 0x925e
leaq 0x50(%rsp), %rdi
callq 0x4210
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9334
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x10c00
jmp 0x9289
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4160
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x4570
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x4700
jmp 0x92c2
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4430
jmp 0x92d2
leaq 0x30(%rsp), %rdi
callq 0x4210
jmp 0x9334
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4210
jmp 0x9377
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x936d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4210
jmp 0x936d
leaq 0x70(%rsp), %rdi
callq 0x9090
movl $0x0, 0xb8(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x4210
movl 0xb8(%rsp), %eax
testl %eax, %eax
je 0x9368
jmp 0x9363
jmp 0x9120
jmp 0x9120
leaq 0x70(%rsp), %rdi
callq 0x9090
leaq 0xd0(%rsp), %rdi
callq 0x4210
jmp 0x9398
movq 0x28(%rsp), %rax
movb 0x34(%rax), %al
andb $0x1, %al
addq $0x4e8, %rsp            # imm = 0x4E8
retq
movq 0xc0(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]pentagod/./pentagogtp.h
// Function: TimeControl::TimeControl()
TimeControl(){
		method   = STATS;
		param    = 2;
		game     = 0;
		move     = 5;
		flexible = true;
		max_sims = 0;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x2, (%rax)
vmovsd 0x33a58(%rip), %xmm0    # 0x3d020
vmovsd %xmm0, 0x8(%rax)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rax)
vmovsd 0x33a3a(%rip), %xmm0    # 0x3d018
vmovsd %xmm0, 0x18(%rax)
movb $0x1, 0x20(%rax)
movl $0x0, 0x24(%rax)
retq
nop
// File: tewalds[P]pentagod/./gtp.h
// Function: GTPclient::gtp_logfile(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse gtp_logfile(vecstr args){
		if(args.size() != 1)
			return GTPResponse(false, "Wrong number of arguments");

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

		setlogfile(fd);

		return GTPResponse(true);
	}

// Assembly:
subq $0xe8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, %rax
movq 0x28(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rax, %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x40(%rsp)
callq 0xcbe0
cmpq $0x1, %rax
je 0xafc0
leaq 0xaf(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4670
movq 0x20(%rsp), %rdx
leaq 0x32a3a(%rip), %rsi     # 0x3d96d
leaq 0xb0(%rsp), %rdi
callq 0x44d0
jmp 0xaf42
movq 0x30(%rsp), %rdi
xorl %esi, %esi
leaq 0xb0(%rsp), %rdx
callq 0xb680
jmp 0xaf58
leaq 0xb0(%rsp), %rdi
callq 0x4210
leaq 0xaf(%rsp), %rdi
callq 0x43f0
jmp 0xb10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xafae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x4210
leaq 0xaf(%rsp), %rdi
callq 0x43f0
jmp 0xb11c
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcc00
movq %rax, %rdi
callq 0x4160
movq %rax, %rdi
leaq 0x33c52(%rip), %rsi     # 0x3ec32
callq 0x4440
movq %rax, 0x90(%rsp)
cmpq $0x0, 0x90(%rsp)
jne 0xb06a
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, 0x14(%rsp)
movl %eax, %esi
callq 0xcc00
movq %rax, %rdx
leaq 0x32973(%rip), %rsi     # 0x3d987
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9440
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xb680
jmp 0xb038
leaq 0x70(%rsp), %rdi
callq 0x4210
jmp 0xb10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4210
jmp 0xb11c
movq 0x40(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x9400
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4670
movq 0x8(%rsp), %rdx
leaq 0x32a1a(%rip), %rsi     # 0x3dab1
leaq 0x50(%rsp), %rdi
callq 0x44d0
jmp 0xb0a3
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x50(%rsp), %rdx
callq 0xb680
jmp 0xb0b9
leaq 0x50(%rsp), %rdi
callq 0x4210
leaq 0x4f(%rsp), %rdi
callq 0x43f0
jmp 0xb10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xb103
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4210
leaq 0x4f(%rsp), %rdi
callq 0x43f0
jmp 0xb11c
movq 0x38(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0xa0(%rsp), %rdi
callq 0x4660
nopl (%rax)
// File: tewalds[P]pentagod/./game.h
// Function: Game::getboard(int) const
Board getboard(int offset = 0) const {
		Board board;
		if(offset <= 0)
			offset += hist.size();
		for(int i = 0; i < offset; i++)
			board.move(hist[i]);
		return board;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0xcfe0
cmpl $0x0, 0x2c(%rsp)
jg 0xcf89
movq 0x18(%rsp), %rdi
callq 0xd020
movq %rax, %rcx
movslq 0x2c(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0xcfcb
movq 0x18(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xd250
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %esi
callq 0xd040
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xcf91
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]pentagod/./board.h
// Function: Board::Board()
Board(){
		sides[0] = 0;
		sides[1] = 0;
		sides[2] = 0;
		nummoves = 0;
		to_play = 1;
		outcome = -4;
		orientation = 8;
		cached_score = default_score;
		cached_hash = 0;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
movb $0x1, 0x19(%rax)
movb $-0x4, 0x1a(%rax)
movb $0x8, 0x1b(%rax)
movw $0xdead, 0x1c(%rax)     # imm = 0xDEAD
movq $0x0, 0x20(%rax)
retq
// File: tewalds[P]pentagod/./board.h
// Function: Board::full_hash() const
uint64_t full_hash() const {
		//make sure this matches Move::rotate
		Board b(*this);

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

		orientation = o;
		return m;
	}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x28, %edx
callq 0x4300
movq $-0x1, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdbd0
movq %rax, %rsi
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
xorl %ecx, %ecx
callq 0xdd00
movq 0x20(%rsp), %rdi
callq 0xdd40
movq %rax, %rsi
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
movl $0x1, %ecx
callq 0xdd00
movq 0x20(%rsp), %rdi
callq 0xdd40
movq %rax, %rsi
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
movl $0x2, %ecx
callq 0xdd00
movq 0x20(%rsp), %rdi
callq 0xdd40
movq %rax, %rsi
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
movl $0x3, %ecx
callq 0xdd00
leaq 0x28(%rsp), %rdi
callq 0xdd70
leaq 0x28(%rsp), %rdi
callq 0xdbd0
movq %rax, %rsi
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
movl $0x4, %ecx
callq 0xdd00
movq 0x20(%rsp), %rdi
callq 0xdd40
movq %rax, %rsi
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
movl $0x5, %ecx
callq 0xdd00
movq 0x20(%rsp), %rdi
callq 0xdd40
movq %rax, %rsi
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
movl $0x6, %ecx
callq 0xdd00
movq 0x20(%rsp), %rdi
callq 0xdd40
movq %rax, %rsi
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
movl $0x7, %ecx
callq 0xdd00
movq 0x8(%rsp), %rax
movb 0x17(%rsp), %cl
movb %cl, 0x1b(%rax)
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]pentagod/./board.h
// Function: Board::simple_hash() const
uint64_t simple_hash() const {
		//Take 9 bits at a time from each player, merge them, convert to base 2
		//results in a 60 bit hash when only 48 bits are needed, but much more efficient to compute
		uint64_t h = 0;
		uint64_t w = sides[1] << 9;
		uint64_t b = sides[2];
		h |= ((uint64_t)(lookup3to2[((w & (0x1FFull <<  9)) | (b & (0x1FFull <<  0))) >>  0])) <<  0;
		h |= ((uint64_t)(lookup3to2[((w & (0x1FFull << 18)) | (b & (0x1FFull <<  9))) >>  9])) << 15;
		h |= ((uint64_t)(lookup3to2[((w & (0x1FFull << 27)) | (b & (0x1FFull << 18))) >> 18])) << 30;
		h |= ((uint64_t)(lookup3to2[((w & (0x1FFull << 36)) | (b & (0x1FFull << 27))) >> 27])) << 45;
		orientation = 8;
		return h;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, -0x10(%rsp)
movq 0x8(%rax), %rcx
shlq $0x9, %rcx
movq %rcx, -0x18(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rsp)
leaq 0x42b68(%rip), %rcx     # 0x50768
movq (%rcx), %rcx
movq -0x18(%rsp), %rdx
andq $0x3fe00, %rdx          # imm = 0x3FE00
movq -0x20(%rsp), %rsi
andq $0x1ff, %rsi            # imm = 0x1FF
orq %rsi, %rdx
shrq $0x0, %rdx
movzwl (%rcx,%rdx,2), %ecx
shlq $0x0, %rcx
orq -0x10(%rsp), %rcx
movq %rcx, -0x10(%rsp)
leaq 0x42b2d(%rip), %rcx     # 0x50768
movq (%rcx), %rcx
movq -0x18(%rsp), %rdx
andq $0x7fc0000, %rdx        # imm = 0x7FC0000
movq -0x20(%rsp), %rsi
andq $0x3fe00, %rsi          # imm = 0x3FE00
orq %rsi, %rdx
shrq $0x9, %rdx
movzwl (%rcx,%rdx,2), %ecx
shlq $0xf, %rcx
orq -0x10(%rsp), %rcx
movq %rcx, -0x10(%rsp)
leaq 0x42af2(%rip), %rcx     # 0x50768
movq (%rcx), %rcx
movabsq $0xff8000000, %rdx      # imm = 0xFF8000000
andq -0x18(%rsp), %rdx
movq -0x20(%rsp), %rsi
andq $0x7fc0000, %rsi        # imm = 0x7FC0000
orq %rsi, %rdx
shrq $0x12, %rdx
movzwl (%rcx,%rdx,2), %ecx
shlq $0x1e, %rcx
orq -0x10(%rsp), %rcx
movq %rcx, -0x10(%rsp)
leaq 0x42ab4(%rip), %rcx     # 0x50768
movq (%rcx), %rcx
movabsq $0x1ff000000000, %rdx   # imm = 0x1FF000000000
andq -0x18(%rsp), %rdx
movabsq $0xff8000000, %rsi      # imm = 0xFF8000000
andq -0x20(%rsp), %rsi
orq %rsi, %rdx
shrq $0x1b, %rdx
movzwl (%rcx,%rdx,2), %ecx
shlq $0x2d, %rcx
orq -0x10(%rsp), %rcx
movq %rcx, -0x10(%rsp)
movb $0x8, 0x1b(%rax)
movq -0x10(%rsp), %rax
retq
nopl (%rax,%rax)
// File: tewalds[P]pentagod/./board.h
// Function: Board::flip_side(unsigned long)
static uint64_t flip_side(uint64_t b){ // flip one player
		//starting pattern
		// 0  1  2 15 16  9
		// 7  8  3 14 17 10
		// 6  5  4 13 12 11
		//shifted down by 9
		// 0  1  2  6  7  0
		// 7  8  3  5  8  1
		// 6  5  4  4  3  2
		//linearized pattern from:to
		// 0  1  2  3  4  5  6  7  8
		// 0  7  6  5  4  3  2  1  8

		//flip along a diagonal axis
		//make sure this matches Move::rotate
		return (flipquad[(b & (0x1FFull <<  0)) >>  0] <<  0) |
		       (flipquad[(b & (0x1FFull <<  9)) >>  9] << 27) |
		       (flipquad[(b & (0x1FFull << 18)) >> 18] << 18) |
		       (flipquad[(b & (0x1FFull << 27)) >> 27] <<  9);
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
andq $0x1ff, %rcx            # imm = 0x1FF
shrq $0x0, %rcx
leaq 0x31394(%rip), %rax     # 0x3f170
movq (%rax,%rcx,8), %rax
shlq $0x0, %rax
movq -0x8(%rsp), %rdx
andq $0x3fe00, %rdx          # imm = 0x3FE00
shrq $0x9, %rdx
leaq 0x31375(%rip), %rcx     # 0x3f170
movq (%rcx,%rdx,8), %rcx
shlq $0x1b, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rdx
andq $0x7fc0000, %rdx        # imm = 0x7FC0000
shrq $0x12, %rdx
leaq 0x31353(%rip), %rcx     # 0x3f170
movq (%rcx,%rdx,8), %rcx
shlq $0x12, %rcx
orq %rcx, %rax
movabsq $0xff8000000, %rdx      # imm = 0xFF8000000
andq -0x8(%rsp), %rdx
shrq $0x1b, %rdx
leaq 0x3132e(%rip), %rcx     # 0x3f170
movq (%rcx,%rdx,8), %rcx
shlq $0x9, %rcx
orq %rcx, %rax
retq
nop
// File: tewalds[P]pentagod/./gtp.h
// Function: GTPclient::find_callback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int find_callback(const string & name){
		for(unsigned int i = 0; i < callbacks.size(); i++)
			if(callbacks[i].name == name)
				return i;
		return -1;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0xb640
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xfea4
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xb660
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x105d0
testb $0x1, %al
jne 0xfe8b
jmp 0xfe95
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xfeac
jmp 0xfe97
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xfe40
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]pentagod/fileio.cpp
// Function: eat_whitespace(_IO_FILE*)
void eat_whitespace(FILE * fd){
	int c = fgetc(fd);
	while(c == ' ' || c == '\n')
		c = fgetc(fd);
	ungetc(c, fd);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45a0
movl %eax, 0xc(%rsp)
movb $0x1, %al
cmpl $0x20, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x12a70
cmpl $0xa, 0xc(%rsp)
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x12a7a
jmp 0x12a8a
movq 0x10(%rsp), %rdi
callq 0x45a0
movl %eax, 0xc(%rsp)
jmp 0x12a57
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x4090
addq $0x18, %rsp
retq
nopl (%rax)
// File: tewalds[P]pentagod/gtpgeneral.cpp
// Function: PentagoGTP::gtp_mcts(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse PentagoGTP::gtp_mcts(vecstr args){
	delete agent;
	agent = new AgentMCTS();
	agent->set_board(game.getboard());
	return GTPResponse(true);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x90(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x12c36
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0xb68, %edi            # imm = 0xB68
callq 0x43b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x2abc0
jmp 0x12c52
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rax
movq %rax, 0x90(%rsi)
movq 0x90(%rsi), %rax
movq %rax, (%rsp)
addq $0x38, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
callq 0xcf40
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl $0x1, %edx
callq *%rax
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4670
movq 0x10(%rsp), %rdx
leaq 0x2adfc(%rip), %rsi     # 0x3dab1
leaq 0x48(%rsp), %rdi
callq 0x44d0
jmp 0x12cc1
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x48(%rsp), %rdx
callq 0xb680
jmp 0x12cd7
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0x47(%rsp), %rdi
callq 0x43f0
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x4360
jmp 0x12d56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x12d4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0x47(%rsp), %rdi
callq 0x43f0
movq 0x98(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/gtpgeneral.cpp
// Function: PentagoGTP::gtp_pns(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse PentagoGTP::gtp_pns(vecstr args){
	delete agent;
	agent = new AgentPNS();
	agent->set_board(game.getboard());
	return GTPResponse(true);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x90(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x12dc6
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0xb00, %edi            # imm = 0xB00
callq 0x43b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x153a0
jmp 0x12de2
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rax
movq %rax, 0x90(%rsi)
movq 0x90(%rsi), %rax
movq %rax, (%rsp)
addq $0x38, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
callq 0xcf40
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl $0x1, %edx
callq *%rax
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4670
movq 0x10(%rsp), %rdx
leaq 0x2ac6c(%rip), %rsi     # 0x3dab1
leaq 0x48(%rsp), %rdi
callq 0x44d0
jmp 0x12e51
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x48(%rsp), %rdx
callq 0xb680
jmp 0x12e67
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0x47(%rsp), %rdi
callq 0x43f0
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x4360
jmp 0x12ee6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x12edc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0x47(%rsp), %rdi
callq 0x43f0
movq 0x98(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/gtpgeneral.cpp
// Function: PentagoGTP::gtp_ab(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse PentagoGTP::gtp_ab(vecstr args){
	delete agent;
	agent = new AgentAB();
	agent->set_board(game.getboard());
	return GTPResponse(true);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x90(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x12f56
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x70, %edi
callq 0x43b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x15540
jmp 0x12f72
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rax
movq %rax, 0x90(%rsi)
movq 0x90(%rsi), %rax
movq %rax, (%rsp)
addq $0x38, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
callq 0xcf40
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl $0x1, %edx
callq *%rax
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4670
movq 0x10(%rsp), %rdx
leaq 0x2aadc(%rip), %rsi     # 0x3dab1
leaq 0x48(%rsp), %rdi
callq 0x44d0
jmp 0x12fe1
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x48(%rsp), %rdx
callq 0xb680
jmp 0x12ff7
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0x47(%rsp), %rdi
callq 0x43f0
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x4360
jmp 0x13076
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x1306c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0x47(%rsp), %rdi
callq 0x43f0
movq 0x98(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/gtpgeneral.cpp
// Function: PentagoGTP::gtp_clearboard(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse PentagoGTP::gtp_clearboard(vecstr args){
	game.clear();
	set_board();

	time_remain = time.game;

	log("clear_board");
	return GTPResponse(true);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x38, %rdi
callq 0x15a00
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xa540
movq 0x20(%rsp), %rax
vmovsd 0x68(%rax), %xmm0
vmovsd %xmm0, 0x80(%rax)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4670
movq 0x28(%rsp), %rdx
leaq 0x29d70(%rip), %rsi     # 0x3d4de
leaq 0x70(%rsp), %rdi
callq 0x44d0
jmp 0x1377a
movq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xcc20
jmp 0x1378b
leaq 0x70(%rsp), %rdi
callq 0x4210
leaq 0x6f(%rsp), %rdi
callq 0x43f0
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4670
movq 0x8(%rsp), %rdx
leaq 0x2a2f7(%rip), %rsi     # 0x3dab1
leaq 0x38(%rsp), %rdi
callq 0x44d0
jmp 0x137c6
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x38(%rsp), %rdx
callq 0xb680
jmp 0x137dc
leaq 0x38(%rsp), %rdi
callq 0x4210
leaq 0x37(%rsp), %rdi
callq 0x43f0
movq 0x18(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x13825
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4210
leaq 0x6f(%rsp), %rdi
callq 0x43f0
jmp 0x13863
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x13859
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4210
leaq 0x37(%rsp), %rdi
callq 0x43f0
movq 0x60(%rsp), %rdi
callq 0x4660
nopl (%rax)
// File: tewalds[P]pentagod/gtpgeneral.cpp
// Function: PentagoGTP::gtp_all_legal(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse PentagoGTP::gtp_all_legal(vecstr args){
	string ret;
	for(MoveIterator move(game.getboard()); !move.done(); ++move)
		ret += move->to_s() + " ";
	return GTPResponse(true, ret);
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x44e0
movq 0x20(%rsp), %rsi
addq $0x38, %rsi
leaq 0x98(%rsp), %rdi
xorl %edx, %edx
callq 0xcf40
jmp 0x13bb0
leaq 0xc0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15b10
jmp 0x13bcc
jmp 0x13bce
leaq 0xc0(%rsp), %rdi
callq 0x15c80
movb %al, 0xf(%rsp)
jmp 0x13be1
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13c2f
leaq 0xc0(%rsp), %rdi
callq 0x15e30
jmp 0x13cf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x13d61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x13ce6
leaq 0xc0(%rsp), %rdi
callq 0x15ca0
movq %rax, (%rsp)
jmp 0x13c42
movq (%rsp), %rsi
leaq 0x48(%rsp), %rdi
xorl %edx, %edx
callq 0xdec0
jmp 0x13c54
leaq 0x2cb62(%rip), %rdx     # 0x407bd
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93b0
jmp 0x13c6c
leaq 0x110(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4490
jmp 0x13c80
leaq 0x68(%rsp), %rdi
callq 0x4210
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0xc0(%rsp), %rdi
callq 0x15cb0
jmp 0x13ca3
jmp 0x13bce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x13cdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4210
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0xc0(%rsp), %rdi
callq 0x15e30
jmp 0x13d61
leaq 0x28(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x4170
jmp 0x13d09
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
callq 0xb680
jmp 0x13d1f
leaq 0x28(%rsp), %rdi
callq 0x4210
leaq 0x110(%rsp), %rdi
callq 0x4210
movq 0x18(%rsp), %rax
addq $0x148, %rsp            # imm = 0x148
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4210
leaq 0x110(%rsp), %rdi
callq 0x4210
movq 0x90(%rsp), %rdi
callq 0x4660
nopl (%rax,%rax)
// File: tewalds[P]pentagod/gtpgeneral.cpp
// Function: PentagoGTP::gtp_history(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse PentagoGTP::gtp_history(vecstr args){
	string ret;
	vector<Move> hist = game.get_hist();
	for(unsigned int i = 0; i < hist.size(); i++)
		ret += hist[i].to_s() + " ";
	return GTPResponse(true, ret);
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x44e0
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x15e50
movq %rax, 0x20(%rsp)
jmp 0x13ddb
movq 0x20(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x15e60
jmp 0x13def
movl $0x0, 0x88(%rsp)
movl 0x88(%rsp), %eax
movq %rax, (%rsp)
leaq 0x98(%rsp), %rdi
callq 0xd020
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x13f11
movl 0x88(%rsp), %eax
movl %eax, %esi
leaq 0x98(%rsp), %rdi
callq 0x15f60
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
xorl %edx, %edx
callq 0xdec0
jmp 0x13e49
leaq 0x2c96d(%rip), %rdx     # 0x407bd
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93b0
jmp 0x13e61
leaq 0xb0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4490
jmp 0x13e75
leaq 0x68(%rsp), %rdi
callq 0x4210
leaq 0x48(%rsp), %rdi
callq 0x4210
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x13dfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x13f97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x13f8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x13f05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4210
leaq 0x48(%rsp), %rdi
callq 0x4210
jmp 0x13f8a
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x4170
jmp 0x13f25
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
callq 0xb680
jmp 0x13f3b
leaq 0x28(%rsp), %rdi
callq 0x4210
leaq 0x98(%rsp), %rdi
callq 0xfb50
leaq 0xb0(%rsp), %rdi
callq 0x4210
movq 0x10(%rsp), %rax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4210
leaq 0x98(%rsp), %rdi
callq 0xfb50
leaq 0xb0(%rsp), %rdi
callq 0x4210
movq 0x90(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/gtpgeneral.cpp
// Function: PentagoGTP::gtp_playgame(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse PentagoGTP::gtp_playgame(vecstr args){
	GTPResponse ret(true);

	for(unsigned int i = 0; ret.success && i < args.size(); i++)
		ret = play(args[i], game.toplay());

	return ret;
}

// Assembly:
subq $0xe8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0xcf(%rsp)
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x4670
movq 0x40(%rsp), %rdx
leaq 0x2924d(%rip), %rsi     # 0x3dab1
leaq 0xa8(%rsp), %rdi
callq 0x44d0
jmp 0x14873
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0xa8(%rsp), %rdx
callq 0xb680
jmp 0x1488c
leaq 0xa8(%rsp), %rdi
callq 0x4210
leaq 0xa7(%rsp), %rdi
callq 0x43f0
movl $0x0, 0x90(%rsp)
movq 0x28(%rsp), %rcx
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, 0x1f(%rsp)
je 0x148e9
movq 0x20(%rsp), %rdi
movl 0x90(%rsp), %eax
movq %rax, 0x10(%rsp)
callq 0xcbe0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x148f6
jmp 0x149cf
movq 0x20(%rsp), %rdi
movl 0x90(%rsp), %eax
movl %eax, %esi
callq 0xcc00
movq 0x38(%rsp), %rdi
movq %rax, (%rsp)
addq $0x38, %rdi
callq 0x15f80
movl %eax, 0xc(%rsp)
jmp 0x14921
movl 0xc(%rsp), %ecx
movq (%rsp), %rdx
movq 0x38(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x13fc0
jmp 0x1493a
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xfef0
leaq 0x48(%rsp), %rdi
callq 0x9090
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0x148b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x149a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x4210
leaq 0xa7(%rsp), %rdi
callq 0x43f0
jmp 0x149f8
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x9090
jmp 0x149f8
movb $0x1, 0xcf(%rsp)
testb $0x1, 0xcf(%rsp)
jne 0x149eb
movq 0x28(%rsp), %rdi
callq 0x9090
movq 0x30(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/gtpgeneral.cpp
// Function: PentagoGTP::gtp_play(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse PentagoGTP::gtp_play(vecstr args){
	if(args.size() != 2)
		return GTPResponse(false, "Wrong number of arguments");

	char toplay = 0;
	switch(tolower(args[0][0])){
		case 'w': toplay = 1; break;
		case 'b': toplay = 2; break;
		default:
			return GTPResponse(false, "Invalid player selection");
	}

	return play(args[1], toplay);
}

// Assembly:
subq $0xb8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq %rax, %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdi, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0xcbe0
cmpq $0x2, %rax
je 0x14afb
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4670
movq 0x18(%rsp), %rdx
leaq 0x28eed(%rip), %rsi     # 0x3d96d
leaq 0x80(%rsp), %rdi
callq 0x44d0
jmp 0x14a8f
movq 0x28(%rsp), %rdi
xorl %esi, %esi
leaq 0x80(%rsp), %rdx
callq 0xb680
jmp 0x14aa5
leaq 0x80(%rsp), %rdi
callq 0x4210
leaq 0x7f(%rsp), %rdi
callq 0x43f0
jmp 0x14bfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x14aec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x4210
leaq 0x7f(%rsp), %rdi
callq 0x43f0
jmp 0x14c09
movq 0x20(%rsp), %rdi
movb $0x0, 0x6b(%rsp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, 0x8(%rsp)
callq 0xcc00
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x4720
movsbl (%rax), %edi
callq 0x4520
movl %eax, %ecx
movl %ecx, 0x14(%rsp)
subl $0x62, %eax
je 0x14b4a
jmp 0x14b35
movl 0x14(%rsp), %eax
subl $0x77, %eax
jne 0x14b54
jmp 0x14b40
movb $0x1, 0x6b(%rsp)
jmp 0x14bd6
movb $0x2, 0x6b(%rsp)
jmp 0x14bd6
leaq 0x47(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4670
movq (%rsp), %rdx
leaq 0x294bc(%rip), %rsi     # 0x3e029
leaq 0x48(%rsp), %rdi
callq 0x44d0
jmp 0x14b79
movq 0x28(%rsp), %rdi
xorl %esi, %esi
leaq 0x48(%rsp), %rdx
callq 0xb680
jmp 0x14b8c
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0x47(%rsp), %rdi
callq 0x43f0
jmp 0x14bfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x14bca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4210
leaq 0x47(%rsp), %rdi
callq 0x43f0
jmp 0x14c09
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xcc00
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rax, %rdx
movsbl 0x6b(%rsp), %ecx
callq 0x13fc0
movq 0x30(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/./agentpns.h
// Function: AgentPNS::AgentPNS()
AgentPNS() {
		df = true;
		epsilon = 0.25;
		ties = 0;
		numthreads = 1;
		gclimit = 5;

		nodes = 0;
		reset();

		set_memlimit(1000*1024*1024);

		//no threads started until a board is set
		threadstate = Thread_Wait_Start;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x16230
movq 0x20(%rsp), %rdi
leaq 0x3a7e4(%rip), %rax     # 0x4fba8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x50, %rdi
movq %rdi, 0x28(%rsp)
callq 0x16260
jmp 0x153db
movq 0x20(%rsp), %rdi
addq $0x9f8, %rdi            # imm = 0x9F8
movq %rdi, 0x10(%rsp)
callq 0x162f0
movq 0x20(%rsp), %rdi
addq $0xa10, %rdi            # imm = 0xA10
movq %rdi, 0x18(%rsp)
movl $0x1, %esi
callq 0x16300
jmp 0x1540e
movq 0x20(%rsp), %rdi
addq $0xa70, %rdi            # imm = 0xA70
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x16300
jmp 0x1542b
movq 0x20(%rsp), %rdi
addq $0xae0, %rdi            # imm = 0xAE0
movq %rdi, (%rsp)
callq 0x16340
jmp 0x15442
movq 0x20(%rsp), %rdi
movb $0x1, 0xad0(%rdi)
movl $0x3e800000, 0xad4(%rdi) # imm = 0x3E800000
movl $0x0, 0xad8(%rdi)
movl $0x1, 0xadc(%rdi)
movl $0x5, 0x48(%rdi)
movq $0x0, 0x38(%rdi)
callq 0x16380
jmp 0x15482
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
movl $0x3e800000, %esi       # imm = 0x3E800000
callq *%rax
jmp 0x15497
movq 0x20(%rsp), %rax
movl $0x1, 0x9f0(%rax)
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1552a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x15516
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1550c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x15502
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x163b0
movq 0x8(%rsp), %rdi
callq 0x16420
movq 0x18(%rsp), %rdi
callq 0x16420
movq 0x10(%rsp), %rdi
callq 0x16480
movq 0x28(%rsp), %rdi
callq 0x164e0
movq 0x20(%rsp), %rdi
callq 0x16560
movq 0x38(%rsp), %rdi
callq 0x4660
nop
// File: tewalds[P]pentagod/./agentab.h
// Function: AgentAB::AgentAB()
AgentAB() : rand(std::rand()) {
		maxdepth = 0;
		nodes_seen = 0;
		time_used = 0;
		TT = NULL;
		set_memlimit(100*1024*1024);

		randomness = 2;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x16230
movq (%rsp), %rax
leaq 0x3a77e(%rip), %rcx     # 0x4fce0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x68, %rax
movq %rax, 0x8(%rsp)
callq 0x40e0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x16cf0
jmp 0x15585
movq (%rsp), %rdi
movl $0x0, 0x50(%rdi)
movq $0x0, 0x58(%rdi)
movq $0x0, 0x60(%rdi)
movq $0x0, 0x38(%rdi)
movq (%rdi), %rax
movq 0x30(%rax), %rax
movl $0x6400000, %esi        # imm = 0x6400000
callq *%rax
jmp 0x155b8
movq (%rsp), %rax
movl $0x2, 0x6c(%rax)
addq $0x28, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x16560
movq 0x18(%rsp), %rdi
callq 0x4660
nopl (%rax)
// File: tewalds[P]pentagod/./game.h
// Function: Game::undo()
bool undo(){
		if(hist.size() <= 0)
			return false;

		hist.pop_back();
		return true;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd020
cmpq $0x0, %rax
ja 0x15ab4
movb $0x0, 0x17(%rsp)
jmp 0x15ac2
movq (%rsp), %rdi
callq 0x16e00
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)