LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_print(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_print(vecstr args){
	Board board = *hist;
	for(auto arg : args)
		if (!board.move(arg))
			break;
	return GTPResponse(true, "\n" + board.to_s(colorboard));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
addq $0x80, %rsi
leaq 0x60(%rsp), %rdi
movq %rdx, %rbx
callq 0x9908
movq (%rbx), %r12
movq 0x8(%rbx), %r15
leaq 0x20(%rsp), %r13
leaq 0xe(%rsp), %rbp
pushq $0x1
popq %rbx
cmpq %r15, %r12
je 0x1ce33
movq %r13, %rdi
movq %r12, %rsi
callq 0x5490
movq %rbp, %rdi
movq %r13, %rsi
callq 0xd26c
leaq 0x60(%rsp), %rdi
movq %rbp, %rsi
movl %ebx, %edx
movl %ebx, %ecx
callq 0xe1ea
movq %r13, %rdi
movl %eax, %r14d
callq 0x5150
addq $0x20, %r12
testb %r14b, %r14b
jne 0x1cdf3
movq 0x18(%rsp), %rax
movzbl 0xcd(%rax), %edx
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x17dc6
leaq 0x5a87(%rip), %rsi      # 0x228dc
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xcf8b
movq 0x10(%rsp), %rbx
pushq $0x1
popq %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x40(%rsp), %rdi
callq 0x5150
leaq 0x20(%rsp), %rdi
callq 0x5150
leaq 0x60(%rsp), %rdi
callq 0x83bc
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
jmp 0x1cec7
jmp 0x1cec4
jmp 0x1cebf
movq %rax, %rbx
jmp 0x1ced1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5150
leaq 0x60(%rsp), %rdi
callq 0x83bc
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_boardsize(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_boardsize(vecstr args){
	if(args.size() != 1)
		return GTPResponse(false, "Current board size: " + hist->size());

	if(!Board::valid_size(args[0]))
		return GTPResponse(false, "Size " + args[0] + " is out of range.");

	hist = History<Board>(Board(args[0]));
	set_board();
	time_control.new_game();

	return GTPResponse(true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
movq %rsi, %r14
subq %rdi, %rax
cmpq $0x20, %rax
jne 0x1cfd8
movq %rdx, %r15
callq 0x9496
testb %al, %al
je 0x1d019
movq (%r15), %rsi
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x5490
leaq 0xe8(%rsp), %rdi
movq %r15, %rsi
callq 0x82d2
leaq 0x88(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x8384
leaq 0x88(%rsp), %r15
leaq 0x68(%r14), %rdi
movq %r15, %rsi
callq 0x1ef74
movq %r15, %rdi
callq 0x8570
leaq 0xe8(%rsp), %rdi
callq 0x83bc
leaq 0x68(%rsp), %rdi
callq 0x5150
movq 0xd8(%r14), %rdi
leaq 0x80(%r14), %rsi
movq (%rdi), %rax
pushq $0x1
popq %rdx
callq *0x20(%rax)
vmovsd 0x40(%r14), %xmm0
vmovsd %xmm0, 0x60(%r14)
leaq 0x5931(%rip), %rsi      # 0x228dd
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x5110
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x8(%rsp), %rdi
jmp 0x1d068
subq $-0x80, %r14
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1ef62
leaq 0x959a(%rip), %rsi      # 0x26590
leaq 0x48(%rsp), %rdi
movq %r15, %rdx
callq 0xcf8b
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8d00
leaq 0x48(%rsp), %rdi
jmp 0x1d05b
movq (%r15), %rdx
leaq 0x88(%rsp), %r14
leaq 0x957a(%rip), %rsi      # 0x265a5
movq %r14, %rdi
callq 0x8070
leaq 0x9571(%rip), %rdx      # 0x265ab
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x8051
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8d00
leaq 0x28(%rsp), %rdi
callq 0x5150
leaq 0x88(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
jmp 0x1d0ce
movq %rax, %rbx
jmp 0x1d0d3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x1d0bc
leaq 0xe8(%rsp), %rdi
movq %rax, %rbx
callq 0x83bc
jmp 0x1d0ad
jmp 0x1d0c3
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x1d0ce
leaq 0x48(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
jmp 0x1d0c6
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_clearboard(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_clearboard(vecstr args){
	hist.clear();
	set_board();
	time_control.new_game();

	return GTPResponse(true);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x68(%rsi), %rdi
movq %rsi, %r14
callq 0x1ef9e
movq 0xd8(%r14), %rdi
leaq 0x80(%r14), %rsi
movq (%rdi), %rax
pushq $0x1
popq %rbp
movl %ebp, %edx
callq *0x20(%rax)
vmovsd 0x40(%r14), %xmm0
leaq 0x57c4(%rip), %rsi      # 0x228dd
leaq 0xf(%rsp), %rdx
vmovsd %xmm0, 0x60(%r14)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x5110
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x8d00
leaq 0x10(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_undo(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_undo(vecstr args){
	int num = (args.size() >= 1 ? from_str<int>(args[0]) : 1);

	while(num--){
		hist.undo();
	}
	set_board(false);
	if(verbose >= 2)
		logerr(hist->to_s(colorboard) + "\n");
	return GTPResponse(true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
movq %rsi, %r14
cmpq %rdi, 0x8(%rdx)
je 0x1d18c
callq 0x94a7
movl %eax, %ebp
jmp 0x1d18f
pushq $0x1
popq %rbp
leaq 0x68(%r14), %r15
subl $0x1, %ebp
jb 0x1d1a2
movq %r15, %rdi
callq 0x1efb4
jmp 0x1d193
movq 0xd8(%r14), %rdi
leaq 0x80(%r14), %r15
movq (%rdi), %rax
pushq $0x1
popq %rdx
movq %r15, %rsi
callq *0x20(%rax)
cmpl $0x2, 0xc8(%r14)
jl 0x1d211
movzbl 0xcd(%r14), %edx
leaq 0x28(%rsp), %r14
movq %r15, %rsi
movq %r14, %rdi
callq 0x17dc6
leaq 0x56f7(%rip), %rdx      # 0x228dc
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x8051
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0xd451
movq %r14, %rdi
callq 0x5150
leaq 0x28(%rsp), %rdi
callq 0x5150
leaq 0x56c5(%rip), %rsi      # 0x228dd
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5110
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x8(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x1d261
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
jmp 0x1d26b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_patterns(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_patterns(vecstr args){
	bool symmetric = true;
	bool invert = true;
	std::string ret;
	const Board & board = *hist;
	for (auto move : board) {
		ret += move.to_s() + " ";
		unsigned int p = board.pattern(move);
		if(symmetric)
			p = board.pattern_symmetry(p);
		if(invert && board.to_play() == Side::P2)
			p = board.pattern_invert(p);
		ret += to_str(p);
		ret += "\n";
	}
	return GTPResponse(true, ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x38(%rsp), %rax
leaq 0x80(%rsi), %r15
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %r15, %rdi
callq 0xe78e
leaq 0x18(%rsp), %rcx
leaq 0x88(%rsp), %r13
leaq 0x68(%rsp), %rbp
leaq 0x28(%rsp), %rbx
leaq 0x5611(%rip), %r12      # 0x228dc
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
shrq $0x20, %rdx
movb %dl, 0xc(%rcx)
cmpw $-0x1, 0x22(%rsp)
je 0x1d395
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
movq %r13, %rdi
callq 0xcfb0
leaq 0x9643(%rip), %rdx      # 0x26943
movq %rbp, %rdi
movq %r13, %rsi
callq 0x8051
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5700
movq %rbp, %rdi
callq 0x5150
movq %r13, %rdi
callq 0x5150
movswl 0xe(%rsp), %esi
movq %r15, %rdi
callq 0x12fe4
movl %eax, %edi
callq 0x1f036
leaq 0x9b6a(%rip), %rdx      # 0x26eab
movb 0x88(%r14), %cl
cmpb (%rdx), %cl
jne 0x1d35e
movl %eax, %ecx
shrl %ecx
andl $0xd5555555, %eax       # imm = 0xD5555555
andl $0x55555555, %ecx       # imm = 0x55555555
leal (%rcx,%rax,2), %eax
movq %rbp, %rdi
movl %eax, %esi
callq 0xd215
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5700
movq %rbp, %rdi
callq 0x5150
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56b0
leaq 0x18(%rsp), %rdi
callq 0xe7ae
jmp 0x1d2d8
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5490
pushq $0x1
popq %rsi
movq 0x10(%rsp), %rbx
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x48(%rsp), %rdi
callq 0x5150
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48(%rsp), %rdi
movq %rax, %rbx
jmp 0x1d418
jmp 0x1d421
jmp 0x1d421
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x1d418
jmp 0x1d421
jmp 0x1d421
movq %rax, %rbx
jmp 0x1d410
leaq 0x68(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
leaq 0x88(%rsp), %rdi
callq 0x5150
jmp 0x1d424
jmp 0x1d421
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::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 (auto move : *hist)
		ret += move.to_s() + " ";
	return GTPResponse(true, ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x38(%rsp), %rax
movq %rdi, 0x10(%rsp)
leaq 0x80(%rsi), %rdi
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
callq 0xe78e
leaq 0x18(%rsp), %r14
leaq 0x68(%rsp), %r15
leaq 0xc(%rsp), %r12
leaq 0x94c4(%rip), %r13      # 0x26943
leaq 0x88(%rsp), %rbp
leaq 0x28(%rsp), %rbx
movq %rax, (%r14)
movl %edx, 0x8(%r14)
shrq $0x20, %rdx
movb %dl, 0xc(%r14)
cmpw $-0x1, 0x22(%rsp)
je 0x1d4e9
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xcfb0
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x8051
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5700
movq %rbp, %rdi
callq 0x5150
movq %r15, %rdi
callq 0x5150
movq %r14, %rdi
callq 0xe7ae
jmp 0x1d49b
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5490
pushq $0x1
popq %rsi
movq 0x10(%rsp), %rbx
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x48(%rsp), %rdi
callq 0x5150
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48(%rsp), %rdi
movq %rax, %rbx
jmp 0x1d560
jmp 0x1d567
jmp 0x1d567
jmp 0x1d567
movq %rax, %rbx
jmp 0x1d55b
leaq 0x88(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
leaq 0x68(%rsp), %rdi
callq 0x5150
jmp 0x1d56a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_history(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_history(vecstr args){
	std::string ret;
	for(auto m : hist)
		ret += m.to_s() + " ";
	return GTPResponse(true, ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq 0x28(%rsp), %rax
leaq 0x58(%rsp), %r14
leaq 0x93a5(%rip), %r12      # 0x26943
leaq 0x78(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq %rdi, 0x10(%rsp)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x68(%rsi), %rbx
movq 0x70(%rsi), %r15
cmpq %r15, %rbx
je 0x1d60a
movzwl (%rbx), %eax
movw %ax, 0xe(%rsp)
leaq 0xe(%rsp), %rsi
movq %r14, %rdi
callq 0xcfb0
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x8051
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5700
movq %r13, %rdi
callq 0x5150
movq %r14, %rdi
callq 0x5150
addq $0x2, %rbx
jmp 0x1d5c1
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5490
pushq $0x1
popq %rsi
movq 0x10(%rsp), %rbx
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x38(%rsp), %rdi
callq 0x5150
leaq 0x18(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%rsp), %rdi
movq %rax, %rbx
jmp 0x1d67f
jmp 0x1d663
movq %rax, %rbx
jmp 0x1d684
movq %rax, %rbx
jmp 0x1d67a
leaq 0x78(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
leaq 0x58(%rsp), %rdi
callq 0x5150
leaq 0x18(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_playgame(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_playgame(vecstr args){
	GTPResponse ret(true);

	for(unsigned int i = 0; ret.success && i < args.size(); i++)
		ret = play(args[i], hist->to_play());

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4ef5(%rip), %rsi      # 0x228dd
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5110
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x8(%rsp), %rdi
callq 0x5150
leaq 0x28(%rsp), %r12
xorl %ebp, %ebp
cmpb $0x1, (%rbx)
jne 0x1da62
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movl %ebp, %eax
subq %rdx, %rcx
sarq $0x5, %rcx
cmpq %rax, %rcx
jbe 0x1da62
movl 0x88(%r15), %ecx
shlq $0x5, %rax
addq %rax, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d696
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa0e6
movq %r12, %rdi
callq 0x7ef6
incl %ebp
jmp 0x1da18
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
movq %rax, %r14
callq 0x5150
jmp 0x1da91
movq %rax, %r14
jmp 0x1da91
movq %rbx, %rdi
movq %rax, %r14
callq 0x7ef6
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_play(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_play(vecstr args){
	if(args.size() != 2)
		return GTPResponse(false, "Wrong number of arguments");

	switch(tolower(args[0][0])){
		case 'w': return play(args[1], Side::P1);
		case 'b': return play(args[1], Side::P2);
		default:  return GTPResponse(false, "Invalid player selection");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq (%rdx), %r15
movq 0x8(%rdx), %rax
movq %rdi, %rbx
subq %r15, %rax
cmpq $0x40, %rax
jne 0x1dad7
movq (%r15), %rax
movq %rsi, %r14
movsbl (%rax), %edi
callq 0x54c0
cmpl $0x62, %eax
je 0x1db03
cmpl $0x77, %eax
jne 0x1db21
leaq 0x93d5(%rip), %rax      # 0x26eaa
jmp 0x1db0a
leaq 0x8b3d(%rip), %rsi      # 0x2661b
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5110
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8d00
leaq 0x30(%rsp), %rdi
jmp 0x1db4b
leaq 0x93a1(%rip), %rax      # 0x26eab
addq $0x20, %r15
movzbl (%rax), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1d696
jmp 0x1db50
leaq 0x8b0d(%rip), %rsi      # 0x26635
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5110
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8d00
leaq 0x10(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rdi
jmp 0x1db6b
jmp 0x1db75
leaq 0x30(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
jmp 0x1db78
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_verbose(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_verbose(vecstr args){
	if(args.size() >= 1)
		verbose = from_str<int>(args[0]);
	else
		verbose = !verbose;
	return GTPResponse(true, "Verbose " + to_str(verbose));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
movq %rsi, %r14
cmpq %rdi, 0x8(%rdx)
je 0x1ddec
callq 0x94a7
movl %eax, %esi
movl %eax, 0xc8(%r14)
jmp 0x1de01
xorl %esi, %esi
cmpl $0x0, 0xc8(%r14)
sete %sil
movl %esi, 0xc8(%r14)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xd1be
leaq 0x8848(%rip), %rsi      # 0x2665d
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xcf8b
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x8(%rsp), %rdi
callq 0x5150
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
jmp 0x1de63
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_colorboard(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_colorboard(vecstr args){
	if(args.size() >= 1)
		colorboard = from_str<int>(args[0]);
	else
		colorboard = !colorboard;
	return GTPResponse(true, "Color " + to_str(colorboard));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
movq %rsi, %r14
cmpq %rdi, 0x8(%rdx)
je 0x1dea0
callq 0x94a7
testl %eax, %eax
setne %al
setne 0xcd(%r14)
jmp 0x1deb8
movb 0xcd(%r14), %al
movl %eax, %ecx
xorb $0x1, %cl
testb %al, %al
sete %al
movb %cl, 0xcd(%r14)
leaq 0x28(%rsp), %r14
movzbl %al, %esi
movq %r14, %rdi
callq 0x1ca27
leaq 0x8797(%rip), %rsi      # 0x26666
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xcf8b
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x8(%rsp), %rdi
callq 0x5150
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
jmp 0x1df1d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_extended(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_extended(vecstr args){
	if(args.size() >= 1)
		genmoveextended = from_str<bool>(args[0]);
	else
		genmoveextended = !genmoveextended;
	return GTPResponse(true, "extended " + to_str(genmoveextended));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
movq %rsi, %r14
cmpq %rdi, 0x8(%rdx)
je 0x1df54
callq 0x1cae1
movb %al, 0xcc(%r14)
jmp 0x1df6c
movb 0xcc(%r14), %al
movl %eax, %ecx
xorb $0x1, %cl
testb %al, %al
sete %al
movb %cl, 0xcc(%r14)
leaq 0x28(%rsp), %r14
movzbl %al, %esi
movq %r14, %rdi
callq 0x1ca27
leaq 0x86ea(%rip), %rsi      # 0x2666d
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xcf8b
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x8(%rsp), %rdi
callq 0x5150
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
jmp 0x1dfd1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_dists(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_dists(vecstr args){
	using std::string;
	Board board = *hist;
	LBDists dists(&board);

	Side side = Side::NONE;
	if(args.size() >= 1){
		switch(tolower(args[0][0])){
			case 'w': side = Side::P1; break;
			case 'b': side = Side::P2; break;
			default:
				return GTPResponse(false, "Invalid player selection");
		}
	}

	if(args.size() >= 2) {
		return GTPResponse(true, to_str(dists.get(Move(args[1]), side)));
	}

	return GTPResponse(true, "\n" + dists.to_s(side));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x9d38, %rsp           # imm = 0x9D38
subq $-0x80, %rsi
leaq 0x90(%rsp), %r14
movq %rdi, %rbx
movq %rdx, %r15
movq %r14, %rdi
callq 0x9908
leaq 0xd8(%rsp), %rdi
movq %r14, %rsi
callq 0x1f92c
movq (%r15), %r14
movq 0x8(%r15), %r15
subq %r14, %r15
je 0x1e2bd
movq (%r14), %rax
movsbl (%rax), %edi
callq 0x54c0
cmpl $0x62, %eax
je 0x1e2c9
cmpl $0x77, %eax
jne 0x1e370
leaq 0x8bef(%rip), %rax      # 0x26eaa
jmp 0x1e2d0
leaq 0x8be5(%rip), %rax      # 0x26ea9
movb (%rax), %bpl
jmp 0x1e323
leaq 0x8bdb(%rip), %rax      # 0x26eab
movb (%rax), %bpl
cmpq $0x21, %r15
jb 0x1e323
addq $0x20, %r14
leaq 0xe(%rsp), %rdi
movq %r14, %rsi
callq 0xd26c
movzwl 0xe(%rsp), %esi
movzbl %bpl, %edx
leaq 0xd8(%rsp), %rdi
callq 0x129d6
leaq 0x50(%rsp), %rdi
movl %eax, %esi
callq 0xd1be
pushq $0x1
popq %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x50(%rsp), %rdi
jmp 0x1e39a
movzbl %bpl, %edx
leaq 0x10(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x1f1b8
leaq 0x459c(%rip), %rsi      # 0x228dc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xcf8b
pushq $0x1
popq %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x8d00
leaq 0x30(%rsp), %rdi
callq 0x5150
leaq 0x10(%rsp), %rdi
jmp 0x1e39a
leaq 0x82be(%rip), %rsi      # 0x26635
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5110
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8d00
leaq 0x70(%rsp), %rdi
callq 0x5150
leaq 0x90(%rsp), %rdi
callq 0x83bc
movq %rbx, %rax
addq $0x9d38, %rsp           # imm = 0x9D38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50(%rsp), %rdi
jmp 0x1e3c9
leaq 0x70(%rsp), %rdi
movq %rax, %rbx
jmp 0x1e3e7
jmp 0x1e3f2
leaq 0x30(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
jmp 0x1e3e2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5150
jmp 0x1e3f5
jmp 0x1e3f2
jmp 0x1e3f2
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x83bc
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::AgentPNS(Morat::Hex::Board const&)
AgentPNS(const Board & b) : Agent(b), pool(this) {
		ab = 2;
		df = true;
		epsilon = 0.25;
		ties = Side::NONE;
		lbdist = false;
		numthreads = 1;
		pool.set_num_threads(numthreads);
		gclimit = 5;

		nodes = 0;
		reset();

		set_memlimit(1000*1024*1024);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xd978
leaq 0x1ccd6(%rip), %rax     # 0x3bb50
leaq 0x70(%rbx), %r14
addq $0x10, %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x1f754
leaq 0x1430(%rbx), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1f7b2
leaq 0x8003(%rip), %rax      # 0x26ea9
leaq 0x1540(%rbx), %r12
movb (%rax), %al
movw $0x78fc, 0x1552(%rbx)   # imm = 0x78FC
andq $0x0, 0x1558(%rbx)
movl $0x2, 0x1528(%rbx)
movb $0x1, 0x152c(%rbx)
movl $0x3e800000, 0x1530(%rbx) # imm = 0x3E800000
movb %al, 0x1534(%rbx)
movb $0x0, 0x1535(%rbx)
movl $0x1, 0x1538(%rbx)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x16524
movl $0x5, 0x68(%rbx)
andq $0x0, 0x58(%rbx)
andq $0x0, 0x1518(%rbx)
movb $0x0, 0x8(%rbx)
movq (%rbx), %rax
movl $0x3e800000, %esi       # imm = 0x3E800000
movq %rbx, %rdi
callq *0x30(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r13
jmp 0x1ef4a
movq %rax, %r13
jmp 0x1ef52
movq %r12, %rdi
movq %rax, %r13
callq 0x157b8
movq %r15, %rdi
callq 0x16a42
movq %r14, %rdi
callq 0x16a80
movq %rbx, %rdi
callq 0xec22
movq %r13, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/../lib/lbdist.h
// Function: Morat::LBDistsBase<Morat::Hex::LBDists, Morat::Hex::Board>::to_s[abi:cxx11](Morat::Side)
std::string to_s(Side side = Side::NONE) {
	// Return a string representation of the whole board, with empty cells showing their distance numbers
		if (board == NULL)
			return "LBDistsBase has no board.....\n";
		return board->to_s(true, std::bind(&LBDistsBase::get_s, this, std::placeholders::_1, side));
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq 0x9c58(%rsi), %r14
movq %rdi, %rbx
testq %r14, %r14
je 0x1f214
leaq 0x84f(%rip), %rcx       # 0x1fa26
leaq 0x20(%rsp), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movb %dl, 0x10(%rax)
movq %rsi, 0x18(%rax)
movq %rax, %rsi
callq 0x1fa82
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x17e20
movq %rsp, %rdi
callq 0x850c
jmp 0x1f228
leaq 0x75bc(%rip), %rsi      # 0x267d7
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rsp, %rdi
movq %rax, %rbx
callq 0x850c
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/../lib/board_grid_hex.h
// Function: Morat::BoardGridHex<Morat::Hex::Board>::pattern_mirror(unsigned long)
static Pattern pattern_mirror(Pattern p) {
		// HGFEDC BA9876 543210 -> DEFGHC 6789AB 123450
		return ((p & (3ull <<  6))      ) | ((p & (3ull <<  0))     ) | // 0,3 stay in place
		       ((p & (3ull << 10)) >>  8) | ((p & (3ull <<  2)) << 8) | // 1,5 swap
		       ((p & (3ull <<  8)) >>  4) | ((p & (3ull <<  4)) << 4) | // 2,4 swap
		       ((p & (3ull << 22)) >> 10) | ((p & (3ull << 12)) <<10) | // 6,B swap
		       ((p & (3ull << 20)) >>  6) | ((p & (3ull << 14)) << 6) | // 7,A swap
		       ((p & (3ull << 18)) >>  2) | ((p & (3ull << 16)) << 2) | // 8,9 swap
		       ((p & (3ull << 30))      ) | ((p & (3ull << 24))     ) | // F,C stay in place
		       ((p & (3ull << 34)) >>  8) | ((p & (3ull << 26)) << 8) | // H,D swap
		       ((p & (3ull << 32)) >>  4) | ((p & (3ull << 28)) << 4);  // G,E swap
	}

// Assembly:
vpmovsxbq 0x6b1c(%rip), %zmm1 # 0x26488
vpbroadcastq %rdi, %zmm0
movb $-0x56, %al
movq %rdi, %rcx
shlq $0x2, %rcx
movabsq $0x300000000, %rdx      # imm = 0x300000000
kmovd %eax, %k1
vpbroadcastq %rcx, %ymm3
movl %edi, %eax
shrl $0x2, %eax
andl $0xc30000c3, %edi       # imm = 0xC30000C3
andl $0x30000, %eax          # imm = 0x30000
vpsrlvq %zmm1, %zmm0, %zmm2
vpsllvq %zmm1, %zmm0, %zmm0
vmovdqa64 %zmm0, %zmm2 {%k1}
vpandq 0x6b45(%rip), %zmm2, %zmm1 # 0x26500
vpblendd $0xc0, %ymm3, %ymm2, %ymm2 # ymm2 = ymm2[0,1,2,3,4,5],ymm3[6,7]
vpand 0x6b97(%rip), %ymm2, %ymm2 # 0x26560
vextracti128 $0x1, %ymm0, %xmm0
vpextrq $0x1, %xmm0, %rcx
andq %rcx, %rdx
orq %rax, %rdx
vextracti64x4 $0x1, %zmm1, %ymm0
vporq %zmm0, %zmm1, %zmm0
vextracti128 $0x1, %ymm0, %xmm1
vpor %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpor %xmm1, %xmm0, %xmm0
vmovq %xmm0, %rcx
vextracti128 $0x1, %ymm2, %xmm0
vpor %xmm0, %xmm2, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpor %xmm1, %xmm0, %xmm0
vmovq %xmm0, %rax
orq %rdi, %rax
orq %rdx, %rax
orq %rcx, %rax
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/fileio.cpp
// Function: Morat::eat_whitespace(std::istream&)
void eat_whitespace(std::istream & is){
	int c = is.peek();
	while(c == ' ' || c == '\n' || c == '\t'){
		is.get();
		c = is.peek();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $0x100000600, %r14      # imm = 0x100000600
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x5100
cmpl $0x20, %eax
ja 0x1fcc3
movl %eax, %eax
btq %rax, %r14
jae 0x1fcc3
movq %rbx, %rdi
callq 0x5410
jmp 0x1fca4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/fileio.cpp
// Function: Morat::eat_char(_IO_FILE*, int)
bool eat_char(FILE * fd, int expect){
	int c = fgetc(fd);
	if (c == expect)
		return true;
	ungetc(c, fd);
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x5560
movl %eax, %ebp
cmpl %ebx, %eax
je 0x1fce9
movl %ebp, %edi
movq %r14, %rsi
callq 0x5050
cmpl %ebx, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/fileio.cpp
// Function: Morat::eat_char(std::istream&, int)
bool eat_char(std::istream & is, int expect){
	int c = is.peek();
	if (c == expect){
		is.get();
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x5100
movl %eax, %ebp
cmpl %ebx, %eax
jne 0x1fd0f
movq %r14, %rdi
callq 0x5410
cmpl %ebx, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/fileio.cpp
// Function: Morat::read_until[abi:cxx11](_IO_FILE*, char, bool)
string read_until(FILE * fd, char until, bool include){
	string ret;
	char c = fgetc(fd);
	while(c != until){
		ret += c;
		c = fgetc(fd);
	}
	if(!include)
		ungetc(c, fd);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x10(%rdi), %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x5560
movsbl %al, %ecx
cmpl %ebp, %ecx
je 0x1fd5a
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
jmp 0x1fd3e
testb %r15b, %r15b
jne 0x1fd69
movl %ebp, %edi
movq %r14, %rsi
callq 0x5050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %r14
callq 0x5150
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/timecontrol.h
// Function: Morat::TimeControl::method_name[abi:cxx11]() const
std::string method_name() const {
		switch(method){
			case PERCENT: return "percent";
			case EVEN:    return "even";
			case STATS:   return "stats";
			default:      return "WTF? unknown time control method";
		}
	}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl (%rsi), %eax
movq %rdi, %rbx
cmpl $0x2, %eax
je 0x20af4
cmpl $0x1, %eax
je 0x20ae6
testl %eax, %eax
jne 0x20b02
leaq 0x6331(%rip), %rsi      # 0x26e10
leaq 0xf(%rsp), %rdx
jmp 0x20b0e
leaq 0x632d(%rip), %rsi      # 0x26e1a
leaq 0xe(%rsp), %rdx
jmp 0x20b0e
leaq 0x6326(%rip), %rsi      # 0x26e21
leaq 0xd(%rsp), %rdx
jmp 0x20b0e
leaq 0x634d(%rip), %rsi      # 0x26e56
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/outcome.cpp
// Function: Morat::Side::to_s[abi:cxx11]() const
std::string Side::to_s() const {
	if(*this == UNDEF) return "never";
	if(*this == NONE)  return "none";
	if(*this == P1)    return "white";
	if(*this == P2)    return "black";
	if(*this == BOTH)  return "both";
	return "unknown";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movzbl (%rsi), %eax
movq %rdi, %rbx
cmpq $0x3, %rax
ja 0x20bff
leaq 0x6290(%rip), %rcx      # 0x26e78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x29e6(%rip), %rsi      # 0x235de
leaq 0xe(%rsp), %rdx
jmp 0x20c4a
cmpl $0xfc, %eax
jne 0x20c14
leaq 0x62a8(%rip), %rsi      # 0x26eb5
leaq 0xf(%rsp), %rdx
jmp 0x20c4a
leaq 0x29bb(%rip), %rsi      # 0x235d6
leaq 0xa(%rsp), %rdx
jmp 0x20c4a
leaq 0x1854(%rip), %rsi      # 0x2247d
leaq 0xc(%rsp), %rdx
jmp 0x20c4a
leaq 0x6284(%rip), %rsi      # 0x26ebb
leaq 0xb(%rsp), %rdx
jmp 0x20c4a
leaq 0x1802(%rip), %rsi      # 0x22447
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/outcome.cpp
// Function: Morat::Outcome::to_s[abi:cxx11]() const
std::string Outcome::to_s() const {
	if(*this == UNDEF)   return "undefined";
	if(*this == UNKNOWN) return "unknown";
	if(*this == P2_DRAW) return "black_or_draw";
	if(*this == P1_DRAW) return "white_or_draw";
	if(*this == DRAW ||
	   *this == DRAW2)   return "draw"; // simultaneous win
	if(*this == P1)      return "white";
	if(*this == P2)      return "black";
    return "unknown";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movzbl (%rsi), %eax
movq %rdi, %rbx
cmpq $0x3, %rax
jbe 0x20ce3
addl $0xffffff04, %eax       # imm = 0xFFFFFF04
cmpl $0x3, %eax
ja 0x20d01
leaq 0x61cc(%rip), %rcx      # 0x26e98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x61e8(%rip), %rsi      # 0x26ec4
leaq 0xf(%rsp), %rdx
jmp 0x20d53
leaq 0x619e(%rip), %rcx      # 0x26e88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6210(%rip), %rsi      # 0x26f0a
leaq 0xb(%rsp), %rdx
jmp 0x20d53
leaq 0x28ce(%rip), %rsi      # 0x235d6
leaq 0x8(%rsp), %rdx
jmp 0x20d53
leaq 0x1731(%rip), %rsi      # 0x22447
leaq 0xa(%rsp), %rdx
jmp 0x20d53
leaq 0x61aa(%rip), %rsi      # 0x26ece
leaq 0xd(%rsp), %rdx
jmp 0x20d53
leaq 0x174b(%rip), %rsi      # 0x2247d
leaq 0x9(%rsp), %rdx
jmp 0x20d53
leaq 0x619c(%rip), %rsi      # 0x26edc
leaq 0xc(%rsp), %rdx
jmp 0x20d53
leaq 0x2888(%rip), %rsi      # 0x235d6
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/outcome.cpp
// Function: Morat::Side::to_s_short[abi:cxx11]() const
std::string Side::to_s_short() const {
	if(*this == NONE)  return "N";
	if(*this == P1)    return "W";
	if(*this == P2)    return "B";
	return "U";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movzbl (%rsi), %eax
movq %rdi, %rbx
cmpl $0x2, %eax
je 0x20d99
cmpl $0x1, %eax
je 0x20d8b
testl %eax, %eax
jne 0x20da7
leaq 0x613c(%rip), %rsi      # 0x26ec0
leaq 0xf(%rsp), %rdx
jmp 0x20db3
leaq 0x34bb(%rip), %rsi      # 0x2424d
leaq 0xe(%rsp), %rdx
jmp 0x20db3
leaq 0x34af(%rip), %rsi      # 0x2424f
leaq 0xd(%rsp), %rdx
jmp 0x20db3
leaq 0x6114(%rip), %rsi      # 0x26ec2
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/outcome.cpp
// Function: Morat::Outcome::to_s_rel[abi:cxx11](Morat::Side) const
std::string Outcome::to_s_rel(Side to_play) const {
	if(*this == Outcome::DRAW)  return "draw";
	if(*this == Outcome::DRAW2) return "draw by simultaneous win";
	if(*this == +to_play)       return "win";
	if(*this == +~to_play)      return "loss";
	if(*this == -~to_play)      return "win or draw";
	if(*this == -to_play)       return "loss or draw";
	return "unkown";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movzbl (%rsi), %eax
movq %rdi, %rbx
cmpl $0x3, %eax
je 0x20de6
testl %eax, %eax
jne 0x20df4
leaq 0x612b(%rip), %rsi      # 0x26f0a
leaq 0xf(%rsp), %rdx
jmp 0x20e51
leaq 0x60fd(%rip), %rsi      # 0x26eea
leaq 0xe(%rsp), %rdx
jmp 0x20e51
cmpb %dl, %al
jne 0x20e06
leaq 0x6100(%rip), %rsi      # 0x26eff
leaq 0xd(%rsp), %rdx
jmp 0x20e51
movb $0x3, %cl
subb %dl, %cl
cmpb %cl, %al
jne 0x20e1c
leaq 0x52fd(%rip), %rsi      # 0x26112
leaq 0xc(%rsp), %rdx
jmp 0x20e51
movl %eax, %ecx
addb %dl, %cl
jne 0x20e30
leaq 0x60da(%rip), %rsi      # 0x26f03
leaq 0xb(%rsp), %rdx
jmp 0x20e51
addb $-0x3, %dl
cmpb %dl, %al
jne 0x20e45
leaq 0x60d1(%rip), %rsi      # 0x26f0f
leaq 0xa(%rsp), %rdx
jmp 0x20e51
leaq 0x60d0(%rip), %rsi      # 0x26f1c
leaq 0x9(%rsp), %rdx
movq %rbx, %rdi
callq 0x5110
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/string.cpp
// Function: Morat::to_str[abi:cxx11](double, int)
string to_str(double a, int prec){
	double p = pow(10.0, prec);
	a = round(a*p)/p;

	stringstream out;
	out << a;
	return out.str();
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
vmovsd %xmm0, (%rsp)
vcvtsi2sd %esi, %xmm1, %xmm1
vmovsd 0x60a3(%rip), %xmm0     # 0x26f28
movq %rdi, %rbx
callq 0x5630
vmulsd (%rsp), %xmm0, %xmm1
vpbroadcastq 0x6095(%rip), %xmm2 # 0x26f30
leaq 0x8(%rsp), %rdi
vpternlogq $0xf8, 0x608d(%rip){1to2}, %xmm1, %xmm2 # 0x26f38
vaddsd %xmm2, %xmm1, %xmm1
vroundsd $0xb, %xmm1, %xmm1, %xmm1
vdivsd %xmm0, %xmm1, %xmm0
vmovsd %xmm0, (%rsp)
callq 0x5220
leaq 0x18(%rsp), %rdi
vmovsd (%rsp), %xmm0
callq 0x55b0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5590
leaq 0x8(%rsp), %rdi
callq 0x5240
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x5240
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/string.cpp
// Function: Morat::to_str_hex[abi:cxx11](unsigned long)
std::string to_str_hex(uint64_t a) {
	static const char hexlookup[] = "0123456789abcdef";
	char buf[19] = "0x";
	for (int i = 15; i >= 0; i--) {
		buf[i+2] = hexlookup[a & 15];
		a >>= 4;
	}
	buf[18] = '\0';
	return (char *)buf;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
vmovaps 0x6049(%rip), %xmm0     # 0x26f60
movq %rdi, %rbx
vmovaps %xmm0, 0x10(%rsp)
andl $0x0, 0x1f(%rsp)
pushq $0x11
popq %rax
leaq 0x6011(%rip), %rcx      # 0x26f40
movl %eax, %edx
addl $-0x2, %edx
js 0x20f4b
movl %esi, %edx
andl $0xf, %edx
shrq $0x4, %rsi
movb (%rdx,%rcx), %dl
movb %dl, 0x10(%rsp,%rax)
decq %rax
jmp 0x20f2f
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movb $0x0, 0x12(%rsi)
callq 0x5110
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/string.cpp
// Function: Morat::explode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
vecstr explode(const string & str, const string & sep, int count){
	vecstr ret;
	string::size_type old = 0, pos = 0;
	while((pos = str.find(sep, old)) != string::npos && --count != 0){
		ret.push_back(str.substr(old, pos - old));
		old = pos + sep.length();
	}
	ret.push_back(str.substr(old));
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
andq $0x0, 0x10(%rdi)
movl %ecx, %ebp
vxorps %xmm0, %xmm0, %xmm0
decl %ebp
leaq 0x8(%rsp), %r12
movq %rdx, %r15
movq %rsi, %r14
xorl %ebx, %ebx
movq %rdi, (%rsp)
vmovups %xmm0, (%rdi)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5710
cmpq $-0x1, %rax
je 0x21083
subl $0x1, %ebp
jb 0x21083
movq %rax, %rcx
movq %rax, %r13
subq %rbx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5350
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x212b8
movq %r12, %rdi
callq 0x5150
addq 0x8(%r15), %r13
movq %r13, %rbx
jmp 0x21036
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5350
movq (%rsp), %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x212b8
leaq 0x8(%rsp), %rdi
callq 0x5150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x210cc
jmp 0x210c7
movq %rax, %rbx
jmp 0x210d9
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x5150
movq (%rsp), %rdi
callq 0x8e84
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/string.cpp
// Function: Morat::implode(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>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string implode(const vecstr & vec, const string & sep){
	string ret;
	if(vec.size() == 0)
		return ret;
	ret += vec[0];
	for(unsigned int i = 1; i < vec.size(); i++){
		ret += sep;
		ret += vec[i];
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x10(%rdi), %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r15)
je 0x21155
movq %rbx, %rdi
movq %rdx, %r14
callq 0x5700
pushq $0x1
popq %r12
movq 0x8(%r15), %rax
movl %r12d, %r12d
subq (%r15), %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x21155
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5700
movq %r12, %rsi
shlq $0x5, %rsi
addq (%r15), %rsi
movq %rbx, %rdi
callq 0x5700
incl %r12d
jmp 0x21120
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x21166
movq %rbx, %rdi
movq %rax, %r14
callq 0x5150
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/string.cpp
// Function: Morat::parse_dict(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
dictstr parse_dict(const std::string & str, const std::string & sep1, const std::string & sep2) {
	dictstr ret;
	auto parts = explode(str, sep1);
	for(auto & p : parts){
		auto kv = explode(p, sep2, 2);
		ret[kv[0]] = (kv.size() == 2 ? kv[1] : "");
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x30(%rdi), %rax
vxorps %xmm0, %xmm0, %xmm0
movq %rcx, %r14
movq %rdi, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
vmovups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
vmovups %xmm0, 0x28(%rdi)
leaq 0x30(%rsp), %rdi
xorl %ecx, %ecx
callq 0x21006
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %rbp
leaq 0x18(%rsp), %r12
leaq 0x48(%rsp), %r13
cmpq %rbp, %r15
je 0x21252
movq %r14, %rdx
movq %r12, %rdi
movq %r15, %rsi
pushq $0x2
popq %rcx
callq 0x21006
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rbx
subq %rsi, %rbx
cmpq $0x40, %rbx
jne 0x2120a
addq $0x20, %rsi
movq %r13, %rdi
callq 0x5490
jmp 0x2121e
leaq 0x16cc(%rip), %rsi      # 0x228dd
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
callq 0x5110
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x2142c
movq %rax, %rdi
movq %r13, %rsi
callq 0x5440
movq %r13, %rdi
callq 0x5150
movq %r12, %rdi
cmpq $0x40, %rbx
callq 0x8e84
addq $0x20, %r15
jmp 0x211d3
leaq 0x30(%rsp), %rdi
callq 0x8e84
movq 0x10(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x212a6
jmp 0x21277
movq %rax, %r14
jmp 0x21292
movq %rax, %r14
jmp 0x2129c
leaq 0x48(%rsp), %rdi
movq %rax, %r14
callq 0x5150
cmpq $0x40, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8e84
leaq 0x30(%rsp), %rdi
callq 0x8e84
movq 0x10(%rsp), %rdi
callq 0xeb22
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/alarm.cpp
// Function: Morat::Alarm::Handler::reset(int)
void Alarm::Handler::reset(int signum){
	Time now;

	double next = 0;
	for(std::vector<Entry>::iterator a = alarms.begin(); a != alarms.end(); ++a){
		double cur = a->timeout - now;
		if(cur <= 0 || signum == SIGUSR1){
			if(!a->called){
				a->fn();
				a->called = true;
			}
		}else{
			if(next == 0 || next > cur)
				next = cur;
		}
	}

	if(next > 0){
		struct itimerval timeout;
		timeout.it_interval.tv_usec = 0;
		timeout.it_interval.tv_sec = 0;
		timeout.it_value.tv_usec = (next - (int)next)*1000000;
		timeout.it_value.tv_sec = next;
		setitimer(ITIMER_REAL, &timeout, NULL);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movl %esi, %ebx
callq 0x5ca0
movq 0x8(%r14), %r15
vxorpd %xmm1, %xmm1, %xmm1
vxorpd %xmm2, %xmm2, %xmm2
addq $0x8, %r15
leaq -0x8(%r15), %rax
cmpq 0x10(%r14), %rax
je 0x21665
cmpl $0xa, %ebx
je 0x2163b
vmovsd 0x28(%rax), %xmm0
vsubsd 0x8(%rsp), %xmm0, %xmm0
vucomisd %xmm0, %xmm1
jae 0x2163b
vcmpeqsd %xmm1, %xmm2, %k1
vminsd %xmm2, %xmm0, %xmm2
vmovsd %xmm0, %xmm2, %xmm2 {%k1}
jmp 0x2165f
cmpb $0x0, -0x4(%r15)
jne 0x2165f
movq %r15, %rdi
vmovapd %xmm2, 0x10(%rsp)
callq 0x1061e
vmovapd 0x10(%rsp), %xmm2
vxorpd %xmm1, %xmm1, %xmm1
movb $0x1, -0x4(%r15)
addq $0x30, %r15
jmp 0x21608
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm0, %xmm2
jbe 0x216a8
vcvttpd2dq %xmm2, %xmm0
vxorpd %xmm1, %xmm1, %xmm1
leaq 0x20(%rsp), %rsi
xorl %edi, %edi
xorl %edx, %edx
vmovapd %xmm1, (%rsi)
vcvtdq2pd %xmm0, %xmm0
vsubsd %xmm0, %xmm2, %xmm0
vmulsd 0x974(%rip), %xmm0, %xmm0 # 0x22008
vunpcklpd %xmm0, %xmm2, %xmm0 # xmm0 = xmm2[0],xmm0[0]
vcvttpd2qq %xmm0, %xmm0
vmovapd %xmm0, 0x10(%rsi)
callq 0x54f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/alarm.cpp
// Function: Morat::Alarm::Handler::add(Morat::Time, std::function<void ()>)
int Alarm::Handler::add(Time timeout, callback_t fn){
	Entry entry(nextid, fn, timeout);
	alarms.push_back(entry);

	nextid = (nextid + 1) & 0x3FFFFFFF; //sets a limit of 2^30 alarms, but keeps them in the positive range

	reset(SIGALRM);

	return entry.id;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl (%rdi), %ebp
leaq 0x40(%rsp), %r14
movq %rdi, %rbx
vmovsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xfc88
vmovsd 0x8(%rsp), %xmm0
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x217da
leaq 0x40(%rsp), %rdi
callq 0x850c
leaq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2180c
movl (%rbx), %eax
incl %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, (%rbx)
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x215e0
leaq 0x18(%rsp), %rdi
movl -0x8(%rdi), %ebx
callq 0x850c
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x21764
leaq 0x18(%rsp), %r14
movq %rax, %rbx
movq %r14, %rdi
callq 0x850c
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/lib/alarm.cpp
// Function: Morat::Alarm::Handler::cancel(int)
bool Alarm::Handler::cancel(int id){
	if(id < 0)
		return false;
	bool found = false;
	for(std::vector<Entry>::iterator a = alarms.begin(); a != alarms.end(); ){
		if(a->id == id){
			a->called = true;
			found = true;
		}
		if(a->called)
			a = alarms.erase(a);
		else
			++a;
	}
	return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x217be
movq 0x8(%rdi), %rax
leaq 0x8(%rdi), %r15
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
movq 0x10(%r14), %rcx
cmpq %rcx, %rax
je 0x217c0
cmpl %ebp, (%rax)
je 0x217ab
testb $0x1, 0x4(%rax)
jne 0x217b1
addq $0x30, %rax
jmp 0x21796
movb $0x1, 0x4(%rax)
movb $0x1, %bl
movq %r15, %rdi
movq %rax, %rsi
callq 0x21838
jmp 0x21792
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/demo/demo.cpp
// Function: run_um(std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>&, std::vector<int, std::allocator<int>> const&)
void
run_um(um& needles, const std::vector<int>& haystack)
{
	for (auto hit = haystack.cbegin(); hit != haystack.cend(); ++hit)
	{
		auto nit = needles.find(*hit);
		
		if (nit != needles.end())
		{
			++(nit->second);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
cmpq 0x8(%rbx), %r15
je 0x1319
movq %r14, %rdi
movq %r15, %rsi
callq 0x183a
testq %rax, %rax
je 0x1313
incl 0xc(%rax)
addq $0x4, %r15
jmp 0x12fa
popq %rbx
popq %r14
popq %r15
retq