LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::calculateLastDiv()
unsigned int OptimalSolverLN::calculateLastDiv() {
	// The last level

	if (seedNum > 1) {
		int lvPosCount = readLength - seedNum * minLength;
		finalDiv = solveFirstOptimal(lvPosCount, lvPosCount, seedNum - 1);
	}
	else {
		finalDiv = readLength;
	}

#ifdef DEBUG
	cout << "opt_div: " << finalDiv << endl;
#endif

	return finalDiv;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x360(%rdi), %eax
movl 0x364(%rdi), %ecx
cmpl $0x2, %ecx
jl 0x5c62
movl 0x368(%rbx), %edx
imull %ecx, %edx
subl %edx, %eax
decl %ecx
movq %rbx, %rdi
movl %eax, %esi
movl %eax, %edx
callq 0x580c
movl %eax, 0x3e0(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::solveDNA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
unsigned int OptimalSolverLN::solveDNA(string& DNA) {
	fillMatrix(DNA);
	calculateLastDiv();
	processedReads++;
	return calcualteFreq();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x51ea
movq %rbx, %rdi
callq 0x5c34
incl 0x400(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x5c6a
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::backtrack()
void OptimalSolverLN::backtrack() {
	if (seedNum > 1) {
		int seedIdx = seedNum - 1;
		int level0lv = readLength - seedNum * minLength - finalDiv;
		int level0pos = finalDiv + (seedNum - 1) * minLength;
		seeds[seedIdx].start = level0[level0lv][level0pos].start;
		seeds[seedIdx].end = level0[level0lv][level0pos].end;
		seeds[seedIdx].frequency = level0[level0lv][level0pos].frequency;
	
		int opt_div = finalDiv;
	
		for (seedIdx = seedNum - 2; seedIdx >= 0; seedIdx--) {
			seeds[seedIdx].start = level[seedIdx][opt_div].rstart;
			seeds[seedIdx].end = level[seedIdx][opt_div].rend;
			seeds[seedIdx].frequency = level[seedIdx][opt_div].rfreq;
			opt_div = level[seedIdx][opt_div].lend + 1 - seedIdx * minLength;
		}
	}
	else {
		seeds[0].start = level0[readLength - minLength][0].start;
		seeds[0].end = level0[readLength - minLength][0].end;
		seeds[0].frequency = level0[readLength - minLength][0].frequency;
	}
}

// Assembly:
movl 0x360(%rdi), %esi
movl 0x364(%rdi), %ecx
movl 0x368(%rdi), %eax
cmpl $0x2, %ecx
jl 0x5dc1
leal -0x1(%rcx), %r8d
movl %eax, %r9d
imull %ecx, %r9d
movl 0x3e0(%rdi), %edx
addl %edx, %r9d
subl %r9d, %esi
movl %eax, %r9d
imull %r8d, %r9d
addl %edx, %r9d
movslq %esi, %rsi
movq 0x398(%rdi), %r10
movq 0x3c8(%rdi), %r11
movq (%r10,%rsi,8), %rsi
movslq %r9d, %r9
leaq (%r9,%r9,4), %r9
leaq (%r8,%r8,4), %r8
movq (%rsi,%r9,8), %r10
movq %r10, (%r11,%r8,8)
movl 0xc(%rsi,%r9,8), %esi
movl %esi, 0xc(%r11,%r8,8)
addl $-0x2, %ecx
movq 0x380(%rdi), %rsi
movl %ecx, %r8d
imull %eax, %r8d
movl $0x1, %edi
subl %r8d, %edi
leaq (%rcx,%rcx,4), %r8
leaq (%r11,%r8,8), %r8
movq (%rsi,%rcx,8), %r9
movslq %edx, %rdx
leaq (%rdx,%rdx,4), %rdx
movq 0x1c(%r9,%rdx,8), %r10
movq %r10, (%r8)
movl 0x24(%r9,%rdx,8), %r10d
movl %r10d, 0xc(%r8)
movl 0x14(%r9,%rdx,8), %edx
addl %edi, %edx
addl %eax, %edi
addq $-0x28, %r8
addq $-0x1, %rcx
jb 0x5d91
retq
subl %eax, %esi
movslq %esi, %rax
movq 0x398(%rdi), %rcx
movq 0x3c8(%rdi), %rdx
movq (%rcx,%rax,8), %rax
movq (%rax), %rcx
movq %rcx, (%rdx)
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::printSeeds(std::ostream&)
void OptimalSolverLN::printSeeds(ostream& stream) {
	for (int i = 0; i < seedNum; i++) {
		stream << "Seed[" << i << "]: start: " << seeds[i].start;
		stream << " end: " << seeds[i].end;
		stream << " frequency: " << seeds[i].frequency;
		stream << endl;
	}
}

// Assembly:
cmpl $0x0, 0x364(%rdi)
jle 0x5f30
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x66ff(%rip), %rbp      # 0xc54b
xorl %r15d, %r15d
movl $0x5, %edx
movq %rbx, %rdi
leaq 0x64ad(%rip), %rsi      # 0xc30b
callq 0x32e0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3450
movq %rax, %r12
movl $0xa, %edx
movq %rax, %rdi
leaq 0x6491(%rip), %rsi      # 0xc311
callq 0x32e0
movq 0x3c8(%r14), %rax
movl (%rax,%r13), %esi
movq %r12, %rdi
callq 0x31b0
movl $0x6, %edx
movq %rbx, %rdi
leaq 0x6475(%rip), %rsi      # 0xc31c
callq 0x32e0
movq 0x3c8(%r14), %rax
movl 0x4(%rax,%r13), %esi
movq %rbx, %rdi
callq 0x31b0
movl $0xc, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x32e0
movq 0x3c8(%r14), %rax
movl 0xc(%rax,%r13), %esi
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31c0
incq %r15
movslq 0x364(%r14), %rax
addq $0x28, %r13
cmpq %rax, %r15
jl 0x5e4f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::printStats(std::ostream&)
void OptimalSolverLN::printStats(ostream& stream) {
	unsigned long long sumOfTravel = 0;
	stream << "divTravel distribution: ";
	for (int i = 0; i < readLength; i++) {
		stream << divTravel[i] << " ";
		sumOfTravel += divTravel[i] * i;
	}
	stream << endl;

	unsigned long long prefixesPerRead = (readLength + 1 - seedNum * minLength) * (seedNum - 2) + 1;
	unsigned long long totalPrefixes = processedReads * prefixesPerRead;
	stream << "divTravel per prefix: " << (double) sumOfTravel / totalPrefixes << endl;
	stream << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x62b3(%rip), %rsi      # 0xc323
movl $0x18, %edx
movq %rbx, %rdi
callq 0x32e0
cmpl $0x0, 0x360(%r14)
jle 0x6100
movq 0x3e8(%r14), %rax
xorl %r12d, %r12d
leaq 0x656e(%rip), %r15      # 0xc606
xorl %r13d, %r13d
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x31a0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32e0
movq 0x3e8(%r14), %rax
movq (%rax,%r12,8), %rcx
imulq %r12, %rcx
addq %rcx, %r13
incq %r12
movslq 0x360(%r14), %rcx
cmpq %rcx, %r12
jl 0x609b
movq %r13, %xmm0
punpckldq 0x5feb(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5ff3(%rip), %xmm0     # 0xc0e0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
jmp 0x6109
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31c0
movl 0x360(%r14), %eax
movl 0x364(%r14), %ecx
movl 0x368(%r14), %edx
imull %ecx, %edx
negl %edx
addl %edx, %eax
incl %eax
addl $-0x2, %ecx
imull %eax, %ecx
incl %ecx
movslq %ecx, %rax
movl 0x400(%r14), %r14d
imulq %rax, %r14
leaq 0x61d1(%rip), %rsi      # 0xc33c
movl $0x16, %edx
movq %rbx, %rdi
callq 0x32e0
movq %r14, %xmm0
punpckldq 0x5f4b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5f53(%rip), %xmm0     # 0xc0e0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd (%rsp), %xmm0
divsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31c0
// File: /workspace/github_cpp_makefile_star2_O3/patxitron[P]BattleyeRconToolLinux/a3s.cpp
// Function: patxi::a3s::login(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void a3s::login(std::string const& password)
{
	if(!listening_) {
		send_request(password.data(), password.size(), LOGIN);
		listening_ = true;
		receive();
	}
}

// Assembly:
cmpb $0x0, 0x1(%rdi)
je 0x6caf
retq
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
movl $0x1, %ecx
callq 0x6cd4
movb $0x1, 0x1(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x6eb8
// File: /workspace/github_cpp_makefile_star2_O3/Aries-orz[P]Ari-RayTracing/src/Demo.cpp
// Function: main
int main(int argc, char* argv[]) {
    Scene scene;
    generateWorld(scene);
    
    //Make a 2x2 sampling
    int samps = (argc==2 ? atoi(argv[1])/4 : 1);
    //Initialize the camera
    Ray camera(Vec3d(50, 52, 295.6), Vec3d(0, -0.042612, -1).norm());
    
    //Start the ray tracing
    engine::raytracing(&scene, samps, camera, w, h, "result.ppm");
    
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movl %edi, %ebp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x59dc
movq %rbx, %rdi
callq 0x234c
movl $0x1, %ebx
cmpl $0x2, %ebp
jne 0x2e5b
movq 0x8(%r14), %rdi
callq 0x2170
leal 0x3(%rax), %ebx
testl %eax, %eax
cmovnsl %eax, %ebx
sarl $0x2, %ebx
movaps 0x327e(%rip), %xmm0     # 0x60e0
movaps %xmm0, (%rsp)
movabsq $0x407279999999999a, %rax # imm = 0x407279999999999A
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movhps 0x32a9(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
leaq 0xb0(%rsp), %rdi
movaps %xmm0, (%rdi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x10(%rdi)
callq 0x5d8e
leaq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x5c94
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
leaq 0x38(%rsp), %rdx
callq 0x59b4
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x5c94
leaq 0x68(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x5c94
leaq 0x325a(%rip), %r9       # 0x6144
leaq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movl %ebx, %esi
movl $0x400, %ecx            # imm = 0x400
movl $0x300, %r8d            # imm = 0x300
callq 0x3945
leaq 0x18(%rsp), %rdi
callq 0x59e8
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2f22
jmp 0x2f22
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59e8
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Aries-orz[P]Ari-RayTracing/src/ObjParser.cpp
// Function: rt::ObjParser::destroy()
void ObjParser::destroy() {
    if (verticeList)
        delete [] verticeList;
    if (faceList)
        delete [] faceList;
        
    numOfVertices = -1;
    numOfFaces = -1;
    verticeList = NULL;
    faceList = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x40df
callq 0x2140
leaq 0x8(%rbx), %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x40f1
callq 0x2140
movq $-0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Aries-orz[P]Ari-RayTracing/src/ObjParser.cpp
// Function: rt::ObjParser::readFromObj(char const*)
bool ObjParser::readFromObj(const char* filename) {
    FILE* fp = fopen(filename, "r");
    if (fp == NULL) {
        printf("RTError: The file %s doesn't exist.\n", filename);
        return false;
    } else {
        if (parse(fp)) {
            printf("Read from %s successfully.\n", filename);
            printf("Vertex Number = %d\n", numOfVertices);
            printf("Face Number = %d\n", numOfFaces);
            fclose(fp);
            return true;
        } else {
            printf("RTError: Cannot parse %s.\n", filename);
            fclose(fp);
            return false;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2127(%rip), %rsi      # 0x6243
movq %r14, %rdi
callq 0x2130
testq %rax, %rax
je 0x417c
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x41ba
testb %al, %al
je 0x4191
leaq 0x2128(%rip), %rdi      # 0x626a
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
movl (%r15), %esi
leaq 0x2130(%rip), %rdi      # 0x6286
xorl %eax, %eax
callq 0x2040
movl 0x4(%r15), %esi
leaq 0x2132(%rip), %rdi      # 0x629a
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
callq 0x2100
movb $0x1, %bpl
jmp 0x41ac
leaq 0x20c2(%rip), %rdi      # 0x6245
xorl %ebp, %ebp
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
jmp 0x41ac
leaq 0x2114(%rip), %rdi      # 0x62ac
xorl %ebp, %ebp
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
callq 0x2100
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5075
leaq 0x137f(%rip), %rdx      # 0x6388
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
jmp 0x5046
xorps %xmm0, %xmm0
movhps 0x10c8(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
jmp 0x505b
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
jmp 0x5070
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
retq
xorps %xmm0, %xmm0
movhps 0x10a5(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, (%rax)
jmp 0x507b
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x51ef
jnp 0x5256
cmpl $0x0, 0x54(%r14)
jle 0x5256
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 0x5222
jnp 0x5243
movsd (%rsp), %xmm1
ucomisd %xmm2, %xmm1
jne 0x522f
jnp 0x523a
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5243
movl %r12d, 0x50(%r14)
movsd %xmm0, (%rsp)
incq %r12
movslq 0x54(%r14), %rax
addq $0x88, %r15
cmpq %rax, %r12
jl 0x5205
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5cca
addq $0x58, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x5de4
movapd %xmm0, (%rsp)
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5de4
movapd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0xf9f(%rip), %xmm0      # 0x6370
cmpltsd %xmm1, %xmm0
andpd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5cca
addq $0x18, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5de4
movapd %xmm0, (%rsp)
movq %r15, %rdi
movq %r15, %rsi
callq 0x5de4
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 0x558e
ucomisd %xmm0, %xmm1
jb 0x5555
sqrtsd %xmm1, %xmm1
jmp 0x5567
movapd %xmm1, %xmm0
callq 0x20e0
movapd (%rsp), %xmm3
movapd %xmm0, %xmm1
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
ucomisd 0xdf9(%rip), %xmm0      # 0x6370
ja 0x558e
addsd %xmm1, %xmm3
movsd 0xdeb(%rip), %xmm0      # 0x6370
cmpltsd %xmm3, %xmm0
andpd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5cca
addq $0x70, %rbx
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5cca
leaq 0x18(%r14), %rbx
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x5d34
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5de4
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 0x57ae
movq %r14, %rsi
movq %r15, %rdx
callq 0x5cca
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x5d7a
movapd (%rsp), %xmm2
jmp 0x57d7
movq %r15, %rsi
movq %r14, %rdx
callq 0x5cca
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x5d7a
movapd 0xa22(%rip), %xmm0      # 0x61f0
movapd (%rsp), %xmm2
xorpd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movsd 0xc0d(%rip), %xmm1      # 0x63f0
ucomisd %xmm2, %xmm1
jbe 0x57fb
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 0x5de4
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x57e9
ucomisd (%rsp), %xmm1
ja 0x57e9
movsd %xmm1, 0x30(%rsp)
leaq 0x38(%rsp), %r14
leaq 0x10(%rsp), %rsi
leaq 0x80(%rsp), %rdx
movq %r14, %rdi
callq 0x5d34
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5de4
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x57e9
movsd 0x30(%rsp), %xmm2
addsd %xmm1, %xmm2
ucomisd (%rsp), %xmm2
ja 0x57e9
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5de4
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0x57e9
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5de4
movapd %xmm0, %xmm1
movsd 0x842(%rip), %xmm0      # 0x60f0
divsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
jmp 0x57e9
// File: /workspace/github_cpp_makefile_star2_O3/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 0x78(%rsi), %xmm1
movsd 0x40(%rsi), %xmm2
movsd 0x58(%rsi), %xmm0
subsd %xmm2, %xmm0
movsd 0x80(%rsi), %xmm3
movhpd 0x70(%rsi), %xmm3       # xmm3 = xmm3[0],mem[0]
movupd 0x48(%rsi), %xmm4
movupd 0x60(%rsi), %xmm5
subpd %xmm4, %xmm5
subsd %xmm4, %xmm1
shufpd $0x1, %xmm2, %xmm4      # xmm4 = xmm4[1],xmm2[0]
subpd %xmm4, %xmm3
movapd %xmm5, %xmm2
shufpd $0x1, %xmm0, %xmm2      # xmm2 = xmm2[1],xmm0[0]
mulsd %xmm1, %xmm0
unpcklpd %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0]
mulpd %xmm2, %xmm1
movapd %xmm5, %xmm2
mulpd %xmm3, %xmm2
subpd %xmm1, %xmm2
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
mulsd %xmm5, %xmm3
subsd %xmm3, %xmm0
movq %rsp, %r15
movapd %xmm2, (%r15)
movsd %xmm0, 0x10(%r15)
movq %r15, %rdi
callq 0x5d8e
addq $0x18, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x5de4
xorpd %xmm1, %xmm1
movq %rsp, %rsi
ucomisd %xmm0, %xmm1
jbe 0x596f
movq %rbx, %rdi
callq 0x5c94
jmp 0x597f
movsd 0x789(%rip), %xmm0      # 0x6100
movq %rbx, %rdi
callq 0x5d12
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5ace
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movq (%rdi), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5a9a
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rax
leaq (%rax,%r14,8), %rsi
addq $0x8, %rsi
movq 0x8(%rbx), %rdx
cmpq %rdx, %rsi
je 0x5abb
leaq (%rax,%r14,8), %rdi
subq %rsi, %rdx
callq 0x2190
movq 0x8(%rbx), %rdx
addq $-0x8, %rdx
movq %rdx, 0x8(%rbx)
decl 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x935(%rip), %rdi       # 0x640a
xorl %eax, %eax
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5af2
movslq %esi, %rax
movq (%rdi), %rcx
movq (%rcx,%rax,8), %rbx
jmp 0x5b02
leaq 0x93c(%rip), %rdi       # 0x6435
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2040
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x18(%rdi), %eax
testl %eax, %eax
jle 0x5b39
xorl %r14d, %r14d
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x5b2e
movq (%rdi), %rax
callq *0x8(%rax)
movl 0x18(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x5b19
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x5b46
movq %rax, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c27(%rip), %r15      # 0x7fe0
movq 0x4c10(%rip), %r12      # 0x7fd0
leaq 0x1f56(%rip), %r13      # 0x531d
movq (%r15), %rax
movq -0x18(%rax), %rdi
testb $0x5, 0x20(%r15,%rdi)
jne 0x33ec
movl 0x4(%rsp), %eax
cmpl %ebp, %eax
setge %cl
cmpl %ebx, %eax
setle %dl
testb %dl, %cl
jne 0x3493
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 0x1edc(%rip), %rsi      # 0x52f3
callq 0x2120
movq %r12, %rdi
movl %ebp, %esi
callq 0x2170
movq %rax, %r14
movl $0x8, %edx
movq %rax, %rdi
leaq 0x1edc(%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 0x33c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f50
cmpl $0x74, %esi
je 0x3f3b
cmpl $0x77, %esi
jne 0x3f97
movq 0x40a3(%rip), %rdi      # 0x7fd0
leaq 0x13ed(%rip), %rsi      # 0x5321
movl $0x8, %edx
jmp 0x3f63
movq 0x408e(%rip), %rdi      # 0x7fd0
leaq 0x13f0(%rip), %rsi      # 0x5339
movl $0x4, %edx
jmp 0x3f63
movq 0x4079(%rip), %rdi      # 0x7fd0
leaq 0x13cc(%rip), %rsi      # 0x532a
movl $0xe, %edx
callq 0x2120
movq 0x4061(%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_O3/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 %r12
pushq %rbx
subq $0x40, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r15
movl $0xffffffec, %ebp       # imm = 0xFFFFFFEC
leaq 0xe(%rsp), %r12
movq %rsi, %r14
movq %rdi, %rbx
vmovups %xmm0, (%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x20(%r15)
vmovups 0x10(%rsi), %ymm0
vmovups %ymm0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
vzeroupper
callq 0xcd90
movl %eax, %ecx
andl $0xfd, %ecx
movw %ax, 0xe(%rsp)
cmpw $0xfc, %cx
je 0xcfc9
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xcfa9
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0xcfb4
movq %rbx, %rdi
movq %r12, %rdx
callq 0xe98e
movzwl 0xe(%rsp), %esi
movq %r15, %rdi
callq 0xd6ec
testb %al, %al
je 0xd00b
incl %ebp
jne 0xcf73
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
jne 0xcffb
movw $0xefe, 0xe(%rsp)       # imm = 0xEFE
cmpq 0x10(%rbx), %rsi
je 0xcfee
movzwl 0xe(%rsp), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0xcffb
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0xeac2
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20256(%rip), %rdi     # 0x2d268
leaq 0x201d3(%rip), %rsi     # 0x2d1ec
leaq 0x20265(%rip), %rcx     # 0x2d285
movl $0xb9, %edx
callq 0x5200
jmp 0xd02e
jmp 0xd02e
movq (%rbx), %rdi
movq %rax, %r14
testq %rdi, %rdi
je 0xd03e
callq 0x5310
movq %r14, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O3/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
movabsq $-0xae502812aa7333, %rcx # imm = 0xFF51AFD7ED558CCD
movl 0x4(%rdi), %edx
xorq %rsi, %rax
movq 0x10(%rdi), %rsi
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movabsq $-0x3b314601e57a13ad, %rcx # imm = 0xC4CEB9FE1A85EC53
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movl %eax, %ecx
andl %edx, %ecx
movq (%rsi,%rcx,8), %r8
testq %r8, %r8
je 0xe841
cmpq %rax, %r8
je 0xe84b
incl %ecx
andl %edx, %ecx
jmp 0xe82d
movq %rax, (%rsi,%rcx,8)
incl 0x8(%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x23f15(%rip), %rax     # 0x31da2
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, (%rdi)
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
vmovups %xmm0, 0x8(%rdi)
vmovups %xmm0, 0x11(%rdi)
movb (%rax), %al
movb %al, 0x21(%rdi)
leaq 0x23ef3(%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 0xe682
movl %eax, %r15d
leal (,%r15,8), %eax
testl %r15d, %r15d
movq $-0x1, %rdi
movslq %eax, %r12
leaq (%r12,%r12), %rax
cmovnsq %rax, %rdi
callq 0x5030
testl %r15d, %r15d
je 0xdf19
leaq (%rax,%r12,2), %rcx
movq %rax, %rdx
movw $0xefc, (%rdx)          # imm = 0xEFC
addq $0x2, %rdx
cmpq %rcx, %rdx
jne 0xdf0b
movq %rsp, %r15
movq %rax, 0x38(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xe03e
cmpb $0x24, 0x30(%rsp)
jge 0xdf55
movslq 0x40(%rbx), %rcx
movq 0x38(%rbx), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x40(%rbx)
movzwl 0x30(%rsp), %edx
movw %dx, (%rax,%rcx,2)
movq %r15, %rdi
callq 0xe122
jmp 0xdf2d
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xdf64
callq 0x5490
movq %rbx, %rdi
callq 0xdf94
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0xdf8b
callq 0x5490
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x40(%rdi), %eax
movq %rdi, %rbx
leal -0x1(%rax), %ecx
movl %ecx, 0x40(%rdi)
testl %eax, %eax
jle 0x27fff
movq %rbx, %rdi
callq 0x28080
movq (%rbx), %rax
movq 0x38(%rbx), %rcx
leaq 0x8(%rbx), %rdi
vmovups (%rax), %ymm0
vmovups %ymm0, 0x8(%rbx)
movq 0x20(%rax), %rax
movq %rax, 0x28(%rbx)
movslq 0x40(%rbx), %rax
movzwl (%rcx,%rax,2), %esi
vzeroupper
callq 0xd6ec
testb %al, %al
je 0x28004
movq %rbx, %rax
popq %rbx
retq
leaq 0x525d(%rip), %rdi      # 0x2d268
leaq 0x5332(%rip), %rsi      # 0x2d344
leaq 0x997c(%rip), %rcx      # 0x31995
movl $0x6b, %edx
callq 0x5200
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::MoveIterator::MoveIterator(Morat::Pentago::Board const&, int)
MoveIterator(const Board & b, int Unique = -1) : base_board(b), move(M_SWAP) {
		unique = (Unique == -1 ? base_board.moves_made() <= Board::unique_depth : Unique);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x23d59(%rip), %rax     # 0x31da2
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, (%rdi)
movq %rsi, %r14
movq %rdi, %rbx
vmovups %xmm0, 0x8(%rdi)
vmovups %xmm0, 0x11(%rdi)
movb (%rax), %al
movb %al, 0x21(%rdi)
leaq 0x23d39(%rip), %rax     # 0x31da5
movb (%rax), %cl
xorl %eax, %eax
movb %cl, 0x22(%rdi)
movw $0xdead, 0x24(%rdi)     # imm = 0xDEAD
movq %rax, 0x28(%rdi)
movw $0xeff, 0x30(%rdi)      # imm = 0xEFF
movq %rax, 0x38(%rdi)
movl $0x0, 0x40(%rdi)
movq %rax, 0x48(%rdi)
xorl %eax, %eax
cmpb $0xb, 0x18(%rsi)
setb %al
xorl %esi, %esi
testl %edx, %edx
setne %sil
cmpl $-0x1, %edx
cmovnel %esi, %eax
movb %al, 0x32(%rdi)
movb 0x1a(%r14), %al
cmpb %cl, %al
jne 0xe0c0
movq %r14, %rdi
callq 0xe2a8
movb %al, 0x1a(%r14)
leaq 0x23ce2(%rip), %rcx     # 0x31da9
cmpb (%rcx), %al
jge 0xe0f1
cmpb $0x1, 0x32(%rbx)
jne 0xe0e7
movq (%rbx), %rdi
callq 0xe682
shll $0x3, %eax
leaq 0x38(%rbx), %rdi
movl %eax, %esi
callq 0xe608
movq %rbx, %rdi
callq 0xe122
jmp 0xe0f7
movw $0x824, 0x30(%rbx)      # imm = 0x824
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xe101
movq 0x48(%rbx), %rdi
movq %rax, %r14
testq %rdi, %rdi
je 0xe112
callq 0x5490
movq %r14, %rdi
movq $0x0, 0x48(%rbx)
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::MoveIterator::operator++()
MoveIterator & operator ++ (){ //prefix form
		while(true){
			move.r++;
			if(move.r >= 8){
				move.r = 0;
				do{
					move.l++;
					if(move.l >= 36) //done
						return *this;
				}while(!base_board.valid_move_fast(move));
			}
			after = base_board;
			bool move_success = after.move(move);
			assert(move_success);
			if(unique){
				uint64_t h = after.full_hash();
				if(!hashes.add(h))
					continue;
			}
			break;
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2189f(%rip), %r12     # 0x2f9d0
leaq 0x8(%rdi), %r14
leaq 0x38(%rdi), %r15
movq %rdi, %rbx
movb 0x31(%rbx), %cl
incb %cl
movb %cl, 0x31(%rbx)
movq (%rbx), %rax
cmpb $0x8, %cl
jl 0xe16c
movb $0x0, 0x31(%rbx)
movb 0x30(%rbx), %cl
movl %ecx, %edx
incb %dl
cmpb $0x23, %dl
jg 0xe1ae
movsbq %dl, %rsi
movq (%r12,%rsi,8), %rsi
testq %rsi, (%rax)
jne 0xe155
movb %dl, 0x30(%rbx)
movq 0x20(%rax), %rcx
movq %r14, %rdi
movq %rcx, 0x20(%r14)
vmovups (%rax), %ymm0
vmovups %ymm0, (%r14)
movl 0x30(%rbx), %esi
vzeroupper
callq 0xd6ec
testb %al, %al
je 0xe1cf
cmpb $0x1, 0x32(%rbx)
jne 0xe1c0
movq %r14, %rdi
callq 0xe6bc
movq %r15, %rdi
movq %rax, %rsi
callq 0xe7e8
testb %al, %al
je 0xe13c
jmp 0xe1c0
incb %cl
movzbl %cl, %eax
movl $0x24, %ecx
cmpb $0x25, %al
cmovgel %eax, %ecx
movb %cl, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1f092(%rip), %rdi     # 0x2d268
leaq 0x1f167(%rip), %rsi     # 0x2d344
leaq 0x1f177(%rip), %rcx     # 0x2d35b
movl $0x31, %edx
callq 0x5200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23afa(%rip), %rax     # 0x31da9
vpbroadcastq 0x8(%rdi), %zmm1
vpbroadcastq 0x10(%rdi), %zmm2
leaq 0x2183c(%rip), %r8      # 0x2fb00
movzbl (%rax), %ecx
leaq 0x23add(%rip), %rax     # 0x31dab
movb (%rax), %dl
leaq 0x23ad3(%rip), %rax     # 0x31daa
vmovd %ecx, %xmm0
movb (%rax), %sil
vpbroadcastb %edx, %xmm3
xorl %eax, %eax
vpbroadcastb %esi, %xmm4
vmovdqu64 (%r8,%rax,8), %zmm5
addq $0x8, %rax
vpandq %zmm1, %zmm5, %zmm6
vpandq %zmm2, %zmm5, %zmm7
vpcmpeqq %zmm5, %zmm6, %k1
vpcmpeqq %zmm5, %zmm7, %k2
vmovdqu8 %xmm3, %xmm5 {%k2} {z}
vmovdqu8 %xmm4, %xmm5 {%k1}
vpor %xmm0, %xmm5, %xmm0
cmpq $0x20, %rax
jne 0xe2ec
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 %sil, %al
sete %sil
cmpb %dl, %al
sete %dl
orb %sil, %dl
jne 0xe362
leaq 0x23a50(%rip), %rdx     # 0x31dac
cmpb (%rdx), %al
jne 0xe366
movl %ecx, %eax
vzeroupper
retq
leaq 0x23a39(%rip), %rax     # 0x31da6
cmpb $0x24, 0x18(%rdi)
movzbl %cl, %ecx
movzbl (%rax), %eax
cmovael %ecx, %eax
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::score_calc() const
int16_t score_calc() const {
		int16_t s = 0;
		uint64_t ws = sides[1];
		uint64_t bs = sides[2];

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

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

// Assembly:
pushq %rbp
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
leaq 0x21665(%rip), %r8      # 0x2fb00
leaq 0x2164e(%rip), %r9      # 0x2faf0
xorl %esi, %esi
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 0xe4e1
testq %r10, %r10
setne %bl
testq %r11, %r11
sete %r11b
andb %bl, %r11b
cmpb $0x1, %r11b
jne 0xe4eb
popcntq %r10, %r10
subw (%r9,%r10,2), %cx
jmp 0xe4eb
popcntq %r11, %r10
addw (%r9,%r10,2), %cx
incq %rsi
cmpq $0x20, %rsi
jne 0xe4a6
leaq 0x238a7(%rip), %rsi     # 0x31da2
movb 0x19(%rdi), %dl
movl %ecx, %eax
negl %eax
cmpb (%rsi), %dl
cmovnel %ecx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::full_hash() const
uint64_t full_hash() const {
		if(num_moves_ >= fullhash_depth)
			return simple_hash();

		if(cached_hash)
			return cached_hash;

		Board b(*this);

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

		cached_hash = m;
		return m;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpb $0x7, 0x18(%rdi)
movq %rdi, %rbx
jb 0xe6e7
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd800
movq 0x20(%rbx), %rax
testq %rax, %rax
jne 0xe7da
movq 0x20(%rbx), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rax, 0x20(%r15)
vmovups (%rbx), %ymm0
vmovups %ymm0, (%r15)
vzeroupper
callq 0xd800
movq %rax, %r14
movl %r14d, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
movl $0x2d0f, %r12d          # imm = 0x2D0F
movl %r14d, %edx
movabsq $0xfffe00000000000, %r13 # imm = 0xFFFE00000000000
movq %r15, %rdi
bextrq %r12, %rax, %rax
shlq $0x2d, %rcx
orq %rax, %rcx
cmpq %rcx, %r14
movq %rcx, %rax
cmovbq %r14, %rax
andl $0x3fff8000, %edx       # imm = 0x3FFF8000
shrq $0xf, %rcx
shlq $0x1e, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovaeq %rdx, %rax
shlq $0xf, %r14
shrq $0xf, %rdx
andq %r13, %r14
orq %rdx, %r14
cmpq %r14, %rax
cmovbq %rax, %r14
callq 0xe84e
movq %r15, %rdi
callq 0xd800
cmpq %rax, %r14
movl %eax, %edx
cmovaeq %rax, %r14
andl $0x7fff, %edx           # imm = 0x7FFF
bextrq %r12, %rax, %rcx
shlq $0x2d, %rdx
orq %rcx, %rdx
movl %eax, %ecx
cmpq %rdx, %r14
cmovaeq %rdx, %r14
andl $0x3fff8000, %ecx       # imm = 0x3FFF8000
shrq $0xf, %rdx
shlq $0x1e, %rcx
orq %rdx, %rcx
cmpq %rcx, %r14
cmovaeq %rcx, %r14
shlq $0xf, %rax
shrq $0xf, %rcx
andq %r13, %rax
orq %rcx, %rax
cmpq %rax, %r14
cmovbq %r14, %rax
movq %rax, 0x20(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x20bdd(%rip), %rax     # 0x31da2
vxorps %xmm0, %xmm0, %xmm0
leaq 0x20bd5(%rip), %rcx     # 0x31da5
movw $0xdead, %dx            # imm = 0xDEAD
movq %rdi, %rbx
xorl %esi, %esi
leaq 0xe8(%rbx), %r14
vmovups %xmm0, 0x19(%rdi)
vmovups %xmm0, 0x10(%rdi)
movb (%rax), %al
movb %al, 0x29(%rdi)
movb (%rcx), %cl
movb %cl, 0x2a(%rdi)
movw %dx, 0x2c(%rdi)
movq %rsi, 0x30(%rdi)
leaq 0x2b80d(%rip), %rdi     # 0x3ca10
movq %rdi, (%rbx)
vmovups %xmm0, 0x80(%rbx)
vmovups %xmm0, 0x89(%rbx)
movb %al, 0x99(%rbx)
leaq 0x20b83(%rip), %rax     # 0x31da6
movb %cl, 0x9a(%rbx)
movw %dx, 0x9c(%rbx)
vmovups %xmm0, 0xa0(%rbx)
vmovups %xmm0, 0xaa(%rbx)
movb (%rax), %al
movb %al, 0xba(%rbx)
movl $0xfc0efd00, 0xbb(%rbx) # imm = 0xFC0EFD00
movb $0xe, 0xbf(%rbx)
movq %rsi, 0xc0(%rbx)
movq %r14, %rdi
callq 0x13a80
leaq 0x14a8(%rbx), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13b12
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)
movl $0x1, %esi
movq %r15, %rdi
callq 0x13b9e
vbroadcastss 0x1c289(%rip), %xmm0 # 0x2d540
movb $0x1, %al
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq $0x3e800000, 0x40(%rbx) # imm = 0x3E800000
movl $0x3f800000, 0x4c(%rbx) # imm = 0x3F800000
movb %al, 0x49(%rbx)
movb %al, 0x50(%rbx)
vmovlps %xmm0, 0x54(%rbx)
movl $0xa, 0x5c(%rbx)
movb %al, 0x60(%rbx)
movq %rcx, 0x64(%rbx)
movabsq $0x1000186a0, %rcx      # imm = 0x1000186A0
movb %al, 0x6c(%rbx)
movq %rcx, 0x70(%rbx)
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rax, %r12
callq 0x13d36
jmp 0x1131f
movq %rax, %r12
movq %r14, %rdi
callq 0x13d78
jmp 0x1132c
movq %rax, %r12
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0x13dc2
movq %r12, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::get_pv() const
std::vector<Move> AgentMCTS::get_pv() const {
	vecmove pv;

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

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

	return pv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x10(%rdi)
movq %rdi, %rbx
vmovups %xmm0, (%rdi)
movq 0xc0(%rsi), %rax
cmpq $0x2, %rax
jb 0x11ebd
movb 0x99(%rsi), %bpl
leaq 0xc0(%rsi), %r15
addq $0xa8, %rsi
leaq 0x4(%rsp), %r14
cmpw $0x0, 0x6(%rax)
je 0x11ebd
movzbl %bpl, %edx
xorl %ecx, %ecx
callq 0x11f18
movq 0x8(%rbx), %rsi
movw %ax, 0x4(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x11e4a
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0x11e55
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe98e
movq (%r15), %rax
movb 0x4(%rsp), %dl
movb 0x5(%rsp), %dil
movl $0x0, %r15d
leaq 0x10(%rax), %rcx
cmpq $0x2, %rax
cmovaeq %rcx, %r15
addq $0x18, %r15
cmpq $0x2, %rax
jb 0x11e8b
movzwl 0x6(%rax), %r8d
shll $0x5, %r8d
addq %rcx, %r8
jmp 0x11e8e
xorl %r8d, %r8d
leaq -0x18(%r15), %rsi
cmpq %r8, %rsi
je 0x11ebd
cmpb %dl, -0x4(%r15)
jne 0x11ea3
cmpb %dil, -0x3(%r15)
je 0x11ea9
addq $0x20, %r15
jmp 0x11e77
movq (%r15), %rax
movb $0x3, %cl
subb %bpl, %cl
movl %ecx, %ebp
cmpq $0x1, %rax
ja 0x11e1b
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
jne 0x11eef
movw $0xefe, 0x6(%rsp)       # imm = 0xEFE
cmpq 0x10(%rbx), %rsi
je 0x11ee2
movzwl 0x6(%rsp), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0x11eef
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0xeac2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11eff
movq (%rbx), %rdi
movq %rax, %r14
testq %rdi, %rdi
je 0x11f0f
callq 0x5310
movq %r14, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::garbage_collect(Morat::Pentago::Board&, Morat::Pentago::AgentMCTS::Node*)
void AgentMCTS::garbage_collect(Board & board, Node * node){
	Node * child = node->children.begin(),
		 * end = node->children.end();

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rdx), %rcx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movl $0x0, %r12d
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r12
jb 0x12667
movzwl 0x6(%rcx), %ecx
shll $0x5, %ecx
addq %rcx, %rax
movq %rax, %r13
cmpq %r13, %r12
je 0x12760
movb 0x19(%r14), %al
leaq 0xe8(%r15), %rcx
addq $0x14, %r12
leaq 0x70(%r15), %rdx
movq %rcx, 0x20(%rsp)
leaq 0xd0(%r15), %rcx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x4(%r12), %rax
cmpq $0x2, %rax
jb 0x1274b
cmpw $0x0, 0x6(%rax)
je 0x1274b
leaq 0x1f6eb(%rip), %rax     # 0x31da9
movb 0x12(%rbx), %cl
movq -0xc(%r12), %rdx
leaq -0x14(%r12), %rbp
movb (%rax), %al
cmpb %al, %cl
jge 0x126ea
cmpb %al, -0x2(%r12)
movq 0x18(%rsp), %rax
cmovlq 0x10(%rsp), %rax
movl (%rax), %eax
cmpq %rax, %rdx
ja 0x1270e
jmp 0x12735
movl 0x70(%r15), %esi
cmpq %rsi, %rdx
jbe 0x12735
cmpb 0xf(%rsp), %cl
jne 0x1270e
movb -0x2(%r12), %cl
cmpb 0xf(%rsp), %cl
sete %dl
cmpb %al, %cl
sete %al
orb %dl, %al
je 0x12735
movl (%r12), %esi
movq %r14, %rdi
callq 0xd6ec
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x12628
movq %r14, %rdi
movq %r12, %rsi
callq 0x143ac
jmp 0x1274b
movq 0x20(%rsp), %rsi
movq %rbp, %rdi
callq 0x13e1a
movl %eax, %eax
subq %rax, 0xc8(%r15)
leaq 0x20(%r12), %rax
addq $0xc, %r12
cmpq %r13, %r12
movq %rax, %r12
jne 0x1269d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop