LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Aries-orz[P]Ari-RayTracing/src/RTTriangle.cpp
// Function: rt::RTTriangle::getNormal(rt::Ray const&, double) const
Vec3d RTTriangle::getNormal(const Ray& r, const double t) const {
    double a = (p1.y-p0.y) * (p2.z-p0.z) - (p1.z-p0.z) * (p2.y-p0.y);
    double b = (p1.z-p0.z) * (p2.x-p0.x) - (p1.x-p0.x) * (p2.z-p0.z);
    double c = (p1.x-p0.x) * (p2.y-p0.y) - (p1.y-p0.y) * (p2.x-p0.x);
    Vec3d n(a,b,c);
    n.norm();
    return n.dot(r.d) < 0 ? n : n*-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd 0x60(%rax), %xmm0
subsd 0x48(%rax), %xmm0
movsd 0x80(%rax), %xmm2
subsd 0x50(%rax), %xmm2
movsd 0x68(%rax), %xmm1
subsd 0x50(%rax), %xmm1
movsd 0x78(%rax), %xmm3
subsd 0x48(%rax), %xmm3
mulsd %xmm3, %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x68(%rax), %xmm0
subsd 0x50(%rax), %xmm0
movsd 0x70(%rax), %xmm2
subsd 0x40(%rax), %xmm2
movsd 0x58(%rax), %xmm1
subsd 0x40(%rax), %xmm1
movsd 0x80(%rax), %xmm3
subsd 0x50(%rax), %xmm3
mulsd %xmm3, %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x58(%rax), %xmm0
subsd 0x40(%rax), %xmm0
movsd 0x78(%rax), %xmm2
subsd 0x48(%rax), %xmm2
movsd 0x60(%rax), %xmm1
subsd 0x48(%rax), %xmm1
movsd 0x70(%rax), %xmm3
subsd 0x40(%rax), %xmm3
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
leaq -0x50(%rbp), %rdi
callq 0x3540
leaq -0x50(%rbp), %rdi
callq 0xa170
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x50(%rbp), %rdi
callq 0xa1f0
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8b2f
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9ea0
jmp 0x8b44
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movsd 0x24e9(%rip), %xmm0     # 0xb028
callq 0xa000
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: Aries-orz[P]Ari-RayTracing/src/Scene.cpp
// Function: rt::Scene::removeObj(int)
void Scene::removeObj(int index) {
    if (index >= size) {
        printf("RTError: Scene::removeObj is out of range!");
        return;
    }
    delete objects[index];
    objects.erase(objects.begin() + index);
    --size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jl 0x8d0f
leaq 0x26e4(%rip), %rdi      # 0xb3ea
movb $0x0, %al
callq 0x2040
jmp 0x8d7f
movq -0x38(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x8eb0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x8d33
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x38(%rbp), %rdi
callq 0x9010
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x9040
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9080
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8fa0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Aries-orz[P]Ari-RayTracing/src/Scene.cpp
// Function: rt::Scene::getObj(int) const
RTObject* Scene::getObj(int index) const {
    if (index >= size) {
        printf("RTError: Scene::getObj is out of range!");
        return NULL;
    }
    return objects[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x18(%rcx), %eax
jl 0x8de7
leaq 0x263f(%rip), %rdi      # 0xb415
movb $0x0, %al
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x8dfb
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x90c0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Aries-orz[P]Ari-RayTracing/src/Scene.cpp
// Function: rt::Scene::clear()
void Scene::clear() {
    for (int i=0; i<size; ++i)
        delete objects[i];
    objects.clear();
    size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x8e68
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x8eb0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8e5b
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x8e5d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8e2b
movq -0x18(%rbp), %rdi
callq 0x90e0
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_47.cc
// Function: func_rvalue(int&&, int&&)
void func_rvalue(int&& lhs, int&& rhs)
{
	// allocate enough space
	std::allocator<int> alloc;
	int* data = alloc.allocate(3);

	// move into the spaced newly allocated
	alloc.construct(data     , lhs);
	alloc.construct(data + 1 , 0);
	alloc.construct(data + 2 , rhs);

	// print
	for (auto p = data; p != data + 3;  ++p)
		std::cout << *p << "\n";

	// destroy and deallocation
	for (auto p = data + 3; p != data; --p)
		alloc.destroy(p);

	alloc.deallocate(data, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x17b0
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x3, %esi
callq 0x17d0
movq %rax, -0x48(%rbp)
jmp 0x1385
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x11(%rbp), %rdi
callq 0x1830
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
movl $0x0, -0x30(%rbp)
leaq -0x11(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x1850
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
leaq -0x11(%rbp), %rdi
callq 0x1830
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0xc, %rcx
cmpq %rcx, %rax
je 0x1439
movq -0x38(%rbp), %rax
movl (%rax), %esi
movq 0x2be3(%rip), %rdi      # 0x3fd8
callq 0x10f0
movq %rax, -0x58(%rbp)
jmp 0x1400
movq -0x58(%rbp), %rdi
leaq 0xc06(%rip), %rsi       # 0x2011
callq 0x1080
jmp 0x1412
jmp 0x1414
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x13d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x18b0
jmp 0x148d
movq -0x20(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x146a
movq -0x40(%rbp), %rsi
leaq -0x11(%rbp), %rdi
callq 0x1870
movq -0x40(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x40(%rbp)
jmp 0x1445
movq -0x20(%rbp), %rsi
leaq -0x11(%rbp), %rdi
movl $0x3, %edx
callq 0x1880
jmp 0x147e
leaq -0x11(%rbp), %rdi
callq 0x18b0
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/Tool.cpp
// Function: Tool::compareStrength(int, int)
char Tool::compareStrength(int strength1, int strength2)
{
	char outcome;

	//series of conditionals to see what the outcome of the "battle" would be.
	if (strength1 > strength2) {
		outcome = 'w';
	}
	else if (strength1 < strength2) {
		outcome = 'l';
	}
	else {
		outcome = 't';
	}
	return outcome;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x26fc
movb $0x77, -0x11(%rbp)
jmp 0x2710
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x270a
movb $0x6c, -0x11(%rbp)
jmp 0x270e
movb $0x74, -0x11(%rbp)
jmp 0x2710
movb -0x11(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/Scissor.cpp
// Function: Scissor::fight(Tool&)
char Scissor::fight(Tool &toolIn)
{
	// Init variables
	char outcome;
	// Temporary strength values
	int tempScissorStr;
	int tempToolStr;

	// Scissor vs Rock
	if (toolIn.getType() == 'r')
	{
		// Rock is strong vs scissor
		tempScissorStr = strength / 2;
		tempToolStr = toolIn.getStrength() * 2;
	}
	// Scissor vs paper
	else if (toolIn.getType() == 'p')
	{
		// Scissor is strong vs paper
		tempScissorStr = strength * 2;
		tempToolStr = toolIn.getStrength() / 2;
	}
	else
	{
		tempScissorStr = strength;
		tempToolStr = toolIn.getStrength();
	}

	// Run the comparison
	outcome = compareStrength(tempScissorStr,
		tempToolStr);

	cout << this->longType << " strength: " << this->strength << " (temp: " << tempScissorStr << ")" << endl;
	cout << toolIn.getLongType() << " strength: " << toolIn.getStrength() << " (temp: " << tempToolStr << ")"  << endl;

	// Return variable
	return outcome;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26a0
movsbl %al, %eax
cmpl $0x72, %eax
jne 0x2fcb
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26c0
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x3016
movq -0x10(%rbp), %rdi
callq 0x26a0
movsbl %al, %eax
cmpl $0x70, %eax
jne 0x2ffe
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
shll %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26c0
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
jmp 0x3014
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26c0
movl %eax, -0x1c(%rbp)
jmp 0x3016
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x26e0
movq -0x28(%rbp), %rsi
movb %al, -0x11(%rbp)
addq $0x10, %rsi
movq 0x5f99(%rip), %rdi      # 0x8fd0
callq 0x2130
movq %rax, %rdi
leaq 0x321d(%rip), %rsi      # 0x6263
callq 0x2160
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x2fa6(%rip), %rsi      # 0x600a
callq 0x2160
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x3021(%rip), %rsi      # 0x609f
callq 0x2160
movq %rax, %rdi
movq 0x5f33(%rip), %rsi      # 0x8fc0
callq 0x2190
movq -0x10(%rbp), %rdi
callq 0x2720
movq %rax, %rsi
movq 0x5f2b(%rip), %rdi      # 0x8fd0
callq 0x2130
movq %rax, %rdi
leaq 0x31af(%rip), %rsi      # 0x6263
callq 0x2160
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26c0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x2200
movq %rax, %rdi
leaq 0x2f2f(%rip), %rsi      # 0x600a
callq 0x2160
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x2faa(%rip), %rsi      # 0x609f
callq 0x2160
movq %rax, %rdi
movq 0x5ebc(%rip), %rsi      # 0x8fc0
callq 0x2190
movb -0x11(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::RPSGame()
RPSGame::RPSGame()
{
	humanPaperStrength = 100;
	humanRockStrength = 100;
	humanScissorStrength = 100;

	computerPaperStrength = 100;
	computerRockStrength = 100;
	computerScissorStrength = 100;
	std::chrono::seconds sleep(0);
	sleepDuration = sleep;

	srand(time(0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0x5c1d(%rip), %rax      # 0x8d58
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x43a0
movq -0x18(%rbp), %rax
movl $0xf4240, 0x48(%rax)    # imm = 0xF4240
movl $0x1, 0x4c(%rax)
movl $0x64, 0x54(%rax)
movl $0x64, 0x50(%rax)
movl $0x64, 0x58(%rax)
movl $0x64, 0x60(%rax)
movl $0x64, 0x5c(%rax)
movl $0x64, 0x64(%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x20c0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2140
movl %eax, %edi
callq 0x2150
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::buildHumanTool(char)
Tool* RPSGame::buildHumanTool(char toolSymbol)
{
	switch (toolSymbol)
	{
	case 'r':
	{
		return new Rock(humanRockStrength);
	}
	case 'p':
	{
		return new Paper(humanPaperStrength);
	}
	default:
	{
		return new Scissor(humanScissorStrength);
	}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x70, %eax
je 0x32a4
jmp 0x3248
movl -0x28(%rbp), %eax
subl $0x72, %eax
jne 0x32ec
jmp 0x3256
movl $0x30, %edi
callq 0x2170
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movl 0x50(%rax), %esi
callq 0x2840
jmp 0x3278
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3334
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x2180
jmp 0x333e
movl $0x30, %edi
callq 0x2170
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movl 0x54(%rax), %esi
callq 0x2b90
jmp 0x32c6
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3334
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x2180
jmp 0x333e
movl $0x30, %edi
callq 0x2170
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movl 0x58(%rax), %esi
callq 0x2e50
jmp 0x330e
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3334
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x2180
jmp 0x333e
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2210
nopw (%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::buildComputerTool(char)
Tool* RPSGame::buildComputerTool(char toolSymbol)
{
	switch (toolSymbol)
	{
	case 'r':
	{
		return new Rock(computerRockStrength);
	}
	case 'p':
	{
		return new Paper(computerPaperStrength);
	}
	default:
	{
		return new Scissor(computerScissorStrength);
	}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x70, %eax
je 0x33d4
jmp 0x3378
movl -0x28(%rbp), %eax
subl $0x72, %eax
jne 0x341c
jmp 0x3386
movl $0x30, %edi
callq 0x2170
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movl 0x5c(%rax), %esi
callq 0x2840
jmp 0x33a8
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3464
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x2180
jmp 0x346e
movl $0x30, %edi
callq 0x2170
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movl 0x60(%rax), %esi
callq 0x2b90
jmp 0x33f6
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3464
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x2180
jmp 0x346e
movl $0x30, %edi
callq 0x2170
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movl 0x64(%rax), %esi
callq 0x2e50
jmp 0x343e
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3464
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x2180
jmp 0x346e
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2210
nopw (%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::choiceToTool(int)
char RPSGame::choiceToTool(int inputChoice)
{
	switch (inputChoice)
	{
	case 1:
	{
		return 'r';
	}
	case 2:
	{
		return 'p';
	}
	default:
	{
		return 's';
	}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x34a2
jmp 0x3498
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x34a8
jmp 0x34ae
movb $0x72, -0x1(%rbp)
jmp 0x34b2
movb $0x70, -0x1(%rbp)
jmp 0x34b2
movb $0x73, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::nextAIMove(int)
char RPSGame::nextAIMove(int inputRound)
{
	char outputTool;
	if (inputRound < 4) //if current round is less than 4, choose a random tool for the computer and let knowledgeBase increase
	{
		int randNumber;
		randNumber = rand() % (3 - 1 + 1) + 1; //random number between 1 and 3
		outputTool = choiceToTool(randNumber);
		return outputTool;
	}
	else
	{
		int randIndex;
		size_t maxIndex = knowledgeBase.size() - 1;
		randIndex = rand() % (static_cast<int>(maxIndex) - 0 + 1) + 0; //random index in knowledgeBase
		outputTool = knowledgeBase[randIndex];

		//Opposite tool selection
		if (outputTool == 's')
		{
			outputTool = 'r';
		}
		else if (outputTool == 'r')
		{
			outputTool = 'p';
		}
		else //output tool = 'p'
		{
			outputTool = 's';
		}

		return outputTool;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x3508
callq 0x2060
movq -0x30(%rbp), %rdi
movl $0x3, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x3575
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x4420
subq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x2060
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rcx
subl $0x0, %ecx
addl $0x1, %ecx
cltd
idivl %ecx
addl $0x0, %edx
movl %edx, -0x20(%rbp)
addq $0x8, %rdi
movslq -0x20(%rbp), %rsi
callq 0x4440
movb (%rax), %al
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x73, %eax
jne 0x355a
movb $0x72, -0x15(%rbp)
jmp 0x356f
movsbl -0x15(%rbp), %eax
cmpl $0x72, %eax
jne 0x3569
movb $0x70, -0x15(%rbp)
jmp 0x356d
movb $0x73, -0x15(%rbp)
jmp 0x356f
movb -0x15(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::choiceMenu()
int RPSGame::choiceMenu()
{
	int userChoice;

	cout << "Choose an option below: " << endl;
	cout << "1) Rock" << endl;
	cout << "2) Paper" << endl;
	cout << "3) Scissors" << endl;
	cout << "4) Quit " << endl << endl;
	cout << "Enter option (1-4): ";
	cin >> userChoice;
	userChoice = validateBetween(userChoice, 1, 4);
	return userChoice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x5715(%rip), %rdi      # 0x8fd0
leaq 0x27f7(%rip), %rsi      # 0x60b9
callq 0x2160
movq %rax, %rdi
movq 0x56ef(%rip), %rsi      # 0x8fc0
callq 0x2190
movq 0x56f3(%rip), %rdi      # 0x8fd0
leaq 0x27ee(%rip), %rsi      # 0x60d2
callq 0x2160
movq %rax, %rdi
movq 0x56cd(%rip), %rsi      # 0x8fc0
callq 0x2190
movq 0x56d1(%rip), %rdi      # 0x8fd0
leaq 0x27d4(%rip), %rsi      # 0x60da
callq 0x2160
movq %rax, %rdi
movq 0x56ab(%rip), %rsi      # 0x8fc0
callq 0x2190
movq 0x56af(%rip), %rdi      # 0x8fd0
leaq 0x27bb(%rip), %rsi      # 0x60e3
callq 0x2160
movq %rax, %rdi
movq 0x5689(%rip), %rsi      # 0x8fc0
callq 0x2190
movq 0x568d(%rip), %rdi      # 0x8fd0
leaq 0x27a5(%rip), %rsi      # 0x60ef
callq 0x2160
movq %rax, %rdi
movq 0x5667(%rip), %rsi      # 0x8fc0
callq 0x2190
movq %rax, %rdi
movq 0x5658(%rip), %rsi      # 0x8fc0
callq 0x2190
movq 0x565c(%rip), %rdi      # 0x8fd0
leaq 0x277d(%rip), %rsi      # 0x60f8
callq 0x2160
movq 0x5659(%rip), %rdi      # 0x8fe0
leaq -0xc(%rbp), %rsi
callq 0x20d0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x4, %ecx
callq 0x39c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::validateBetween(int, int, int)
int RPSGame::validateBetween(int inputNumber, int validMin, int validMax) {
	while ((cin.fail() || inputNumber < validMin || inputNumber > validMax)) {
		cin.clear();
		cin.ignore(1000, '\n');
		cout << "Please enter a valid integer >= " << validMin << " or <=  " << validMax << " : " << endl;
		cin >> inputNumber;
	}
	return inputNumber;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq 0x5604(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x55fa(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x2030
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0x3a14
movl -0xc(%rbp), %ecx
movb $0x1, %al
cmpl -0x10(%rbp), %ecx
movb %al, -0x15(%rbp)
jl 0x3a14
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
setg %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x3a20
jmp 0x3abd
movq 0x55b9(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x55af(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x21f0
movq 0x559d(%rip), %rdi      # 0x8fe0
movl $0x3e8, %esi            # imm = 0x3E8
movl $0xa, %edx
callq 0x20f0
movq 0x5577(%rip), %rdi      # 0x8fd0
leaq 0x2867(%rip), %rsi      # 0x62c7
callq 0x2160
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x286e(%rip), %rsi      # 0x62e8
callq 0x2160
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x285d(%rip), %rsi      # 0x62f1
callq 0x2160
movq %rax, %rdi
movq 0x551d(%rip), %rsi      # 0x8fc0
callq 0x2190
movq 0x5531(%rip), %rdi      # 0x8fe0
leaq -0xc(%rbp), %rsi
callq 0x20d0
jmp 0x39d5
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::mainMenu()
void RPSGame::mainMenu()
{
	bool runMain = true;
	int mainInput;

	while (runMain)
	{

		screenClear();
		cout << "Welcome to Rock Paper Scissors! " << "Choose an option below: " << endl << endl;
		cout << "1) Start New Game" << endl;
		cout << "2) Tool Settings" << endl;
		cout << "3) Quit" << endl << endl;

		cout << "Enter option (1-3): ";
		cin >> mainInput;
		mainInput = validateBetween(mainInput, 1, 3);

		switch (mainInput)
		{
		case 1: //Start new game
		{
			playGame();
			break;
		}
		case 2:
		{
			toolSettingsMenu();
			screenClear();
			break;
		}
		case 3:
		{
			runMain = false;
			cout << "Goodbye!" << endl;
		}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x3c45
movq -0x18(%rbp), %rdi
callq 0x3880
movq 0x54ce(%rip), %rdi      # 0x8fd0
movq %rdi, -0x28(%rbp)
leaq 0x2600(%rip), %rsi      # 0x610d
callq 0x2160
movq %rax, %rdi
leaq 0x259d(%rip), %rsi      # 0x60b9
callq 0x2160
movq %rax, %rdi
movq 0x5495(%rip), %rsi      # 0x8fc0
movq %rsi, -0x30(%rbp)
callq 0x2190
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x28(%rbp), %rdi
leaq 0x25e3(%rip), %rsi      # 0x612e
callq 0x2160
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x28(%rbp), %rdi
leaq 0x25d9(%rip), %rsi      # 0x6140
callq 0x2160
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x28(%rbp), %rdi
leaq 0x25ce(%rip), %rsi      # 0x6151
callq 0x2160
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq -0x28(%rbp), %rdi
leaq 0x25ae(%rip), %rsi      # 0x6159
callq 0x2160
movq 0x5429(%rip), %rdi      # 0x8fe0
leaq -0x10(%rbp), %rsi
callq 0x20d0
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x39c0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x3bfa
jmp 0x3be6
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x3c06
jmp 0x3bf0
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x3c1a
jmp 0x3c40
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x3c40
movq -0x18(%rbp), %rdi
callq 0x3c50
movq -0x18(%rbp), %rdi
callq 0x3880
jmp 0x3c40
movb $0x0, -0x9(%rbp)
movq 0x53ab(%rip), %rdi      # 0x8fd0
leaq 0x2542(%rip), %rsi      # 0x616e
callq 0x2160
movq %rax, %rdi
movq 0x5385(%rip), %rsi      # 0x8fc0
callq 0x2190
jmp 0x3ae8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/RPSGame.cpp
// Function: RPSGame::printRoundResult(char)
void RPSGame::printRoundResult(char inputResult)
{
	switch (inputResult)
	{
	case 'w':
	{
		cout << "You win!" << endl;
		break;
	}
	case 'l':
	{
		cout << "Computer wins!" << endl;
		break;
	}
	case 't':
	{
		cout << "Tie." << endl;
	}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x6c, %eax
je 0x42a8
jmp 0x4270
movl -0x10(%rbp), %eax
subl $0x74, %eax
je 0x42cc
jmp 0x427a
movl -0x10(%rbp), %eax
subl $0x77, %eax
jne 0x42ee
jmp 0x4284
movq 0x4d45(%rip), %rdi      # 0x8fd0
leaq 0x2063(%rip), %rsi      # 0x62f5
callq 0x2160
movq %rax, %rdi
movq 0x4d1f(%rip), %rsi      # 0x8fc0
callq 0x2190
jmp 0x42ee
movq 0x4d21(%rip), %rdi      # 0x8fd0
leaq 0x2048(%rip), %rsi      # 0x62fe
callq 0x2160
movq %rax, %rdi
movq 0x4cfb(%rip), %rsi      # 0x8fc0
callq 0x2190
jmp 0x42ee
movq 0x4cfd(%rip), %rdi      # 0x8fd0
leaq 0x2033(%rip), %rsi      # 0x630d
callq 0x2160
movq %rax, %rdi
movq 0x4cd7(%rip), %rsi      # 0x8fc0
callq 0x2190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: LifeAlgorithm[P]RockPaperScissors/play_game.cpp
// Function: main
int main()
{
	// Amount of time in seconds final score is displayed before game resets.
	int finalScoreDisplay = 5;

	RPSGame game;
	game.setSleepDuration(finalScoreDisplay);
	game.mainMenu();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl $0x5, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3120
movq -0x88(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x4360
jmp 0x531a
leaq -0x70(%rbp), %rdi
callq 0x3ad0
jmp 0x5325
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31c0
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31c0
movq -0x78(%rbp), %rdi
callq 0x2210
// File: tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::clear()
void clear() {
		sides[0] = 0;
		sides[1] = 0;
		sides[2] = 0;
		num_moves_ = 0;
		to_play_ = Side::P1;
		outcome_ = Outcome::UNDEF;
		cached_score = default_score;
		cached_hash = 0;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
leaq 0x4c8f8(%rip), %rcx     # 0x5b814
movb (%rcx), %cl
movb %cl, 0x19(%rax)
leaq 0x4c8ef(%rip), %rcx     # 0x5b817
movb (%rcx), %cl
movb %cl, 0x1a(%rax)
movw $0xdead, 0x1c(%rax)     # imm = 0xDEAD
movq $0x0, 0x20(%rax)
retq
nopl (%rax)
// File: tewalds[P]morat/pentago/agentab.cpp
// Function: Morat::Pentago::AgentAB::get_pv() const
std::vector<Move> AgentAB::get_pv() const {
	vecmove pv;

	Board b = rootboard;
	int i = 20;
	while (i--) {
		Move m = return_move(b);
		if(m == M_UNKNOWN || m == M_RESIGN)
			break;
		pv.push_back(m);
		bool move_success = b.move(m);
		assert(move_success);
	}

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

	return pv;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x77(%rsp)
callq 0xef40
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
leaq 0x48(%rsp), %rdi
movl $0x28, %edx
callq 0x5380
movl $0x14, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x44(%rsp)
cmpl $0x0, %eax
je 0x13f75
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x13c00
movw %ax, 0x6(%rsp)
jmp 0x13e83
movw 0x6(%rsp), %ax
movw %ax, 0x42(%rsp)
movl $0xfffffffc, 0x30(%rsp) # imm = 0xFFFFFFFC
leaq 0x42(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x15970
movb %al, 0x5(%rsp)
jmp 0x13eaa
movb 0x5(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x4(%rsp)
jne 0x13ee2
jmp 0x13ebb
movl $0xfffffffe, 0x2c(%rsp) # imm = 0xFFFFFFFE
leaq 0x42(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x15970
movb %al, 0x3(%rsp)
jmp 0x13ed8
movb 0x3(%rsp), %al
movb %al, 0x4(%rsp)
jmp 0x13ee2
movb 0x4(%rsp), %al
testb $0x1, %al
jne 0x13eec
jmp 0x13f0e
jmp 0x13f75
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x10af0
jmp 0x13fcc
movq 0x8(%rsp), %rdi
leaq 0x42(%rsp), %rsi
callq 0x15990
jmp 0x13f1f
movw 0x42(%rsp), %ax
movw %ax, 0x28(%rsp)
movzwl 0x28(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0x14c70
movb %al, 0x2(%rsp)
jmp 0x13f3e
movb 0x2(%rsp), %al
andb $0x1, %al
movb %al, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
je 0x13f51
jmp 0x13f70
leaq 0x302d8(%rip), %rdi     # 0x44230
leaq 0x30255(%rip), %rsi     # 0x441b4
movl $0xb9, %edx
leaq 0x302e2(%rip), %rcx     # 0x4424d
callq 0x52d0
jmp 0x13e55
movq 0x8(%rsp), %rdi
callq 0x15a00
cmpq $0x0, %rax
jne 0x13fa9
leaq 0x26(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x14180
jmp 0x13f96
movq 0x8(%rsp), %rdi
leaq 0x26(%rsp), %rsi
callq 0x15a20
jmp 0x13fa7
jmp 0x13fa9
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x13fbf
movq 0x8(%rsp), %rdi
callq 0x10af0
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint32>::RandomMoveIterator(Morat::Pentago::Board const&, Morat::XORShift_uint32&, int)
RandomMoveIterator(const Board & b, Rand & r, int Unique = -1) : base_board(b), rand(r), moves(NULL), cur(0) {
		moves = new Move[b.moves_avail()];

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

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

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0x6, %esi
callq 0x16790
movq 0x20(%rsp), %rax
movq 0xa0(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq $0x0, 0x38(%rax)
movl $0x0, 0x40(%rax)
movq 0xa8(%rsp), %rdi
callq 0x168e0
cltq
movq %rax, 0x28(%rsp)
movl $0x2, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rsp)
cmpq $0x0, %rax
je 0x1543f
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rdx
shlq %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x14180
jmp 0x15427
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0x2, %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x15411
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0xa8(%rsp), %rsi
movl 0x9c(%rsp), %edx
leaq 0x38(%rsp), %rdi
callq 0x15670
leaq 0x38(%rsp), %rdi
callq 0x157e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x154a2
leaq 0x38(%rsp), %rdi
callq 0x15940
jmp 0x154fb
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0x5570
jmp 0x1550d
leaq 0x38(%rsp), %rdi
callq 0x15960
movq 0x20(%rsp), %rsi
movq %rax, %rdx
movq 0x38(%rsi), %rax
movl 0x40(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x40(%rsi)
movslq %ecx, %rcx
movw (%rdx), %dx
movw %dx, (%rax,%rcx,2)
leaq 0x38(%rsp), %rdi
callq 0x15820
jmp 0x154d9
jmp 0x15466
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15940
jmp 0x1550d
movq 0x20(%rsp), %rdi
callq 0x15570
addq $0xb8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint32>::operator++()
RandomMoveIterator & operator ++ (){ //prefix form
		cur--;
		if(cur >= 0){
			choose_rand();
			after = base_board;
			bool move_success = after.move(moves[cur]);
			assert(move_success);
		}
		return *this;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
cmpl $0x0, 0x40(%rax)
jl 0x15605
movq (%rsp), %rdi
callq 0x173c0
movq (%rsp), %rdi
movq (%rdi), %rsi
addq $0x8, %rdi
movl $0x28, %edx
callq 0x5380
movq (%rsp), %rcx
movq %rcx, %rdi
addq $0x8, %rdi
movq 0x38(%rcx), %rax
movslq 0x40(%rcx), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, 0xd(%rsp)
movzwl 0xd(%rsp), %esi
callq 0x14c70
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x155e4
jmp 0x15603
leaq 0x2ec45(%rip), %rdi     # 0x44230
leaq 0x2ed1d(%rip), %rsi     # 0x4430f
movl $0x6b, %edx
leaq 0x2edb0(%rip), %rcx     # 0x443ae
callq 0x52d0
jmp 0x15605
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::MoveIterator::MoveIterator(Morat::Pentago::Board const&, int)
MoveIterator(const Board & b, int Unique = -1) : base_board(b), move(M_SWAP) {
		unique = (Unique == -1 ? base_board.moves_made() <= Board::unique_depth : Unique);

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0x6, %esi
callq 0x16790
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14180
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
movq %rdi, 0x28(%rsp)
callq 0x167d0
cmpl $-0x1, 0x44(%rsp)
jne 0x156f7
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x16800
movl %eax, 0x1c(%rsp)
jmp 0x156e2
movl 0x1c(%rsp), %eax
cmpl $0xa, %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x18(%rsp)
jmp 0x156ff
movl 0x44(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
testl %ecx, %ecx
setne 0x32(%rax)
movq (%rax), %rdi
callq 0x14100
movb %al, 0x17(%rsp)
jmp 0x1571c
movb 0x17(%rsp), %al
movb %al, 0x33(%rsp)
leaq 0x460f0(%rip), %rsi     # 0x5b81b
leaq 0x33(%rsp), %rdi
callq 0x140c0
movb %al, 0x16(%rsp)
jmp 0x1573b
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0x15745
jmp 0x15785
leaq 0x31(%rsp), %rdi
movl $0x24, %esi
movl $0x8, %edx
callq 0x16810
jmp 0x1575b
movq 0x20(%rsp), %rax
movw 0x31(%rsp), %cx
movw %cx, 0x30(%rax)
jmp 0x157cf
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x16900
jmp 0x157d4
movq 0x20(%rsp), %rax
testb $0x1, 0x32(%rax)
je 0x157c1
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x38, %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x168e0
movl %eax, 0x10(%rsp)
jmp 0x157af
movl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0x16830
jmp 0x157bf
jmp 0x157c1
movq 0x20(%rsp), %rdi
callq 0x15820
jmp 0x157cd
jmp 0x157cf
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x57a0
nop
// File: tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::MoveIterator::operator++()
MoveIterator & operator ++ (){ //prefix form
		while(true){
			move.r++;
			if(move.r >= 8){
				move.r = 0;
				do{
					move.l++;
					if(move.l >= 36) //done
						return *this;
				}while(!base_board.valid_move_fast(move));
			}
			after = base_board;
			bool move_success = after.move(move);
			assert(move_success);
			if(unique){
				uint64_t h = after.full_hash();
				if(!hashes.add(h))
					continue;
			}
			break;
		}
		return *this;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movb 0x31(%rax), %cl
addb $0x1, %cl
movb %cl, 0x31(%rax)
movsbl 0x31(%rax), %eax
cmpl $0x8, %eax
jl 0x1588e
movq (%rsp), %rax
movb $0x0, 0x31(%rax)
movq (%rsp), %rax
movb 0x30(%rax), %cl
addb $0x1, %cl
movb %cl, 0x30(%rax)
movsbl 0x30(%rax), %eax
cmpl $0x24, %eax
jl 0x15874
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x15933
jmp 0x15876
movq (%rsp), %rsi
movq (%rsi), %rdi
addq $0x30, %rsi
callq 0x16610
xorb $-0x1, %al
testb $0x1, %al
jne 0x15850
jmp 0x1588e
movq (%rsp), %rdi
movq (%rdi), %rsi
addq $0x8, %rdi
movl $0x28, %edx
callq 0x5380
movq (%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movw 0x30(%rax), %ax
movw %ax, 0x15(%rsp)
movzwl 0x15(%rsp), %esi
callq 0x14c70
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
je 0x158d0
jmp 0x158ef
leaq 0x2e959(%rip), %rdi     # 0x44230
leaq 0x2ea31(%rip), %rsi     # 0x4430f
movl $0x31, %edx
leaq 0x2ea3c(%rip), %rcx     # 0x44326
callq 0x52d0
movq (%rsp), %rax
testb $0x1, 0x32(%rax)
je 0x15928
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x16a20
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
movq 0x8(%rsp), %rsi
callq 0x16b90
testb $0x1, %al
jne 0x15926
jmp 0x15832
jmp 0x15928
jmp 0x1592a
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::won_calc() const
Outcome won_calc() const {
		Outcome wonside = Outcome::DRAW;
		uint64_t ws = sides[1];
		uint64_t bs = sides[2];

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

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x45a41(%rip), %rcx     # 0x5b81b
movb (%rcx), %cl
movb %cl, 0x37(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x20, 0x1c(%rsp)
jge 0x15e6d
movslq 0x1c(%rsp), %rcx
leaq 0x30b43(%rip), %rax     # 0x46950
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
andq 0x10(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x15e3a
leaq 0x37(%rsp), %rdi
leaq 0x459e9(%rip), %rsi     # 0x5b81c
callq 0x15f10
jmp 0x15e5e
movq 0x20(%rsp), %rax
andq 0x10(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x15e5c
leaq 0x37(%rsp), %rdi
leaq 0x459c6(%rip), %rsi     # 0x5b81d
callq 0x15f10
jmp 0x15e5e
jmp 0x15e60
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x15dfa
leaq 0x37(%rsp), %rdi
leaq 0x459a3(%rip), %rsi     # 0x5b81c
callq 0x14ae0
testb $0x1, %al
jne 0x15e99
leaq 0x37(%rsp), %rdi
leaq 0x4598f(%rip), %rsi     # 0x5b81d
callq 0x14ae0
testb $0x1, %al
jne 0x15e99
jmp 0x15ea3
movb 0x37(%rsp), %al
movb %al, 0x47(%rsp)
jmp 0x15efb
leaq 0x37(%rsp), %rdi
leaq 0x4596f(%rip), %rsi     # 0x5b81e
callq 0x14ae0
testb $0x1, %al
jne 0x15eba
jmp 0x15ec9
leaq 0x4595a(%rip), %rax     # 0x5b81b
movb (%rax), %al
movb %al, 0x47(%rsp)
jmp 0x15efb
movq 0x8(%rsp), %rax
movzbl 0x18(%rax), %eax
cmpl $0x24, %eax
jl 0x15ee4
leaq 0x4593d(%rip), %rax     # 0x5b81b
movq %rax, (%rsp)
jmp 0x15ef1
leaq 0x4592d(%rip), %rax     # 0x5b818
movq %rax, (%rsp)
jmp 0x15ef1
movq (%rsp), %rax
movb (%rax), %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::score_calc() const
int16_t score_calc() const {
		int16_t s = 0;
		uint64_t ws = sides[1];
		uint64_t bs = sides[2];

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

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movw $0x0, 0x4e(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
cmpl $0x20, 0x34(%rsp)
jge 0x16320
movslq 0x34(%rsp), %rcx
leaq 0x306d5(%rip), %rax     # 0x46950
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
andq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
andq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x162d8
cmpq $0x0, 0x18(%rsp)
jne 0x162d8
movq 0x20(%rsp), %rax
popcntq %rax, %rax
movslq %eax, %rcx
leaq 0x3067a(%rip), %rax     # 0x46940
movswl (%rax,%rcx,2), %ecx
movswl 0x4e(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x4e(%rsp)
jmp 0x1630e
cmpq $0x0, 0x20(%rsp)
jne 0x1630c
cmpq $0x0, 0x18(%rsp)
je 0x1630c
movq 0x18(%rsp), %rax
popcntq %rax, %rax
movslq %eax, %rcx
leaq 0x30644(%rip), %rax     # 0x46940
movswl (%rax,%rcx,2), %ecx
movswl 0x4e(%rsp), %eax
subl %ecx, %eax
movw %ax, 0x4e(%rsp)
jmp 0x1630e
jmp 0x16310
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x16264
movq 0x10(%rsp), %rdi
addq $0x19, %rdi
leaq 0x454e4(%rip), %rsi     # 0x5b814
callq 0x16360
testb $0x1, %al
jne 0x1633b
jmp 0x1634a
movswl 0x4e(%rsp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
jmp 0x16353
movswl 0x4e(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::full_hash() const
uint64_t full_hash() const {
		if(num_moves_ >= fullhash_depth)
			return simple_hash();

		if(cached_hash)
			return cached_hash;

		Board b(*this);

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

		cached_hash = m;
		return m;
	}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x18(%rax), %eax
cmpl $0x7, %eax
jl 0x16a50
movq 0x8(%rsp), %rdi
callq 0x14ec0
movq %rax, 0x50(%rsp)
jmp 0x16b84
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x16a6f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0x16b84
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x28, %edx
callq 0x5380
movq $-0x1, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x14ec0
movq %rax, %rsi
movq %rsi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16c50
movq 0x18(%rsp), %rdi
callq 0x16c80
movq %rax, %rsi
movq %rsi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16c50
movq 0x18(%rsp), %rdi
callq 0x16c80
movq %rax, %rsi
movq %rsi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16c50
movq 0x18(%rsp), %rdi
callq 0x16c80
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x16c50
leaq 0x20(%rsp), %rdi
callq 0x16cb0
leaq 0x20(%rsp), %rdi
callq 0x14ec0
movq %rax, %rsi
movq %rsi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16c50
movq 0x18(%rsp), %rdi
callq 0x16c80
movq %rax, %rsi
movq %rsi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16c50
movq 0x18(%rsp), %rdi
callq 0x16c80
movq %rax, %rsi
movq %rsi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16c50
movq 0x18(%rsp), %rdi
callq 0x16c80
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x16c50
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint32>::choose_rand()
void choose_rand(){
		// incremental fisher-yates shuffle. Choose a random element that hasn't yet been chosen.
		int j = rand() % (cur+1);
		Move tmp = moves[j];
		moves[j] = moves[cur];
		moves[cur] = tmp;
//		logerr(moves[cur].to_s() + " ");
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rax), %rdi
callq 0x14bc0
movq (%rsp), %rcx
movl 0x40(%rcx), %esi
addl $0x1, %esi
xorl %edx, %edx
divl %esi
movl %edx, 0xc(%rsp)
movq 0x38(%rcx), %rax
movslq 0xc(%rsp), %rdx
movw (%rax,%rdx,2), %ax
movw %ax, 0xa(%rsp)
movq 0x38(%rcx), %rsi
movslq 0x40(%rcx), %rdi
movq 0x38(%rcx), %rax
movslq 0xc(%rsp), %rdx
movw (%rsi,%rdi,2), %si
movw %si, (%rax,%rdx,2)
movq 0x38(%rcx), %rax
movslq 0x40(%rcx), %rcx
movw 0xa(%rsp), %dx
movw %dx, (%rax,%rcx,2)
addq $0x18, %rsp
retq
nop
// File: tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::AgentMCTS()
AgentMCTS::AgentMCTS() : pool(this) {
	nodes = 0;
	runs = 0;
	gclimit = 5;

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

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

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

	win_score = 1;

	instantwin  = 0;

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1ca90
movq 0x18(%rsp), %rdi
leaq 0x40cfc(%rip), %rax     # 0x5a9a0
movq %rax, (%rdi)
subq $-0x80, %rdi
movl $0x6, %esi
callq 0x16790
jmp 0x19cb7
movq 0x18(%rsp), %rdi
addq $0xa8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x1cac0
jmp 0x19ccf
movq 0x18(%rsp), %rdi
addq $0xe8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1cb30
jmp 0x19ce7
movq 0x18(%rsp), %rsi
movq %rsi, %rdi
addq $0x14a8, %rdi           # imm = 0x14A8
movq %rdi, (%rsp)
callq 0x1cbc0
jmp 0x19d01
movq 0x18(%rsp), %rax
movq $0x0, 0xc8(%rax)
movq $0x0, 0xd8(%rax)
movl $0x5, 0xd0(%rax)
movb $0x0, 0x48(%rax)
movb $0x0, 0x38(%rax)
movl $0x1, 0x3c(%rax)
movq %rax, %rdi
addq $0x14a8, %rdi           # imm = 0x14A8
movl 0x3c(%rax), %esi
callq 0x1cc80
jmp 0x19d49
movq 0x18(%rsp), %rax
movq $0x3e800000, 0x40(%rax) # imm = 0x3E800000
vmovss 0x2a7e2(%rip), %xmm0    # 0x44540
vmovss %xmm0, 0x4c(%rax)
movb $0x1, 0x49(%rax)
movb $0x1, 0x50(%rax)
vmovss 0x2a7cd(%rip), %xmm0    # 0x44540
vmovss %xmm0, 0x54(%rax)
vmovss 0x2a7c0(%rip), %xmm0    # 0x44540
vmovss %xmm0, 0x58(%rax)
movl $0xa, 0x5c(%rax)
movb $0x1, 0x60(%rax)
movl $0x1, 0x64(%rax)
movl $0x1, 0x68(%rax)
movb $0x1, 0x6c(%rax)
movl $0x186a0, 0x70(%rax)    # imm = 0x186A0
movl $0x1, 0x74(%rax)
movl $0x0, 0x78(%rax)
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x19e17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x19e0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x19e03
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x1ceb0
movq 0x8(%rsp), %rdi
callq 0x1cf20
movq 0x10(%rsp), %rdi
callq 0x1cfa0
movq 0x18(%rsp), %rdi
callq 0x16d90
movq 0x28(%rsp), %rdi
callq 0x57a0
nopl (%rax,%rax)