LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/PSLc.cpp
// Function: main
int main(int argc, char **argv)
{
	FILE *exe = fopen(argv[0], "rb");
	if (!exe)
		return 1;

	if (!compiled(exe))
	{
		if (argc >= 2)
			compile(exe, argv[1]);
	}
	else
	{
		variable arg;
		for (int i = 0; i < argc; i++)
			arg[i] = argv[i];
		execute(exe, arg);
#if _WIN32
		getch();
#endif
	}

	fclose(exe);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
movq (%rsi), %rdi
leaq 0x1bc86(%rip), %rsi     # 0x2841c
callq 0xc200
testq %rax, %rax
je 0xc817
movq %rax, %rbx
movq %rax, %rdi
callq 0xc653
testb %al, %al
je 0xc81e
movq %rbx, 0x10(%rsp)
movq %rsp, %rdi
callq 0xcc92
testl %ebp, %ebp
jle 0xc7fc
movl %ebp, %ebx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq (%r14,%r15,8), %rbp
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0xccf0
movq %r12, %rdi
movq %rbp, %rsi
callq 0xcd38
movq 0x8(%rsp), %rdi
callq 0xfe30
incq %r15
cmpq %r15, %rbx
jne 0xc7cd
movq %rsp, %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xc696
movq (%rsp), %rdi
callq 0xfe30
jmp 0xc82f
movl $0x1, %eax
jmp 0xc839
cmpl $0x2, %ebp
jl 0xc82f
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xc40c
movq %rbx, %rdi
callq 0xc1b0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc873
jmp 0xc84c
movq %rax, %rbx
jmp 0xc85e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xfe30
movq (%rsp), %rdi
callq 0xfe30
movq %rbx, %rdi
callq 0xc290
jmp 0xc873
jmp 0xc873
movq %rax, %rdi
callq 0xe0af
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/RNG.cpp
// Function: RNG::getInt32()
unsigned long RNG::getInt32()
{
    unsigned long y;
    static unsigned long mag01[2]={0x0UL, MATRIX_A};
    /* mag01[x] = x * MATRIX_A  for x=0,1 */

    if (mti >= N) { /* generate N words at one time */
        int kk;

        for (kk=0;kk<N-M;kk++) {
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
            mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
        }
        for (;kk<N-1;kk++) {
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
            mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
        }
        y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
        mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];

        mti = 0;
    }
  
    y = mt[mti++];

    /* Tempering */
    y ^= (y >> 11);
    y ^= (y << 7) & 0x9d2c5680UL;
    y ^= (y << 15) & 0xefc60000UL;
    y ^= (y >> 18);

    return y;
}

// Assembly:
cmpl $0x270, 0x1380(%rdi)    # imm = 0x270
jl 0x2726
xorl %edx, %edx
movl $0x80000000, %ecx       # imm = 0x80000000
leaq 0x79ce(%rip), %rax      # 0xa030
movl (%rdi,%rdx,8), %esi
andl %ecx, %esi
movl 0x8(%rdi,%rdx,8), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %esi, %r9d
shrl %r9d
andl $0x1, %r8d
movq (%rax,%r8,8), %rsi
xorq 0xc68(%rdi,%rdx,8), %rsi
xorq %r9, %rsi
movq %rsi, (%rdi,%rdx,8)
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq $0xe3, %rsi
jne 0x2662
movl $0xe4, %ecx
movl $0x80000000, %edx       # imm = 0x80000000
movl -0x8(%rdi,%rcx,8), %esi
andl %edx, %esi
movl (%rdi,%rcx,8), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %esi, %r9d
shrl %r9d
andl $0x1, %r8d
movq (%rax,%r8,8), %rsi
xorq -0x720(%rdi,%rcx,8), %rsi
xorq %r9, %rsi
movq %rsi, -0x8(%rdi,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x26ad
movl $0x80000000, %ecx       # imm = 0x80000000
andl 0x1378(%rdi), %ecx
movl (%rdi), %edx
movl %edx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
orl %ecx, %esi
andl $0x1, %edx
movq (%rax,%rdx,8), %rax
xorq 0xc60(%rdi), %rax
shrl %esi
xorq %rsi, %rax
movq %rax, 0x1378(%rdi)
movl $0x0, 0x1380(%rdi)
movslq 0x1380(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x1380(%rdi)
movq (%rdi,%rax,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
movl %ecx, %eax
shll $0x7, %eax
andl $0x9d2c5680, %eax       # imm = 0x9D2C5680
xorq %rcx, %rax
movl %eax, %ecx
shll $0xf, %ecx
andl $0xefc60000, %ecx       # imm = 0xEFC60000
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x12, %rax
xorq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSample.cpp
// Function: usage(char*)
void usage(char *app)
{
	printf(	"Usage: %s [-m] [-t] [-r <relax count=0>] [-M <multiplier=10>] [-N <minMaxThrows=1000>] <method> <radius> <output>\n", app);
	printf(	"	-m		maximize point set after sampling\n");
	printf(	"	-t		use tiled domain\n");
	printf(	"	-r		apply the specified number of relaxations after sampling (requires qvoronoi)\n");
	printf(	"	-M		set multiplier for DartThrowing and BestCandidate samplers\n");
	printf(	"	-N		set minimum number of maximum throws for DartThrowing sampler\n");
	printf(	"	available methods = {\n"
			"		DartThrowing, (uses multiplier and minMaxThrows)\n"
			"		BestCandidate, (uses multiplier)\n"
			"		Boundary, \n"
			"		Pure, \n"
			"		LinearPure, \n"
			"		Penrose, \n"
			"		Uniform" "}\n");

	exit(1);
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x7785(%rip), %rdi      # 0xa078
xorl %eax, %eax
callq 0x2040
leaq 0x78d3(%rip), %rdi      # 0xa1d4
callq 0x2290
leaq 0x78ee(%rip), %rdi      # 0xa1fb
callq 0x2290
leaq 0x78f8(%rip), %rdi      # 0xa211
callq 0x2290
leaq 0x793e(%rip), %rdi      # 0xa263
callq 0x2290
leaq 0x7972(%rip), %rdi      # 0xa2a3
callq 0x2290
leaq 0x79a9(%rip), %rdi      # 0xa2e6
callq 0x2290
movl $0x1, %edi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::PDSampler(float, bool, bool)
PDSampler::PDSampler(float _radius, bool _isTiled, bool usesGrid) :
	m_rng((unsigned long) (timeInSeconds()*1000)),
	radius(_radius),
	isTiled(_isTiled)
{
	if (usesGrid) {
			// grid size is chosen so that 4*radius search only 
			// requires searching adjacent cells, this also
			// determines max points per cell
		m_gridSize = (int) ceil(2./(4.*_radius));
		if (m_gridSize<2) m_gridSize = 2;

		m_gridCellSize = 2.0f/m_gridSize;
		m_grid = new int[m_gridSize*m_gridSize][kMaxPointsPerCell];

		for (int y=0; y<m_gridSize; y++) {
			for (int x=0; x<m_gridSize; x++) {
				for (int k=0; k<kMaxPointsPerCell; k++) {
					m_grid[y*m_gridSize + x][k] = -1;
				}
			}
		}
	} else {
		m_gridSize = 0;
		m_gridCellSize = 0;
		m_grid = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
leaq 0xcbb3(%rip), %rax      # 0xfb48
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
callq 0x28b4
mulsd 0x744f(%rip), %xmm0     # 0xa3f8
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x7443(%rip), %xmm0     # 0xa400
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r15, %rdi
callq 0x24dc
movss 0xc(%rsp), %xmm1
xorl %eax, %eax
movq %rax, 0x13a0(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x1390(%rbx)
movupd %xmm0, 0x13b8(%rbx)
movq %rax, 0x13c8(%rbx)
movss %xmm1, 0x13d0(%rbx)
movb %r14b, 0x13d4(%rbx)
testl %ebp, %ebp
je 0x30cc
leaq 0x1390(%rbx), %r14
leaq 0x13b8(%rbx), %r12
cvtss2sd %xmm1, %xmm1
mulsd 0x73dd(%rip), %xmm1     # 0xa408
movsd 0x73dd(%rip), %xmm0     # 0xa410
divsd %xmm1, %xmm0
callq 0x2060
cvttsd2si %xmm0, %eax
cmpl $0x3, %eax
movl $0x2, %ecx
cmovgel %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movl %ecx, 0x13b0(%rbx)
movss 0x7418(%rip), %xmm1     # 0xa478
divss %xmm0, %xmm1
movss %xmm1, 0x13b4(%rbx)
imull %ecx, %ecx
shlq $0x2, %rcx
leaq (%rcx,%rcx,8), %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x13a8(%rbx)
movslq 0x13b0(%rbx), %r14
testq %r14, %r14
jle 0x30d4
movl 0x13b0(%rbx), %r12d
movq %r12, %rax
shlq $0x2, %rax
leaq (%rax,%rax,8), %rbx
xorl %ebp, %ebp
testl %r12d, %r12d
jle 0x30c2
movl %ebp, %eax
leaq (%rax,%rax,8), %rax
leaq (%r15,%rax,4), %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x20c0
addl %r12d, %ebp
decq %r14
jne 0x30a6
jmp 0x30d4
movupd %xmm0, 0x13a8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0x30fc
movq 0x13c8(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2364
movq %r15, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::getTiled(Vec2)
Vec2 PDSampler::getTiled(Vec2 v)
{
	float x = v.x, y = v.y;

	if (isTiled) {
		if (x<-1) x += 2;
		else if (x>1) x -= 2;

		if (y<-1) y += 2;
		else if (y>1) y -= 2;
	}

	return Vec2(x,y);
}

// Assembly:
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
cmpb $0x1, 0x13d4(%rdi)
jne 0x31e0
movss 0x72e0(%rip), %xmm2     # 0xa47c
ucomiss %xmm0, %xmm2
jbe 0x31ab
movss 0x72cf(%rip), %xmm3     # 0xa478
jmp 0x31bc
ucomiss 0x72ce(%rip), %xmm0     # 0xa480
jbe 0x31c0
movss 0x72c8(%rip), %xmm3     # 0xa484
addss %xmm3, %xmm0
ucomiss %xmm1, %xmm2
jbe 0x31cf
addss 0x72ab(%rip), %xmm1     # 0xa478
jmp 0x31e0
ucomiss 0x72aa(%rip), %xmm1     # 0xa480
jbe 0x31e0
addss 0x72a4(%rip), %xmm1     # 0xa484
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
retq
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::getGridXY(Vec2&, int*, int*)
void PDSampler::getGridXY(Vec2 &v, int *gx_out, int *gy_out)
{
	int gx = *gx_out = (int) floor(.5*(v.x + 1)*m_gridSize);
	int gy = *gy_out = (int) floor(.5*(v.y + 1)*m_gridSize);
	if (gx<0 || gx>=m_gridSize || gy<0 || gy>=m_gridSize) {
		printf("Internal error, point outside grid was generated, ignoring.\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movss (%rsi), %xmm0
addss 0x727c(%rip), %xmm0     # 0xa480
cvtss2sd %xmm0, %xmm1
mulsd 0x6e40(%rip), %xmm1     # 0xa050
xorps %xmm0, %xmm0
cvtsi2sdl 0x13b0(%rdi), %xmm0
mulsd %xmm1, %xmm0
callq 0x22f0
cvttsd2si %xmm0, %ebp
movl %ebp, (%r15)
movss 0x724d(%rip), %xmm0     # 0xa480
addss 0x4(%r12), %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
mulsd 0x6e07(%rip), %xmm1     # 0xa050
xorps %xmm0, %xmm0
cvtsi2sdl 0x13b0(%rbx), %xmm0
mulsd %xmm1, %xmm0
callq 0x22f0
cvttsd2si %xmm0, %eax
movl %eax, (%r14)
testl %ebp, %ebp
js 0x3283
movl 0x13b0(%rbx), %ecx
cmpl %ebp, %ecx
jle 0x3283
testl %eax, %eax
js 0x3283
cmpl %eax, %ecx
jle 0x3283
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x91ca(%rip), %rdi      # 0xc454
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::addPoint(Vec2)
void PDSampler::addPoint(Vec2 pt)
{
	int i, gx, gy, *cell;

	points.push_back(pt);

	if (m_grid) {
		getGridXY(pt, &gx, &gy);
		cell = m_grid[gy*m_gridSize + gx];
		for (i=0; i<kMaxPointsPerCell; i++) {
			if (cell[i]==-1) {
				cell[i] = (int) points.size()-1;
				break;
			}
		}
		if (i==kMaxPointsPerCell) {
			printf("Internal error, overflowed max points per grid cell. Exiting.\n");
			exit(1);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movlps %xmm0, (%rsp)
movq 0x13c0(%rdi), %rsi
cmpq 0x13c8(%rdi), %rsi
je 0x32c9
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x13c0(%rbx)
jmp 0x32d8
leaq 0x13b8(%rbx), %rdi
movq %rsp, %rdx
callq 0x6a38
cmpq $0x0, 0x13a8(%rbx)
je 0x3368
movq %rsp, %rsi
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x31e4
movslq (%r15), %rax
movslq 0x13b0(%rbx), %rcx
imulq %rax, %rcx
movslq (%r14), %rax
addq %rcx, %rax
leaq (%rax,%rax,8), %rax
shlq $0x2, %rax
addq 0x13a8(%rbx), %rax
xorl %ecx, %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x334b
incq %rcx
cmpq $0x9, %rcx
jne 0x3326
leaq 0x9154(%rip), %rdi      # 0xc490
callq 0x2290
movl $0x1, %edi
callq 0x2200
movq 0x13c0(%rbx), %rdx
subq 0x13b8(%rbx), %rdx
shrq $0x3, %rdx
decl %edx
movl %edx, (%rax,%rcx,4)
cmpq $0x9, %rcx
je 0x3335
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::findNeighbors(Vec2&, float)
int PDSampler::findNeighbors(Vec2 &pt, float distance)
{
	if (!m_grid) {
		printf("Internal error, sampler cannot search without grid.\n");
		exit(1);
	}

	float distanceSqrd = distance*distance;
	int i, j, k, gx, gy, N = (int) ceil(distance/m_gridCellSize);
	if (N>(m_gridSize>>1)) N = m_gridSize>>1;
	
	m_neighbors.clear();
	getGridXY(pt, &gx, &gy);
	for (j=-N; j<=N; j++) {
		for (i=-N; i<=N; i++) {
			int cx = (gx+i+m_gridSize)%m_gridSize;
			int cy = (gy+j+m_gridSize)%m_gridSize;
			int *cell = m_grid[cy*m_gridSize + cx];

			for (k=0; k<kMaxPointsPerCell; k++) {
				if (cell[k]==-1) {
					break;
				} else {
					if (getDistanceSquared(pt, points[cell[k]])<distanceSqrd)
						m_neighbors.push_back(cell[k]);
				}
			}
		}
	}

	return (int) m_neighbors.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x13a8(%rdi)
je 0x3514
movq %rsi, %r14
movq %rdi, %rbx
movss %xmm0, 0x4(%rsp)
divss 0x13b4(%rdi), %xmm0
callq 0x20d0
cvttss2si %xmm0, %eax
movl 0x13b0(%rbx), %ecx
sarl %ecx
cmpl %eax, %ecx
cmovgel %eax, %ecx
movl %ecx, (%rsp)
movq 0x1390(%rbx), %rax
cmpq %rax, 0x1398(%rbx)
je 0x33d2
movq %rax, 0x1398(%rbx)
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31e4
cmpl $0x0, (%rsp)
movss 0x4(%rsp), %xmm0
js 0x34f3
mulss %xmm0, %xmm0
leaq 0x1390(%rbx), %r15
movl (%rsp), %eax
negl %eax
movl 0x1c(%rsp), %ecx
movq %rcx, 0x20(%rsp)
movl 0x18(%rsp), %ecx
movl %ecx, 0x14(%rsp)
movl %eax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movss %xmm0, 0x4(%rsp)
movl 0x10(%rsp), %eax
movl %eax, %r13d
movq 0x20(%rsp), %rax
addl %r13d, %eax
movl 0x13b0(%rbx), %esi
addl %esi, %eax
cltd
idivl %esi
movl %edx, %ecx
movq 0x8(%rsp), %rax
addl %esi, %eax
addl 0x14(%rsp), %eax
cltd
idivl %esi
imull %esi, %edx
addl %ecx, %edx
movslq %edx, %rax
leaq (%rax,%rax,8), %r12
shlq $0x2, %r12
addq 0x13a8(%rbx), %r12
xorl %ebp, %ebp
movslq (%r12,%rbp), %rdx
cmpq $-0x1, %rdx
je 0x34cc
shlq $0x3, %rdx
addq 0x13b8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50ba
movss 0x4(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x34c2
leaq (%r12,%rbp), %rdx
movq 0x1398(%rbx), %rsi
cmpq 0x13a0(%rbx), %rsi
je 0x34ba
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x1398(%rbx)
jmp 0x34c2
movq %r15, %rdi
callq 0x6b7e
addq $0x4, %rbp
cmpq $0x24, %rbp
jne 0x346a
leal 0x1(%r13), %eax
cmpl (%rsp), %r13d
movl %eax, %r13d
jne 0x342e
movq 0x8(%rsp), %rcx
leal 0x1(%rcx), %eax
cmpl (%rsp), %ecx
movq %rax, 0x8(%rsp)
jne 0x3427
movq 0x1398(%rbx), %rax
subq 0x1390(%rbx), %rax
shrq $0x2, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8fb3(%rip), %rdi      # 0xc4ce
callq 0x2290
movl $0x1, %edi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::findClosestNeighbor(Vec2&, float)
float PDSampler::findClosestNeighbor(Vec2 &pt, float distance)
{
	if (!m_grid) {
		printf("Internal error, sampler cannot search without grid.\n");
		exit(1);
	}

	float closestSqrd = distance*distance;
	int i, j, k, gx, gy, N = (int) ceil(distance/m_gridCellSize);
	if (N>(m_gridSize>>1)) N = m_gridSize>>1;
	
	getGridXY(pt, &gx, &gy);
	for (j=-N; j<=N; j++) {
		for (i=-N; i<=N; i++) {
			int cx = (gx+i+m_gridSize)%m_gridSize;
			int cy = (gy+j+m_gridSize)%m_gridSize;
			int *cell = m_grid[cy*m_gridSize + cx];

			for (k=0; k<kMaxPointsPerCell; k++) {
				if (cell[k]==-1) {
					break;
				} else {
					float d = getDistanceSquared(pt, points[cell[k]]);

					if (d<closestSqrd)
						closestSqrd = d;
				}
			}
		}
	}

	return sqrt(closestSqrd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x13a8(%rdi)
je 0x369b
movq %rsi, %rbx
movq %rdi, %r14
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
divss 0x13b4(%rdi), %xmm0
callq 0x20d0
cvttss2si %xmm0, %eax
movl 0x13b0(%r14), %r15d
sarl %r15d
cmpl %eax, %r15d
cmovgel %eax, %r15d
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31e4
testl %r15d, %r15d
js 0x3667
movl %r15d, %eax
negl %eax
movl 0x1c(%rsp), %ecx
movq %rcx, 0x20(%rsp)
movl 0x18(%rsp), %ecx
movl %ecx, 0x14(%rsp)
movl %eax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movss 0x4(%rsp), %xmm0
movl 0x10(%rsp), %eax
movl %eax, %ebp
movq 0x20(%rsp), %rax
addl %ebp, %eax
movl 0x13b0(%r14), %esi
addl %esi, %eax
cltd
idivl %esi
movl %edx, %ecx
movq 0x8(%rsp), %rax
addl %esi, %eax
addl 0x14(%rsp), %eax
cltd
idivl %esi
imull %esi, %edx
addl %ecx, %edx
movslq %edx, %rax
leaq (%rax,%rax,8), %r12
shlq $0x2, %r12
addq 0x13a8(%r14), %r12
xorl %r13d, %r13d
movaps %xmm0, %xmm1
movslq (%r12,%r13,4), %rdx
cmpq $-0x1, %rdx
je 0x363e
shlq $0x3, %rdx
addq 0x13b8(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movss %xmm1, 0x4(%rsp)
callq 0x50ba
minss 0x4(%rsp), %xmm0
incq %r13
movaps %xmm0, %xmm1
cmpq $0x9, %r13
jne 0x3604
jmp 0x3641
movaps %xmm1, %xmm0
leal 0x1(%rbp), %eax
cmpl %r15d, %ebp
movl %eax, %ebp
jne 0x35c4
movq 0x8(%rsp), %rcx
leal 0x1(%rcx), %eax
cmpl %r15d, %ecx
movq %rax, 0x8(%rsp)
jne 0x35be
jmp 0x366d
movss 0x4(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x3688
sqrtss %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2320
leaq 0x8e2c(%rip), %rdi      # 0xc4ce
callq 0x2290
movl $0x1, %edi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::maximize()
void PDSampler::maximize()
{
	RangeList rl(0,0);
	int i, N = (int) points.size();

	for (i=0; i<N; i++) {
		Vec2 &candidate = points[i];

		rl.reset(0, (float) M_PI*2);
		findNeighborRanges(i, rl);
		while (rl.numRanges) {
			RangeEntry &re = rl.ranges[m_rng.getInt31()%rl.numRanges];
			float angle = re.min + (re.max-re.min)*m_rng.getFloatL();
			Vec2 pt = getTiled(Vec2(candidate.x + cos(angle)*2*radius,
									candidate.y + sin(angle)*2*radius));

			addPoint(pt);
			rl.subtract(angle - (float) M_PI/3, angle + (float) M_PI/3);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x7270
movq 0x13c0(%rbx), %rax
subq 0x13b8(%rbx), %rax
shrq $0x3, %rax
movq %rax, 0x10(%rsp)
testl %eax, %eax
jle 0x3c40
leaq 0x8(%rbx), %r14
movq 0x10(%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0x38(%rsp), %r12
movq 0x13b8(%rbx), %rbp
xorps %xmm0, %xmm0
movq %r12, %rdi
movss 0x69ca(%rip), %xmm1     # 0xa498
callq 0x72c2
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x36b2
cmpl $0x0, 0x40(%rsp)
je 0x3c32
movq 0x38(%rsp), %r13
movq %r14, %rdi
callq 0x276a
movslq 0x40(%rsp), %rcx
cqto
idivq %rcx
movss (%r13,%rdx,8), %xmm0
movss %xmm0, 0x20(%rsp)
movss 0x4(%r13,%rdx,8), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
callq 0x2846
movss 0xc(%rsp), %xmm1
movss 0x20(%rsp), %xmm2
subss %xmm2, %xmm1
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0xc(%rsp)
movss (%rbp,%r15,8), %xmm0
movss %xmm0, 0x20(%rsp)
movaps %xmm1, %xmm0
callq 0x2120
addss %xmm0, %xmm0
mulss 0x13d0(%rbx), %xmm0
addss 0x20(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movss 0x4(%rbp,%r15,8), %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x2170
addss %xmm0, %xmm0
mulss 0x13d0(%rbx), %xmm0
addss 0x1c(%rsp), %xmm0
cmpb $0x1, 0x13d4(%rbx)
jne 0x3bbe
movss 0x68d2(%rip), %xmm1     # 0xa47c
movaps 0x20(%rsp), %xmm2
ucomiss %xmm2, %xmm1
jbe 0x3bc5
addss 0x68bc(%rip), %xmm2     # 0xa478
jmp 0x3bd6
movaps 0x20(%rsp), %xmm2
jmp 0x3bfe
ucomiss 0x68b4(%rip), %xmm2     # 0xa480
jbe 0x3bd6
addss 0x68ae(%rip), %xmm2     # 0xa484
movss 0x689e(%rip), %xmm1     # 0xa47c
ucomiss %xmm0, %xmm1
jbe 0x3bed
addss 0x688d(%rip), %xmm0     # 0xa478
jmp 0x3bfe
ucomiss 0x688c(%rip), %xmm0     # 0xa480
jbe 0x3bfe
addss 0x6886(%rip), %xmm0     # 0xa484
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movq %rbx, %rdi
movaps %xmm2, %xmm0
callq 0x3298
movss 0xc(%rsp), %xmm1
movaps %xmm1, %xmm0
addss 0x687f(%rip), %xmm0     # 0xa49c
addss 0x687b(%rip), %xmm1     # 0xa4a0
movq %r12, %rdi
callq 0x73d8
jmp 0x3ae1
incq %r15
cmpq 0x10(%rsp), %r15
jne 0x3ab9
leaq 0x38(%rsp), %rdi
callq 0x72d6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c5f
jmp 0x3c5f
jmp 0x3c5f
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x72d6
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: DartThrowing::complete()
void DartThrowing::complete()
{
	while (1) {
		int i, N = (int) points.size()*m_maxThrowsMult;
		if (N<m_minMaxThrows) N = m_minMaxThrows;

		for (i=0; i<N; i++) {
			Vec2 pt = randomPoint();

			findNeighbors(pt, 2*radius);

			if (!m_neighbors.size()) {
				addPoint(pt);
				break;
			}
		}

		if (i==N)
			break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x8(%rsp), %r15
movq 0x13c0(%rbx), %r12
subq 0x13b8(%rbx), %r12
shrq $0x3, %r12
imull 0x13dc(%rbx), %r12d
movl 0x13d8(%rbx), %eax
cmpl %eax, %r12d
cmovlel %eax, %r12d
xorl %ebp, %ebp
testl %r12d, %r12d
jle 0x41b5
movq %r14, %rdi
callq 0x2846
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x2846
movaps 0x10(%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
addps %xmm1, %xmm1
addps 0x6341(%rip), %xmm1     # 0xa4b0
movlps %xmm1, 0x8(%rsp)
movss 0x13d0(%rbx), %xmm0
addss %xmm0, %xmm0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3372
movq 0x1398(%rbx), %rax
cmpq 0x1390(%rbx), %rax
je 0x41a7
incl %ebp
cmpl %ebp, %r12d
jne 0x4148
movl %r12d, %ebp
jmp 0x41b5
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x3298
cmpl %r12d, %ebp
jne 0x411a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: BestCandidate::complete()
void BestCandidate::complete()
{
	for (int i=0; i<m_N; i++) {
		Vec2 best(0,0);
		float bestDistance = 0;
		int count = 1 + (int) points.size()*m_multiplier;

		for (int j=0; j<count; j++) {
			Vec2 pt = randomPoint();
			float closest = 2;

			closest = findClosestNeighbor(pt, 4*radius);
			if (j==0 || closest>bestDistance) {
				bestDistance = closest;
				best = pt;
			}
		}

		addPoint(best);
	}
}

// Assembly:
cmpl $0x0, 0x13dc(%rdi)
jle 0x432c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x13c0(%rbx), %r12
subq 0x13b8(%rbx), %r12
shrq $0x3, %r12
imull 0x13d8(%rbx), %r12d
testl %r12d, %r12d
js 0x42fb
incl %r12d
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x2846
movaps %xmm0, 0x20(%rsp)
movq %r14, %rdi
callq 0x2846
movaps 0x20(%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
addps %xmm1, %xmm1
addps 0x6202(%rip), %xmm1     # 0xa4b0
movlps %xmm1, 0x8(%rsp)
movss 0x13d0(%rbx), %xmm0
mulss 0x61c9(%rip), %xmm0     # 0xa48c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x352a
testl %r13d, %r13d
sete %al
ucomiss 0x4(%rsp), %xmm0
seta %cl
orb %al, %cl
je 0x42f1
movsd 0x8(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movss %xmm0, 0x4(%rsp)
incl %r13d
cmpl %r13d, %r12d
jne 0x4287
jmp 0x4303
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movaps 0x10(%rsp), %xmm0
callq 0x3298
incl %ebp
cmpl 0x13dc(%rbx), %ebp
jl 0x424d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/PDSampling.cpp
// Function: PenroseSampler::complete()
void PenroseSampler::complete()
{
	PenroseQuasisampler s((unsigned int) (9.1/(radius*radius)));
	std::vector<Point2D> pts = s.getSamplingPoints();

	for (std::vector<Point2D>::iterator it=pts.begin(); it!=pts.end(); it++ ) {
		Vec2 pt((float) it->x/50.f - 1.0f, (float) it->y/50.f - 1.0f);

		if (pointInDomain(pt)) {
			addPoint(pt);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movss 0x13d0(%rdi), %xmm0
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x54d4(%rip), %xmm1     # 0xa428
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movaps 0x556c(%rip), %xmm0     # 0xa4d0
leaq 0x20(%rsp), %rsi
movups %xmm0, 0x10(%rsi)
movq $0x0, 0x8(%rsi)
leaq 0xadc4(%rip), %rcx      # 0xfd40
movq %rcx, (%rsi)
movl %eax, 0x20(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x55dc
movq 0x8(%rsp), %r14
cmpq 0x10(%rsp), %r14
je 0x4ff0
movupd (%r14), %xmm0
cvtpd2ps %xmm0, %xmm0
divps 0x5538(%rip), %xmm0     # 0xa4e0
addps 0x5501(%rip), %xmm0     # 0xa4b0
ucomiss 0x54c6(%rip), %xmm0     # 0xa47c
jb 0x4fea
movaps %xmm0, %xmm1
cmpleps 0x552d(%rip), %xmm1     # 0xa4f0
unpcklps %xmm1, %xmm1            # xmm1 = xmm1[0,0,1,1]
movmskpd %xmm1, %eax
testb $0x2, %al
je 0x4fea
testb $0x1, %al
je 0x4fea
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x549c(%rip), %xmm1     # 0xa47c
jb 0x4fea
movq %rbx, %rdi
callq 0x3298
addq $0x10, %r14
jmp 0x4f91
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5007
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
leaq 0x20(%rsp), %rdi
callq 0x5658
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x5038
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5038
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
leaq 0x20(%rsp), %rdi
callq 0x5658
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::insert(int, float)
void WeightedDiscretePDF<T>::insert(T item, float weight)
{
	WDPDF_Node<T> *p=0, *n=m_root;

	while (n) {
		if (n->leftIsRed() && n->rightIsRed())
			split(n);

		p = n;
		if (n->key==item) {
			throw std::domain_error("insert: argument(item) already in tree");
		} else {
			n = (item<n->key)?n->left:n->right;
		}
	}

	n = new WDPDF_Node<T>(item, weight, p);

	if (!p) {
		m_root = n;
	} else {
		if (item<p->key) {
			p->left = n;
		} else {
			p->right = n;
		}

		split(n);
	}

	propogateSumsUp(n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
movss %xmm0, 0x4(%rsp)
je 0x51f6
movq %rax, %r14
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x51da
cmpb $0x1, (%rax)
jne 0x51da
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x51da
cmpb $0x1, (%rax)
jne 0x51da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fee
cmpl %ebp, 0x20(%r14)
je 0x5292
setle %al
movzbl %al, %eax
movq 0x10(%r14,%rax,8), %rax
testq %rax, %rax
jne 0x51b0
jmp 0x51f9
xorl %r14d, %r14d
movl $0x30, %edi
callq 0x21a0
movq %rax, %r15
movb $0x0, (%rax)
movl %ebp, 0x20(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x24(%rax)
movl $0x0, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r14, 0x8(%rax)
testq %r14, %r14
je 0x5249
xorl %eax, %eax
cmpl %ebp, 0x20(%r14)
setle %al
movq %r15, 0x10(%r14,%rax,8)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6fee
jmp 0x524c
movq %r15, (%rbx)
movq 0x10(%r15), %rax
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
testq %rax, %rax
je 0x5260
movss 0x28(%rax), %xmm1
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x526e
movss 0x28(%rax), %xmm0
addss 0x24(%r15), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x28(%r15)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x524c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x70f3(%rip), %rsi      # 0xc399
movq %rax, %rdi
callq 0x20f0
movq 0xad0b(%rip), %rsi      # 0xffc0
movq 0xad14(%rip), %rdx      # 0xffd0
movq %rbx, %rdi
callq 0x2300
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::choose(float)
T WeightedDiscretePDF<T>::choose(float p)
{
	if (p<0.0 || p>=1.0) {
		throw std::domain_error("choose: argument(p) outside valid range");
	} else if (!m_root) {
		throw std::logic_error("choose: choose() called on empty tree");
	} else {
		float w = m_root->sumWeights * p;
		WDPDF_Node<T> *n = m_root;

		while (1) {
			if (n->left) {
				if (w<n->left->sumWeights) {
					n = n->left;
					continue;
				} else {
					w -= n->left->sumWeights;
				}
			}
			if (w<n->weight || !n->right) {
				break; // !n->right condition shouldn't be necessary, just sanity check
			}
			w -= n->weight;
			n = n->right;
		}

		return n->key;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x5338
ucomiss 0x5195(%rip), %xmm0     # 0xa480
jae 0x5338
movq (%rdi), %rax
testq %rax, %rax
je 0x5364
mulss 0x28(%rax), %xmm0
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x5314
movss 0x28(%rax), %xmm1
ucomiss %xmm0, %xmm1
ja 0x52fa
subss %xmm1, %xmm0
movss 0x24(%rcx), %xmm1
ucomiss %xmm0, %xmm1
ja 0x532d
movq 0x18(%rcx), %rax
testq %rax, %rax
je 0x532d
subss %xmm1, %xmm0
jmp 0x52fa
movl 0x20(%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x7074(%rip), %rsi      # 0xc3c0
movq %rax, %rdi
callq 0x20f0
movq 0xac65(%rip), %rsi      # 0xffc0
movq 0xac6e(%rip), %rdx      # 0xffd0
jmp 0x538e
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x7070(%rip), %rsi      # 0xc3e8
movq %rax, %rdi
callq 0x2270
movq 0xac61(%rip), %rsi      # 0xffe8
movq 0xac4a(%rip), %rdx      # 0xffd8
movq %rbx, %rdi
callq 0x2300
jmp 0x5398
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::remove(int)
WDPDF_Node<T> **WeightedDiscretePDF<T>::lookup(T item, WDPDF_Node<T> **parent_out)
{
	WDPDF_Node<T> *n, *p=0, **np=&m_root;

	while ((n = *np)) {
		if (n->key==item) {
			break;
		} else {
			p = n;
			if (item<n->key) {
				np = &n->left;
			} else {
				np = &n->right;
			}
		}
	}

	if (parent_out)
		*parent_out = p;
	return np;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rcx
movq %rdi, %rax
testq %rcx, %rcx
je 0x53ed
movl 0x20(%rcx), %edx
movq %rdi, %rax
cmpl %esi, %edx
je 0x53ed
movq %rcx, %rax
xorl %r8d, %r8d
cmpl %esi, %edx
setle %r8b
movq 0x10(%rcx,%r8,8), %rcx
testq %rcx, %rcx
je 0x53e2
movl 0x20(%rcx), %edx
cmpl %esi, %edx
jne 0x53c5
leaq 0x10(,%r8,8), %rcx
addq %rcx, %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x54c3
cmpq $0x0, 0x10(%rcx)
je 0x5427
leaq 0x10(%rcx), %rdx
movq %rdx, %rax
movq (%rdx), %rbx
leaq 0x18(%rbx), %rdx
cmpq $0x0, 0x18(%rbx)
jne 0x5404
movl 0x20(%rbx), %edx
movl %edx, 0x20(%rcx)
movss 0x24(%rbx), %xmm0
movss %xmm0, 0x24(%rcx)
jmp 0x542a
movq %rcx, %rbx
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
jne 0x5437
movq 0x18(%rbx), %rsi
movq %rsi, (%rax)
testq %rsi, %rsi
je 0x5451
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsi)
cmpb $0x0, (%rbx)
jne 0x5451
callq 0x715c
leaq 0x10(%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x5494
movq 0x10(%rcx), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
testq %rdx, %rdx
je 0x5472
movss 0x28(%rdx), %xmm1
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
je 0x5480
movss 0x28(%rdx), %xmm0
addss 0x24(%rcx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x28(%rcx)
movq 0x8(%rcx), %rcx
jmp 0x5459
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
testq %rbx, %rbx
je 0x54bb
movq %rbx, %rdi
callq 0x6d96
movl $0x30, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x6f37(%rip), %rsi      # 0xc40e
movq %rax, %rdi
callq 0x20f0
movq 0xaada(%rip), %rsi      # 0xffc0
movq 0xaae3(%rip), %rdx      # 0xffd0
movq %rbx, %rdi
callq 0x2300
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::getSamplingPoints()
std::vector<Point2D> getSamplingPoints()
  {
    if (root) delete root;
    std::vector<Point2D> pointlist;
    
    buildAdaptiveSubdivision(); 
    collectPoints(pointlist);
    return pointlist;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x5605
movq %r15, %rdi
callq 0x57ea
movl $0x78, %esi
movq %r15, %rdi
callq 0x21b0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
movl $0x6, %esi
callq 0x5872
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5a9e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5650
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::TileNode::collapse()
void collapse()
    {
      // Recursively prune the tree.
      for (unsigned i=0; i<children.size(); i++) delete children[i];
      terminal = true;
      children.clear();
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rdx
cmpq %rax, %rdx
je 0x5860
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x5845
movq %r14, %rdi
callq 0x57ea
movl $0x78, %esi
movq %r14, %rdi
callq 0x21b0
movl %ebp, %ecx
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rcx, %rsi
ja 0x5827
movb $0x1, 0x5c(%rbx)
cmpq %rax, %rdx
je 0x586d
movq %rax, 0x68(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::collectPoints(std::vector<Point2D, std::allocator<Point2D>>&, bool)
void collectPoints( 
    std::vector<Point2D> &pointlist,
    bool filterBounds = true )
  {
    pointlist.clear();

    Point2D pt, pt_displaced;
    unsigned importance;
    TileLeafIterator it(root);
    do {
      pt = it->getP1();  
      if ( it->isSamplingType() ) // Only "pentagonal" tiles generate sampling points.
      {   
        importance = getImportanceAt_bounded( pt );

        // Threshold the function against the F-Code value.           
        if ( importance >= calcFCodeValue( it->getFCode() , 2*it->getLevel() ) )
        {
          // Get the displaced point using the lookup table.
          pt_displaced = it->getDisplacedSamplingPoint(importance);

          if ( !filterBounds ||
            (pt_displaced.x>=0 && pt_displaced.x<width && 
            pt_displaced.y>=0 && pt_displaced.y<height) )
          {
            pointlist.push_back(pt_displaced); // collect point.
          }
        }
      }

    } while ( it.next() );

  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x5ac1
movq %rax, 0x8(%r14)
movq 0x8(%r15), %r12
cmpb $0x0, 0x5c(%r12)
jne 0x5add
movq 0x60(%r12), %rax
movq (%rax), %r12
cmpb $0x1, 0x5c(%r12)
jne 0x5acd
movq %rsp, %r13
cmpl $0x1, 0x4(%r12)
ja 0x5bde
movsd 0x18(%r12), %xmm0
xorl %ebp, %ebp
ucomisd 0x493b(%rip), %xmm0     # 0xa438
jb 0x5b33
movsd 0x10(%r15), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5b33
movsd 0x20(%r12), %xmm1
ucomisd 0x491e(%rip), %xmm1     # 0xa438
jb 0x5b33
movsd 0x18(%r15), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x5b33
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movl %eax, %ebp
movl (%r12), %esi
movl 0x48(%r12), %edi
addl %esi, %esi
callq 0x6762
cmpl %eax, %ebp
jb 0x5bde
movl 0x8(%r12), %edx
movl 0x48(%r12), %esi
movl %ebp, %edi
callq 0x680a
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movsd 0x10(%r12), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm0, %xmm1
movupd 0x18(%r12), %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, (%rsp)
testb %bl, %bl
je 0x5bb9
ucomisd 0x48ad(%rip), %xmm0     # 0xa438
jb 0x5bde
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
ucomisd 0x489b(%rip), %xmm1     # 0xa438
setae %al
movupd 0x10(%r15), %xmm1
cmpltpd %xmm1, %xmm0
movmskpd %xmm0, %ecx
andb %cl, %al
shrb %cl
andb %cl, %al
cmpb $0x1, %al
jne 0x5bde
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x5bd3
movapd (%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%r14)
jmp 0x5bde
movq %r14, %rdi
movq %r13, %rdx
callq 0x68f8
movq %r12, %rdi
callq 0x66e8
testq %rax, %rax
je 0x5bf6
movq %rax, %r12
cmpb $0x1, 0x5c(%rax)
jne 0x5bde
jmp 0x5bf9
xorl %r12d, %r12d
testq %r12, %r12
jne 0x5ae0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::TileNode::TileNode(double, double)
TileNode( double roi_width,  double roi_height)
    {
      double side = MAX(roi_width,roi_height);
      double scale = 2.0 * side;
      Point2D offset(PHI*PHI/2.0-0.25,0.125);
      *this = TileNode(NULL, TileTypeF,offset*-scale,15,0,0,scale);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
xorps %xmm2, %xmm2
movups %xmm2, 0x60(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x70(%rdi)
maxsd %xmm1, %xmm0
addsd %xmm0, %xmm0
leaq 0x68(%rsp), %rax
movups %xmm2, (%rax)
movq %rcx, 0x10(%rax)
movq %rcx, -0x10(%rax)
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd 0x48b6(%rip), %xmm1     # 0xa510
movupd %xmm1, -0x48(%rax)
movl $0xf, -0x58(%rax)
movl %ecx, -0x8(%rax)
movsd %xmm0, -0x50(%rax)
movabsq $0x500000000, %rdx      # imm = 0x500000000
movq %rdx, -0x60(%rax)
movsd 0x47bc(%rip), %xmm2     # 0xa440
mulsd %xmm0, %xmm2
xorpd %xmm3, %xmm3
mulsd %xmm2, %xmm3
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulsd 0x47ac(%rip), %xmm0     # 0xa448
addpd %xmm1, %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd 0x4874(%rip), %xmm0     # 0xa520
movupd %xmm2, -0x38(%rax)
addpd %xmm1, %xmm0
movupd %xmm0, -0x28(%rax)
movl %ecx, -0x18(%rax)
movb $0x1, -0x4(%rax)
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x5ccf
movq %rcx, 0x70(%rsp)
leaq 0x8(%rsp), %rdx
movl $0xb, %ecx
movq %rbx, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movb 0x5c(%rdx), %cl
movb %cl, 0x5c(%rbx)
movl 0x58(%rdx), %ecx
movl %ecx, 0x58(%rbx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x64a6
leaq 0x8(%rsp), %rdi
callq 0x57ea
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x57ea
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5d31
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r15, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::subdivideAll(int)
void subdivideAll(int times=1)
  {
    if (!root) return;
    TileNode *tmp;
    for (int i=0;i<times;i++)  
    {
      TileLeafIterator it(root);
      do { 
        tmp = *it;
        it.next();
        tmp->refine();
      }
      while (*it);
    }
  }

// Assembly:
cmpq $0x0, 0x8(%rdi)
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x5db4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r13d, %r13d
movq 0x8(%r14), %r15
cmpb $0x0, 0x5c(%r15)
jne 0x5d75
movq 0x60(%r15), %rax
movq (%rax), %r15
cmpb $0x1, 0x5c(%r15)
jne 0x5d67
movq %r15, %r12
movq %r12, %rdi
callq 0x66e8
testq %rax, %rax
je 0x5d90
movq %rax, %r12
cmpb $0x1, 0x5c(%rax)
jne 0x5d78
jmp 0x5d93
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x5e10
movq %r12, %r15
testq %r12, %r12
jne 0x5d78
incl %r13d
cmpl %ebx, %r13d
jne 0x5d5c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::getReqSubdivisionLevel(unsigned int)
static unsigned getReqSubdivisionLevel( unsigned importance )
  {
    if (importance==0) return 0;
    unsigned nbits = (unsigned)(log( (double)importance*SQRT5 + 1.0 ) / LOG_PHI) - 1;
    if (nbits<1) nbits = 1;
    return (unsigned)ceil(0.5*nbits);
  }

// Assembly:
testl %edi, %edi
je 0x5e0c
pushq %rax
movl %edi, %eax
cvtsi2sd %rax, %xmm0
mulsd 0x4686(%rip), %xmm0     # 0xa450
addsd 0x4686(%rip), %xmm0     # 0xa458
callq 0x2150
divsd 0x4681(%rip), %xmm0     # 0xa460
cvttsd2si %xmm0, %rax
leal -0x1(%rax), %ecx
cmpl $0x1, %ecx
adcl $-0x1, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x4253(%rip), %xmm0     # 0xa050
callq 0x2060
cvttsd2si %xmm0, %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::TileNode::nextNode()
TileNode* nextNode()
    {
      if (!terminal) return children[0];
      
      if (level == 0) return NULL; // single node case.

      if ( parent_slot < parent->children.size()-1 )
        return parent->children[parent_slot+1];

      // last child case
      TileNode* tmp = this;
      do
      {
        tmp = tmp->parent;
      }
      while ( (tmp->level != 0) && (tmp->parent_slot ==  tmp->parent->children.size()-1) );

      if (tmp->level == 0) return NULL; // last node
      return tmp->parent->children[tmp->parent_slot+1];

    }

// Assembly:
cmpb $0x0, 0x5c(%rdi)
je 0x6719
cmpl $0x0, (%rdi)
je 0x675f
movl 0x58(%rdi), %eax
movq 0x50(%rdi), %rdx
movq 0x60(%rdx), %rcx
movq 0x68(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
decq %rdx
cmpq %rax, %rdx
jbe 0x6721
incl %eax
leaq (%rcx,%rax,8), %rax
jmp 0x671d
movq 0x60(%rdi), %rax
movq (%rax), %rax
retq
xorl %eax, %eax
movq 0x50(%rdi), %rdi
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x6720
movq 0x50(%rdi), %rdx
movq 0x68(%rdx), %rsi
subq 0x60(%rdx), %rsi
movl 0x58(%rdi), %edx
sarq $0x3, %rsi
decq %rsi
cmpq %rdx, %rsi
je 0x6723
testl %ecx, %ecx
je 0x675f
movq 0x50(%rdi), %rcx
movl 0x58(%rdi), %eax
incl %eax
shlq $0x3, %rax
addq 0x60(%rcx), %rax
jmp 0x671d
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::calcFCodeValue(unsigned int, unsigned int)
static unsigned calcFCodeValue(unsigned bitsequence,unsigned nbits)
  {
    unsigned i_s = 0;
    for (unsigned i=0; i<nbits ;i++ )
    {
      if ( bitsequence & ( 1u<<(nbits-i-1) ) ) i_s += fibonacci(i+2);
    }
    return i_s;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x6796
movl %esi, %ebx
movl %edi, %ebp
decl %ebx
xorl %r14d, %r14d
movl $0x2, %r15d
btl %ebx, %ebp
jae 0x678c
movl %r15d, %edi
callq 0x67a8
addl %eax, %r14d
incl %r15d
addl $-0x1, %ebx
jb 0x677c
jmp 0x6799
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::calcDisplacementVector(unsigned int, unsigned int, int)
static Point2D calcDisplacementVector(unsigned importance, unsigned f_code, int dir)
  {
    unsigned i_s = calcStructuralIndex(f_code);
    unsigned i_v = calcImportanceIndex(importance);

    return  
      vvect[dir]        * lut[i_v][i_s][0] + // u component
      vvect[(dir+5)%20] * lut[i_v][i_s][1] ; // v component
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %edi, %r14d
movl %esi, %edi
movl $0x6, %esi
callq 0x6762
movl %eax, %ebx
movl %r14d, %eax
cvtsi2sd %rax, %xmm0
mulsd 0x3c1b(%rip), %xmm0     # 0xa450
addsd 0x3c1b(%rip), %xmm0     # 0xa458
callq 0x2150
divsd 0x3c1e(%rip), %xmm0     # 0xa468
movsd %xmm0, 0x8(%rsp)
callq 0x22f0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x3c09(%rip), %xmm1     # 0xa470
cvttsd2si %xmm1, %rax
movslq %ebp, %rcx
movl %ecx, %edx
addl $0x5, %edx
movslq %edx, %rdx
imulq $0x66666667, %rdx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x23, %rdx
addl %esi, %edx
shll $0x2, %edx
leal (%rdx,%rdx,4), %edx
negl %edx
addl %ecx, %edx
addl $0x5, %edx
shlq $0x4, %rcx
leaq 0x3d2d(%rip), %rsi      # 0xa5d0
movl %eax, %eax
movl %ebx, %edi
imulq $0x150, %rax, %rax      # imm = 0x150
leaq 0x3e5b(%rip), %r8       # 0xa710
addq %rax, %r8
shlq $0x4, %rdi
movslq %edx, %rax
shlq $0x4, %rax
movsd (%rdi,%r8), %xmm1
movsd 0x8(%rdi,%r8), %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd (%rcx,%rsi), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd (%rax,%rsi), %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::split(WDPDF_Node<int>*)
void WeightedDiscretePDF<T>::split(WDPDF_Node<T> *n)
{
	if (n->left) n->left->markBlack();
	if (n->right) n->right->markBlack();

	if (n->parent) {
		WDPDF_Node<T> *p = n->parent;

		n->markRed();

		if (p->isRed()) {
			p->parent->markRed();

				// not same direction
			if (!(	(n==p->left && p==p->parent->left) || 
					(n==p->right && p==p->parent->right))) {
			  rotate(n);
			  p = n;
			}

			rotate(p);
			p->markBlack();
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x7005
movb $0x0, (%rax)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x7011
movb $0x0, (%rax)
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x7060
movb $0x1, (%r14)
cmpb $0x1, (%r15)
jne 0x7060
movq 0x8(%r15), %rax
movb $0x1, (%rax)
cmpq %r14, 0x10(%r15)
jne 0x7037
cmpq 0x10(%rax), %r15
je 0x7051
cmpq %r14, 0x18(%r15)
jne 0x7043
cmpq 0x18(%rax), %r15
je 0x7051
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7066
movq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7066
movb $0x0, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::rotate(WDPDF_Node<int>*)
void WeightedDiscretePDF<T>::rotate(WDPDF_Node<T> *n)
{
	WDPDF_Node<T> *p=n->parent, *pp=p->parent;

	n->parent = pp;
	p->parent = n;

	if (n==p->left) {
		p->left = n->right;
		n->right = p;
		if (p->left) p->left->parent = p;
	} else {
		p->right = n->left;
		n->left = p;
		if (p->right) p->right->parent = p;
	}

	n->setSum();
	p->setSum();
	
	if (!pp) {
		m_root = n;
	} else {
		if (p==pp->left) {
			pp->left = n;
		} else {
			pp->right = n;
		}
	}
}

// Assembly:
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rsi, 0x8(%rax)
cmpq %rsi, 0x10(%rax)
je 0x708a
movq 0x10(%rsi), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x10(%rsi)
jmp 0x7096
movq 0x18(%rsi), %rdx
movq %rdx, 0x10(%rax)
movq %rax, 0x18(%rsi)
testq %rdx, %rdx
je 0x709f
movq %rax, 0x8(%rdx)
movq 0x10(%rsi), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
testq %rdx, %rdx
je 0x70b3
movss 0x28(%rdx), %xmm1
movss 0x24(%rsi), %xmm2
movq 0x18(%rsi), %rdx
testq %rdx, %rdx
je 0x70c6
movss 0x28(%rdx), %xmm0
addss %xmm1, %xmm2
addss %xmm0, %xmm2
movss %xmm2, 0x28(%rsi)
movq 0x10(%rax), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
testq %rdx, %rdx
je 0x70e7
movss 0x28(%rdx), %xmm1
movss 0x24(%rax), %xmm2
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x70fa
movss 0x28(%rdx), %xmm0
addss %xmm1, %xmm2
addss %xmm0, %xmm2
movss %xmm2, 0x28(%rax)
testq %rcx, %rcx
je 0x711c
leaq 0x10(%rcx), %rdx
leaq 0x18(%rcx), %rdi
cmpq 0x10(%rcx), %rax
cmoveq %rdx, %rdi
movq %rsi, (%rdi)
retq