LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
fldt 0x38(%rsp)
fldt 0x28(%rsp)
fldt 0x18(%rsp)
fstpt -0xc(%rsp)
fld %st(0)
fmul %st(1), %st
fld %st(2)
fmul %st(3), %st
fld %st(0)
fadd %st(2), %st
xorl %eax, %eax
flds 0x33f0(%rip)            # 0x93ec
fucompi %st(1), %st
fldt 0x8(%rsp)
fstpt -0x18(%rsp)
fldz
jae 0x601e
fstp %st(2)
fstp %st(4)
fstp %st(2)
fstp %st(0)
fldz
fldz
fldz
fldz
fldz
jmp 0x6099
fstp %st(0)
xorl %ecx, %ecx
flds 0x33c4(%rip)            # 0x93ec
fldz
fxch %st(2)
fxch %st(6)
fxch %st(2)
fxch %st(5)
fxch %st(3)
fxch %st(4)
fxch %st(2)
fxch %st(3)
fxch %st(2)
fstp %st(5)
fxch %st(4)
fsubp %st, %st(3)
fadd %st, %st(0)
fmulp %st, %st(1)
fldt -0x18(%rsp)
faddp %st, %st(2)
fldt -0xc(%rsp)
faddp %st, %st(1)
fld %st(1)
fmul %st(2), %st
fld %st(1)
fmul %st(2), %st
fld %st(0)
fadd %st(2), %st
fxch %st(5)
fucomi %st(5), %st
leal 0x1(%rcx), %eax
jb 0x607f
cmpl $0xff, %ecx
movl %eax, %ecx
fxch %st(5)
fxch %st(6)
fxch %st(5)
fxch %st(1)
fxch %st(4)
fxch %st(2)
jb 0x603c
jmp 0x6099
fstp %st(1)
fstp %st(2)
fstp %st(2)
fstp %st(0)
fstp %st(0)
fldz
fldz
fldz
fldz
fldz
fxch %st(5)
fxch %st(6)
fxch %st(5)
fstp %st(4)
fstp %st(2)
fstp %st(0)
fstp %st(0)
fstp %st(0)
movl $0x0, (%rdx)
movl %eax, (%rsi)
leal -0x1(%rax), %ecx
cmpl $0xfe, %ecx
ja 0x60f4
fld %st(0)
fsubrs 0x332e(%rip)            # 0x93ec
fmuls 0x332c(%rip)            # 0x93f0
fxch %st(2)
fsubp %st, %st(1)
fdivrp %st, %st(1)
fnstcw -0x20(%rsp)
movzwl -0x20(%rsp), %ecx
orl $0xc00, %ecx            # imm = 0xC00
movw %cx, -0x1e(%rsp)
fldcw -0x1e(%rsp)
fistpl -0x1c(%rsp)
fldcw -0x20(%rsp)
movl -0x1c(%rsp), %ecx
movl %ecx, (%rdx)
fldz
fldz
fstp %st(1)
fstp %st(0)
movl (%rdx), %edx
movl %eax, %esi
jmp 0x5f1c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
fldt 0x18(%rsp)
fldt 0x8(%rsp)
fld %st(0)
fmul %st(1), %st
fld %st(2)
fmul %st(3), %st
fld %st(0)
fadd %st(2), %st
xorl %eax, %eax
fldz
flds 0x32cc(%rip)            # 0x93ec
fucompi %st(2), %st
jae 0x6134
fstp %st(5)
fstp %st(2)
fstp %st(0)
fstp %st(1)
fxch %st(1)
fstpt -0x18(%rsp)
jmp 0x61a1
fstp %st(0)
xorl %ecx, %ecx
fld %st(3)
fstpt -0xc(%rsp)
fld %st(4)
fxch %st(1)
fxch %st(5)
fxch %st(1)
fxch %st(4)
fxch %st(1)
fxch %st(3)
fxch %st(2)
fxch %st(1)
fxch %st(5)
fstpt -0x18(%rsp)
fsubrp %st, %st(1)
fxch %st(3)
fadd %st, %st(0)
fmulp %st, %st(2)
fldt -0xc(%rsp)
faddp %st, %st(3)
fld %st(0)
fxch %st(2)
faddp %st, %st(1)
fld %st(2)
fmul %st(3), %st
fld %st(1)
fmul %st(2), %st
fld %st(0)
fadd %st(2), %st
flds 0x3270(%rip)            # 0x93ec
fucompi %st(1), %st
leal 0x1(%rcx), %eax
jb 0x6197
cmpl $0xff, %ecx
movl %eax, %ecx
fxch %st(5)
fxch %st(3)
fxch %st(4)
fxch %st(3)
jb 0x6150
jmp 0x61ab
fstp %st(4)
fstp %st(2)
fstp %st(0)
fstp %st(0)
fstp %st(1)
fldz
fldz
fldz
fldz
fldz
fstp %st(4)
fstp %st(2)
fstp %st(0)
fstp %st(0)
fstp %st(0)
movl $0x0, (%rdx)
movl %eax, (%rsi)
leal -0x1(%rax), %ecx
cmpl $0xfe, %ecx
ja 0x6208
fldt -0x18(%rsp)
fld %st(0)
fsubrs 0x3218(%rip)            # 0x93ec
fmuls 0x3216(%rip)            # 0x93f0
fxch %st(2)
fsubp %st, %st(1)
fdivrp %st, %st(1)
fnstcw -0x20(%rsp)
movzwl -0x20(%rsp), %ecx
orl $0xc00, %ecx            # imm = 0xC00
movw %cx, -0x1e(%rsp)
fldcw -0x1e(%rsp)
fistpl -0x1c(%rsp)
fldcw -0x20(%rsp)
movl -0x1c(%rsp), %ecx
movl %ecx, (%rdx)
fldz
fstp %st(0)
movl (%rdx), %edx
movl %eax, %esi
jmp 0x5f1c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rax
movq %rdi, %r14
movslq %esi, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x21, %rdx
addl %esi, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
movslq %ecx, %r15
imulq $0xd0, %r15, %rsi
addq 0x48(%rdi), %rsi
movl $0xd0, %edx
movq %rax, %rdi
callq 0x3280
imulq $0x70, %r15, %rsi
addq 0x50(%r14), %rsi
movl $0xe, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x676d
movq %r8, %r14
movq %rcx, %r15
movl %esi, %r13d
movq %rdi, %r12
leaq 0x5c7a(%rip), %rsi      # 0xc360
movq %rsp, %rdi
movl $0xd0, %edx
callq 0x3280
leaq 0x5d36(%rip), %rsi      # 0xc430
leaq 0xd0(%rsp), %rbp
movl $0xe, %ecx
movq %rbp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movslq %r13d, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movslq %eax, %r13
imulq $0xd0, %r13, %rsi
addq 0x48(%r12), %rsi
movl $0xd0, %edx
movq %rsp, %rdi
callq 0x3280
imulq $0x70, %r13, %rsi
addq 0x50(%r12), %rsi
movl $0xe, %ecx
movq %rbp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, %rdi
movq %rbp, %rsi
movq %rsp, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x6782
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_O1/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 0x1fa8(%rip)            # 0x9400
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 0x3510
fldt 0x4c(%rsp)
fmulp %st, %st(1)
fstpt 0x4c(%rsp)
cvtss2sd 0x30(%r12), %xmm1
mulsd 0x60(%rsp), %xmm1
movsd 0x201b(%rip), %xmm0     # 0x94c0
callq 0x35a0
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 0x7508
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 0x5fd8
jmp 0x751f
fxch %st(1)
fstpt 0x10(%rsp)
fstpt (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6102
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3510
fldt 0x14(%rsp)
fmulp %st, %st(1)
fstpl (%rbx)
fldt 0x20(%rsp)
fstpt (%rsp)
callq 0x33a0
fstpl (%r13)
fldt 0x20(%rsp)
fstpt (%rsp)
callq 0x3510
fstpl (%r15)
movq $0x0, (%rbp)
movsd (%r15), %xmm0
xorps 0x1923(%rip), %xmm0     # 0x94e0
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 0x3610
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 0x3510
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 0x3510
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::SetPointColor(unsigned char*, long, int, int)
void M3DDrawer::SetPointColor (unsigned char *array, long which, int mandel, int fraction)
{
	long index;
    
	if (0 == (which & 1)) // even
    {
		index = (which * 3)>>1;
		array [index] = mandel;
		array [index+1] = (array [index+1] & 0xf0) | (fraction & 0x0f);
    }
	else
    {
		index = (which * 3 + 1)>>1;
		array [index] = mandel;
		array [index - 1] = (array [index - 1] & 0x0f) | ((fraction << 4) & 0xf0);
    }	
}

// Assembly:
testb $0x1, %dl
jne 0x7e3c
movq %rdx, %rax
sarq %rax
addq %rax, %rsi
movb %cl, (%rdx,%rsi)
movb 0x1(%rdx,%rsi), %al
andb $-0x10, %al
andb $0xf, %r8b
orb %al, %r8b
movb %r8b, 0x1(%rdx,%rsi)
retq
leaq (%rdx,%rdx,2), %rax
incq %rax
sarq %rax
movb %cl, (%rsi,%rax)
movb -0x1(%rsi,%rax), %cl
andb $0xf, %cl
shlb $0x4, %r8b
orb %cl, %r8b
movb %r8b, -0x1(%rsi,%rax)
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
callq 0x8486
leaq 0x16c7(%rip), %rsi      # 0x9571
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x16c3(%rip), %rsi      # 0x9581
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x16be(%rip), %rsi      # 0x9590
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x16b7(%rip), %rsi      # 0x959d
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x16b2(%rip), %rsi      # 0x95ac
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x16ab(%rip), %rsi      # 0x95b9
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x16a4(%rip), %rsi      # 0x95c6
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x169d(%rip), %rsi      # 0x95d3
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x1695(%rip), %rsi      # 0x95df
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x168e(%rip), %rsi      # 0x95ec
movq %rax, %rdi
callq 0x84d0
callq 0x8486
leaq 0x1689(%rip), %rsi      # 0x95fb
movq %rax, %rdi
callq 0x84d0
leaq 0x46df(%rip), %rbx      # 0xc660
leaq 0x15e0(%rip), %r14      # 0x9568
xorl %ebp, %ebp
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3170
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
callq 0x8486
movq %rax, %rdi
movq %rbx, %rsi
callq 0x84d0
incl %ebp
cmpl $0x5, %ebp
jne 0x7f8a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8486
leaq 0x15c1(%rip), %rsi      # 0x95ac
movq %rax, %rdi
movl $0x1, %edx
callq 0x85c2
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpl $0xa, %eax
movl $0xa, %ecx
cmovgel %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8486
leaq 0x150c(%rip), %rsi      # 0x9581
movq %rax, %rdi
movl $0x19, %edx
callq 0x85c2
cmpl $0xb, %eax
movl $0xa, %ecx
cmovgel %eax, %ecx
cmpl $0x28, %ecx
movl $0x28, %eax
cmovll %ecx, %eax
cvtsi2ss %eax, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8486
leaq 0x14cb(%rip), %rsi      # 0x9590
movq %rax, %rdi
movl $0x1, %edx
callq 0x85c2
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpl $0x4, %eax
movl $0x4, %ecx
cmovgel %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8486
leaq 0x1419(%rip), %rsi      # 0x95ec
movq %rax, %rdi
movl $0x64, %edx
callq 0x85c2
cvtsi2sd %eax, %xmm0
mulsd 0x10c4(%rip), %xmm0     # 0x92b0
cvtsd2ss %xmm0, %xmm0
movss 0x135c(%rip), %xmm1     # 0x9554
maxss %xmm0, %xmm1
movss 0x1354(%rip), %xmm0     # 0x9558
minss %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8486
leaq 0x136c(%rip), %rsi      # 0x95b9
movq %rax, %rdi
movl $0x2, %edx
callq 0x85c2
testl %eax, %eax
je 0x8267
cmpl $0x1, %eax
jne 0x826b
movb $0x1, %al
jmp 0x8275
xorl %eax, %eax
jmp 0x8275
callq 0x30e0
testb $0x1, %al
sete %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8486
leaq 0x1341(%rip), %rsi      # 0x95c6
movq %rax, %rdi
movl $0x2, %edx
callq 0x85c2
cmpl $0x1, %eax
je 0x829f
testl %eax, %eax
jne 0x82a3
xorl %eax, %eax
jmp 0x82ad
movb $0x1, %al
jmp 0x82ad
callq 0x30e0
testb $0x1, %al
sete %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8486
leaq 0x125a(%rip), %rsi      # 0x95d3
xorl %ebx, %ebx
movq %rax, %rdi
xorl %edx, %edx
callq 0x85c2
testl %eax, %eax
cmovgl %eax, %ebx
cmpl $0xa, %ebx
movl $0xa, %eax
cmovll %ebx, %eax
cvtsi2ss %eax, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1715
callq 0x1722
leaq 0x28(%rbx), %rdi
movq (%rbx), %rsi
addq $0x3, %rax
andq $-0x4, %rax
leaq (%rax,%rdx,8), %rdx
callq 0x1758
leaq 0x2cbf(%rip), %rax      # 0x43c0
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %rbx
movl (%rdx), %eax
movabsq $-0x21a0462d9cfba717, %rcx # imm = 0xDE5FB9D2630458E9
mulq %rcx
movq %rdi, %r14
addq %rax, %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x186e
movq %rax, %r12
movl %edx, %ebp
testb $0x1, %dl
je 0x17e1
leaq 0x8(%rsp), %rcx
movq %r15, (%rcx)
leaq 0x2bff(%rip), %rdx      # 0x43d0
leaq 0x7(%rsp), %r8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x180a
movq (%rbx), %rax
addq %r12, %rax
shlq $0x3, %r12
addq 0x8(%rbx), %r12
movq %rax, (%r14)
movq %r12, 0x8(%r14)
movb %bpl, 0x10(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movabsq $-0x21a0462d9cfba717, %rcx # imm = 0xDE5FB9D2630458E9
mulq %rcx
movl $0x0, 0x4(%rsi)
addq %rax, %rdx
callq 0x1fc4
addq (%r14), %rbx
cmpq %rbx, %rax
jne 0x184f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x28c8(%rip), %rdi      # 0x411e
leaq 0x1884(%rip), %rsi      # 0x30e1
leaq 0x293a(%rip), %rcx      # 0x419e
movl $0x803, %edx            # imm = 0x803
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19e2
movq %rax, %r15
cmpq $0x0, 0x28(%r14)
jne 0x199c
movq (%r14), %rax
cmpb $-0x2, (%rax,%r15)
jne 0x19ca
incq 0x10(%r14)
movq (%r14), %rax
xorl %ecx, %ecx
cmpb $-0x80, (%rax,%r15)
sete %cl
subq %rcx, 0x28(%r14)
andl $0x7f, %ebx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x1ae0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1a7c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19e2
movq %rax, %r15
jmp 0x199c
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq 0x18(%rdi), %rcx
leaq 0x1(%rcx), %rax
testq %rcx, %rax
jne 0x1a5d
shrq $0x7, %rsi
andq %rcx, %rsi
movq (%rdi), %rdi
xorl %r8d, %r8d
movdqu (%rdi,%rsi), %xmm0
pcmpeqd %xmm1, %xmm1
pcmpgtb %xmm0, %xmm1
pmovmskb %xmm1, %r9d
testl %r9d, %r9d
je 0x1a23
bsfl %r9d, %eax
addq %rsi, %rax
andq %rcx, %rax
movq %r8, %rdx
jmp 0x1a36
cmpq %rcx, %r8
jae 0x1a3e
addq %r8, %rsi
addq $0x10, %rsi
addq $0x10, %r8
andq %rcx, %rsi
testw %r9w, %r9w
je 0x19fd
popq %rcx
retq
leaq 0x1997(%rip), %rdi      # 0x33dc
leaq 0x1695(%rip), %rsi      # 0x30e1
leaq 0x19b2(%rip), %rcx      # 0x3405
movl $0x7be, %edx            # imm = 0x7BE
callq 0x10a0
leaq 0x18fe(%rip), %rdi      # 0x3362
leaq 0x1676(%rip), %rsi      # 0x30e1
leaq 0x1919(%rip), %rcx      # 0x338b
movl $0x44, %edx
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x1ab5
leaq 0x1(%rax), %rcx
testq %rax, %rcx
jne 0x1abf
movq %rax, %rcx
shrq $0x3, %rcx
movq %rax, %rdx
subq %rcx, %rdx
shrq %rdx
cmpq %rdx, 0x10(%rdi)
jbe 0x1c20
leaq 0x1(,%rax,2), %rsi
jmp 0x1b22
movl $0x1, %esi
jmp 0x1b22
pushq %rax
leaq 0x1600(%rip), %rdi      # 0x30c7
leaq 0x1613(%rip), %rsi      # 0x30e1
leaq 0x21ca(%rip), %rcx      # 0x3c9f
movl $0x1d6, %edx            # imm = 0x1D6
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b02
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 0x2447(%rip), %rdi      # 0x3f51
leaq 0x15d0(%rip), %rsi      # 0x30e1
leaq 0x2447(%rip), %rcx      # 0x3f5f
movl $0x81e, %edx            # imm = 0x81E
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1ec6
callq 0x1722
movq %rax, %r14
leaq 0x28(%rbx), %rdi
addq $0x3, %r14
andq $-0x4, %r14
leaq (%r14,%rdx,8), %rsi
callq 0x1f04
testb $0x3, %al
jne 0x1ee5
movq %rax, (%rbx)
addq %rax, %r14
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdx
addq $0x10, %rdx
movq %rax, %rdi
movl $0x80, %esi
callq 0x1080
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movb $-0x1, (%rax,%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f62
leaq 0x2088(%rip), %rdi      # 0x3f55
leaq 0x120d(%rip), %rsi      # 0x30e1
leaq 0x18c3(%rip), %rcx      # 0x379e
movl $0x70b, %edx            # imm = 0x70B
callq 0x10a0
leaq 0x1b57(%rip), %rdi      # 0x3a43
leaq 0x1b80(%rip), %rsi      # 0x3a73
leaq 0x1b88(%rip), %rcx      # 0x3a82
movl $0xfbe, %edx            # imm = 0xFBE
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f24
addq $0x3, %rsi
shrq $0x2, %rsi
leaq 0x7(%rsp), %rdi
xorl %edx, %edx
callq 0x1fa8
testb $0x3, %al
jne 0x1f43
popq %rcx
retq
leaq 0x1382(%rip), %rdi      # 0x32ad
leaq 0x11af(%rip), %rsi      # 0x30e1
leaq 0x1a1e(%rip), %rcx      # 0x3957
movl $0x2b4, %edx            # imm = 0x2B4
callq 0x10a0
leaq 0x1a9f(%rip), %rdi      # 0x39e9
leaq 0x1190(%rip), %rsi      # 0x30e1
leaq 0x19ff(%rip), %rcx      # 0x3957
movl $0x2bb, %edx            # imm = 0x2BB
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x40, %edi
callq 0x2030
addl $0x30, %ebx
xorl %ecx, %ecx
movl %ebx, %edx
andl $0x1, %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%rax,%rcx,8)
shrl %ebx
andl $0x7f, %ebx
incq %rcx
cmpq $0x8, %rcx
jne 0x25ee
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29ef(%rip), %xmm0     # 0x5008
xorl %eax, %eax
movsd (%rdi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll %cl, %edx
orb %dl, %al
incq %rcx
cmpq $0x8, %rcx
jne 0x261b
movzbl %al, %eax
addl $-0x30, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x20, %edi
callq 0x2030
xorl %ecx, %ecx
movl %ebx, %edx
andl $0x1, %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsbl %bl, %ebx
sarl %ebx
incq %rcx
cmpq $0x4, %rcx
jne 0x264b
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2992(%rip), %xmm0     # 0x5008
xorl %eax, %eax
movsd (%rdi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll %cl, %edx
orl %edx, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x2678
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x50, %edi
callq 0x2030
movd %ebx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x296f(%rip), %xmm1     # 0x5020
xorl %ecx, %ecx
movdqa 0x2975(%rip), %xmm2     # 0x5030
movdqa 0x297d(%rip), %xmm3     # 0x5040
movdqa %xmm1, %xmm4
pcmpeqd %xmm0, %xmm4
pshufd $0xb1, %xmm4, %xmm5     # xmm5 = xmm4[1,0,3,2]
pand %xmm4, %xmm5
pand %xmm2, %xmm5
movdqu %xmm5, (%rax,%rcx,8)
addq $0x2, %rcx
paddq %xmm3, %xmm1
cmpq $0xa, %rcx
jne 0x26c3
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorl %eax, %eax
movsd (%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
cmoval %ecx, %eax
maxsd %xmm0, %xmm1
incq %rcx
movapd %xmm1, %xmm0
cmpq $0xa, %rcx
jne 0x26f5
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x48a6(%rip), %rbx      # 0x6fd0
leaq 0x291f(%rip), %rsi      # 0x5050
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2150
testl %ebp, %ebp
jle 0x2787
movl %ebp, %r13d
xorl %ebp, %ebp
movq 0x4882(%rip), %r15      # 0x6fd0
leaq 0x29ad(%rip), %r12      # 0x5102
movsd (%r14,%rbp,8), %xmm0
addsd 0x28a5(%rip), %xmm0     # 0x5008
cvttsd2si %xmm0, %esi
movq %r15, %rdi
callq 0x21b0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
incq %rbp
cmpq %rbp, %r13
jne 0x2755
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, (%rdi)
jle 0x2fe6
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x2fc9
callq 0x2180
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x2fdb
callq 0x2180
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x2fb7
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2ff4
callq 0x2180
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3002
callq 0x2180
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x3017
popq %rbx
popq %r14
jmp 0x2180
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
cmpl $0x4, %ecx
je 0x30b7
cmpl $0x8, %ecx
je 0x308a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xa, %ecx
jne 0x30dd
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorl %eax, %eax
movsd (%rsi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
cmoval %ecx, %eax
maxsd %xmm0, %xmm1
incq %rcx
movapd %xmm1, %xmm0
cmpq $0xa, %rcx
jne 0x306b
jmp 0x30dd
xorl %ecx, %ecx
movsd 0x1f74(%rip), %xmm0     # 0x5008
xorl %eax, %eax
movsd (%rsi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll %cl, %edx
orb %dl, %al
incq %rcx
cmpq $0x8, %rcx
jne 0x3096
movzbl %al, %eax
addl $-0x30, %eax
retq
xorl %ecx, %ecx
movsd 0x1f47(%rip), %xmm0     # 0x5008
xorl %eax, %eax
movsd (%rsi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll %cl, %edx
orl %edx, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x30c3
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movl %edx, 0x4(%rsp)
testl %ecx, %ecx
jle 0x31fb
movq 0x10(%rdi), %rax
movslq %esi, %rdx
movq (%rax,%rdx,8), %r15
movl %ecx, %eax
movl 0x4(%rsp), %r13d
movq %rax, 0x10(%rsp)
leaq (,%rax,8), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq 0x3eab(%rip), %rcx      # 0x6fd0
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x4(%rsp)
movsd 0x1ee1(%rip), %xmm1     # 0x5018
leaq 0x1fc6(%rip), %rdx      # 0x5104
movq %rcx, %rbp
leaq 0x1fbf(%rip), %rax      # 0x5107
xorpd %xmm2, %xmm2
leaq 0x1fae(%rip), %rcx      # 0x5101
jle 0x31b8
xorl %r12d, %r12d
movq %r15, 0x20(%rsp)
movsd (%r15,%r12,8), %xmm0
ucomisd %xmm0, %xmm1
movq %rax, %r14
cmovaq %rdx, %rax
ucomisd %xmm0, %xmm2
movq %rcx, %r15
movq %rcx, %rsi
cmovneq %rax, %rsi
cmovpq %rax, %rsi
movq %r13, %rbx
movq %rdx, %r13
movl $0x2, %edx
movq %rbp, %rdi
callq 0x2150
movq %r15, %rcx
movq 0x20(%rsp), %r15
xorpd %xmm2, %xmm2
movq %r14, %rax
movq %r13, %rdx
movq %rbx, %r13
movsd 0x1e68(%rip), %xmm1     # 0x5018
incq %r12
cmpq %r12, %rbx
jne 0x315d
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20b0
movq 0x18(%rsp), %rax
incq %rax
addq 0x8(%rsp), %r15
cmpq 0x10(%rsp), %rax
movq %rbp, %rcx
jne 0x3125
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::print_label(int)
void DataSet::print_label(int n) {
	using namespace std;
	
	double *label = this->label_vector(n);
	cout << "[" << label[0];
	for(int i=1; i < this->label_vector_length(); i++) {
		cout << ", " << label[i];
	}
	cout << "]" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r13
movq 0x3da6(%rip), %rbx      # 0x6fd0
leaq 0x1ed9(%rip), %rsi      # 0x510a
movl $0x1, %ebp
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2150
movsd (%r13), %xmm0
movq %rbx, %rdi
callq 0x21a0
cmpl $0x2, 0x8(%r14)
jl 0x3291
movq 0x3d71(%rip), %r15      # 0x6fd0
leaq 0x1ea6(%rip), %r12      # 0x510c
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2150
movsd (%r13,%rbp,8), %xmm0
movq %r15, %rdi
callq 0x21a0
incq %rbp
movslq 0x8(%r14), %rax
cmpq %rax, %rbp
jl 0x3266
leaq 0x1e77(%rip), %rsi      # 0x510f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::~NeuralNet()
NeuralNet::~NeuralNet() {
  delete[] hidden_weights;
  delete[] hidden_weights_buffer;
  delete[] hidden_weight_deltas;
  delete[] hidden_values;

  delete[] output_weights;
  delete[] output_weights_buffer;
  delete[] output_weight_deltas;
  delete[] output_values;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3e30
callq 0x2180
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3e3e
callq 0x2180
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3e4c
callq 0x2180
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x3e5a
callq 0x2180
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x3e68
callq 0x2180
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3e76
callq 0x2180
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x3e84
callq 0x2180
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x3e93
popq %rbx
jmp 0x2180
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::run(double*)
double *NeuralNet::run(double *input) {
  double *iv = input;
  double *hv = hidden_values;
  double *ov = output_values;
  
  // Propagate from input to hidden layer
  #pragma omp parallel for
  for(int i=0; i < num_hidden; i++) {
    double sum = 0.0;
    for(int j=0; j < num_inputs; j++) {
      sum += iv[j] * hidden_weights[i][j];
    }
    hv[i] = sigmoid(sum);
  }
  
  // Propagate from hidden to output layer
  #pragma omp parallel for
  for(int i=0; i < num_outputs; i++) {
    double sum = 0.0;
    for(int j=0; j < num_hidden; j++) {
      sum += hv[j] * output_weights[i][j];
    }
    ov[i] = sigmoid(sum);
  }
  
  return ov;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r12
movq 0x48(%rdi), %r14
cmpl $0x0, 0x4(%rdi)
jle 0x3f18
movq %rsi, %r15
xorl %r13d, %r13d
movslq (%rbx), %rax
testq %rax, %rax
jle 0x3ee5
movq 0x10(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%r15,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x3ecc
jmp 0x3ee9
xorpd %xmm0, %xmm0
xorpd 0x138f(%rip), %xmm0     # 0x5280
callq 0x21d0
movsd 0x1372(%rip), %xmm1     # 0x5270
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%r12,%r13,8)
incq %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jl 0x3eb6
cmpl $0x0, 0x8(%rbx)
jle 0x3f84
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
testq %rax, %rax
jle 0x3f51
movq 0x30(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%r12,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x3f38
jmp 0x3f55
xorpd %xmm0, %xmm0
xorpd 0x1323(%rip), %xmm0     # 0x5280
callq 0x21d0
movsd 0x1306(%rip), %xmm1     # 0x5270
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%r15,8)
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x3f21
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop