LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Exact.cpp
// Function: Exact::sdeltam(double, double)
double sdeltam(double D, double delta)
{
	// tmp
	double Et = E(D);
	double Ft = F(D);
	// denominator
	double densq1 = pow(Et, 2) * s23sq + pow(Ft, 2) * c23sq + 2 * Et * Ft * c23 * s23 * cos(delta);
	double densq2 = pow(Et, 2) * c23sq + pow(Ft, 2) * s23sq - 2 * Et * Ft * c23 * s23 * cos(delta);
	// numerator c23sq -> c23 typo corrected
	return ((pow(Et, 2) + pow(Ft, 2)) * sin(delta) * s23 * c23) / sqrt(densq1 * densq2);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x20(%rsp)
callq 0x43c1
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x444d
leaq 0x7962(%rip), %rbx      # 0xc2a0
movapd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm1, %xmm1
movapd %xmm1, 0x50(%rsp)
leaq 0x796b(%rip), %r14      # 0xc2c8
addsd %xmm2, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
leaq 0x7986(%rip), %rax      # 0xc2f8
movsd (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x795e(%rip), %rax      # 0xc2e0
movsd (%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2290
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2290
movapd 0x7672(%rip), %xmm6     # 0xc020
movapd 0x10(%rsp), %xmm7
xorpd %xmm7, %xmm6
movsd (%r14), %xmm1
movsd (%rbx), %xmm2
movapd %xmm2, %xmm3
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
movapd 0x50(%rsp), %xmm5
movapd %xmm5, %xmm4
unpckhpd %xmm5, %xmm4            # xmm4 = xmm4[1],xmm5[1]
mulpd %xmm4, %xmm3
movapd %xmm4, %xmm8
movapd %xmm5, %xmm4
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
unpcklpd %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0]
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
unpcklpd %xmm7, %xmm6            # xmm6 = xmm6[0],xmm7[0]
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm6, %xmm2
movapd 0x40(%rsp), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm2, %xmm3
unpcklpd 0x30(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
mulpd %xmm3, %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
addsd %xmm5, %xmm8
movapd %xmm8, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2060
movapd %xmm0, %xmm2
mulsd 0x30(%rsp), %xmm2
mulsd 0x40(%rsp), %xmm2
mulsd 0x20(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4a77
sqrtsd %xmm0, %xmm0
jmp 0x4a88
movsd %xmm2, 0x8(%rsp)
callq 0x2120
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Exact.cpp
// Function: Exact::UMNSm(double, double)
Matrix<std::complex<double> > UMNSm(double a, double delta)
{
	double t12m = atan2(sqrt(s12msq(a)), sqrt(c12msq(a)));
	double t13m = atan2(sqrt(s13msq(a)), sqrt(c13msq(a)));
	double t23m = atan2(sqrt(s23msq(a, delta)), sqrt(c23msq(a, delta)));
	double deltam = atan2(sdeltam(a, delta), cdeltam(a, delta));

	Matrix<std::complex<double> > U12m = U12(t12m);
	Matrix<std::complex<double> > U13m = U13(t13m);
	Matrix<std::complex<double> > U23m = U23(deltam, t23m);

	return U23m * U13m * U12m;
}

// Assembly:
pushq %rbx
subq $0xc0, %rsp
movsd %xmm1, 0x20(%rsp)
movq %rdi, %rbx
movsd %xmm0, (%rsp)
callq 0x448c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4ac3
sqrtsd %xmm0, %xmm0
jmp 0x4ac8
callq 0x2120
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm0
callq 0x457f
ucomisd 0x7878(%rip), %xmm0     # 0xc358
jb 0x4ae8
sqrtsd %xmm0, %xmm1
jmp 0x4af1
callq 0x2120
movapd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
callq 0x2050
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm0
callq 0x4597
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4b1c
sqrtsd %xmm0, %xmm0
jmp 0x4b21
callq 0x2120
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x461c
ucomisd 0x781f(%rip), %xmm0     # 0xc358
jb 0x4b41
sqrtsd %xmm0, %xmm1
jmp 0x4b4a
callq 0x2120
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x2050
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x4634
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4b7b
sqrtsd %xmm0, %xmm0
jmp 0x4b80
callq 0x2120
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x4720
ucomisd 0x77ba(%rip), %xmm0     # 0xc358
jb 0x4ba6
sqrtsd %xmm0, %xmm1
jmp 0x4baf
callq 0x2120
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x2050
movsd %xmm0, 0x28(%rsp)
movsd (%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x490f
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x4738
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x2050
movsd %xmm0, (%rsp)
leaq 0xa8(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x3a8f
leaq 0x90(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3985
leaq 0x78(%rsp), %rdi
movsd (%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x382e
leaq 0x48(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x8724
leaq 0x60(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x8a32
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x8724
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a32
leaq 0x30(%rsp), %rdi
callq 0x87a2
leaq 0x60(%rsp), %rdi
callq 0x87a2
leaq 0x48(%rsp), %rdi
callq 0x87a2
leaq 0x78(%rsp), %rdi
callq 0x87a2
leaq 0x90(%rsp), %rdi
callq 0x87a2
leaq 0xa8(%rsp), %rdi
callq 0x87a2
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x87a2
jmp 0x4cde
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x87a2
jmp 0x4ced
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x87a2
jmp 0x4cfc
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x87a2
jmp 0x4d0b
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x87a2
leaq 0xa8(%rsp), %rdi
callq 0x87a2
movq %rbx, %rdi
callq 0x2280
movq %rax, %rbx
jmp 0x4d18
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Exact.cpp
// Function: Exact::Talphabetai(int, int, int, double, double)
std::complex<double> Talphabetai(int alpha, int beta, int i, double a, double delta)
{
	assert (alpha >= 0 && alpha <= 2); // alpha valid for 0, 1, 2
	assert (beta >= 0 && beta <= 2); // beta valid for 0, 1, 2
	assert (i >= 0 && i <= 2); // i valid for 0, 1, 2

	Matrix<std::complex<double> > U = UMNSm(a, delta);
	return std::conj(U(alpha, i)) * U(beta, i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpl $0x3, %edi
jae 0x4dde
movl %esi, %ebx
cmpl $0x3, %esi
jae 0x4dfd
movl %edx, %ebp
cmpl $0x3, %edx
jae 0x4e1c
movl %edi, %r14d
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4a98
movl %r14d, %esi
movl %ebp, %r14d
movq %r15, %rdi
movq %r14, %rdx
callq 0x87b0
movsd 0x8(%rax), %xmm0
xorps 0x7298(%rip), %xmm0     # 0xc020
movsd (%rax), %xmm1
movsd %xmm1, 0x10(%rsp)
movlps %xmm0, 0x18(%rsp)
movl %ebx, %esi
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x87b0
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3719
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x87a2
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x739a(%rip), %rdi      # 0xc17f
leaq 0x75a4(%rip), %rsi      # 0xc390
leaq 0x75ab(%rip), %rcx      # 0xc39e
movl $0xc9, %edx
callq 0x2100
leaq 0x73e0(%rip), %rdi      # 0xc1e4
leaq 0x7585(%rip), %rsi      # 0xc390
leaq 0x758c(%rip), %rcx      # 0xc39e
movl $0xca, %edx
callq 0x2100
leaq 0x73d8(%rip), %rdi      # 0xc1fb
leaq 0x7566(%rip), %rsi      # 0xc390
leaq 0x756d(%rip), %rcx      # 0xc39e
movl $0xcb, %edx
callq 0x2100
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x87a2
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/First_Peak.cpp
// Function: PL(double, double const*)
double PL(double L, const double * p)
{
	int alpha = p[0];
	int beta = p[1];
	double E = p[2];
	double Yrho = p[3];
	double delta = p[4];
	int sign = p[5];
	return sign * Exact::Palphabeta(alpha, beta, Yrho * E * Y_to_a, L / E, delta);
}

// Assembly:
subq $0x18, %rsp
movapd %xmm0, %xmm1
cvttsd2si (%rdi), %eax
cvttsd2si 0x8(%rdi), %esi
movsd 0x28(%rdi), %xmm0
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, (%rsp)
movsd 0x10(%rdi), %xmm0
divsd %xmm0, %xmm1
mulsd 0x18(%rdi), %xmm0
movsd 0x20(%rdi), %xmm2
leaq 0x7204(%rip), %rcx      # 0xc330
mulsd (%rcx), %xmm0
movl %eax, %edi
callq 0x4e50
mulsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/First_Peak.cpp
// Function: First_Extremum_Exact(int, int, double, double, double, bool)
double First_Extremum_Exact(int alpha, int beta, double E, double Yrho, double delta, bool max)
{
	double L_range_min, L_range_max;
	double p[6];
	p[0] = alpha;
	p[1] = beta;
	p[2] = E;
	p[3] = Yrho;
	p[4] = delta;
	p[5] = (alpha == beta) ? 1 : -1;
	p[5] *= (max) ? 1 : -1; // switch sign for max/min

	// numbers here are selected so that the first max/min are contained in this region, but not the second
	if (max)
	{
		L_range_min = E * 300;
		L_range_max = E * 1000;
	}
	else
	{
		L_range_min = E * 500;
		L_range_max = E * 1800;
	}

	return std::abs(gss_min(PL, L_range_min, L_range_max, tol, p));
}

// Assembly:
subq $0x38, %rsp
cvtsi2sd %edi, %xmm3
cvtsi2sd %esi, %xmm4
movsd %xmm3, (%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm2, 0x20(%rsp)
xorl %eax, %eax
cmpl %esi, %edi
sete %al
leal -0x1(,%rax,2), %eax
cvtsi2sd %eax, %xmm1
testl %edx, %edx
jne 0x5188
xorpd 0x6e98(%rip), %xmm1     # 0xc020
movsd %xmm1, 0x28(%rsp)
jne 0x519a
movsd 0x7340(%rip), %xmm3     # 0xc4d8
jmp 0x51a2
movsd 0x732e(%rip), %xmm3     # 0xc4d0
mulsd %xmm0, %xmm3
jne 0x51b2
movsd 0x7338(%rip), %xmm1     # 0xc4e8
jmp 0x51ba
movsd 0x7326(%rip), %xmm1     # 0xc4e0
mulsd %xmm0, %xmm1
movsd 0xbfca(%rip), %xmm2     # 0x11190
leaq -0xdd(%rip), %rdi       # 0x50f0
movq %rsp, %rsi
movapd %xmm3, %xmm0
callq 0x8d58
andpd 0x72df(%rip), %xmm0     # 0xc4c0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/First_Peak.cpp
// Function: FP_line(int, int, double, double, bool, double*, double*)
void FP_line(int alpha, int beta, double Yrho, double delta, bool max, double *m, double *b)
{
	double p[5];
	p[0] = alpha;
	p[1] = beta;
	p[2] = Yrho;
	p[3] = delta;
	p[4] = 1; // look for a max

	double rsq;
	Linear_Fit(FEE_x, FEE_y, 0.1, 5., 1e2, p, m, b, &rsq);
}

// Assembly:
subq $0x38, %rsp
movq %r8, %r9
movq %rcx, %r8
cvtsi2sd %edi, %xmm2
leaq 0x10(%rsp), %rcx
movsd %xmm2, (%rcx)
cvtsi2sd %esi, %xmm2
movsd %xmm2, 0x8(%rcx)
movsd %xmm0, 0x10(%rcx)
movsd %xmm1, 0x18(%rcx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x20(%rcx)
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq -0xad(%rip), %rdi       # 0x51e6
leaq -0x7b(%rip), %rsi       # 0x521f
movsd 0x724e(%rip), %xmm0     # 0xc4f0
movsd 0x724e(%rip), %xmm1     # 0xc4f8
pushq $0x64
popq %rdx
callq 0x8528
addq $0x38, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::ReUm4(double, double, int, int, int, int, int, int)
double ReUm4(double a, double delta, int alpha, int beta, int w, int x, int y, int z)
{
	assert (alpha >= 0 && alpha <= 2); // alpha valid for 0, 1, 2
	assert (beta >= 0 && beta <= 2); // beta valid for 0, 1, 2
	assert (w >= 0 && w <= 2); // w valid for 0, 1, 2
	assert (x >= 0 && x <= 2); // x valid for 0, 1, 2
	assert (y >= 0 && y <= 2); // y valid for 0, 1, 2
	assert (z >= 0 && z <= 2); // z valid for 0, 1, 2

	Matrix<std::complex<double> > U = Check::UMNSm(a, delta);

	return std::real(U(alpha, w) * std::conj(U(beta, x) * U(alpha, y)) * U(beta, z));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x3, %edi
jae 0x53d0
movl %esi, %r14d
cmpl $0x3, %esi
jae 0x53e9
movl %edx, %r15d
cmpl $0x3, %edx
jae 0x5402
movl %ecx, %r12d
cmpl $0x3, %ecx
jae 0x541b
movl %r8d, %ebp
cmpl $0x3, %r8d
jae 0x5434
movl %r9d, 0x8(%rsp)
cmpl $0x3, %r9d
jae 0x544d
movl %edi, %r13d
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30d3
movl %r13d, %r13d
movl %r15d, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x87b0
movq %rax, %r15
movl %r14d, %r14d
movl %r12d, %edx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x87b0
movl 0x8(%rsp), %ebx
movq %rax, %r12
movl %ebp, %edx
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x87b0
movq %r12, %rdi
movq %rax, %rsi
callq 0x3719
xorps 0x6cb2(%rip), %xmm1     # 0xc020
leaq 0x38(%rsp), %rsi
movsd %xmm0, (%rsi)
movlps %xmm1, 0x8(%rsi)
movq %r15, %rdi
callq 0x3719
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x30(%rsp)
movl %ebx, %edx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x87b0
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x3719
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x87a2
movsd 0x8(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6da8(%rip), %rdi      # 0xc17f
leaq 0x7142(%rip), %rsi      # 0xc520
leaq 0x7146(%rip), %rcx      # 0xc52b
pushq $0x13
jmp 0x5464
leaq 0x6df4(%rip), %rdi      # 0xc1e4
leaq 0x7129(%rip), %rsi      # 0xc520
leaq 0x712d(%rip), %rcx      # 0xc52b
pushq $0x14
jmp 0x5464
leaq 0x7161(%rip), %rdi      # 0xc56a
leaq 0x7110(%rip), %rsi      # 0xc520
leaq 0x7114(%rip), %rcx      # 0xc52b
pushq $0x15
jmp 0x5464
leaq 0x7159(%rip), %rdi      # 0xc57b
leaq 0x70f7(%rip), %rsi      # 0xc520
leaq 0x70fb(%rip), %rcx      # 0xc52b
pushq $0x16
jmp 0x5464
leaq 0x7151(%rip), %rdi      # 0xc58c
leaq 0x70de(%rip), %rsi      # 0xc520
leaq 0x70e2(%rip), %rcx      # 0xc52b
pushq $0x17
jmp 0x5464
leaq 0x7149(%rip), %rdi      # 0xc59d
leaq 0x70c5(%rip), %rsi      # 0xc520
leaq 0x70c9(%rip), %rcx      # 0xc52b
pushq $0x18
popq %rdx
callq 0x2100
jmp 0x546c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x87a2
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::G1(int, int, double, double)
double G1(int alpha, int Beta, double a, double delta)
{
	double spsi = sin(Check::psi(a));
	Matrix<std::complex<double> > U = Check::UMNSm(a, delta);
	double deltaalphabeta = alpha == Beta ? 1 : 0;
	return -spsi * std::real((U(alpha, 0) * std::conj(U(Beta, 2)) + U(alpha, 2) * std::conj(U(Beta, 0)))
				* (2. * std::conj(U(alpha, 2)) * U(Beta, 2) - deltaalphabeta));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movsd %xmm1, (%rsp)
movsd %xmm0, 0x30(%rsp)
movl %esi, %ebx
movl %edi, %ebp
callq 0x299c
callq 0x2060
movaps %xmm0, 0x40(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movsd 0x30(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x30d3
cmpl %ebx, %ebp
je 0x55f4
xorpd %xmm0, %xmm0
jmp 0x55fc
movsd 0x6a1c(%rip), %xmm0     # 0xc018
movsd %xmm0, 0x10(%rsp)
movslq %ebp, %r14
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x87b0
movq %rax, %r15
movslq %ebx, %rbx
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0x87b0
movsd 0x8(%rax), %xmm0
xorpd 0x69eb(%rip), %xmm0     # 0xc020
movsd (%rax), %xmm1
leaq 0x98(%rsp), %rsi
movsd %xmm1, (%rsi)
movlpd %xmm0, 0x8(%rsi)
movq %r15, %rdi
callq 0x3719
movapd %xmm0, (%rsp)
movapd %xmm1, 0x30(%rsp)
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x87b0
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x87b0
movsd 0x8(%rax), %xmm0
xorpd 0x6994(%rip), %xmm0     # 0xc020
movsd (%rax), %xmm1
leaq 0x88(%rsp), %rsi
movsd %xmm1, (%rsi)
movlpd %xmm0, 0x8(%rsi)
movq %r15, %rdi
callq 0x3719
movapd (%rsp), %xmm2
unpcklpd 0x30(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd %xmm2, %xmm0
movapd %xmm0, 0x60(%rsp)
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x87b0
movupd (%rax), %xmm0
mulpd 0x6e22(%rip), %xmm0     # 0xc500
movapd %xmm0, 0x50(%rsp)
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0x87b0
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x3719
subsd 0x10(%rsp), %xmm0
leaq 0x78(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm1, 0x8(%rsi)
leaq 0x60(%rsp), %rdi
callq 0x3719
movapd 0x40(%rsp), %xmm1
xorpd 0x68f3(%rip), %xmm1     # 0xc020
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x87a2
movsd (%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x575b
jmp 0x575b
jmp 0x575b
jmp 0x575b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x87a2
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::G2(int, int, double, double)
double G2(int alpha, int Beta, double a, double delta)
{
	double cpsi = cos(Check::psi(a));
	Matrix<std::complex<double> > U = Check::UMNSm(a, delta);
	double deltaalphabeta = alpha == Beta ? 1 : 0;
	return cpsi * std::real((U(alpha, 1) * std::conj(U(Beta, 2)) + U(alpha, 2) * std::conj(U(Beta, 1)))
				* (2. * std::conj(U(alpha, 2)) * U(Beta, 2) - deltaalphabeta));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movsd %xmm1, 0x40(%rsp)
movsd %xmm0, 0x30(%rsp)
movl %esi, %ebx
movl %edi, %ebp
callq 0x299c
callq 0x2290
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movsd 0x30(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
callq 0x30d3
cmpl %ebx, %ebp
je 0x57c0
xorpd %xmm0, %xmm0
jmp 0x57c8
movsd 0x6850(%rip), %xmm0     # 0xc018
movsd %xmm0, 0x10(%rsp)
movslq %ebp, %r14
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x87b0
movq %rax, %r15
movslq %ebx, %rbx
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0x87b0
movsd 0x8(%rax), %xmm0
xorpd 0x681e(%rip), %xmm0     # 0xc020
movsd (%rax), %xmm1
leaq 0x98(%rsp), %rsi
movsd %xmm1, (%rsi)
movlpd %xmm0, 0x8(%rsi)
movq %r15, %rdi
callq 0x3719
movapd %xmm0, 0x40(%rsp)
movapd %xmm1, 0x30(%rsp)
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x87b0
movq %rax, %r15
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x87b0
movsd 0x8(%rax), %xmm0
xorpd 0x67c5(%rip), %xmm0     # 0xc020
movsd (%rax), %xmm1
leaq 0x88(%rsp), %rsi
movsd %xmm1, (%rsi)
movlpd %xmm0, 0x8(%rsi)
movq %r15, %rdi
callq 0x3719
movapd 0x40(%rsp), %xmm2
unpcklpd 0x30(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd %xmm2, %xmm0
movapd %xmm0, 0x60(%rsp)
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x87b0
movupd (%rax), %xmm0
mulpd 0x6c52(%rip), %xmm0     # 0xc500
movapd %xmm0, 0x50(%rsp)
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0x87b0
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x3719
subsd 0x10(%rsp), %xmm0
leaq 0x78(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm1, 0x8(%rsi)
leaq 0x60(%rsp), %rdi
callq 0x3719
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x87a2
movsd 0x8(%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5925
jmp 0x5925
jmp 0x5925
jmp 0x5925
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x87a2
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::C21(int, int, double, double, int)
double C21(int alpha, int Beta, double a, double delta, int order)
{
	assert (order >= 0 && order <= 1); // order valid for 0, 1
	double C210 = -ReUm4(a, delta, alpha, Beta, 1, 1, 0, 0);
	double C1 = epsp(a) * Dmsqee;
	double F1 = GF::F1(alpha, Beta, a, delta);
	double F2 = GF::F2(alpha, Beta, a, delta);
	double Dl31 = Check::Dl31(a, order);
	double Dl32 = Check::Dl32(a, order);
	double C211 = C1 * (F1 / Dl31 + F2 / Dl32);
	return C210 + order * C211;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x2, %edx
jae 0x5a28
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x1
popq %rcx
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movl %ecx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x52b8
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x37ac
leaq 0xb7f2(%rip), %rax      # 0x11178
mulsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5481
movaps %xmm0, 0x40(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5516
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2a4f
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2ac7
movapd 0x40(%rsp), %xmm2
unpcklpd 0x10(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
divpd %xmm1, %xmm2
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
cvtsi2sd %ebx, %xmm0
mulsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd 0x28(%rsp), %xmm0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6b7f(%rip), %rdi      # 0xc5ae
leaq 0x6aea(%rip), %rsi      # 0xc520
leaq 0x6b8a(%rip), %rcx      # 0xc5c7
pushq $0x3d
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::C31(int, int, double, double, int)
double C31(int alpha, int Beta, double a, double delta, int order)
{
	assert (order >= 0 && order <= 1); // order valid for 0, 1
	double C310 = -ReUm4(a, delta, alpha, Beta, 2, 2, 0, 0);
	double C1 = epsp(a) * Dmsqee;
	double F1 = GF::F1(alpha, Beta, a, delta);
	double F2 = GF::F2(alpha, Beta, a, delta);
	double G1 = GF::G1(alpha, Beta, a, delta);
	double Dl31 = Check::Dl31(a, order);
	double Dl32 = Check::Dl32(a, order);
	double C311 = C1 * ((F1 + G1) / Dl31 - F2 / Dl32);
	return C310 + order * C311;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
cmpl $0x2, %edx
jae 0x5b55
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x2
popq %rcx
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movl %ecx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x52b8
movsd %xmm0, 0x38(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x37ac
leaq 0xb6e7(%rip), %rax      # 0x11178
mulsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5481
movsd %xmm0, 0x28(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5516
movaps %xmm0, 0x50(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x55a7
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2a4f
movaps %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2ac7
movapd 0x10(%rsp), %xmm1
addsd 0x28(%rsp), %xmm1
unpcklpd 0x50(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
movapd 0x40(%rsp), %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
subsd %xmm0, %xmm1
cvtsi2sd %ebx, %xmm0
mulsd 0x30(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd 0x38(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6a52(%rip), %rdi      # 0xc5ae
leaq 0x69bd(%rip), %rsi      # 0xc520
leaq 0x6a8b(%rip), %rcx      # 0xc5f5
pushq $0x4a
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::C32(int, int, double, double, int)
double C32(int alpha, int Beta, double a, double delta, int order)
{
	assert (order >= 0 && order <= 1); // order valid for 0, 1
	double C320 = -ReUm4(a, delta, alpha, Beta, 2, 2, 1, 1);
	double C1 = epsp(a) * Dmsqee;
	double F1 = GF::F1(alpha, Beta, a, delta);
	double F2 = GF::F2(alpha, Beta, a, delta);
	double G2 = GF::G2(alpha, Beta, a, delta);
	double Dl31 = Check::Dl31(a, order);
	double Dl32 = Check::Dl32(a, order);
	double C321 = C1 * (-F1 / Dl31 + (F2 + G2) / Dl32);
	return C320 + order * C321;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
cmpl $0x2, %edx
jae 0x5c7f
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x2
popq %rcx
pushq $0x1
popq %r8
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movl %ecx, %edx
movl %r8d, %r9d
callq 0x52b8
movsd %xmm0, 0x38(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x37ac
leaq 0xb5b9(%rip), %rax      # 0x11178
mulsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5481
movaps %xmm0, 0x50(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5516
movsd %xmm0, 0x28(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5770
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2a4f
movaps %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2ac7
movapd 0x10(%rsp), %xmm1
addsd 0x28(%rsp), %xmm1
unpcklpd 0x50(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
unpcklpd 0x40(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
subsd %xmm0, %xmm1
cvtsi2sd %ebx, %xmm0
mulsd 0x30(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd 0x38(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6928(%rip), %rdi      # 0xc5ae
leaq 0x6893(%rip), %rsi      # 0xc520
leaq 0x698f(%rip), %rcx      # 0xc623
pushq $0x58
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Hat.cpp
// Function: Hat::lp(double)
double lp(double a)
{
	double x = Dmsqee + a;
	double y = normal_sign * sqrt(pow(Dmsqee - a, 2) + 4 * s13sq * a * Dmsqee);
	double z = eps * Dmsqee * s12sq;
	return (x + y) / 2. + z;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
leaq 0xaf54(%rip), %rbx      # 0x11178
movsd (%rbx), %xmm2
movapd %xmm2, %xmm3
leaq 0x6075(%rip), %rax      # 0xc2a8
movsd (%rax), %xmm0
mulsd 0x62d1(%rip), %xmm0     # 0xc510
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm2
leaq 0xaf3a(%rip), %rax      # 0x1118c
cvtsi2sdl (%rax), %xmm4
subsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x6272
sqrtsd %xmm0, %xmm0
jmp 0x628d
movsd %xmm2, 0x8(%rsp)
movsd %xmm4, (%rsp)
callq 0x2120
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm2
mulsd %xmm4, %xmm0
leaq 0xaee8(%rip), %rax      # 0x11180
movsd (%rax), %xmm1
mulsd (%rbx), %xmm1
addsd %xmm0, %xmm2
leaq 0x5fed(%rip), %rax      # 0xc298
mulsd (%rax), %xmm1
mulsd 0x5d51(%rip), %xmm2     # 0xc008
addsd %xmm1, %xmm2
movapd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Hat.cpp
// Function: Hat::Pee(double, double)
double Pee(double a, double LE)
{
	double L4E = km_per_GeV_to_per_eV2 * LE / 4; // in eV^-2 now
	double Deltapm = (lp(a) - lm(a)) * L4E;
	double P = 1 - pow(s2phi(a) * sin(Deltapm), 2);
	ProbabilityWarning W(&P);
	return P;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm0, 0x8(%rsp)
leaq 0x5e3a(%rip), %rax      # 0xc328
mulsd (%rax), %xmm1
mulsd 0x5e3e(%rip), %xmm1     # 0xc338
movsd %xmm1, 0x10(%rsp)
callq 0x6214
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x62c5
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6376
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x2060
mulsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x5ac2(%rip), %xmm1     # 0xc018
subsd %xmm0, %xmm1
leaq 0x18(%rsp), %rbx
movsd %xmm1, (%rbx)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xadac
movsd (%rbx), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xaa7a
movsd (%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Hat.cpp
// Function: Hat::W(double, int)
Matrix<std::complex<double> > W(double a, int order)
{
	assert (order >= 0 && order <= 1); // order valid for 0, 1

	Matrix<std::complex<double> > W(3, 3);
	double c = cos(phi(a) - t13);
	double s = sin(phi(a) - t13);
	double coef = eps * c12 * s12 * Dmsqee;

	switch (order)
	{
		case 1:
			W(0, 1) += coef * c / Dl0m(a);
			W(1, 0) -= coef * c / Dl0m(a);
			W(1, 2) += coef * s / Dlp0(a);
			W(2, 1) -= coef * s / Dlp0(a);

		case 0:
			// zeroth order
			for (int i = 0; i < 3; i++)
				W(i, i) += 1;
	}
	return W;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, 0x8(%rsp)
cmpl $0x2, %esi
jae 0x6a0d
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x3
popq %rdx
movq %rdx, %rsi
callq 0x8682
movsd 0x8(%rsp), %xmm0
callq 0x63e2
leaq 0x5a9e(%rip), %rax      # 0xc318
movsd (%rax), %xmm1
movsd %xmm1, 0x10(%rsp)
subsd %xmm1, %xmm0
callq 0x2290
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x63e2
subsd 0x10(%rsp), %xmm0
callq 0x2060
testb $0x1, %bpl
je 0x69d5
movsd %xmm0, 0x10(%rsp)
leaq 0xa8c0(%rip), %rax      # 0x11180
movsd (%rax), %xmm0
leaq 0x5a25(%rip), %rax      # 0xc2f0
mulsd (%rax), %xmm0
leaq 0x5a02(%rip), %rax      # 0xc2d8
mulsd (%rax), %xmm0
leaq 0xa897(%rip), %rax      # 0x11178
mulsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x643f
movsd %xmm0, 0x20(%rsp)
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x87b0
movsd 0x18(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
divsd 0x20(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x643f
movsd %xmm0, 0x20(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x87b0
movsd 0x18(%rsp), %xmm1
divsd 0x20(%rsp), %xmm1
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x64ad
movsd %xmm0, 0x18(%rsp)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x87b0
movsd 0x10(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
divsd 0x18(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x64ad
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x87b0
movsd 0x10(%rsp), %xmm1
divsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
xorl %r14d, %r14d
cmpq $0x3, %r14
je 0x6a01
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x87b0
movsd (%rax), %xmm0
addsd 0x5620(%rip), %xmm0     # 0xc018
movsd %xmm0, (%rax)
incq %r14
jmp 0x69d8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5b9a(%rip), %rdi      # 0xc5ae
leaq 0x5c9f(%rip), %rsi      # 0xc6ba
leaq 0x5ca4(%rip), %rcx      # 0xc6c6
pushq $0x5e
popq %rdx
callq 0x2100
jmp 0x6a2c
movq %rax, %r14
movq %rbx, %rdi
callq 0x87a2
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Hat.cpp
// Function: Hat::Talphabetai(int, int, int, double, double, int)
std::complex<double> Talphabetai(int alpha, int beta, int i, double a, double delta, int order)
{
	assert (alpha >= 0 && alpha <= 2); // alpha valid for 0, 1, 2
	assert (beta >= 0 && beta <= 2); // beta valid for 0, 1, 2
	assert (i >= 0 && i <= 2); // i valid for 0, 1, 2
	assert (order >= 0 && order <= 1); // order valid for 0, 1

	Matrix<std::complex<double> > Vtmp = V(a, delta, order);
	return std::conj(Vtmp(alpha, i)) * Vtmp(beta, i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpl $0x3, %edi
jae 0x6c58
movl %esi, %ebx
cmpl $0x3, %esi
jae 0x6c77
movl %edx, %ebp
cmpl $0x3, %edx
jae 0x6c96
cmpl $0x2, %ecx
jae 0x6cb5
movl %edi, %r14d
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl %ecx, %esi
callq 0x6ad0
movl %r14d, %esi
movl %ebp, %r14d
movq %r15, %rdi
movq %r14, %rdx
callq 0x87b0
movsd 0x8(%rax), %xmm0
xorps 0x541e(%rip), %xmm0     # 0xc020
movsd (%rax), %xmm1
movsd %xmm1, 0x10(%rsp)
movlps %xmm0, 0x18(%rsp)
movl %ebx, %esi
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x87b0
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3719
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x87a2
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5520(%rip), %rdi      # 0xc17f
leaq 0x5a54(%rip), %rsi      # 0xc6ba
leaq 0x5ac3(%rip), %rcx      # 0xc730
movl $0x81, %edx
callq 0x2100
leaq 0x5566(%rip), %rdi      # 0xc1e4
leaq 0x5a35(%rip), %rsi      # 0xc6ba
leaq 0x5aa4(%rip), %rcx      # 0xc730
movl $0x82, %edx
callq 0x2100
leaq 0x555e(%rip), %rdi      # 0xc1fb
leaq 0x5a16(%rip), %rsi      # 0xc6ba
leaq 0x5a85(%rip), %rcx      # 0xc730
movl $0x83, %edx
callq 0x2100
leaq 0x58f2(%rip), %rdi      # 0xc5ae
leaq 0x59f7(%rip), %rsi      # 0xc6ba
leaq 0x5a66(%rip), %rcx      # 0xc730
movl $0x84, %edx
callq 0x2100
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x87a2
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Hyperbolas.cpp
// Function: Hyperbolas::l2(double)
double l2(double a)
{
	double ax = cos(2 * t12) * eps * Dmsqee;
	double ax12 = lb - la(0);
	double ax13 = lc - la(0);
	double atr = (ax13 - ax12) / 2.; // ansatz that simple average is right, perhaps weighted average by the X's is better

	if (a < atr)
		return 0.5 * ((a - ax) + sqrt(pow(a - ax, 2) + pow(X12(a), 2))) + lb;
	else
		return 0.5 * ((la(a) + lc) - sqrt(pow(la(a) - lc, 2) + pow(X23, 2)));

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, (%rsp)
leaq 0x521f(%rip), %rax      # 0xc308
movsd (%rax), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x2290
leaq 0xa07d(%rip), %rbx      # 0x11180
movsd (%rbx), %xmm2
leaq 0xa06a(%rip), %r14      # 0x11178
movsd (%r14), %xmm3
movsd 0xa085(%rip), %xmm5     # 0x111a0
leaq 0x5186(%rip), %rax      # 0xc2a8
leaq 0x516f(%rip), %rcx      # 0xc298
movsd (%rcx), %xmm1
mulsd %xmm2, %xmm1
addsd (%rax), %xmm1
mulsd %xmm3, %xmm1
xorpd %xmm6, %xmm6
addsd %xmm1, %xmm6
subsd %xmm6, %xmm5
movsd 0xa05b(%rip), %xmm4     # 0x111a8
movapd %xmm4, %xmm7
subsd %xmm6, %xmm7
subsd %xmm5, %xmm7
movsd (%rsp), %xmm5
mulsd 0x4ea2(%rip), %xmm7     # 0xc008
ucomisd %xmm5, %xmm7
jbe 0x71c0
mulsd %xmm2, %xmm0
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm5
movsd %xmm5, (%rsp)
mulsd %xmm5, %xmm5
movsd %xmm5, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2060
mulsd (%rbx), %xmm0
mulsd (%r14), %xmm0
mulsd %xmm0, %xmm0
addsd 0x8(%rsp), %xmm0
sqrtsd %xmm0, %xmm0
addsd (%rsp), %xmm0
mulsd 0x4e52(%rip), %xmm0     # 0xc008
addsd 0x9fe2(%rip), %xmm0     # 0x111a0
jmp 0x71f4
addsd %xmm5, %xmm1
movapd %xmm4, %xmm0
addsd %xmm1, %xmm0
subsd %xmm4, %xmm1
mulsd %xmm1, %xmm1
movsd 0x9fd4(%rip), %xmm2     # 0x111b0
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
sqrtsd %xmm2, %xmm1
subsd %xmm1, %xmm0
mulsd 0x4e14(%rip), %xmm0     # 0xc008
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Hyperbolas.cpp
// Function: Hyperbolas::s12msq(double)
double s12msq(double D)
{
	double x = (pow(Hyperbolas::l2(D), 2) - alpha() * Hyperbolas::l2(D) + beta()) * Hyperbolas::Dl31(D);
	double s12msq_n = -x;
	double s12msq_d = Hyperbolas::Dl32(D) * (pow(Hyperbolas::l1(D), 2) - alpha() * Hyperbolas::l1(D) + beta()) - x;
	return s12msq_n / s12msq_d;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x70d6
mulsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x72fe
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x70d6
mulsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x733e
addsd 0x10(%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x7298
movapd 0x10(%rsp), %xmm1
xorpd 0x4ba2(%rip), %xmm1     # 0xc020
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x72cb
movsd %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x703e
mulsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x72fe
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x703e
mulsd 0x28(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x733e
addsd 0x10(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Linear_Fit.cpp
// Function: void Linear_Fit<double>(double (*)(double, double const*), double (*)(double, double const*), double, double, int, double*, double*, double*, double*)
void Linear_Fit(T (*x)(T t, const T *p), T (*y)(T t, const T *p), T t_min, T t_max, int n, T *p, T *m, T *b, T *rsq)
{
	T sum_x = 0;
	T sum_xsq = 0;
	T sum_y = 0;
	T sum_ysq = 0;
	T sum_xy = 0;

	T x_tmp, y_tmp;
	for (T t = t_min; t <= t_max; t += (t_max - t_min) / (n - 1))
	{
		x_tmp = x(t, p);
		y_tmp = y(t, p);
		sum_x += x_tmp;
		sum_xsq += pow(x_tmp, 2);
		sum_y += y_tmp;
		sum_ysq += pow(y_tmp, 2);
		sum_xy += x_tmp * y_tmp;
	}

	T x_bar = sum_x / n;
	T y_bar = sum_y / n;

	T ss_xx = sum_xsq - n * pow(x_bar, 2);
	T ss_yy = sum_ysq - n * pow(y_bar, 2);
	T ss_xy = sum_xy - n * x_bar * y_bar;

	*m = ss_xy / ss_xx;
	*b = y_bar - *m * x_bar;
	*rsq = pow(ss_xy, 2) / (ss_xx * ss_yy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movl %edx, %r15d
movapd %xmm0, %xmm2
movq %rsi, %r13
movq %rdi, %rbp
movsd %xmm1, 0x18(%rsp)
subsd %xmm0, %xmm1
leal -0x1(%r15), %eax
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
xorpd %xmm4, %xmm4
xorpd %xmm3, %xmm3
xorpd %xmm5, %xmm5
movsd 0x18(%rsp), %xmm0
ucomisd %xmm2, %xmm0
jb 0x85f8
movapd %xmm2, %xmm0
movq %r12, %rdi
movapd %xmm3, 0x50(%rsp)
movapd %xmm4, 0x40(%rsp)
movapd %xmm5, 0x30(%rsp)
movsd %xmm2, 0x8(%rsp)
callq *%rbp
movapd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
movq %r12, %rdi
callq *%r13
movsd 0x8(%rsp), %xmm2
movapd 0x30(%rsp), %xmm5
movapd 0x40(%rsp), %xmm4
movapd 0x50(%rsp), %xmm3
movapd %xmm0, %xmm1
movapd 0x20(%rsp), %xmm6
unpcklpd %xmm6, %xmm1            # xmm1 = xmm1[0],xmm6[0]
addpd %xmm1, %xmm4
mulpd %xmm1, %xmm1
addpd %xmm1, %xmm5
mulsd %xmm0, %xmm6
addsd %xmm6, %xmm3
addsd 0x10(%rsp), %xmm2
jmp 0x8574
cvtsi2sd %r15d, %xmm0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
divpd %xmm1, %xmm4
movapd %xmm4, %xmm2
mulpd %xmm4, %xmm2
mulpd %xmm1, %xmm2
subpd %xmm2, %xmm5
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
mulsd %xmm1, %xmm0
mulsd %xmm4, %xmm0
subsd %xmm0, %xmm3
movapd %xmm5, %xmm0
unpckhpd %xmm5, %xmm0            # xmm0 = xmm0[1],xmm5[1]
movapd %xmm3, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%r14)
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm4
movsd %xmm4, (%rbx)
mulsd %xmm3, %xmm3
mulsd %xmm5, %xmm0
divsd %xmm0, %xmm3
movq 0xa0(%rsp), %rax
movsd %xmm3, (%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::operator=(Matrix<std::complex<double>>)
Matrix<T> Matrix<T>::operator = (const Matrix other)
{
	rows = other.rows;
	cols = other.cols;
	buffer = new T[rows * cols];
	std::copy(other.buffer, other.buffer + rows * cols, buffer);
	return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, (%rsi)
movq 0x8(%rdx), %rbp
movq %rbp, 0x8(%rsi)
imulq %rax, %rbp
movq %rbp, %rax
shrq $0x3c, %rax
movq %rbp, %r12
shlq $0x4, %r12
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r12, %rdi
callq 0x2030
movq %rax, %r13
testq %rbp, %rbp
je 0x88de
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20e0
movq %r13, 0x10(%r14)
movq 0x10(%r15), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x2250
jmp 0x88e2
movq %r13, 0x10(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8724
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::operator+=(Matrix<std::complex<double>>)
Matrix<T> Matrix<T>::operator += (const Matrix other)
{
	assert(rows == other.rows);
	assert(cols == other.cols);

	for (std::size_t i = 0; i < rows * cols; i++)
		buffer[i] += other.buffer[i];
	return *this;
}

// Assembly:
pushq %rbx
movq (%rsi), %rcx
cmpq (%rdx), %rcx
jne 0x895d
movq 0x8(%rsi), %r8
cmpq 0x8(%rdx), %r8
jne 0x8976
movq %rdi, %rbx
xorl %eax, %eax
xorl %edi, %edi
imulq %rcx, %r8
cmpq %r8, %rdi
jae 0x8950
movq 0x10(%rdx), %rcx
movq 0x10(%rsi), %r8
movupd (%rcx,%rax), %xmm0
movupd (%r8,%rax), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%r8,%rax)
incq %rdi
movq (%rsi), %rcx
movq 0x8(%rsi), %r8
addq $0x10, %rax
jmp 0x891a
movq %rbx, %rdi
callq 0x8724
movq %rbx, %rax
popq %rbx
retq
leaq 0x400a(%rip), %rdi      # 0xc96e
leaq 0x3f15(%rip), %rsi      # 0xc880
leaq 0x400f(%rip), %rcx      # 0xc981
pushq $0x40
jmp 0x898d
leaq 0x4063(%rip), %rdi      # 0xc9e0
leaq 0x3efc(%rip), %rsi      # 0xc880
leaq 0x3ff6(%rip), %rcx      # 0xc981
pushq $0x41
popq %rdx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::operator+(Matrix<std::complex<double>>) const
Matrix<T> Matrix<T>::operator + (const Matrix other) const
{
	assert(rows == other.rows);
	assert(cols == other.cols);

	Matrix ret(cols, rows);
	for (std::size_t i = 0; i < rows * cols; i++)
		ret.buffer[i] = buffer[i] + other.buffer[i];
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq (%rsi), %rdx
cmpq (%rbx), %rdx
jne 0x89fb
movq %rsi, %r15
movq 0x8(%rsi), %rsi
cmpq 0x8(%rbx), %rsi
jne 0x8a14
movq %rdi, %r14
callq 0x8682
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x8(%r15), %rdx
imulq (%r15), %rdx
cmpq %rdx, %rcx
jae 0x89f2
movq 0x10(%r15), %rdx
movq 0x10(%rbx), %rsi
movq 0x10(%r14), %rdi
movupd (%rdx,%rax), %xmm0
movupd (%rsi,%rax), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rdi,%rax)
incq %rcx
addq $0x10, %rax
jmp 0x89bd
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3f6c(%rip), %rdi      # 0xc96e
leaq 0x3e77(%rip), %rsi      # 0xc880
leaq 0x3fe3(%rip), %rcx      # 0xc9f3
pushq $0x4b
jmp 0x8a2b
leaq 0x3fc5(%rip), %rdi      # 0xc9e0
leaq 0x3e5e(%rip), %rsi      # 0xc880
leaq 0x3fca(%rip), %rcx      # 0xc9f3
pushq $0x4c
popq %rdx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::operator*(Matrix<std::complex<double>>) const
Matrix<T> Matrix<T>::operator * (const Matrix rhs) const
{
	assert(cols == rhs.rows);

	Matrix ret(rows, rhs.cols);
	for (std::size_t i = 0; i < rows; i++)
	{
		for (std::size_t j = 0; j < rhs.cols; j++)
		{
			for (std::size_t k = 0; k < rows; k++)
			{
				ret(i, j) += this->Get(i, k) * rhs(k, j);
			}
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x8(%rsi), %rax
cmpq (%rdx), %rax
jne 0x8b1f
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%rdx), %rdx
callq 0x8682
movq (%r15), %rax
xorl %r12d, %r12d
cmpq %rax, %r12
jae 0x8b0d
xorl %r13d, %r13d
cmpq 0x8(%r14), %r13
jae 0x8b05
xorl %ebp, %ebp
cmpq %rax, %rbp
jae 0x8afd
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x8b50
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x880e
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x3719
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x30(%rsp)
callq 0x87b0
movupd (%rax), %xmm0
movapd 0x20(%rsp), %xmm1
unpcklpd 0x30(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
addpd %xmm0, %xmm1
movupd %xmm1, (%rax)
incq %rbp
movq (%r15), %rax
jmp 0x8a80
incq %r13
jmp 0x8a74
incq %r12
jmp 0x8a68
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f31(%rip), %rdi      # 0xca57
leaq 0x3d53(%rip), %rsi      # 0xc880
leaq 0x3f34(%rip), %rcx      # 0xca68
pushq $0x57
popq %rdx
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x87a2
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::Transpose()
void Matrix<T>::Transpose()
{
	T * tmp = new T[rows * cols];
	std::copy(buffer, buffer + rows * cols, tmp);

	for (std::size_t i = 0; i < rows; i++)
	{
		for (std::size_t j = 0; j < cols; j++)
			buffer[Get_index(i, j)] = tmp[Get_index(j, i)];
	}
	delete [] tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r13
movq 0x8(%rdi), %r12
movq %r12, %rbp
imulq %r13, %rbp
movq %rbp, %rax
shrq $0x3c, %rax
movq %rbp, %r15
shlq $0x4, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x2030
movq %rax, %r14
testq %rbp, %rbp
je 0x8c0b
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2250
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %r13, %rcx
jae 0x8c5d
movq %rcx, %rdx
shlq $0x4, %rdx
addq %r14, %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpq %r12, %rdi
jae 0x8c51
movq %rax, %r8
imulq %r12, %r8
imulq %rdi, %r12
shlq $0x4, %r12
addq 0x10(%rbx), %r8
movups (%rdx,%r12), %xmm0
movups %xmm0, (%rsi,%r8)
incq %rdi
movq 0x8(%rbx), %r12
addq $0x10, %rsi
jmp 0x8c22
incq %rcx
movq (%rbx), %r13
addq $0x10, %rax
jmp 0x8c0f
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::Hermitian()
void Matrix<T>::Hermitian()
{
	T * tmp = new T[rows * cols];
	std::copy(buffer, buffer + rows * cols, tmp);

	for (std::size_t i = 0; i < rows; i++)
	{
		for (std::size_t j = 0; j < cols; j++)
			buffer[Get_index(i, j)] = std::conj(tmp[Get_index(j, i)]);
	}
	delete [] tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r13
movq 0x8(%rdi), %r12
movq %r12, %rbp
imulq %r13, %rbp
movq %rbp, %rax
shrq $0x3c, %rax
movq %rbp, %r15
shlq $0x4, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x2030
movq %rax, %r14
testq %rbp, %rbp
je 0x8cc5
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2250
xorl %eax, %eax
pushq $0x8
popq %rcx
movaps 0x334f(%rip), %xmm0     # 0xc020
xorl %edx, %edx
cmpq %r13, %rdx
jae 0x8d35
movq %rdx, %rsi
shlq $0x4, %rsi
addq %r14, %rsi
movq %rcx, %rdi
xorl %r8d, %r8d
cmpq %r12, %r8
jae 0x8d29
movq %rax, %r9
imulq %r12, %r9
imulq %r8, %r12
shlq $0x4, %r12
movsd (%rsi,%r12), %xmm1
movsd 0x8(%rsi,%r12), %xmm2
xorps %xmm0, %xmm2
addq 0x10(%rbx), %r9
movsd %xmm1, -0x8(%rdi,%r9)
movlps %xmm2, (%rdi,%r9)
incq %r8
movq 0x8(%rbx), %r12
addq $0x10, %rdi
jmp 0x8ce8
incq %rdx
movq (%rbx), %r13
addq $0x10, %rax
jmp 0x8cd3
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21c0
nop