LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFPrinter<Morat::Move>::child_end()
void child_end() {
		assert(!_root);
		assert(_depth >= 1);
		_depth--;
		if(_indent)
			print("\n" + std::string(_depth, ' '));
		print(")");
		_indent = true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
cmpb $0x1, 0x8(%rdi)
je 0x1304f
movl 0xc(%rdi), %eax
movq %rdi, %rbx
testl %eax, %eax
jle 0x1306e
decl %eax
movl %eax, 0xc(%rbx)
cmpb $0x1, 0x10(%rbx)
jne 0x13003
leaq 0x30(%rsp), %r14
movl %eax, %esi
movq %r14, -0x10(%r14)
leaq 0x20(%rsp), %rdi
movl $0x20, %edx
callq 0x53b0
leaq 0x1e985(%rip), %rcx     # 0x31906
leaq 0x20(%rsp), %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5380
leaq 0x10(%rsp), %r15
movq %rax, %rcx
addq $0x10, %rcx
movq %r15, -0x10(%r15)
movq (%rax), %rdx
cmpq %rcx, %rdx
je 0x12fbb
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x12fc4
vmovups (%rcx), %xmm0
vmovups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x15a20
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12ff4
callq 0x52e0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x13003
callq 0x52e0
leaq 0x50(%rsp), %r15
leaq 0x40(%rsp), %r14
leaq 0x20cf0(%rip), %rsi     # 0x33d04
leaq 0x20cea(%rip), %rdx     # 0x33d05
movq %r14, %rdi
movq %r15, -0x10(%r15)
callq 0xb1dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15a20
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x13041
callq 0x52e0
movb $0x1, 0x10(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2028a(%rip), %rdi     # 0x332e0
leaq 0x2028a(%rip), %rsi     # 0x332e7
leaq 0x203e2(%rip), %rcx     # 0x33446
movl $0x46, %edx
callq 0x51d0
leaq 0x202cb(%rip), %rdi     # 0x33340
leaq 0x2026b(%rip), %rsi     # 0x332e7
leaq 0x203c3(%rip), %rcx     # 0x33446
movl $0x47, %edx
callq 0x51d0
movq (%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x130a3
callq 0x52e0
jmp 0x130a3
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
jne 0x130c1
jmp 0x130c6
movq %rax, %rbx
jmp 0x130c6
movq 0x40(%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x130c6
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/move_iterator.h
// Function: Morat::MoveIterator<Morat::Hex::Board>::operator++()
MoveIterator & operator ++ () {  //prefix form
		do {
			move_.x++;
			move_.xy++;

			if (move_.x >= line_end_) {
				move_.y++;
				if (move_.y >= board_.lines()) {  // done
					move_ = M_NONE;
					return *this;
				}
				move_.x = board_.line_start(move_.y);
				move_.xy = board_.xy(move_.x, move_.y);
				line_end_ = board_.line_end(move_.y);
			}
		} while (!board_.valid_move_fast(move_));

		return *this;
	}

// Assembly:
leaq 0x23244(%rip), %rsi     # 0x363a9
movq %rdi, %rax
movb 0x9(%rdi), %r9b
movzwl 0xa(%rdi), %r8d
movb 0xc(%rdi), %dil
movb 0x8(%rax), %cl
movq (%rax), %rdx
movb (%rsi), %sil
incb %r9b
incl %r8d
movb %r9b, 0x9(%rax)
movw %r8w, 0xa(%rax)
cmpb %dil, %r9b
jl 0x131bf
incb %cl
movb %cl, 0x8(%rax)
movb (%rdx), %dil
cmpb %cl, %dil
jle 0x131d2
movsbl %dil, %r8d
movsbl %cl, %r9d
movb $0x0, 0x9(%rax)
movswl %r8w, %r8d
imull %r9d, %r8d
xorl %r9d, %r9d
movw %r8w, 0xa(%rax)
movb %dil, 0xc(%rax)
movq 0x10(%rdx), %r11
movswq %r8w, %r10
shlq $0x4, %r10
cmpb %sil, (%r11,%r10)
jne 0x1317e
retq
movl $0xffff78fd, 0x8(%rax)  # imm = 0xFFFF78FD
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFParser<Morat::Move>::next_child()
bool next_child() {
		eat_whitespace(_is);
		if(eat_char(_is, '('))
			return next_node();
		return false;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2d6bb
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x2d71b
testb %al, %al
je 0x13200
movq %rbx, %rdi
popq %rbx
jmp 0x15bde
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFParser<Morat::Move>::move()
Move move() {
		if(_properties.count("W"))
			return Move(_properties["W"]);
		if(_properties.count("B"))
			return Move(_properties["B"]);
		return Move();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x20(%rsp), %r15
movq %rdi, %rbx
movq %r15, -0x10(%r15)
leaq 0x201d1(%rip), %rsi     # 0x333f1
leaq 0x201cb(%rip), %rdx     # 0x333f2
leaq 0x10(%rsp), %rdi
callq 0xb1dc
addq $0x8, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x15d48
movq 0x10(%rsp), %rdi
movq %rax, %r14
cmpq %r15, %rdi
je 0x13254
callq 0x52e0
leaq 0x10(%rsp), %rdi
testq %r14, %r14
je 0x13290
movq %r15, (%rdi)
leaq 0x20189(%rip), %rsi     # 0x333f1
leaq 0x20183(%rip), %rdx     # 0x333f2
callq 0xb1dc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x13f5e
leaq 0xe(%rsp), %rdi
movq %rax, %rsi
callq 0x11418
jmp 0x132ff
movq %r15, (%rdi)
leaq 0x20159(%rip), %rsi     # 0x333f3
leaq 0x20153(%rip), %rdx     # 0x333f4
callq 0xb1dc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x15d48
movq 0x10(%rsp), %rdi
movq %rax, %r14
cmpq %r15, %rdi
je 0x132c5
callq 0x52e0
testq %r14, %r14
je 0x13310
leaq 0x10(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x2011a(%rip), %rsi     # 0x333f3
leaq 0x20114(%rip), %rdx     # 0x333f4
callq 0xb1dc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x13f5e
leaq 0xe(%rsp), %rdi
movq %rax, %rsi
callq 0x11418
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x13317
callq 0x52e0
jmp 0x13317
movw $0x78fc, 0xe(%rsp)      # imm = 0x78FC
movzwl 0xe(%rsp), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13332
jmp 0x13337
jmp 0x13332
jmp 0x13337
jmp 0x13332
jmp 0x13337
movq %rax, %rbx
jmp 0x13349
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x13349
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::update_hash(Morat::MoveValid const&, Morat::Side)
void update_hash(const MoveValid & pos, Side side) {
		int turn = side.to_i();
		hash.update(0, 3 * pos.xy + turn);
		if(num_moves_ <= unique_depth) {
			hash.update(1, 3 * xy(sizem1_ - pos.x, sizem1_ - pos.y) + turn);
		}
	}

// Assembly:
movswq 0x2(%rsi), %rax
movsbq %dl, %rcx
leaq (%rax,%rax,2), %rax
addq %rax, %rcx
leaq 0x22a8d(%rip), %rax     # 0x364d0
movq (%rax,%rcx,8), %rcx
xorq %rcx, 0x28(%rdi)
cmpw $0x5, 0x4(%rdi)
jg 0x13a82
movsbl %dl, %ecx
movsbl 0x1(%rdi), %edx
movsbl 0x1(%rsi), %r8d
movsbl (%rsi), %esi
movl %edx, %r9d
subl %esi, %edx
movsbl (%rdi), %esi
subl %r8d, %r9d
imull %edx, %esi
addl %r9d, %esi
leal (%rsi,%rsi,2), %edx
addl %ecx, %edx
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
xorq %rax, 0x30(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Data::move(Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Data*)
void move(Data * s){
			assert(!empty()); //don't move an empty Data segment
			assert(*parent == s); //my parent points to my old location

			//update my parent with my new location
			*parent = this;

			//make sure the parent points back to the same place
			assert(parent_consistent());

			//update my children
			for(Node * i = begin(), * e = end(); i != e; ++i){
				if(i->children.data){
					i->children.data->parent = &(i->children.data);
					assert(i->children.data->parent_consistent());
				}
			}
		}

// Assembly:
pushq %rax
movl (%rdi), %eax
cmpl $0x4, %eax
jbe 0x13e44
movq 0x8(%rdi), %rcx
cmpq %rsi, (%rcx)
jne 0x13e63
movq %rdi, (%rcx)
movq 0x8(%rdi), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jne 0x13e82
movzwl 0x6(%rdi), %eax
testq %rax, %rax
je 0x13e23
shll $0x4, %eax
addq $0x38, %rdi
leaq (%rax,%rax,2), %rax
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x13e19
movq %rdi, 0x8(%rcx)
movq (%rdi), %rcx
movl (%rcx), %edx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %edx
jne 0x13e25
addq $0x30, %rdi
addq $-0x30, %rax
jne 0x13dfd
popq %rax
retq
leaq 0x1f00a(%rip), %rdi     # 0x32e36
leaq 0x1ea12(%rip), %rsi     # 0x32845
leaq 0x1ef81(%rip), %rcx     # 0x32dbb
movl $0x6a, %edx
callq 0x51d0
leaq 0x1ef67(%rip), %rdi     # 0x32db2
leaq 0x1e9f3(%rip), %rsi     # 0x32845
leaq 0x1ef62(%rip), %rcx     # 0x32dbb
movl $0x5d, %edx
callq 0x51d0
leaq 0x1efbf(%rip), %rdi     # 0x32e29
leaq 0x1e9d4(%rip), %rsi     # 0x32845
leaq 0x1ef43(%rip), %rcx     # 0x32dbb
movl $0x5e, %edx
callq 0x51d0
leaq 0x1efbf(%rip), %rdi     # 0x32e48
leaq 0x1e9b5(%rip), %rsi     # 0x32845
leaq 0x1ef24(%rip), %rcx     # 0x32dbb
movl $0x64, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Chunk::dealloc(bool)
void dealloc(bool deallocnext = false){
			assert(capacity > 0 && mem != NULL);
			if(deallocnext && next != NULL){
				next->dealloc(deallocnext);
				delete next;
				next = NULL;
			}
			assert(next == NULL);
			capacity = 0;
			used = 0;
			delete[] (uint64_t *)mem;
			mem = NULL;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0xc(%rdi)
je 0x13f20
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x13f20
movq (%rbx), %rax
testb %sil, %sil
je 0x13efe
testq %rax, %rax
je 0x13f03
movl $0x1, %esi
movq %rax, %rdi
callq 0x13ea2
movq (%rbx), %r14
testq %r14, %r14
je 0x13ee2
movq %r14, %rdi
callq 0x13d88
movq %r14, %rdi
callq 0x52e0
xorl %eax, %eax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
movq %rax, 0xc(%rbx)
testq %rdi, %rdi
jne 0x13f0b
jmp 0x13f10
testq %rax, %rax
jne 0x13f3f
movq $0x0, 0xc(%rbx)
callq 0x5440
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1ef35(%rip), %rdi     # 0x32e5c
leaq 0x1e917(%rip), %rsi     # 0x32845
leaq 0x1ef43(%rip), %rcx     # 0x32e78
movl $0xd4, %edx
callq 0x51d0
leaq 0x1eca4(%rip), %rdi     # 0x32bea
leaq 0x1e8f8(%rip), %rsi     # 0x32845
leaq 0x1ef24(%rip), %rcx     # 0x32e78
movl $0xda, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/thread.h
// Function: Morat::Barrier::wait()
bool wait(){
		cond.lock();

		//wait for threads to exit
		while(counter > waitexit)
			cond.wait();

		bool flip = (++counter == numthreads);

		if(flip){
			counter--;
			if(numthreads > 1)
				counter += waitexit;
			cond.broadcast();
		}else{
			while(counter < waitexit)
				cond.wait();

			counter--;
			if(counter == waitexit){
				counter = 0;
				cond.broadcast();
			}
		}
		cond.unlock();

		return flip;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x54c0
movl 0x5c(%rbx), %eax
cmpl $0x40000001, %eax       # imm = 0x40000001
jb 0x143d4
leaq 0x28(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5510
movl 0x5c(%rbx), %eax
cmpl $0x40000000, %eax       # imm = 0x40000000
ja 0x143bf
movl 0x5c(%rbx), %ebp
incl %ebp
movl %ebp, 0x5c(%rbx)
movl 0x58(%rbx), %r15d
movl 0x5c(%rbx), %eax
cmpl %r15d, %ebp
jne 0x143ff
decl %eax
movl %eax, 0x5c(%rbx)
movl 0x58(%rbx), %eax
cmpl $0x2, %eax
jb 0x14432
movl $0x40000000, %eax       # imm = 0x40000000
addl 0x5c(%rbx), %eax
jmp 0x1442f
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
ja 0x1441f
leaq 0x28(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5510
movl 0x5c(%rbx), %eax
cmpl $0x40000000, %eax       # imm = 0x40000000
jb 0x1440a
decl 0x5c(%rbx)
xorl %eax, %eax
movl 0x5c(%rbx), %ecx
cmpl $0x40000000, %ecx       # imm = 0x40000000
jne 0x1443b
movl %eax, 0x5c(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x50e0
cmpl %r15d, %ebp
movq %rbx, %rdi
sete %bpl
callq 0x5230
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/thread.h
// Function: Morat::Barrier::~Barrier()
~Barrier(){
		cond.lock();

		//wait for threads to exit
		while(counter > waitexit)
			cond.wait();

		cond.unlock();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x54c0
leaq 0x28(%rbx), %r14
movl 0x5c(%rbx), %eax
cmpl $0x40000001, %eax       # imm = 0x40000001
jb 0x1470f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5510
jmp 0x146f8
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5700
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x53c0
movq %rax, %rdi
callq 0xa8ae
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/thread.h
// Function: Morat::Barrier::reset(int)
void reset(int n){
		cond.lock();
		assert(counter == 0);
		numthreads = n;
		cond.unlock();
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x54c0
cmpl $0x0, 0x5c(%rbx)
jne 0x14796
movl %ebp, 0x58(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5230
leaq 0x1ea07(%rip), %rdi     # 0x331a4
leaq 0x1e9d2(%rip), %rsi     # 0x33176
leaq 0x1ea06(%rip), %rcx     # 0x331b1
movl $0xca, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
movl $0x2, %ecx
movl $0x1, %edx
movl $0xa02, %esi            # imm = 0xA02
movl $0x0, (%rdi)
xorl %eax, %eax
xorl %r8d, %r8d
movb %al, 0x1004(%rdi,%r8)
movb %al, 0x4(%rdi,%r8)
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %r11d, %r11d
movl %r8d, %ebx
movl %ebx, %ebp
andl $0x1d, %ebp
cmpl $0x11, %ebp
jne 0x14ce5
cmpl $0x5, %r11d
shlxl %r11d, %ecx, %ebp
cmovel %edx, %ebp
orb %bpl, %r10b
movb %r10b, 0x4(%rdi,%r8)
movl %ebx, %ebp
andl $0x2e, %ebp
cmpl $0x22, %ebp
jne 0x14d06
cmpl $0x5, %r11d
shlxl %r11d, %ecx, %ebp
cmovel %edx, %ebp
orb %bpl, %r9b
movb %r9b, 0x1004(%rdi,%r8)
bextrl %esi, %ebx, %ebp
andl $0x3, %ebx
incl %r11d
shll $0xa, %ebx
orl %ebp, %ebx
cmpl $0x6, %r11d
jne 0x14cc7
incq %r8
cmpq $0x1000, %r8            # imm = 0x1000
jne 0x14cae
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14d58
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x14f64
movb $0x1, 0x8(%rbx)
leaq 0x286(%rip), %rdx       # 0x14fd0
movq %rbx, %rdi
xorl %esi, %esi
movq %rbx, %rcx
popq %rbx
jmp 0x56a0
leaq 0x1e4c8(%rip), %rdi     # 0x33227
leaq 0x1e410(%rip), %rsi     # 0x33176
leaq 0x1e4cc(%rip), %rcx     # 0x33239
movl $0x5c, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x21627(%rip), %r13     # 0x363b1
leaq 0x1d6bf(%rip), %r14     # 0x32450
movl $0x3, %r15d
movl $0x6, %ebp
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x38(%rbx), %rdi
movl (%rdi), %eax
cmpq $0x6, %rax
ja 0x14da2
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
addq $0x20, %rdi
callq 0x143a2
movq 0x38(%rbx), %rcx
movl $0x1, %eax
lock
cmpxchgl %r15d, (%rcx)
movl $0x2, %eax
movq 0x38(%rbx), %rcx
lock
cmpxchgl %r12d, (%rcx)
jmp 0x14da2
subq $-0x80, %rdi
callq 0x143a2
testb %al, %al
je 0x14e0f
movq 0x40(%rbx), %rdi
callq 0x14fec
movq 0x38(%rbx), %rcx
movl $0x4, %eax
lock
cmpxchgl %r15d, (%rcx)
movl $0x5, %eax
movq 0x38(%rbx), %rcx
lock
cmpxchgl %ebp, (%rcx)
movq 0x38(%rbx), %rdi
subq $-0x80, %rdi
callq 0x143a2
jmp 0x14da2
movq 0x40(%rbx), %rax
movb (%r13), %cl
cmpb %cl, 0x19(%rax)
jge 0x14e97
cmpb %cl, 0x4102(%rax)
jge 0x14e97
movq 0x4128(%rax), %rcx
testq %rcx, %rcx
je 0x14e48
cmpq %rcx, 0x4120(%rax)
jae 0x14e97
movq 0x4140(%rax), %rdx
movq 0x4138(%rax), %rcx
movl 0x8(%rdx), %edx
movl 0x10(%rcx), %ecx
shlq $0x18, %rdx
addq %rdx, %rcx
cmpq 0x60(%rax), %rcx
jae 0x14ea5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0x14da2
addq $0x20, %rdi
callq 0x143a2
movq 0x38(%rbx), %rcx
movl $0x6, %eax
movl $0x1, %edx
lock
cmpxchgl %edx, (%rcx)
jmp 0x14da2
movl $0x3, %eax
lock
cmpxchgl %ebp, (%rdi)
jmp 0x14da2
movl $0x3, %eax
movl $0x4, %ecx
lock
cmpxchgl %ecx, (%rdi)
jmp 0x14da2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d6bb
movq (%rbx), %rdi
movl $0x3b, %esi
callq 0x2d71b
movl %eax, %ebp
testb %al, %al
je 0x15c07
movq %rbx, %rdi
callq 0x15c10
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13572
movq (%rbx), %rdi
callq 0x5110
addl $-0x41, %eax
cmpl $0x19, %eax
ja 0x15d1c
movq (%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rdi,%rax)
jne 0x15d1c
leaq 0x30(%rsp), %r14
leaq 0x15(%rsp), %r15
leaq 0x40(%rsp), %r12
movl $0xa, %edx
movl $0x5b, %ecx
movq %r15, %rsi
callq 0x56f0
movq (%rbx), %rdi
movl $0x400, %edx            # imm = 0x400
movl $0x5d, %ecx
movq %r12, %rsi
callq 0x56f0
movq %r15, %rdi
movq %r14, %r13
movq %r14, 0x20(%rsp)
callq 0x5140
leaq 0x15(%rsp,%rax), %rdx
leaq 0x20(%rsp), %r14
movq %r15, %rsi
movq %r14, %rdi
callq 0xb1dc
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x13f5e
movq 0x8(%rax), %r14
movq %r12, %rdi
movq %rax, %rbp
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 0x15cf7
callq 0x52e0
movq (%rbx), %rdi
callq 0x5110
addl $-0x41, %eax
cmpl $0x19, %eax
ja 0x15d1c
movq (%rbx), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rdi,%rax)
je 0x15c6a
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rbx
cmpq %r13, %rdi
je 0x15d40
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40(%rdi), %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0xd8(%rax)
je 0x17745
leaq 0x2f08(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17ede
cmpb $-0x4, %al
jne 0x1779e
movq 0x40(%r15), %rax
cmpb $0x1, 0xd0(%rax)
jne 0x17768
leaq 0xf04(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1811c
cmpb $-0x4, %al
jne 0x1779e
movq 0x40(%r15), %rax
cmpl $0x0, 0xd4(%rax)
je 0x17784
leaq 0x4c(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x181f2
cmpb $-0x4, %al
jne 0x1779e
addq $0xa14, %r15            # imm = 0xA14
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x18270
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17a4f
movl %esi, (%rdi)
cmpl %esi, 0x4(%rdi)
jae 0x17a57
movl %esi, 0x4(%rdi)
movl %esi, %eax
imull %esi, %esi
addq %rax, 0x10(%rdi)
addq %rsi, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, 0x9c58(%rdi)
vpmovsxbq 0x1a7f5(%rip), %zmm1 # 0x32270
vpmovsxbq 0x1a7a3(%rip), %zmm2 # 0x32228
vpbroadcastd 0x1bc31(%rip), %zmm3 # 0x336c0
movl %ecx, %ebp
movq %rdi, %rbx
movsbl (%rsi), %eax
movl %eax, %ecx
imull %ecx, %ecx
cmpl $0x1, %ecx
adcl $0x0, %ecx
xorl %edi, %edi
leaq -0x1(%rcx), %rsi
addl $0xf, %ecx
vpbroadcastq %rsi, %zmm0
andl $-0x10, %ecx
movb $0x1, %sil
imulq $0x1388, %rdi, %rdi     # imm = 0x1388
movb $0x1, %r8b
xorl %r9d, %r9d
addq %rbx, %rdi
testb %al, %al
je 0x17b0c
imulq $0x9c4, %r9, %r9        # imm = 0x9C4
xorl %r10d, %r10d
addq %rdi, %r9
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, (%r9,%r10,4) {%k1}
addq $0x10, %r10
cmpq %r10, %rcx
jne 0x17ad8
movl $0x1, %r9d
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x17ac7
movl $0x1, %edi
testb $0x1, %sil
movl $0x0, %esi
jne 0x17ab7
leaq 0x1e875(%rip), %rax     # 0x363aa
notb %bpl
movzbl %dl, %r14d
movb (%rax), %al
testb %bpl, %al
jne 0x17b54
movzbl %al, %edx
movq %rbx, %rdi
movl %r14d, %esi
vzeroupper
callq 0x18406
leaq 0x1e850(%rip), %rax     # 0x363ab
movb (%rax), %al
testb %bpl, %al
jne 0x17b77
movzbl %al, %edx
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
vzeroupper
jmp 0x18406
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, %r15
movswl 0x2(%rsi), %esi
movl %edx, %ebx
movq %rdi, %r14
callq 0x18390
cmpl $0x3, %eax
jne 0x17c87
movswl 0x2(%r15), %esi
movq 0x10(%r14), %rax
movq %rsi, %rdi
shlq $0x4, %rdi
movslq %esi, %rdx
movzwl 0x4(%rax,%rdi), %ecx
cmpl %edx, %ecx
je 0x17be3
leaq 0x4(%rax,%rdi), %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 0x17bc0
movw %cx, (%rsi)
movq %rcx, %rsi
shlq $0x4, %rsi
leaq (%rdx,%rdx,8), %rdx
movb 0x6(%rax,%rsi), %cl
movq 0x38(%r14), %rsi
leaq 0x2(%rsi,%rdx,8), %rdx
xorl %esi, %esi
movswq (%rdx,%rsi), %r8
cmpq $-0x1, %r8
je 0x17c5e
movq %r8, %rdi
shlq $0x4, %rdi
cmpb %bl, (%rax,%rdi)
jne 0x17c5e
movl %r8d, %r9d
movq %r9, %r10
shlq $0x4, %r10
movzwl 0x4(%rax,%r10), %edi
cmpl %r8d, %edi
je 0x17c51
leaq 0x4(%rax,%r10), %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 0x17c2b
movq %rdi, %r9
movw %di, (%r8)
shlq $0x4, %r9
addq $0x4, %rsi
orb 0x6(%rax,%r9), %cl
leaq 0x4(%rsi), %rdi
cmpq $0x14, %rsi
movq %rdi, %rsi
jl 0x17bfa
leaq 0x1e738(%rip), %rax     # 0x363aa
xorl %edx, %edx
cmpb %bl, (%rax)
movzbl %cl, %eax
sete %dl
leal -0xd(%rdx,%rdx,8), %ecx
orl %eax, %ecx
cmpl $-0x1, %ecx
je 0x17c90
leaq 0x1e720(%rip), %rax     # 0x363ae
movb (%rax), %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17edd
leaq 0x1e58d(%rip), %rax     # 0x363b1
cmpb %cl, (%rax)
jne 0x17edd
movslq 0x5594(%rdx), %rax
leaq (%rax,%rax,2), %r8
movslq 0x5598(%rdx), %rax
leaq (%rax,%rax,2), %rax
addq %r8, %rax
je 0x17edd
movsbq %cl, %r9
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
xorl %r8d, %r8d
decq %r9
imulq $0x4e2, %r9, %r9        # imm = 0x4E2
addq %rdi, %r9
testl %r10d, %r10d
js 0x17eb7
movsbq 0x4e42(%rdx,%r8), %r11
cmpb %cl, %r11b
jne 0x17e96
cmpb $-0x1, 0x4e40(%rdx,%r8)
je 0x17e96
movzwl 0x4e40(%rdx,%r8), %r11d
movl %r10d, %r10d
movw %r11w, (%r9,%r10,2)
jmp 0x17eb7
cmpl $0x2, 0x9c4(%rdi)
jne 0x17eb7
imulq $0x4e2, %r11, %r11      # imm = 0x4E2
movl %r10d, %r10d
addq %rdi, %r11
movw $0x78fc, -0x4e2(%r11,%r10,2) # imm = 0x78FC
movsbl 0x4e40(%rdx,%r8), %r10d
movsbl (%rsi), %r11d
imull %r10d, %r11d
movsbl 0x4e41(%rdx,%r8), %r10d
addq $0x3, %r8
addl %r11d, %r10d
cmpq %r8, %rax
jne 0x17e65
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1825c
movsbq (%rdx), %rax
cmpq $-0x1, %rax
je 0x1825c
movsbq 0x8(%rsi), %rcx
movsbq (%rsi), %r8
movsbq 0x1(%rdx), %rdx
imulq $0x4e2, %rcx, %rcx      # imm = 0x4E2
imulq %r8, %rax
addq %rax, %rdx
addq %rdi, %rcx
movzwl -0x4e2(%rcx,%rdx,2), %eax
cmpb $-0x4, %al
je 0x1825c
movsbq %al, %rdx
movzwl %ax, %ecx
leaq 0x1e16b(%rip), %rdi     # 0x363a9
imulq %r8, %rdx
shrl $0x8, %ecx
shlq $0x4, %rdx
addq 0x10(%rsi), %rdx
movsbq %cl, %rsi
shlq $0x4, %rsi
movb (%rsi,%rdx), %dl
cmpb (%rdi), %dl
je 0x18264
movw $0x78, %cx
movw $0xfc, %ax
movzwl %cx, %ecx
movzbl %al, %eax
shll $0x8, %ecx
orl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e132(%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
xorl %edx, %edx
movslq 0x4ec(%rdi), %r8
divl %r8d
leal -0x1(%r8), %eax
movl %eax, 0x4ec(%rdi)
movslq %edx, %rdx
movzwl 0x2(%rdi,%r8,2), %r8d
movzwl 0x4(%rdi,%rdx,2), %eax
movw %r8w, 0x4(%rdi,%rdx,2)
movl %eax, %r9d
shrl $0x8, %r9d
movslq 0x4ec(%rdi), %rdx
movw %ax, 0x4(%rdi,%rdx,2)
movsbq %al, %rdx
movsbq (%rsi), %r8
imulq %rdx, %r8
movsbq %r9b, %rdx
shlq $0x4, %rdx
shlq $0x4, %r8
addq 0x10(%rsi), %r8
movb (%rdx,%r8), %dl
cmpb (%rcx), %dl
jne 0x18277
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
vxorps %xmm0, %xmm0, %xmm0
xorl %eax, %eax
movl %eax, 0x12130(%rdi)
movq %rcx, 0x12128(%rdi)
vmovups %xmm0, 0x12138(%rdi)
movl %eax, 0x12150(%rdi)
movq %rcx, 0x12148(%rdi)
vmovups %xmm0, 0x12158(%rdi)
movw $0x0, 0x2f14(%rdi)
movl %eax, 0x12170(%rdi)
movq %rcx, 0x12168(%rdi)
vmovups %xmm0, 0x12178(%rdi)
movl %eax, 0x12190(%rdi)
movq %rcx, 0x12188(%rdi)
vmovups %xmm0, 0x12198(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x121a8(%rdi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9c58(%rdi), %rax
leaq 0x1df8b(%rip), %rcx     # 0x363aa
movzbl %dl, %ebp
movzbl %sil, %r14d
movq %rdi, %rbx
movsbl (%rax), %r13d
leal -0x1(%r13), %r15d
cmpb %dl, (%rcx)
jne 0x184a2
testb %r13b, %r13b
jle 0x18504
xorl %r12d, %r12d
movl $0x2, %r9d
movq %rbx, %rdi
xorl %esi, %esi
movl %r12d, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x18534
incl %r12d
cmpl %r12d, %r13d
jne 0x18441
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x185ee
testb %r13b, %r13b
jle 0x18513
movl $0x1, %ecx
movl $0x5, %r9d
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %ebp, %r8d
callq 0x18534
incl %r12d
cmpl %r12d, %r13d
jne 0x1847c
jmp 0x18513
testb %r13b, %r13b
jle 0x18504
xorl %r12d, %r12d
movl $0x3, %r9d
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x18534
incl %r12d
cmpl %r12d, %r13d
jne 0x184aa
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x185ee
testb %r13b, %r13b
jle 0x18513
movl $0x1, %ecx
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18534
incl %r12d
cmpl %r12d, %r13d
jne 0x184e1
jmp 0x18513
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x185ee
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 0x185ee
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x10(%r10), %r10
imull %edx, %eax
addl %esi, %eax
movslq %eax, %r11
shlq $0x4, %r11
movb (%r10,%r11), %r11b
movb $0x3, %r10b
subb %r8b, %r10b
cmpb %r10b, %r11b
je 0x185ed
pushq %rbx
leaq 0x1de3f(%rip), %rbx     # 0x363a9
xorl %r10d, %r10d
movzbl %dl, %edx
movslq %ecx, %rcx
cmpb (%rbx), %r11b
movl %eax, %ebx
movswq %ax, %rax
sete %r10b
shll $0x8, %esi
shll $0x10, %ebx
imulq $0x1388, %rcx, %rcx     # imm = 0x1388
movzwl %si, %esi
imulq $0x1d4c, %r10, %r11     # imm = 0x1D4C
orl %ebx, %esi
orl %esi, %edx
movslq 0x9c40(%rdi,%r10,4), %rsi
addq %rdi, %rcx
addq %rdi, %r11
leal 0x1(%rsi), %ebx
leaq (%rsi,%rsi,2), %rsi
movl %ebx, 0x9c40(%rdi,%r10,4)
movl %edx, 0x2710(%r11,%rsi,4)
movsbq %r8b, %rdx
movl %r10d, 0x2714(%r11,%rsi,4)
movl %r9d, 0x2718(%r11,%rsi,4)
incl 0x9c54(%rdi)
imulq $0x9c4, %rdx, %rdx      # imm = 0x9C4
addq %rdx, %rcx
movl %r10d, -0x9c4(%rcx,%rax,4)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18851
movl 0x7540(%rdi), %ecx
movslq %ecx, %rdx
movl 0x7530(%rdi,%rdx,4), %r8d
testl %r8d, %r8d
jne 0x1881d
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 0x187ee
movl %ecx, 0x7540(%rdi)
decl %r8d
movl %r8d, 0x7530(%rdi,%rdx,4)
imulq $0x1d4c, %rdx, %rdx     # imm = 0x1D4C
movslq %r8d, %rcx
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 0x1885b
movl $0x0, 0x7540(%rdi)
testl %eax, %eax
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x10(%rsp), %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %r15, -0x10(%r15)
leaq 0x19a59(%rip), %rsi     # 0x332b2
leaq 0x19a54(%rip), %rdx     # 0x332b4
movq %rsp, %rdi
callq 0xb1dc
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1c5ca(%rip), %rsi     # 0x35e43
leaq 0x1c5c4(%rip), %rdx     # 0x35e44
leaq 0x20(%rsp), %rdi
callq 0xb1dc
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rcx
movq %rsp, %rdx
movq %r14, %rsi
callq 0x2fafb
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x198ae
callq 0x52e0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x198bc
callq 0x52e0
movq 0x58(%rsp), %r14
cmpq $0x6, %r14
jne 0x199d2
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1c226(%rip), %rsi     # 0x35afe
leaq 0x1c223(%rip), %rdx     # 0x35b02
callq 0xb1dc
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x13f5e
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x11418
movzwl 0x20(%rsp), %eax
movw %ax, 0x12(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19915
callq 0x52e0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1a228(%rip), %rsi     # 0x33b4a
leaq 0x1a224(%rip), %rdx     # 0x33b4d
callq 0xb1dc
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x13f5e
movq %rax, %rdi
callq 0x1bf54
movl %eax, (%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19953
callq 0x52e0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1a1ee(%rip), %rsi     # 0x33b4e
leaq 0x1a1ec(%rip), %rdx     # 0x33b53
callq 0xb1dc
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x13f5e
movq %rax, %rdi
callq 0x1bf54
movl %eax, 0x4(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19992
callq 0x52e0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1a1b5(%rip), %rsi     # 0x33b54
leaq 0x1a1b2(%rip), %rdx     # 0x33b58
callq 0xb1dc
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x13f5e
movq %rax, %rdi
callq 0x13446
movq %rax, 0x8(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x199d2
callq 0x52e0
cmpq $0x6, %r14
leaq 0x40(%rsp), %rdi
sete %bl
callq 0x13554
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x199f7
jmp 0x199f7
jmp 0x199f7
movq %rax, %rbx
jmp 0x19a13
jmp 0x19a02
jmp 0x19a02
jmp 0x19a02
movq (%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x19a13
callq 0x52e0
leaq 0x40(%rsp), %rdi
callq 0x13554
movq %rbx, %rdi
callq 0x5670
movq 0x20(%rsp), %rdi
movq %rax, %rbx
cmpq %r12, %rdi
je 0x19a3c
callq 0x52e0
jmp 0x19a3c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19a1d
callq 0x52e0
jmp 0x19a1d
movq %rax, %rbx
jmp 0x19a1d
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18(%rsi), %rcx
movq %rdi, %rbx
xorl %r12d, %r12d
movl $0x0, %r14d
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r14
jb 0x1b8eb
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %r12
cmpq %r12, %r14
je 0x1b944
leaq 0x70(%rbx), %r15
cmpl $0x0, (%r14)
je 0x1b90a
cmpl $0x0, 0x4(%r14)
je 0x1b90a
movl 0x68(%rbx), %eax
cmpq %rax, 0x8(%r14)
jae 0x1b926
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c48a
movl %eax, %eax
subq %rax, 0x58(%rbx)
addq $0x20, %r14
cmpq %r12, %r14
jne 0x1b8f4
jmp 0x1b944
movq 0x18(%r14), %rax
cmpq $0x2, %rax
jb 0x1b91b
cmpw $0x0, 0x6(%rax)
je 0x1b91b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b8b8
jmp 0x1b91b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18(%rdx), %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x2, %rax
jb 0x1b97c
cmpw $0x0, 0x6(%rax)
jne 0x1bad6
leaq 0x1aa2e(%rip), %rdx     # 0x363b1
movswl 0x2(%r15), %esi
movswl 0x4(%r15), %ecx
movb 0x9(%r15), %al
addq $0x18, %rbx
xorl %ebp, %ebp
movq %rbx, %rdi
subl %ecx, %esi
cmpb (%rdx), %al
leaq 0x70(%r14), %rdx
cmovgel %ebp, %esi
callq 0x1c206
movq %r15, %rdi
callq 0x13114
movq %rax, 0x8(%rsp)
movq %rdx, %rax
shrq $0x20, %rax
movl %edx, 0x10(%rsp)
notl %edx
movb %al, 0x14(%rsp)
testl $0xffff0000, %edx       # imm = 0xFFFF0000
je 0x1bab6
leaq 0x18(%rsp), %r13
xorl %r12d, %r12d
xorl %ebp, %ebp
movl 0x10(%rsp), %eax
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
movl %eax, 0x4(%rsp)
movl 0x8(%r15), %edx
callq 0x17b80
movzwl 0x4(%rsp), %ecx
movq %r12, 0x20(%rsp)
movw $0x0, 0x28(%rsp)
leaq 0x1a9a2(%rip), %rdi     # 0x363b1
movw %cx, 0x2a(%rsp)
movq %r12, 0x30(%rsp)
movzbl %al, %ecx
movl 0x1534(%r14), %edx
movl %edx, %esi
cmpb %al, (%rdi)
je 0x1ba2b
movl %ecx, %esi
leaq 0x1a977(%rip), %rax     # 0x363a9
cmpb %dl, (%rax)
leaq 0x1a973(%rip), %rax     # 0x363ae
cmovnel %esi, %ecx
cmpb (%rax), %cl
jne 0x1ba51
movl $0x1, 0x18(%rsp)
movl $0x1, %eax
jmp 0x1ba7d
movb 0x8(%r15), %al
cmpb %al, %cl
jne 0x1ba65
movl $0x3fffffff, 0x18(%rsp) # imm = 0x3FFFFFFF
xorl %eax, %eax
jmp 0x1ba7d
movb $0x3, %dl
movl $0x0, 0x18(%rsp)
subb %al, %dl
xorl %eax, %eax
cmpb %dl, %cl
sete %al
orl $0x3ffffffe, %eax       # imm = 0x3FFFFFFE
movl %eax, 0x1c(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c3dc
movq %rax, %rdi
movq %r13, %rsi
callq 0x1c43a
movq %r13, %rdi
callq 0x1bfd4
leaq 0x8(%rsp), %rdi
incl %ebp
callq 0x1315e
cmpw $-0x1, 0x12(%rsp)
jne 0x1b9de
movl %ebp, %eax
lock
addq %rax, 0x58(%r14)
movl %ebp, %esi
movq (%rbx), %rdi
callq 0x1e7ea
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16b4d(%rip), %rdi     # 0x3262a
leaq 0x18084(%rip), %rsi     # 0x33b68
leaq 0x18184(%rip), %rcx     # 0x33c6f
movl $0x142, %edx            # imm = 0x142
callq 0x51d0
leaq 0x18(%rsp), %rdi
movq %rax, %rbx
callq 0x1bfd4
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x18(%rcx), %rcx
movl %r8d, 0x10(%rsp)
movl %edx, 0x14(%rsp)
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
xorl %r12d, %r12d
movl $0x0, %r13d
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r13
jb 0x1bb54
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %r12
cmpq %r12, %r13
je 0x1bc90
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %ebp
movb $0x3, %al
subb %cl, %al
movzbl %cl, %ecx
movb %al, 0xf(%rsp)
movzbl %al, %eax
movl %ecx, 0x1c(%rsp)
movl %eax, 0x18(%rsp)
cmpq %rbp, 0x8(%r13)
jb 0x1bc83
cmpl $0x3fffffff, (%r14)     # imm = 0x3FFFFFFF
je 0x1bc1a
movl 0x4(%r14), %eax
leaq 0x1a814(%rip), %rcx     # 0x363b1
cmpl $0x3ffffffe, %eax       # imm = 0x3FFFFFFE
je 0x1bbb2
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
je 0x1bbba
leaq 0x1a7fc(%rip), %rcx     # 0x363ae
movl 0x10(%rsp), %edx
cmpb %dl, (%rcx)
jne 0x1bc1a
cmpl $0x3fffffff, (%r13)     # imm = 0x3FFFFFFF
movl 0x10(%rsp), %ecx
je 0x1bbf2
movl 0x4(%r13), %edx
movb 0xf(%rsp), %cl
cmpl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
je 0x1bbf2
cmpl $0x3ffffffe, %edx       # imm = 0x3FFFFFFE
jne 0x1bbe9
leaq 0x1a7ca(%rip), %rcx     # 0x363b1
jmp 0x1bbf0
leaq 0x1a7be(%rip), %rcx     # 0x363ae
movb (%rcx), %cl
movl 0x10(%rsp), %edx
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
je 0x1bc16
cmpl $0x3ffffffe, %eax       # imm = 0x3FFFFFFE
jne 0x1bc0d
leaq 0x1a7a6(%rip), %rax     # 0x363b1
jmp 0x1bc14
leaq 0x1a79a(%rip), %rax     # 0x363ae
movb (%rax), %dl
cmpb %dl, %cl
jne 0x1bc83
movq %r15, %rdi
callq 0x12b38
movzwl 0x12(%r13), %edx
movl 0x1c(%rsp), %esi
movq %r15, %rdi
callq 0x12d00
leaq 0x28(%rsp), %rbx
movq %r13, %rsi
movq %rbx, %rdi
callq 0x1904c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12e4c
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1bc62
callq 0x52e0
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %edx
movl 0x18(%rsp), %r8d
movq %r15, %rsi
movq %r13, %rcx
callq 0x1bb0a
movq %r15, %rdi
callq 0x12f30
addq $0x20, %r13
cmpq %r12, %r13
jne 0x1bb7b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rbx
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1bcb6
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x1a14d(%rip), %rax     # 0x363ae
movb 0x8(%rdi), %bpl
movq %rsi, %r14
movq %rdi, %r15
movb (%rax), %bl
callq 0x13114
movq %rax, 0x8(%rsp)
movq %rdx, %rax
shrq $0x20, %rax
movl %edx, 0x10(%rsp)
notl %edx
movb %al, 0x14(%rsp)
testl $0xffff0000, %edx       # imm = 0xFFFF0000
je 0x1c2e2
movb %bpl, 0x3(%rsp)
movzbl %bpl, %ebp
leaq 0x4(%rsp), %r12
leaq 0x8(%rsp), %r13
movl 0x10(%rsp), %eax
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %eax, 0x4(%rsp)
incl (%r14)
callq 0x17b80
cmpb %bpl, %al
je 0x1c2e6
leaq 0x1a0ea(%rip), %rcx     # 0x363b1
movzbl %bl, %ebx
movq %r13, %rdi
movzbl (%rcx), %ecx
cmpb %cl, %al
cmovel %ecx, %ebx
callq 0x1315e
cmpw $-0x1, 0x12(%rsp)
jne 0x1c2a3
movl %ebx, %eax
jmp 0x1c2ea
movb 0x3(%rsp), %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop