LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/RTBBox.cpp
// Function: rt::RTBBox::hit(rt::Ray const&)
double RTBBox::hit(const Ray& r) {
    double ox = r.o.x, oy = r.o.y, oz = r.o.z;
    double dx = r.d.x, dy = r.d.y, dz = r.d.z;
    double x0 = p0.x, y0 = p0.y, z0 = p0.z;
    double x1 = p1.x, y1 = p1.y, z1 = p1.z;
    
    double tx_min, ty_min, tz_min;
    double tx_max, ty_max, tz_max;
    
    double a = 1.0/dx;
    if (a >= 0) {
        tx_min = (x0 - ox) * a;
        tx_max = (x1 - ox) * a;
    } else {
        tx_min = (x1 - ox) * a;
        tx_max = (x0 - ox) * a;
    }
    
    double b = 1.0/dy;
    if (b >= 0) {
        ty_min = (y0 - oy) * b;
        ty_max = (y1 - oy) * b;
    } else {
        ty_min = (y1 - oy) * b;
        ty_max = (y0 - oy) * b;
    }
    
    double c = 1.0/dz;
    if (c >= 0) {
        tz_min = (z0 - oz) * c;
        tz_max = (z1 - oz) * c;
    } else {
        tz_min = (z1 - oz) * c;
        tz_max = (z0 - oz) * c;
    }
    
    double t0, t1;
    if (tx_min > ty_min)
        t0 = tx_min;
    else
        t0 = ty_min;
    if (tz_min > t0)
        t0 = tz_min;
    
    if (tx_max < ty_max)
        t1 = tx_max;
    else
        t1 = ty_max;
    if (tz_max < t1)
        t1 = tz_max;
    
    if (t0 < t1 && t1 > 1e-4) return 1;
    return 0;
}

// Assembly:
movsd (%rsi), %xmm6
movsd 0x40(%rdi), %xmm5
movsd 0x48(%rdi), %xmm9
movsd 0x58(%rdi), %xmm0
movsd 0x60(%rdi), %xmm4
movsd 0x227d(%rip), %xmm1     # 0x7060
movapd %xmm1, %xmm8
divsd 0x18(%rsi), %xmm8
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm8
xorpd %xmm3, %xmm3
cmpnlesd %xmm8, %xmm3
movapd %xmm3, %xmm7
andpd %xmm5, %xmm7
andnpd %xmm0, %xmm3
orpd %xmm7, %xmm3
jb 0x4e17
movapd %xmm5, %xmm0
movsd 0x8(%rsi), %xmm10
movsd 0x50(%rdi), %xmm5
movsd 0x68(%rdi), %xmm7
subsd %xmm6, %xmm0
subsd %xmm6, %xmm3
movapd %xmm1, %xmm11
divsd 0x20(%rsi), %xmm11
ucomisd %xmm2, %xmm11
xorpd %xmm6, %xmm6
cmpnlesd %xmm11, %xmm6
movapd %xmm6, %xmm12
andpd %xmm9, %xmm12
andnpd %xmm4, %xmm6
orpd %xmm12, %xmm6
jb 0x4e63
movapd %xmm9, %xmm4
movsd 0x10(%rsi), %xmm9
mulsd %xmm8, %xmm0
mulsd %xmm8, %xmm3
subsd %xmm10, %xmm4
mulsd %xmm11, %xmm4
subsd %xmm10, %xmm6
movapd %xmm1, %xmm8
divsd 0x28(%rsi), %xmm8
mulsd %xmm11, %xmm6
ucomisd %xmm2, %xmm8
cmpnlesd %xmm8, %xmm2
movapd %xmm2, %xmm10
andpd %xmm7, %xmm10
andnpd %xmm5, %xmm2
orpd %xmm10, %xmm2
jb 0x4eb6
movapd %xmm7, %xmm5
subsd %xmm9, %xmm5
mulsd %xmm8, %xmm5
subsd %xmm9, %xmm2
mulsd %xmm8, %xmm2
maxsd %xmm4, %xmm0
maxsd %xmm0, %xmm2
minsd %xmm6, %xmm3
minsd %xmm3, %xmm5
cmpltsd %xmm5, %xmm2
movsd 0x23c1(%rip), %xmm0     # 0x72a8
cmpltsd %xmm5, %xmm0
andpd %xmm1, %xmm0
andpd %xmm2, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/RTBox.cpp
// Function: rt::RTBox::getNormal(rt::Ray const&, double) const
Vec3d RTBox::getNormal(const Ray& r, const double t) const {
    switch (face) {
        case 0: return Vec3d(-1,0,0);
        case 1: return Vec3d(0,-1,0);
        case 2: return Vec3d(0,0,-1);
        case 3: return Vec3d(1,0,0);
        case 4: return Vec3d(0,1,0);
        case 5: return Vec3d(0,0,1);
    }
    return Vec3d();
}

// Assembly:
movq %rdi, %rax
movl 0x70(%rsi), %ecx
cmpq $0x5, %rcx
ja 0x521c
leaq 0x211b(%rip), %rdx      # 0x72c0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
jmp 0x51e7
xorl %ecx, %ecx
movq %rcx, (%rax)
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
jmp 0x5201
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
jmp 0x5217
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
retq
xorl %ecx, %ecx
movq %rcx, (%rax)
movabsq $-0x4010000000000000, %rdx # imm = 0xBFF0000000000000
movq %rdx, 0x8(%rax)
jmp 0x5217
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x10(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/RTComplexObj.cpp
// Function: rt::RTComplexObj::hit(rt::Ray const&)
double RTComplexObj::hit(const Ray& r) {
    if (!bbox->hit(r)) return 0;
    double tmin = 0;
    for (int i=0; i<size; ++i) {
        double t = indices[i].hit(r);
        if (!t) continue;
        if (t < tmin || !tmin) {
            tmin = t;
            index = i;
        }
    }
    return tmin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
movsd %xmm1, (%rsp)
ucomisd %xmm2, %xmm0
jne 0x5397
jnp 0x53fe
cmpl $0x0, 0x54(%r14)
jle 0x53fe
xorl %r15d, %r15d
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x40(%r14), %rdi
movq (%rdi,%r15), %rax
addq %r15, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x53ca
jnp 0x53eb
movsd (%rsp), %xmm1
ucomisd %xmm2, %xmm1
jne 0x53d7
jnp 0x53e2
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x53eb
movl %r12d, 0x50(%r14)
movsd %xmm0, (%rsp)
incq %r12
movslq 0x54(%r14), %rax
addq $0x88, %r15
cmpq %rax, %r12
jl 0x53ad
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/RTPlane.cpp
// Function: rt::RTPlane::hit(rt::Ray const&)
double RTPlane::hit(const Ray& r) {
    double t = (point - r.o).dot(normal) / (r.d).dot(normal);
    if (t > 1e-4)
        return t;
    else
        return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rdi), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x5e90
addq $0x58, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x5ffa
movapd %xmm0, (%rsp)
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ffa
movapd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x1d2f(%rip), %xmm0     # 0x72a8
cmpltsd %xmm1, %xmm0
andpd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/RTSphere.cpp
// Function: rt::RTSphere::hit(rt::Ray const&)
double RTSphere::hit(const Ray& r) {
	Vec3d dis = pos - r.o;
	double t;
	double eps = 1e-4;
	double b = dis.dot(r.d);
	double det = b*b - dis.dot(dis) + rad*rad;
	if (det < 0) return 0;
	else det = sqrt(det);

    return (t=b-det)>eps ? t : ((t=b+det)>eps ? t : 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rdi), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x5e90
addq $0x18, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5ffa
movapd %xmm0, (%rsp)
movq %r15, %rdi
movq %r15, %rsi
callq 0x5ffa
movapd (%rsp), %xmm3
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
subsd %xmm0, %xmm2
movsd 0x58(%r14), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x5736
ucomisd %xmm0, %xmm1
jb 0x56fd
sqrtsd %xmm1, %xmm1
jmp 0x570f
movapd %xmm1, %xmm0
callq 0x20e0
movapd (%rsp), %xmm3
movapd %xmm0, %xmm1
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
ucomisd 0x1b89(%rip), %xmm0     # 0x72a8
ja 0x5736
addsd %xmm1, %xmm3
movsd 0x1b7b(%rip), %xmm0     # 0x72a8
cmpltsd %xmm3, %xmm0
andpd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Aries-orz[P]Ari-RayTracing/src/RTTriangle.cpp
// Function: rt::RTTriangle::hit(rt::Ray const&)
double RTTriangle::hit(const Ray& r) {
	Vec3d e1 = p1 - p0;
	Vec3d e2 = p2 - p0;
	Vec3d p = (r.d)^(e2);
	double det = e1.dot(p);
	Vec3d tt;
	if (det > 0) tt = r.o - p0;
	else {
		tt = p0 - r.o;
		det = -det;
	}
	if (det < 0.0001f) return 0;
	double u = tt.dot(p);
	if (u < 0.0f || u > det) return 0;
	Vec3d q = tt^e1;
	double v = r.d.dot(q);
	if (v < 0.0f || u+v > det) return 0;
	if (e2.dot(q) <= 0) return 0;
	double t = e2.dot(q);
	double invDet = 1.0f / det;
	t *= invDet;
	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rdi), %rsi
leaq 0x40(%rdi), %r15
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x5e90
addq $0x70, %rbx
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5e90
leaq 0x18(%r14), %rbx
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x5f14
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5ffa
xorpd %xmm1, %xmm1
movapd %xmm0, (%rsp)
ucomisd %xmm1, %xmm0
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x38(%rsp), %r12
movq %r12, %rdi
jbe 0x5956
movq %r14, %rsi
movq %r15, %rdx
callq 0x5e90
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x5f6a
movapd (%rsp), %xmm2
jmp 0x597f
movq %r15, %rsi
movq %r14, %rdx
callq 0x5e90
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x5f6a
movapd 0x178a(%rip), %xmm0     # 0x7100
movapd (%rsp), %xmm2
xorpd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movsd 0x199d(%rip), %xmm1     # 0x7328
ucomisd %xmm2, %xmm1
jbe 0x59a3
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movapd %xmm2, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x5ffa
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x5991
ucomisd (%rsp), %xmm1
ja 0x5991
movsd %xmm1, 0x30(%rsp)
leaq 0x38(%rsp), %r14
leaq 0x10(%rsp), %rsi
leaq 0x80(%rsp), %rdx
movq %r14, %rdi
callq 0x5f14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ffa
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x5991
movsd 0x30(%rsp), %xmm2
addsd %xmm1, %xmm2
ucomisd (%rsp), %xmm2
ja 0x5991
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5ffa
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0x5991
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5ffa
movapd %xmm0, %xmm1
movsd 0x160a(%rip), %xmm0     # 0x7060
divsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
jmp 0x5991
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movsd 0x60(%rsi), %xmm0
movsd 0x40(%rsi), %xmm1
movsd 0x48(%rsi), %xmm4
subsd %xmm4, %xmm0
movsd 0x80(%rsi), %xmm3
movsd 0x50(%rsi), %xmm5
subsd %xmm5, %xmm3
movsd 0x68(%rsi), %xmm2
subsd %xmm5, %xmm2
movsd 0x78(%rsi), %xmm5
subsd %xmm4, %xmm5
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
movsd 0x58(%rsi), %xmm6
subsd %xmm1, %xmm6
mulsd %xmm6, %xmm3
mulsd %xmm5, %xmm6
mulsd %xmm2, %xmm5
subsd %xmm5, %xmm4
movsd 0x70(%rsi), %xmm5
subsd %xmm1, %xmm5
mulsd %xmm5, %xmm2
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm5
subsd %xmm5, %xmm6
leaq 0x8(%rsp), %r15
movsd %xmm4, (%r15)
movsd %xmm2, 0x8(%r15)
movsd %xmm6, 0x10(%r15)
movq %r15, %rdi
callq 0x5f8a
addq $0x18, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x5ffa
xorpd %xmm1, %xmm1
leaq 0x8(%rsp), %rsi
ucomisd %xmm0, %xmm1
jbe 0x5b29
movq %rbx, %rdi
callq 0x5e44
jmp 0x5b39
movsd 0x151f(%rip), %xmm0     # 0x7050
movq %rbx, %rdi
callq 0x5eec
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl %esi, 0x18(%rdi)
jle 0x5c81
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movq (%rdi), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5c51
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
leaq (%rax,%r14,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x5c71
leaq (%rax,%r14,8), %rdi
subq %rsi, %rdx
callq 0x2190
addq $-0x8, 0x8(%rbx)
decl 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x16ba(%rip), %rdi      # 0x7342
xorl %eax, %eax
jmp 0x2040
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
cmpl %esi, 0x18(%rdi)
jle 0x5ca6
movslq %esi, %rax
movq (%rdi), %rcx
movq (%rcx,%rax,8), %rbx
jmp 0x5cb6
leaq 0x16c0(%rip), %rdi      # 0x736d
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2040
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x5cea
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5cde
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x5ccc
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x5cf7
movq %rax, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xc, %edi
callq 0x1070
movq %rax, %rbx
movl (%r15), %eax
movl %eax, (%rbx)
movl $0x0, 0x4(%rbx)
movl (%r14), %eax
movl %eax, 0x8(%rbx)
xorl %r12d, %r12d
movq 0x2c6e(%rip), %r14      # 0x3fd8
leaq 0xca0(%rip), %r15       # 0x2011
movl (%rbx,%r12), %esi
movq %r14, %rdi
callq 0x10c0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
addq $0x4, %r12
cmpq $0xc, %r12
jne 0x1371
movl $0xc, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0x23f4
cmpb $0x72, %al
jne 0x2add
movl 0x8(%r12), %eax
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
movq %rbx, %rdi
callq 0x23f8
movl %eax, %r14d
addl %eax, %r14d
jmp 0x2b13
movq %rbx, %rdi
callq 0x23f4
movl 0x8(%r12), %r15d
cmpb $0x70, %al
jne 0x2b08
addl %r15d, %r15d
movq %rbx, %rdi
callq 0x23f8
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
jmp 0x2b13
movq %rbx, %rdi
callq 0x23f8
movl %eax, %r14d
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x23fc
movb %al, 0x7(%rsp)
movq 0x10(%r12), %rsi
movq 0x18(%r12), %rdx
movq 0x549a(%rip), %rbp      # 0x7fd0
movq %rbp, %rdi
callq 0x2120
movq %rax, %r13
leaq 0x2747(%rip), %rsi      # 0x528f
movl $0xb, %edx
movq %rax, %rdi
callq 0x2120
movl 0x8(%r12), %esi
movq %r13, %rdi
callq 0x2170
movq %rax, %r13
leaq 0x249e(%rip), %r12      # 0x500a
movl $0x8, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq %r13, %rdi
movl %r15d, %esi
callq 0x2170
movq %rax, %r13
leaq 0x253a(%rip), %r15      # 0x50cb
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2120
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2414
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbp, %rdi
callq 0x2120
movq %rax, %r13
movl $0xb, %edx
movq %rax, %rdi
leaq 0x269d(%rip), %rsi      # 0x528f
callq 0x2120
movq %rbx, %rdi
callq 0x23f8
movq %r13, %rdi
movl %eax, %esi
callq 0x2170
movq %rax, %rbx
movl $0x8, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2170
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2120
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movb 0x7(%rsp), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
leaq 0x50f4(%rip), %rax      # 0x7d70
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movaps 0x23ad(%rip), %xmm0     # 0x5040
movups %xmm0, 0x48(%rdi)
movaps 0x23b2(%rip), %xmm0     # 0x5050
movups %xmm0, 0x58(%rdi)
movq %rax, 0x40(%rdi)
xorl %edi, %edi
callq 0x20d0
movl %eax, %edi
popq %rax
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x30, %edi
callq 0x2100
movq %rax, %rbx
cmpl $0x70, %ebp
je 0x2d3a
cmpl $0x72, %ebp
jne 0x2d48
movl 0x50(%r14), %esi
movq %rbx, %rdi
callq 0x24a2
jmp 0x2d54
movl 0x54(%r14), %esi
movq %rbx, %rdi
callq 0x276e
jmp 0x2d54
movl 0x58(%r14), %esi
movq %rbx, %rdi
callq 0x2a06
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2d60
jmp 0x2d60
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x30, %edi
callq 0x2100
movq %rax, %rbx
cmpl $0x70, %ebp
je 0x2da6
cmpl $0x72, %ebp
jne 0x2db4
movl 0x5c(%r14), %esi
movq %rbx, %rdi
callq 0x24a2
jmp 0x2dc0
movl 0x60(%r14), %esi
movq %rbx, %rdi
callq 0x276e
jmp 0x2dc0
movl 0x64(%r14), %esi
movq %rbx, %rdi
callq 0x2a06
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2dcc
jmp 0x2dcc
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %esi
jg 0x2e40
callq 0x2050
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
leal (%rax,%rcx), %esi
incl %esi
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
movl 0x10(%rbx), %ebp
subl 0x8(%rbx), %ebp
callq 0x2050
cltd
idivl %ebp
movslq %edx, %rax
movq 0x8(%rbx), %rcx
movb (%rcx,%rax), %al
xorl %ecx, %ecx
cmpb $0x72, %al
setne %cl
leal (%rcx,%rcx,2), %ecx
addl $0x70, %ecx
cmpb $0x73, %al
movl $0x72, %eax
cmovnel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movq 0x4c29(%rip), %r15      # 0x7fe0
movq 0x4c12(%rip), %r12      # 0x7fd0
leaq 0x1f58(%rip), %r13      # 0x531d
movq (%r15), %rax
movq -0x18(%rax), %rdi
testb $0x5, 0x20(%r15,%rdi)
jne 0x33ea
movl 0x4(%rsp), %eax
cmpl %ebp, %eax
setge %cl
cmpl %ebx, %eax
setle %dl
testb %dl, %cl
jne 0x3491
addq %r15, %rdi
xorl %esi, %esi
callq 0x2160
movl $0x3e8, %esi            # imm = 0x3E8
movq %r15, %rdi
movl $0xa, %edx
callq 0x2090
movl $0x20, %edx
movq %r12, %rdi
leaq 0x1ede(%rip), %rsi      # 0x52f3
callq 0x2120
movq %r12, %rdi
movl %ebp, %esi
callq 0x2170
movq %rax, %r14
movl $0x8, %edx
movq %rax, %rdi
leaq 0x1ede(%rip), %rsi      # 0x5314
callq 0x2120
movq %r14, %rdi
movl %ebx, %esi
callq 0x2170
movq %rax, %r14
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2120
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
callq 0x2080
jmp 0x33c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
cmpl $0x6c, %esi
je 0x3f90
cmpl $0x74, %esi
je 0x3f7b
cmpl $0x77, %esi
jne 0x3fd7
movq 0x4063(%rip), %rdi      # 0x7fd0
leaq 0x13ad(%rip), %rsi      # 0x5321
movl $0x8, %edx
jmp 0x3fa3
movq 0x404e(%rip), %rdi      # 0x7fd0
leaq 0x13b0(%rip), %rsi      # 0x5339
movl $0x4, %edx
jmp 0x3fa3
movq 0x4039(%rip), %rdi      # 0x7fd0
leaq 0x138c(%rip), %rsi      # 0x532a
movl $0xe, %edx
callq 0x2120
movq 0x4021(%rip), %rbx      # 0x7fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
jmp 0x20a0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %rax
leaq 0x10(%rsp), %r15
movq %rax, 0x20(%r15)
vmovups 0x10(%rsi), %ymm0
vmovups %ymm0, (%r15)
movl $0xffffffeb, %r13d      # imm = 0xFFFFFFEB
leaq 0xe(%rsp), %r12
incl %r13d
je 0xd015
movq %r14, %rdi
movq %r15, %rsi
vzeroupper
callq 0xcdca
movl %eax, %ebp
movw %ax, 0xe(%rsp)
andb $-0x3, %bpl
cmpb $-0x4, %bpl
je 0xd015
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xcff3
movzwl 0xe(%rsp), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0xcffe
movq %rbx, %rdi
movq %r12, %rdx
callq 0xea52
movzwl 0xe(%rsp), %esi
movq %r15, %rdi
callq 0xd74e
testb %al, %al
je 0xd05f
cmpb $-0x4, %bpl
jne 0xcfb6
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
jne 0xd04a
movw $0xefe, 0xe(%rsp)       # imm = 0xEFE
cmpq 0x10(%rbx), %rsi
je 0xd03a
movzwl 0xe(%rsp), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0xd04a
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
vzeroupper
callq 0xeb86
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0x20202(%rip), %rdi     # 0x2d268
leaq 0x2017f(%rip), %rsi     # 0x2d1ec
leaq 0x20211(%rip), %rcx     # 0x2d285
movl $0xb9, %edx
callq 0x5200
jmp 0xd082
jmp 0xd082
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd092
callq 0x5310
movq %r14, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/../lib/bits.h
// Function: Morat::HashSet::add(unsigned long)
inline uint64_t mix_bits(uint64_t h){
	h ^= h >> 33;
	h *= 0xff51afd7ed558ccdull;
	h ^= h >> 33;
	h *= 0xc4ceb9fe1a85ec53ull;
	h ^= h >> 33;
	return h;
}

// Assembly:
movq %rsi, %rax
shrq $0x21, %rax
xorq %rsi, %rax
movabsq $-0xae502812aa7333, %rcx # imm = 0xFF51AFD7ED558CCD
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movabsq $-0x3b314601e57a13ad, %rdx # imm = 0xC4CEB9FE1A85EC53
imulq %rax, %rdx
movq %rdx, %rcx
shrq $0x21, %rcx
xorq %rdx, %rcx
movl 0x4(%rdi), %edx
movl 0x8(%rdi), %esi
movl %ecx, %r8d
andl %edx, %r8d
movq 0x10(%rdi), %r9
movl %r8d, %r10d
movq (%r9,%r10,8), %r11
testq %r11, %r11
je 0xe8ed
cmpq %rcx, %r11
jne 0xe8fd
xorl %eax, %eax
jmp 0xe8f8
movq %rcx, (%r9,%r10,8)
incl %esi
movl %esi, 0x8(%rdi)
movb $0x1, %al
xorl %r10d, %r10d
jmp 0xe906
incl %r8d
andl %edx, %r8d
movb $0x1, %r10b
testb %r10b, %r10b
jne 0xe8d8
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint32>::RandomMoveIterator(Morat::Pentago::Board const&, Morat::XORShift_uint32&, int)
RandomMoveIterator(const Board & b, Rand & r, int Unique = -1) : base_board(b), rand(r), moves(NULL), cur(0) {
		moves = new Move[b.moves_avail()];

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x23ea7(%rip), %rax     # 0x31da1
movb (%rax), %al
movb %al, 0x21(%rdi)
leaq 0x23ea0(%rip), %rax     # 0x31da6
movb (%rax), %al
movb %al, 0x22(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x8(%rdi)
vmovups %xmm0, 0x11(%rdi)
leaq 0x23e82(%rip), %rax     # 0x31da2
movb (%rax), %al
movb %al, 0x21(%rdi)
leaq 0x23e79(%rip), %rax     # 0x31da5
movb (%rax), %al
movb %al, 0x22(%rdi)
movw $0xdead, 0x24(%rdi)     # imm = 0xDEAD
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movl $0x0, 0x40(%rdi)
movq %rsi, %rdi
callq 0xe726
movl %eax, %r15d
leal (,%r15,8), %eax
movslq %eax, %r12
leaq (%r12,%r12), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x5030
testl %r15d, %r15d
je 0xdf93
leaq (%rax,%r12,2), %rcx
movq %rax, %rdx
movw $0xefc, (%rdx)          # imm = 0xEFC
addq $0x2, %rdx
cmpq %rcx, %rdx
jne 0xdf85
movq %rax, 0x38(%rbx)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xe0ba
cmpb $0x24, 0x30(%rsp)
jge 0xdfcf
movq 0x38(%rbx), %rax
movslq 0x40(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x40(%rbx)
movzwl 0x30(%rsp), %edx
movw %dx, (%rax,%rcx,2)
movq %r15, %rdi
callq 0xe1b8
jmp 0xdfa7
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xdfde
callq 0x5490
movq %rbx, %rdi
callq 0xe00e
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xe005
callq 0x5490
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint64>::operator++()
RandomMoveIterator & operator ++ (){ //prefix form
		cur--;
		if(cur >= 0){
			choose_rand();
			after = base_board;
			bool move_success = after.move(moves[cur]);
			assert(move_success);
		}
		return *this;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x40(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x40(%rdi)
testl %eax, %eax
jle 0x28451
movq %rbx, %rdi
callq 0x284d2
leaq 0x8(%rbx), %rdi
movq (%rbx), %rax
movq 0x38(%rbx), %rcx
vmovups (%rax), %ymm0
vmovups %ymm0, 0x8(%rbx)
movq 0x20(%rax), %rax
movq %rax, 0x28(%rbx)
movslq 0x40(%rbx), %rax
movzwl (%rcx,%rax,2), %esi
vzeroupper
callq 0xd74e
testb %al, %al
je 0x28456
movq %rbx, %rax
popq %rbx
retq
leaq 0x4e0b(%rip), %rdi      # 0x2d268
leaq 0x4ee0(%rip), %rsi      # 0x2d344
leaq 0x952a(%rip), %rcx      # 0x31995
movl $0x6b, %edx
callq 0x5200
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::MoveIterator::MoveIterator(Morat::Pentago::Board const&, int)
MoveIterator(const Board & b, int Unique = -1) : base_board(b), move(M_SWAP) {
		unique = (Unique == -1 ? base_board.moves_made() <= Board::unique_depth : Unique);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x23cd3(%rip), %rax     # 0x31da1
movb (%rax), %al
movb %al, 0x21(%rdi)
leaq 0x23ccc(%rip), %rax     # 0x31da6
movb (%rax), %al
movb %al, 0x22(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x8(%rdi)
vmovups %xmm0, 0x11(%rdi)
leaq 0x23cae(%rip), %rax     # 0x31da2
movb (%rax), %al
movb %al, 0x21(%rdi)
leaq 0x23ca5(%rip), %rax     # 0x31da5
movb (%rax), %al
movb %al, 0x22(%rdi)
movw $0xdead, 0x24(%rdi)     # imm = 0xDEAD
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
movw $0xeff, 0x30(%rdi)      # imm = 0xEFF
movq %rcx, 0x38(%rdi)
movl $0x0, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
xorl %ecx, %ecx
cmpb $0xb, 0x18(%rsi)
setb %cl
xorl %esi, %esi
testl %edx, %edx
setne %sil
cmpl $-0x1, %edx
cmovnel %esi, %ecx
movb %cl, 0x32(%rdi)
cmpb %al, 0x1a(%r14)
jne 0xe152
movq %r14, %rdi
callq 0xe358
movb %al, 0x1a(%r14)
movb 0x1a(%r14), %al
leaq 0x23c4c(%rip), %rcx     # 0x31da9
cmpb (%rcx), %al
jge 0xe187
cmpb $0x1, 0x32(%rbx)
jne 0xe17d
movq (%rbx), %rdi
callq 0xe726
leaq 0x38(%rbx), %rdi
shll $0x3, %eax
movl %eax, %esi
callq 0xe6a8
movq %rbx, %rdi
callq 0xe1b8
jmp 0xe18d
movw $0x824, 0x30(%rbx)      # imm = 0x824
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xe197
movq %rax, %r14
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xe1a8
callq 0x5490
movq $0x0, 0x48(%rbx)
movq %r14, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::MoveIterator::operator++()
MoveIterator & operator ++ (){ //prefix form
		while(true){
			move.r++;
			if(move.r >= 8){
				move.r = 0;
				do{
					move.l++;
					if(move.l >= 36) //done
						return *this;
				}while(!base_board.valid_move_fast(move));
			}
			after = base_board;
			bool move_success = after.move(move);
			assert(move_success);
			if(unique){
				uint64_t h = after.full_hash();
				if(!hashes.add(h))
					continue;
			}
			break;
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x38(%rdi), %r15
leaq 0x217fe(%rip), %r12     # 0x2f9d0
movb 0x31(%rbx), %al
incb %al
movb %al, 0x31(%rbx)
cmpb $0x8, %al
jl 0xe201
movb $0x0, 0x31(%rbx)
movb 0x30(%rbx), %al
movq (%rbx), %rdx
movl %eax, %ecx
incb %cl
cmpb $0x23, %cl
jg 0xe25d
movsbq %cl, %rsi
movq (%r12,%rsi,8), %rsi
testq %rsi, (%rdx)
jne 0xe1ea
movb %cl, 0x30(%rbx)
movq (%rbx), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%r14)
vmovups (%rax), %ymm0
vmovups %ymm0, (%r14)
movl 0x30(%rbx), %esi
movq %r14, %rdi
vzeroupper
callq 0xd74e
testb %al, %al
je 0xe27e
cmpb $0x1, 0x32(%rbx)
jne 0xe244
movq %r14, %rdi
callq 0xe762
movq %r15, %rdi
movq %rax, %rsi
callq 0xe88e
testb %al, %al
je 0xe24b
movl $0x3, %eax
jmp 0xe252
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %eax
cmpl $0x2, %eax
je 0xe1d2
jmp 0xe26f
incb %al
movzbl %al, %eax
cmpb $0x25, %al
movl $0x24, %ecx
cmovgel %eax, %ecx
movb %cl, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1efe3(%rip), %rdi     # 0x2d268
leaq 0x1f0b8(%rip), %rsi     # 0x2d344
leaq 0x1f0c8(%rip), %rcx     # 0x2d35b
movl $0x31, %edx
callq 0x5200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq 0x23a4a(%rip), %rax     # 0x31da9
movzbl (%rax), %ecx
leaq 0x23a41(%rip), %rsi     # 0x31daa
leaq 0x23a3b(%rip), %rdx     # 0x31dab
vmovd %ecx, %xmm0
vpbroadcastq 0x8(%rdi), %zmm1
vpbroadcastq 0x10(%rdi), %zmm2
vpbroadcastb (%rdx), %xmm3
vpbroadcastb (%rsi), %xmm4
xorl %eax, %eax
leaq 0x2176b(%rip), %r8      # 0x2fb00
vmovdqu64 (%r8,%rax,8), %zmm5
vpandq %zmm1, %zmm5, %zmm6
vpcmpeqq %zmm5, %zmm6, %k1
vpandq %zmm2, %zmm5, %zmm6
vpcmpeqq %zmm5, %zmm6, %k2
vmovdqu8 %xmm3, %xmm5 {%k2} {z}
vmovdqu8 %xmm4, %xmm5 {%k1}
vpor %xmm0, %xmm5, %xmm0
addq $0x8, %rax
cmpq $0x20, %rax
jne 0xe395
vpshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
vpor %xmm1, %xmm0, %xmm0
vpsrld $0x10, %xmm0, %xmm1
vpor %xmm1, %xmm0, %xmm0
vpsrlw $0x8, %xmm0, %xmm1
vpor %xmm1, %xmm0, %xmm0
vmovd %xmm0, %eax
cmpb (%rsi), %al
je 0xe402
cmpb (%rdx), %al
je 0xe402
leaq 0x239b0(%rip), %rdx     # 0x31dac
cmpb (%rdx), %al
jne 0xe406
movl %ecx, %eax
vzeroupper
retq
cmpb $0x24, 0x18(%rdi)
leaq 0x23995(%rip), %rax     # 0x31da6
movzbl %cl, %ecx
movzbl (%rax), %eax
cmovael %ecx, %eax
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::score_calc() const
int16_t score_calc() const {
		int16_t s = 0;
		uint64_t ws = sides[1];
		uint64_t bs = sides[2];

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

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

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

		if(cached_hash)
			return cached_hash;

		Board b(*this);

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

		cached_hash = m;
		return m;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpb $0x7, 0x18(%rdi)
jb 0xe78d
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd860
movq 0x20(%rbx), %rax
testq %rax, %rax
jne 0xe880
movq 0x20(%rbx), %rax
movq %rsp, %r15
movq %rax, 0x20(%r15)
vmovups (%rbx), %ymm0
vmovups %ymm0, (%r15)
movq %r15, %rdi
vzeroupper
callq 0xd860
movq %rax, %r14
movl $0x2d0f, %r12d          # imm = 0x2D0F
bextrq %r12, %rax, %rax
movl %r14d, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
shlq $0x2d, %rcx
orq %rax, %rcx
cmpq %rcx, %r14
movq %rcx, %rax
cmovbq %r14, %rax
shrq $0xf, %rcx
movl %r14d, %edx
andl $0x3fff8000, %edx       # imm = 0x3FFF8000
shlq $0x1e, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovaeq %rdx, %rax
shrq $0xf, %rdx
shlq $0xf, %r14
movabsq $0xfffe00000000000, %r13 # imm = 0xFFFE00000000000
andq %r13, %r14
orq %rdx, %r14
cmpq %r14, %rax
cmovbq %rax, %r14
movq %r15, %rdi
callq 0xe90e
movq %r15, %rdi
callq 0xd860
cmpq %rax, %r14
cmovaeq %rax, %r14
bextrq %r12, %rax, %rcx
movl %eax, %edx
andl $0x7fff, %edx           # imm = 0x7FFF
shlq $0x2d, %rdx
orq %rcx, %rdx
cmpq %rdx, %r14
cmovaeq %rdx, %r14
shrq $0xf, %rdx
movl %eax, %ecx
andl $0x3fff8000, %ecx       # imm = 0x3FFF8000
shlq $0x1e, %rcx
orq %rdx, %rcx
cmpq %rcx, %r14
cmovaeq %rcx, %r14
shrq $0xf, %rcx
shlq $0xf, %rax
andq %r13, %rax
orq %rcx, %rax
cmpq %rax, %r14
cmovbq %r14, %rax
movq %rax, 0x20(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::AgentMCTS()
AgentMCTS::AgentMCTS() : pool(this) {
	nodes = 0;
	runs = 0;
	gclimit = 5;

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

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

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

	win_score = 1;

	instantwin  = 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2b784(%rip), %rax     # 0x3ca28
movq %rax, (%rdi)
leaq 0x20af3(%rip), %rax     # 0x31da1
movb (%rax), %al
movb %al, 0x29(%rdi)
leaq 0x20aec(%rip), %rax     # 0x31da6
movb (%rax), %al
movb %al, 0x2a(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rdi)
vmovups %xmm0, 0x19(%rdi)
leaq 0x20ace(%rip), %rcx     # 0x31da2
movb (%rcx), %cl
movb %cl, 0x29(%rdi)
leaq 0x20ac5(%rip), %rdx     # 0x31da5
movb (%rdx), %dl
movb %dl, 0x2a(%rdi)
movw $0xdead, %si            # imm = 0xDEAD
movw %si, 0x2c(%rdi)
xorl %edi, %edi
movq %rdi, 0x30(%rbx)
leaq 0x2b696(%rip), %r8      # 0x3c990
movq %r8, (%rbx)
vmovups %xmm0, 0x80(%rbx)
vmovups %xmm0, 0x89(%rbx)
movb %cl, 0x99(%rbx)
movb %dl, 0x9a(%rbx)
movw %si, 0x9c(%rbx)
vmovups %xmm0, 0xa0(%rbx)
vmovups %xmm0, 0xaa(%rbx)
movb %al, 0xba(%rbx)
movl $0xfc0efd00, 0xbb(%rbx) # imm = 0xFC0EFD00
movb $0xe, 0xbf(%rbx)
movq %rdi, 0xc0(%rbx)
leaq 0xe8(%rbx), %r14
movq %r14, %rdi
callq 0x13bd2
leaq 0x14a8(%rbx), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13c64
xorl %eax, %eax
movq %rax, 0xc8(%rbx)
movq %rax, 0xd8(%rbx)
movl $0x5, 0xd0(%rbx)
movb %al, 0x48(%rbx)
movb %al, 0x38(%rbx)
movl $0x1, 0x3c(%rbx)
movq %r15, %rdi
movl $0x1, %esi
callq 0x13cf0
movq $0x3e800000, 0x40(%rbx) # imm = 0x3E800000
movl $0x3f800000, 0x4c(%rbx) # imm = 0x3F800000
movb $0x1, %al
movb %al, 0x49(%rbx)
movb %al, 0x50(%rbx)
vbroadcastss 0x1c17d(%rip), %xmm0 # 0x2d540
vmovlps %xmm0, 0x54(%rbx)
movl $0xa, 0x5c(%rbx)
movb %al, 0x60(%rbx)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x64(%rbx)
movb %al, 0x6c(%rbx)
movabsq $0x1000186a0, %rax      # imm = 0x1000186A0
movq %rax, 0x70(%rbx)
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x13e88
jmp 0x11414
movq %rax, %r12
movq %r14, %rdi
callq 0x13eca
jmp 0x11421
movq %rax, %r12
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0x13f14
movq %r12, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::get_pv() const
std::vector<Move> AgentMCTS::get_pv() const {
	vecmove pv;

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

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

	return pv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movb 0x99(%rsi), %bpl
addq $0xa8, %r14
leaq 0x4(%rsp), %r15
movq 0x18(%r14), %rax
cmpq $0x2, %rax
jb 0x12002
cmpw $0x0, 0x6(%rax)
je 0x12002
movzbl %bpl, %edx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1205c
movw %ax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x11f9a
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0x11fa5
movq %rbx, %rdi
movq %r15, %rdx
callq 0xea52
movq 0x18(%r14), %rax
leaq 0x10(%rax), %rcx
cmpq $0x2, %rax
movl $0x0, %r14d
cmovaeq %rcx, %r14
movb 0x4(%rsp), %dl
movb 0x5(%rsp), %sil
cmpq $0x2, %rax
jb 0x11fd6
movzwl 0x6(%rax), %edi
shll $0x5, %edi
addq %rcx, %rdi
jmp 0x11fd8
xorl %edi, %edi
cmpq %rdi, %r14
je 0x11fef
cmpb %dl, 0x14(%r14)
jne 0x11fe9
cmpb %sil, 0x15(%r14)
je 0x11ff2
addq $0x20, %r14
jmp 0x11fc4
xorl %r14d, %r14d
movb $0x3, %al
subb %bpl, %al
movl %eax, %ebp
testq %r14, %r14
jne 0x11f5a
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
jne 0x12034
movw $0xefe, 0x6(%rsp)       # imm = 0xEFE
cmpq 0x10(%rbx), %rsi
je 0x12027
movzwl 0x6(%rsp), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0x12034
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0xeb86
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12044
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x12054
callq 0x5310
movq %r14, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::garbage_collect(Morat::Pentago::Board&, Morat::Pentago::AgentMCTS::Node*)
void AgentMCTS::garbage_collect(Board & board, Node * node){
	Node * child = node->children.begin(),
		 * end = node->children.end();

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdx), %rcx
leaq 0x10(%rcx), %rax
xorl %r13d, %r13d
movl $0x0, %r12d
cmpq $0x2, %rcx
cmovaeq %rax, %r12
jb 0x127b1
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %r13
cmpq %r13, %r12
je 0x128ad
movb 0x19(%r14), %al
movb %al, 0xf(%rsp)
leaq 0xe8(%r15), %rax
movq %rax, 0x20(%rsp)
addq $0x14, %r12
leaq 0x70(%r15), %rax
movq %rax, 0x18(%rsp)
leaq 0xd0(%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x4(%r12), %rax
cmpq $0x2, %rax
jb 0x12898
cmpw $0x0, 0x6(%rax)
je 0x12898
leaq -0x14(%r12), %rbp
movb 0x12(%rbx), %cl
leaq 0x1f599(%rip), %rax     # 0x31da9
movb (%rax), %al
cmpb %al, %cl
jl 0x1283e
movl 0x70(%r15), %edx
cmpq %rdx, -0xc(%r12)
jbe 0x1283e
cmpb 0xf(%rsp), %cl
jne 0x1285b
movb -0x2(%r12), %dl
cmpb 0xf(%rsp), %dl
sete %sil
cmpb %al, %dl
sete %dl
orb %sil, %dl
jne 0x1285b
cmpb %al, %cl
jge 0x12882
cmpb %al, -0x2(%r12)
movq 0x18(%rsp), %rax
cmovlq 0x10(%rsp), %rax
movl (%rax), %eax
cmpq %rax, -0xc(%r12)
jbe 0x12882
movl (%r12), %esi
movq %r14, %rdi
callq 0xd74e
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x12772
movq %r14, %rdi
movq %r12, %rsi
callq 0x1454c
jmp 0x12898
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
callq 0x13f6c
movl %eax, %eax
subq %rax, 0xc8(%r15)
leaq 0x20(%r12), %rax
addq $0xc, %r12
cmpq %r13, %r12
movq %rax, %r12
jne 0x127e7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq