LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::SetMaterialType(TMaterialOption)
void M3DDrawer::SetMaterialType (TMaterialOption option)
{    
	if (option == moBoth)
    {
		option = ((rand() & 1)==0) ? moPlastic : moMetal;
    }
    
	if (option == moPlastic)
    {
		k1 = 40; k2 = 70; k3 = 46; k_pow = 3; // light coefficients
    }
	else
    {
		k1 = 10, k2 = 70, k3 = 30, k_pow = 13; // light coefficients
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0xa087
callq 0x30f0
movl %eax, %edx
andl $0x1, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xa0ae
movq -0x18(%rbp), %rax
movl $0x28, (%rax)
movl $0x46, 0x4(%rax)
movl $0x2e, 0x8(%rax)
movl $0x3, 0xc(%rax)
jmp 0xa0cd
movq -0x18(%rbp), %rax
movl $0xa, (%rax)
movl $0x46, 0x4(%rax)
movl $0x1e, 0x8(%rax)
movl $0xd, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
fldt 0x20(%rbp)
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
fstpt -0x30(%rbp)
fstpt -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rax
fldt 0x50(%rax)
fstpt -0x60(%rbp)
movq -0x10(%rbp), %rax
fldt 0x60(%rax)
fstpt -0x70(%rbp)
movq -0x10(%rbp), %rax
fldt 0x70(%rax)
fstpt -0x80(%rbp)
movq $0x0, -0x88(%rbp)
fldt -0x30(%rbp)
movq -0x18(%rbp), %rax
fldl 0x18(%rax)
fdivrp %st, %st(1)
flds 0x427b(%rip)            # 0xe3cc
fmulp %st, %st(1)
fldz
faddp %st, %st(1)
fstpl -0xb8(%rbp)
fldt -0x80(%rbp)
fstpt -0xd8(%rbp)
fldt -0x40(%rbp)
movq -0x10(%rbp), %rax
flds 0x34(%rax)
faddp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0xb1e0
fldt -0xd8(%rbp)
fmulp %st, %st(1)
fstpt -0xa0(%rbp)
fldt -0x80(%rbp)
fstpt -0xcc(%rbp)
fldt -0x40(%rbp)
movq -0x10(%rbp), %rax
flds 0x34(%rax)
faddp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0xb210
fldt -0xcc(%rbp)
fmulp %st, %st(1)
fstpt -0xb0(%rbp)
movsd -0xb8(%rbp), %xmm1
movq -0x10(%rbp), %rax
movss 0x30(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm0, %xmm1
movsd 0x42b8(%rip), %xmm0     # 0xe490
callq 0x3690
movsd %xmm0, -0xc0(%rbp)
fldt -0xa0(%rbp)
fldl -0xc0(%rbp)
fdivrp %st, %st(1)
fstpt -0xa0(%rbp)
fldt -0xb0(%rbp)
fldl -0xc0(%rbp)
fdivrp %st, %st(1)
fstpt -0xb0(%rbp)
fldt -0x60(%rbp)
fldt -0xa0(%rbp)
faddp %st, %st(1)
fstpt -0xa0(%rbp)
fldt -0x70(%rbp)
fldt -0xb0(%rbp)
faddp %st, %st(1)
fstpt -0xb0(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0xa279
movq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rax
fldt 0x10(%rax)
fldt 0x20(%rax)
fldt -0xa0(%rbp)
fldt -0xb0(%rbp)
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rsp, %rax
fstpt 0x30(%rax)
fstpt 0x20(%rax)
fstpt 0x10(%rax)
fstpt (%rax)
callq 0x86b0
movq %rax, -0x88(%rbp)
jmp 0xa2a8
movq -0xe0(%rbp), %rdi
fldt -0xa0(%rbp)
fldt -0xb0(%rbp)
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rsp, %rax
fstpt 0x10(%rax)
fstpt (%rax)
callq 0x8870
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: intheswim[P]FractalTubes/m3d.cpp
// Function: GetColor(long, long, int&, int&, int&)
static long GetColor (long color, long col, int &red, int &green, int &blue)
{
	long r, g, b;
	r = color & 0xff;
	color >>= 8;
	g = color & 0xff;
	color >>= 8;
	b = color & 0xff;
    
	r = r * col * 0.01; if (r > 255) r = 255;
	g = g * col * 0.01; if (g > 255) g = 255;
	b = b * col * 0.01; if (b > 255) b = 255;
    
	color = r + (g << 8) + (b << 16);
	red = (int)r;
	green = (int)g;
	blue = (int)b;
    
	return color;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
andq $0xff, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0xff, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0xff, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
imulq -0x10(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x3368(%rip), %xmm1     # 0xe2c8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x30(%rbp)
cmpq $0xff, -0x30(%rbp)
jle 0xaf7f
movq $0xff, -0x30(%rbp)
movq -0x38(%rbp), %rax
imulq -0x10(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x3333(%rip), %xmm1     # 0xe2c8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x38(%rbp)
cmpq $0xff, -0x38(%rbp)
jle 0xafb4
movq $0xff, -0x38(%rbp)
movq -0x40(%rbp), %rax
imulq -0x10(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x32fe(%rip), %xmm1     # 0xe2c8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x40(%rbp)
cmpq $0xff, -0x40(%rbp)
jle 0xafe9
movq $0xff, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
shlq $0x10, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x18(%rbp), %rcx
andq $0x1, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0xb0ac
imulq $0x3, -0x18(%rbp), %rax
sarq %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
andl $0xf0, %eax
movl -0x20(%rbp), %ecx
andl $0xf, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, 0x1(%rax,%rcx)
jmp 0xb0fe
imulq $0x3, -0x18(%rbp), %rax
addq $0x1, %rax
sarq %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movl -0x20(%rbp), %ecx
shll $0x4, %ecx
andl $0xf0, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
// File: intheswim[P]FractalTubes/m3d.cpp
// Function: GetJuliaSetParams(int, long double&, long double&)
static void GetJuliaSetParams (int juliaIndex, long double &juliaRe, long double &juliaIm)
{
	juliaIndex = juliaIndex % 4;
    
	if (juliaIndex == 0)
    {
		juliaRe = 0.3245;
		juliaIm = 0.04855;
    }
	else if (juliaIndex == 1)
    {
		juliaRe = -0.4961;
		juliaIm = 0.5432;
    }
	else if (juliaIndex == 2)
    {
		juliaRe = 0.300283;
		juliaIm = 0.48857;
    }
	else if (juliaIndex == 3)
    {
		juliaRe = -0.744819;
		juliaIm = -0.105094;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xb13d
movq -0x10(%rbp), %rax
fldl 0x339b(%rip)            # 0xe4c8
fstpt (%rax)
movq -0x18(%rbp), %rax
fldl 0x3397(%rip)            # 0xe4d0
fstpt (%rax)
jmp 0xb1a1
cmpl $0x1, -0x4(%rbp)
jne 0xb15d
movq -0x10(%rbp), %rax
fldl 0x336b(%rip)            # 0xe4b8
fstpt (%rax)
movq -0x18(%rbp), %rax
fldl 0x3367(%rip)            # 0xe4c0
fstpt (%rax)
jmp 0xb19f
cmpl $0x2, -0x4(%rbp)
jne 0xb17d
movq -0x10(%rbp), %rax
fldl 0x333b(%rip)            # 0xe4a8
fstpt (%rax)
movq -0x18(%rbp), %rax
fldl 0x3337(%rip)            # 0xe4b0
fstpt (%rax)
jmp 0xb19d
cmpl $0x3, -0x4(%rbp)
jne 0xb19b
movq -0x10(%rbp), %rax
fldl 0x330b(%rip)            # 0xe498
fstpt (%rax)
movq -0x18(%rbp), %rax
fldl 0x3307(%rip)            # 0xe4a0
fstpt (%rax)
jmp 0xb19d
jmp 0xb19f
jmp 0xb1a1
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xbaf0
movq %rax, %rdi
leaq 0x329a(%rip), %rsi      # 0xe571
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x3296(%rip), %rsi      # 0xe581
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x3291(%rip), %rsi      # 0xe590
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x328a(%rip), %rsi      # 0xe59d
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x3285(%rip), %rsi      # 0xe5ac
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x327e(%rip), %rsi      # 0xe5b9
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x3277(%rip), %rsi      # 0xe5c6
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x3270(%rip), %rsi      # 0xe5d3
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x3268(%rip), %rsi      # 0xe5df
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x3261(%rip), %rsi      # 0xe5ec
callq 0xbb60
callq 0xbaf0
movq %rax, %rdi
leaq 0x325c(%rip), %rsi      # 0xe5fb
callq 0xbb60
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0xb3d9
movl -0x4(%rbp), %edi
callq 0xb270
movq %rax, -0x10(%rbp)
callq 0xbaf0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xbb60
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb3ab
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xbaf0
movq %rax, %rdi
leaq 0x3185(%rip), %rsi      # 0xe5ac
movl $0x1, %edx
callq 0xbcc0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xb441
movl $0x0, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jle 0xb44e
movl $0xa, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xbaf0
movq %rax, %rdi
leaq 0x309a(%rip), %rsi      # 0xe581
movl $0x19, %edx
callq 0xbcc0
movl %eax, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jge 0xb501
movl $0xa, -0x4(%rbp)
cmpl $0x28, -0x4(%rbp)
jle 0xb50e
movl $0x28, -0x4(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xbaf0
movq %rax, %rdi
leaq 0x3029(%rip), %rsi      # 0xe590
movl $0x1, %edx
callq 0xbcc0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xb581
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jle 0xb58e
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xbaf0
movq %rax, %rdi
leaq 0x2ee5(%rip), %rsi      # 0xe5ec
movl $0x64, %edx
callq 0xbcc0
cvtsi2sd %eax, %xmm1
movsd 0x2b63(%rip), %xmm0     # 0xe280
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss 0x2c9e(%rip), %xmm0     # 0xe3d0
ucomiss -0x4(%rbp), %xmm0
jbe 0xb745
movss 0x2c90(%rip), %xmm0     # 0xe3d0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x2e06(%rip), %xmm1     # 0xe558
ucomiss %xmm1, %xmm0
jbe 0xb764
movss 0x2df9(%rip), %xmm0     # 0xe558
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb7a0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xb7dc
movb $0x0, -0x1(%rbp)
jmp 0xb7ff
cmpl $0x1, -0x8(%rbp)
jne 0xb7e8
movb $0x1, -0x1(%rbp)
jmp 0xb7ff
callq 0x30f0
andl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb620
movl %eax, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0xb82c
movb $0x1, -0x1(%rbp)
jmp 0xb84f
cmpl $0x0, -0x8(%rbp)
jne 0xb838
movb $0x0, -0x1(%rbp)
jmp 0xb84f
callq 0x30f0
andl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getIntervalInSecs()
float AppParams::getIntervalInSecs()
{
    int option = getIntervalOption();

    if (option == INTERVAL_45) return 45.0;
    if (option == INTERVAL_60) return 60.0;

    return 90.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb890
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xb8d5
movss 0x2c96(%rip), %xmm0     # 0xe564
movss %xmm0, -0x4(%rbp)
jmp 0xb8f7
cmpl $0x1, -0x8(%rbp)
jne 0xb8ea
movss 0x2c7d(%rip), %xmm0     # 0xe560
movss %xmm0, -0x4(%rbp)
jmp 0xb8f7
movss 0x2c6a(%rip), %xmm0     # 0xe55c
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xbaf0
movq %rax, %rdi
leaq 0x2c1c(%rip), %rsi      # 0xe5d3
xorl %edx, %edx
callq 0xbcc0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xb9ce
movl $0x0, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jle 0xb9db
movl $0xa, -0x4(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rax)
jne 0x183f
jmp 0x1948
movq $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
cmpq 0x18(%rcx), %rax
je 0x18ad
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1970
testb $0x1, %al
jne 0x1874
jmp 0x189b
movq 0x10(%rsp), %rdi
callq 0x19c0
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1990
jmp 0x189d
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x1848
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x19e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x8(%rax), %rdi
movq 0x18(%rax), %rsi
shlq $0x3, %rsi
callq 0x1a40
movq 0x10(%rsp), %rdi
callq 0x19c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1b10
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x1a50
callq 0x1b60
movq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
callq 0x1b70
movq $0x0, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/phmap/./phmap.h
// Function: void phmap::container_internal::Deallocate<4ul, std::allocator<std::pair<unsigned int const, unsigned int>>>(std::allocator<std::pair<unsigned int const, unsigned int>>*, void*, unsigned long)
void Deallocate(Alloc* alloc, void* p, 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);
  AT::deallocate(mem_alloc, static_cast<M*>(p),
                 (n + sizeof(M) - 1) / sizeof(M));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x20(%rsp)
movb %al, 0xb(%rsp)
je 0x1a79
movb $0x1, %al
movb %al, 0xb(%rsp)
jmp 0x1a79
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x1a83
jmp 0x1a85
jmp 0x1aa4
leaq 0x4804(%rip), %rdi      # 0x6290
leaq 0x461e(%rip), %rsi      # 0x60b1
movl $0x2c6, %edx            # imm = 0x2C6
leaq 0x480b(%rip), %rcx      # 0x62aa
callq 0x10a0
movq 0x30(%rsp), %rsi
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1d50
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x3, %rdx
shrq $0x2, %rdx
callq 0x1d70
jmp 0x1ad4
leaq 0x1f(%rsp), %rdi
callq 0x1da0
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x1f(%rsp), %rdi
callq 0x1da0
movq 0x10(%rsp), %rdi
callq 0x1110
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x68(%rsp), %rsi
callq 0x2340
movb %dl, 0x50(%rsp)
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x58(%rsp)
movb 0x50(%rsp), %al
movb %al, 0x60(%rsp)
testb $0x1, 0x60(%rsp)
je 0x22fc
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x24f0
callq 0x2520
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x5353(%rip), %rdx      # 0x7640
leaq 0x40(%rsp), %rcx
leaq 0x3f(%rsp), %r8
callq 0x23c0
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x2530
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x58(%rsp), %rdx
addq $0x8, %rdx
leaq 0x28(%rsp), %rsi
callq 0x2570
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x19c0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x78(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %r8
callq 0x4a90
movq 0x8(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movq 0x78(%rsp), %rsi
callq 0x2530
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2250
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x4b00
movq 0x8(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x78(%rsp), %rsi
callq 0x2530
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x4b40
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4ad0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x24ab
jmp 0x24b3
movb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x24b3
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x24bd
jmp 0x24bf
jmp 0x24de
leaq 0x4ec4(%rip), %rdi      # 0x738a
leaq 0x3be4(%rip), %rsi      # 0x60b1
movl $0x803, %edx            # imm = 0x803
leaq 0x4f31(%rip), %rcx      # 0x740a
callq 0x10a0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq 0x90(%rsp), %rdx
leaq 0x78(%rsp), %rdi
callq 0x2810
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2860
movq 0x8(%rsp), %rsi
addq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x2870
movq 0x90(%rsp), %rdi
callq 0x2a60
leaq 0x60(%rsp), %rdi
movzbl %al, %esi
callq 0x28a0
movl %eax, 0x54(%rsp)
leaq 0x54(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2a70
movl %eax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2a90
movl %eax, 0x4c(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x2ab0
testb $0x1, %al
jne 0x2673
jmp 0x2726
leaq 0x50(%rsp), %rdi
callq 0x2ad0
movq 0x10(%rsp), %rdi
movl %eax, 0x48(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x2b10
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movslq 0x48(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x2b40
movq (%rsp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
callq 0x2b30
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x2ae0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x26e3
jmp 0x2715
movslq 0x48(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x2b40
movq %rax, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x2f(%rsp), %rdx
callq 0x2b60
jmp 0x278c
jmp 0x2717
leaq 0x50(%rsp), %rdi
callq 0x2b90
jmp 0x265b
leaq 0x60(%rsp), %rdi
callq 0x2bb0
movl %eax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2be0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2748
jmp 0x274a
jmp 0x2759
leaq 0x78(%rsp), %rdi
callq 0x2c00
jmp 0x25ee
movq 0x10(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x2c30
movq %rax, 0x20(%rsp)
movb $0x1, 0x1f(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x1f(%rsp), %rdx
callq 0x2b60
movq 0xa8(%rsp), %rax
movb 0xb0(%rsp), %dl
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x3230
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
callq 0x1b70
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, 0x27(%rsp)
jne 0x2c91
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3340
xorb $-0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x2c9b
jmp 0x2cd2
movq 0x18(%rsp), %rdi
callq 0x3360
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x3230
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq (%rax), %rax
movq 0x38(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x33f0
movq 0x18(%rsp), %rdi
andb $0x1, %al
movzbl %al, %eax
movq %rax, 0x8(%rsp)
callq 0x1b70
movq 0x8(%rsp), %rdx
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2a60
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
movsbl %al, %edx
callq 0x3410
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x34e0
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: attractivechaos[P]udb2/phmap/./phmap.h
// Function: int phmap::container_internal::TrailingZeros<unsigned int>(unsigned int)
int TrailingZeros(T x) {
  return sizeof(T) == 8 ? base_internal::CountTrailingZerosNonZero64(
                              static_cast<uint64_t>(x))
                        : base_internal::CountTrailingZerosNonZero32(
                              static_cast<uint32_t>(x));
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
tzcntl %eax, %eax
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq 0x58(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x2810
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2860
movq 0x18(%rsp), %rsi
addq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x2870
leaq 0x30(%rsp), %rdi
callq 0x34f0
movl %eax, 0x2c(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x2be0
testb $0x1, %al
jne 0x329e
jmp 0x32dd
leaq 0x2c(%rsp), %rdi
callq 0x2e30
movslq %eax, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2b40
movq 0x10(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0x3660
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
leaq 0x40(%rsp), %rdi
callq 0x3660
movq 0x20(%rsp), %rdx
movq %rax, %rcx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, 0xf(%rsp)
jae 0x3303
movb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x3303
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x330d
jmp 0x330f
jmp 0x332e
leaq 0x30c0(%rip), %rdi      # 0x63d6
leaq 0x2d94(%rip), %rsi      # 0x60b1
movl $0x7be, %edx            # imm = 0x7BE
leaq 0x30d6(%rip), %rcx      # 0x63ff
callq 0x10a0
leaq 0x40(%rsp), %rdi
callq 0x2c00
jmp 0x3257
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rax)
jne 0x338b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x36a0
jmp 0x33dd
movq 0x8(%rsp), %rdi
callq 0x17b0
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
callq 0x38e0
movq %rax, %rdi
callq 0x3890
movq %rax, %rcx
movq (%rsp), %rax
shrq %rcx
cmpq %rcx, %rax
ja 0x33c6
movq 0x8(%rsp), %rdi
callq 0x38f0
jmp 0x33db
movq 0x8(%rsp), %rdi
movq 0x18(%rdi), %rsi
shlq %rsi
addq $0x1, %rsi
callq 0x36a0
jmp 0x33dd
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x18(%rcx), %rax
jae 0x343b
jmp 0x345a
leaq 0x3d4b(%rip), %rdi      # 0x718d
leaq 0x2c68(%rip), %rsi      # 0x60b1
movl $0x81e, %edx            # imm = 0x81E
leaq 0x3d46(%rip), %rcx      # 0x719b
callq 0x10a0
movsbl 0x17(%rsp), %edi
callq 0x1970
testb $0x1, %al
jne 0x346a
jmp 0x3486
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4a30
jmp 0x34a0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4a50
movq 0x8(%rsp), %rsi
movb 0x17(%rsp), %dl
movq (%rsi), %rax
movq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movb 0x17(%rsp), %dl
movq (%rsi), %rax
movq 0x18(%rsp), %rcx
subq $0x10, %rcx
andq 0x18(%rsi), %rcx
addq $0x1, %rcx
movq 0x18(%rsi), %rsi
andq $0xf, %rsi
addq %rsi, %rcx
movb %dl, (%rax,%rcx)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rax)
je 0x3c7c
jmp 0x3c9b
leaq 0x350e(%rip), %rdi      # 0x7191
leaq 0x2427(%rip), %rsi      # 0x60b1
movl $0x70b, %edx            # imm = 0x70B
leaq 0x2b02(%rip), %rcx      # 0x6798
callq 0x10a0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3cac
callq 0x1740
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x19e0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
callq 0x19c0
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1b10
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x3db0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3ed0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3f50
movq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
callq 0x3fd0
movq 0x8(%rsp), %rdi
callq 0x4020
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x4060
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x48(%rsp)
movb %al, 0x2b(%rsp)
je 0x3dd4
movb $0x1, %al
movb %al, 0x2b(%rsp)
jmp 0x3dd4
movb 0x2b(%rsp), %al
testb $0x1, %al
jne 0x3dde
jmp 0x3de0
jmp 0x3dff
leaq 0x24a9(%rip), %rdi      # 0x6290
leaq 0x22c3(%rip), %rsi      # 0x60b1
movl $0x2b4, %edx            # imm = 0x2B4
leaq 0x2b57(%rip), %rcx      # 0x6951
callq 0x10a0
movq 0x50(%rsp), %rsi
leaq 0x47(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4070
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
callq 0x4090
movq %rax, 0x20(%rsp)
jmp 0x3e31
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rcx
andq $0x3, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0x17(%rsp)
jne 0x3e58
movb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x3e58
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3e62
jmp 0x3e64
jmp 0x3e9d
leaq 0x2b9d(%rip), %rdi      # 0x6a08
leaq 0x223f(%rip), %rsi      # 0x60b1
movl $0x2bb, %edx            # imm = 0x2BB
leaq 0x2ad3(%rip), %rcx      # 0x6951
callq 0x10a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x40c0
jmp 0x3ebb
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x40c0
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1110
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/phmap/./phmap_base.h
// Function: std::conditional<std::is_const<char>::value, std::tuple_element<0ul, std::tuple<signed char, phmap::container_internal::map_slot_type<unsigned int, unsigned int>>>::type const, std::tuple_element<0ul, 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<0ul, 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x4, 0x10(%rsp)
movq 0x18(%rsp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x3f02
jmp 0x3f21
leaq 0x2b59(%rip), %rdi      # 0x6a62
leaq 0x2b82(%rip), %rsi      # 0x6a92
movl $0xfbe, %edx            # imm = 0xFBE
leaq 0x2b85(%rip), %rcx      # 0x6aa1
callq 0x10a0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x1e90
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/phmap/./phmap.h
// Function: void phmap::container_internal::map_slot_policy<unsigned int, unsigned int>::transfer<std::allocator<std::pair<unsigned int const, unsigned int>>>(std::allocator<std::pair<unsigned int const, unsigned int>>*, phmap::container_internal::map_slot_type<unsigned int, unsigned int>*, phmap::container_internal::map_slot_type<unsigned int, unsigned int>*)
static void transfer(Allocator* alloc, slot_type* new_slot,
                         slot_type* old_slot) {
        emplace(new_slot);
        if (kMutableKeys::value) {
            phmap::allocator_traits<Allocator>::construct(
                *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
        } else {
            phmap::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
                                                         std::move(old_slot->value));
        }
        destroy(alloc, old_slot);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x43e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x43f0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1bc0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $-0x1, %eax
jne 0x4503
jmp 0x4522
leaq 0x2c0f(%rip), %rdi      # 0x7119
leaq 0x1ba0(%rip), %rsi      # 0x60b1
movl $0x1be, %edx            # imm = 0x1BE
leaq 0x2c18(%rip), %rcx      # 0x7135
callq 0x10a0
movq 0x18(%rsp), %rdi
callq 0x1cb0
testb $0x1, %al
jne 0x4532
jmp 0x4534
jmp 0x4553
leaq 0x1b5c(%rip), %rdi      # 0x6097
leaq 0x1b6f(%rip), %rsi      # 0x60b1
movl $0x1bf, %edx            # imm = 0x1BF
leaq 0x2be7(%rip), %rcx      # 0x7135
callq 0x10a0
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq 0x18(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
je 0x459f
movq 0x10(%rsp), %rsi
movq %rsp, %rdi
callq 0x2870
movq 0x10(%rsp), %rsi
movq %rsp, %rdi
callq 0x4640
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x455d
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq (%rdx), %rsi
movq %rsi, 0x1(%rax,%rcx)
movq 0x8(%rdx), %rdx
movq %rdx, 0x9(%rax,%rcx)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movb $-0x1, (%rax,%rcx)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/phmap/./phmap.h
// Function: void phmap::container_internal::map_slot_policy<unsigned int, unsigned int>::construct<std::allocator<std::pair<unsigned int const, unsigned int>>, std::piecewise_construct_t const&, std::tuple<unsigned int&&>, std::tuple<>>(std::allocator<std::pair<unsigned int const, unsigned int>>*, phmap::container_internal::map_slot_type<unsigned int, unsigned int>*, std::piecewise_construct_t const&, std::tuple<unsigned int&&>&&, std::tuple<>&&)
static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
        emplace(slot);
        if (kMutableKeys::value) {
            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
                                                         std::forward<Args>(args)...);
        } else {
            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->value,
                                                         std::forward<Args>(args)...);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x43e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x4c00
addq $0x28, %rsp
retq
nopl (%rax,%rax)