LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/ImagePairStats.cpp
// Function: calculateLabScore(Image3ChnlReal const&, Image3ChnlReal const&)
Float_t calculateLabScore(const Image3ChnlReal &imgOri, const Image3ChnlReal &img)
{
	assert(imgOri.width() == img.width() && imgOri.height() == img.height());
	
	//We must invert the sign of the lab delta error so that higher lab delta errors are better.
	//This way, psnr and lab delta error can be compared in a similar fashion, i.e.,
	//that higher scores will be considered better scores.
	
	return -calcImgLabDeltaE(imgOri, img);
}

// Assembly:
pushq %rax
movl 0x28(%rdi), %eax
cmpl 0x28(%rsi), %eax
jne 0x2322c
movl 0x2c(%rdi), %eax
cmpl 0x2c(%rsi), %eax
jne 0x2322c
callq 0x229eb
xorps 0x9266(%rip), %xmm0     # 0x2c490
popq %rax
retq
leaq 0xc472(%rip), %rdi      # 0x2f6a5
leaq 0xc246(%rip), %rsi      # 0x2f480
leaq 0xc539(%rip), %rcx      # 0x2f77a
movl $0xc5, %edx
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/Random.cpp
// Function: RandStdNorm()
Float_t RandStdNorm()
{
	//Standard normal distribution
	
	//Box-Muller
	//http://en.wikipedia.org/wiki/Normal_distribution
	
	//Float_t a = RandZeroFloat(1.0);
	//Float_t b = RandZeroFloat(1.0);
	//Float_t c = sqrt(-2 * log(a)) * cos(2 * Pi * b);
	//return c;
	
	//return sqrt(-2.0 * log(RandZeroFloat(1.0))) * cos(PiTimes2 * RandZeroFloat(1.0));
	
	//================================================================================
	
	//Polar form of Box-Muller
	//http://www.taygeta.com/random/gaussian.html
	
	Float_t x1, x2, w, y1;
	static Float_t y2;
	static bool use_last = false;

	if (use_last)	//Use value from previous call
	{
		y1 = y2;
		use_last = false;
	}
	else
	{
		do
		{
			x1 = 2.0 * RandZeroFloat(1.0) - 1.0;
			x2 = 2.0 * RandZeroFloat(1.0) - 1.0;
			w = x1 * x1 + x2 * x2;
		} while ( w >= 1.0 );
		
		w = sqrt( (-2.0 * log( w ) ) / w );
		y1 = x1 * w;
		y2 = x2 * w;
		use_last = true;
	}

	return y1;//(y1 * stddev + mean);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movb 0x168e6(%rip), %bl      # 0x39be0
testb %bl, %bl
je 0x2330b
movsd 0x168d2(%rip), %xmm1    # 0x39bd8
jmp 0x233c9
callq 0x30a0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0xc4a9(%rip), %xmm0     # 0x2f7c8
divsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movsd 0x7d41(%rip), %xmm0     # 0x2b070
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x30a0
movsd 0x8(%rsp), %xmm0
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
divsd 0xc475(%rip), %xmm2     # 0x2f7c8
addsd %xmm2, %xmm2
addsd 0x7d11(%rip), %xmm2     # 0x2b070
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
ucomisd 0x7ce1(%rip), %xmm0     # 0x2b058
jae 0x2330b
movsd %xmm2, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
callq 0x3250
mulsd 0xc43e(%rip), %xmm0     # 0x2f7d0
divsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x233a8
sqrtsd %xmm0, %xmm0
jmp 0x233ad
callq 0x3240
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x1680f(%rip)    # 0x39bd8
xorb $0x1, %bl
movb %bl, 0x1680e(%rip)      # 0x39be0
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/Bayer.cpp
// Function: determineBlockCorner(int, int)
BlockCorner determineBlockCorner(int x, int y)
{
	int x2 = x % 2, y2 = y % 2;
	
	if (x2 == 0 && y2 == 0)
		return UL;
	if (x2 == 1 && y2 == 0)
		return UR;
	if (x2 == 0 && y2 == 1)
		return LL;
	//if (x2 == 1 && y2 == 1)
		return LR;
}

// Assembly:
movl %edi, %eax
shrl $0x1f, %eax
addl %edi, %eax
andl $-0x2, %eax
subl %eax, %edi
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
andl $-0x2, %eax
subl %eax, %esi
movl %esi, %eax
orl %edi, %eax
je 0x23467
movl %edi, %ecx
xorl $0x1, %ecx
movl $0x1, %eax
orl %esi, %ecx
je 0x23466
xorl $0x1, %esi
xorl %eax, %eax
orl %esi, %edi
sete %al
xorl $0x3, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/Bayer.cpp
// Function: determineBlockColorOrder(int&, int&, int&, int&, int&, int&, int&, int&, int&, int&)
void determineBlockCoord(Color color, int &x, int &y)
{
	assert(color != G);
	if (color == R)
	{
		if (gBayerPattern == kRGGB || gBayerPattern == kGRBG)
			y = 0;
		else y = 1;
		
		if (gBayerPattern == kRGGB || gBayerPattern == kGBRG)
			x = 0;
		else x = 1;
	}
	else //if (color == B)
	{
		if (gBayerPattern == kBGGR || gBayerPattern == kGBRG)
			y = 0;
		else y = 1;
		
		if (gBayerPattern == kBGGR || gBayerPattern == kGRBG)
			x = 0;
		else x = 1;
	}
}

// Assembly:
pushq %rbx
movq 0x13e2e(%rip), %rax     # 0x37320
leaq 0x13de7(%rip), %r10     # 0x372e0
cmpq %r10, %rax
sete %r10b
leaq 0x13df9(%rip), %r11     # 0x37300
cmpq %r11, %rax
sete %r11b
movl %r10d, %ebx
orb %r11b, %bl
xorb $0x1, %bl
movzbl %bl, %ebx
movl %ebx, (%rsi)
leaq 0x13ded(%rip), %rbx     # 0x37310
cmpq %rbx, %rax
sete %bl
orb %bl, %r10b
xorb $0x1, %r10b
movzbl %r10b, %r10d
movl %r10d, (%rdi)
leaq 0x13db2(%rip), %r10     # 0x372f0
cmpq %r10, %rax
sete %al
orb %al, %bl
xorb $0x1, %bl
movzbl %bl, %r10d
movl %r10d, (%r9)
orb %r11b, %al
xorb $0x1, %al
movzbl %al, %eax
movl %eax, (%r8)
cmpl %eax, (%rdi)
je 0x23619
movl (%rsi), %eax
cmpl (%r9), %eax
je 0x23619
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
movl (%rsi), %eax
orl (%rdi), %eax
je 0x23582
movl (%r9), %eax
orl (%r8), %eax
jne 0x23588
movl $0x1, (%rdx)
movl (%rdi), %eax
movl (%rsi), %ecx
movl %eax, %edx
orl %ecx, %edx
jne 0x235a5
movl $0x2, %eax
movl $0x3, %ecx
movl $0x1, %edx
xorl %esi, %esi
jmp 0x235f8
xorl $0x1, %eax
orl %ecx, %eax
jne 0x235bf
movl $0x3, %eax
movl $0x2, %ecx
xorl %edx, %edx
movl $0x1, %esi
jmp 0x235f8
movl (%r8), %ecx
movl (%r9), %eax
movl %ecx, %edx
orl %eax, %edx
jne 0x235de
movl $0x2, %eax
xorl %ecx, %ecx
movl $0x1, %edx
movl $0x3, %esi
jmp 0x235f8
cmpl $0x1, %ecx
jne 0x23638
testl %eax, %eax
jne 0x23638
xorl %edx, %edx
movl $0x3, %eax
movl $0x1, %ecx
movl $0x2, %esi
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %r10
movl %esi, (%r10)
movl %edx, (%r9)
movl %ecx, (%r8)
movl %eax, (%rdi)
popq %rbx
retq
leaq 0xc1fb(%rip), %rdi      # 0x2f81b
leaq 0xc1bc(%rip), %rsi      # 0x2f7e3
leaq 0xc202(%rip), %rcx      # 0x2f830
movl $0x55, %edx
callq 0x31c0
leaq 0xaef7(%rip), %rdi      # 0x2e536
leaq 0xc19d(%rip), %rsi      # 0x2f7e3
leaq 0xc1e3(%rip), %rcx      # 0x2f830
movl $0x78, %edx
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fft2d.cpp
// Function: fft2dInit(long, long)
int fft2dInit(long M2, long M){
	// init for fft2d, ifft2d, rfft2d, and rifft2d
	// malloc storage for 4 columns of 2d ffts then call fftinit for both row and column ffts sizes
/* INPUTS */
/* M = log2 of number of columns */
/* M2 = log2 of number of rows */
/*       of 2d matrix to be fourier transformed */
/* OUTPUTS */
/* private storage for columns of 2d ffts	*/
/* calls fftInit for cosine and bit reversed tables	*/
int theError = 1;
if ((M2 >= 0) && (M2 < 8*sizeof(long))){
	theError = 0;
	if (Array2d[M2] == 0){
		Array2d[M2] = (Float_t *) malloc( 4*2*POW2(M2)*sizeof(Float_t) );
		if (Array2d[M2] == 0)
			theError = 2;
		else{
			theError = fftInit(M2);
		}
	}
	if (theError == 0)
		theError = fftInit(M);
}
return theError;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x1, %eax
cmpq $0x3f, %rdi
ja 0x236aa
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1657b(%rip), %r15     # 0x39bf0
xorl %eax, %eax
cmpq $0x0, (%r15,%rdi,8)
jne 0x236a6
movl $0x40, %edi
movl %r14d, %ecx
shlq %cl, %rdi
callq 0x33d0
movq %rax, (%r15,%r14,8)
testq %rax, %rax
je 0x236a1
movq %r14, %rdi
callq 0x247f8
jmp 0x236a6
movl $0x2, %eax
testl %eax, %eax
je 0x236b0
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x247f8
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fft2d.cpp
// Function: fft2dFree()
void fft2dFree(){
// free storage for columns of 2d ffts and call fftFree to free all BRLow and Utbl storage
long i1;
for (i1=8*sizeof(long)-1; i1>=0; i1--){
	if (Array2d[i1] != 0){
		free(Array2d[i1]);
		Array2d[i1] = 0;
	};
};
fftFree();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x3f, %ebx
leaq 0x16522(%rip), %r14     # 0x39bf0
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x236ec
leaq (,%rbx,8), %r15
callq 0x3370
movq $0x0, (%r15,%r14)
addq $-0x1, %rbx
jb 0x236ce
popq %rbx
popq %r14
popq %r15
jmp 0x248ec
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fft2d.cpp
// Function: fft2d(double*, long, long)
void fft2d(Float_t *data, long M2, long M){
/* Compute 2D complex fft and return results in-place	*/
/* INPUTS */
/* *data = input data array	*/
/* M2 = log2 of fft size number of rows */
/* M = log2 of fft size number of columns */
/* OUTPUTS */
/* *data = output data array	*/
long i1;
if((M2>0)&&(M>0)){
	ffts(data, M, POW2(M2));
	if (M>2)
		for (i1=0; i1<POW2(M); i1+=4){
			cxpose(data + i1*2, POW2(M), Array2d[M2], POW2(M2), POW2(M2), 4);
			ffts(Array2d[M2], M2, 4);
			cxpose(Array2d[M2], POW2(M2), data + i1*2, POW2(M), 4, POW2(M2));
		}
	else{
		cxpose(data, POW2(M), Array2d[M2], POW2(M2), POW2(M2), POW2(M));
		ffts(Array2d[M2], M2, POW2(M));
		cxpose(Array2d[M2], POW2(M2), data, POW2(M), POW2(M), POW2(M2));
	}
}
else
	ffts(data, M2+M, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
setle %al
testq %rdx, %rdx
setle %cl
orb %al, %cl
jne 0x237c4
movl $0x1, %r15d
movl $0x1, %r12d
movl %r14d, %ecx
shlq %cl, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x24957
movl %r13d, %ecx
shlq %cl, %r15
cmpq $0x3, %r13
jl 0x237e5
xorl %r13d, %r13d
leaq 0x16492(%rip), %rbp     # 0x39bf0
movq (%rbp,%r14,8), %rdx
movl $0x4, %r9d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r12, %r8
callq 0x2a2c5
movq (%rbp,%r14,8), %rdi
movl $0x4, %edx
movq %r14, %rsi
callq 0x24957
movq (%rbp,%r14,8), %rdi
movl $0x4, %r8d
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r9
callq 0x2a2c5
addq $0x4, %r13
addq $0x40, %rbx
cmpq %r15, %r13
jb 0x2375e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r14, %r13
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24957
leaq 0x16404(%rip), %r13     # 0x39bf0
movq (%r13,%r14,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x2a2c5
movq (%r13,%r14,8), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x24957
movq (%r13,%r14,8), %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r15, %r8
movq %r12, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a2c5
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fft2d.cpp
// Function: ifft2d(double*, long, long)
void ifft2d(Float_t *data, long M2, long M){
/* Compute 2D complex ifft and return results in-place	*/
/* INPUTS */
/* *data = input data array	*/
/* M2 = log2 of fft size number of rows */
/* M = log2 of fft size number of columns */
/* OUTPUTS */
/* *data = output data array	*/
long i1;
if((M2>0)&&(M>0)){
	iffts(data, M, POW2(M2));
	if (M>2)
		for (i1=0; i1<POW2(M); i1+=4){
			cxpose(data + i1*2, POW2(M), Array2d[M2], POW2(M2), POW2(M2), 4);
			iffts(Array2d[M2], M2, 4);
			cxpose(Array2d[M2], POW2(M2), data + i1*2, POW2(M), 4, POW2(M2));
		}
	else{
		cxpose(data, POW2(M), Array2d[M2], POW2(M2), POW2(M2), POW2(M));
		iffts(Array2d[M2], M2, POW2(M));
		cxpose(Array2d[M2], POW2(M2), data, POW2(M), POW2(M), POW2(M2));
	}
}
else
	iffts(data, M2+M, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
setle %al
testq %rdx, %rdx
setle %cl
orb %al, %cl
jne 0x23904
movl $0x1, %r15d
movl $0x1, %r12d
movl %r14d, %ecx
shlq %cl, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x24980
movl %r13d, %ecx
shlq %cl, %r15
cmpq $0x3, %r13
jl 0x23925
xorl %r13d, %r13d
leaq 0x16352(%rip), %rbp     # 0x39bf0
movq (%rbp,%r14,8), %rdx
movl $0x4, %r9d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r12, %r8
callq 0x2a2c5
movq (%rbp,%r14,8), %rdi
movl $0x4, %edx
movq %r14, %rsi
callq 0x24980
movq (%rbp,%r14,8), %rdi
movl $0x4, %r8d
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r9
callq 0x2a2c5
addq $0x4, %r13
addq $0x40, %rbx
cmpq %r15, %r13
jb 0x2389e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r14, %r13
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24980
leaq 0x162c4(%rip), %r13     # 0x39bf0
movq (%r13,%r14,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x2a2c5
movq (%r13,%r14,8), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x24980
movq (%r13,%r14,8), %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r15, %r8
movq %r12, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a2c5
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fft2d.cpp
// Function: fft3dInit(long, long, long)
int fft3dInit(long L, long M2, long M){
	// init for fft3d, ifft3d
	// malloc storage for 4 columns and 4 pages of 3d ffts
	// then call fftinit for page, row and column ffts sizes
//* M = log2 of number of columns */
/* M2 = log2 of number of rows */
/* L = log2 of number of pages */
/*       of 3d matrix to be fourier transformed */
/* OUTPUTS */
/* private storage for columns and pages of 3d ffts	*/
/* calls fftInit for cosine and bit reversed tables	*/
int theError = 1;
if ((L >= 0) && (L < 8*sizeof(long))){
	theError = 0;
	if (Array2d[L] == 0){
		Array2d[L] = (Float_t *) malloc( 4*2*POW2(L)*sizeof(Float_t) );
		if (Array2d[L] == 0)
			theError = 2;
		else{
			theError = fftInit(L);
		}
	}
	if (theError == 0){
		if (Array2d[M2] == 0){
			Array2d[M2] = (Float_t *) malloc( 4*2*POW2(M2)*sizeof(Float_t) );
			if (Array2d[M2] == 0)
				theError = 2;
			else{
				theError = fftInit(M2);
			}
		}
	}
	if (theError == 0)
		theError = fftInit(M);
}
return theError;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %eax
cmpq $0x3f, %rdi
ja 0x23a09
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x16251(%rip), %r12     # 0x39bf0
xorl %eax, %eax
cmpq $0x0, (%r12,%rdi,8)
jne 0x239d0
movl $0x40, %edi
movl %r15d, %ecx
shlq %cl, %rdi
callq 0x33d0
movq %rax, (%r12,%r15,8)
testq %rax, %rax
je 0x239cb
movq %r15, %rdi
callq 0x247f8
jmp 0x239d0
movl $0x2, %eax
testl %eax, %eax
jne 0x23a05
xorl %eax, %eax
cmpq $0x0, (%r12,%r14,8)
jne 0x23a05
movl $0x40, %edi
movl %r14d, %ecx
shlq %cl, %rdi
callq 0x33d0
movq %rax, (%r12,%r14,8)
testq %rax, %rax
je 0x23a00
movq %r14, %rdi
callq 0x247f8
jmp 0x23a05
movl $0x2, %eax
testl %eax, %eax
je 0x23a15
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x247f8
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fft2d.cpp
// Function: rspect2dprod(double*, double*, double*, long, long)
void rspect2dprod(Float_t *data1, Float_t *data2, Float_t *outdata, long N2, long N1){
// When multiplying a pair of 2d spectra from rfft2d care must be taken to multiply the
// four real values seperately from the complex ones. This routine does it correctly.
// the result can be stored in-place over one of the inputs
/* *data1 = input data array	first spectra */
/* *data2 = input data array	second spectra */
/* N2 = fft size number of rows into rfft2d for both data1 and data2 */
/* N1 = fft size number of columns into rfft2d for both data1 and data2 */
long N = N2 * N1/2;		// number of "complex" numbers in spectra

if( (N2 > 1) && (N1>1)){
	outdata[0] = data1[0] * data2[0];	// multiply the zero freq, zero wavenumber values
	outdata[1] = data1[1] * data2[1];	// multiply the zero freq, nyquest wavenumber values

	cvprod(data1 + 2, data2 + 2, outdata + 2, N/2-1);

	outdata[N] = data1[N] * data2[N];		// multiply the nyquest freq, zero wavenumber values
	outdata[N+1] = data1[N+1] * data2[N+1];	// multiply the nyquest freq, nyquest wavenumber values

	cvprod(data1 + N+2, data2 + N+2, outdata + N+2, N/2-1);
}
else{	// really 1D rfft spectra
	N = N2 * N1;	// one of these is a 1
	if(N>1){
		outdata[0] = data1[0] * data2[0];	// multiply the zero freq values
		outdata[1] = data1[1] * data2[1];	// multiply the nyquest freq values
		cvprod(data1 + 2, data2 + 2, outdata + 2, N/2-1);	// multiply the other positive freq values
	}
	else{
		outdata[0] = data1[0] * data2[0];
	}
}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %r8, %r13
imulq %rcx, %r13
movq %r13, %r14
shrq $0x3f, %r14
addq %r13, %r14
sarq %r14
cmpq $0x2, %rcx
setl %al
cmpq $0x2, %r8
setl %cl
orb %al, %cl
jne 0x2479d
movsd (%r12), %xmm0
mulsd (%r15), %xmm0
movsd %xmm0, (%rbx)
movsd 0x8(%r12), %xmm0
mulsd 0x8(%r15), %xmm0
movsd %xmm0, 0x8(%rbx)
leaq 0x10(%r12), %rdi
leaq 0x10(%r15), %rsi
leaq 0x10(%rbx), %rdx
shrq $0x2, %r13
decq %r13
movq %r13, %rcx
callq 0x2a3e0
leaq (%r12,%r14,8), %rdi
addq $0x10, %rdi
movsd -0x10(%rdi), %xmm0
leaq 0x10(%r15,%r14,8), %rsi
mulsd -0x10(%rsi), %xmm0
leaq 0x10(%rbx,%r14,8), %rdx
movsd %xmm0, -0x10(%rdx)
movsd -0x8(%rdi), %xmm0
mulsd -0x8(%rsi), %xmm0
movsd %xmm0, -0x8(%rdx)
movq %r13, %rcx
jmp 0x247df
movsd (%r12), %xmm0
mulsd (%r15), %xmm0
movsd %xmm0, (%rbx)
cmpq $0x2, %r13
jl 0x247ed
movsd 0x8(%r12), %xmm0
mulsd 0x8(%r15), %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x10, %r12
addq $0x10, %r15
addq $0x10, %rbx
decq %r14
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a3e0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fftext.cpp
// Function: fftInit(long)
int fftInit(long M){
// malloc and init cosine and bit reversed tables for a given size fft, ifft, rfft, rifft
/* INPUTS */
/* M = log2 of fft size	(ex M=10 for 1024 point fft) */
/* OUTPUTS */
/* private cosine and bit reversed tables	*/

int theError = 1;
/*** I did NOT test cases with M>27 ***/
if ((M >= 0) && (M < 8*sizeof(long))){
	theError = 0;
	if (UtblArray[M] == 0){	// have we not inited this size fft yet?
		// init cos table
		UtblArray[M] = (Float_t *) malloc( (POW2(M)/4+1)*sizeof(Float_t) );
		if (UtblArray[M] == 0)
			theError = 2;
		else{
			fftCosInit(M, UtblArray[M]);
		}
		if (M > 1){
			if (BRLowArray[M/2] == 0){	// init bit reversed table for cmplx fft
				BRLowArray[M/2] = (short *) malloc( POW2(M/2-1)*sizeof(short) );
				if (BRLowArray[M/2] == 0)
					theError = 2;
				else{
					fftBRInit(M, BRLowArray[M/2]);
				}
			}
		}
		if (M > 2){
			if (BRLowArray[(M-1)/2] == 0){	// init bit reversed table for real fft
				BRLowArray[(M-1)/2] = (short *) malloc( POW2((M-1)/2-1)*sizeof(short) );
				if (BRLowArray[(M-1)/2] == 0)
					theError = 2;
				else{
					fftBRInit(M-1, BRLowArray[(M-1)/2]);
				}
			}
		}
	}
};
return theError;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %ebp
cmpq $0x3f, %rdi
ja 0x248df
movq %rdi, %rbx
leaq 0x155d8(%rip), %r14     # 0x39df0
xorl %ebp, %ebp
cmpq $0x0, (%r14,%rdi,8)
jne 0x248df
movl $0x2, %edi
movl %ebx, %ecx
shlq %cl, %rdi
andq $-0x8, %rdi
addq $0x8, %rdi
callq 0x33d0
movq %rax, (%r14,%rbx,8)
testq %rax, %rax
je 0x24854
movq %rbx, %rdi
movq %rax, %rsi
callq 0x24a28
xorl %ebp, %ebp
jmp 0x24859
movl $0x2, %ebp
leaq 0x15790(%rip), %r15     # 0x39ff0
cmpq $0x2, %rbx
jl 0x2489e
movq %rbx, %r14
shrq %r14
cmpq $0x0, (%r15,%r14,8)
jne 0x2489e
movl $0x1, %edi
movl %r14d, %ecx
shlq %cl, %rdi
callq 0x33d0
movq %rax, (%r15,%r14,8)
testq %rax, %rax
je 0x24899
movq %rbx, %rdi
movq %rax, %rsi
callq 0x24ad1
jmp 0x2489e
movl $0x2, %ebp
cmpq $0x3, %rbx
jl 0x248df
decq %rbx
movq %rbx, %r14
shrq %r14
cmpq $0x0, (%r15,%r14,8)
jne 0x248df
movl $0x1, %edi
movl %r14d, %ecx
shlq %cl, %rdi
callq 0x33d0
movq %rax, (%r15,%r14,8)
testq %rax, %rax
je 0x248da
movq %rbx, %rdi
movq %rax, %rsi
callq 0x24ad1
jmp 0x248df
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fftext.cpp
// Function: fftFree()
void fftFree(){
// release storage for all private cosine and bit reversed tables
long i1;
for (i1=8*sizeof(long)/2-1; i1>=0; i1--){
	if (BRLowArray[i1] != 0){
		free(BRLowArray[i1]);
		BRLowArray[i1] = 0;
	};
};
for (i1=8*sizeof(long)-1; i1>=0; i1--){
	if (UtblArray[i1] != 0){
		free(UtblArray[i1]);
		UtblArray[i1] = 0;
	};
};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x1f, %ebx
leaq 0x156f3(%rip), %r14     # 0x39ff0
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x2491b
leaq (,%rbx,8), %r15
callq 0x3370
movq $0x0, (%r15,%r14)
addq $-0x1, %rbx
jb 0x248fd
movl $0x3f, %ebx
leaq 0x154c3(%rip), %r14     # 0x39df0
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x2494b
leaq (,%rbx,8), %r15
callq 0x3370
movq $0x0, (%r15,%r14)
addq $-0x1, %rbx
jb 0x2492d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: fftCosInit(long, double*)
void fftCosInit(long M, Float_t *Utbl){
/* Compute Utbl, the cosine table for ffts	*/
/* of size (pow(2,M)/4 +1)	*/
/* INPUTS */
/* M = log2 of fft size	*/
/* OUTPUTS */
/* *Utbl = cosine table	*/
unsigned long fftN = POW2(M);
unsigned long i1;
	Utbl[0] = 1.0;
	for (i1 = 1; i1 < fftN/4; i1++)
		Utbl[i1] = cos( (2.0 * MYPI * i1) / fftN );
	Utbl[fftN/4] = 0.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rcx
movl $0x1, %r14d
movl $0x1, %eax
shlq %cl, %rax
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rdx, (%rsi)
movq %rax, %r15
shrq $0x2, %r15
cmpq $0x3, %rdi
jb 0x24abd
movq %rax, %xmm0
punpckldq 0x65b2(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x65ba(%rip), %xmm0     # 0x2b030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
cmpq $0x3, %r15
movl $0x2, %r12d
cmovaeq %r15, %r12
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
mulsd 0xadf3(%rip), %xmm0     # 0x2f898
divsd (%rsp), %xmm0
callq 0x3530
movsd %xmm0, (%rbx,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x24a95
movq $0x0, (%rbx,%r15,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: fftBRInit(long, short*)
void fftBRInit(long M, short *BRLow){
/* Compute BRLow, the bit reversed table for ffts	*/
/* of size pow(2,M/2 -1)	*/
/* INPUTS */
/* M = log2 of fft size	*/
/* OUTPUTS */
/* *BRLow = bit reversed counter table	*/
long	Mroot_1 = M / 2 - 1;
long	Nroot_1 = POW2(Mroot_1);
long i1;
long bitsum;
long bitmask;
long bit;
for (i1 = 0; i1 < Nroot_1; i1++){
	bitsum = 0;
	bitmask = 1;
	for (bit=1; bit <= Mroot_1; bitmask<<=1, bit++)
		if (i1 & bitmask)
			bitsum = bitsum + (Nroot_1 >> bit);
	BRLow[i1] = bitsum;
};
}

// Assembly:
movq %rdi, %r9
shrq $0x3f, %r9
addq %rdi, %r9
sarq %r9
leaq -0x1(%r9), %rcx
movl $0x1, %eax
movl $0x1, %edx
shlq %cl, %rdx
cmpq $0x3f, %rcx
je 0x24b5b
pushq %r14
pushq %rbx
cmpq $0x3, %r9
movl $0x2, %r8d
cmovgeq %r9, %r8
cmpq $0x2, %rdx
cmovgeq %rdx, %rax
xorl %r9d, %r9d
cmpq $0x4, %rdi
jl 0x24b48
movl $0x1, %ecx
movl $0x1, %r11d
xorl %r10d, %r10d
movq %r11, %rbx
movq %rdx, %r14
sarq %cl, %r14
andq %r9, %rbx
testq %rbx, %rbx
cmoveq %rbx, %r14
addq %r14, %r10
addq %r11, %r11
incq %rcx
cmpq %rcx, %r8
jne 0x24b25
jmp 0x24b4b
xorl %r10d, %r10d
movw %r10w, (%rsi,%r9,2)
incq %r9
cmpq %rax, %r9
jne 0x24b11
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: fftrecurs(double*, long, double*, long, long, long)
void fftrecurs(Float_t *ioptr, long M, Float_t *Utbl, long Ustride, long NDiffU, long StageCnt){
/* recursive bfstages calls to maximize on chip cache efficiency */
long i1;
if (M <= MCACHE)  // fits on chip ?
	bfstages(ioptr, M, Utbl, Ustride, NDiffU, StageCnt);		/*  RADIX 8 Stages	*/
else{
	for (i1=0; i1<8; i1++){
		fftrecurs(&ioptr[i1*POW2(M-3)*2], M-3, Utbl, 8*Ustride, NDiffU, StageCnt-1);	/*  RADIX 8 Stages	*/
	}
	bfstages(ioptr, M, Utbl, Ustride, POW2(M-3), 1);	/*  RADIX 8 Stage	*/
}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, (%rsp)
movq %r8, %r13
movq %rdx, %r12
movq %rdi, %rbp
cmpq $0xb, %rsi
jae 0x24b8c
movq %rbp, %rdi
movq %r12, %rdx
movq %r13, %r8
movq (%rsp), %r9
jmp 0x24bf8
movq %rsi, 0x8(%rsp)
leaq -0x3(%rsi), %rbx
movq %rcx, 0x10(%rsp)
leaq (,%rcx,8), %r15
decq (%rsp)
xorl %r14d, %r14d
movq %r14, %rdi
movl %ebx, %ecx
shlq %cl, %rdi
shlq $0x4, %rdi
addq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r13, %r8
movq (%rsp), %r9
callq 0x24b5c
incq %r14
cmpq $0x8, %r14
jne 0x24ba9
movq 0x8(%rsp), %rsi
leal -0x3(%rsi), %ecx
movl $0x1, %r8d
shlq %cl, %r8
movl $0x1, %r9d
movq %rbp, %rdi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2622d
// File: /workspace/github_cpp_makefile_star2_O1/kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: ifftrecurs(double*, long, double*, long, long, long)
void ifftrecurs(Float_t *ioptr, long M, Float_t *Utbl, long Ustride, long NDiffU, long StageCnt){
/* recursive bfstages calls to maximize on chip cache efficiency */
long i1;
if (M <= MCACHE)
	ibfstages(ioptr, M, Utbl, Ustride, NDiffU, StageCnt);		/*  RADIX 8 Stages	*/
else{
	for (i1=0; i1<8; i1++){
		ifftrecurs(&ioptr[i1*POW2(M-3)*2], M-3, Utbl, 8*Ustride, NDiffU, StageCnt-1);	/*  RADIX 8 Stages	*/
	}
	ibfstages(ioptr, M, Utbl, Ustride, POW2(M-3), 1);	/*  RADIX 8 Stage	*/
}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, (%rsp)
movq %r8, %r13
movq %rdx, %r12
movq %rdi, %rbp
cmpq $0xb, %rsi
jae 0x252bf
movq %rbp, %rdi
movq %r12, %rdx
movq %r13, %r8
movq (%rsp), %r9
jmp 0x2532b
movq %rsi, 0x8(%rsp)
leaq -0x3(%rsi), %rbx
movq %rcx, 0x10(%rsp)
leaq (,%rcx,8), %r15
decq (%rsp)
xorl %r14d, %r14d
movq %r14, %rdi
movl %ebx, %ecx
shlq %cl, %rdi
shlq $0x4, %rdi
addq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r13, %r8
movq (%rsp), %r9
callq 0x2528f
incq %r14
cmpq $0x8, %r14
jne 0x252dc
movq 0x8(%rsp), %rsi
leal -0x3(%rsi), %ecx
movl $0x1, %r8d
shlq %cl, %r8
movl $0x1, %r9d
movq %rbp, %rdi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2793c
// File: /workspace/github_cpp_makefile_star2_O1/Czxck001[P]algorithms/src/fft.cc
// Function: auto ifft<double>(std::vector<std::complex<double>, std::allocator<std::complex<double>>> const&)
auto ifft(const CVec<T> &X) {
  auto x0 = fft(X);
  auto x = x0;
  auto N = static_cast<T>(x.size());

  for (auto i = 1; i < N; i++) {
    x[i] = 1.0 / N * x0[N - i];
  }
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x154a
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x19ae
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
sarq $0x4, %rax
cmpq $0x2, %rax
jb 0x1956
movq %rax, %xmm1
punpckldq 0x760(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x768(%rip), %xmm1      # 0x2030
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x734(%rip), %xmm3      # 0x2010
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
movl $0x18, %eax
movl $0x2, %ecx
movsd 0x722(%rip), %xmm2      # 0x2018
movapd %xmm0, %xmm4
subsd %xmm3, %xmm4
cvttsd2si %xmm4, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd %xmm2, %xmm4
cvttsd2si %xmm4, %rdi
andq %rsi, %rdi
orq %rdx, %rdi
movq -0x48(%rbp), %rdx
shlq $0x4, %rdi
movsd (%rdx,%rdi), %xmm3
mulsd %xmm1, %xmm3
movsd 0x8(%rdx,%rdi), %xmm4
mulsd %xmm1, %xmm4
movq -0x30(%rbp), %rdx
movsd %xmm3, -0x8(%rdx,%rax)
movsd %xmm4, (%rdx,%rax)
xorps %xmm3, %xmm3
cvtsi2sd %ecx, %xmm3
addq $0x10, %rax
incl %ecx
ucomisd %xmm3, %xmm0
ja 0x18f6
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rbx)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rbx)
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x1982
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x19a6
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/estan[P]tsp/tsp.cpp
// Function: createDistanceMatrix(std::istream&)
Matrix<uint32_t> createDistanceMatrix(istream& in) {
    // Read vertex coordinates.
    size_t N;
    in >> N;
    vector<double> x(N);
    vector<double> y(N);
    for (size_t i = 0; i < N; ++i) {
        in >> x[i] >> y[i];
    }

    // Calculate distance matrix.
    Matrix<uint32_t> d(N, N);
    for (size_t i = 0; i < N; ++i) {
        for (size_t j = i + 1; j < N; ++j) {
            d[i][j] = d[j][i] = round(sqrt(pow(x[i]-x[j], 2) + pow(y[i]-y[j], 2)));
        }
    }

    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x20a0
movq (%r15), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2a5e
movq (%r15), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rdx
callq 0x2a5e
movq 0x8(%rsp), %r13
testq %r13, %r13
je 0x2484
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x40(%rsp), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x20c0
movq 0x28(%rsp), %rsi
addq %r15, %rsi
movq %rax, %rdi
callq 0x20c0
incq %r12
movq 0x8(%rsp), %r13
addq $0x8, %r15
cmpq %r13, %r12
jb 0x2453
movq %r13, %rsi
imulq %r13, %rsi
leaq 0x14(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x3412
movq %r13, 0x18(%rbx)
movq %r13, 0x20(%rbx)
cmpq $0x0, 0x8(%rsp)
je 0x2582
movabsq $0x100000000, %r14      # imm = 0x100000000
xorl %r13d, %r13d
movq %r14, 0x18(%rsp)
leaq 0x1(%r13), %rax
movq %rax, 0x20(%rsp)
cmpq 0x8(%rsp), %rax
jae 0x256d
movslq %r13d, %rbp
shlq $0x2, %rbp
movq 0x18(%rsp), %r12
movq 0x20(%rsp), %r15
movq 0x40(%rsp), %rax
movsd (%rax,%r13,8), %xmm1
subsd (%rax,%r15,8), %xmm1
mulsd %xmm1, %xmm1
movq 0x28(%rsp), %rax
movsd (%rax,%r13,8), %xmm0
subsd (%rax,%r15,8), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd 0x2ae4(%rip), %xmm0     # 0x5008
jb 0x252c
sqrtsd %xmm0, %xmm0
jmp 0x2531
callq 0x2110
callq 0x2080
cvttsd2si %xmm0, %rax
movq %r12, %rcx
sarq $0x20, %rcx
movq (%rbx), %rdx
movq 0x20(%rbx), %rsi
imulq %rsi, %rcx
leaq (%rdx,%rcx,4), %rcx
movl %eax, (%rcx,%r13,4)
imulq %rbp, %rsi
addq %rdx, %rsi
movl %eax, (%rsi,%r15,4)
incq %r15
addq %r14, %r12
cmpq 0x8(%rsp), %r15
jb 0x24ee
addq %r14, 0x18(%rsp)
movq 0x20(%rsp), %r13
cmpq 0x8(%rsp), %r13
jb 0x24c9
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2591
callq 0x2150
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x25a0
callq 0x2150
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25b9
movq %rax, %rbx
jmp 0x25cb
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x25cb
callq 0x2150
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x25da
callq 0x2150
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/estan[P]tsp/tsp.cpp
// Function: main
int main(int argc, char *argv[]) {

    // Approximate/print a TSP tour in ~1950 milliseconds.
    for (auto city : approximate(cin, now() + chrono::milliseconds(1950))) {
        cout << city << endl;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x2040
addq $0x743aa380, %rax       # imm = 0x743AA380
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq 0x477f(%rip), %rsi      # 0x6fe0
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2b70
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x28c0
movq 0x474f(%rip), %rbx      # 0x6fd0
movzwl (%r15), %esi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
addq $0x2, %r15
cmpq %r12, %r15
jne 0x2881
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x28cf
callq 0x2150
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x28ef
callq 0x2150
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/estan[P]tsp/tsp.cpp
// Function: greedy(Matrix<unsigned int> const&)
inline vector<uint16_t> greedy(const Matrix<uint32_t>& d) {
    size_t N = d.rows();
    vector<uint16_t> tour(N);
    vector<bool> used(N, false);
    tour[0] = 0;
    used[0] = true;
    for (size_t i = 1; i < N; ++i) {
        // Find k, the closest city to the (i - 1):th city in tour.
        int32_t k = -1;
        for (uint16_t j = 0; j < N; ++j) {
            if (!used[j] && (k == -1 || d[tour[i-1]][j] < d[tour[i-1]][k])) {
                k = j;
            }
        }
        tour[i] = k;
        used[k] = true;
    }
    return tour;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
callq 0x2ae8
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0x6(%rsp), %rcx
movq %r15, %rsi
callq 0x479a
movq %rbx, 0x8(%rsp)
movq (%rbx), %rax
movw $0x0, (%rax)
movq 0x10(%rsp), %rdi
orq $0x1, (%rdi)
cmpq $0x2, %r15
jb 0x3660
movl $0x1, %edx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
leaq 0x3f(%rsi), %r8
movq (%r14), %rcx
movq 0x20(%r14), %r9
leaq (,%r9,4), %r10
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movq %r12, %r13
shrq $0x6, %r13
movq (%rdi,%r13,8), %r13
btq %r12, %r13
jb 0x360f
cmpl $-0x1, %r11d
je 0x360c
movzwl -0x2(%rax,%rdx,2), %r13d
movq %r9, %rbp
imulq %r13, %rbp
leaq (%rcx,%rbp,4), %rbp
imulq %r10, %r13
addq %rcx, %r13
movl (%r13,%r12,4), %r13d
movslq %r11d, %rbx
cmpl (%rbp,%rbx,4), %r13d
jae 0x360f
movl %r12d, %r11d
incq %r12
movzwl %r12w, %ebx
cmpq %rbx, %r15
ja 0x35ce
movw %r11w, (%rax,%rdx,2)
movslq %r11d, %rcx
leaq 0x3f(%rcx), %r9
testq %rcx, %rcx
cmovnsq %rcx, %r9
sarq $0x6, %r9
movq %rcx, %r10
andq %r8, %r10
xorl %r11d, %r11d
cmpq %rsi, %r10
setbe %r11b
movl $0x1, %r10d
shlq %cl, %r10
leaq (%rdi,%r9,8), %rcx
orq %r10, -0x8(%rcx,%r11,8)
incq %rdx
cmpq %r15, %rdx
jne 0x35b6
callq 0x2150
movq 0x8(%rsp), %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 0x3689
callq 0x2150
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/estan[P]tsp/tsp.cpp
// Function: doubleBridge(std::vector<unsigned short, std::allocator<unsigned short>> const&)
inline vector<uint16_t> doubleBridge(const vector<uint16_t>& tour) {
    const size_t N = tour.size();
    vector<uint16_t> newTour;
    newTour.reserve(N);
    uniform_int_distribution<size_t> randomOffset(1, N / 4);
    size_t A = randomOffset(rng);
    size_t B = A + randomOffset(rng);
    size_t C = B + randomOffset(rng);
    copy(tour.begin(), tour.begin() + A, back_inserter(newTour));
    copy(tour.begin() + C, tour.end(), back_inserter(newTour));
    copy(tour.begin() + B, tour.begin() + C, back_inserter(newTour));
    copy(tour.begin() + A, tour.begin() + B, back_inserter(newTour));
    return newTour;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
subq (%rsi), %r15
sarq %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r15, %rsi
callq 0x48c8
shrq $0x2, %r15
movq %rsp, %rdi
movq $0x1, (%rdi)
movq %r15, 0x8(%rdi)
leaq 0x3f43(%rip), %rsi      # 0x84a0
movq %rdi, %rdx
callq 0x4956
movq %rax, %r15
leaq 0x3f31(%rip), %rsi      # 0x84a0
movq %rsp, %rdi
movq %rdi, %rdx
callq 0x4956
movq %rax, %r12
leaq 0x3f1c(%rip), %rsi      # 0x84a0
movq %rsp, %rdi
movq %rdi, %rdx
callq 0x4956
movq %rax, %r13
movq (%r14), %rdi
leaq (%rdi,%r15,2), %rsi
movq %rbx, %rdx
callq 0x4ada
addq %r15, %r12
addq %r12, %r13
leaq (,%r13,2), %rdi
addq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x4ada
movq (%r14), %rax
leaq (%rax,%r12,2), %rdi
leaq (%rax,%r13,2), %rsi
movq %rbx, %rdx
callq 0x4ada
movq (%r14), %rax
leaq (%rax,%r15,2), %rdi
leaq (%rax,%r12,2), %rsi
movq %rbx, %rdx
callq 0x4ada
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4603
jmp 0x4603
jmp 0x4603
jmp 0x4603
jmp 0x4603
jmp 0x4603
jmp 0x4603
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4613
callq 0x2150
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./ex16_12_13.h
// Function: bool operator==<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(BlobPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, BlobPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
bool operator==(const BlobPtr<T>& lhs, const BlobPtr<T>& rhs)
{
	// std::shared_ptr<T> lock() const;(since C++11)
	// Creates a new std::shared_ptr that shares ownership of the managed object.
	// If there is no managed object, i.e. *this is empty, then the returned shared_ptr also is empty.
	// Effectively returns expired() ? shared_ptr<T>() : shared_ptr<T>(*this), executed atomically.
	return lhs.wptr.lock().get() == rhs.wptr.lock().get() && lhs.curr == rhs.curr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x3a3e
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x3a3c
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x8(%rbx)
jne 0x3a2c
jmp 0x3a3e
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x3a4e
movl 0x8(%rbx), %eax
testl %eax, %eax
sete -0x2a(%rbp)
jmp 0x3a52
movb $0x1, -0x2a(%rbp)
movq (%rdi), %r14
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x3a73
movl 0x8(%rcx), %eax
testl %eax, %eax
je 0x3a71
leal 0x1(%rax), %edx
lock
cmpxchgl %edx, 0x8(%rcx)
jne 0x3a61
jmp 0x3a73
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x3a83
movl 0x8(%rcx), %eax
testl %eax, %eax
sete -0x29(%rbp)
jmp 0x3a87
movb $0x1, -0x29(%rbp)
movq (%rsi), %r12
movq 0x10(%rsi), %r13
movq 0x10(%rdi), %r15
testq %rcx, %rcx
je 0x3a9f
movq %rcx, %rdi
callq 0x2f76
testq %rbx, %rbx
je 0x3aac
movq %rbx, %rdi
callq 0x2f76
xorl %eax, %eax
cmpb $0x0, -0x2a(%rbp)
cmovneq %rax, %r14
cmpb $0x0, -0x29(%rbp)
cmovneq %rax, %r12
xorq %r14, %r12
xorq %r13, %r15
orq %r12, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./ex16_12_13.h
// Function: BlobPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::check(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::shared_ptr<std::vector<T>> BlobPtr<T>::check(std::size_t i, const std::string& msg) const
{
	// is the vector still around?
	auto ret = wptr.lock();
	if (!ret)
		throw std::runtime_error("unbound StrBlobPtr");

	if (i >= ret->size())
		throw std::out_of_range(msg);

	// otherwise, return a shared_ptr to the vector
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3ada
movq (%rbx), %rax
testq %rax, %rax
je 0x3b6a
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x5, %rcx
cmpq %r14, %rcx
jbe 0x3b96
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2080
movq %rax, %r14
leaq 0x554(%rip), %rsi       # 0x40d2
movq %rax, %rdi
callq 0x2060
movq 0x3423(%rip), %rdx      # 0x6fb0
movq 0x345c(%rip), %rsi      # 0x6ff0
jmp 0x3bbc
movl $0x10, %edi
callq 0x2080
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x3413(%rip), %rdx      # 0x6fc8
movq 0x3414(%rip), %rsi      # 0x6fd0
movq %r14, %rdi
callq 0x21b0
jmp 0x3bc6
movq %rax, %r15
movq %r14, %rdi
callq 0x20d0
jmp 0x3bd6
movq %rax, %r15
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3be4
callq 0x2f76
movq %r15, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/buildsi[P]ldaudit-yaml/auditlib.cpp
// Function: init()
__attribute__((constructor))
static void init(void) {
    // Do we want to write output to a file?
    char * out = getenv("LDAUDIT_OUTFILE");
    
    // Prepare file for writing
    if (out) {
        initFile(out);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x3cb3(%rip), %rdi      # 0x6020
callq 0x2190
testq %rax, %rax
je 0x23bb
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x2120
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x23c6
leaq 0x8(%rsp), %rdi
callq 0x2040
leaq 0x8(%rsp), %rdi
callq 0x2050
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x42e8(%rip), %rdi      # 0x66b5
callq 0x21e0
movl $0x1, %edi
callq 0x2180
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/buildsi[P]ldaudit-yaml/auditlib.cpp
// Function: doPrint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static void doPrint(std::string output) {
  char * out = getenv("LDAUDIT_OUTFILE");
    
  // Open for append to write, and then close
  // This is obviously not ideal for many writes, but I don't
  // see an easy way to do this without having an exit function.
  if (out) {
     std::ofstream file;
     file.open(out, std::ios_base::app);
     if (!file) {
        printf("Error writing to output file.\n");
        exit (EXIT_FAILURE);
     }
     file << output;
     file.close();
  } else {
      std::cout << output;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq 0x37e0(%rip), %rdi      # 0x6020
callq 0x2190
testq %rax, %rax
je 0x28d0
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2220
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2030
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x28ef
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rsp, %rdi
callq 0x2150
movq %rsp, %rdi
callq 0x21b0
movq 0x6737(%rip), %rax      # 0x8fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x2100
leaq 0xf8(%rsp), %rdi
callq 0x2070
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x66fa(%rip), %rdi      # 0x8fd8
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x2150
leaq 0x3dde(%rip), %rdi      # 0x66d4
callq 0x21e0
movl $0x1, %edi
callq 0x2180
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/buildsi[P]ldaudit-yaml/auditlib.cpp
// Function: la_preinit
void la_preinit(uintptr_t *cookie) {
  std::stringstream ss;
  ss << cookie;   
  std::string output = "  - event: pre_init\n    function: la_preinit\n    initiated_by: " + ss.str() +"\n";
  doPrint(output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x88(%rsp), %rdi
callq 0x20b0
leaq 0x98(%rsp), %rdi
movq %rbx, %rsi
callq 0x20e0
leaq 0xa0(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x2200
leaq 0x3732(%rip), %rcx      # 0x608f
leaq 0x68(%rsp), %rdi
movl $0x3f, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2140
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2998
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x299f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x3938(%rip), %rsi      # 0x62fa
callq 0x2250
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x29ee
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x29f5
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2a24
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a3f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2130
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x2090
leaq 0x48(%rsp), %rdi
callq 0x282a
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x2a80
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2a97
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x651a(%rip), %rsi      # 0x8fb8
leaq 0x88(%rsp), %rdi
callq 0x20d0
leaq 0x108(%rsp), %rdi
callq 0x2070
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ae4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x2ae4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b36
movq 0x18(%rsp), %rsi
jmp 0x2b27
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b14
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x2b14
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b36
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x2b36
jmp 0x2b33
movq %rax, %rbx
movq 0x647b(%rip), %rsi      # 0x8fb8
leaq 0x88(%rsp), %rdi
callq 0x20d0
leaq 0x108(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2230