LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/Chi_Square_Distribution.cpp
// Function: gser(double, double)
void gser(  double a, double x )
{
	int n, ITMAX=100;
	double sum, del, ap, eps = 3.0e-7;
	gln = gammln( a );
	if( x <= 0.0 )
	{
		if( x < 0.0 )
		{
			printf( "x less than 0 in routine gser" );
			exit( 1 );
		}
		gamser = 0.0;
		return;
	}
	else
	{
		ap = a;
		del = sum = 1.0 / a;

		for( n = 1; n <= ITMAX; n++ )
		{
			++ap;
			del *= x / ap;
			sum += del;
			if( fabs( del ) < fabs( sum ) * eps)
			{
				gamser = sum * exp( -x + a * log( x ) - gln );
				return;
			}
		}
		printf( "Error:a too large, ITMAX too small in routine gser" );
		exit( 1 );
	}
	return;
//	returns the incomplete gamma function P(a,x) evaluated by its series reprentation
//  as gamser, also returns ln(gamma(a) as gln;
//  the incomplete gamma function P(a,x) is efined:
//		P(a,x) = 1/gamma(a)* integral(0,x) exp(-t)t^(a-1) dt (a>0);
//	it has the limiting values P(a,0)=0 and P(a,infinity)=1;
//  it relates many cumulative probability functions, such as chi-square;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
callq 0x3dd9
movsd -0x10(%rbp), %xmm7
movsd %xmm0, 0x951b(%rip)     # 0xd218
xorpd %xmm1, %xmm1
ucomisd %xmm7, %xmm1
jae 0x3d91
movsd 0x52f5(%rip), %xmm0     # 0x9008
movapd %xmm0, %xmm3
movsd -0x8(%rbp), %xmm9
divsd %xmm9, %xmm3
movl $0x64, %eax
movapd 0x5491(%rip), %xmm1     # 0x91c0
movsd 0x52f1(%rip), %xmm2     # 0x9028
movapd %xmm9, %xmm4
movapd %xmm3, %xmm8
movapd %xmm3, %xmm5
addsd %xmm0, %xmm4
movapd %xmm7, %xmm3
divsd %xmm4, %xmm3
mulsd %xmm5, %xmm3
addsd %xmm3, %xmm8
movapd %xmm3, %xmm5
andpd %xmm1, %xmm5
movapd %xmm8, %xmm6
andpd %xmm1, %xmm6
mulsd %xmm2, %xmm6
ucomisd %xmm5, %xmm6
ja 0x3d9c
decl %eax
jne 0x3d41
leaq 0x5544(%rip), %rdi      # 0x92c4
xorl %eax, %eax
callq 0x2050
movl $0x1, %edi
callq 0x2240
jbe 0x3dcb
leaq 0x550c(%rip), %rdi      # 0x92a6
jmp 0x3d80
movapd %xmm7, %xmm0
movapd %xmm8, -0x20(%rbp)
callq 0x21a0
mulsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
subsd 0x945b(%rip), %xmm0     # 0xd218
callq 0x2380
movapd -0x20(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x944d(%rip)     # 0xd220
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/Chi_Square_Distribution.cpp
// Function: gammln(double)
double gammln( double xx )
{
	double x, y, tmp, ser;
	static double cof[6]={76.18009172947146,-86.50532032941677,24.01409824083091,
		-1.231739572450155,0.1208650973866179e-2,-0.5395239384953e-5};
	int j;
	
	y = x = xx;
	tmp = x + 5.5;
	tmp -= ( x + 0.5 ) * log( tmp );
	ser = 1.000000000190015;
	for( j = 0; j < 6; j++ )
		ser += cof[ j ] / ++y;
	return( -tmp + log( 2.5066282746310005 * ser / x ) );
//	Returns the logarithmic value of gamma function of xx for xx>0;
//  the gamma function is defined by the intergral:
// 		gamma(z)=inter(0,infinity) t^(z-1)epx(-t)dt;
//  n!=gamma(n+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movapd %xmm0, %xmm1
movsd %xmm0, -0x10(%rbp)
movsd 0x523e(%rip), %xmm0     # 0x9030
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x21a0
movsd -0x10(%rbp), %xmm5
movapd %xmm0, %xmm1
movsd 0x5227(%rip), %xmm0     # 0x9038
xorl %eax, %eax
leaq 0x53f6(%rip), %rcx      # 0x9210
movsd 0x51e6(%rip), %xmm2     # 0x9008
movapd %xmm5, %xmm3
movsd (%rax,%rcx), %xmm4
addsd %xmm2, %xmm3
divsd %xmm3, %xmm4
addsd %xmm4, %xmm0
addq $0x8, %rax
cmpq $0x30, %rax
jne 0x3e26
movsd 0x51f7(%rip), %xmm2     # 0x9040
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm2
movsd -0x8(%rbp), %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, -0x8(%rbp)
mulsd 0x51e1(%rip), %xmm0     # 0x9048
divsd %xmm5, %xmm0
callq 0x21a0
subsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/Chi_Square_Distribution.cpp
// Function: gammp(double, double)
double gammp( double a, double x )
{

	// x = chisquare, a = df/2
	if( x < 0.0 || a <= 0.0 )
	{
		printf( "error: invalid arguments in routine gammp" );
		exit( 1 );
	}
	if( x < ( a + 1.0 ) )
	{
		gser( a, x );
		return( gamser );
	}
	else
	{
		gcf( a, x );
		return( 1.0 - gammcf );
	}
//	returns the incomplete gamma function P(a,x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x3ec7
ucomisd %xmm1, %xmm2
ja 0x3ec7
movsd 0x5171(%rip), %xmm2     # 0x9008
addsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x3eb0
callq 0x3cd9
movsd 0x9372(%rip), %xmm0     # 0xd220
jmp 0x3ec5
callq 0x3edf
movsd 0x514b(%rip), %xmm0     # 0x9008
subsd 0x9363(%rip), %xmm0     # 0xd228
popq %rbp
retq
leaq 0x5429(%rip), %rdi      # 0x92f7
xorl %eax, %eax
callq 0x2050
movl $0x1, %edi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/Chi_Square_Distribution.cpp
// Function: gcf(double, double)
void gcf(  double a, double x )
{
	int i, ITMAX=100;
	double an, b, c, d, del, h, eps = 3.0e-7, fpmin = 1.0e-30;
	gln = gammln( a );
	b = x + 1.0 - a;
	c = 1.0 / fpmin;
	d = 1.0 / b;
	h = d;
	for( i = 1; i < ITMAX; i++ )
	{
		
		an = -i * ( i-a );
		b += 2.0;
		d = an * d + b;
		if( fabs( d ) < fpmin )
			d = fpmin;
		c = b + an / c;
		if( fabs( c ) < fpmin )
			c = fpmin;
		d = 1.0 / d;
		del = d * c;
		h *= del;
		if( fabs( del-1.0 ) < eps )
			break;
	}
	if( i > ITMAX )
	{
		printf( "Error:a too large, ITMAX too small in routine gser" );
		exit( 1 );
	}
	gammcf = exp( -x + a * log( x ) - gln ) * h;
//	returns the incomplete gamma function P(a,x) evaluated by its continued fraction
//	reprentation as gammcf, also returns ln(gamma(a) as gln;
//  the definition of incomplete function P(a,x) can see routine gser();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
callq 0x3dd9
movsd -0x8(%rbp), %xmm14
movsd %xmm0, 0x9314(%rip)     # 0xd218
movsd 0x50fc(%rip), %xmm0     # 0x9008
movsd -0x10(%rbp), %xmm1
movapd %xmm1, %xmm13
addsd %xmm0, %xmm1
subsd %xmm14, %xmm1
movapd %xmm0, %xmm15
divsd %xmm1, %xmm15
movsd 0x511f(%rip), %xmm2     # 0x9050
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movsd 0x5115(%rip), %xmm3     # 0x9058
movapd 0x5275(%rip), %xmm4     # 0x91c0
movsd 0x510d(%rip), %xmm5     # 0x9060
movsd 0x50f5(%rip), %xmm6     # 0x9050
movsd 0x50b5(%rip), %xmm7     # 0x9018
movsd 0x50bc(%rip), %xmm8     # 0x9028
movapd %xmm15, %xmm9
xorps %xmm10, %xmm10
cvtsi2sd %ecx, %xmm10
xorps %xmm11, %xmm11
cvtsi2sd %eax, %xmm11
subsd %xmm14, %xmm11
mulsd %xmm10, %xmm11
addsd %xmm3, %xmm1
mulsd %xmm11, %xmm9
addsd %xmm1, %xmm9
movapd %xmm0, %xmm10
divsd %xmm9, %xmm10
andpd %xmm4, %xmm9
divsd %xmm2, %xmm11
addsd %xmm1, %xmm11
movapd %xmm11, %xmm2
andpd %xmm4, %xmm2
cmpltsd %xmm5, %xmm2
movapd %xmm2, %xmm12
andnpd %xmm11, %xmm12
andpd %xmm5, %xmm2
orpd %xmm12, %xmm2
cmpltsd %xmm5, %xmm9
movapd %xmm9, %xmm11
andnpd %xmm10, %xmm11
andpd %xmm6, %xmm9
orpd %xmm11, %xmm9
movapd %xmm9, %xmm10
mulsd %xmm2, %xmm10
mulsd %xmm10, %xmm15
addsd %xmm7, %xmm10
andpd %xmm4, %xmm10
ucomisd %xmm10, %xmm8
ja 0x401f
incl %eax
leal -0x1(%rcx), %edx
cmpl $-0x63, %ecx
movl %edx, %ecx
jne 0x3f71
movapd %xmm13, %xmm0
movsd %xmm15, -0x18(%rbp)
callq 0x21a0
mulsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
subsd 0x91d7(%rip), %xmm0     # 0xd218
callq 0x2380
movsd -0x18(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x91d1(%rip)     # 0xd228
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/ChiSquareContinuous.cpp
// Function: ChiSquareContinuous::ChiSquareContinuous(double, int)
ChiSquareContinuous::ChiSquareContinuous(double memory_,int num)
{
  chi_squared = 0;
  upper_bins = new double;
  lower_bins = new double;
  memory = memory_;
  switch(num)
  {
  case 1: 
    memory = memory_/3;
    quantile_sketch = new GK(memory);
    break;
  case 2:
    quantile_sketch = new QDigestDouble(memory);
    break;
  case 3: 
    quantile_sketch = new ReservoirSampling((int)memory);
    break;
  default:
    throw IndexError();
  }	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x8, %edi
callq 0x2220
movq %rax, 0x10(%rbx)
movl $0x8, %edi
callq 0x2220
movq %rax, 0x18(%rbx)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rbx)
cmpl $0x3, %r14d
je 0x4620
cmpl $0x2, %r14d
je 0x4599
cmpl $0x1, %r14d
jne 0x4673
movsd -0x18(%rbp), %xmm0
divsd 0x4ab0(%rip), %xmm0     # 0x9020
movsd %xmm0, -0x18(%rbp)
movsd %xmm0, 0x8(%rbx)
movl $0x30, %edi
callq 0x2220
movq %rax, %r14
cvttsd2si -0x18(%rbp), %esi
movq %rax, %rdi
callq 0x29ba
jmp 0x4666
movl $0x80, %edi
callq 0x2220
movq %rax, %r14
addq $0x38, %rax
movq %rax, 0x8(%r14)
movl $0x1, %eax
movq %rax, 0x10(%r14)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%r14)
movl $0x3f800000, 0x28(%r14) # imm = 0x3F800000
movupd %xmm0, 0x30(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x60(%r14)
movq %rax, 0x48(%r14)
xorl %eax, %eax
movq %rax, 0x40(%r14)
movq %rax, 0x68(%r14)
movq $0x3b9aca00, 0x50(%r14) # imm = 0x3B9ACA00
movq $-0x3b9aca00, 0x58(%r14) # imm = 0xC4653600
leaq 0x8779(%rip), %rax      # 0xcd78
movq %rax, (%r14)
movabsq $0x41cdcd6500000000, %rax # imm = 0x41CDCD6500000000
movq %rax, 0x70(%r14)
movabsq $0x40c3880000000000, %rax # imm = 0x40C3880000000000
movq %rax, 0x78(%r14)
jmp 0x4666
movl $0x18, %edi
callq 0x2220
movq %rax, %r14
cvttsd2si -0x18(%rbp), %eax
leaq 0x8687(%rip), %rcx      # 0xccc0
movq %rcx, (%r14)
movl %eax, 0xc(%r14)
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, 0x10(%r14)
movl $0x0, 0x8(%r14)
movq %r14, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %edi
callq 0x2100
leaq 0x86c4(%rip), %rsi      # 0xcd48
movq %rax, %rdi
xorl %edx, %edx
callq 0x2330
jmp 0x4690
movq %rax, %rbx
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/ChiSquareContinuous.cpp
// Function: ChiSquareContinuous::normal_cdf_inverse(double, double, double)
double ChiSquareContinuous::normal_cdf_inverse(double p, double mean, double SD){
  if (p < 0.0 || p > 1.0)
  {
    //throw an exception
  }

  if(p==0)
    return -99999999;
    
  if(p==1)
    return 99999999;
    
  if (p < 0.5)
  {
    // F^-1(p) = - G^-1(p)
    return -rational_approximation( sqrt(-2.0*log(p)))*SD + mean;
  }
  else
  {
    // F^-1(p) = G^-1(1-p)
    return rational_approximation( sqrt(-2.0*log(1-p)))*SD + mean;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jne 0x4889
jp 0x4889
movsd 0x48ac(%rip), %xmm0     # 0x9130
jmp 0x49dc
ucomisd 0x4777(%rip), %xmm0     # 0x9008
jne 0x48a2
jp 0x48a2
movsd 0x489b(%rip), %xmm0     # 0x9138
jmp 0x49dc
movsd %xmm2, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0x478c(%rip), %xmm1     # 0x9040
ucomisd %xmm0, %xmm1
jbe 0x48d7
callq 0x21a0
mulsd 0x47a1(%rip), %xmm0     # 0x9068
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4904
sqrtsd %xmm0, %xmm0
jmp 0x4909
movsd 0x4729(%rip), %xmm1     # 0x9008
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x21a0
mulsd 0x4774(%rip), %xmm0     # 0x9068
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4975
sqrtsd %xmm0, %xmm0
jmp 0x497a
callq 0x2190
movsd -0x8(%rbp), %xmm3
movsd 0x482a(%rip), %xmm1     # 0x9140
mulsd %xmm0, %xmm1
addsd 0x4826(%rip), %xmm1     # 0x9148
mulsd %xmm0, %xmm1
addsd 0x4822(%rip), %xmm1     # 0x9150
movsd 0x4822(%rip), %xmm2     # 0x9158
mulsd %xmm0, %xmm2
addsd 0x481e(%rip), %xmm2     # 0x9160
mulsd %xmm0, %xmm2
addsd 0x481a(%rip), %xmm2     # 0x9168
mulsd %xmm0, %xmm2
addsd 0x46ae(%rip), %xmm2     # 0x9008
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
mulsd %xmm3, %xmm0
movsd -0x10(%rbp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x49dc
callq 0x2190
movsd -0x8(%rbp), %xmm3
movsd 0x47b9(%rip), %xmm1     # 0x9140
mulsd %xmm0, %xmm1
addsd 0x47b5(%rip), %xmm1     # 0x9148
mulsd %xmm0, %xmm1
addsd 0x47b1(%rip), %xmm1     # 0x9150
movsd 0x47b1(%rip), %xmm2     # 0x9158
mulsd %xmm0, %xmm2
addsd 0x47ad(%rip), %xmm2     # 0x9160
mulsd %xmm0, %xmm2
addsd 0x47a9(%rip), %xmm2     # 0x9168
mulsd %xmm0, %xmm2
addsd 0x463d(%rip), %xmm2     # 0x9008
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
mulsd %xmm3, %xmm0
addsd -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/VaryMemoryOneSample.cpp
// Function: get_estimate(ChiSquareContinuous*, char, int, double, double)
double get_estimate(ChiSquareContinuous *quantile_sketch, char distribution_type, int num_buckets, double location, double scale)
{
  if (distribution_type == 'N')
    return quantile_sketch->calculate_statistic_ifNormal(num_buckets, location, scale);
  else if (distribution_type == 'U')
    return quantile_sketch->calculate_statistic_ifUniform(num_buckets, location, scale);
  else if (distribution_type == 'P')
    return quantile_sketch->calculate_statistic_ifPareto(num_buckets, location, scale);
  else
    return quantile_sketch->calculate_statistic_ifExponential(num_buckets, location, scale);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x55, %esi
je 0x6750
cmpl $0x50, %esi
je 0x6747
cmpl $0x4e, %esi
jne 0x6759
movl %edx, %esi
popq %rbp
jmp 0x46e0
leaq -0x1ad4(%rip), %rax     # 0x4c7a
jmp 0x6760
leaq -0x1b61(%rip), %rax     # 0x4bf6
jmp 0x6760
leaq -0x1a36(%rip), %rax     # 0x4d2a
movl %edx, %esi
movq %rax, %rdx
xorl %ecx, %ecx
popq %rbp
jmp 0x4a2c
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/QDigestDouble.h
// Function: QDigestDouble::insert(double)
void insert(double x)
  { 
    if (x < -range)
      x = 0;
    if (x > range)
      x = precision;
    QDigest::insert(doubleToLong(x)); 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x70(%rdi), %xmm1
movsd 0x78(%rdi), %xmm2
movapd 0x2546(%rip), %xmm3     # 0x91d0
xorpd %xmm2, %xmm3
movapd %xmm0, %xmm4
cmpltsd %xmm3, %xmm4
andnpd %xmm0, %xmm4
movapd %xmm2, %xmm0
cmpltsd %xmm4, %xmm0
movapd %xmm0, %xmm3
andnpd %xmm4, %xmm3
andpd %xmm1, %xmm0
orpd %xmm3, %xmm0
addsd %xmm2, %xmm0
addsd %xmm2, %xmm2
divsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
popq %rbp
jmp 0x30e6
nop
// File: /workspace/github_cpp_makefile_star2_O3/Joke-Shi[P]astrunc/sample/sample_en.cc
// Function: main
int main( int argc, const char **argv)
{         
    std::string s_en = "He said: Chang suggested organizing a canine patrol squad at the "
                       "museum \"abc\" and, in 1987, dogs came back. At 1 year old, each dog is "
                       "given a tailored training course. ";

    std::vector< std::string> vec_s;
    int rc = astrunc::access::split( vec_s, s_en, astrunc::access::EN, 32);
    if ( 0 == rc) {
        for ( auto const &__s : vec_s) {
            std::cout << __s << std::endl;
            std::cout << "------------------------------------------------------------------\n";
        }
    } else { std::cerr << "[Error]: Split error\n"; }


    return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x15cd(%rip), %rsi      # 0x82f8
leaq 0x166f(%rip), %rdx      # 0x83a1
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x71da
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
cmpq $0x0, 0x8(%r14)
je 0x6e04
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
movl $0x20, %edx
callq 0x40a0
movl %eax, %ebp
testl %eax, %eax
je 0x6d90
movq 0x4275(%rip), %rdi      # 0xaff0
leaq 0x1664(%rip), %rsi      # 0x83e6
movl $0x15, %edx
callq 0x2150
movl %ebp, %ebx
jmp 0x6e04
movq (%rsp), %rbp
movq 0x8(%rsp), %r13
cmpq %r13, %rbp
je 0x6e04
movq 0x422b(%rip), %r14      # 0xafd0
leaq 0x15f6(%rip), %r15      # 0x83a2
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %r14, %rdi
callq 0x2150
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movl $0x43, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
addq $0x20, %rbp
cmpq %r13, %rbp
jne 0x6dac
leaq 0x28(%rsp), %r15
movq %rsp, %rdi
callq 0x6ece
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x6e23
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2130
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e36
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6ece
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6e5d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kentcz[P]rapl-tools/Rapl.cpp
// Function: Rapl::Rapl()
Rapl::Rapl() {

	open_msr();
	pp1_supported = detect_pp1();

	/* Read MSR_RAPL_POWER_UNIT Register */
	uint64_t raw_value = read_msr(MSR_RAPL_POWER_UNIT);
	power_units = pow(0.5,	(double) (raw_value & 0xf));
	energy_units = pow(0.5,	(double) ((raw_value >> 8) & 0x1f));
	time_units = pow(0.5,	(double) ((raw_value >> 16) & 0xf));

	/* Read MSR_PKG_POWER_INFO Register */
	raw_value = read_msr(MSR_PKG_POWER_INFO);
	thermal_spec_power = power_units * ((double)(raw_value & 0x7fff));
	minimum_power = power_units * ((double)((raw_value >> 16) & 0x7fff));
	maximum_power = power_units * ((double)((raw_value >> 32) & 0x7fff));
	time_window = time_units * ((double)((raw_value >> 48) & 0x7fff));

	reset();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x0, 0x4(%rdi)
movb $0x1, 0x8(%rdi)
callq 0x2984
movl $0x1, %eax
cpuid
andl $0xffff0, %eax          # imm = 0xFFFF0
cmpl $0x206d0, %eax          # imm = 0x206D0
setne %cl
cmpl $0x306f0, %eax          # imm = 0x306F0
setne %al
andb %cl, %al
movb %al, 0x8(%r14)
movq %r14, %rdi
movl $0x606, %esi            # imm = 0x606
callq 0x2afc
movq %rax, %rbx
andl $0xf, %eax
cvtsi2sd %eax, %xmm0
orpd 0x17c0(%rip), %xmm0     # 0x4070
callq 0x2120
movsd %xmm0, 0x10(%r14)
movl %ebx, %eax
shrl $0x8, %eax
andl $0x1f, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
orpd 0x179e(%rip), %xmm0     # 0x4070
callq 0x2120
movsd %xmm0, 0x18(%r14)
shrl $0x10, %ebx
andl $0xf, %ebx
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
orpd 0x177e(%rip), %xmm0     # 0x4070
callq 0x2120
movsd %xmm0, 0x20(%r14)
movq %r14, %rdi
movl $0x614, %esi            # imm = 0x614
callq 0x2afc
movupd 0x10(%r14), %xmm0
movq %rax, %xmm1
shrl $0x10, %eax
movd %eax, %xmm2
movdqa %xmm1, %xmm3
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movdqa 0x1754(%rip), %xmm2     # 0x4080
pand %xmm2, %xmm3
cvtdq2pd %xmm3, %xmm3
movapd %xmm0, %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
mulpd %xmm3, %xmm4
movupd %xmm4, 0x28(%r14)
pshufd $0x44, %xmm1, %xmm3     # xmm3 = xmm1[0,1,0,1]
psrlq $0x20, %xmm1
psrlq $0x30, %xmm3
movsd %xmm1, %xmm3            # xmm3 = xmm1[0],xmm3[1]
shufps $0xe8, %xmm3, %xmm3     # xmm3 = xmm3[0,2,2,3]
andps %xmm2, %xmm3
cvtdq2pd %xmm3, %xmm1
movhpd 0x20(%r14), %xmm0       # xmm0 = xmm0[0],mem[0]
mulpd %xmm1, %xmm0
movupd %xmm0, 0x38(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b20
nop
// File: /workspace/github_cpp_makefile_star2_O3/kentcz[P]rapl-tools/Rapl.cpp
// Function: Rapl::open_msr()
void Rapl::open_msr() {
	std::stringstream filename_stream;
	filename_stream << "/dev/cpu/" << core << "/msr";
	fd = open(filename_stream.str().c_str(), O_RDONLY);
	if (fd < 0) {
		if ( errno == ENXIO) {
			fprintf(stderr, "rdmsr: No CPU %d\n", core);
			exit(2);
		} else if ( errno == EIO) {
			fprintf(stderr, "rdmsr: CPU %d doesn't support MSRs\n", core);
			exit(3);
		} else {
			perror("rdmsr:open");
			fprintf(stderr, "Trying to open %s\n",
					filename_stream.str().c_str());
			exit(127);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20c0
leaq 0x30(%rsp), %r14
leaq 0x1731(%rip), %rsi      # 0x40d8
movl $0x9, %edx
movq %r14, %rdi
callq 0x2170
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x2230
leaq 0x171c(%rip), %rsi      # 0x40e2
movl $0x4, %edx
movq %rax, %rdi
callq 0x2170
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x21f0
movq (%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x20d0
movl %eax, (%rbx)
leaq 0x10(%rsp), %rcx
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x2a0c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movl (%rbx), %eax
testl %eax, %eax
js 0x2a39
movq 0x3591(%rip), %rsi      # 0x5fa8
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0xa0(%rsp), %rdi
callq 0x2080
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
addq $0x4, %rbx
callq 0x2040
movl (%rax), %eax
cmpl $0x5, %eax
je 0x2a84
cmpl $0x6, %eax
je 0x2a7c
leaq 0x16c8(%rip), %rdi      # 0x411d
callq 0x20f0
movq 0x3577(%rip), %rax      # 0x5fd8
movq (%rax), %rbx
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2140
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x22ac
movq %rbx, %rdi
callq 0x2286
movq %rbx, %rdi
callq 0x2260
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ab3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x2ab3
jmp 0x2ab0
jmp 0x2ab0
movq %rax, %rbx
movq 0x34ee(%rip), %rsi      # 0x5fa8
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0xa0(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/kentcz[P]rapl-tools/Rapl.cpp
// Function: Rapl::read_msr(int)
uint64_t Rapl::read_msr(int msr_offset) {
	uint64_t data;
	if (pread(fd, &data, sizeof(data), msr_offset) != sizeof(data)) {
		perror("read_msr():pread");
		exit(127);
	}
	return data;
}

// Assembly:
pushq %rax
movl (%rdi), %edi
movslq %esi, %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq 0x2190
cmpq $0x8, %rax
jne 0x2b1b
movq (%rsp), %rax
popq %rcx
retq
callq 0x22d7
// File: /workspace/github_cpp_makefile_star2_O3/kentcz[P]rapl-tools/Rapl.cpp
// Function: Rapl::reset()
void Rapl::reset() {

	prev_state = &state1;
	current_state = &state2;
	next_state = &state3;

	// sample twice to fill current and previous
	sample();
	sample();

	// Initialize running_total
	running_total.pkg = 0;
	running_total.pp0 = 0;
	running_total.dram = 0;
	gettimeofday(&(running_total.tsc), NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x60(%rdi), %rax
movq %rax, 0x50(%rdi)
leaq 0x90(%rdi), %rax
movq %rax, 0x48(%rdi)
leaq 0xc0(%rdi), %rax
movq %rax, 0x58(%rdi)
callq 0x2b76
movq %rbx, %rdi
callq 0x2b76
movq $0x0, 0x108(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xf0(%rbx)
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/kentcz[P]rapl-tools/Rapl.cpp
// Function: Rapl::sample()
void Rapl::sample() {
	uint32_t max_int = ~((uint32_t) 0);

	next_state->pkg = read_msr(MSR_PKG_ENERGY_STATUS) & max_int;
	next_state->pp0 = read_msr(MSR_PP0_ENERGY_STATUS) & max_int;

	if (pp1_supported) {
		next_state->pp1 = read_msr(MSR_PP1_ENERGY_STATUS) & max_int;
		next_state->dram = 0;
	} else {
		next_state->pp1 = 0;
		next_state->dram = read_msr(MSR_DRAM_ENERGY_STATUS) & max_int;
	}

	gettimeofday(&(next_state->tsc), NULL);


	// Update running total
	running_total.pkg += energy_delta(current_state->pkg, next_state->pkg);
	running_total.pp0 += energy_delta(current_state->pp0, next_state->pp0);
	running_total.pp1 += energy_delta(current_state->pp0, next_state->pp0);
	running_total.dram += energy_delta(current_state->dram, next_state->dram);

	// Rotate states
	rapl_state_t *pprev_state = prev_state;
	prev_state = current_state;
	current_state = next_state;
	next_state = pprev_state;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x611, %esi            # imm = 0x611
callq 0x2afc
movl %eax, %eax
movq 0x58(%rbx), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
movl $0x639, %esi            # imm = 0x639
callq 0x2afc
movl %eax, %ecx
movq 0x58(%rbx), %rax
movq %rcx, 0x8(%rax)
cmpb $0x1, 0x8(%rbx)
jne 0x2bc5
movq %rbx, %rdi
movl $0x641, %esi            # imm = 0x641
callq 0x2afc
movl %eax, %eax
movq 0x58(%rbx), %rdi
movq %rax, 0x10(%rdi)
xorl %eax, %eax
jmp 0x2be0
movq $0x0, 0x10(%rax)
movq %rbx, %rdi
movl $0x619, %esi            # imm = 0x619
callq 0x2afc
movl %eax, %eax
movq 0x58(%rbx), %rdi
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
xorl %esi, %esi
callq 0x2210
movq 0x58(%rbx), %rax
movq 0x48(%rbx), %rcx
movdqu (%rcx), %xmm0
movdqu (%rax), %xmm1
movdqa %xmm1, %xmm2
psubq %xmm0, %xmm2
movdqa 0x1481(%rip), %xmm3     # 0x4090
pxor %xmm3, %xmm1
pxor %xmm3, %xmm0
movdqa %xmm0, %xmm3
pcmpgtd %xmm1, %xmm3
pcmpeqd %xmm1, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pand %xmm3, %xmm0
pshufd $0xf5, %xmm3, %xmm1     # xmm1 = xmm3[1,1,3,3]
por %xmm0, %xmm1
pand 0x1463(%rip), %xmm1     # 0x40a0
movq 0x50(%rbx), %rdx
movdqu 0xf0(%rbx), %xmm0
paddq %xmm2, %xmm0
paddq %xmm1, %xmm0
movdqu %xmm0, 0xf0(%rbx)
movq 0x8(%rax), %rsi
subq 0x8(%rcx), %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq (%rsi,%rdi), %r8
cmovaeq %rsi, %r8
addq %r8, 0x100(%rbx)
movq 0x18(%rax), %rsi
subq 0x18(%rcx), %rsi
leaq (%rsi,%rdi), %rdi
cmovaeq %rsi, %rdi
addq %rdi, 0x108(%rbx)
movq %rcx, 0x50(%rbx)
movq %rax, 0x48(%rbx)
movq %rdx, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/henrixh[P]shittydsa/examples/fft.cpp
// Function: main
int main(int, char**) {
  ul len_a, len_b;
  cin >> len_a >> len_b;
  vd a,b;

  fp x;
  for (ul i { 0 }; i < len_a; ++i) {
    cin >> x;
    a.push_back(x);
  }

  for (ul i { 0 }; i < len_b; ++i) {
    cin >> x;
    b.push_back(x);
  }

  vd r { convolve(a,b) };
  r.resize(len_a+len_b);
  for (auto x : r) {
    cout << round(x) << '\n';
  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq 0x3463(%rip), %rdi      # 0x4fe0
leaq 0x14(%rsp), %rbx
movq %rbx, %rsi
callq 0x1120
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1120
xorl %r12d, %r12d
movq %r12, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r12, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
cmpl $0x0, (%rbx)
je 0x1c08
movq 0x3423(%rip), %rbx      # 0x4fe0
leaq 0x18(%rsp), %r14
leaq 0x40(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
movq 0x48(%rsp), %rsi
cmpq 0x50(%rsp), %rsi
je 0x1bf3
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x48(%rsp)
jmp 0x1bfe
movq %r15, %rdi
movq %r14, %rdx
callq 0x2362
incl %r12d
cmpl 0x14(%rsp), %r12d
jb 0x1bc7
cmpl $0x0, 0x10(%rsp)
je 0x1c61
xorl %ebp, %ebp
movq 0x33c8(%rip), %rbx      # 0x4fe0
leaq 0x18(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x1c4e
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x28(%rsp)
jmp 0x1c59
movq %r15, %rdi
movq %r14, %rdx
callq 0x2362
incl %ebp
cmpl 0x10(%rsp), %ebp
jb 0x1c22
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1693
movl 0x10(%rsp), %esi
addl 0x14(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0x1f36
movq 0x58(%rsp), %rbx
movq 0x60(%rsp), %r12
cmpq %r12, %rbx
je 0x1cd6
movq 0x3333(%rip), %r14      # 0x4fd0
leaq 0xf(%rsp), %r15
movsd (%rbx), %xmm0
callq 0x1050
movq %r14, %rdi
callq 0x1100
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d0
addq $0x8, %rbx
cmpq %r12, %rbx
jne 0x1ca2
movq 0x58(%rsp), %rbx
testq %rbx, %rbx
je 0x1ceb
movq 0x68(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x10c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d02
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1d19
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d33
jmp 0x1d2e
jmp 0x1d2e
movq %rax, %rbx
jmp 0x1d4d
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1d4d
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1d64
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1d7b
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O3/superblocks[P]superblocks/set-nug.cpp
// Function: Superblocks::init()
void Superblocks::init() {

	coin = "NUG"; 
	coin_name = "Nuggets";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 49;

	// superblock (step 1)
	reward[1] = 10045; // superblock reward (step 1)
	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 55;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 1000000;
	luck_type[1] = LUCK_WITH_LESS_THAN_X;
	luck_x[1] = 9723;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
movq 0x20(%rbx), %rdx
leaq 0x18f4(%rip), %rcx      # 0x3b00
movl $0x3, %r8d
xorl %esi, %esi
callq 0x1130
leaq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rdx
leaq 0x18dc(%rip), %rcx      # 0x3b04
movl $0x7, %r8d
xorl %esi, %esi
callq 0x1130
movl $0x40, 0x58(%rbx)
movabsq $0x273d00000031, %rax   # imm = 0x273D00000031
movq %rax, 0xd4(%rbx)
movl $0x2, 0x60(%rbx)
movl $0x37, 0x68(%rbx)
movl $0x7, 0x70(%rbx)
movl $0x1, %eax
movl %eax, 0x78(%rbx)
movl $0xf4240, 0x80(%rbx)    # imm = 0xF4240
movl %eax, 0xc0(%rbx)
movl $0x25fb, 0xc8(%rbx)     # imm = 0x25FB
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ahupp[P]mural/search.cpp
// Function: is_fuzzy_match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*)
bool is_fuzzy_match(const string& symbol, const string& query,
                    int* inter_count_ret) {

  size_t qi = 0;
  size_t si = 0;
  int lastmatch = -1;

  // The number of characters between fuzzy matches.  This is 0 if
  // query is a substring of symbol.  Larger values of inter_count
  // will generally be worse matches than smaller values.
  int inter_count = 0;

  while (qi < query.length() && si < symbol.length()) {
    if (query[qi] == symbol[si]) {
      if (lastmatch != -1) {
        inter_count += si - lastmatch - 1;
      }
      lastmatch = si;
      ++qi;
    }
    ++si;
  }
  *inter_count_ret = inter_count;
  return qi == query.length();
}

// Assembly:
movq 0x8(%rsi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
setne %r8b
testq %rcx, %rcx
setne %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x2d9b
pushq %rbp
pushq %rbx
movq (%rsi), %r8
movq (%rdi), %r9
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
xorl %edi, %edi
xorl %r11d, %r11d
xorl %esi, %esi
movb (%r8,%rsi), %bpl
cmpb (%r9,%r11), %bpl
jne 0x2d8a
movl %ebx, %ebp
notl %ebp
addl %r11d, %ebp
cmpl $-0x1, %ebx
cmovel %r10d, %ebp
addl %ebp, %edi
incq %rsi
movl %r11d, %ebx
cmpq %rax, %rsi
jae 0x2d97
incq %r11
cmpq %rcx, %r11
jb 0x2d6a
popq %rbx
popq %rbp
jmp 0x2d9f
xorl %esi, %esi
xorl %edi, %edi
movl %edi, (%rdx)
cmpq %rax, %rsi
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/ahupp[P]mural/search.cpp
// Function: is_better_match(std::pair<TagInfo const*, int> const&, std::pair<TagInfo const*, int> const&)
bool is_better_match(const FuzzyMatch& lhs, const FuzzyMatch& rhs) {
  if (lhs.second < rhs.second) {
    return true;
  } else if (lhs.second == rhs.second) {
    if (lhs.first->symbol.length() < rhs.first->symbol.length()) {
      return true;
    }
  }
  return false;
}

// Assembly:
movl 0x8(%rsi), %ecx
movb $0x1, %al
cmpl %ecx, 0x8(%rdi)
jl 0x2dc6
jne 0x2dc4
movq (%rdi), %rcx
movq 0x8(%rcx), %rcx
movq (%rsi), %rdx
cmpq 0x8(%rdx), %rcx
jb 0x2dc6
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ahupp[P]mural/search.cpp
// Function: find_all_fuzzy_matches(std::vector<TagInfo, std::allocator<TagInfo>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
vector<FuzzyMatch> find_all_fuzzy_matches(const vector<TagInfo>& tags,
                                          const string& query,
                                          const bool ignore_case) {
  // Searches that don't explicitly look like a method ("::") will
  // never include methods, and vice-versa.
  bool methods_only = is_method_tag(query);

  vector<FuzzyMatch> matches;

  for (size_t i = 0; i < tags.size(); ++i) {
    int inter_count;
    const TagInfo& tag = tags[i];

    if (tag.is_method != methods_only) {
      // could split the tags into method and non-method sets and only
      // search one, but right now it's fast enough.
      continue;
    }

    if (is_fuzzy_match(ignore_case ? tag.symbol_lc : tag.symbol,
                       query, &inter_count)) {
      // Passing &tag here is an important perf optimization to avoid
      // excessive copying when there are many possible results (like
      // "A")
      matches.push_back(make_pair(&tag, inter_count));
    }
  }
  return matches;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq %rdx, %rdi
callq 0x39a8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %r15
movq %r14, 0x10(%rsp)
movq 0x8(%r14), %r13
cmpq %r15, %r13
je 0x2eb2
movl %eax, %ebp
movzbl %r12b, %eax
shll $0x5, %eax
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
xorl %r14d, %r14d
cmpb %bpl, 0x64(%r15,%r12)
jne 0x2e8a
movq 0x18(%rsp), %rax
leaq (%r15,%rax), %rdi
addq %r12, %rdi
movq 0x20(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x2d34
testb %al, %al
je 0x2e8a
addq %r12, %r15
movl 0xc(%rsp), %eax
movq %r15, 0x28(%rsp)
movl %eax, 0x30(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2e71
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x2e7e
movq %rbx, %rdi
leaq 0x28(%rsp), %rdx
callq 0x313e
movq 0x10(%rsp), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
incq %r14
movq %r13, %rax
subq %r15, %rax
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rcx # imm = 0x4EC4EC4EC4EC4EC5
imulq %rcx, %rax
addq $0x68, %r12
cmpq %rax, %r14
jb 0x2e22
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2edb
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/ahupp[P]mural/tags.cpp
// Function: lowercase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string lowercase(const string& s) {
  string ret = s;
  for (size_t i = 0; i < ret.length(); ++i) {
    ret[i] = tolower(ret[i]);
  }
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x3736
cmpq $0x0, 0x8(%rbx)
je 0x3a0a
xorl %r14d, %r14d
movq (%rbx), %r15
movsbl (%r15,%r14), %edi
callq 0x22a0
movb %al, (%r15,%r14)
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x39f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ahupp[P]mural/tags.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> split(const string& line, char delim) {

  vector<string> result;

  size_t i = 0;
  while (1) {

    size_t next = line.find(delim, i);
    if (next == string::npos) {
      break;
    }

    result.push_back(line.substr(i, next - i));

    i = next + 1;
  }
  result.push_back(line.substr(i, line.length() - i));

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %r13d, %r13d
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x2270
cmpq $-0x1, %rax
je 0x3ab2
movq %rax, %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movsbl %bpl, %ebp
movq %r15, %rcx
subq %r13, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2210
movq %rbx, %rdi
movq %r12, %rsi
callq 0x46dc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a96
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %r15, %r13
incq %r13
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x2270
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x3a5b
movq 0x8(%r14), %rcx
subq %r13, %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2210
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x46dc
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3af1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x3b25
jmp 0x3b13
movq %rax, %r14
jmp 0x3b37
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3b37
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x4502
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/ahupp[P]mural/tags.cpp
// Function: read_tags_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<TagInfo, std::allocator<TagInfo>>&)
void read_tags_file(const string& tags_file, vector<TagInfo>& tags) {

  if (0 != access(tags_file.c_str(), R_OK)) {
    cerr << "error: " << tags_file << " not readable" << endl;
    exit(1);
  }

  tags.clear();

  ifstream tags_stream(tags_file.c_str());

  string line;
  getline(tags_stream, line);
  tags_stream.seekg(0);

  if (line.length() && line[0] == '!') {
    read_ctags_file(tags_stream, tags);
  } else {
    read_etags_file(tags_stream, tags);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x4, %esi
callq 0x22f0
testl %eax, %eax
jne 0x4496
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x4c94
movq (%r14), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2360
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %edx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2370
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2260
cmpq $0x0, 0x10(%rsp)
je 0x445b
movq 0x8(%rsp), %rax
cmpb $0x21, (%rax)
jne 0x445b
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x3b47
jmp 0x4468
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x3f84
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x447f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x28(%rsp), %rdi
callq 0x2070
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq 0x3b53(%rip), %rdi      # 0x7ff0
leaq 0xc49(%rip), %rsi       # 0x50ed
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
leaq 0xc3a(%rip), %rsi       # 0x50f5
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x2240
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x44ef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x28(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./DirectoryIterator.h
// Function: jshund::DirectoryIterator::addFiles(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void addFiles (std::vector<std::string>& files, std::string const& argument) {
        if (isFile(argument)) {
          files.push_back(std::string(argument));
        }
        else if (isDir(argument)) {
          addDir(files, argument);
        }
        else {
          std::cerr << "Ignoring invalid file/directory path '" << argument << "'" << std::endl;
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x21d0
movl $0xf000, %ebp           # imm = 0xF000
testl %eax, %eax
jne 0x2e7f
movl 0x38(%rsp), %eax
andl %ebp, %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x2e7f
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x35cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x335c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2edf
movq 0x30(%rsp), %rsi
jmp 0x2ed7
movq (%r14), %rdi
leaq 0x20(%rsp), %rsi
callq 0x21d0
testl %eax, %eax
jne 0x2eef
andl 0x38(%rsp), %ebp
cmpl $0x4000, %ebp           # imm = 0x4000
jne 0x2eef
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x35cc
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2f9c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2edf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x90fa(%rip), %rbx      # 0xbff0
leaq 0x5289(%rip), %rsi      # 0x8186
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2250
movq %rax, %rbx
leaq 0x5498(%rip), %rsi      # 0x83bb
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2160
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2f93
movq 0x10(%rsp), %rsi
jmp 0x2f8b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f93
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./FileReader.h
// Function: jshund::FileReader::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
char* read (const std::string& fileName) {
        std::ifstream f;

        f.open(fileName.c_str(), std::ifstream::in | std::ifstream::binary);

        if (! f.is_open()) {
          return 0;
        }

        // get filesize
        f.seekg(0, std::ios::end);
        int fileSize = f.tellg();
        f.seekg(0, std::ios::beg);

        // allocate buffer plus some extra bytes
        char* buffer = new char[fileSize + 5];

        if (buffer != 0) {
          // initialise buffer with 0s
          memset(buffer + fileSize, 0, 5);

          // read contents
          f.read(buffer, fileSize);
          f.close();
        }

        return buffer;
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2240
movq (%rbx), %rsi
movq %r14, %rdi
movl $0xc, %edx
callq 0x2140
leaq 0x78(%rsp), %rdi
callq 0x2080
testb %al, %al
je 0x3703
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x22b0
movq %rsp, %rdi
callq 0x2360
movq %rax, %rbx
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22b0
shlq $0x20, %rbx
movabsq $0x500000000, %rdi      # imm = 0x500000000
addq %rbx, %rdi
sarq $0x20, %rdi
callq 0x2030
movq %rax, %r14
sarq $0x20, %rbx
movb $0x0, 0x4(%rax,%rbx)
movl $0x0, (%rax,%rbx)
movq %rsp, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2280
movq %rsp, %rdi
callq 0x2070
jmp 0x3706
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0x2090
movq %r14, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0x3722
jmp 0x3722
jmp 0x3722
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::tokenize(char const*)
const std::vector<Token>& tokenize (char const* input) {
        _input    = input;
        _length   = ::strlen(input);
        _position = 0;
        _line     = 1; 
        _last     = TOKEN_UNKNOWN;

        _tokens.clear();

        doTokenize();

        if (_debug) {
          for (size_t i = 0; i < _tokens.size(); ++i) {
            _tokens[i].dump();
          }
        }

        return _tokens;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x80(%rdi)
movq %rsi, %rdi
callq 0x20f0
movq %rax, 0x88(%rbx)
movq $0x0, 0x90(%rbx)
movq $0x1, 0x98(%rbx)
movl $0x0, 0x78(%rbx)
leaq 0x60(%rbx), %r14
movq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x6d80
movq %rbx, %rdi
callq 0x6b7e
cmpb $0x1, 0xa0(%rbx)
jne 0x5b65
movq 0x60(%rbx), %rdi
cmpq %rdi, 0x68(%rbx)
je 0x5b65
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
addq %r15, %rdi
callq 0x6cee
incq %r13
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rax
subq %rdi, %rax
sarq $0x4, %rax
imulq %r12, %rax
addq $0x30, %r15
cmpq %rax, %r13
jb 0x5b3e
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Validator.h
// Function: jshund::Validator::reportError(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void reportError (int line, std::string const& name, bool global) {
        std::cout << _filename << ':' << line << ':'  
                  << (global ? _colorGlobal : _colorLocal) << " unused " << (global ? "global" : "local") 
                  << " variable '" << name << '\'' << _colorEnd  
                  << std::endl;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x60(%rdi), %rsi
movq 0x68(%rdi), %rdx
movq 0x5f12(%rip), %rdi      # 0xbfd0
callq 0x2250
movb $0x3a, %r12b
leaq 0xd(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq %rax, %rdi
movl %r15d, %esi
callq 0x2350
leaq 0xe(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movl %ebp, %ecx
xorb $0x1, %cl
movzbl %cl, %ecx
shll $0x5, %ecx
movq (%rbx,%rcx), %rsi
movq 0x8(%rbx,%rcx), %rdx
movq %rax, %rdi
callq 0x2250
movq %rax, %r15
leaq 0x227a(%rip), %rsi      # 0x839b
movl $0x8, %edx
movq %rax, %rdi
callq 0x2250
leaq 0x226f(%rip), %rax      # 0x83a4
leaq 0x226f(%rip), %rsi      # 0x83ab
testl %ebp, %ebp
cmovneq %rax, %rsi
movl %ebp, %edx
addq $0x5, %rdx
movq %r15, %rdi
callq 0x2250
leaq 0x225a(%rip), %rsi      # 0x83b1
movl $0xb, %edx
movq %r15, %rdi
callq 0x2250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2250
leaq 0xf(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
movq %rax, %rdi
callq 0x2250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop