LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::TransformColor(long, int)
long M3DDrawer::TransformColor (long color, int pal_case)
{
	int red, green, blue;

	red = color & 0xff;
	green = (color >> 8) & 0xff;
	blue = (color >> 16) & 0xff;
 
	if (((blue>>6) > 0) && ((blue >> 6) < 4) && green==0)
    {
		green = red >> 2;
        
		if (pal_case == 0)
        {
			blue -= (63 - (red >> 2));
        }
		else if (pal_case == 1)
        {
			if ((blue >> 6) == 3)
				blue -= (63 - (red >> 2));
			else if ((blue >> 6) == 1)
				blue += (63 - (red >> 2));
        }
		else if (pal_case == 2)
        {
			if ((blue >> 6) == 3)
				blue += (63 - (red >> 2));
			else if ((blue >> 6) == 1)
				blue -= (63 - (red >> 2));
        }
        
		red = 0;
		
		color = red + (blue << 16) + (green << 8);
		//green += (red >> 1);
    } 
    
	return color;
}

// Assembly:
movq %rdi, %rax
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
cmpl $0x40, %ecx
setb %dl
testw $0xff00, %ax            # imm = 0xFF00
setne %dil
orb %dl, %dil
jne 0x5d83
movl %ecx, %edx
shrl $0x6, %edx
shrl $0x2, %eax
andl $0x3f, %eax
cmpl $0x2, %esi
je 0x5d61
cmpl $0x1, %esi
je 0x5d55
testl %esi, %esi
je 0x5d74
jmp 0x5d7b
cmpl $0x1, %edx
je 0x5d6b
cmpl $0x3, %edx
je 0x5d74
jmp 0x5d7b
cmpl $0x1, %edx
je 0x5d74
cmpl $0x3, %edx
jne 0x5d7b
movl %eax, %edx
xorl $0x3f, %edx
addl %edx, %ecx
jmp 0x5d7b
movl %eax, %edx
xorl $0x3f, %edx
subl %edx, %ecx
shll $0x10, %ecx
shll $0x8, %eax
orl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::Julia(long double, long double, long double, long double, int&, int&)
DWORD M3DDrawer::Julia(long double juliaRe, long double juliaIm,
			long double Re, long double Im, int &mandel, int &fraction)
{
    int cnt=0;
    long double cRe, cIm, tRe, tIm;
    long double cRe2, cIm2, last=0, final;
    
    cRe = Re, cIm = Im;
    do {
        cRe2 = cRe * cRe;
        cIm2 = cIm * cIm;
        final = cRe2 + cIm2;
        
        if ((final <= 4.0) && cnt < 256)
		{
            last = final;
            tRe = cRe2 - cIm2;
            tIm = 2 * cRe * cIm;
            cRe = tRe + juliaRe, cIm = tIm + juliaIm;
            cnt++;
		}
        else break;
    } while (1);
    
    long color=0;
    
    fraction = 0;
    mandel = cnt;
    
    if (cnt > 0 && cnt < 256)
    {
        fraction = 16 * (4.0 - last)/(final - last) ;
    }
    
    color = GetExactColor (cnt, fraction);
    
    return color;   
}

// Assembly:
movq %rsi, %rax
fldz
fstpt -0x18(%rsp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
fldt 0x38(%rsp)
fldt 0x28(%rsp)
fldt 0x18(%rsp)
fstpt -0xc(%rsp)
fldt 0x8(%rsp)
leal 0x1(%rcx), %esi
fld %st(1)
fmul %st(2), %st
fld %st(3)
fmul %st(4), %st
fld %st(0)
fadd %st(2), %st
flds 0x3641(%rip)            # 0x93fc
fucompi %st(1), %st
jb 0x5de5
cmpl $0xff, %esi
ja 0x5de5
fxch %st(2)
fsubp %st, %st(1)
fxch %st(3)
fadd %st, %st(0)
fmulp %st, %st(4)
fxch %st(2)
fadd %st(1), %st
fldt -0xc(%rsp)
faddp %st, %st(4)
movl %esi, %ecx
fxch %st(2)
fstpt -0x18(%rsp)
jmp 0x5da6
fstp %st(1)
fstp %st(4)
fstp %st(1)
fstp %st(1)
fstp %st(0)
andl $0x0, (%rdx)
movl %esi, (%rax)
cmpl $0xff, %ecx
jae 0x5e3b
fldt -0x18(%rsp)
fld %st(0)
fsubrs 0x35f4(%rip)            # 0x93fc
fmuls 0x35f2(%rip)            # 0x9400
fxch %st(2)
fsubp %st, %st(1)
fdivrp %st, %st(1)
fnstcw -0x20(%rsp)
movzwl -0x20(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x1e(%rsp)
fldcw -0x1e(%rsp)
fistpl -0x1c(%rsp)
fldcw -0x20(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, (%rdx)
jmp 0x5e3f
fstp %st(0)
movl (%rdx), %eax
movl %eax, %edx
jmp 0x5ccc
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::Strange(long double, long double, int&, int&)
DWORD M3DDrawer::Strange(long double Re, long double Im, int &mandel, int &fraction)
{
    int cnt=0;
    long double cRe, cIm, tRe, tIm;
    long double cRe2, cIm2, last=0, final;
    
    cRe = Re, cIm = Im;
    do {
        cRe2 = cRe * cRe;
        cIm2 = cIm * cIm;
        final = cRe2 + cIm2;
        
#ifdef DEMO_VERSION
		if ((final <= 4.0) && cnt < 256)
#else
            if ((final <= 4.0) && cnt < 256)
#endif
            {
                last = final;
                tRe = cRe2 - cIm2;
                tIm = 2 * cRe * cIm;
                cRe = tRe + Re, cIm = tIm + Im;
                cnt++;
            }
            else break;
    } while (1);
    
    long color = 0;
    
    fraction = 0;
    mandel = cnt;
    
    if (cnt > 0 && cnt < 256)
    {
        fraction = 16 * (4.0 - last)/(final - last) ;
    }
    color = GetExactColor (cnt, fraction);
    
    return color;   
}

// Assembly:
movq %rsi, %rax
fldz
fstpt -0x18(%rsp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
fldt 0x18(%rsp)
fldt 0x8(%rsp)
fld %st(1)
fstpt -0xc(%rsp)
fld %st(0)
leal 0x1(%rcx), %esi
fld %st(0)
fmul %st(1), %st
fld %st(3)
fmul %st(4), %st
fld %st(0)
fadd %st(2), %st
flds 0x3583(%rip)            # 0x93fc
fucompi %st(1), %st
jb 0x5ea3
cmpl $0xff, %esi
ja 0x5ea3
fxch %st(2)
fsubp %st, %st(1)
fxch %st(2)
fadd %st, %st(0)
fmulp %st, %st(4)
fxch %st(1)
fadd %st(2), %st
fldt -0xc(%rsp)
faddp %st, %st(4)
movl %esi, %ecx
fxch %st(1)
fstpt -0x18(%rsp)
jmp 0x5e64
fstp %st(1)
fstp %st(3)
fstp %st(3)
fstp %st(0)
fstp %st(1)
andl $0x0, (%rdx)
movl %esi, (%rax)
cmpl $0xff, %ecx
jae 0x5ef9
fldt -0x18(%rsp)
fld %st(0)
fsubrs 0x3536(%rip)            # 0x93fc
fmuls 0x3534(%rip)            # 0x9400
fxch %st(2)
fsubp %st, %st(1)
fdivrp %st, %st(1)
fnstcw -0x20(%rsp)
movzwl -0x20(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x1e(%rsp)
fldcw -0x1e(%rsp)
fistpl -0x1c(%rsp)
fldcw -0x20(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, (%rdx)
jmp 0x5efd
fstp %st(0)
movl (%rdx), %eax
movl %eax, %edx
jmp 0x5ccc
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::GetParamsByIndex(int, DrawParams&, ShapeParams&)
bool M3DDrawer::GetParamsByIndex (int index, struct DrawParams &dp, struct ShapeParams &sp)
{
    index = (index % PRESET_COUNT);
    
    memcpy (&dp, &rotationArray[index], sizeof (struct DrawParams));
    memcpy (&sp, &spArray[index], sizeof (struct ShapeParams));
    
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %rcx
movl %esi, %eax
movq %rdi, %r14
pushq $0x5
popq %rsi
cltd
idivl %esi
movslq %edx, %r15
imulq $0xd0, %r15, %rsi
addq 0x48(%rdi), %rsi
movl $0xd0, %edx
movq %rcx, %rdi
callq 0x3290
imulq $0x70, %r15, %rsi
addq 0x50(%r14), %rsi
pushq $0xe
popq %rcx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::Paint(int, bool, pointData**, corePointData**)
bool M3DDrawer::Paint (int set_index, bool preview, struct pointData ** pointData,
                      struct corePointData ** corePoints)
{
    bool ret = false;

	if (preview)
    {
		struct DrawParams previewDraw;
		struct ShapeParams previewShape;
        
		memcpy (&previewDraw, &defParams, sizeof (struct DrawParams));
		memcpy (&previewShape, &defShapeParams, sizeof (struct ShapeParams));
        
        GetParamsByIndex (set_index, previewDraw, previewShape);
                
		ret = ShowInPreviewWindow (&previewShape, &previewDraw, pointData, corePoints);
    }
	  else
    {
		// draw_zpr (hdc, &currentShape, &currentParams);
    }

  return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movl %edx, %ebx
testl %edx, %edx
je 0x6389
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
pushq $0x5
popq %rcx
movl %esi, %eax
cltd
idivl %ecx
movslq %edx, %rbp
imulq $0xd0, %rbp, %rsi
addq 0x48(%rdi), %rsi
leaq 0x70(%rsp), %r13
movl $0xd0, %edx
movq %r13, %rdi
callq 0x3290
imulq $0x70, %rbp, %rsi
addq 0x50(%r12), %rsi
pushq $0xe
popq %rcx
movq %rsp, %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x639e
movl %ebx, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::GetMandelColor(DrawParams&, ShapeParams&, long double, long double, int&, int&)
long M3DDrawer::GetMandelColor (struct DrawParams &params, struct ShapeParams &sp,
								long double alpha, long double alp, int &mandel, int &fraction)
{
	long double xCenter = params.xCenter,
    			yCenter = params.yCenter, 
    			xRadius = params.xRadius;
    
	long color = 0;
	long double Re, Im;
    
	double power = POWER_ADD + POWER_RANGE * (alpha/sp.alpha_range);
        
	Re = xRadius * cos (alp + params.sampleRotation);
	Im = xRadius * sin (alp + params.sampleRotation);
    
	double k = pow (POWER_BASE, power * params.stretchRatio);
    
	Re = Re / k;
	Im = Im / k;
    
	Re += xCenter;
	Im += yCenter;
    
	if (params.juliaSet)
    {
		color = Julia(params.juliaRe, params.juliaIm, Re, Im, mandel, fraction);
    }
	else
    {
		color = Strange(Re, Im, mandel, fraction);
    }
    
	return color;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
fldt 0xd0(%rsp)
fld %st(0)
fstpt 0x68(%rsp)
fldt 0xc0(%rsp)
fldt 0x50(%rsi)
fstpt 0x80(%rsp)
fldt 0x60(%rsi)
fstpt 0x8c(%rsp)
fdivl 0x18(%rdx)
fldt 0x70(%rsi)
fstpt 0x4c(%rsp)
fmuls 0x2754(%rip)            # 0x9410
fldz
faddp %st, %st(1)
fstpl 0x60(%rsp)
fadds 0x34(%rsi)
fstpt (%rsp)
callq 0x33a0
fldt 0x4c(%rsp)
fmulp %st, %st(1)
fstpt 0x74(%rsp)
fldt 0x68(%rsp)
fadds 0x34(%r12)
fstpt (%rsp)
callq 0x3520
fldt 0x4c(%rsp)
fmulp %st, %st(1)
fstpt 0x4c(%rsp)
cvtss2sd 0x30(%r12), %xmm1
mulsd 0x60(%rsp), %xmm1
movsd 0x27c7(%rip), %xmm0     # 0x94d0
callq 0x35b0
movsd %xmm0, 0x58(%rsp)
fldl 0x58(%rsp)
fldt 0x74(%rsp)
fdiv %st(1), %st
fldt 0x80(%rsp)
faddp %st, %st(1)
fldt 0x4c(%rsp)
fdivp %st, %st(2)
fldt 0x8c(%rsp)
faddp %st, %st(2)
cmpb $0x1, (%r12)
jne 0x6d6c
fldt 0x10(%r12)
fldt 0x20(%r12)
fxch %st(3)
fstpt 0x30(%rsp)
fxch %st(1)
fstpt 0x20(%rsp)
fxch %st(1)
fstpt 0x10(%rsp)
fstpt (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5d84
jmp 0x6d83
fxch %st(1)
fstpt 0x10(%rsp)
fstpt (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5e46
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::GetPixelCoordinates(double, double, double, long double, long double, long double, double, double&, double&, double&, double&, double&, double&)
void M3DDrawer::GetPixelCoordinates (double y1, double r, double l, long double alpha, long double beta,
                                     long double coef, double slope,
                                     double & x_real, double & y_real, double & z_real,
                                     double & x_norm, double & y_norm, double & z_norm)
{
	double temp_x ;
    
	x_real = r * cos (alpha);
	y_real = y1 ;
	z_real = r * sin (alpha);
    
	// initial values (assuming l=1)
	// x_norm = cos (coef*alp);
	// y_norm = sin (coef*alp);
    
    x_norm = cos (beta);
    y_norm = sin (beta);
    
	z_norm = 0;
    
	// first, slope (around x=0)
	z_norm = -y_norm * sin (slope);
	y_norm = y_norm * cos (slope); // ignoring z it's 0 anyway
    
	// turn by alpha (around y=0)
    
	temp_x = x_norm;
	x_norm = x_norm * cos(alpha) - z_norm * sin (alpha);
	//y_norm = y_norm;
	z_norm = temp_x * sin (alpha) + z_norm * cos (alpha);
    
	// add to centerpoints
	x_real += x_norm * l;
	y_real += y_norm * l;
	z_real += z_norm * l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r15
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movsd %xmm3, 0x38(%rsp)
movsd %xmm2, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movq 0xd0(%rsp), %rbp
fldt 0xb0(%rsp)
fstpt 0x20(%rsp)
fldt 0xa0(%rsp)
fld %st(0)
fstpt 0x44(%rsp)
movsd %xmm1, 0x60(%rsp)
fldl 0x60(%rsp)
fstpt 0x14(%rsp)
fstpt (%rsp)
callq 0x33a0
fldt 0x14(%rsp)
fmulp %st, %st(1)
fstpl (%r12)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, (%r14)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x3520
fldt 0x14(%rsp)
fmulp %st, %st(1)
fstpl (%rbx)
fldt 0x20(%rsp)
fstpt (%rsp)
callq 0x33a0
fstpl (%r13)
fldt 0x20(%rsp)
fstpt (%rsp)
callq 0x3520
fstpl (%r15)
andq $0x0, (%rbp)
movsd (%r15), %xmm0
xorps 0x212a(%rip), %xmm0     # 0x9530
movaps %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x3080
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rbp)
movsd (%r15), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x3620
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%r15)
fldl (%r13)
fstpt 0x38(%rsp)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x33a0
fstpt 0x20(%rsp)
fldl (%rbp)
fstpt 0x14(%rsp)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x3520
fldt 0x14(%rsp)
fmulp %st, %st(1)
fldt 0x38(%rsp)
fldt 0x20(%rsp)
fmulp %st, %st(1)
fsubp %st, %st(1)
fstpl (%r13)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x3520
fstpt 0x20(%rsp)
fldl (%rbp)
fstpt 0x14(%rsp)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x33a0
fldt 0x14(%rsp)
fmulp %st, %st(1)
fldt 0x38(%rsp)
fldt 0x20(%rsp)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpl (%rbp)
movsd (%r13), %xmm0
movsd 0x58(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd (%r12), %xmm0
movsd %xmm0, (%r12)
movsd (%r15), %xmm0
mulsd %xmm1, %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%r14)
mulsd (%rbp), %xmm1
addsd (%rbx), %xmm1
movsd %xmm1, (%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::resetToDefaults()
void AppParams::resetToDefaults()
{
   UserDefaults::sharedInstance()->deleteKey (kIntervalOption);
   UserDefaults::sharedInstance()->deleteKey (kRotationSpeed);
   UserDefaults::sharedInstance()->deleteKey (kDetailLevel);
   UserDefaults::sharedInstance()->deleteKey (kShuffleImages);
   UserDefaults::sharedInstance()->deleteKey (kTransparencyLevel);
   UserDefaults::sharedInstance()->deleteKey (kPaletteType);
   UserDefaults::sharedInstance()->deleteKey (kLightSource);
   UserDefaults::sharedInstance()->deleteKey (kGlossyOption);
   UserDefaults::sharedInstance()->deleteKey (kGlossRandom);

   UserDefaults::sharedInstance()->deleteKey (kLightDistance);
   UserDefaults::sharedInstance()->deleteKey (kLight2Sides);

   for (int i=0; i < PRESET_COUNT; i++)
   {
      char *key = getImageKey (i);
      UserDefaults::sharedInstance()->deleteKey (key);
   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x7b9a
leaq 0x1f03(%rip), %rsi      # 0x95c9
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1eff(%rip), %rsi      # 0x95d9
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1efa(%rip), %rsi      # 0x95e8
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1ef3(%rip), %rsi      # 0x95f5
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1eee(%rip), %rsi      # 0x9604
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1ee7(%rip), %rsi      # 0x9611
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1ee0(%rip), %rsi      # 0x961e
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1ed9(%rip), %rsi      # 0x962b
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1ed1(%rip), %rsi      # 0x9637
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1eca(%rip), %rsi      # 0x9644
movq %rax, %rdi
callq 0x7bde
callq 0x7b9a
leaq 0x1ec5(%rip), %rsi      # 0x9653
movq %rax, %rdi
callq 0x7bde
xorl %ebx, %ebx
leaq 0x5ed1(%rip), %r14      # 0xd670
cmpl $0x5, %ebx
je 0x77bf
movl %ebx, %edi
callq 0x767c
callq 0x7b9a
movq %rax, %rdi
movq %r14, %rsi
callq 0x7bde
incl %ebx
jmp 0x779f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getTransparencyLevel()
int AppParams::getTransparencyLevel ()
{
    int ret = UserDefaults::sharedInstance()->getInteger (kTransparencyLevel, DEF_TRANSPARENCY);
    if (ret < MIN_TRANSP) ret = MIN_TRANSP;
    if (ret > MAX_TRANSP) ret = MAX_TRANSP;

    return ret;
}

// Assembly:
pushq %rax
callq 0x7b9a
leaq 0x1e15(%rip), %rsi      # 0x9604
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x7c8c
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpl $0xa, %eax
pushq $0xa
popq %rcx
cmovgel %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getRotationSpeed()
float AppParams::getRotationSpeed ()
{
    int ret = UserDefaults::sharedInstance()->getInteger (kRotationSpeed, DEF_ROTATION_SPEED);
    if (ret < MIN_SPEED) ret = MIN_SPEED;
    if (ret > MAX_SPEED) ret = MAX_SPEED;
    return (float)ret;
}

// Assembly:
pushq %rax
callq 0x7b9a
leaq 0x1d8a(%rip), %rsi      # 0x95d9
pushq $0x19
popq %rdx
movq %rax, %rdi
callq 0x7c8c
cmpl $0xb, %eax
pushq $0xa
popq %rcx
cmovgel %eax, %ecx
cmpl $0x28, %ecx
pushq $0x28
popq %rax
cmovll %ecx, %eax
cvtsi2ss %eax, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getDetailLevel()
int AppParams::getDetailLevel()
{
   int ret = UserDefaults::sharedInstance()->getInteger (kDetailLevel, DEF_DETAIL_LEVEL);
   if (ret < 0) ret = 0;
   if (ret > 4) ret = 4;

   return ret;
}

// Assembly:
pushq %rax
callq 0x7b9a
leaq 0x1d4f(%rip), %rsi      # 0x95e8
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x7c8c
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpl $0x4, %eax
pushq $0x4
popq %rcx
cmovgel %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getLightDistance()
float AppParams::getLightDistance()
{
    // default return 10. Range 2..30
    float value = 0.1 * UserDefaults::sharedInstance()->getInteger (kLightDistance, 10 * DEF_LIGHT_DISTANCE);

    if (value < MIN_DISTANCE) value = MIN_DISTANCE;
    if (value > MAX_DISTANCE) value = MAX_DISTANCE;

    return value;
}

// Assembly:
pushq %rax
callq 0x7b9a
leaq 0x1cc7(%rip), %rsi      # 0x9644
pushq $0x64
popq %rdx
movq %rax, %rdi
callq 0x7c8c
cvtsi2sd %eax, %xmm0
mulsd 0x191c(%rip), %xmm0     # 0x92b0
cvtsd2ss %xmm0, %xmm0
movss 0x1c0c(%rip), %xmm1     # 0x95ac
maxss %xmm0, %xmm1
movss 0x1c04(%rip), %xmm0     # 0x95b0
minss %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::isPaletteAlternative()
bool AppParams::isPaletteAlternative()
{
    int source = getPalette();

    if (source == PALETTE_STD) { return NO; }
    if (source == PALETTE_ALT) { return YES; }

    int v = rand() & 0x01;

    return (v == 0);
}

// Assembly:
pushq %rax
callq 0x79cc
testl %eax, %eax
je 0x79f9
cmpl $0x1, %eax
jne 0x79fd
movb $0x1, %al
jmp 0x7a07
xorl %eax, %eax
jmp 0x7a07
callq 0x30e0
testb $0x1, %al
sete %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getLightMoving()
bool AppParams::getLightMoving()
{
    int source = getLightSource();

    if (source == LIGHT_MOVING) return true;
    if (source == LIGHT_FIXED) return false;

    int v = rand() & 0x01;

    return (v == 0);
}

// Assembly:
pushq %rax
callq 0x78f4
cmpl $0x1, %eax
je 0x7a1d
testl %eax, %eax
jne 0x7a21
xorl %eax, %eax
jmp 0x7a2b
movb $0x1, %al
jmp 0x7a2b
callq 0x30e0
testb $0x1, %al
sete %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getGlossLevel()
float AppParams::getGlossLevel (void)
{
    // from 0 to 10

    int value = UserDefaults::sharedInstance()->getInteger (kGlossyOption, DEF_GLOSS_LEVEL);

    if (value < MIN_GLOSS) value = MIN_GLOSS;
    if (value > MAX_GLOSS) value = MAX_GLOSS;

    return (float)value;
}

// Assembly:
pushq %rbx
callq 0x7b9a
leaq 0x1b46(%rip), %rsi      # 0x962b
xorl %ebx, %ebx
movq %rax, %rdi
xorl %edx, %edx
callq 0x7c8c
testl %eax, %eax
cmovgl %eax, %ebx
cmpl $0xa, %ebx
pushq $0xa
popq %rax
cmovll %ebx, %eax
cvtsi2ss %eax, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::destroy_slots()
void destroy_slots() {
        if (!capacity_) return;
        for (size_t i = 0; i != capacity_; ++i) {
            if (IsFull(ctrl_[i])) {
                PolicyTraits::destroy(&alloc_ref(), slots_ + i);
            }
        }
        auto layout = MakeLayout(capacity_);
        // Unpoison before returning the memory to the allocator.
        SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
        Deallocate<Layout::Alignment()>(&alloc_ref(), ctrl_, layout.AllocSize());
        ctrl_ = EmptyGroup();
        slots_ = nullptr;
        size_ = 0;
        capacity_ = 0;
        growth_left() = 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x160f
callq 0x161c
leaq 0x28(%rbx), %rdi
movq (%rbx), %rsi
addq $0x3, %rax
andq $-0x4, %rax
leaq (%rax,%rdx,8), %rdx
callq 0x1652
leaq 0x2fe5(%rip), %rax      # 0x45e0
movq %rax, (%rbx)
andq $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: std::pair<phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::iterator, bool> phmap::container_internal::raw_hash_map<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::try_emplace_impl<unsigned int>(unsigned int&&)
std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
        auto res = this->find_or_prepare_insert(k);
        if (res.second)
            this->emplace_at(res.first, std::piecewise_construct,
                             std::forward_as_tuple(std::forward<K>(k)),
                             std::forward_as_tuple(std::forward<Args>(args)...));
        return {this->iterator_at(res.first), res.second};
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x16f2
movq %rax, %r15
movl %edx, %ebp
testb $0x1, %dl
je 0x16c9
leaq 0x8(%rsp), %rcx
movq %r12, (%rcx)
leaq 0x2f37(%rip), %rdx      # 0x45f0
leaq 0x7(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
callq 0x170a
movq (%r14), %rax
addq %r15, %rax
shlq $0x3, %r15
addq 0x8(%r14), %r15
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movb %bpl, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: void phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::emplace_at<std::piecewise_construct_t const&, std::tuple<unsigned int&&>, std::tuple<>>(unsigned long, std::piecewise_construct_t const&, std::tuple<unsigned int&&>&&, std::tuple<>&&)
void emplace_at(size_t i, Args&&... args) {
        PolicyTraits::construct(&alloc_ref(), slots_ + i,
                                std::forward<Args>(args)...);

        assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
               iterator_at(i) &&
               "constructed value does not match the lookup key");
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
leaq (%rax,%rsi,8), %rsi
movq (%rcx), %rax
movl (%rax), %eax
movl %eax, (%rsi)
andl $0x0, 0x4(%rsi)
movq %rsp, %rdi
movq %r14, (%rdi)
callq 0x1f8f
addq (%r14), %rbx
cmpq %rbx, %rax
jne 0x1742
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2bf2(%rip), %rdi      # 0x433b
leaq 0x1991(%rip), %rsi      # 0x30e1
leaq 0x2c64(%rip), %rcx      # 0x43bb
movl $0x803, %edx            # imm = 0x803
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: std::pair<unsigned long, bool> phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::find_or_prepare_insert<unsigned int>(unsigned int const&, unsigned long)
std::pair<size_t, bool> find_or_prepare_insert(const K& key, size_t hash) {
        auto seq = probe(hash);
        while (true) {
            Group g{ctrl_ + seq.offset()};
            for (int i : g.Match(H2(hash))) {
                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
                                          EqualElement<K>{key, eq_ref()},
                                          PolicyTraits::element(slots_ + seq.offset(i)))))
                    return {seq.offset(i), false};
            }
            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) break;
            seq.next();
        }
        return {prepare_insert(hash), true};
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1834
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movl %ebx, %eax
andb $0x7f, %al
movzbl %al, %eax
movd %eax, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movq (%r12), %rsi
movq 0x8(%r12), %rdi
movl (%r15), %r8d
movq 0x10(%r12), %r9
movdqa 0x1863(%rip), %xmm1     # 0x3020
movdqu (%rcx,%rdi), %xmm2
movdqa %xmm0, %xmm3
pcmpeqb %xmm2, %xmm3
pmovmskb %xmm3, %r10d
testl %r10d, %r10d
je 0x17f0
bsfl %r10d, %eax
addq %rdi, %rax
andq %rsi, %rax
cmpl %r8d, (%rdx,%rax,8)
je 0x1816
leal -0x1(%r10), %eax
andl %r10d, %eax
movl %eax, %r10d
jmp 0x17cf
pcmpeqb %xmm1, %xmm2
pmovmskb %xmm2, %eax
testl %eax, %eax
jne 0x1824
addq %r9, %rdi
addq $0x10, %rdi
addq $0x10, %r9
movq %r9, 0x10(%rsp)
andq %rsi, %rdi
movq %rdi, 0x8(%rsp)
jmp 0x17bd
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1850
movb $0x1, %dl
jmp 0x1818
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::prepare_insert(unsigned long)
size_t prepare_insert(size_t hash) PHMAP_ATTRIBUTE_NOINLINE {
        auto target = find_first_non_full(hash);
        if (PHMAP_PREDICT_FALSE(growth_left() == 0 &&
                               !IsDeleted(ctrl_[target.offset]))) {
            rehash_and_grow_if_necessary();
            target = find_first_non_full(hash);
        }
        ++size_;
        growth_left() -= IsEmpty(ctrl_[target.offset]);
        set_ctrl(target.offset, H2(hash));
        infoz_.RecordInsert(hash, target.probe_length);
        return target.offset;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x18fe
movq %rax, %r15
movq (%r14), %rcx
movq 0x28(%r14), %rax
testq %rax, %rax
jne 0x1878
cmpb $-0x2, (%rcx,%r15)
jne 0x18a6
xorl %eax, %eax
incq 0x10(%r14)
xorl %edx, %edx
cmpb $-0x80, (%rcx,%r15)
sete %dl
subq %rdx, %rax
movq %rax, 0x28(%r14)
andl $0x7f, %ebx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x19e2
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1992
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18fe
movq %rax, %r15
movq (%r14), %rcx
movq 0x28(%r14), %rax
jmp 0x1878
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::find_first_non_full(unsigned long)
FindInfo find_first_non_full(size_t hash) {
        auto seq = probe(hash);
        while (true) {
            Group g{ctrl_ + seq.offset()};
            auto mask = g.MatchEmptyOrDeleted();
            if (mask) {
                return {seq.offset(mask.LowestBitSet()), seq.index()};
            }
            assert(seq.index() < capacity_ && "full table!");
            seq.next();
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1834
movq (%rbx), %rsi
movq 0x18(%rbx), %rdi
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
addq $0x10, %r8
leaq -0x10(%r8), %rdx
movdqu (%rsi,%rcx), %xmm0
pcmpeqd %xmm1, %xmm1
pcmpgtb %xmm0, %xmm1
pmovmskb %xmm1, %r9d
testl %r9d, %r9d
jne 0x1961
cmpq %rdi, %rdx
jae 0x1973
movq %r8, 0x10(%rsp)
addq %r8, %rcx
andq %rax, %rcx
movq %rcx, 0x8(%rsp)
jmp 0x192b
bsfl %r9d, %esi
addq %rsi, %rcx
andq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1a62(%rip), %rdi      # 0x33dc
leaq 0x1760(%rip), %rsi      # 0x30e1
leaq 0x1a7d(%rip), %rcx      # 0x3405
movl $0x7be, %edx            # imm = 0x7BE
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::rehash_and_grow_if_necessary()
void rehash_and_grow_if_necessary() {
        if (capacity_ == 0) {
            resize(1);
        } else if (size() <= CapacityToGrowth(capacity()) / 2) {
            // Squash DELETED without growing if there is enough capacity.
            drop_deletes_without_resize();
        } else {
            // Otherwise grow the container.
            resize(capacity_ * 2 + 1);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x19c1
movq 0x10(%rbx), %r14
callq 0x1b20
shrq %rax
cmpq %rax, %r14
jbe 0x19d3
movq 0x18(%rbx), %rax
leaq 0x1(,%rax,2), %rsi
jmp 0x19c4
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a24
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b5c
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::set_ctrl(unsigned long, signed char)
void set_ctrl(size_t i, ctrl_t h) {
        assert(i < capacity_);

        if (IsFull(h)) {
            SanitizerUnpoisonObject(slots_ + i);
        } else {
            SanitizerPoisonObject(slots_ + i);
        }

        ctrl_[i] = h;
        ctrl_[((i - Group::kWidth) & capacity_) + 1 +
              ((Group::kWidth - 1) & capacity_)] = h;
    }

// Assembly:
cmpq %rsi, 0x18(%rdi)
jbe 0x1a04
movq (%rdi), %rax
movb %dl, (%rax,%rsi)
addq $-0x10, %rsi
movq 0x18(%rdi), %rax
andq %rax, %rsi
andl $0xf, %eax
addq (%rdi), %rsi
movb %dl, 0x1(%rax,%rsi)
retq
pushq %rax
leaq 0x2762(%rip), %rdi      # 0x416e
leaq 0x16ce(%rip), %rsi      # 0x30e1
leaq 0x2762(%rip), %rcx      # 0x417c
movl $0x81e, %edx            # imm = 0x81E
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::initialize_slots()
void initialize_slots() {
        assert(capacity_);
        if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value && 
            slots_ == nullptr) {
            infoz_ = Sample();
        }

        auto layout = MakeLayout(capacity_);
        char* mem = static_cast<char*>(
            Allocate<Layout::Alignment()>(&alloc_ref(), layout.AllocSize()));
        ctrl_ = reinterpret_cast<ctrl_t*>(layout.template Pointer<0>(mem));
        slots_ = layout.template Pointer<1>(mem);
        reset_ctrl();
        reset_growth_left();
        infoz_.RecordStorageChanged(size_, capacity_);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1d8d
callq 0x161c
movq %rsp, %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x28(%rbx), %rdi
addq $0x3, %rax
andq $-0x4, %rax
leaq (%rax,%rdx,8), %rsi
callq 0x1dac
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1e08
movq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e32
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
movq 0x18(%rbx), %rdx
addq $0x10, %rdx
movl $0x80, %esi
callq 0x1080
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movb $-0x1, (%rax,%rcx)
movq %rbx, %rdi
callq 0x1e6a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x23de(%rip), %rdi      # 0x4172
leaq 0x1346(%rip), %rsi      # 0x30e1
leaq 0x19fc(%rip), %rcx      # 0x379e
movl $0x70b, %edx            # imm = 0x70B
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: void* phmap::container_internal::Allocate<4ul, std::allocator<std::pair<unsigned int const, unsigned int>>>(std::allocator<std::pair<unsigned int const, unsigned int>>*, unsigned long)
void* Allocate(Alloc* alloc, size_t n) {
  static_assert(Alignment > 0, "");
  assert(n && "n must be positive");
  struct alignas(Alignment) M {};
  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
  A mem_alloc(*alloc);
  void* p = AT::allocate(mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
         "allocator does not respect alignment");
  return p;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1dca
addq $0x3, %rsi
shrq $0x2, %rsi
leaq 0x7(%rsp), %rdi
callq 0x1e82
testb $0x3, %al
jne 0x1de9
popq %rcx
retq
leaq 0x14dc(%rip), %rdi      # 0x32ad
leaq 0x1309(%rip), %rsi      # 0x30e1
leaq 0x1b78(%rip), %rcx      # 0x3957
movl $0x2b4, %edx            # imm = 0x2B4
callq 0x10a0
leaq 0x1bf9(%rip), %rdi      # 0x39e9
leaq 0x12ea(%rip), %rsi      # 0x30e1
leaq 0x1b59(%rip), %rcx      # 0x3957
movl $0x2bb, %edx            # imm = 0x2BB
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap_base.h
// Function: std::conditional<std::is_const<char>::value, std::tuple_element<1ul, std::tuple<signed char, phmap::container_internal::map_slot_type<unsigned int, unsigned int>>>::type const, std::tuple_element<1ul, std::tuple<signed char, phmap::container_internal::map_slot_type<unsigned int, unsigned int>>>::type>::type* phmap::container_internal::internal_layout::LayoutImpl<std::tuple<signed char, phmap::container_internal::map_slot_type<unsigned int, unsigned int>>, phmap::integer_sequence<unsigned long, 0ul, 1ul>, phmap::integer_sequence<unsigned long, 0ul, 1ul>>::Pointer<1ul, char>(char*) const
CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
        using C = typename std::remove_const<Char>::type;
        static_assert(
            std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
            std::is_same<C, signed char>(),
            "The argument must be a pointer to [const] [signed|unsigned] char");
        constexpr size_t alignment = Alignment();
        (void)alignment;
        assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
        return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
    }

// Assembly:
testb $0x3, %sil
jne 0x1e4a
movq (%rdi), %rax
addq $0x3, %rax
andq $-0x4, %rax
addq %rax, %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0x1bf1(%rip), %rdi      # 0x3a43
leaq 0x1c1a(%rip), %rsi      # 0x3a73
leaq 0x1e3f(%rip), %rcx      # 0x3c9f
movl $0xfbe, %edx            # imm = 0xFBE
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::ConvertDeletedToEmptyAndFullToDeleted(signed char*, unsigned long)
inline void ConvertDeletedToEmptyAndFullToDeleted(
    ctrl_t* ctrl, size_t capacity) 
{
    assert(ctrl[capacity] == kSentinel);
    assert(IsValidCapacity(capacity));
    for (ctrl_t* pos = ctrl; pos != ctrl + capacity + 1; pos += Group::kWidth) {
        Group{pos}.ConvertSpecialToEmptyAndFullToDeleted(pos);
    }
    // Copy the cloned ctrl bytes.
    std::memcpy(ctrl + capacity + 1, ctrl, Group::kWidth);
    ctrl[capacity] = kSentinel;
}

// Assembly:
pushq %rax
cmpb $-0x1, (%rdi,%rsi)
jne 0x1f12
testq %rsi, %rsi
je 0x1f31
leaq 0x1(%rsi), %rax
movq %rax, %rcx
andq %rsi, %rcx
jne 0x1f31
addq %rdi, %rsi
leaq 0x1(%rsi), %rcx
xorl %edx, %edx
movdqa 0x1156(%rip), %xmm0     # 0x3030
movdqa 0x115e(%rip), %xmm1     # 0x3040
cmpq %rdx, %rax
je 0x1f07
movdqu (%rdi,%rdx), %xmm2
pxor %xmm3, %xmm3
pcmpgtb %xmm2, %xmm3
pand %xmm0, %xmm3
pxor %xmm1, %xmm3
movdqu %xmm3, (%rdi,%rdx)
addq $0x10, %rdx
jmp 0x1ee2
movups (%rdi), %xmm0
movups %xmm0, (%rcx)
movb $-0x1, (%rsi)
popq %rax
retq
leaq 0x21e1(%rip), %rdi      # 0x40fa
leaq 0x11c1(%rip), %rsi      # 0x30e1
leaq 0x21ef(%rip), %rcx      # 0x4116
movl $0x1be, %edx            # imm = 0x1BE
callq 0x10a0
leaq 0x118f(%rip), %rdi      # 0x30c7
leaq 0x11a2(%rip), %rsi      # 0x30e1
leaq 0x21d0(%rip), %rcx      # 0x4116
movl $0x1bf, %edx            # imm = 0x1BF
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::iterator phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::find<unsigned int>(unsigned int const&, unsigned long)
iterator find(const key_arg<K>& key, size_t hash) {
        auto seq = probe(hash);
        while (true) {
            Group g{ctrl_ + seq.offset()};
            for (int i : g.Match(H2(hash))) {
                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
                                          EqualElement<K>{key, eq_ref()},
                                          PolicyTraits::element(slots_ + seq.offset(i)))))
                    return iterator_at(seq.offset(i));
            }
            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) 
                return end();
            seq.next();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1834
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
andb $0x7f, %r14b
movzbl %r14b, %edx
movd %edx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl (%r15), %edi
movq 0x10(%r12), %r8
movdqa 0xff0(%rip), %xmm1      # 0x3020
movdqu (%rax,%rsi), %xmm2
movdqa %xmm0, %xmm3
pcmpeqb %xmm2, %xmm3
pmovmskb %xmm3, %r9d
testl %r9d, %r9d
je 0x2063
bsfl %r9d, %r10d
addq %rsi, %r10
andq %rdx, %r10
cmpl %edi, (%rcx,%r10,8)
je 0x208b
leal -0x1(%r9), %r10d
andl %r9d, %r10d
movl %r10d, %r9d
jmp 0x2042
pcmpeqb %xmm1, %xmm2
pmovmskb %xmm2, %r9d
testl %r9d, %r9d
jne 0x209e
addq %r8, %rsi
addq $0x10, %rsi
addq $0x10, %r8
movq %r8, 0x10(%rsp)
andq %rdx, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2030
leaq (%rcx,%r10,8), %rdx
addq %r10, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%rbx), %r10
jmp 0x208f
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: vector_for_label_ascii(int)
double *vector_for_label_ascii(int label) {
	double *vec = new double[ASCII_LENGTH];
	unsigned char c = (unsigned char)label + 48;
	for(int i=0; i < ASCII_LENGTH; i++) {
		vec[i] = (double)(c & 1);
		c = c >> 1;
	}
	return vec;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x40
popq %rdi
callq 0x2030
addl $0x30, %ebx
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x24aa
movl %ebx, %edx
andl $0x1, %edx
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%rax,%rcx,8)
shrl %ebx
andl $0x7f, %ebx
incq %rcx
jmp 0x248c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: label_for_vector_ascii(double*)
int label_for_vector_ascii(double *vec) {
	unsigned char label = 0;
	for(int i=0; i < ASCII_LENGTH; i++) {
		label |= int(vec[i] + 0.5) << i;
	}
	return label - 48;
}

// Assembly:
xorl %ecx, %ecx
movsd 0x1b52(%rip), %xmm0     # 0x4008
xorl %eax, %eax
cmpq $0x8, %rcx
je 0x24d4
movsd (%rdi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll %cl, %edx
orb %dl, %al
incq %rcx
jmp 0x24b8
movzbl %al, %eax
addl $-0x30, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: vector_for_label_packed(int)
double *vector_for_label_packed(int label) {
	double *vec = new double[PACKED_LENGTH];
	char c = (char)label;
	for(int i=0; i < PACKED_LENGTH; i++) {
		vec[i] = (double)(c & 1);
		c = c >> 1;
	}
	return vec;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x20
popq %rdi
callq 0x2030
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x2506
movl %ebx, %edx
andl $0x1, %edx
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsbl %bl, %ebx
sarl %ebx
incq %rcx
jmp 0x24e8
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: label_for_vector_packed(double*)
int label_for_vector_packed(double *vec) {
	int label = 0;
	for(int i=0; i < PACKED_LENGTH; i++) {
		label |= int(vec[i] + 0.5) << i;
	}
	return label;
}

// Assembly:
xorl %ecx, %ecx
movsd 0x1af6(%rip), %xmm0     # 0x4008
xorl %eax, %eax
cmpq $0x4, %rcx
je 0x2530
movsd (%rdi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll %cl, %edx
orl %edx, %eax
incq %rcx
jmp 0x2514
retq
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: vector_for_label_full(int)
double *vector_for_label_full(int label) {
	double *vec = new double[FULL_LENGTH];
	for(int i=0; i < FULL_LENGTH; i++) {
		vec[i] = (i == label) ? 1.0 : 0.0;
	}
	return vec;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x50
popq %rdi
callq 0x2030
movl %ebx, %ecx
xorl %edx, %edx
movsd 0x1ac8(%rip), %xmm0     # 0x4010
cmpq $0xa, %rdx
je 0x2563
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x2559
xorps %xmm1, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x2548
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: label_for_vector_full(double*)
int label_for_vector_full(double *vec) {
	double max = 0.0;
	int maxi = 0;
	for(int i=0; i < FULL_LENGTH; i++) {
		if(vec[i] > max) {
			max = vec[i];
			maxi = i;
		}
	}
	return maxi;
}

// Assembly:
xorl %ecx, %ecx
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0xa, %rcx
je 0x258c
movsd (%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
cmoval %ecx, %eax
maxsd %xmm0, %xmm1
incq %rcx
movapd %xmm1, %xmm0
jmp 0x256d
retq
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: print_vec(double*, int)
void print_vec(double *vec, int len) {
	using namespace std;
	cout << "Vec: ";
	for(int i=0; i < len; i++) {
		cout << int(vec[i] + 0.5) << " ";
	}
	cout << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x3a2e(%rip), %r15      # 0x5fd0
leaq 0x1a87(%rip), %rsi      # 0x4030
movq %r15, %rdi
callq 0x2100
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
leaq 0x1b21(%rip), %r12      # 0x40e2
cmpq %r13, %rbx
je 0x25f0
movsd (%r14,%r13,8), %xmm0
addsd 0x1a34(%rip), %xmm0     # 0x4008
cvttsd2si %xmm0, %esi
movq %r15, %rdi
callq 0x2190
movq %rax, %rdi
movq %r12, %rsi
callq 0x2100
incq %r13
jmp 0x25c1
movq 0x39d9(%rip), %rdi      # 0x5fd0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::~DataSet()
DataSet::~DataSet() {
	for(int i=0; i < num_entries; i++) {
		delete[] image_data[i];
		delete[] label_data[i];
	}
	delete[] image_data;
	delete[] label_data;
	delete[] labels;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x10(%rbx), %rdi
cmpq %rax, %r14
jge 0x2ab3
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x2a9c
callq 0x2150
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x2aae
callq 0x2150
incq %r14
jmp 0x2a82
testq %rdi, %rdi
je 0x2abd
callq 0x2150
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2acb
callq 0x2150
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x2ae0
popq %rbx
popq %r14
jmp 0x2150
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::label_for_vector(double*)
int DataSet::label_for_vector(double *vec) {
	int label = -1;
	switch(label_data_length) {
		case ASCII_LENGTH:
			label = label_for_vector_ascii(vec);
			break;
		case PACKED_LENGTH:
			label = label_for_vector_packed(vec);
			break;
		case FULL_LENGTH:
			label = label_for_vector_full(vec);
			break;
	}
	return label;
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl $0x4, %eax
je 0x2b36
cmpl $0xa, %eax
je 0x2b2e
cmpl $0x8, %eax
jne 0x2b3e
movq %rsi, %rdi
jmp 0x24ac
movq %rsi, %rdi
jmp 0x2565
movq %rsi, %rdi
jmp 0x2508
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::print_image(int, int, int)
void DataSet::print_image(int n, int width, int height) {
	using namespace std;
	
	double *img = this->image_vector(n);
	for(int y=0; y < height; y ++) {
		for(int x=0; x < width; x ++) {
			double pixel = img[y * height + x];
			if(pixel == 0.0) {
				cout << "  ";
			} else if(pixel < 0.9) {
				cout << "..";
			} else {
				cout << "##";
			}
		}
		cout << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq 0x10(%rdi), %rax
movslq %esi, %rdx
xorl %esi, %esi
testl %ebx, %ebx
cmovlel %esi, %ebx
movslq %ecx, %rcx
testl %ecx, %ecx
movl $0x0, %edi
cmovgl %ecx, %edi
movq %rdi, 0x8(%rsp)
movq (%rax,%rdx,8), %rbp
shlq $0x3, %rcx
movq %rcx, (%rsp)
movq 0x344b(%rip), %r14      # 0x5fd0
leaq 0x155b(%rip), %r13      # 0x40e7
leaq 0x154e(%rip), %r15      # 0x40e1
cmpq 0x8(%rsp), %rsi
je 0x2bfe
movq %rsi, 0x10(%rsp)
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x2be8
movsd (%rbp,%r12,8), %xmm0
movsd 0x146a(%rip), %xmm1     # 0x4020
ucomisd %xmm0, %xmm1
movq %r13, %rax
leaq 0x1520(%rip), %rcx      # 0x40e4
cmovaq %rcx, %rax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
movq %r15, %rsi
cmovneq %rax, %rsi
cmovpq %rax, %rsi
movq %r14, %rdi
callq 0x2100
incq %r12
jmp 0x2ba2
movq %r14, %rdi
callq 0x2090
movq 0x10(%rsp), %rsi
incq %rsi
addq (%rsp), %rbp
jmp 0x2b93
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop