LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint32>::RandomMoveIterator(Morat::Pentago::Board const&, Morat::XORShift_uint32&, int)
RandomMoveIterator(const Board & b, Rand & r, int Unique = -1) : base_board(b), rand(r), moves(NULL), cur(0) {
		moves = new Move[b.moves_avail()];

		for(MoveIterator it(b, Unique); !it.done(); ++it)
			moves[cur++] = *it;

//		logerr("\n");
		++(*this); //find the first valid move
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x19ad7(%rip), %rax     # 0x24c12
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, (%rdi)
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
vmovups %xmm0, 0x8(%rdi)
vmovups %xmm0, 0x11(%rdi)
movb (%rax), %al
movb %al, 0x21(%rdi)
leaq 0x19ab5(%rip), %rax     # 0x24c15
movb (%rax), %al
movb %al, 0x22(%rdi)
movw $0xdead, 0x24(%rdi)     # imm = 0xDEAD
andq $0x0, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
andl $0x0, 0x40(%rdi)
movq %rsi, %rdi
callq 0xb90a
movslq %eax, %r15
leaq (%r15,%r15), %rax
testl %r15d, %r15d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x5030
testl %r15d, %r15d
je 0xb1b5
leaq (%rax,%r15,2), %rcx
movq %rax, %rdx
movw $0xefc, (%rdx)          # imm = 0xEFC
addq $0x2, %rdx
cmpq %rcx, %rdx
jne 0xb1a7
leaq 0x8(%rsp), %r15
movq %rax, 0x38(%rbx)
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rdi
callq 0xb2ac
cmpb $0x24, 0x38(%rsp)
jge 0xb1f3
movslq 0x40(%rbx), %rcx
movq 0x38(%rbx), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x40(%rbx)
movzwl 0x38(%rsp), %edx
movw %dx, (%rax,%rcx,2)
movq %r15, %rdi
callq 0xb372
jmp 0xb1cb
leaq 0x40(%rsp), %rdi
callq 0xb916
movq %rbx, %rdi
callq 0xb226
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rdi
movq %rax, %rbx
callq 0xb916
movq %rbx, %rdi
callq 0x5690
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint32>::operator++()
RandomMoveIterator & operator ++ (){ //prefix form
		cur--;
		if(cur >= 0){
			choose_rand();
			after = base_board;
			bool move_success = after.move(moves[cur]);
			assert(move_success);
		}
		return *this;
	}

// Assembly:
pushq %rbx
movl 0x40(%rdi), %eax
movq %rdi, %rbx
leal -0x1(%rax), %ecx
movl %ecx, 0x40(%rdi)
testl %eax, %eax
jle 0xb26f
movq %rbx, %rdi
callq 0xbc48
movq (%rbx), %rax
movq 0x38(%rbx), %rcx
leaq 0x8(%rbx), %rdi
vmovups (%rax), %ymm0
vmovups %ymm0, 0x8(%rbx)
movq 0x20(%rax), %rax
movq %rax, 0x28(%rbx)
movslq 0x40(%rbx), %rax
movzwl (%rcx,%rax,2), %esi
vzeroupper
callq 0xad6a
testb %al, %al
je 0xb274
movq %rbx, %rax
popq %rbx
retq
leaq 0x14fc5(%rip), %rdi     # 0x20240
leaq 0x1509a(%rip), %rsi     # 0x2031c
leaq 0x15132(%rip), %rcx     # 0x203bb
pushq $0x6b
popq %rdx
callq 0x5220
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::MoveIterator::MoveIterator(Morat::Pentago::Board const&, int)
MoveIterator(const Board & b, int Unique = -1) : base_board(b), move(M_SWAP) {
		unique = (Unique == -1 ? base_board.moves_made() <= Board::unique_depth : Unique);

		if(base_board.outcome() >= Outcome::DRAW){
			move = Move(36, 8); //already done
		} else {
			if(unique)
				hashes.init(base_board.moves_avail());
			++(*this); //find the first valid move
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1995b(%rip), %rax     # 0x24c12
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, (%rdi)
leaq 0x38(%rdi), %rbx
movq %rdi, %r14
vmovups %xmm0, 0x8(%rdi)
vmovups %xmm0, 0x11(%rdi)
movb (%rax), %al
movb %al, 0x21(%rdi)
leaq 0x1993a(%rip), %rax     # 0x24c15
movb (%rax), %al
movb %al, 0x22(%rdi)
movw $0xdead, 0x24(%rdi)     # imm = 0xDEAD
andq $0x0, 0x28(%rdi)
movw $0xeff, 0x30(%rdi)      # imm = 0xEFF
andq $0x0, 0x38(%rdi)
andl $0x0, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
xorl %eax, %eax
cmpb $0xb, 0x18(%rsi)
setb %al
xorl %ecx, %ecx
testl %edx, %edx
setne %cl
cmpl $-0x1, %edx
cmovnel %ecx, %eax
movb %al, 0x32(%rdi)
movq %rsi, %rdi
callq 0xa9d0
leaq 0x198f2(%rip), %rcx     # 0x24c19
cmpb (%rcx), %al
jge 0xb34e
cmpb $0x1, 0x32(%r14)
jne 0xb344
movq (%r14), %rdi
callq 0xb90a
movq %rbx, %rdi
movl %eax, %esi
callq 0xb8b8
movq %r14, %rdi
callq 0xb372
jmp 0xb355
movw $0x824, 0x30(%r14)      # imm = 0x824
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xb35f
movq %rbx, %rdi
movq %rax, %r14
callq 0xb916
movq %r14, %rdi
callq 0x5690
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::MoveIterator::operator++()
MoveIterator & operator ++ (){ //prefix form
		while(true){
			move.r++;
			if(move.r >= 8){
				move.r = 0;
				do{
					move.l++;
					if(move.l >= 36) //done
						return *this;
				}while(!base_board.valid_move_fast(move));
			}
			after = base_board;
			bool move_success = after.move(move);
			assert(move_success);
			if(unique){
				uint64_t h = after.full_hash();
				if(!hashes.add(h))
					continue;
			}
			break;
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x174bf(%rip), %r12     # 0x22840
leaq 0x8(%rdi), %r14
leaq 0x38(%rdi), %r15
movq %rdi, %rbx
movb 0x31(%rbx), %cl
incb %cl
movb %cl, 0x31(%rbx)
movq (%rbx), %rax
cmpb $0x8, %cl
jl 0xb3bd
movb $0x0, 0x31(%rbx)
movb 0x30(%rbx), %cl
leal 0x1(%rcx), %edx
cmpb $0x23, %dl
jg 0xb3ff
movsbq %dl, %rcx
movq (%r12,%rcx,8), %rsi
movl %edx, %ecx
testq %rsi, (%rax)
jne 0xb3a3
movb %dl, 0x30(%rbx)
movq 0x20(%rax), %rcx
movq %r14, %rdi
movq %rcx, 0x20(%r14)
vmovups (%rax), %ymm0
vmovups %ymm0, (%r14)
movl 0x30(%rbx), %esi
vzeroupper
callq 0xad6a
testb %al, %al
je 0xb413
cmpb $0x1, 0x32(%rbx)
jne 0xb404
movq %r14, %rdi
callq 0xb97c
movq %r15, %rdi
movq %rax, %rsi
callq 0xbaa8
testb %al, %al
je 0xb38c
jmp 0xb404
incb %cl
movb %cl, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x14e26(%rip), %rdi     # 0x20240
leaq 0x14efb(%rip), %rsi     # 0x2031c
leaq 0x14f0b(%rip), %rcx     # 0x20333
pushq $0x31
popq %rdx
callq 0x5220
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/../lib/bits.h
// Function: Morat::mix_bits(unsigned long)
inline uint64_t mix_bits(uint64_t h){
	h ^= h >> 33;
	h *= 0xff51afd7ed558ccdull;
	h ^= h >> 33;
	h *= 0xc4ceb9fe1a85ec53ull;
	h ^= h >> 33;
	return h;
}

// Assembly:
movq %rdi, %rax
shrq $0x21, %rax
movabsq $-0xae502812aa7333, %rcx # imm = 0xFF51AFD7ED558CCD
movabsq $-0x3b314601e57a13ad, %rdx # imm = 0xC4CEB9FE1A85EC53
xorq %rdi, %rax
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
imulq %rax, %rdx
movq %rdx, %rax
shrq $0x21, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::won_calc() const
Outcome won_calc() const {
		Outcome wonside = Outcome::DRAW;
		uint64_t ws = sides[1];
		uint64_t bs = sides[2];

		for(int i = 0; i < 32; i++){
			uint64_t wm = winmaps[i];
			if     ((ws & wm) == wm) wonside |= Outcome::P1;
			else if((bs & wm) == wm) wonside |= Outcome::P2;
		}

		if(wonside == Outcome::P1 || wonside == Outcome::P2)
			return wonside;
		if(wonside == Outcome::DRAW2) // both sides win simultaneously
			return Outcome::DRAW;
		return (num_moves_ >= 36 ? Outcome::DRAW : Outcome::UNKNOWN);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1966e(%rip), %rax     # 0x24c19
leaq 0x19669(%rip), %r11     # 0x24c1b
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %r8
xorl %r10d, %r10d
movb (%rax), %cl
leaq 0x19654(%rip), %rax     # 0x24c1a
movb (%r11), %dl
leaq 0x173a0(%rip), %r11     # 0x22970
movb (%rax), %r9b
movzbl %dl, %ebx
movl %ecx, %eax
cmpq $0x20, %r10
je 0xb603
movq (%r11,%r10,8), %r14
andnq %r14, %rsi, %r15
jne 0xb5ee
orb %r9b, %al
jmp 0xb5fe
andnq %r14, %r8, %r14
movl $0x0, %ebp
cmovel %ebx, %ebp
orb %bpl, %al
incq %r10
jmp 0xb5d8
cmpb %r9b, %al
sete %sil
cmpb %dl, %al
sete %dl
orb %sil, %dl
jne 0xb637
leaq 0x19601(%rip), %rdx     # 0x24c1c
cmpb (%rdx), %al
jne 0xb623
movl %ecx, %eax
jmp 0xb637
leaq 0x195ec(%rip), %rax     # 0x24c16
cmpb $0x24, 0x18(%rdi)
movzbl %cl, %ecx
movzbl (%rax), %eax
cmovael %ecx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::score_calc() const
int16_t score_calc() const {
		int16_t s = 0;
		uint64_t ws = sides[1];
		uint64_t bs = sides[2];

		//calculate score from white's perspective
		for(int i = 0; i < 32; i++){
			uint64_t wm = winmaps[i];
			uint64_t w = (ws & wm);
			uint64_t b = (bs & wm);

			if     (w && !b) s += scoremap[bitcount(w)];
			else if(!w && b) s -= scoremap[bitcount(b)];
		}
		//return the score from the perspective of the player that just played
		//ie not the player whose turn it is now
		return (to_play_ == Side::P1 ? -s : s);
	}

// Assembly:
pushq %rbp
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
leaq 0x1724d(%rip), %r8      # 0x22970
leaq 0x17236(%rip), %r9      # 0x22960
xorl %esi, %esi
xorl %ecx, %ecx
cmpq $0x20, %rsi
je 0xb77e
movq (%r8,%rsi,8), %r10
movq %r10, %r11
andq %rax, %r11
sete %bl
andq %rdx, %r10
setne %bpl
orb %bl, %bpl
je 0xb76f
testq %r10, %r10
setne %bl
testq %r11, %r11
sete %r11b
andb %bl, %r11b
cmpb $0x1, %r11b
jne 0xb779
popcntq %r10, %r10
subw (%r9,%r10,2), %cx
jmp 0xb779
popcntq %r11, %r10
addw (%r9,%r10,2), %cx
incq %rsi
jmp 0xb72e
leaq 0x1948d(%rip), %rsi     # 0x24c12
movb 0x19(%rdi), %dl
movl %ecx, %eax
negl %eax
cmpb (%rsi), %dl
cmovnel %ecx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::full_hash() const
uint64_t full_hash() const {
		if(num_moves_ >= fullhash_depth)
			return simple_hash();

		if(cached_hash)
			return cached_hash;

		Board b(*this);

		uint64_t h, m = ~0ull;
		choose(m, (h = b.simple_hash()));
		choose(m, (h = rotate_hash(h) ));
		choose(m, (h = rotate_hash(h) ));
		choose(m, (    rotate_hash(h) ));
		b.flip_board();
		choose(m, (h = b.simple_hash()));
		choose(m, (h = rotate_hash(h) ));
		choose(m, (h = rotate_hash(h) ));
		choose(m, (    rotate_hash(h) ));

		cached_hash = m;
		return m;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpb $0x7, 0x18(%rdi)
movq %rdi, %rbx
jb 0xb9a7
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xae62
movq 0x20(%rbx), %rax
testq %rax, %rax
jne 0xba9a
movq 0x20(%rbx), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rax, 0x20(%r15)
vmovups (%rbx), %ymm0
vmovups %ymm0, (%r15)
vzeroupper
callq 0xae62
movq %rax, %r14
movl %r14d, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
movl $0x2d0f, %r12d          # imm = 0x2D0F
movl %r14d, %edx
movabsq $0xfffe00000000000, %r13 # imm = 0xFFFE00000000000
movq %r15, %rdi
bextrq %r12, %rax, %rax
shlq $0x2d, %rcx
orq %rax, %rcx
cmpq %rcx, %r14
movq %rcx, %rax
cmovbq %r14, %rax
andl $0x3fff8000, %edx       # imm = 0x3FFF8000
shrq $0xf, %rcx
shlq $0x1e, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovaeq %rdx, %rax
shlq $0xf, %r14
shrq $0xf, %rdx
andq %r13, %r14
orq %rdx, %r14
cmpq %r14, %rax
cmovbq %rax, %r14
callq 0xbae4
movq %r15, %rdi
callq 0xae62
cmpq %rax, %r14
movl %eax, %edx
cmovaeq %rax, %r14
andl $0x7fff, %edx           # imm = 0x7FFF
bextrq %r12, %rax, %rcx
shlq $0x2d, %rdx
orq %rcx, %rdx
movl %eax, %ecx
cmpq %rdx, %r14
cmovaeq %rdx, %r14
andl $0x3fff8000, %ecx       # imm = 0x3FFF8000
shrq $0xf, %rdx
shlq $0x1e, %rcx
orq %rdx, %rcx
cmpq %rcx, %r14
cmovaeq %rcx, %r14
shlq $0xf, %rax
shrq $0xf, %rcx
andq %r13, %rax
orq %rcx, %rax
cmpq %rax, %r14
cmovbq %r14, %rax
movq %rax, 0x20(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/../lib/hashset.h
// Function: Morat::HashSet::add(unsigned long)
bool add(uint64_t h){
		h = mix_bits(h);
		unsigned int i = h & mask;
		while(true){
			uint64_t t = table[i];
			if (t == 0) {
				table[i] = h;
				count++;
				return true;
			} else if (t == h) {
				return false;
			}
			i = (i+1) & mask;
		}
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb44d
movl 0x4(%rbx), %ecx
movq 0x10(%rbx), %rsi
movl %eax, %edx
andl %ecx, %edx
movl %edx, %edx
movq (%rsi,%rdx,8), %rdi
testq %rdi, %rdi
je 0xbad5
cmpq %rax, %rdi
je 0xbadc
incl %edx
andl %ecx, %edx
jmp 0xbabf
movq %rax, (%rsi,%rdx,8)
incl 0x8(%rbx)
testq %rdi, %rdi
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint32>::choose_rand()
void choose_rand(){
		// incremental fisher-yates shuffle. Choose a random element that hasn't yet been chosen.
		int j = rand() % (cur+1);
		Move tmp = moves[j];
		moves[j] = moves[cur];
		moves[cur] = tmp;
//		logerr(moves[cur].to_s() + " ");
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xb794
movslq 0x40(%rbx), %rcx
xorl %edx, %edx
leal 0x1(%rcx), %esi
divl %esi
movq 0x38(%rbx), %rax
movslq %edx, %rdx
movzwl (%rax,%rcx,2), %ecx
movzwl (%rax,%rdx,2), %esi
movw %cx, (%rax,%rdx,2)
movq 0x38(%rbx), %rax
movslq 0x40(%rbx), %rcx
movw %si, (%rax,%rcx,2)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::AgentMCTS()
AgentMCTS::AgentMCTS() : pool(this) {
	nodes = 0;
	runs = 0;
	gclimit = 5;

	profile     = false;
	ponder      = false;
//#ifdef SINGLE_THREAD ... make sure only 1 thread
	numthreads  = 1;
	pool.set_num_threads(numthreads);
	maxmem      = 1000*1024*1024;

	explore     = 1;
	parentexplore = true;
	knowledge   = true;
	useexplore  = 1;
	fpurgency   = 1;
	rollouts    = 10;

	keeptree    = true;
	minimax     = 1;
	visitexpand = 1;
	prunesymmetry = true;
	gcsolved    = 100000;

	win_score = 1;

	instantwin  = 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe9fa
leaq 0x23965(%rip), %rax     # 0x309a8
vxorps %xmm0, %xmm0, %xmm0
leaq 0xa8(%rbx), %r14
movq %rax, (%rbx)
leaq 0x17bba(%rip), %rax     # 0x24c12
vmovups %xmm0, 0x80(%rbx)
vmovups %xmm0, 0x89(%rbx)
movq %r14, %rdi
movb (%rax), %al
movb %al, 0x99(%rbx)
leaq 0x17b9b(%rip), %rax     # 0x24c15
movb (%rax), %al
movb %al, 0x9a(%rbx)
movw $0xdead, 0x9c(%rbx)     # imm = 0xDEAD
andq $0x0, 0xa0(%rbx)
callq 0xea36
leaq 0xe8(%rbx), %r15
movq %r15, %rdi
callq 0xea60
leaq 0x14a8(%rbx), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xeabe
andq $0x0, 0xc8(%rbx)
andq $0x0, 0xd8(%rbx)
xorl %eax, %eax
movl $0x5, 0xd0(%rbx)
movb %al, 0x48(%rbx)
movb %al, 0x38(%rbx)
movl $0x1, 0x3c(%rbx)
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0xeb2c
vbroadcastss 0x1345a(%rip), %xmm0 # 0x20550
movb $0x1, %al
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq $0x3e800000, 0x40(%rbx) # imm = 0x3E800000
movl $0x3f800000, 0x4c(%rbx) # imm = 0x3F800000
movb %al, 0x49(%rbx)
movb %al, 0x50(%rbx)
vmovlps %xmm0, 0x54(%rbx)
movl $0xa, 0x5c(%rbx)
movb %al, 0x60(%rbx)
movq %rcx, 0x64(%rbx)
movabsq $0x1000186a0, %rcx      # imm = 0x1000186A0
movb %al, 0x6c(%rbx)
movq %rcx, 0x70(%rbx)
andl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %rax, %rbx
callq 0xec98
jmp 0xd15b
movq %rax, %rbx
movq %r15, %rdi
callq 0xecd6
jmp 0xd168
movq %rax, %rbx
movq %r14, %rdi
callq 0xed1e
movq %rbx, %rdi
callq 0x5690
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::get_pv() const
std::vector<Move> AgentMCTS::get_pv() const {
	vecmove pv;

	const Node * n = & root;
	Side turn = rootboard.to_play();
	while(n && !n->children.empty()){
		Move m = return_move(n, turn);
		pv.push_back(m);
		n = find_child(n, m);
		turn = ~turn;
	}

	if(pv.size() == 0)
		pv.push_back(Move(M_RESIGN));

	return pv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
vxorps %xmm0, %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
addq $0xa8, %r14
leaq 0x4(%rsp), %r15
movq %rdi, %rbx
vmovups %xmm0, (%rdi)
movb 0x99(%rsi), %bpl
testq %r14, %r14
je 0xd8a0
movq 0x18(%r14), %rax
cmpq $0x2, %rax
jb 0xd8a0
cmpw $0x0, 0x6(%rax)
je 0xd8a0
movzbl %bpl, %edx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xd8de
movw %ax, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb430
movq %r14, %rsi
movq %r15, %rdx
callq 0xdb14
movb $0x3, %cl
movq %rax, %r14
subb %bpl, %cl
movl %ecx, %ebp
jmp 0xd855
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
jne 0xd8bb
leaq 0x6(%rsp), %rsi
movw $0xefe, (%rsi)          # imm = 0xEFE
movq %rbx, %rdi
callq 0xbdb8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd8cb
movq %rbx, %rdi
movq %rax, %r14
callq 0x947e
movq %r14, %rdi
callq 0x5690
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::move_stats[abi:cxx11](std::vector<Morat::Pentago::Move, std::allocator<Morat::Pentago::Move>>) const
std::string AgentMCTS::move_stats(vecmove moves) const {
	std::string s = "";
	const Node * node = & root;

	if(moves.size()){
		s += "path:\n";
		for(auto m : moves){
			if(node){
				node = find_child(node, m);
				s += node->to_s() + "\n";
			}
		}
	}

	if(node){
		s += "children:\n";
		for(auto & n : node->children)
			s += n.to_s() + "\n";
	}
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
leaq 0x11ca2(%rip), %rsi     # 0x1f819
leaq 0x8(%rsp), %rdx
movq %rdi, %rbx
callq 0x5130
addq $0xa8, %r14
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0xdc28
leaq 0x12b6a(%rip), %rsi     # 0x20709
movq %rbx, %rdi
callq 0x56e0
movq (%r15), %r13
movq 0x8(%r15), %r15
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %rbp
cmpq %r15, %r13
je 0xdc1f
movzwl (%r13), %eax
movw %ax, 0x6(%rsp)
testq %r14, %r14
je 0xdc16
leaq 0x6(%rsp), %rdx
movq %r14, %rsi
callq 0xdb14
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq 0xbe90
leaq 0x11c2a(%rip), %rdx     # 0x1f818
movq %rbp, %rdi
movq %r12, %rsi
callq 0x7b4d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5730
movq %rbp, %rdi
callq 0x5170
movq %r12, %rdi
callq 0x5170
jmp 0xdc19
xorl %r14d, %r14d
addq $0x2, %r13
jmp 0xdbb8
testq %r14, %r14
je 0xdcae
leaq 0x12ae1(%rip), %rsi     # 0x20710
movq %rbx, %rdi
callq 0x56e0
movq 0x18(%r14), %rcx
xorl %ebp, %ebp
movl $0x0, %r14d
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r14
jb 0xdc5e
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %rbp
leaq 0x28(%rsp), %r15
leaq 0x11bae(%rip), %r12     # 0x1f818
leaq 0x8(%rsp), %r13
cmpq %rbp, %r14
je 0xdcae
movq %r15, %rdi
movq %r14, %rsi
callq 0xbe90
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7b4d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5730
movq %r13, %rdi
callq 0x5170
movq %r15, %rdi
callq 0x5170
addq $0x20, %r14
jmp 0xdc6f
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdcc8
jmp 0xdcd2
jmp 0xdcc8
jmp 0xdccd
movq %rax, %r14
jmp 0xdce9
movq %rax, %r14
jmp 0xdcdf
leaq 0x8(%rsp), %rdi
movq %rax, %r14
callq 0x5170
leaq 0x28(%rsp), %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x5170
movq %r14, %rdi
callq 0x5690
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::garbage_collect(Morat::Pentago::Board&, Morat::Pentago::AgentMCTS::Node*)
void AgentMCTS::garbage_collect(Board & board, Node * node){
	Node * child = node->children.begin(),
		 * end = node->children.end();

	Side to_play = board.to_play();
	for( ; child != end; child++){
		if(child->children.num() == 0)
			continue;

		if(	(node->outcome >= Outcome::DRAW && child->exp.num() > gcsolved && (node->outcome != to_play || child->outcome == to_play || child->outcome == Outcome::DRAW)) || //parent is solved, only keep the proof tree, plus heavy draws
			(node->outcome <  Outcome::DRAW && child->exp.num() > (child->outcome >= Outcome::DRAW ? gcsolved : gclimit)) ){ // only keep heavy nodes, with different cutoffs for solved and unsolved
			board.move(child->move);
			garbage_collect(board, child);
			board.undo(child->move);
		}else{
			nodes -= child->dealloc(ctmem);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rdx), %rcx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x0, %r12d
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r12
jb 0xdd39
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %r13
movb 0x19(%r14), %al
leaq 0xe8(%r15), %rcx
addq $0x14, %r12
leaq 0x70(%r15), %rdx
movq %rcx, 0x20(%rsp)
leaq 0xd0(%r15), %rcx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movb %al, 0xf(%rsp)
leaq -0x14(%r12), %rbp
cmpq %r13, %rbp
je 0xde26
movq 0x4(%r12), %rax
cmpq $0x2, %rax
jb 0xde1d
cmpw $0x0, 0x6(%rax)
je 0xde1d
leaq 0x16e84(%rip), %rax     # 0x24c19
movb 0x12(%rbx), %cl
movq -0xc(%r12), %rdx
movb (%rax), %al
cmpb %al, %cl
jge 0xddbc
cmpb %al, -0x2(%r12)
movq 0x18(%rsp), %rax
cmovlq 0x10(%rsp), %rax
movl (%rax), %eax
cmpq %rax, %rdx
ja 0xdde0
jmp 0xde07
movl 0x70(%r15), %esi
cmpq %rsi, %rdx
jbe 0xde07
cmpb 0xf(%rsp), %cl
jne 0xdde0
movb -0x2(%r12), %cl
cmpb 0xf(%rsp), %cl
sete %dl
cmpb %al, %cl
sete %al
orb %dl, %al
je 0xde07
movl (%r12), %esi
movq %r14, %rdi
callq 0xad6a
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xdcfa
movq %r14, %rdi
movq %r12, %rsi
callq 0xf264
jmp 0xde1d
movq 0x20(%rsp), %rsi
movq %rbp, %rdi
callq 0xed56
movl %eax, %eax
subq %rax, 0xc8(%r15)
addq $0x20, %r12
jmp 0xdd66
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::create_children_simple(Morat::Pentago::Board const&, Morat::Pentago::AgentMCTS::Node*)
void AgentMCTS::create_children_simple(const Board & board, Node * node){
	assert(node->children.empty());

	node->children.alloc(board.moves_avail(), ctmem);

	Node * child = node->children.begin(),
		 * end   = node->children.end();
	MoveIterator moveit(board, prunesymmetry);
	int num_moves = 0;
	for(; !moveit.done() && child != end; ++moveit, ++child){
		*child = Node(*moveit);
		num_moves++;
	}

	if(prunesymmetry)
		node->children.shrink(num_moves); //shrink the node to ignore the extra moves
	else //both end conditions should happen in parallel
		assert(moveit.done() && child == end);

	PLUS(nodes, node->children.num());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x18(%rdx), %rax
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r14
cmpq $0x2, %rax
jb 0xdf67
cmpw $0x0, 0x6(%rax)
jne 0xe0a1
movq %rbp, %rdi
addq $0x18, %rbx
callq 0xb90a
leaq 0xe8(%r14), %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0xf6f6
movq (%rbx), %rcx
movq %rbx, 0x8(%rsp)
xorl %r15d, %r15d
movl $0x0, %r12d
movl $0x0, %ebx
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r12
jb 0xdfb5
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %rbx
movzbl 0x6c(%r14), %edx
leaq 0x38(%rsp), %r13
movq %r14, 0x30(%rsp)
movq %rbp, %rsi
movq %r13, %rdi
callq 0xb2ac
leaq 0x16c40(%rip), %r14     # 0x24c16
leaq 0x10(%rsp), %rbp
movb 0x68(%rsp), %al
cmpb $0x23, %al
jg 0xe03f
cmpq %rbx, %r12
je 0xe03f
movb (%r14), %al
movzwl 0x68(%rsp), %ecx
vxorps %xmm0, %xmm0, %xmm0
andw $0x0, 0x20(%rsp)
vmovaps %xmm0, 0x10(%rsp)
movb %al, 0x22(%rsp)
movb $0x0, 0x23(%rsp)
movw %cx, 0x24(%rsp)
movw $0xefc, 0x26(%rsp)      # imm = 0xEFC
andq $0x0, 0x28(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xf182
movq %rbp, %rdi
callq 0xed1e
movq %r13, %rdi
callq 0xb372
incl %r15d
addq $0x20, %r12
jmp 0xdfdb
movq 0x30(%rsp), %r14
cmpb $0x1, 0x6c(%r14)
jne 0xe05d
movq 0x8(%rsp), %r13
movl %r15d, %esi
movq %r13, %rdi
callq 0xf73c
jmp 0xe06b
movq 0x8(%rsp), %r13
cmpb $0x24, %al
jl 0xe0c0
cmpq %rbx, %r12
jne 0xe0c0
movq (%r13), %rax
cmpq $0x2, %rax
jb 0xe07b
movzwl 0x6(%rax), %eax
jmp 0xe07d
xorl %eax, %eax
lock
addq %rax, 0xc8(%r14)
leaq 0x70(%rsp), %rdi
callq 0xb916
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x126d5(%rip), %rdi     # 0x2077d
leaq 0x12609(%rip), %rsi     # 0x206b8
leaq 0x126de(%rip), %rcx     # 0x20794
movl $0x14b, %edx            # imm = 0x14B
callq 0x5220
leaq 0x1271b(%rip), %rdi     # 0x207e2
leaq 0x125ea(%rip), %rsi     # 0x206b8
leaq 0x126bf(%rip), %rcx     # 0x20794
movl $0x15b, %edx            # imm = 0x15B
callq 0x5220
jmp 0xe0f0
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0xed1e
jmp 0xe0f3
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xb916
movq %rbx, %rdi
callq 0x5690
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/move.h
// Function: Morat::Pentago::Move::Move(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Move(const std::string & str){
		if(     str == "swap"    ){ l = M_SWAP;    r = 14; }
		else if(str == "resign"  ){ l = M_RESIGN;  r = 14; }
		else if(str == "none"    ){ l = M_NONE;    r = 14; }
		else if(str == "unknown" ){ l = M_UNKNOWN; r = 14; }
		else if(str.length() <= 2){ l = M_NONE;    r = 14; }
		else{
			unsigned int y = tolower(str[0]) - 'a'; //[abcdef]
			unsigned int x = str[1] - '1';          //[123456]
			l = y*6+x;

			char c = tolower(str[2]);
			if(     c >= '1' && c <= '8') r = c - '1'; //[12345678]
			else if(c >= 's' && c <= 'z') r = c - 's'; //[stuvwxyz]
			else if(c >= 'a' && c <= 'h') r = c - 'a'; //[abcdefgh]
			else r = 0; //unknown, but do something
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x11f8a(%rip), %rsi     # 0x202ac
movq %rdi, %rbx
movq %r14, %rdi
callq 0x778c
testb %al, %al
je 0xe336
movb $-0x1, (%rbx)
jmp 0xe37c
leaq 0x11f74(%rip), %rsi     # 0x202b1
movq %r14, %rdi
callq 0x778c
testb %al, %al
je 0xe34e
movb $-0x2, (%rbx)
jmp 0xe37c
leaq 0x11f52(%rip), %rsi     # 0x202a7
movq %r14, %rdi
callq 0x778c
testb %al, %al
je 0xe366
movb $-0x3, (%rbx)
jmp 0xe37c
leaq 0x11f32(%rip), %rsi     # 0x2029f
movq %r14, %rdi
callq 0x778c
testb %al, %al
je 0xe389
movb $-0x4, (%rbx)
movb $0xe, %al
movb %al, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq $0x2, 0x8(%r14)
jbe 0xe361
movq (%r14), %r14
movsbl (%r14), %edi
callq 0x5500
imull $0x6, %eax, %eax
addb 0x1(%r14), %al
addb $-0x77, %al
movb %al, (%rbx)
movsbl 0x2(%r14), %edi
callq 0x5500
movsbl %al, %ecx
leal -0x31(%rcx), %edx
cmpl $0x7, %edx
ja 0xe3c1
addl $-0x31, %eax
jmp 0xe37e
leal -0x73(%rcx), %edx
cmpl $0x7, %edx
ja 0xe3ce
addl $-0x73, %eax
jmp 0xe37e
addl $-0x61, %ecx
cmpl $0x7, %ecx
ja 0xe3db
addl $-0x61, %eax
jmp 0xe37e
xorl %eax, %eax
jmp 0xe37e
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::undo(Morat::Pentago::Move const&)
bool undo(const Move & m) {
		if(valid_move(m))
			return false;

		if(m == M_SWAP){
			std::swap(sides[1], sides[2]);
			to_play_ = 1;
			return true;
		}

		to_play_ = ~to_play_;
		num_moves_--;

		if (m.direction() == 0) {
			sides[1] = rotate_quad_cw(sides[1], m.quadrant());
			sides[2] = rotate_quad_cw(sides[2], m.quadrant());
		} else {
			sides[1] = rotate_quad_ccw(sides[1], m.quadrant());
			sides[2] = rotate_quad_ccw(sides[2], m.quadrant());
		}

		sides[to_play_.to_i()] &= ~xybits[m.l];

		sides[0] = sides[1] | sides[2];

		outcome_ = Outcome::UNDEF;
		cached_score = default_score;
		cached_hash = 0;

		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xfcea
movl %eax, %ebp
testb %al, %al
jne 0xf32c
cmpb $-0x1, (%r14)
je 0xf2be
movb $0x3, %al
subb 0x19(%rbx), %al
movb %al, 0x19(%rbx)
decb 0x18(%rbx)
movb 0x1(%r14), %al
movq 0x8(%rbx), %rdi
movl %eax, %ecx
sarb %cl
movsbl %cl, %esi
testb $0x1, %al
jne 0xf2d0
callq 0xb7de
movq %rax, 0x8(%rbx)
movb 0x1(%r14), %al
movq 0x10(%rbx), %rdi
sarb %al
movsbl %al, %esi
callq 0xb7de
jmp 0xf2eb
vpermilps $0x4e, 0x8(%rbx), %xmm0 # xmm0 = mem[2,3,0,1]
vmovups %xmm0, 0x8(%rbx)
movb $0x1, 0x19(%rbx)
jmp 0xf32c
callq 0xb7b4
movq %rax, 0x8(%rbx)
movb 0x1(%r14), %al
movq 0x10(%rbx), %rdi
sarb %al
movsbl %al, %esi
callq 0xb7b4
movq %rax, 0x10(%rbx)
leaq 0x1354a(%rip), %rcx     # 0x22840
movsbq (%r14), %rax
movq (%rcx,%rax,8), %rax
movsbq 0x19(%rbx), %rcx
notq %rax
andq %rax, (%rbx,%rcx,8)
movq 0x10(%rbx), %rax
orq 0x8(%rbx), %rax
movq %rax, (%rbx)
leaq 0x158f9(%rip), %rax     # 0x24c15
movb (%rax), %al
movb %al, 0x1a(%rbx)
movw $0xdead, 0x1c(%rbx)     # imm = 0xDEAD
andq $0x0, 0x20(%rbx)
xorb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmctsthread.cpp
// Function: Morat::Pentago::AgentMCTS::AgentThread::iterate()
void AgentMCTS::AgentThread::iterate(){
	INCR(agent->runs);
	if(agent->profile){
		timestamps[0] = Time();
		stage = 0;
	}

	movelist.reset(&(agent->rootboard));
	agent->root.exp.addvloss();
	Board copy = agent->rootboard;
	walk_tree(copy, & agent->root, 0);
	agent->root.exp.addv(movelist.getexp(~agent->rootboard.to_play()));

	if(agent->profile){
		times[0] += timestamps[1] - timestamps[0];
		times[1] += timestamps[2] - timestamps[1];
		times[2] += timestamps[3] - timestamps[2];
		times[3] += Time() - timestamps[3];
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0x40(%rdi), %rax
movq %rdi, %rbx
lock
incq 0xd8(%rax)
movq 0x40(%rdi), %rax
cmpb $0x1, 0x48(%rax)
jne 0x1166f
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x5df0
movq (%r14), %rax
movq %rax, 0xe0(%rbx)
andl $0x0, 0x78(%rbx)
movq 0x40(%rbx), %rax
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
vmovups %ymm0, 0x58(%rbx)
lock
incq 0xb0(%rax)
movq 0x40(%rbx), %rdx
movq 0xa0(%rdx), %rax
movq %rax, 0x20(%rsi)
vmovupd 0x80(%rdx), %ymm0
addq $0xa8, %rdx
vmovupd %ymm0, (%rsi)
vzeroupper
callq 0x11772
movq 0x40(%rbx), %rax
movb $0x3, %cl
subb 0x99(%rax), %cl
movsbq %cl, %rcx
shlq $0x4, %rcx
leaq 0x48(%rcx,%rbx), %rcx
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x116dd
lock
addq %rdx, 0xa8(%rax)
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x116ee
lock
addq %rcx, 0xb0(%rax)
movq 0x40(%rbx), %rax
cmpb $0x1, 0x48(%rax)
jne 0x1176a
vmovupd 0xe0(%rbx), %xmm0
vmovupd 0xe8(%rbx), %xmm1
leaq 0x8(%rsp), %r14
movq %r14, %rdi
vunpcklpd %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vsubpd %xmm0, %xmm1, %xmm0
vaddpd 0xc0(%rbx), %xmm0, %xmm0
vmovupd %xmm0, 0xc0(%rbx)
vmovsd 0xf8(%rbx), %xmm0
vsubsd 0xf0(%rbx), %xmm0, %xmm0
vaddsd 0xd0(%rbx), %xmm0, %xmm0
vmovsd %xmm0, 0xd0(%rbx)
callq 0x5df0
vmovsd (%r14), %xmm0
vsubsd 0xf8(%rbx), %xmm0, %xmm0
vaddsd 0xd8(%rbx), %xmm0, %xmm0
vmovsd %xmm0, 0xd8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmctsthread.cpp
// Function: Morat::Pentago::AgentMCTS::AgentThread::choose_move(Morat::Pentago::AgentMCTS::Node const*, Morat::Side) const
AgentMCTS::Node * AgentMCTS::AgentThread::choose_move(const Node * node, Side to_play) const {
	float val, maxval = -1000000000;
	float logvisits = log(node->exp.num());

	float explore = agent->explore;
	if(agent->parentexplore)
		explore *= node->exp.avg();

	Node * ret   = NULL,
		 * child = node->children.begin(),
		 * end   = node->children.end();

	for(; child != end; child++){
		if(child->outcome >= Outcome::DRAW){
			if(child->outcome == to_play) //return a win immediately
				return child;

			val = (child->outcome == Outcome::DRAW ? -1 : -2); //-1 for tie so any unknown is better, -2 for loss so it's even worse
		}else{
			val = child->value(agent->knowledge, agent->fpurgency);
			if(explore > 0)
				val += explore*sqrt(logvisits/(child->exp.num() + 1));
		}

		if(maxval < val){
			maxval = val;
			ret = child;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
vcvtusi2sdq 0x8(%rsi), %xmm0, %xmm0
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x52b0
movq 0x40(%r14), %rax
vmovss 0x4c(%rax), %xmm2
cmpb $0x1, 0x49(%rax)
jne 0x11b0d
movq %r15, %rdi
vmovss %xmm2, 0xc(%rsp)
vmovsd %xmm0, 0x10(%rsp)
callq 0xf23c
vmovss 0xc(%rsp), %xmm2
vmulss %xmm0, %xmm2, %xmm2
vmovsd 0x10(%rsp), %xmm0
movq 0x18(%r15), %rcx
xorl %r13d, %r13d
movl $0x0, %r15d
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r15
jb 0x11b35
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %r13
vcvtsd2ss %xmm0, %xmm0, %xmm0
leaq 0x130d9(%rip), %rbp     # 0x24c19
xorl %r12d, %r12d
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm0, 0x1c(%rsp)
vcvtss2sd %xmm2, %xmm2, %xmm0
vmovsd %xmm0, 0x20(%rsp)
vmovss 0xfd6f(%rip), %xmm0     # 0x218d0
cmpq %r13, %r15
je 0x11c2c
movb 0x12(%r15), %al
movb (%rbp), %cl
vmovss %xmm0, 0x10(%rsp)
cmpb %cl, %al
jge 0x11bd5
movq 0x40(%r14), %rax
movq %r15, %rdi
vmovss 0x58(%rax), %xmm0
movzbl 0x50(%rax), %esi
callq 0x12278
vmovss 0xc(%rsp), %xmm2
vmovaps %xmm0, %xmm3
vucomiss 0xfd32(%rip), %xmm2     # 0x218d4
vmovss 0x10(%rsp), %xmm0
jbe 0x11c14
movq 0x8(%r15), %rax
vmovss 0x1c(%rsp), %xmm1
incq %rax
vcvtusi2ss %rax, %xmm4, %xmm0
vdivss %xmm0, %xmm1, %xmm0
vcvtss2sd %xmm0, %xmm0, %xmm0
vucomisd 0xe553(%rip), %xmm0     # 0x20120
jb 0x11bee
vsqrtsd %xmm0, %xmm0, %xmm0
jmp 0x11bff
cmpb %bl, %al
je 0x11c29
xorl %edx, %edx
cmpb %cl, %al
leaq 0xfce4(%rip), %rax      # 0x218c8
sete %dl
vmovss (%rax,%rdx,4), %xmm3
jmp 0x11c0e
vmovss %xmm3, 0x18(%rsp)
callq 0x52a0
vmovss 0x18(%rsp), %xmm3
vcvtss2sd %xmm3, %xmm3, %xmm1
vfmadd231sd 0x20(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vcvtsd2ss %xmm1, %xmm1, %xmm3
vmovss 0x10(%rsp), %xmm0
vucomiss %xmm0, %xmm3
vmaxss %xmm0, %xmm3, %xmm0
cmovaq %r15, %r12
addq $0x20, %r15
jmp 0x11b61
movq %r15, %r12
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmctsthread.cpp
// Function: Morat::Pentago::AgentMCTS::AgentThread::rollout(Morat::Pentago::Board&, Morat::Pentago::Move, int)
Outcome AgentMCTS::AgentThread::rollout(Board & board, Move move, int depth){
	Outcome won;
	while((won = board.outcome()) < Outcome::DRAW) {
		board.move_rand(rand64);
	}
	gamelen.add(board.moves_made());
	movelist.finishrollout(won);
	return won;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x12a7c(%rip), %r12     # 0x24c19
leaq 0x48(%rdi), %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %r14, %rdi
callq 0xa9d0
cmpb (%r12), %al
jge 0x121c2
movq %r14, %rdi
movq %r15, %rsi
callq 0x122f4
jmp 0x121a7
movzbl 0x18(%r14), %esi
leaq 0xa0(%rbx), %rdi
movl %eax, %ebp
callq 0x12258
addq $0x58, %rbx
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x12224
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentmcts.h
// Function: Morat::Pentago::AgentMCTS::Node::value(bool, float)
float value(bool knowledge, float fpurgency){
			float val = fpurgency;
			float expnum = exp.num();

			if(expnum > 0)
				val = exp.avg();

			if(knowledge && know != 0){
				if(expnum <= 1)
					val += 0.01f * know;
				else if(expnum < 1000) //knowledge is only useful with little experience
					val += 0.01f * know / sqrt(expnum);
			}

			return val;
		}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r14
movl %esi, %ebp
movq %rdi, %rbx
testq %r14, %r14
je 0x12292
movq %rbx, %rdi
callq 0xf23c
testb %bpl, %bpl
je 0x122ee
movzwl 0x10(%rbx), %eax
testw %ax, %ax
je 0x122ee
cmpq $0x1, %r14
ja 0x122b6
cwtl
vcvtsi2ss %eax, %xmm1, %xmm1
vfmadd231ss 0xf624(%rip), %xmm1, %xmm0 # xmm0 = (xmm1 * mem) + xmm0
jmp 0x122ee
cmpq $0x3e7, %r14            # imm = 0x3E7
ja 0x122ee
vcvtusi2ss %r14, %xmm1, %xmm1
cwtl
vcvtsi2ss %eax, %xmm2, %xmm2
vmulss 0xf606(%rip), %xmm2, %xmm2 # 0x218d8
vcvtss2sd %xmm1, %xmm1, %xmm1
vsqrtsd %xmm1, %xmm1, %xmm1
vcvtss2sd %xmm2, %xmm2, %xmm2
vcvtss2sd %xmm0, %xmm0, %xmm0
vdivsd %xmm1, %xmm2, %xmm1
vaddsd %xmm0, %xmm1, %xmm0
vcvtsd2ss %xmm0, %xmm0, %xmm0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::move_rand(Morat::XORShift_uint64&)
bool move_rand(XORShift_uint64 & rand){
		//find an empty space, this should take log2(bits set) to converge, assuming a good and fast RNG
		uint64_t move = (~sides[0]) & 0xFFFFFFFFFULL; // bits set for all empty positions
		uint64_t mask;
		do {
			mask = rand();
			if((move & mask) > 0) // don't let it drop to no bits set
				move &= mask;
		} while(move & (move-1));
//		} while(bitcount(move) > 1); // if there's only one bit left, that's our move

		sides[to_play_.to_i()] |= move;

		uint64_t rotation = (mask >> 36); //mask is already a random number, so just re-use the unused high bits
		uint64_t direction = rotation & 0x4;
		uint64_t quadrant = rotation & 0x3;

		if (direction) {
			sides[1] = rotate_quad_ccw(sides[1], quadrant);
			sides[2] = rotate_quad_ccw(sides[2], quadrant);
		} else {
			sides[1] = rotate_quad_cw(sides[1], quadrant);
			sides[2] = rotate_quad_cw(sides[2], quadrant);
		}
		sides[0] = sides[1] | sides[2];

		num_moves_++;
		to_play_ = ~to_play_;
		outcome_ = Outcome::UNDEF;
		cached_score = default_score;
		cached_hash = 0;

		return true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
movb $0x24, %cl
movq %rsi, %r14
movq %rdi, %rbx
notq %rax
bzhiq %rcx, %rax, %rcx
movq %r14, %rdi
movq %rcx, %r15
callq 0x1240e
movq %rax, %rcx
andq %r15, %rcx
cmoveq %r15, %rcx
blsrq %rcx, %rdx
jne 0x1230c
movsbq 0x19(%rbx), %rdx
movq %rax, %r14
shrq $0x24, %r14
andl $0x3, %r14d
movl %r14d, %esi
orq %rcx, (%rbx,%rdx,8)
btq $0x26, %rax
movq 0x8(%rbx), %rdi
jb 0x12361
callq 0xb7de
movq %rax, 0x8(%rbx)
movl %r14d, %esi
movq 0x10(%rbx), %rdi
callq 0xb7de
jmp 0x12376
callq 0xb7b4
movq %rax, 0x8(%rbx)
movl %r14d, %esi
movq 0x10(%rbx), %rdi
callq 0xb7b4
movq %rax, 0x10(%rbx)
orq 0x8(%rbx), %rax
movq %rax, (%rbx)
incb 0x18(%rbx)
movb $0x3, %al
subb 0x19(%rbx), %al
movb %al, 0x19(%rbx)
leaq 0x12882(%rip), %rax     # 0x24c15
movb (%rax), %al
movb %al, 0x1a(%rbx)
movw $0xdead, 0x1c(%rbx)     # imm = 0xDEAD
andq $0x0, 0x20(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/../lib/xorshift.h
// Function: Morat::XORShift_uint64::rand()
uint64_t rand(){
		r ^= r >> 12; // a
		r ^= r << 25; // b
		r ^= r >> 27; // c
		return r * 2685821657736338717LL;
	}

// Assembly:
movq (%rdi), %rax
movq %rax, %rcx
shrq $0xc, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0x19, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq %rcx, %rax
movq %rcx, (%rdi)
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agentpns.cpp
// Function: Morat::Pentago::AgentPNS::create_children_simple(Morat::Pentago::Board const&, Morat::Pentago::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(MoveIterator move(board); !move.done(); ++move){
		Outcome outcome = move.board().outcome();
		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 $0x78, %rsp
movq 0x18(%rdx), %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x2, %rax
jb 0x13ad4
cmpw $0x0, 0x6(%rax)
jne 0x13bbb
movq %r15, %rdi
addq $0x18, %rbx
callq 0xb90a
leaq 0x50(%r14), %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x14104
leaq 0x28(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r15, %rsi
callq 0xb2ac
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
cmpb $0x24, 0x58(%rsp)
jge 0x13b91
leaq 0x30(%rsp), %rdi
callq 0xa9d0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rsp)
movzwl 0x58(%rsp), %ecx
andq $0x0, 0x10(%rsp)
andw $0x0, 0x18(%rsp)
movw %cx, 0x1a(%rsp)
andq $0x0, 0x20(%rsp)
movzbl 0x19(%r15), %edx
movl 0x1514(%r14), %ecx
movzbl %al, %esi
movq %r12, %rdi
pushq $0x1
popq %r8
callq 0x14210
movq %rax, %r13
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1426c
movq %rax, %rdi
movq %r13, %rsi
callq 0x142ca
movq %r12, %rdi
callq 0x13ef6
incl %ebp
leaq 0x28(%rsp), %rdi
callq 0xb372
jmp 0x13b05
leaq 0x60(%rsp), %rdi
callq 0xb916
movl %ebp, %eax
lock
addq %rax, 0x38(%r14)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14318
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcbbb(%rip), %rdi      # 0x2077d
leaq 0xdf6f(%rip), %rsi      # 0x21b38
leaq 0xe075(%rip), %rcx      # 0x21c45
movl $0x13d, %edx            # imm = 0x13D
callq 0x5220
jmp 0x13bdc
movq %rax, %rbx
jmp 0x13bee
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x13ef6
leaq 0x60(%rsp), %rdi
callq 0xb916
movq %rbx, %rdi
callq 0x5690
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/agent.h
// Function: Morat::Pentago::Agent::solve1ply(Morat::Pentago::Board const&, unsigned int&)
static Outcome solve1ply(const Board & board, unsigned int & nodes) {
		Outcome outcome = Outcome::UNDEF;
		Side turn = board.to_play();
		for(MoveIterator move(board); !move.done(); ++move){
			++nodes;
			Outcome won = move.board().outcome();

			if(won == +turn)
				return won;
			if(won == Outcome::DRAW)
				outcome = Outcome::DRAW;
			else if(outcome == +~turn || outcome == Outcome::UNDEF)
				outcome = won;
		}
		return outcome;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x10ab6(%rip), %rax     # 0x24c15
movb 0x19(%rdi), %r13b
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
movb (%rax), %bl
pushq $-0x1
popq %rdx
callq 0xb2ac
leaq 0x10a9a(%rip), %r12     # 0x24c19
movb $0x3, %r15b
subb %r13b, %r15b
cmpb $0x23, 0x38(%rsp)
jg 0x141cf
incl (%r14)
leaq 0x10(%rsp), %rdi
callq 0xa9d0
movl %eax, %ebp
cmpb %r13b, %al
je 0x141de
cmpb (%r12), %bpl
je 0x141c1
leaq 0x10a68(%rip), %rax     # 0x24c15
movzbl %bl, %ecx
cmpb (%rax), %bl
movzbl %bpl, %eax
movl %ecx, %ebp
cmovel %eax, %ebp
cmpb %r15b, %cl
cmovel %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xb372
movl %ebp, %ebx
jmp 0x14185
leaq 0x40(%rsp), %rdi
callq 0xb916
movl %ebx, %r13d
jmp 0x141e8
leaq 0x40(%rsp), %rdi
callq 0xb916
movl %r13d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rdi
movq %rax, %rbx
callq 0xb916
movq %rbx, %rdi
callq 0x5690
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/gtpgeneral.cpp
// Function: Morat::Pentago::GTP::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 GTP::gtp_mcts(vecstr args){
	delete agent;
	agent = new AgentMCTS();
	agent->set_board(*hist);
	return GTPResponse(true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
movq %rsi, %r14
testq %rdi, %rdi
je 0x16b55
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1590, %edi           # imm = 0x1590
callq 0x5360
movq %rax, %r15
movq %rax, %rdi
callq 0xd02c
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movq (%r15), %rax
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
leaq 0x8c8e(%rip), %rsi      # 0x1f819
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5130
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x86e2
leaq 0x10(%rsp), %rdi
callq 0x5170
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x5170
jmp 0x16be0
movq %rax, %rbx
jmp 0x16be0
movq %r15, %rdi
movq %rax, %rbx
callq 0x5320
movq %rbx, %rdi
callq 0x5690
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/gtpgeneral.cpp
// Function: Morat::Pentago::GTP::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 GTP::gtp_pns(vecstr args){
	delete agent;
	agent = new AgentPNS();
	agent->set_board(*hist);
	return GTPResponse(true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
movq %rsi, %r14
testq %rdi, %rdi
je 0x16c09
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1540, %edi           # imm = 0x1540
callq 0x5360
movq %rax, %r15
movq %rax, %rdi
callq 0x185ca
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movq (%r15), %rax
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
leaq 0x8bda(%rip), %rsi      # 0x1f819
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5130
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x86e2
leaq 0x10(%rsp), %rdi
callq 0x5170
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x5170
jmp 0x16c94
movq %rax, %rbx
jmp 0x16c94
movq %r15, %rdi
movq %rax, %rbx
callq 0x5320
movq %rbx, %rdi
callq 0x5690
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/gtpgeneral.cpp
// Function: Morat::Pentago::GTP::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 GTP::gtp_ab(vecstr args){
	delete agent;
	agent = new AgentAB();
	agent->set_board(*hist);
	return GTPResponse(true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
movq %rsi, %r14
testq %rdi, %rdi
je 0x16cbd
movq (%rdi), %rax
callq *0x8(%rax)
pushq $0x70
popq %rdi
callq 0x5360
movq %rax, %r15
movq %rax, %rdi
callq 0x186b8
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movq (%r15), %rax
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
leaq 0x8b28(%rip), %rsi      # 0x1f819
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5130
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x86e2
leaq 0x10(%rsp), %rdi
callq 0x5170
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x5170
jmp 0x16d46
movq %rax, %rbx
jmp 0x16d46
movq %r15, %rdi
movq %rax, %rbx
callq 0x5320
movq %rbx, %rdi
callq 0x5690
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/pentago/gtpgeneral.cpp
// Function: Morat::Pentago::GTP::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 GTP::gtp_all_legal(vecstr args){
	std::string ret;
	for(MoveIterator move(*hist); !move.done(); ++move)
		ret += move->to_s() + " ";
	return GTPResponse(true, ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq 0x18(%rsp), %rax
movq %rdi, (%rsp)
subq $-0x80, %rsi
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x48(%rsp), %rdi
pushq $-0x1
popq %rdx
callq 0xb2ac
leaq 0x78(%rsp), %r14
leaq 0x98(%rsp), %r15
leaq 0xce04(%rip), %r12      # 0x23ea9
leaq 0xb8(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x48(%rsp), %rbx
cmpb $0x24, 0x78(%rsp)
jge 0x170fc
movq %r15, %rdi
movq %r14, %rsi
callq 0xabfe
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7b4d
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5730
movq %r13, %rdi
callq 0x5170
movq %r15, %rdi
callq 0x5170
movq %rbx, %rdi
callq 0xb372
jmp 0x170b7
leaq 0x80(%rsp), %rdi
callq 0xb916
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x54d0
pushq $0x1
popq %rsi
movq (%rsp), %rbx
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x86e2
leaq 0x28(%rsp), %rdi
callq 0x5170
leaq 0x8(%rsp), %rdi
callq 0x5170
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
movq %rax, %rbx
callq 0x5170
jmp 0x171a1
jmp 0x17166
movq %rax, %rbx
jmp 0x171a1
jmp 0x17191
movq %rax, %rbx
jmp 0x17182
leaq 0xb8(%rsp), %rdi
movq %rax, %rbx
callq 0x5170
leaq 0x98(%rsp), %rdi
callq 0x5170
jmp 0x17194
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xb916
leaq 0x8(%rsp), %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x5690
nop