LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/policy_bridge.h
// Function: Morat::ProtectBridge<Morat::Hex::Board>::ProtectBridge()
ProtectBridge() : offset(0) {
		// precompute the valid moves around a pattern for all possible 6-patterns.
		for(unsigned int i = 0; i < 1<<12; i++){
			lookup[0][i] = lookup[1][i] = 0;
			unsigned int p = i;
			for(unsigned int d = 0; d < 6; d++){
				// player 1
				if((p & 0x1D) == 0x11) // 01 11 01 -> 01 00 01
					lookup[0][i] |= (1 << ((d+1)%6)); // +1 because we want to play in the empty spot

				// player 2
				if((p & 0x2E) == 0x22) // 10 11 10 -> 10 00 10
					lookup[1][i] |= (1 << ((d+1)%6));

				p = ((p & 0xFFC)>>2) | ((p & 0x3) << 10);
			}
		}
	}

// Assembly:
movl $0x0, (%rdi)
xorl %eax, %eax
movl $0x2, %ecx
movl $0x1, %edx
movl $0xa02, %esi            # imm = 0xA02
xorl %r8d, %r8d
movb %al, 0x1004(%rdi,%r8)
movb %al, 0x4(%rdi,%r8)
xorl %r9d, %r9d
movl %r8d, %r10d
movl %r10d, %r11d
andl $0x1d, %r11d
cmpl $0x11, %r11d
jne 0x14bda
cmpl $0x5, %r9d
shlxl %r9d, %ecx, %r11d
cmovel %edx, %r11d
orb %r11b, 0x4(%rdi,%r8)
movl %r10d, %r11d
andl $0x2e, %r11d
cmpl $0x22, %r11d
jne 0x14bfc
cmpl $0x5, %r9d
shlxl %r9d, %ecx, %r11d
cmovel %edx, %r11d
orb %r11b, 0x1004(%rdi,%r8)
bextrl %esi, %r10d, %r11d
andl $0x3, %r10d
shll $0xa, %r10d
orl %r11d, %r10d
incl %r9d
cmpl $0x6, %r9d
jne 0x14bbb
incq %r8
cmpq $0x1000, %r8            # imm = 0x1000
jne 0x14ba8
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/thread.h
// Function: Morat::Thread::operator()(std::function<void ()>)
int operator()(std::function<void()> fn){
		assert(destruct == false);

		func = fn;
		destruct = true;
		return pthread_create(&thread, NULL, (void* (*)(void*)) &Thread::runner, this);
	}

// Assembly:
pushq %rbx
cmpb $0x0, 0x8(%rdi)
jne 0x14c4e
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x14e5a
movb $0x1, 0x8(%rbx)
leaq 0x286(%rip), %rdx       # 0x14ec6
movq %rbx, %rdi
xorl %esi, %esi
movq %rbx, %rcx
popq %rbx
jmp 0x56a0
leaq 0x1e5d2(%rip), %rdi     # 0x33227
leaq 0x1e51a(%rip), %rsi     # 0x33176
leaq 0x1e5d6(%rip), %rcx     # 0x33239
movl $0x5c, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/agentpool.h
// Function: Morat::AgentThreadBase<Morat::Hex::AgentMCTS>::run()
void run(){
		while(true){
			switch(pool->thread_state){
			case Thread_Cancelled:  //threads should exit
				return;

			case Thread_Wait_Start: //threads are waiting to start
			case Thread_Wait_Start_Cancelled:
				pool->run_barrier.wait();
				CAS(pool->thread_state, Thread_Wait_Start, Thread_Running);
				CAS(pool->thread_state, Thread_Wait_Start_Cancelled, Thread_Cancelled);
				break;

			case Thread_Wait_End:   //threads are waiting to end
				pool->run_barrier.wait();
				CAS(pool->thread_state, Thread_Wait_End, Thread_Wait_Start);
				break;

			case Thread_Running:    //threads are running
				if(agent->done()){ //solved or finished runs
					CAS(pool->thread_state, Thread_Running, Thread_Wait_End);
					break;
				}
				if(agent->need_gc()){ //out of memory, start garbage collection
					CAS(pool->thread_state, Thread_Running, Thread_GC);
					break;
				}
				iterate();
				break;

			case Thread_GC:         //one thread is running garbage collection, the rest are waiting
			case Thread_GC_End:     //once done garbage collecting, go to wait_end instead of back to running
				if(pool->gc_barrier.wait()){
					agent->start_gc();
					CAS(pool->thread_state, Thread_GC,     Thread_Running);
					CAS(pool->thread_state, Thread_GC_End, Thread_Wait_End);
				}
				pool->gc_barrier.wait();
				break;
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1d7cd(%rip), %r14     # 0x32450
movl $0x3, %r15d
xorl %r12d, %r12d
leaq 0x2171e(%rip), %r13     # 0x363b1
movl $0x6, %ebp
movq 0x38(%rbx), %rdi
movl (%rdi), %eax
cmpq $0x6, %rax
ja 0x14c98
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
addq $0x20, %rdi
callq 0x142a6
movq 0x38(%rbx), %rcx
movl $0x1, %eax
lock
cmpxchgl %r15d, (%rcx)
movq 0x38(%rbx), %rcx
movl $0x2, %eax
lock
cmpxchgl %r12d, (%rcx)
jmp 0x14c98
subq $-0x80, %rdi
callq 0x142a6
testb %al, %al
je 0x14d05
movq 0x40(%rbx), %rdi
callq 0x14ee2
movq 0x38(%rbx), %rcx
movl $0x4, %eax
lock
cmpxchgl %r15d, (%rcx)
movq 0x38(%rbx), %rcx
movl $0x5, %eax
lock
cmpxchgl %ebp, (%rcx)
movq 0x38(%rbx), %rdi
subq $-0x80, %rdi
callq 0x142a6
jmp 0x14c98
movq 0x40(%rbx), %rax
movb (%r13), %cl
cmpb %cl, 0x19(%rax)
jge 0x14d8d
cmpb %cl, 0x4102(%rax)
jge 0x14d8d
movq 0x4128(%rax), %rcx
testq %rcx, %rcx
je 0x14d3e
cmpq %rcx, 0x4120(%rax)
jae 0x14d8d
movq 0x4138(%rax), %rcx
movq 0x4140(%rax), %rdx
movl 0x8(%rdx), %edx
shlq $0x18, %rdx
movl 0x10(%rcx), %ecx
addq %rdx, %rcx
cmpq 0x60(%rax), %rcx
jae 0x14d9b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0x14c98
addq $0x20, %rdi
callq 0x142a6
movq 0x38(%rbx), %rcx
movl $0x6, %eax
movl $0x1, %edx
lock
cmpxchgl %edx, (%rcx)
jmp 0x14c98
movl $0x3, %eax
lock
cmpxchgl %ebp, (%rdi)
jmp 0x14c98
movl $0x3, %eax
movl $0x4, %ecx
lock
cmpxchgl %ecx, (%rdi)
jmp 0x14c98
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFParser<Morat::Move>::next_node()
bool next_node() {
		eat_whitespace(_is);
		if(eat_char(_is, ';')){
			read_node();
			return true;
		}
		return false;
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2d7a7
movq (%rbx), %rdi
movl $0x3b, %esi
callq 0x2d807
movl %eax, %ebp
testb %al, %al
je 0x15b09
movq %rbx, %rdi
callq 0x15b12
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFParser<Morat::Move>::read_node()
void read_node() {
		_properties.clear();
		char key[11], value[1025];
		for(int c = _is.peek(); _is.good() && 'A' <= c && c <= 'Z'; c = _is.peek()) {
			_is.getline(key, 10, '[');
			_is.getline(value, 1024, ']');
			_properties[key] = value;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp            # imm = 0x448
movq %rdi, %rbx
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1346c
movq (%rbx), %rdi
callq 0x5110
addl $-0x41, %eax
cmpl $0x19, %eax
ja 0x15c1e
movq (%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rdi,%rax)
jne 0x15c1e
leaq 0x30(%rsp), %r14
leaq 0x15(%rsp), %r15
leaq 0x40(%rsp), %r12
movl $0xa, %edx
movq %r15, %rsi
movl $0x5b, %ecx
callq 0x56f0
movq (%rbx), %rdi
movl $0x400, %edx            # imm = 0x400
movq %r12, %rsi
movl $0x5d, %ecx
callq 0x56f0
movq %r14, %r13
movq %r14, 0x20(%rsp)
movq %r15, %rdi
callq 0x5140
leaq 0x15(%rsp,%rax), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xb0e0
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x13e58
movq %rax, %rbp
movq 0x8(%rax), %r14
movq %r12, %rdi
callq 0x5140
movq %rbp, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x5540
movq 0x20(%rsp), %rdi
movq %r13, %r14
cmpq %r13, %rdi
je 0x15bf9
callq 0x52e0
movq (%rbx), %rdi
callq 0x5110
addl $-0x41, %eax
cmpl $0x19, %eax
ja 0x15c1e
movq (%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rdi,%rax)
je 0x15b6c
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x15c42
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmctsthread.cpp
// Function: Morat::Hex::AgentMCTS::AgentThread::rollout_choose_move(Morat::Hex::Board&, Morat::Move const&)
Move AgentMCTS::AgentThread::rollout_choose_move(Board & board, const Move & prev){
	//look for instant wins
	if(agent->instantwin){
		Move move = instant_wins.choose_move(board, prev);
		if(move != M_UNKNOWN)
			return move;
	}

	//force a bridge reply
	if(agent->rolloutpattern){
		Move move = protect_bridge.choose_move(board, prev);
		if(move != M_UNKNOWN)
			return move;
	}

	//reuse the last good reply
	if(agent->lastgoodreply){
		Move move = last_good_reply.choose_move(board, prev);
		if(move != M_UNKNOWN)
			return move;
	}

	return random_policy.choose_move(board, prev);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rdi), %rax
cmpl $0x0, 0xd8(%rax)
je 0x176df
leaq 0x2f08(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17e42
cmpb $-0x4, %al
jne 0x1773c
movq 0x40(%r15), %rax
cmpb $0x1, 0xd0(%rax)
jne 0x17702
leaq 0xf04(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1809c
cmpb $-0x4, %al
jne 0x1773c
movq 0x40(%r15), %rax
cmpl $0x0, 0xd4(%rax)
je 0x17722
leaq 0x4c(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x18172
cmpb $-0x4, %al
jne 0x1773c
addq $0xa14, %r15            # imm = 0xA14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x181f0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/depthstats.h
// Function: Morat::DepthStats::add(unsigned int)
void add(unsigned int depth){
		num++;
		if(mindepth > depth) mindepth = depth;
		if(maxdepth < depth) maxdepth = depth;
		sumdepth += depth;
		sumdepthsq += depth*depth;
	}

// Assembly:
incl 0x8(%rdi)
cmpl %esi, (%rdi)
jbe 0x179e7
movl %esi, (%rdi)
cmpl %esi, 0x4(%rdi)
jae 0x179ef
movl %esi, 0x4(%rdi)
movl %esi, %eax
addq %rax, 0x10(%rdi)
imull %esi, %esi
addq %rsi, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/lbdist.h
// Function: Morat::LBDistsBase<Morat::Hex::LBDists, Morat::Hex::Board>::run(Morat::Hex::Board const*, bool, Morat::Side)
void run(const Board * b, bool crossvcs = true, Side side = Side::BOTH) {
	// run the flood fills needed to generate the distances
		board = b;

		for(int i = 0; i < Board::LBDist_directions; i++)
			for(int j = 0; j < 2; j++)
				for(int k = 0; k < board->vec_size(); k++)
					dists[i][j][k] = maxdist; //far far away!

		if((side & Side::P1) == Side::P1) self()->init_player(crossvcs, Side::P1);
		if((side & Side::P2) == Side::P2) self()->init_player(crossvcs, Side::P2);
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdi, %rbx
movq %rsi, 0x9c58(%rdi)
movsbl (%rsi), %eax
movl %eax, %ecx
imull %ecx, %ecx
cmpl $0x1, %ecx
adcl $0x0, %ecx
leaq -0x1(%rcx), %rsi
addl $0xf, %ecx
andl $-0x10, %ecx
vpbroadcastq %rsi, %zmm0
xorl %esi, %esi
vpmovsxbq 0x1a838(%rip), %zmm1 # 0x32270
vpmovsxbq 0x1a7e6(%rip), %zmm2 # 0x32228
vpbroadcastd 0x1bc74(%rip), %zmm3 # 0x336c0
movq %rdi, %r8
xorl %r9d, %r9d
testb %al, %al
je 0x17a8d
xorl %r10d, %r10d
vpbroadcastq %r10, %zmm4
vporq %zmm1, %zmm4, %zmm5
vporq %zmm2, %zmm4, %zmm4
vpcmpleuq %zmm0, %zmm4, %k0
vpcmpleuq %zmm0, %zmm5, %k1
kunpckbw %k0, %k1, %k1
vmovdqu32 %zmm3, (%r8,%r10,4) {%k1}
addq $0x10, %r10
cmpq %r10, %rcx
jne 0x17a59
leaq 0x1(%r9), %r10
addq $0x9c4, %r8             # imm = 0x9C4
testq %r9, %r9
movq %r10, %r9
je 0x17a52
leaq 0x1(%rsi), %r8
addq $0x1388, %rdi           # imm = 0x1388
testq %rsi, %rsi
movq %r8, %rsi
je 0x17a4c
leaq 0x1e8f0(%rip), %rax     # 0x363aa
movb (%rax), %al
notb %bpl
movzbl %dl, %r14d
testb %bpl, %al
jne 0x17ad9
movzbl %al, %edx
movq %rbx, %rdi
movl %r14d, %esi
vzeroupper
callq 0x18384
leaq 0x1e8cb(%rip), %rax     # 0x363ab
movb (%rax), %al
testb %bpl, %al
jne 0x17afc
movzbl %al, %edx
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
vzeroupper
jmp 0x18384
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::test_outcome(Morat::MoveValid const&, Morat::Side) const
Outcome test_outcome(const MoveValid & pos, Side turn) const {
		if(test_local(pos, turn)){
			Cell testcell = cells_[find_group(pos.xy)];
			int numgroups = 0;
			auto it = neighbors_small(pos);
			for (const MoveValid *i = it.begin(), *e = it.end(); i < e; i++) {
				if(i->on_board() && turn == get(i->xy)){
					const Cell * g = & cells_[find_group(i->xy)];
					testcell.edge   |= g->edge;
					testcell.size   += g->size;
					i++; //skip the next one
					numgroups++;
				}
			}

			int winmask = (turn == Side::P1 ? 3 : 0xC);
			if((testcell.edge & winmask) == winmask)
				return +turn;
		}

		return Outcome::UNKNOWN;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movswl 0x2(%rsi), %esi
callq 0x1830e
cmpl $0x3, %eax
jne 0x17bfc
movswl 0x2(%r15), %esi
movslq %esi, %rdx
movq 0x10(%r14), %rax
shlq $0x4, %rsi
movzwl 0x4(%rax,%rsi), %ecx
cmpl %edx, %ecx
je 0x17b61
leaq 0x4(%rax,%rsi), %rsi
movl %ecx, %ecx
shlq $0x4, %rcx
movzwl 0x4(%rax,%rcx), %edi
movzwl %di, %ecx
movl %ecx, %r8d
shll $0x4, %r8d
cmpw 0x4(%rax,%r8), %di
jne 0x17b41
movw %di, (%rsi)
shll $0x4, %ecx
movb 0x6(%rax,%rcx), %cl
movq 0x38(%r14), %rsi
leaq (%rdx,%rdx,8), %rdx
leaq 0x2(%rsi,%rdx,8), %rdx
xorl %esi, %esi
movswq (%rdx,%rsi), %r8
cmpq $-0x1, %r8
je 0x17bd3
movq %r8, %rdi
shlq $0x4, %rdi
cmpb %bl, (%rax,%rdi)
jne 0x17bd3
movl %r8d, %r9d
shlq $0x4, %r9
movzwl 0x4(%rax,%r9), %edi
cmpl %r8d, %edi
je 0x17bc8
leaq 0x4(%rax,%r9), %r8
movl %edi, %edi
shlq $0x4, %rdi
movzwl 0x4(%rax,%rdi), %r9d
movzwl %r9w, %edi
movl %edi, %r10d
shll $0x4, %r10d
cmpw 0x4(%rax,%r10), %r9w
jne 0x17ba5
movw %r9w, (%r8)
shll $0x4, %edi
orb 0x6(%rax,%rdi), %cl
addq $0x4, %rsi
leaq 0x4(%rsi), %rdi
cmpq $0x14, %rsi
movq %rdi, %rsi
jl 0x17b77
leaq 0x1e7c3(%rip), %rax     # 0x363aa
xorl %edx, %edx
cmpb %bl, (%rax)
sete %dl
movzbl %cl, %eax
leal -0xd(%rdx,%rdx,8), %ecx
orl %eax, %ecx
cmpl $-0x1, %ecx
je 0x17c05
leaq 0x1e7ab(%rip), %rax     # 0x363ae
movb (%rax), %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/policy_lastgoodreply.h
// Function: Morat::LastGoodReply<Morat::Hex::Board>::rollout_end(Morat::Hex::Board const&, Morat::MoveList<Morat::Hex::Board> const&, Morat::Outcome)
void rollout_end(const Board & board, const MoveList<Board> & movelist, Outcome outcome) {
		if(!enabled || outcome != Outcome::DRAW)
			return;
		int m = -1;
		for(const MovePlayer * i = movelist.begin(), * e = movelist.end(); i != e; i++){
			if(m >= 0){
				if(+i->player == outcome && *i != M_SWAP)
					goodreply[i->player.to_i() - 1][m] = *i;
				else if(enabled == 2)
					goodreply[i->player.to_i() - 1][m] = M_UNKNOWN;
			}
			m = board.xy(*i);
		}
	}

// Assembly:
cmpl $0x0, 0x9c4(%rdi)
je 0x17e40
leaq 0x1e62b(%rip), %rax     # 0x363b1
cmpb %cl, (%rax)
jne 0x17e40
movslq 0x5594(%rdx), %rax
leaq (%rax,%rax,2), %r8
movslq 0x5598(%rdx), %rax
leaq (%rax,%rax,2), %rax
addq %r8, %rax
je 0x17e40
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
testl %r9d, %r9d
js 0x17e16
movsbq 0x4e42(%rdx,%r8), %r10
cmpb %cl, %r10b
jne 0x17df5
cmpb $-0x1, 0x4e40(%rdx,%r8)
je 0x17df5
imulq $0x4e2, %r10, %r10      # imm = 0x4E2
movl %r9d, %r9d
addq %rdi, %r10
movzwl 0x4e40(%rdx,%r8), %r11d
movw %r11w, -0x4e2(%r10,%r9,2)
jmp 0x17e16
cmpl $0x2, 0x9c4(%rdi)
jne 0x17e16
imulq $0x4e2, %r10, %r10      # imm = 0x4E2
movl %r9d, %r9d
addq %rdi, %r10
movw $0x78fc, -0x4e2(%r10,%r9,2) # imm = 0x78FC
movsbl 0x4e40(%rdx,%r8), %r9d
movsbl (%rsi), %r10d
imull %r9d, %r10d
movsbl 0x4e41(%rdx,%r8), %r9d
addl %r10d, %r9d
addq $0x3, %r8
cmpq %r8, %rax
jne 0x17db6
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/policy_lastgoodreply.h
// Function: Morat::LastGoodReply<Morat::Hex::Board>::choose_move(Morat::Hex::Board const&, Morat::Move const&) const
Move choose_move(const Board & board, const Move & prev) const {
		if (enabled && prev != M_SWAP) {
			Move move = goodreply[board.to_play().to_i() - 1][board.xy(prev)];
			if(move != M_UNKNOWN && board.valid_move_fast(move))
				return move;
		}
		return M_UNKNOWN;
	}

// Assembly:
cmpl $0x0, 0x9c4(%rdi)
je 0x181dc
movsbq (%rdx), %rax
cmpq $-0x1, %rax
je 0x181dc
movsbq 0x8(%rsi), %rcx
imulq $0x4e2, %rcx, %rcx      # imm = 0x4E2
movsbq (%rsi), %r8
imulq %r8, %rax
movsbq 0x1(%rdx), %rdx
addq %rax, %rdx
addq %rdi, %rcx
movzwl -0x4e2(%rcx,%rdx,2), %eax
cmpb $-0x4, %al
je 0x181dc
movzwl %ax, %ecx
shrl $0x8, %ecx
movsbq %al, %rdx
imulq %r8, %rdx
shlq $0x4, %rdx
addq 0x10(%rsi), %rdx
movsbq %cl, %rsi
shlq $0x4, %rsi
movb (%rsi,%rdx), %dl
leaq 0x1e1d1(%rip), %rsi     # 0x363a9
cmpb (%rsi), %dl
je 0x181e4
movw $0x78, %cx
movw $0xfc, %ax
movzwl %cx, %ecx
shll $0x8, %ecx
movzbl %al, %eax
orl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/policy_random.h
// Function: Morat::RandomPolicy<Morat::Hex::Board>::choose_move(Morat::Hex::Board const&, Morat::Move const&)
Move choose_move(const Board & board, const Move & prev) {
		while(true){
			int r = rand() % cur;
			cur--;
			Move m = moves[r];
			moves[r] = moves[cur];
			moves[cur] = m;
			if(board.valid_move_fast(m))
				return m;
		}
	}

// Assembly:
leaq 0x1e1b2(%rip), %rcx     # 0x363a9
movl (%rdi), %eax
movl %eax, %edx
shll $0xd, %edx
xorl %eax, %edx
movl %edx, %eax
shrl $0x11, %eax
xorl %edx, %eax
movl %eax, %edx
shll $0x5, %edx
xorl %eax, %edx
movl %edx, (%rdi)
imull $0x5f356495, %edx, %eax # imm = 0x5F356495
movslq 0x4ec(%rdi), %r8
xorl %edx, %edx
divl %r8d
leal -0x1(%r8), %eax
movl %eax, 0x4ec(%rdi)
movslq %edx, %rdx
movzwl 0x4(%rdi,%rdx,2), %eax
movl %eax, %r9d
shrl $0x8, %r9d
movzwl 0x2(%rdi,%r8,2), %r8d
movw %r8w, 0x4(%rdi,%rdx,2)
movslq 0x4ec(%rdi), %rdx
movw %ax, 0x4(%rdi,%rdx,2)
movsbq %al, %rdx
movsbq (%rsi), %r8
imulq %rdx, %r8
shlq $0x4, %r8
addq 0x10(%rsi), %r8
movsbq %r9b, %rdx
shlq $0x4, %rdx
movb (%rdx,%r8), %dl
cmpb (%rcx), %dl
jne 0x181f7
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.h
// Function: Morat::Hex::AgentMCTS::AgentThread::reset()
void reset(){
			treelen.reset();
			gamelen.reset();

			use_rave = false;
			use_explore = false;

			for(int a = 0; a < 2; a++)
				for(int b = 0; b < Board::num_win_types; b++)
					win_types[a][b].reset();

			for(int a = 0; a < 4; a++)
				times[a] = 0;
		}

// Assembly:
xorl %eax, %eax
movl %eax, 0x12130(%rdi)
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
movq %rcx, 0x12128(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x12138(%rdi)
movl %eax, 0x12150(%rdi)
movq %rcx, 0x12148(%rdi)
vmovups %xmm0, 0x12158(%rdi)
movw $0x0, 0x2f14(%rdi)
leaq 0x12178(%rdi), %rcx
movl $0x0, -0x8(%rcx,%rax)
movq $0x3b9aca00, -0x10(%rcx,%rax) # imm = 0x3B9ACA00
vmovups %xmm0, (%rcx,%rax)
addq $0x20, %rax
cmpq $0x20, %rax
je 0x182dd
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x121a8(%rdi)
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/lbdist.h
// Function: Morat::Hex::LBDists::init_player(bool, Morat::Side)
void init_player(bool crossvcs, Side player){
		int m = board->lines();
		int m1 = m-1;

		if (player == Side::P1) {
			for(int y = 0; y < m; y++) { init(0,  y, 0,  player, 2); } flood(0,  player, crossvcs);  // p1 edge 0
			for(int y = 0; y < m; y++) { init(m1, y, 1,  player, 5); } flood(1,  player, crossvcs);  // p1 edge 1
		} else {
			for(int x = 0; x < m; x++) { init(x,  0, 0,  player, 3); } flood(0,  player, crossvcs);  // p2 edge 0
			for(int x = 0; x < m; x++) { init(x, m1, 1,  player, 0); } flood(1,  player, crossvcs);  // p2 edge 1
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x9c58(%rdi), %rax
movsbl (%rax), %r13d
leal -0x1(%r13), %r15d
leaq 0x1e002(%rip), %rax     # 0x363aa
movzbl %dl, %ebp
movzbl %sil, %r14d
cmpb %dl, (%rax)
jne 0x1841c
testb %r13b, %r13b
jle 0x183db
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl %r12d, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
movl $0x2, %r9d
callq 0x1849c
incl %r12d
cmpl %r12d, %r13d
jne 0x183bb
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x18556
testb %r13b, %r13b
jle 0x1847c
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl $0x1, %ecx
movl %ebp, %r8d
movl $0x5, %r9d
callq 0x1849c
incl %r12d
cmpl %r12d, %r13d
jne 0x183f6
jmp 0x1847c
testb %r13b, %r13b
jle 0x18444
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
movl $0x3, %r9d
callq 0x1849c
incl %r12d
cmpl %r12d, %r13d
jne 0x18424
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x18556
testb %r13b, %r13b
jle 0x1847c
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl $0x1, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x1849c
incl %r12d
cmpl %r12d, %r13d
jne 0x1845b
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
movl %r14d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18556
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/lbdist.h
// Function: Morat::LBDistsBase<Morat::Hex::LBDists, Morat::Hex::Board>::init(int, int, int, Morat::Side, int)
void init(int x, int y, int edge, Side player, int dir){
		Side val = board->get(x, y);
		if(val != ~player){
			bool empty = (val == Side::NONE);
			MoveValid move(x, y, board->xy(x, y));
			Q.push(MoveDist(move, empty, dir));
			dist(edge, player, move) = empty;
		}
	}

// Assembly:
movq 0x9c58(%rdi), %r10
movsbl (%r10), %eax
imull %edx, %eax
addl %esi, %eax
movslq %eax, %r11
movq 0x10(%r10), %r10
shlq $0x4, %r11
movb (%r10,%r11), %r11b
movb $0x3, %r10b
subb %r8b, %r10b
cmpb %r10b, %r11b
je 0x18555
pushq %rbx
leaq 0x1ded7(%rip), %rbx     # 0x363a9
xorl %r10d, %r10d
cmpb (%rbx), %r11b
sete %r10b
imulq $0x1d4c, %r10, %r11     # imm = 0x1D4C
addq %rdi, %r11
movl %eax, %ebx
shll $0x10, %ebx
shll $0x8, %esi
movzwl %si, %esi
orl %ebx, %esi
movzbl %dl, %edx
orl %esi, %edx
movslq 0x9c40(%rdi,%r10,4), %rsi
leal 0x1(%rsi), %ebx
movl %ebx, 0x9c40(%rdi,%r10,4)
leaq (%rsi,%rsi,2), %rsi
movl %edx, 0x2710(%r11,%rsi,4)
movl %r10d, 0x2714(%r11,%rsi,4)
movl %r9d, 0x2718(%r11,%rsi,4)
incl 0x9c54(%rdi)
movslq %ecx, %rcx
movsbq %r8b, %rdx
imulq $0x9c4, %rdx, %rdx      # imm = 0x9C4
movswq %ax, %rax
imulq $0x1388, %rcx, %rcx     # imm = 0x1388
addq %rdi, %rcx
addq %rdx, %rcx
movl %r10d, -0x9c4(%rcx,%rax,4)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/lbdist.h
// Function: Morat::LBDistsBase<Morat::Hex::LBDists, Morat::Hex::Board>::IntPQueue::pop(Morat::LBDistsBase<Morat::Hex::LBDists, Morat::Hex::Board>::MoveDist&)
bool pop(MoveDist & ret){
			if(num == 0){
				current = 0;
				return false;
			}

			while(counts[current] == 0)
				current = (current+1) % maxvals;

			ret = vals[current][--counts[current]];
			num--;

			return true;
		}

// Assembly:
movl 0x7544(%rdi), %eax
testl %eax, %eax
je 0x187c5
movl 0x7540(%rdi), %ecx
movslq %ecx, %rdx
movl 0x7530(%rdi,%rdx,4), %r8d
testl %r8d, %r8d
jne 0x18791
leal 0x1(%rcx), %edx
leal 0x4(%rcx), %r8d
testl %edx, %edx
cmovnsl %edx, %r8d
andl $-0x4, %r8d
negl %r8d
leal 0x1(%rcx,%r8), %ecx
movslq %ecx, %rdx
movl 0x7530(%rdi,%rdx,4), %r8d
testl %r8d, %r8d
je 0x18762
movl %ecx, 0x7540(%rdi)
decl %r8d
movl %r8d, 0x7530(%rdi,%rdx,4)
movslq %r8d, %rcx
imulq $0x1d4c, %rdx, %rdx     # imm = 0x1D4C
leaq (%rcx,%rcx,2), %rcx
addq %rdi, %rdx
movl 0x8(%rdx,%rcx,4), %r8d
movl %r8d, 0x8(%rsi)
movq (%rdx,%rcx,4), %rcx
movq %rcx, (%rsi)
decl 0x7544(%rdi)
jmp 0x187cf
movl $0x0, 0x7540(%rdi)
testl %eax, %eax
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::Node::from_s(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool AgentPNS::Node::from_s(std::string s) {
	auto dict = parse_dict(s, ", ", " ");

	if(dict.size() == 6){
		move = Move(dict["move"]);
		phi = from_str<uint32_t>(dict["phi"]);
		delta = from_str<uint32_t>(dict["delta"]);
		work = from_str<uint64_t>(dict["work"]);
		// ignore children
		return true;
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19ad1(%rip), %rsi     # 0x332b2
leaq 0x19acc(%rip), %rdx     # 0x332b4
movq %rsp, %rdi
callq 0xb0e0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1c642(%rip), %rsi     # 0x35e43
leaq 0x1c63c(%rip), %rdx     # 0x35e44
leaq 0x20(%rsp), %rdi
callq 0xb0e0
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rsi
callq 0x2fc2f
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x19836
callq 0x52e0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19844
callq 0x52e0
movq 0x58(%rsp), %r14
cmpq $0x6, %r14
jne 0x1995a
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1c29e(%rip), %rsi     # 0x35afe
leaq 0x1c29b(%rip), %rdx     # 0x35b02
callq 0xb0e0
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x13e58
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x11286
movzwl 0x20(%rsp), %eax
movw %ax, 0x12(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1989d
callq 0x52e0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1a2a0(%rip), %rsi     # 0x33b4a
leaq 0x1a29c(%rip), %rdx     # 0x33b4d
callq 0xb0e0
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x13e58
movq %rax, %rdi
callq 0x1bf9d
movl %eax, (%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x198db
callq 0x52e0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1a266(%rip), %rsi     # 0x33b4e
leaq 0x1a264(%rip), %rdx     # 0x33b53
callq 0xb0e0
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x13e58
movq %rax, %rdi
callq 0x1bf9d
movl %eax, 0x4(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1991a
callq 0x52e0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1a22d(%rip), %rsi     # 0x33b54
leaq 0x1a22a(%rip), %rdx     # 0x33b58
callq 0xb0e0
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x13e58
movq %rax, %rdi
callq 0x13340
movq %rax, 0x8(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1995a
callq 0x52e0
cmpq $0x6, %r14
sete %bl
leaq 0x40(%rsp), %rdi
callq 0x1344e
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1997f
jmp 0x1997f
jmp 0x1997f
movq %rax, %rbx
jmp 0x1999b
jmp 0x1998a
jmp 0x1998a
jmp 0x1998a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1999b
callq 0x52e0
leaq 0x40(%rsp), %rdi
callq 0x1344e
movq %rbx, %rdi
callq 0x5670
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x199c4
callq 0x52e0
jmp 0x199c4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x199a5
callq 0x52e0
jmp 0x199a5
movq %rax, %rbx
jmp 0x199a5
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::garbage_collect(Morat::Hex::AgentPNS::Node*)
void AgentPNS::garbage_collect(Node * node){
	Node * child = node->children.begin();
	Node * end = node->children.end();

	for( ; child != end; child++){
		if(child->terminal() || child->work < gclimit){ //solved or low work, ignore solvedness since it's trivial to re-solve
			nodes -= child->dealloc(ctmem);
		}else if(child->children.num() > 0){
			garbage_collect(child);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rsi), %rcx
leaq 0x10(%rcx), %rax
xorl %r12d, %r12d
movl $0x0, %r14d
cmpq $0x2, %rcx
cmovaeq %rax, %r14
jb 0x1b903
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %r12
cmpq %r12, %r14
je 0x1b95c
leaq 0x70(%rbx), %r15
cmpl $0x0, (%r14)
je 0x1b922
cmpl $0x0, 0x4(%r14)
je 0x1b922
movl 0x68(%rbx), %eax
cmpq %rax, 0x8(%r14)
jae 0x1b93e
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c4f4
movl %eax, %eax
subq %rax, 0x58(%rbx)
addq $0x20, %r14
cmpq %r12, %r14
jne 0x1b90c
jmp 0x1b95c
movq 0x18(%r14), %rax
cmpq $0x2, %rax
jb 0x1b933
cmpw $0x0, 0x6(%rax)
je 0x1b933
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b8d0
jmp 0x1b933
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::create_children_simple(Morat::Hex::Board const&, Morat::Hex::AgentPNS::Node*)
void AgentPNS::create_children_simple(const Board & board, Node * node){
	assert(node->children.empty());
	node->children.alloc(board.moves_avail(), ctmem);
	unsigned int i = 0;
	for (auto move : board) {
		Outcome outcome = board.test_outcome(move);
		node->children[i] = Node(move).outcome(outcome, board.to_play(), ties, 1);
		i++;
	}
	PLUS(nodes, i);
	node->children.shrink(i); //if symmetry, there may be extra moves to ignore
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdx), %rax
cmpq $0x2, %rax
jb 0x1b994
cmpw $0x0, 0x6(%rax)
jne 0x1baf8
addq $0x18, %rbx
movb 0x9(%r15), %al
leaq 0x1aa0e(%rip), %rdx     # 0x363b1
movswl 0x2(%r15), %esi
movswl 0x4(%r15), %ecx
subl %ecx, %esi
xorl %ebp, %ebp
cmpb (%rdx), %al
cmovgel %ebp, %esi
leaq 0x70(%r14), %rdx
movq %rbx, %rdi
callq 0x1c250
movq %r15, %rdi
callq 0x13010
movq %rax, 0x8(%rsp)
movl %edx, 0x10(%rsp)
shrq $0x20, %rdx
movb %dl, 0x14(%rsp)
cmpw $-0x1, 0x12(%rsp)
je 0x1bad8
xorl %r12d, %r12d
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x8(%r15), %edx
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
callq 0x17b04
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movw $0x0, 0x28(%rsp)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x2a(%rsp)
movq %r12, 0x30(%rsp)
movl 0x1534(%r14), %edx
movzbl %al, %ecx
movl %edx, %esi
leaq 0x1a96a(%rip), %rdi     # 0x363b1
cmpb %al, (%rdi)
je 0x1ba4d
movl %ecx, %esi
leaq 0x1a955(%rip), %rax     # 0x363a9
cmpb %dl, (%rax)
cmovnel %esi, %ecx
leaq 0x1a94e(%rip), %rax     # 0x363ae
cmpb (%rax), %cl
jne 0x1ba73
movl $0x1, 0x18(%rsp)
movl $0x1, %eax
jmp 0x1ba9f
movb 0x8(%r15), %al
cmpb %al, %cl
jne 0x1ba87
movl $0x3fffffff, 0x18(%rsp) # imm = 0x3FFFFFFF
xorl %eax, %eax
jmp 0x1ba9f
movb $0x3, %dl
subb %al, %dl
xorl %eax, %eax
cmpb %dl, %cl
sete %al
movl $0x0, 0x18(%rsp)
orl $0x3ffffffe, %eax       # imm = 0x3FFFFFFE
movl %eax, 0x1c(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c446
movq %rax, %rdi
movq %r13, %rsi
callq 0x1c4a4
movq %r13, %rdi
callq 0x1c01e
incl %ebp
leaq 0x8(%rsp), %rdi
callq 0x13058
cmpw $-0x1, 0x12(%rsp)
jne 0x1b9f1
movl %ebp, %eax
lock
addq %rax, 0x58(%r14)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x1e890
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16b2b(%rip), %rdi     # 0x3262a
leaq 0x18062(%rip), %rsi     # 0x33b68
leaq 0x18162(%rip), %rcx     # 0x33c6f
movl $0x142, %edx            # imm = 0x142
callq 0x51d0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1c01e
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::gen_sgf(Morat::SGFPrinter<Morat::Move>&, unsigned int, Morat::Hex::AgentPNS::Node const&, Morat::Side) const
void AgentPNS::gen_sgf(SGFPrinter<Move> & sgf, unsigned int limit, const Node & node, Side side) const {
	for(auto & child : node.children){
		if(child.work >= limit && (side != node.to_outcome(~side) || child.to_outcome(side) == node.to_outcome(~side))){
			sgf.child_start();
			sgf.move(side, child.move);
			sgf.comment(child.to_s());
			gen_sgf(sgf, limit, child, ~side);
			sgf.child_end();
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movl %edx, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x18(%rcx), %rdx
leaq 0x10(%rdx), %rax
xorl %ebx, %ebx
movl $0x0, %r13d
cmpq $0x2, %rdx
cmovaeq %rax, %r13
jb 0x1bb72
movzwl 0x6(%rdx), %edx
shll $0x5, %edx
addq %rdx, %rax
movq %rax, %rbx
cmpq %rbx, %r13
je 0x1bccf
movl 0x8(%rsp), %r12d
movb $0x3, %bpl
subb %r8b, %bpl
movzbl %r8b, %eax
movl %eax, 0x14(%rsp)
movzbl %bpl, %eax
movl %eax, 0xc(%rsp)
movl %r8d, 0x10(%rsp)
cmpq %r12, 0x8(%r13)
jb 0x1bcc2
movl (%r14), %eax
movl %ebp, %esi
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
je 0x1bbdb
movl 0x4(%r14), %edx
movl %r8d, %esi
cmpl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
je 0x1bbdb
cmpl $0x3ffffffe, %edx       # imm = 0x3FFFFFFE
jne 0x1bbd1
leaq 0x1a7e2(%rip), %rdx     # 0x363b1
jmp 0x1bbd8
leaq 0x1a7d6(%rip), %rdx     # 0x363ae
movb (%rdx), %sil
cmpb %r8b, %sil
jne 0x1bc4b
cmpl $0x3fffffff, (%r13)     # imm = 0x3FFFFFFF
movl %r8d, %esi
je 0x1bc16
movl 0x4(%r13), %edx
movl %ebp, %esi
cmpl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
je 0x1bc16
cmpl $0x3ffffffe, %edx       # imm = 0x3FFFFFFE
jne 0x1bc0c
leaq 0x1a7a7(%rip), %rdx     # 0x363b1
jmp 0x1bc13
leaq 0x1a79b(%rip), %rdx     # 0x363ae
movb (%rdx), %sil
movl %ebp, %edx
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
je 0x1bc46
movl 0x4(%r14), %eax
movl %r8d, %edx
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
je 0x1bc46
cmpl $0x3ffffffe, %eax       # imm = 0x3FFFFFFE
jne 0x1bc3d
leaq 0x1a776(%rip), %rax     # 0x363b1
jmp 0x1bc44
leaq 0x1a76a(%rip), %rax     # 0x363ae
movb (%rax), %dl
cmpb %dl, %sil
jne 0x1bcc2
movq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x12a32
movzwl 0x12(%r13), %edx
movq %r15, %rdi
movl 0x14(%rsp), %esi
callq 0x12bfa
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x18fd0
movq %r15, %rdi
leaq 0x28(%rsp), %rsi
callq 0x12d46
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1bc97
callq 0x52e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %r15
movq %r15, %rsi
movl 0x8(%rsp), %edx
movq %r13, %rcx
movl 0xc(%rsp), %r8d
callq 0x1bb2c
movq %r15, %rdi
callq 0x12e2a
movl 0x10(%rsp), %r8d
addq $0x20, %r13
cmpq %rbx, %r13
jne 0x1bb9b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1bcf5
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agent.h
// Function: Morat::Hex::Agent::solve1ply(Morat::Hex::Board const&, unsigned int&)
static Outcome solve1ply(const Board & board, unsigned int & nodes) {
		Outcome outcome = Outcome::UNKNOWN;
		Side turn = board.to_play();
		for (auto move : board) {
			++nodes;
			Outcome won = board.test_outcome(move, turn);

			if(won == +turn)
				return won;
			if(won == Outcome::DRAW)
				outcome = Outcome::DRAW;
		}
		return outcome;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1a0fd(%rip), %rax     # 0x363ae
movb (%rax), %bl
movb 0x8(%rdi), %bpl
callq 0x13010
movq %rax, 0x8(%rsp)
movl %edx, 0x10(%rsp)
shrq $0x20, %rdx
movb %dl, 0x14(%rsp)
cmpw $-0x1, 0x12(%rsp)
je 0x1c328
movzbl %bpl, %ebp
leaq 0x4(%rsp), %r12
leaq 0x8(%rsp), %r13
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
incl (%r14)
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x17b04
cmpb %bpl, %al
je 0x1c326
leaq 0x1a0aa(%rip), %rcx     # 0x363b1
movb (%rcx), %cl
cmpb %cl, %al
movzbl %cl, %eax
movzbl %bl, %ebx
cmovel %eax, %ebx
movq %r13, %rdi
callq 0x13058
cmpw $-0x1, 0x12(%rsp)
jne 0x1c2e3
jmp 0x1c328
movl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agent.h
// Function: Morat::Hex::Agent::solve2ply(Morat::Hex::Board const&, unsigned int&)
static Outcome solve2ply(const Board & board, unsigned int & nodes) {
		int losses = 0;
		Outcome outcome = Outcome::UNKNOWN;
		Side turn = board.to_play();
		Side op = ~turn;
		for (auto move : board) {
			++nodes;
			Outcome won = board.test_outcome(move, turn);

			if(won == +turn)
				return won;
			if(won == Outcome::DRAW)
				outcome = Outcome::DRAW;

			if(board.test_outcome(move, op) == +op)
				losses++;
		}
		if(losses >= 2)
			return (Outcome)op;
		return outcome;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %r14
leaq 0x1a057(%rip), %rax     # 0x363ae
movb (%rax), %r12b
movb 0x8(%rdi), %bpl
callq 0x13010
movq %rax, 0x10(%rsp)
movl %edx, 0x18(%rsp)
shrq $0x20, %rdx
movb %dl, 0x1c(%rsp)
cmpw $-0x1, 0x1a(%rsp)
sete %bl
je 0x1c429
movb $0x3, %al
subb %bpl, %al
movl $0x0, 0x8(%rsp)
movb %bpl, 0x3(%rsp)
movzbl %bpl, %r15d
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
incl (%rax)
movq %r14, %rdi
leaq 0xc(%rsp), %rbp
movq %rbp, %rsi
movl %r15d, %edx
callq 0x17b04
movl %eax, %r13d
cmpb %r15b, %al
je 0x1c3fc
leaq 0x19fe0(%rip), %rax     # 0x363b1
movzbl (%rax), %eax
cmpb %al, %r13b
movzbl %r12b, %r12d
cmovel %eax, %r12d
movq %r14, %rdi
movq %rbp, %rsi
movl 0x4(%rsp), %ebp
movl %ebp, %edx
callq 0x17b04
xorl %ecx, %ecx
cmpb %bpl, %al
sete %cl
addl %ecx, 0x8(%rsp)
cmpb 0x3(%rsp), %r13b
je 0x1c418
leaq 0x10(%rsp), %rdi
callq 0x13058
cmpw $-0x1, 0x1a(%rsp)
sete %bl
jne 0x1c3a0
cmpl $0x2, 0x8(%rsp)
movzbl %r12b, %r12d
cmovgel 0x4(%rsp), %r12d
jmp 0x1c429
movzbl %r12b, %ecx
movzbl %r13b, %eax
testb $0x1, %bl
cmovnel %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::Node::operator=(Morat::Hex::AgentPNS::Node const&)
Node & operator = (const Node & n){
			if(this != & n){ //don't copy to self
				//don't copy to a node that already has children
				assert(children.empty());

				phi = n.phi;
				delta = n.delta;
				work = n.work;
				move = n.move;
				//don't copy the children
			}
			return *this;
		}

// Assembly:
cmpq %rsi, %rdi
je 0x1c4d0
movq 0x18(%rdi), %rax
cmpq $0x2, %rax
jb 0x1c4ba
cmpw $0x0, 0x6(%rax)
jne 0x1c4d4
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movzwl 0x12(%rsi), %eax
movw %ax, 0x12(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x16154(%rip), %rdi     # 0x32630
leaq 0x17823(%rip), %rsi     # 0x33d06
leaq 0x1784f(%rip), %rcx     # 0x33d39
movl $0x2d, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::~AgentPNS()
~AgentPNS(){
		pool.pause();
		pool.set_num_threads(0);

		root.dealloc(ctmem);
		ctmem.compact();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d556(%rip), %rax     # 0x49b10
movq %rax, (%rdi)
leaq 0x1430(%rdi), %r14
movq %r14, %rdi
callq 0x1d134
movq %r14, %rdi
xorl %esi, %esi
callq 0x1d1a8
leaq 0x1540(%rbx), %r12
leaq 0x70(%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1c4f4
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
movq %r15, %rdi
callq 0x1d340
movq %r12, %rdi
callq 0x1c01e
movq %r14, %rdi
callq 0x1d7ae
movq %r15, %rdi
callq 0x1d7f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1350c
movq %rax, %rdi
callq 0xa7e4
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::set_board(Morat::Hex::Board const&, bool)
void set_board(const Board & board, bool clear = true){
		rootboard = board;
		reset();
		if(clear)
			clear_mem();
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x8(%rsi), %eax
movw %ax, 0x18(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
addq $0x20, %rdi
addq $0x10, %rsi
callq 0x13648
vmovups 0x28(%r14), %xmm0
vmovups %xmm0, 0x38(%rbx)
movq 0x38(%r14), %rax
movq %rax, 0x48(%rbx)
leaq 0x50(%rbx), %rdi
addq $0x40, %r14
movq %r14, %rsi
callq 0x13732
movq $0x0, 0x1518(%rbx)
movb $0x0, 0x8(%rbx)
testl %ebp, %ebp
je 0x1c6bf
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::clear_mem()
void clear_mem(){
		reset();
		root.dealloc(ctmem);
		ctmem.compact();
		root = Node(0, 0, 1);
		nodes = 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
movq %r12, 0x1518(%rdi)
movb $0x0, 0x8(%rdi)
leaq 0x1540(%rdi), %r14
leaq 0x70(%rdi), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c4f4
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
movq %r15, %rdi
callq 0x1d340
movabsq $0x100000001, %rax      # imm = 0x100000001
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r12, 0x18(%rsi)
movq %r12, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x1c4a4
leaq 0x8(%rsp), %rdi
callq 0x1c01e
movq $0x0, 0x58(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1c01e
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::gen_sgf(Morat::SGFPrinter<Morat::Move>&, int) const
void gen_sgf(SGFPrinter<Move> & sgf, int limit) const {
		if(limit < 0){
			limit = 0;
			//TODO: Set the root.work properly
			for(auto & child : root.children)
				limit += child.work;
			limit /= 1000;
		}
		gen_sgf(sgf, limit, root, rootboard.to_play());
	}

// Assembly:
testl %edx, %edx
jns 0x1cff5
movq 0x1558(%rdi), %r9
leaq 0x10(%r9), %r8
xorl %edx, %edx
movl $0x0, %eax
movl $0x0, %ecx
cmpq $0x2, %r9
cmovaeq %r8, %rax
jb 0x1cf3d
movzwl 0x6(%r9), %ecx
shll $0x5, %ecx
addq %rcx, %r8
movq %r8, %rcx
cmpq %rcx, %rax
je 0x1cff5
subq %rax, %rcx
addq $-0x20, %rcx
vpbroadcastq %rcx, %zmm0
shrq $0x5, %rcx
addq $0x8, %rcx
andq $-0x8, %rcx
vpsrlq $0x5, %zmm0, %zmm0
vpxor %xmm4, %xmm4, %xmm4
xorl %edx, %edx
vpmovsxbq 0x152b2(%rip), %zmm1 # 0x32228
vpmovzxbd 0x169f9(%rip), %ymm2 # 0x33978
vmovdqa %ymm4, %ymm3
vpbroadcastq %rdx, %zmm4
vporq %zmm1, %zmm4, %zmm4
vpcmpleuq %zmm0, %zmm4, %k1
kmovq %k1, %k2
vpxor %xmm4, %xmm4, %xmm4
vpgatherdq 0x8(%rax,%ymm2), %zmm4 {%k2}
vpmovqd %zmm4, %ymm4
vpaddd %ymm4, %ymm3, %ymm4
addq $0x8, %rdx
addq $0x100, %rax            # imm = 0x100
cmpq %rdx, %rcx
jne 0x1cf7f
vmovdqa32 %ymm4, %ymm3 {%k1}
vextracti128 $0x1, %ymm3, %xmm0
vphaddd %xmm3, %xmm0, %xmm0
vphaddd %xmm0, %xmm0, %xmm0
vphaddd %xmm0, %xmm0, %xmm0
vmovd %xmm0, %eax
cltq
imulq $0x10624dd3, %rax, %rdx # imm = 0x10624DD3
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x26, %rdx
addl %eax, %edx
leaq 0x1540(%rdi), %rcx
movl 0x18(%rdi), %r8d
vzeroupper
jmp 0x1bb2c
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentPNS::Node>::Data::shrink(int)
int shrink(int n){
			assert(n > 0 && n <= capacity && n <= used);
			for(Node * i = children + n, * e = children + used; i != e; ++i)
				i->~Node();
			int diff = used - n;
			used = n;
			return diff;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x1e8f6
movl %esi, %ebx
movq %rdi, %r14
movzwl 0x4(%rdi), %eax
cmpl %esi, %eax
jl 0x1e8f6
movzwl 0x6(%r14), %r12d
cmpl %ebx, %r12d
jl 0x1e8f6
movl %ebx, %eax
cmpq %r12, %rax
je 0x1e8de
leaq 0x10(%r14), %r15
shlq $0x5, %rax
addq %rax, %r15
shll $0x5, %r12d
subq %rax, %r12
movq %r15, %rdi
callq 0x1c01e
addq $0x20, %r15
addq $-0x20, %r12
jne 0x1e8cc
movzwl 0x6(%r14), %eax
subl %ebx, %eax
movw %bx, 0x6(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x15b8a(%rip), %rdi     # 0x34487
leaq 0x13f41(%rip), %rsi     # 0x32845
leaq 0x15ba0(%rip), %rcx     # 0x344ab
movl $0x4e, %edx
callq 0x51d0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/board.cpp
// Function: Morat::Hex::Board::edges(int, int) const
int Board::edges(int x, int y) const {
	return (y == 0       ? 1 : 0) |
	       (y == sizem1_ ? 2 : 0) |
	       (x == 0       ? 4 : 0) |
	       (x == sizem1_ ? 8 : 0);
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
sete %al
movsbl 0x1(%rdi), %ecx
xorl %edi, %edi
cmpl %edx, %ecx
sete %dil
xorl %edx, %edx
testl %esi, %esi
sete %dl
xorl %r8d, %r8d
cmpl %esi, %ecx
leal (%rax,%rdx,4), %eax
sete %r8b
leal (%rax,%rdi,2), %eax
leal (%rax,%r8,8), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/board.cpp
// Function: Morat::Hex::Board::gen_neighbor_list() const
std::shared_ptr<MoveValid> Board::gen_neighbor_list() const {
	std::shared_ptr<MoveValid> list(new MoveValid[vec_size()*18]);
	MoveValid * a = list.get();
	for(int y = 0; y < size_; y++){
		for(int x = 0; x < size_; x++){
			Move pos(x,y);

			for(int i = 0; i < 18; i++){
				Move loc = pos + neighbor_offsets[i];
				*a = MoveValid(loc, (on_board(loc) ? xy(loc) : -1) );
				++a;
			}
		}
	}

	return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rsi), %ebp
movl %ebp, %eax
imull %eax, %eax
addl %eax, %eax
leal (%rax,%rax,8), %r15d
leaq (,%r15,4), %rdi
callq 0x5030
testl %ebp, %ebp
je 0x202a0
leaq (%rax,%r15,4), %rcx
movq %rax, %rdx
movl $0xffff78fc, (%rdx)     # imm = 0xFFFF78FC
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x20291
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x20474
cmpb $0x0, (%r14)
jle 0x2034e
movq (%rbx), %r8
xorl %eax, %eax
leaq 0x1444b(%rip), %rcx     # 0x34710
cmpb $0x0, (%r14)
jle 0x20340
xorl %edx, %edx
movq %r8, %rsi
xorl %edi, %edi
movb 0x1(%rdi,%rcx), %r11b
addb %dl, %r11b
movb (%rdi,%rcx), %bpl
addb %al, %bpl
movzbl %r11b, %r8d
movl $0xffff0000, %r9d       # imm = 0xFFFF0000
movl %r11d, %r10d
orb %bpl, %r10b
movzbl %bpl, %r10d
js 0x20313
movb (%r14), %r15b
cmpb %r15b, %r11b
jge 0x20313
cmpb %r15b, %bpl
jge 0x20313
movsbl (%r14), %r9d
imull %r10d, %r9d
addl %r8d, %r9d
shll $0x10, %r9d
shll $0x8, %r8d
orl %r10d, %r8d
orl %r9d, %r8d
movl %r8d, (%rsi,%rdi)
addq $0x4, %rdi
cmpq $0x48, %rdi
jne 0x202d2
incl %edx
movsbl (%r14), %r9d
leaq (%rsi,%rdi), %r8
cmpl %r9d, %edx
jl 0x202cd
addq %rdi, %rsi
movq %rsi, %r8
incl %eax
movsbl (%r14), %edx
cmpl %edx, %eax
jl 0x202c5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/gtpagent.cpp
// Function: Morat::Hex::GTP::gtp_move_stats(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::gtp_move_stats(vecstr args){
	vector<Move> moves;
	for(auto s : args)
		moves.push_back(Move(s));
	return GTPResponse(true, agent->move_stats(moves));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%rdx), %rbp
movq 0x8(%rdx), %rbx
cmpq %rbx, %rbp
je 0x205bd
leaq 0x48(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0xe(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r14, 0x38(%rsp)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xa866
movq %r12, %rdi
movq %r15, %rsi
callq 0x11286
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x2059a
movzwl 0xe(%rsp), %eax
movw %ax, (%rsi)
addq $0x2, 0x18(%rsp)
jmp 0x205a5
movq %r13, %rdi
movq %r12, %rdx
callq 0x1584a
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x205b4
callq 0x52e0
addq $0x20, %rbp
cmpq %rbx, %rbp
jne 0x2055b
movq 0x30(%rsp), %rax
movq 0xd8(%rax), %rsi
movq (%rsi), %rax
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq *0x48(%rax)
leaq 0x58(%rsp), %rdx
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xa7f0
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20603
callq 0x52e0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20612
callq 0x52e0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x2064b
jmp 0x20650
jmp 0x20639
movq %rax, %rbx
jmp 0x20650
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x20650
callq 0x52e0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2065f
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
nop