LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kebwi[P]Trifid/src/FFT/fftext.cpp
// Function: rspectprod(double*, double*, double*, long)
void rspectprod(Float_t *data1, Float_t *data2, Float_t *outdata, long N){
// When multiplying a pair of spectra from rfft care must be taken to multiply the
// two real values seperately from the complex ones. This routine does it correctly.
// the result can be stored in-place over one of the inputs
/* INPUTS */
/* *data1 = input data array	first spectra */
/* *data2 = input data array	second spectra */
/* N = fft input size for both data1 and data2 */
/* OUTPUTS */
/* *outdata = output data array spectra */
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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jle 0x3a9a0
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x3a9b8
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0xe634(%rip), %xmm0     # 0x49020
movsd %xmm0, (%rax)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x2, %rcx
cmpq %rcx, %rax
jae 0x3aa78
movq -0x20(%rbp), %xmm0
movaps 0xe63b(%rip), %xmm3     # 0x49050
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0xe63f(%rip), %xmm2     # 0x49060
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x12f88(%rip), %xmm1    # 0x4d9c0
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x4660
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3a9f8
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x2, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x3ab70
movq $0x0, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x3ab4c
movq -0x28(%rbp), %rax
andq -0x38(%rbp), %rax
cmpq $0x0, %rax
je 0x3ab31
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rcx
sarq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x3ab33
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x3ab00
movq -0x30(%rbp), %rax
movw %ax, %dx
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3aada
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0xa, -0x10(%rbp)
ja 0x3abc9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x3b750
jmp 0x3ac68
movq $0x0, -0x38(%rbp)
cmpq $0x8, -0x38(%rbp)
jge 0x3ac34
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x3, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
imulq %rcx, %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
subq $0x3, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
subq $0x1, %r9
callq 0x3ab80
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3abd1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
subq $0x3, %rcx
movl $0x1, %r8d
shlq %cl, %r8
movq -0x40(%rbp), %rcx
movl $0x1, %r9d
callq 0x3b750
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0xa, -0x10(%rbp)
ja 0x3aee9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x40290
jmp 0x3af88
movq $0x0, -0x38(%rbp)
cmpq $0x8, -0x38(%rbp)
jge 0x3af54
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x3, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
imulq %rcx, %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
subq $0x3, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
subq $0x1, %r9
callq 0x3aea0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3aef1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
subq $0x3, %rcx
movl $0x1, %r8d
shlq %cl, %r8
movq -0x40(%rbp), %rcx
movl $0x1, %r9d
callq 0x40290
addq $0x40, %rsp
popq %rbp
retq
nop
// File: kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: fft2pt(double*)
inline void fft2pt(Float_t *ioptr){
/***   RADIX 2 fft	***/
Float_t f0r, f0i, f1r, f1i;
Float_t t0r, t0i;

	/* bit reversed load */
f0r = ioptr[0];
f0i = ioptr[1];
f1r = ioptr[2];
f1i = ioptr[3];

		/* Butterflys		*/
		/*
		f0	-	-	t0
		f1	-  1 -	f1
		*/

t0r = f0r + f1r;
t0i = f0i + f1i;
f1r = f0r - f1r;
f1i = f0i - f1i;

	/* store result */
ioptr[0] = t0r;
ioptr[1] = t0i;
ioptr[2] = f1r;
ioptr[3] = f1i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: ifft2pt(double*, double)
inline void ifft2pt(Float_t *ioptr, Float_t scale){
/***   RADIX 2 ifft	***/
Float_t f0r, f0i, f1r, f1i;
Float_t t0r, t0i;

	/* bit reversed load */
f0r = ioptr[0];
f0i = ioptr[1];
f1r = ioptr[2];
f1i = ioptr[3];

		/* Butterflys		*/
		/*
		f0	-	-	t0
		f1	-  1 -	f1
		*/

t0r = f0r + f1r;
t0i = f0i + f1i;
f1r = f0r - f1r;
f1i = f0i - f1i;

	/* store result */
ioptr[0] = scale*t0r;
ioptr[1] = scale*t0i;
ioptr[2] = scale*f1r;
ioptr[3] = scale*f1i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: rfft1pt(double*)
inline void rfft1pt(Float_t *ioptr){
/***   RADIX 2 rfft	***/
Float_t f0r, f0i;
Float_t t0r, t0i;

	/* bit reversed load */
f0r = ioptr[0];
f0i = ioptr[1];

	/* finish rfft */
t0r = 	f0r + f0i;
t0i = 	f0r - f0i;

	/* store result */
ioptr[0] = t0r;
ioptr[1] = t0i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nop
// File: kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: rfft2pt(double*)
inline void rfft2pt(Float_t *ioptr){
/***   RADIX 4 rfft	***/
Float_t f0r, f0i, f1r, f1i;
Float_t t0r, t0i;

	/* bit reversed load */
f0r = ioptr[0];
f0i = ioptr[1];
f1r = ioptr[2];
f1i = ioptr[3];

		/* Butterflys		*/
		/*
		f0	-	-	t0
		f1	-  1 -	f1
		*/

t0r = f0r + f1r;
t0i = f0i + f1i;
f1r = f0r - f1r;
f1i = f1i - f0i;
	/* finish rfft */
f0r = 	t0r + t0i;
f0i = 	t0r - t0i;

	/* store result */
ioptr[0] = f0r;
ioptr[1] = f0i;
ioptr[2] = f1r;
ioptr[3] = f1i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: rifft1pt(double*, double)
inline void rifft1pt(Float_t *ioptr, Float_t scale){
/***   RADIX 2 rifft	***/
Float_t f0r, f0i;
Float_t t0r, t0i;

	/* bit reversed load */
f0r = ioptr[0];
f0i = ioptr[1];

	/* finish rfft */
t0r = 	f0r + f0i;
t0i = 	f0r - f0i;

	/* store result */
ioptr[0] = scale*t0r;
ioptr[1] = scale*t0i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: kebwi[P]Trifid/src/FFT/fftlib.cpp
// Function: rifft2pt(double*, double)
inline void rifft2pt(Float_t *ioptr, Float_t scale){
/***   RADIX 4 rifft	***/
Float_t f0r, f0i, f1r, f1i;
Float_t t0r, t0i;
const Float_t Two = 2.0;

	/* bit reversed load */
t0r = ioptr[0];
t0i = ioptr[1];
f1r = Two * ioptr[2];
f1i = Two * ioptr[3];

	/* start rifft */
f0r = 	t0r + t0i;
f0i = 	t0r - t0i;
		/* Butterflys		*/
		/*
		f0	-	-	t0
		f1	-  1 -	f1
		*/

t0r = f0r + f1r;
t0i = f0i - f1i;
f1r = f0r - f1r;
f1i = f0i + f1i;

	/* store result */
ioptr[0] = scale*t0r;
ioptr[1] = scale*t0i;
ioptr[2] = scale*f1r;
ioptr[3] = scale*f1i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd 0x3ea3(%rip), %xmm0     # 0x4a548
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movsd 0x3e77(%rip), %xmm0     # 0x4a548
mulsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x3e61(%rip), %xmm0     # 0x4a548
mulsd 0x18(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x17e0
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1d30
jmp 0x1b74
leaq -0x40(%rbp), %rdi
callq 0x1d10
movq %rax, %xmm0
movaps 0x2487(%rip), %xmm1     # 0x4010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x248b(%rip), %xmm1     # 0x4020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x1, -0x5c(%rbp)
cvtsi2sdl -0x5c(%rbp), %xmm1
movsd -0x58(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1c6e
movsd -0x58(%rbp), %xmm1
movsd 0x245f(%rip), %xmm0     # 0x4030
divsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x58(%rbp), %xmm0
cvtsi2sdl -0x5c(%rbp), %xmm1
subsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
movsd 0x2439(%rip), %xmm1     # 0x4038
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1f40
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x3260
movsd %xmm0, -0x70(%rbp)
movsd %xmm1, -0x68(%rbp)
movslq -0x5c(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1f40
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x1bb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1cb0
jmp 0x1ca0
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2050
leaq -0x40(%rbp), %rdi
callq 0x1cb0
leaq -0x28(%rbp), %rdi
callq 0x1cb0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x1130
nopl (%rax)
// File: 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 $0x70, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movabsq $0x401921fb54442c46, %rax # imm = 0x401921FB54442C46
movq %rax, -0x60(%rbp)
movl $0x1, %edi
callq 0x32a0
movsd %xmm0, -0x70(%rbp)
movsd %xmm1, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3260
movsd %xmm0, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3220
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31e0
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3630
movq %rax, -0x10(%rbp)
callq 0x3650
movl %eax, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x245a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x244a
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x243a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x36a0
movq %rax, %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq -0x14(%rbp), %rdi
callq 0x3660
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x243c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x23fb
jmp 0x244c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x23e9
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2c60
movq %rax, -0x40(%rbp)
movl $0x79e, -0x4c(%rbp)     # imm = 0x79E
leaq -0x48(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x4430
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x43e0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq 0xe43e(%rip), %rsi      # 0x10fe0
leaq -0x38(%rbp), %rdx
callq 0x3ca0
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3af0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b60
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4450
testb $0x1, %al
jne 0x2be9
leaq -0x30(%rbp), %rdi
callq 0x3c20
jmp 0x2c45
leaq -0x58(%rbp), %rdi
callq 0x4490
movw (%rax), %ax
movw %ax, -0x62(%rbp)
movzwl -0x62(%rbp), %esi
movq 0xe3cc(%rip), %rdi      # 0x10fd0
callq 0x21c0
movq %rax, -0x80(%rbp)
jmp 0x2c0f
movq -0x80(%rbp), %rdi
movq 0xe3a6(%rip), %rsi      # 0x10fc0
callq 0x2130
jmp 0x2c21
jmp 0x2c23
leaq -0x58(%rbp), %rdi
callq 0x44b0
jmp 0x2bcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3c20
jmp 0x2c50
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x21f0
nopl (%rax)
// File: estan[P]tsp/tsp.cpp
// Function: length(std::vector<unsigned short, std::allocator<unsigned short>> const&, Matrix<unsigned int> const&)
inline uint64_t length(const vector<uint16_t>& tour, const Matrix<uint32_t>& d) {
    size_t N = tour.size();
    uint64_t length = 0;
    for (size_t i = 0, j = 1; i < N; ++i, ++j) {
        length += d[tour[i]][tour[j % N]];
    }
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b90
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x67db
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8ee0
movq -0x40(%rbp), %rdi
movzwl (%rax), %esi
callq 0x36a0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, %rsi
callq 0x8ee0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movzwl (%rcx), %ecx
movl (%rax,%rcx,4), %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6765
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: estan[P]tsp/tsp.cpp
// Function: reverse(std::vector<unsigned short, std::allocator<unsigned short>>&, unsigned long, unsigned long, std::vector<unsigned short, std::allocator<unsigned short>>&)
inline void reverse(vector<uint16_t> &tour, size_t start, size_t end,
        vector<uint16_t>& position) {
    size_t N = tour.size();
    size_t numSwaps = (((start <= end ? end - start : (end + N) - start) + 1)/2);
    uint16_t i = start;
    uint16_t j = end;
    for (size_t n = 0; n < numSwaps; ++n) {
        swap(tour[i], tour[j]);
        position[tour[i]] = i;
        position[tour[j]] = j;
        i = (i + 1) % N;
        j = ((j + N) - 1) % N;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b90
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x90bd
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x90cd
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
shrq %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movw %ax, -0x32(%rbp)
movq -0x18(%rbp), %rax
movw %ax, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x91dc
movq -0x8(%rbp), %rdi
movzwl -0x32(%rbp), %eax
movl %eax, %esi
callq 0x3ad0
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x3ad0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x91f0
movw -0x32(%rbp), %ax
movw %ax, -0x5a(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0x32(%rbp), %eax
movl %eax, %esi
callq 0x3ad0
movq -0x68(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, %esi
callq 0x3ad0
movw -0x5a(%rbp), %cx
movw %cx, (%rax)
movw -0x34(%rbp), %ax
movw %ax, -0x4a(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x3ad0
movq -0x58(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, %esi
callq 0x3ad0
movw -0x4a(%rbp), %cx
movw %cx, (%rax)
movzwl -0x32(%rbp), %eax
addl $0x1, %eax
cltq
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
movw %dx, %ax
movw %ax, -0x32(%rbp)
movzwl -0x34(%rbp), %eax
addq -0x28(%rbp), %rax
subq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
movw %dx, %ax
movw %ax, -0x34(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x90f4
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x21(%rbp)
callq 0x7230
movq -0x40(%rbp), %rdi
callq 0x7580
testb $0x1, %al
jne 0x74d6
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0xc20(%rip), %rsi       # 0x80a8
callq 0x2060
jmp 0x748f
movq -0x50(%rbp), %rdi
movq 0x5b56(%rip), %rsi      # 0xcff0
movq 0x5b0f(%rip), %rdx      # 0xcfb0
callq 0x21e0
jmp 0x7579
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x20e0
jmp 0x7567
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7567
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x5f80
movq %rax, %rdi
callq 0x5fa0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jb 0x754a
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
callq 0x21a0
jmp 0x751a
movq -0x60(%rbp), %rdi
movq 0x5aab(%rip), %rsi      # 0xcfd0
movq 0x5a9c(%rip), %rdx      # 0xcfc8
callq 0x21e0
jmp 0x7579
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x20e0
jmp 0x7567
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x755d
movq -0x40(%rbp), %rdi
callq 0x34a0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34a0
movq -0x30(%rbp), %rdi
callq 0x2200
nopl (%rax)
// File: 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 %rax
leaq 0x3a58(%rip), %rdi      # 0x7000
callq 0x32c0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x35c1
movq (%rsp), %rdi
callq 0x35d0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: buildsi[P]ldaudit-yaml/auditlib.cpp
// Function: initFile(char*)
static void initFile(char * filename) {
    std::fstream file;
    file.open(filename, std::ios::out);
    if(!file) {
      printf("Error in creating output file.\n");
      exit (EXIT_FAILURE);
    }
    file.close();
}

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x230(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x32a0
movq 0x8(%rsp), %rdi
movq 0x230(%rsp), %rsi
movl $0x10, %edx
callq 0x3210
jmp 0x3607
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x20(%rsp,%rax), %rdi
callq 0x3110
movb %al, 0x7(%rsp)
jmp 0x3620
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x362a
jmp 0x365e
leaq 0x403a(%rip), %rdi      # 0x766b
xorl %eax, %eax
callq 0x3040
jmp 0x363a
movl $0x1, %edi
callq 0x32b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x30a0
jmp 0x367c
leaq 0x20(%rsp), %rdi
callq 0x3060
jmp 0x366a
leaq 0x20(%rsp), %rdi
callq 0x30a0
addq $0x238, %rsp            # imm = 0x238
retq
movq 0x18(%rsp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x108, %rsp            # imm = 0x108
movl %edi, 0x100(%rsp)
cmpl $0x0, 0x100(%rsp)
jne 0x36bb
movl 0x100(%rsp), %eax
movl %eax, 0x104(%rsp)
jmp 0x38cf
movl 0x100(%rsp), %esi
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x33a0
movq 0x8(%rsp), %rdx
leaq 0x3930(%rip), %rsi      # 0x7010
leaq 0xc0(%rsp), %rdi
callq 0x33e0
jmp 0x36ef
leaq 0x3933(%rip), %rdx      # 0x7029
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x3090
jmp 0x370d
leaq 0xc0(%rsp), %rdi
callq 0x3130
leaq 0xa0(%rsp), %rdi
callq 0x3130
movl 0x100(%rsp), %esi
leaq 0x30(%rsp), %rdi
callq 0x33a0
jmp 0x373a
leaq 0x38f4(%rip), %rsi      # 0x7035
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x33e0
jmp 0x3752
leaq 0x3b81(%rip), %rdx      # 0x72da
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3090
jmp 0x376a
leaq 0xe0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x32e0
jmp 0x377e
leaq 0x70(%rsp), %rdi
callq 0x3130
leaq 0x50(%rsp), %rdi
callq 0x3130
leaq 0x30(%rsp), %rdi
callq 0x3130
leaq 0x10(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x30f0
jmp 0x37b0
leaq 0x10(%rsp), %rdi
callq 0x38f0
jmp 0x37bc
leaq 0x10(%rsp), %rdi
callq 0x3130
movl $0x2, 0x104(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x3130
jmp 0x38cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x381a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x3130
leaq 0xa0(%rsp), %rdi
callq 0x3130
jmp 0x38de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x38c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x3896
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x388c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x3130
leaq 0x50(%rsp), %rdi
callq 0x3130
leaq 0x30(%rsp), %rdi
callq 0x3130
jmp 0x38c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3130
leaq 0xe0(%rsp), %rdi
callq 0x3130
jmp 0x38de
movl 0x104(%rsp), %eax
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x98(%rsp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: 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:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x10(%rsp)
movq %rdi, 0x230(%rsp)
leaq 0x36f5(%rip), %rdi      # 0x7000
callq 0x32c0
movq %rax, 0x228(%rsp)
cmpq $0x0, 0x228(%rsp)
je 0x39cf
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3400
movq 0x8(%rsp), %rdi
movq 0x228(%rsp), %rsi
movl $0x1, %edx
callq 0x3050
jmp 0x394f
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x28(%rsp,%rax), %rdi
callq 0x3110
movb %al, 0x7(%rsp)
jmp 0x3968
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x3972
jmp 0x39a6
leaq 0x3d12(%rip), %rdi      # 0x768b
xorl %eax, %eax
callq 0x3040
jmp 0x3982
movl $0x1, %edi
callq 0x32b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3370
jmp 0x39e8
movq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3200
jmp 0x39b7
leaq 0x28(%rsp), %rdi
callq 0x3330
jmp 0x39c3
leaq 0x28(%rsp), %rdi
callq 0x3370
jmp 0x39e0
movq 0x10(%rsp), %rsi
movq 0x65fd(%rip), %rdi      # 0x9fd8
callq 0x3200
addq $0x238, %rsp            # imm = 0x238
retq
movq 0x20(%rsp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x3160
leaq 0xa8(%rsp), %rdi
movq 0x220(%rsp), %rsi
callq 0x31b0
jmp 0x3a33
leaq 0x28(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x3220
jmp 0x3a47
leaq 0x3621(%rip), %rsi      # 0x706f
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x33e0
jmp 0x3a5f
leaq 0x3874(%rip), %rdx      # 0x72da
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3090
jmp 0x3a77
leaq 0x48(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x30f0
jmp 0x3a9c
leaq 0x8(%rsp), %rdi
callq 0x38f0
jmp 0x3aa8
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x68(%rsp), %rdi
callq 0x3130
leaq 0x98(%rsp), %rdi
callq 0x31a0
addq $0x228, %rsp            # imm = 0x228
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x3b65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x3b1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x3b65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x3b5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x68(%rsp), %rdi
callq 0x3130
leaq 0x98(%rsp), %rdi
callq 0x31a0
movq 0x90(%rsp), %rdi
callq 0x3410
nop
// File: 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:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x3160
leaq 0xa8(%rsp), %rdi
movq 0x220(%rsp), %rsi
callq 0x31b0
jmp 0x4b33
leaq 0x28(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x3220
jmp 0x4b47
leaq 0x29b4(%rip), %rsi      # 0x7502
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x33e0
jmp 0x4b5f
leaq 0x2774(%rip), %rdx      # 0x72da
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3090
jmp 0x4b77
leaq 0x48(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x30f0
jmp 0x4b9c
leaq 0x8(%rsp), %rdi
callq 0x38f0
jmp 0x4ba8
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x68(%rsp), %rdi
callq 0x3130
leaq 0x98(%rsp), %rdi
callq 0x31a0
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x4c67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x4c1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x4c67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x4c5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x68(%rsp), %rdi
callq 0x3130
leaq 0x98(%rsp), %rdi
callq 0x31a0
movq 0x90(%rsp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: fhirschman[P]CANF-gp/source/general_functions.cc
// Function: freeAll()
void freeAll(){
	for( int i = 0 ; i < N_Y ; i++ ){
	    delete[] cnumber_matrix[i];
	}
	delete[] cnumber_matrix;
	// gp.close();     
	return;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
leaq 0x20a61(%rip), %rcx     # 0x298e8
cmpl (%rcx), %eax
jge 0x8ec2
leaq 0x20be6(%rip), %rax     # 0x29a78
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8eb3
movq 0x8(%rsp), %rdi
callq 0x8700
jmp 0x8eb5
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8e7c
leaq 0x20baf(%rip), %rax     # 0x29a78
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x8edf
movq (%rsp), %rdi
callq 0x8700
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: fhirschman[P]CANF-gp/source/general_functions.cc
// Function: limitsChanged()
int limitsChanged(){
	if(abs(x_max-x_max_SAVE)>epsilon  || abs(x_min-x_min_SAVE)>epsilon  ||abs(y_max-y_max_SAVE)>epsilon  ||abs(y_min-y_min_SAVE)>epsilon){
		return 1;
	}
	else{
		return 0;
	}
}

// Assembly:
pushq %rax
leaq 0x20428(%rip), %rax     # 0x29940
movsd (%rax), %xmm0
leaq 0x2043d(%rip), %rax     # 0x29960
subsd (%rax), %xmm0
callq 0xbe50
leaq 0x20045(%rip), %rax     # 0x29578
ucomisd (%rax), %xmm0
ja 0x95b1
leaq 0x203f8(%rip), %rax     # 0x29938
movsd (%rax), %xmm0
leaq 0x2040d(%rip), %rax     # 0x29958
subsd (%rax), %xmm0
callq 0xbe50
leaq 0x2001d(%rip), %rax     # 0x29578
ucomisd (%rax), %xmm0
ja 0x95b1
leaq 0x203e8(%rip), %rax     # 0x29950
movsd (%rax), %xmm0
leaq 0x203fd(%rip), %rax     # 0x29970
subsd (%rax), %xmm0
callq 0xbe50
leaq 0x1fff5(%rip), %rax     # 0x29578
ucomisd (%rax), %xmm0
ja 0x95b1
leaq 0x203b8(%rip), %rax     # 0x29948
movsd (%rax), %xmm0
leaq 0x203cd(%rip), %rax     # 0x29968
subsd (%rax), %xmm0
callq 0xbe50
leaq 0x1ffcd(%rip), %rax     # 0x29578
ucomisd (%rax), %xmm0
jbe 0x95bb
movl $0x1, 0x4(%rsp)
jmp 0x95c3
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopl (%rax)
// File: fhirschman[P]CANF-gp/source/general_functions.cc
// Function: deactivatedZoomMode()
int deactivatedZoomMode(){
	if(abs(abs(x_max-x_min) - abs(x_max_SAVE-x_min_SAVE)) < 0.05*N_X && abs(abs(y_max-y_min) - abs(y_max_SAVE-y_min_SAVE)) < 0.05*N_Y){
		return 1;
	}
	else{
		return 0;
	}
}

// Assembly:
subq $0x18, %rsp
leaq 0x20365(%rip), %rax     # 0x29940
movsd (%rax), %xmm0
leaq 0x20352(%rip), %rax     # 0x29938
subsd (%rax), %xmm0
callq 0xbe50
movsd %xmm0, 0x8(%rsp)
leaq 0x20364(%rip), %rax     # 0x29960
movsd (%rax), %xmm0
leaq 0x20351(%rip), %rax     # 0x29958
subsd (%rax), %xmm0
callq 0xbe50
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
callq 0xbe50
movaps %xmm0, %xmm1
leaq 0x202b8(%rip), %rax     # 0x298e4
cvtsi2sdl (%rax), %xmm2
movsd 0x149e8(%rip), %xmm0    # 0x1e020
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x96b8
leaq 0x20307(%rip), %rax     # 0x29950
movsd (%rax), %xmm0
leaq 0x202f4(%rip), %rax     # 0x29948
subsd (%rax), %xmm0
callq 0xbe50
movsd %xmm0, (%rsp)
leaq 0x20307(%rip), %rax     # 0x29970
movsd (%rax), %xmm0
leaq 0x202f4(%rip), %rax     # 0x29968
subsd (%rax), %xmm0
callq 0xbe50
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
subsd %xmm1, %xmm0
callq 0xbe50
movaps %xmm0, %xmm1
leaq 0x20250(%rip), %rax     # 0x298e8
cvtsi2sdl (%rax), %xmm2
movsd 0x1497c(%rip), %xmm0    # 0x1e020
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x96b8
movl $0x1, 0x14(%rsp)
jmp 0x96c0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: fhirschman[P]CANF-gp/source/general_functions.cc
// Function: saveLimits()
void saveLimits(){
	gp.getLimits(x_min,x_max,y_min,y_max);
	x_max_SAVE=x_max;
	x_min_SAVE=x_min;
	y_max_SAVE=y_max;
	y_min_SAVE=y_min;
	return;
}

// Assembly:
pushq %rax
leaq 0x1f308(%rip), %rdi     # 0x29a80
leaq 0x1f1b9(%rip), %rsi     # 0x29938
leaq 0x1f1ba(%rip), %rdx     # 0x29940
leaq 0x1f1bb(%rip), %rcx     # 0x29948
leaq 0x1f1bc(%rip), %r8      # 0x29950
callq 0xbf70
leaq 0x1f1a0(%rip), %rax     # 0x29940
movsd (%rax), %xmm0
leaq 0x1f1b5(%rip), %rax     # 0x29960
movsd %xmm0, (%rax)
leaq 0x1f182(%rip), %rax     # 0x29938
movsd (%rax), %xmm0
leaq 0x1f197(%rip), %rax     # 0x29958
movsd %xmm0, (%rax)
leaq 0x1f184(%rip), %rax     # 0x29950
movsd (%rax), %xmm0
leaq 0x1f199(%rip), %rax     # 0x29970
movsd %xmm0, (%rax)
leaq 0x1f166(%rip), %rax     # 0x29948
movsd (%rax), %xmm0
leaq 0x1f17b(%rip), %rax     # 0x29968
movsd %xmm0, (%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: fhirschman[P]CANF-gp/source/general_functions.cc
// Function: setup()
void setup( ){
	// Allocate Unified Memory – accessible from CPU or GPU
	cnumber_matrix = new complex<double>*[N_Y];
	for(int i=0; i<N_Y; i++){
		cnumber_matrix[i] = new complex<double>[N_X];
	};
	
	iter_matrix.resize(N_Y);
	for (int i=0; i<N_Y;i++){
		iter_matrix[i].resize(N_X);
	}

	roots_matrix.resize(N_Y);
	for (int i=0; i<N_Y;i++){
		roots_matrix[i].resize(N_X);
	}

	N_RAND_COLORS =  sizeof colorMatrix / sizeof colorMatrix[0];
	return;
}

// Assembly:
subq $0x58, %rsp
leaq 0x1f0dd(%rip), %rax     # 0x298e8
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rcx
leaq 0x1f23f(%rip), %rax     # 0x29a78
movq %rcx, (%rax)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
leaq 0x1f099(%rip), %rcx     # 0x298e8
cmpl (%rcx), %eax
jge 0xa936
leaq 0x1f086(%rip), %rax     # 0x298e4
movslq (%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, 0x20(%rsp)
callq 0x8030
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rsp)
cmpq $0x0, %rax
je 0xa8ec
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rdx
shlq $0x4, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xc0c0
jmp 0xa8d4
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0xa8bd
movq 0x30(%rsp), %rdx
leaq 0x1f180(%rip), %rax     # 0x29a78
movq (%rax), %rax
movslq 0x54(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xa844
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x8a40
jmp 0xaa02
leaq 0x1efab(%rip), %rax     # 0x298e8
movslq (%rax), %rsi
leaq 0x1f0c1(%rip), %rdi     # 0x29a08
callq 0xc0f0
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
leaq 0x1ef89(%rip), %rcx     # 0x298e8
cmpl (%rcx), %eax
jge 0xa993
movslq 0x40(%rsp), %rsi
leaq 0x1f099(%rip), %rdi     # 0x29a08
callq 0xbd50
movq %rax, %rdi
leaq 0x1ef66(%rip), %rax     # 0x298e4
movslq (%rax), %rsi
callq 0xc190
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0xa954
leaq 0x1ef4e(%rip), %rax     # 0x298e8
movslq (%rax), %rsi
leaq 0x1f07c(%rip), %rdi     # 0x29a20
callq 0xc0f0
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
leaq 0x1ef2c(%rip), %rcx     # 0x298e8
cmpl (%rcx), %eax
jge 0xa9f0
movslq 0x3c(%rsp), %rsi
leaq 0x1f054(%rip), %rdi     # 0x29a20
callq 0xbd50
movq %rax, %rdi
leaq 0x1ef09(%rip), %rax     # 0x298e4
movslq (%rax), %rsi
callq 0xc190
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0xa9b1
leaq 0x1ef09(%rip), %rax     # 0x29900
movl $0x35, (%rax)
addq $0x58, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x8960
nopl (%rax)