LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x3f, %rdi
ja 0x1c854
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x163b9(%rip), %r13     # 0x32be0
cmpq $0x0, (%r13,%rdi,8)
pushq $0x40
popq %r15
pushq $0x2
popq %rbp
je 0x1c859
cmpq $0x0, (%r13,%r14,8)
je 0x1c87f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d638
pushq $0x1
popq %rbp
jmp 0x1c8a5
movq %r15, %rdi
movl %r12d, %ecx
shlq %cl, %rdi
callq 0x33a0
movq %rax, (%r13,%r12,8)
testq %rax, %rax
je 0x1c8a5
movq %r12, %rdi
callq 0x1d638
testl %eax, %eax
jne 0x1c8a3
jmp 0x1c836
movl %r14d, %ecx
shlq %cl, %r15
movq %r15, %rdi
callq 0x33a0
movq %rax, (%r13,%r14,8)
testq %rax, %rax
je 0x1c8a5
movq %r14, %rdi
callq 0x1d638
testl %eax, %eax
je 0x1c83e
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %r15
movq %r8, %r13
imulq %rcx, %r13
pushq $0x2
popq %rsi
movq %r13, %rax
cqto
idivq %rsi
movq %rax, %r12
cmpq $0x2, %rcx
setl %al
cmpq $0x2, %r8
setl %cl
orb %al, %cl
jne 0x1d5e0
movsd (%r15), %xmm0
mulsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movsd 0x8(%r15), %xmm0
mulsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
leaq 0x10(%r15), %rdi
leaq 0x10(%r14), %rsi
leaq 0x10(%rbx), %rdx
shrq $0x2, %r13
decq %r13
movq %r13, %rcx
callq 0x2190c
movsd (%r15,%r12,8), %xmm0
mulsd (%r14,%r12,8), %xmm0
movsd %xmm0, (%rbx,%r12,8)
movsd 0x8(%r15,%r12,8), %xmm0
mulsd 0x8(%r14,%r12,8), %xmm0
movsd %xmm0, 0x8(%rbx,%r12,8)
leaq 0x10(%r15,%r12,8), %rdi
leaq (%r14,%r12,8), %rsi
addq $0x10, %rsi
leaq (%rbx,%r12,8), %rdx
addq $0x10, %rdx
movq %r13, %rcx
jmp 0x1d620
movsd (%r15), %xmm0
mulsd (%r14), %xmm0
movsd %xmm0, (%rbx)
cmpq $0x2, %r13
jl 0x1d62e
movsd 0x8(%r15), %xmm0
mulsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x10, %r15
addq $0x10, %r14
addq $0x10, %rbx
decq %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2190c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
cmpq $0x3f, %rdi
ja 0x1d686
movq %rdi, %rbx
leaq 0x15790(%rip), %r14     # 0x32de0
xorl %ebp, %ebp
cmpq $0x0, (%r14,%rdi,8)
jne 0x1d689
pushq $0x2
popq %rdi
movl %ebx, %ecx
shlq %cl, %rdi
andq $-0x8, %rdi
addq $0x8, %rdi
callq 0x33a0
movq %rax, (%r14,%rbx,8)
testq %rax, %rax
je 0x1d694
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1d864
xorl %ebp, %ebp
jmp 0x1d697
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2
popq %rbp
cmpq $0x2, %rbx
jb 0x1d689
movq %rbx, %r15
shrq %r15
leaq 0x15936(%rip), %r12     # 0x32fe0
cmpq $0x0, (%r12,%r15,8)
pushq $0x1
popq %r14
jne 0x1d6dc
movq %r14, %rdi
movl %r15d, %ecx
shlq %cl, %rdi
callq 0x33a0
movq %rax, (%r12,%r15,8)
testq %rax, %rax
je 0x1d6d9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1d8ea
jmp 0x1d6dc
pushq $0x2
popq %rbp
cmpq $0x2, %rbx
je 0x1d689
decq %rbx
movq %rbx, %r15
shrq %r15
cmpq $0x0, (%r12,%r15,8)
jne 0x1d689
movl %r15d, %ecx
shlq %cl, %r14
movq %r14, %rdi
callq 0x33a0
movq %rax, (%r12,%r15,8)
testq %rax, %rax
je 0x1d719
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1d8ea
jmp 0x1d689
pushq $0x2
jmp 0x1d688
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1f
popq %rbx
leaq 0x158b1(%rip), %r14     # 0x32fe0
testq %rbx, %rbx
js 0x1d754
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x1d74f
leaq (,%rbx,8), %r15
callq 0x3330
andq $0x0, (%r15,%r14)
decq %rbx
jmp 0x1d72f
pushq $0x3f
popq %rbx
leaq 0x15682(%rip), %r14     # 0x32de0
testq %rbx, %rbx
js 0x1d783
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x1d77e
leaq (,%rbx,8), %r15
callq 0x3330
andq $0x0, (%r15,%r14)
decq %rbx
jmp 0x1d75e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %rcx
pushq $0x1
popq %r14
movq %r14, %r15
shlq %cl, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rsi)
movq %r15, %xmm0
shrq $0x2, %r15
punpckldq 0x4785(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x478d(%rip), %xmm0     # 0x22030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
cmpq %r15, %r14
jae 0x1d8db
cvtsi2sd %r14, %xmm0
mulsd 0x90da(%rip), %xmm0     # 0x269a0
divsd (%rsp), %xmm0
callq 0x3500
movsd %xmm0, (%rbx,%r14,8)
incq %r14
jmp 0x1d8b4
andq $0x0, (%rbx,%r15,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
movq %rdi, %rax
movabsq $0x2, %rcx
cqto
idivq %rcx
leal -0x1(%rax), %ecx
movabsq $0x1, %rdx
movq %rdx, %rdi
shlq %cl, %rdi
xorl %r8d, %r8d
testq %rdi, %rdi
movl $0x0, %r9d
cmovgq %rdi, %r9
cmpq %r9, %r8
je 0x1d95d
xorl %r10d, %r10d
movq %rdx, %r11
movq %rdx, %rcx
cmpq %rax, %rcx
jge 0x1d953
movq %r11, %rbx
movq %rdi, %r14
sarq %cl, %r14
andq %r8, %rbx
testq %rbx, %rbx
cmoveq %rbx, %r14
addq %r14, %r10
addq %r11, %r11
incq %rcx
jmp 0x1d930
movw %r10w, (%rsi,%r8,2)
incq %r8
jmp 0x1d922
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r8, %r13
movq %rdx, %r12
movq %rdi, %rbp
cmpq $0xb, %rsi
jae 0x1d989
movq %rbp, %rdi
movq %r12, %rdx
movq %r13, %r8
jmp 0x1d9f7
movq %rsi, (%rsp)
leaq -0x3(%rsi), %rbx
movq %rcx, 0x8(%rsp)
leaq (,%rcx,8), %rcx
movq %rcx, 0x10(%rsp)
decq %r9
movq %r9, %r15
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x1d9dc
movq %r14, %rdi
movl %ebx, %ecx
shlq %cl, %rdi
shlq $0x4, %rdi
addq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
movq %r13, %r8
movq %r15, %r9
callq 0x1d961
incq %r14
jmp 0x1d9ac
pushq $0x1
popq %r9
movq %r9, %r8
movl %ebx, %ecx
shlq %cl, %r8
movq %rbp, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e112
// File: /workspace/github_cpp_makefile_star2_O2/kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: ffts1(double*, long, long, double*, short*)
void ffts1(Float_t *ioptr, long M, long Rows, Float_t *Utbl, short *BRLow){
/* Compute in-place complex fft on the rows of the input array	*/
/* INPUTS */
/* *ioptr = input data array	*/
/* M = log2 of fft size	(ex M=10 for 1024 point fft) */
/* Rows = number of rows in ioptr array (use Rows of 1 if ioptr is a 1 dimensional array)	*/
/* *Utbl = cosine table	*/
/* *BRLow = bit reversed counter table	*/
/* OUTPUTS */
/* *ioptr = output data array	*/

long 	StageCnt;
long 	NDiffU;

switch (M){
case 0:
	break;
case 1:
	for (;Rows>0;Rows--){
		fft2pt(ioptr);				/* a 2 pt fft */
		ioptr += 2*POW2(M);
	}
	break;
case 2:
	for (;Rows>0;Rows--){
		fft4pt(ioptr);				/* a 4 pt fft */
		ioptr += 2*POW2(M);
	}
	break;
case 3:
	for (;Rows>0;Rows--){
		fft8pt(ioptr);				/* an 8 pt fft */
		ioptr += 2*POW2(M);
	}
	break;
default:
	for (;Rows>0;Rows--){

		bitrevR2(ioptr, M, BRLow);						/* bit reverse and first radix 2 stage */
		
		StageCnt = (M-1) / 3;		// number of radix 8 stages
		NDiffU = 2;				// one radix 2 stage already complete

		if ( (M-1-(StageCnt * 3)) == 1 ){
			bfR2(ioptr, M, NDiffU);				/* 1 radix 2 stage */
			NDiffU *= 2;
		}

		if ( (M-1-(StageCnt * 3)) == 2 ){
			bfR4(ioptr, M, NDiffU);			/* 1 radix 4 stage */
			NDiffU *= 4;
		}

		if (M <= MCACHE)
			bfstages(ioptr, M, Utbl, 1, NDiffU, StageCnt);		/*  RADIX 8 Stages	*/

		else{
			fftrecurs(ioptr, M, Utbl, 1, NDiffU, StageCnt);		/*  RADIX 8 Stages	*/
		}

		ioptr += 2*POW2(M);
	}
}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
cmpq $0x3, %rsi
ja 0x1da86
leaq 0x8f8a(%rip), %rax      # 0x269b8
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
testq %rbx, %rbx
jle 0x1da77
movq %r14, %rdi
callq 0x1ed7b
addq $0x20, %r14
decq %rbx
jmp 0x1da37
testq %rbx, %rbx
jle 0x1da77
movq %r14, %rdi
callq 0x1ee03
subq $-0x80, %r14
decq %rbx
jmp 0x1da4d
movq %r14, %rdi
callq 0x1ed9a
addq $0x40, %r14
decq %rbx
testq %rbx, %rbx
jg 0x1da63
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, 0x10(%rsp)
leaq -0x1(%r12), %rax
pushq $0x3
popq %rcx
cqto
idivq %rcx
movq %rax, 0x8(%rsp)
imulq $-0x3, %rax, %rax
leaq (%rax,%r12), %r15
decq %r15
pushq $0x2
popq %r13
movl %r12d, %ecx
shlq %cl, %r13
shlq $0x3, %r13
testq %rbx, %rbx
jle 0x1da77
movq %r14, %rdi
movq %r12, %rsi
movq %r8, %rbp
movq %r8, %rdx
callq 0x1efbb
cmpq $0x2, %r15
je 0x1daee
pushq $0x2
popq %r8
cmpq $0x1, %r15
jne 0x1db00
movq %r14, %rdi
movq %r12, %rsi
pushq $0x2
popq %rdx
callq 0x1f1c7
pushq $0x4
jmp 0x1dafe
movq %r14, %rdi
movq %r12, %rsi
pushq $0x2
popq %rdx
callq 0x1f2df
pushq $0x8
popq %r8
movq %r14, %rdi
movq %r12, %rsi
cmpq $0xa, %r12
ja 0x1db20
movq 0x10(%rsp), %rdx
pushq $0x1
popq %rcx
movq 0x8(%rsp), %r9
callq 0x1e112
jmp 0x1db32
movq 0x10(%rsp), %rdx
pushq $0x1
popq %rcx
movq 0x8(%rsp), %r9
callq 0x1d961
decq %rbx
addq %r13, %r14
movq %rbp, %r8
jmp 0x1dab6
// File: /workspace/github_cpp_makefile_star2_O2/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 %r8, %r13
movq %rdx, %r12
movq %rdi, %rbp
cmpq $0xb, %rsi
jae 0x1db68
movq %rbp, %rdi
movq %r12, %rdx
movq %r13, %r8
jmp 0x1dbd6
movq %rsi, (%rsp)
leaq -0x3(%rsi), %rbx
movq %rcx, 0x8(%rsp)
leaq (,%rcx,8), %rcx
movq %rcx, 0x10(%rsp)
decq %r9
movq %r9, %r15
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x1dbbb
movq %r14, %rdi
movl %ebx, %ecx
shlq %cl, %rdi
shlq $0x4, %rdi
addq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
movq %r13, %r8
movq %r15, %r9
callq 0x1db40
incq %r14
jmp 0x1db8b
pushq $0x1
popq %r9
movq %r9, %r8
movl %ebx, %ecx
shlq %cl, %r8
movq %rbp, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f5c5
// File: /workspace/github_cpp_makefile_star2_O2/Czxck001[P]algorithms/src/fft.cc
// Function: main
int main() {
  auto x = CVec<double>{0, 0, 0, 0, 1, 1, 1, 1};
  for (auto xi: x) {
    std::cout << xi << std::endl;
  }
  std::cout << std::endl;

  auto X = fft(x);
  for (auto Xk: X) {
    std::cout << Xk << std::endl;
  }
  std::cout << std::endl;

  auto y = ifft(X);
  for (auto yi: y) {
    std::cout << yi << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
leaq 0xdf3(%rip), %rsi       # 0x2058
pushq $0x10
popq %rcx
leaq -0xf0(%rbp), %rbx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x58(%rbp), %r14
pushq $0x8
popq %rdx
leaq -0x40(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13de
movq (%r14), %r15
movq 0x8(%r14), %r12
movq 0x2d3f(%rip), %r14      # 0x3fd8
cmpq %r12, %r15
je 0x12c2
movups (%r15), %xmm0
movaps %xmm0, -0xf0(%rbp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
addq $0x10, %r15
jmp 0x1299
movq 0x2d0f(%rip), %rdi      # 0x3fd8
callq 0x1070
leaq -0xf0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1417
movq -0xf0(%rbp), %r15
movq -0xe8(%rbp), %r12
movq 0x2ce5(%rip), %rbx      # 0x3fd8
leaq -0x40(%rbp), %r14
cmpq %r12, %r15
je 0x131d
movups (%r15), %xmm0
movaps %xmm0, -0x40(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
addq $0x10, %r15
jmp 0x12f7
movq 0x2cb4(%rip), %rdi      # 0x3fd8
callq 0x1070
leaq -0x40(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x1626
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
movq 0x2c90(%rip), %rbx      # 0x3fd8
leaq -0x70(%rbp), %r14
cmpq %r12, %r15
je 0x1372
movups (%r15), %xmm0
movaps %xmm0, -0x70(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
addq $0x10, %r15
jmp 0x134c
leaq -0x40(%rbp), %rdi
callq 0x182c
leaq -0xf0(%rbp), %rdi
callq 0x182c
leaq -0x58(%rbp), %rdi
callq 0x182c
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13b8
jmp 0x13b8
jmp 0x13c9
jmp 0x13c9
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x182c
jmp 0x13bb
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x182c
jmp 0x13cc
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x182c
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O2/Czxck001[P]algorithms/src/fft.cc
// Function: auto fft<double>(std::vector<std::complex<double>, std::allocator<std::complex<double>>> const&)
auto fft(const CVec<T> &x) {
  // X[k] = E[k] + g^k * O[k]

  auto N = x.size();
  auto M = N / 2;

  if (N == 1) {
    return x;
  }

  // subdivide the signal into even part and odd part
  auto e = CVec<T>();
  auto o = CVec<T>();
  for (auto i = 0; i < N; i++) {
    if (i % 2 == 0) {
      e.push_back(x[i]);
    } else {
      o.push_back(x[i]);
    }
  }

  // recursively calculate sub-spectrums
  auto E = fft(e);
  auto O = fft(o);

  // calculate the spectrum from the sub-spectrums
  auto X = CVec<T>();
  for (auto k = 0; k < N; k++) {
    X.push_back(E[k % M] + cru<T>(k, N) * O[k % M]);
  }

  return X;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
subq (%rsi), %r14
cmpq $0x10, %r14
jne 0x1451
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1748
movq %r15, %rax
jmp 0x15c4
movq %r15, -0x30(%rbp)
sarq $0x4, %r14
movq %r14, %rax
shrq %rax
movq %rax, -0x38(%rbp)
xorpd %xmm0, %xmm0
leaq -0x50(%rbp), %rax
andq $0x0, 0x10(%rax)
leaq -0xb0(%rbp), %r12
andq $0x0, 0x10(%r12)
movapd %xmm0, (%rax)
movapd %xmm0, (%r12)
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x14b5
movq (%rbx), %rsi
addq %r13, %rsi
testb $0x1, %r15b
movq %r12, %rdi
leaq -0x50(%rbp), %rax
cmoveq %rax, %rdi
callq 0x1798
incq %r15
addq $0x10, %r13
jmp 0x148d
leaq -0xe0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1417
leaq -0xc8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1417
movq -0x38(%rbp), %r13
xorpd %xmm0, %xmm0
leaq -0x90(%rbp), %rax
andq $0x0, 0x10(%rax)
movapd %xmm0, (%rax)
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x1561
movq %r12, %rax
xorl %edx, %edx
divq %r13
movq %rdx, %r15
shlq $0x4, %r15
movq -0xe0(%rbp), %rbx
addq %r15, %rbx
movl %r12d, %edi
movl %r14d, %esi
callq 0x17e7
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
addq -0xc8(%rbp), %r15
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x17bc
addsd (%rbx), %xmm0
addsd 0x8(%rbx), %xmm1
movsd %xmm0, -0x70(%rbp)
movsd %xmm1, -0x68(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x19f8
incq %r12
jmp 0x14f3
leaq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq -0x30(%rbp), %rbx
movq %rax, (%rbx)
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x182c
leaq -0xc8(%rbp), %rdi
callq 0x182c
leaq -0xe0(%rbp), %rdi
callq 0x182c
leaq -0xb0(%rbp), %rdi
callq 0x182c
leaq -0x50(%rbp), %rdi
callq 0x182c
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x15fd
jmp 0x15dd
movq %rax, %rbx
jmp 0x1609
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x182c
leaq -0xc8(%rbp), %rdi
callq 0x182c
leaq -0xe0(%rbp), %rdi
callq 0x182c
leaq -0xb0(%rbp), %rdi
callq 0x182c
leaq -0x50(%rbp), %rdi
callq 0x182c
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1417
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x1748
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
sarq $0x4, %rax
movq %rax, %xmm1
punpckldq 0x9ab(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x9b3(%rip), %xmm1      # 0x2020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x9bf(%rip), %xmm1      # 0x2040
divsd %xmm0, %xmm1
pushq $0x18
popq %rax
pushq $0x1
popq %rcx
movsd 0x9b5(%rip), %xmm2      # 0x2048
cvtsi2sd %ecx, %xmm3
ucomisd %xmm3, %xmm0
jbe 0x16f2
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)
addq $0x10, %rax
incl %ecx
jmp 0x1693
leaq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq %rax, (%rbx)
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x182c
leaq -0x48(%rbp), %rdi
callq 0x182c
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x182c
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O2/Czxck001[P]algorithms/src/fft.cc
// Function: auto cru<double>(int, int)
inline auto cru(const int k, const int N) {
  // kth complex root of unity e ^ (i2Pi * (k / N))
  auto Tk = static_cast<T>(k);
  auto TN = static_cast<T>(N);
  return std::exp((2 * PI * 1i * Tk) / TN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cvtsi2sd %edi, %xmm0
cvtsi2sd %esi, %xmm1
movapd 0x831(%rip), %xmm2      # 0x2030
andpd %xmm0, %xmm2
mulsd 0x845(%rip), %xmm0      # 0x2050
divsd %xmm1, %xmm2
divsd %xmm1, %xmm0
leaq -0x10(%rbp), %rdi
movsd %xmm2, (%rdi)
movsd %xmm0, 0x8(%rdi)
callq 0x1b53
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/estan[P]tsp/tsp.cpp
// Function: minDistance(Matrix<unsigned int> const&)
uint32_t minDistance(const Matrix<uint32_t>& d) {
    size_t N = d.rows();
    uint32_t min = numeric_limits<uint32_t>::max();
    for (size_t i = 0; i < N; ++i) {
        for (size_t j = 0; j < N; ++j) {
            if (i != j)
                min = std::min(min, d[i][j]);
        }
    }
    return min;
}

// Assembly:
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rsi
shlq $0x2, %rsi
pushq $-0x1
popq %rax
xorl %edi, %edi
cmpq %rdx, %rdi
je 0x1361
movslq %edi, %r8
imulq %rsi, %r8
addq %rcx, %r8
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0x135c
cmpq %r9, %rdi
je 0x1357
movl (%r8,%r9,4), %r10d
cmpl %eax, %r10d
cmovbl %r10d, %eax
incq %r9
jmp 0x1342
incq %rdi
jmp 0x1330
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x78, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x20(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x10c0
movq (%r15), %rsi
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x1944
movq (%r15), %rsi
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1944
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x20(%rsp), %rdx
cmpq %rdx, %r15
jae 0x13e4
movq 0x60(%rsp), %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x10e0
movq 0x48(%rsp), %rsi
addq %rbx, %rsi
movq %rax, %rdi
callq 0x10e0
incq %r15
addq $0x8, %rbx
jmp 0x13b1
movq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x1996
movabsq $0x100000000, %r14      # imm = 0x100000000
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rsp)
xorl %r13d, %r13d
cmpq 0x18(%rsp), %r13
je 0x14cf
movslq %r13d, %rax
leaq 0x1(%r13), %rbp
movq 0x60(%rsp), %rbx
movq 0x48(%rsp), %r12
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
movq 0x20(%rdx), %rdx
leaq (%rcx,%r13,4), %rsi
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
imulq %rdx, %rax
leaq (%rcx,%rax,4), %r15
movq %r14, 0x30(%rsp)
movq %rbp, 0x28(%rsp)
cmpq 0x18(%rsp), %rbp
jae 0x14b3
movsd (%rbx,%r13,8), %xmm0
subsd (%rbx,%rbp,8), %xmm0
movsd (%r12,%r13,8), %xmm1
subsd (%r12,%rbp,8), %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm0
callq 0x1080
cvttsd2si %xmm0, %rax
movq %r14, %rcx
sarq $0x20, %rcx
imulq 0x40(%rsp), %rcx
movq 0x38(%rsp), %rdx
movl %eax, (%rdx,%rcx,4)
movl %eax, (%r15,%rbp,4)
incq %rbp
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r14
jmp 0x1450
movabsq $0x100000000, %rax      # imm = 0x100000000
movq 0x30(%rsp), %r14
addq %rax, %r14
movq 0x28(%rsp), %r13
jmp 0x1408
leaq 0x48(%rsp), %rdi
callq 0x1e24
leaq 0x60(%rsp), %rdi
callq 0x1e24
movq 0x10(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14fe
movq %rax, %rbx
jmp 0x150b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1e24
leaq 0x60(%rsp), %rdi
callq 0x1e24
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
callq 0x1030
addq $0x743aa380, %rax       # imm = 0x743AA380
movq %rsp, %rdx
movq %rax, (%rdx)
movq 0x58aa(%rip), %rsi      # 0x6fe0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a63
movq (%rbx), %r14
movq 0x8(%rbx), %r15
movq 0x587f(%rip), %rbx      # 0x6fd0
cmpq %r15, %r14
je 0x1770
movzwl (%r14), %esi
movq %rbx, %rdi
callq 0x1170
movq %rax, %rdi
callq 0x10a0
addq $0x2, %r14
jmp 0x1751
leaq 0x8(%rsp), %rdi
callq 0x2066
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2066
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq 0x18(%rsi), %r15
leaq 0x20(%rsp), %rdx
movq %r15, %rsi
callq 0x1a12
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x20(%rsp), %rdi
leaq 0xe(%rsp), %rcx
movq %r15, %rsi
movq %rbx, 0x10(%rsp)
callq 0x2fc8
movq (%rbx), %rax
andw $0x0, (%rax)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x302c
orq %rdx, (%rax)
pushq $0x1
popq %rbx
leaq 0x20(%rsp), %r12
cmpq %r15, %rbx
jae 0x2208
xorl %r13d, %r13d
pushq $-0x1
popq %r14
movzwl %r13w, %r13d
movslq %r14d, %rbp
cmpq %r13, %r15
jbe 0x21e9
movq %r12, %rdi
movq %r13, %rsi
callq 0x302c
testq %rdx, (%rax)
jne 0x21e4
cmpl $-0x1, %r14d
je 0x21e1
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzwl -0x2(%rax,%rbx,2), %eax
movq 0x18(%rsp), %rcx
imulq 0x20(%rcx), %rax
shlq $0x2, %rax
addq (%rcx), %rax
movl (%rax,%r13,4), %ecx
cmpl (%rax,%rbp,4), %ecx
jae 0x21e4
movl %r13d, %r14d
incl %r13d
jmp 0x2198
movq 0x10(%rsp), %rax
movq (%rax), %rax
movw %bp, (%rax,%rbx,2)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x302c
orq %rdx, (%rax)
incq %rbx
jmp 0x218c
leaq 0x20(%rsp), %rdi
callq 0x304a
movq 0x10(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x222f
movq %rax, %r14
jmp 0x223c
jmp 0x222f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x304a
movq 0x10(%rsp), %rdi
callq 0x2066
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movq %r15, %rsi
callq 0x3250
shrq $0x2, %r15
movq %rsp, %rdi
movq $0x1, (%rdi)
movq %r15, 0x8(%rdi)
leaq 0x56a1(%rip), %rsi      # 0x8480
callq 0x32de
movq %rax, %r15
leaq 0x5692(%rip), %rsi      # 0x8480
movq %rsp, %rdi
callq 0x32de
movq %rax, %r12
leaq 0x5680(%rip), %rsi      # 0x8480
movq %rsp, %rdi
callq 0x32de
movq %rax, %r13
movq (%r14), %rdi
leaq (%rdi,%r15,2), %rsi
movq %rbx, %rdx
callq 0x33f4
addq %r15, %r12
addq %r12, %r13
leaq (,%r13,2), %rdi
addq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x33f4
movq (%r14), %rax
leaq (%rax,%r12,2), %rdi
leaq (%rax,%r13,2), %rsi
movq %rbx, %rdx
callq 0x33f4
movq (%r14), %rax
leaq (%rax,%r15,2), %rdi
leaq (%rax,%r12,2), %rsi
movq %rbx, %rdx
callq 0x33f4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2e7c
jmp 0x2e7c
jmp 0x2e7c
jmp 0x2e7c
jmp 0x2e7c
jmp 0x2e7c
jmp 0x2e7c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2066
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x371c
movq (%r15), %r12
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x371c
xorq (%r15), %r12
movq 0x10(%rbx), %rax
xorq 0x10(%r14), %rax
orq %r12, %rax
sete %bl
leaq -0x28(%rbp), %rdi
callq 0x2b04
leaq -0x38(%rbp), %rdi
callq 0x2b04
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x371c
movq (%rbx), %rax
testq %rax, %rax
je 0x37dc
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x5, %rcx
cmpq %r14, %rcx
jbe 0x3806
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %r14
leaq 0x8ba(%rip), %rsi       # 0x40a8
movq %rax, %rdi
callq 0x2050
movq 0x37b3(%rip), %rdx      # 0x6fb0
movq 0x37ec(%rip), %rsi      # 0x6ff0
jmp 0x382a
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2180
movq 0x37a5(%rip), %rdx      # 0x6fc8
movq 0x37a6(%rip), %rsi      # 0x6fd0
movq %r14, %rdi
callq 0x21c0
jmp 0x3834
movq %rax, %r15
movq %r14, %rdi
callq 0x20d0
jmp 0x3844
movq %rax, %r15
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2b04
movq %r15, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c53(%rip), %rdi      # 0x4020
callq 0x2170
testq %rax, %rax
je 0x2419
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2150
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2130
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x2424
leaq 0x8(%rsp), %rdi
callq 0x2040
leaq 0x8(%rsp), %rdi
callq 0x2060
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x228a(%rip), %rdi      # 0x46b5
callq 0x2200
pushq $0x1
popq %rdi
callq 0x2160
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/buildsi[P]ldaudit-yaml/auditlib.cpp
// Function: la_version
unsigned int la_version(unsigned int version) {
  // If version == 0 the library will be ignored by the linker.
  if (version == 0) {
    return version;
  } 

  // Prepare output - top of the yaml, and first event (version)
  std::string output = "auditlib:\n  la_version: " + std::to_string(version) + "\n  audits:\n";
  output += "  - event: handshake\n    function: la_version\n    value: " + std::to_string(version) + "\n";
  doPrint(output);

  return LAV_CURRENT;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
testl %edi, %edi
je 0x254e
movl %edi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x1bb9(%rip), %rsi      # 0x4030
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x2240
leaq 0x1bbe(%rip), %rdx      # 0x4049
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x88(%rsp), %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x1b91(%rip), %rsi      # 0x4055
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x2240
leaq 0x1e1d(%rip), %rdx      # 0x42fa
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2050
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x22b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x88(%rsp), %rdi
callq 0x20a0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x21a0
leaq 0x68(%rsp), %rdi
callq 0x25c5
leaq 0x68(%rsp), %rdi
callq 0x20a0
leaq 0x48(%rsp), %rdi
callq 0x20a0
pushq $0x2
popq %rax
jmp 0x2550
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x2590
jmp 0x2597
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x2579
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0x2588
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x20a0
jmp 0x259a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x25b8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x25b3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a45(%rip), %rdi      # 0x4020
callq 0x2170
testq %rax, %rax
je 0x2638
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2260
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2030
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x2653
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2120
movq %rsp, %rdi
callq 0x21c0
movq %rsp, %rdi
callq 0x21d0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq 0x4999(%rip), %rdi      # 0x6fd8
movq %rbx, %rsi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x2120
leaq 0x207a(%rip), %rdi      # 0x46d4
callq 0x2200
pushq $0x1
popq %rdi
callq 0x2160
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/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 %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 0x28(%rsp), %rdi
callq 0x2220
leaq 0x19d4(%rip), %rsi      # 0x408f
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2240
leaq 0x1c29(%rip), %rdx      # 0x42fa
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2050
leaq 0x48(%rsp), %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
callq 0x25c5
leaq 0x8(%rsp), %rdi
callq 0x20a0
leaq 0x68(%rsp), %rdi
callq 0x20a0
leaq 0x88(%rsp), %rdi
callq 0x20d0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x2749
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x2767
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20a0
jmp 0x2762
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0x2773
jmp 0x2770
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/buildsi[P]ldaudit-yaml/auditlib.cpp
// Function: la_objclose
unsigned int la_objclose (uintptr_t *cookie) {
  std::stringstream ss;
  ss << cookie;

  std::string output = "  - event: object_closed\n    function: la_objclose\n    identifier: " + ss.str() + "\n";
  doPrint(output);
  return 0;
}

// Assembly:
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 0x28(%rsp), %rdi
callq 0x2220
leaq 0x1320(%rip), %rsi      # 0x4522
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2240
leaq 0x10e2(%rip), %rdx      # 0x42fa
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2050
leaq 0x48(%rsp), %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
callq 0x25c5
leaq 0x8(%rsp), %rdi
callq 0x20a0
leaq 0x68(%rsp), %rdi
callq 0x20a0
leaq 0x88(%rsp), %rdi
callq 0x20d0
xorl %eax, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0x3292
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x32b0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20a0
jmp 0x32ab
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0x32bc
jmp 0x32b9
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/arinaschwartz[P]KNN-MNIST/MNISTDataset.cpp
// Function: MNISTDataset::MNISTDataset(std::istream&, std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
MNISTDataset::MNISTDataset(istream &imageFile, istream &labelFile, string type)
{
	uint32 magic, numLabels;

	magic = readUInt32(imageFile);

	if(magic!=2051)
		throw MNISTFileException("Magic number in image file is not 2051");

	this->numImages = readUInt32(imageFile);
	this->numRows = readUInt32(imageFile);
	this->numCols = readUInt32(imageFile);

	magic = readUInt32(labelFile);
	if(magic!=2049)
		throw MNISTFileException("Magic number in label file is not 2049");

	numLabels = readUInt32(labelFile);

	if (numLabels != this->numImages)
		throw MNISTFileException("Number of images doesn't match the number of labels");

	imgs = new MNISTImage*[this->numImages];

	for(uint32 i=0; i<this->numImages; i++)
	{
		uint8 img[this->numCols*this->numRows];
		uint8 label;

		label = readUInt8(labelFile);
		readUInt8Array(imageFile, img, numCols*numRows);

		imgs[i] = createImage(img, label, type);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2652
cmpl $0x803, %eax            # imm = 0x803
jne 0x25d4
movq %rbx, %rsi
callq 0x2652
movl %eax, 0x8(%r15)
movq %rbx, %rsi
callq 0x2652
movl %eax, 0xc(%r15)
movq %rbx, -0x38(%rbp)
movq %rbx, %rsi
callq 0x2652
movl %eax, 0x10(%r15)
movq %r14, %rsi
callq 0x2652
cmpl $0x801, %eax            # imm = 0x801
jne 0x25ef
movq %r14, %rsi
callq 0x2652
cmpl 0x8(%r15), %eax
jne 0x260a
movl %eax, %ebx
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2030
movq %rax, (%r15)
xorl %r12d, %r12d
movl %ebx, %eax
cmpq %rax, %r12
jae 0x25c5
movq %rsp, %r13
movl 0xc(%r15), %eax
imull 0x10(%r15), %eax
addq $0xf, %rax
andq $-0x10, %rax
movq %rsp, %rbx
subq %rax, %rbx
movq %rbx, %rsp
movq %r14, %rsi
callq 0x2674
movb %al, -0x29(%rbp)
movl 0xc(%r15), %edx
imull 0x10(%r15), %edx
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x21d0
leaq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x21f0
movzbl -0x29(%rbp), %edx
movq %r15, %rdi
movq %rbx, %rsi
leaq -0x60(%rbp), %rbx
movq %rbx, %rcx
callq 0x26a4
movq (%r15), %rcx
movq %rax, (%rcx,%r12,8)
movq %rbx, %rdi
callq 0x22b8
movq %r13, %rsp
incq %r12
movl 0x8(%r15), %ebx
jmp 0x2540
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
leaq 0x45cd(%rip), %rcx      # 0x6bb0
movq %rcx, (%rax)
leaq 0x1a17(%rip), %rcx      # 0x4004
jmp 0x2623
pushq $0x10
popq %rdi
callq 0x20e0
leaq 0x45b2(%rip), %rcx      # 0x6bb0
movq %rcx, (%rax)
leaq 0x1a23(%rip), %rcx      # 0x402b
jmp 0x2623
pushq $0x10
popq %rdi
callq 0x20e0
leaq 0x4597(%rip), %rcx      # 0x6bb0
movq %rcx, (%rax)
leaq 0x1a2f(%rip), %rcx      # 0x4052
movq %rcx, 0x8(%rax)
leaq 0x459a(%rip), %rsi      # 0x6bc8
movq 0x49a3(%rip), %rdx      # 0x6fd8
movq %rax, %rdi
callq 0x2240
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x22b8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/arinaschwartz[P]KNN-MNIST/MNISTImageImpls.cpp
// Function: ArrayMNISTImage::distance(MNISTImage const*) const
double ArrayMNISTImage::distance(const MNISTImage *img) const
{
    const ArrayMNISTImage *arrayimg = dynamic_cast<const ArrayMNISTImage*>(img);
    double squared_distance = 0;
    double first_image_point;
    double second_image_point;
    double diff;

    for(uint32 i = 0; i < size; i++){
        first_image_point = this->data[i];
        second_image_point = arrayimg->data[i];
        diff = first_image_point - second_image_point;
        squared_distance += (diff*diff);
    }
	return sqrt(squared_distance);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2a02
leaq 0x421c(%rip), %rax      # 0x6c08
leaq 0x4275(%rip), %rdx      # 0x6c68
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x21a0
jmp 0x2a04
xorl %eax, %eax
movl 0x18(%rbx), %ecx
movq 0x10(%rbx), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x2a3b
movzbl (%rdx,%rsi), %edi
cvtsi2sd %edi, %xmm1
movq 0x10(%rax), %rdi
movzbl (%rdi,%rsi), %edi
cvtsi2sd %edi, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0x2a11
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2a4b
sqrtsd %xmm0, %xmm0
popq %rbx
retq
popq %rbx
jmp 0x2130
nop