LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::l3(double, int)
double l3(double a, int order)
{
	assert (order >= 0 && order <= 2); // order valid for 0, 1, 2
	double l3 = l30(a);
	if (order == 2)
		l3 += l32(a);
	return l3;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x3, %edi
jae 0x28da
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x6b14
cmpl $0x2, %ebx
jne 0x28d4
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x28fe
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb74f(%rip), %rdi      # 0xe030
leaq 0xb761(%rip), %rsi      # 0xe049
leaq 0xb7a4(%rip), %rcx      # 0xe093
movl $0x1f, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::Dl21(double, int)
double Dl21(double a, int order)
{
	assert (order >= 0 && order <= 2); // order valid for 0, 1, 2
	if (order < 2)
		return l20(a) - l10(a);
	else
		return l2(a) - l1(a);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
cmpl $0x3, %edi
jae 0x2a80
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x2745
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, %ebx
jne 0x2a61
movsd 0x8(%rsp), %xmm0
callq 0x2814
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2590
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2660
addsd 0x18(%rsp), %xmm0
jmp 0x2a6c
movsd 0x8(%rsp), %xmm0
callq 0x2590
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xb5a9(%rip), %rdi      # 0xe030
leaq 0xb5bb(%rip), %rsi      # 0xe049
leaq 0xb61c(%rip), %rcx      # 0xe0b1
movl $0x4b, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::Dl31(double, int)
double Dl31(double a, int order)
{
	assert (order >= 0 && order <= 2); // order valid for 0, 1, 2
	if (order < 2)
		return l30(a) - l10(a);
	else
		return l3(a) - l1(a);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
cmpl $0x3, %edi
jae 0x2b1f
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x6b14
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, %ebx
jne 0x2b00
movsd 0x8(%rsp), %xmm0
callq 0x28fe
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2590
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2660
addsd 0x18(%rsp), %xmm0
jmp 0x2b0b
movsd 0x8(%rsp), %xmm0
callq 0x2590
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xb50a(%rip), %rdi      # 0xe030
leaq 0xb51c(%rip), %rsi      # 0xe049
leaq 0xb59d(%rip), %rcx      # 0xe0d1
movl $0x53, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::Dl32(double, int)
double Dl32(double a, int order)
{
	assert (order >= 0 && order <= 2); // order valid for 0, 1, 2
	if (order < 2)
		return l30(a) - l20(a);
	else
		return l3(a) - l2(a);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
cmpl $0x3, %edi
jae 0x2bbe
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x6b14
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, %ebx
jne 0x2b9f
movsd 0x8(%rsp), %xmm0
callq 0x28fe
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2745
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2814
addsd 0x18(%rsp), %xmm0
jmp 0x2baa
movsd 0x8(%rsp), %xmm0
callq 0x2745
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xb46b(%rip), %rdi      # 0xe030
leaq 0xb47d(%rip), %rsi      # 0xe049
leaq 0xb51e(%rip), %rcx      # 0xe0f1
movl $0x5b, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::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 <= 2); // order valid for 0, 1, 2

	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 $0x48, %rsp
cmpl $0x3, %edi
jae 0x350c
movl %esi, %ebx
cmpl $0x3, %esi
jae 0x352b
movl %edx, %ebp
cmpl $0x3, %edx
jae 0x354a
cmpl $0x3, %ecx
jae 0x3569
movl %edi, %r14d
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ecx, %esi
callq 0x3361
movl %r14d, %esi
movl %ebp, %r14d
movq %r15, %rdi
movq %r14, %rdx
callq 0xa1d2
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movl %ebx, %esi
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0xa1d2
movaps 0x10(%rsp), %xmm1
xorps 0xab68(%rip), %xmm1     # 0xe020
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rdi)
movlps %xmm1, 0x8(%rdi)
movq %rax, %rsi
callq 0x3968
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xa1c4
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xac6c(%rip), %rdi      # 0xe17f
leaq 0xab2f(%rip), %rsi      # 0xe049
leaq 0xac77(%rip), %rcx      # 0xe198
movl $0xa6, %edx
callq 0x20f0
leaq 0xacb2(%rip), %rdi      # 0xe1e4
leaq 0xab10(%rip), %rsi      # 0xe049
leaq 0xac58(%rip), %rcx      # 0xe198
movl $0xa7, %edx
callq 0x20f0
leaq 0xacaa(%rip), %rdi      # 0xe1fb
leaq 0xaaf1(%rip), %rsi      # 0xe049
leaq 0xac39(%rip), %rcx      # 0xe198
movl $0xa8, %edx
callq 0x20f0
leaq 0xaac0(%rip), %rdi      # 0xe030
leaq 0xaad2(%rip), %rsi      # 0xe049
leaq 0xac1a(%rip), %rcx      # 0xe198
movl $0xa9, %edx
callq 0x20f0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa1c4
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Constants.cpp
// Function: set_ordering(bool)
void set_ordering(bool _normal)
{
	normal = _normal;
	normal_sign = normal ? 1 : -1;

	Dmsq31 = normal_sign * Dmsq31_base;

	Dmsqee = Dmsq31 - s12sq * Dmsq21;
	eps = Dmsq21 / Dmsqee;
}

// Assembly:
movb %dil, 0xf782(%rip)      # 0x13198
decl %edi
orl $0x1, %edi
cvtsi2sd %edi, %xmm0
mulsd 0xa841(%rip), %xmm0     # 0xe268
movl %edi, 0xf76f(%rip)      # 0x1319c
movsd %xmm0, 0xf74b(%rip)     # 0x13180
addsd 0xa833(%rip), %xmm0     # 0xe270
movsd %xmm0, 0xf743(%rip)     # 0x13188
movsd 0xa82b(%rip), %xmm1     # 0xe278
divsd %xmm0, %xmm1
movsd %xmm1, 0xf737(%rip)     # 0x13190
retq
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Constants.cpp
// Function: U23(double, double)
Matrix<std::complex<double> > U23(double delta, double angle)
{
	std::complex<double> eid(cos(delta), sin(delta));
	Matrix<std::complex<double> > ret(3, 3);
	ret(0, 0) = 1;
	ret(1, 1) = cos(angle);
	ret(1, 2) = sin(angle) * eid;
	ret(2, 1) = -sin(angle) * std::conj(eid);
	ret(2, 2) = cos(angle);
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
callq 0x22c0
movaps %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2070
movaps %xmm0, 0x10(%rsp)
movl $0x3, %esi
movl $0x3, %edx
movq %rbx, %rdi
callq 0xa076
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1d2
movsd 0xa568(%rip), %xmm0     # 0xe018
movups %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movsd %xmm0, 0x20(%rsp)
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa1d2
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2070
movaps %xmm0, 0x20(%rsp)
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa1d2
movapd 0x30(%rsp), %xmm0
unpcklpd 0x10(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd %xmm0, 0x30(%rsp)
mulpd %xmm0, %xmm1
movupd %xmm1, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2070
movaps %xmm0, 0x10(%rsp)
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa1d2
movapd 0xa4c8(%rip), %xmm0     # 0xe020
movapd 0x10(%rsp), %xmm1
xorpd %xmm1, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd 0x30(%rsp), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movsd %xmm0, 0x8(%rsp)
movl $0x2, %esi
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa1d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x3bb8
jmp 0x3bb8
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1c4
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Constants.cpp
// Function: U13(double)
Matrix<std::complex<double> > U13(double angle)
{
	Matrix<std::complex<double> > ret(3, 3);
	ret(0, 0) = cos(angle);
	ret(0, 2) = sin(angle);
	ret(1, 1) = 1;
	ret(2, 0) = -sin(angle);
	ret(2, 2) = cos(angle);
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x3, %esi
movl $0x3, %edx
callq 0xa076
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1d2
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2070
movsd %xmm0, 0x10(%rsp)
movl $0x2, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa1d2
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa1d2
movsd 0xa3b3(%rip), %xmm0     # 0xe018
movups %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2070
movaps %xmm0, 0x10(%rsp)
movl $0x2, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa1d2
movaps 0x10(%rsp), %xmm0
xorps 0xa38d(%rip), %xmm0     # 0xe020
movlps %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movsd %xmm0, 0x8(%rsp)
movl $0x2, %esi
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa1d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1c4
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Constants.cpp
// Function: U12(double)
Matrix<std::complex<double> > U12(double angle)
{
	Matrix<std::complex<double> > ret(3, 3);
	ret(0, 0) = cos(angle);
	ret(0, 1) = sin(angle);
	ret(1, 0) = -sin(angle);
	ret(1, 1) = cos(angle);
	ret(2, 2) = 1;
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x3, %esi
movl $0x3, %edx
callq 0xa076
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1d2
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2070
movsd %xmm0, 0x10(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa1d2
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2070
movaps %xmm0, 0x10(%rsp)
movl $0x1, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa1d2
movaps 0x10(%rsp), %xmm0
xorps 0xa284(%rip), %xmm0     # 0xe020
movlps %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movsd %xmm0, 0x8(%rsp)
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa1d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x2, %esi
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa1d2
movsd 0xa222(%rip), %xmm0     # 0xe018
movups %xmm0, (%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1c4
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Dmsqeff.cpp
// Function: Dmsqeff::Pee(double, double)
double Pee(double a, double LE)
{
	double L4E = km_per_GeV_to_per_eV2 * LE / 4; // in eV^-2 now

	double Delta21 = Dmsq21 * L4E;
	double Deltaee = Dlee(a) * L4E;

	return 1 - pow(c13sq * sin(2 * t12) * sin(Delta21), 2) - pow(sin(2 * t13) * sin(Deltaee), 2);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0xa37b(%rip), %rax      # 0xe328
mulsd (%rax), %xmm1
mulsd 0xa37f(%rip), %xmm1     # 0xe338
movsd %xmm1, 0x8(%rsp)
leaq 0xa2ea(%rip), %rax      # 0xe2b0
movsd (%rax), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
callq 0x6f81
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0xa2e4(%rip), %rbx      # 0xe2d0
leaq 0xa315(%rip), %rax      # 0xe308
movsd (%rax), %xmm0
addsd %xmm0, %xmm0
callq 0x2070
mulsd (%rbx), %xmm0
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2070
movaps %xmm0, 0x10(%rsp)
leaq 0xa2f7(%rip), %rax      # 0xe318
movsd (%rax), %xmm0
addsd %xmm0, %xmm0
callq 0x2070
movapd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2070
movapd 0x30(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd 0x10(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm2, %xmm1
mulpd %xmm1, %xmm1
movsd 0x9fb3(%rip), %xmm0     # 0xe018
subsd %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
subsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Exact.cpp
// Function: Exact::cdeltam(double, double)
double cdeltam(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)) * cos(delta) * s23 * c23 + Et * Ft * (c23sq - s23sq)) / sqrt(densq1 * densq2);
}

// Assembly:
subq $0xa8, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
callq 0x4772
movaps %xmm0, 0x60(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4837
movapd %xmm0, 0x90(%rsp)
leaq 0x959f(%rip), %rax      # 0xe2a0
movsd (%rax), %xmm1
movaps %xmm1, 0x30(%rsp)
movapd 0x60(%rsp), %xmm1
movapd %xmm1, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm2, %xmm2
movapd %xmm2, 0x10(%rsp)
leaq 0x959f(%rip), %rax      # 0xe2c8
movsd (%rax), %xmm2
movaps %xmm2, 0x40(%rsp)
addsd %xmm1, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, 0x80(%rsp)
leaq 0x95ae(%rip), %rax      # 0xe2f8
movsd (%rax), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x9586(%rip), %rax      # 0xe2e0
movsd (%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movapd 0x929a(%rip), %xmm7     # 0xe020
movapd 0x80(%rsp), %xmm8
xorpd %xmm8, %xmm7
movapd 0x30(%rsp), %xmm5
movapd %xmm5, %xmm1
movapd 0x40(%rsp), %xmm6
unpcklpd %xmm6, %xmm1            # xmm1 = xmm1[0],xmm6[0]
movapd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2            # xmm2 = xmm2[1],xmm4[1]
mulpd %xmm2, %xmm1
movapd %xmm4, %xmm3
movapd %xmm4, %xmm9
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
movapd %xmm6, %xmm4
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
mulpd %xmm3, %xmm4
addpd %xmm1, %xmm4
unpcklpd %xmm8, %xmm7            # xmm7 = xmm7[0],xmm8[0]
movapd 0x70(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm7, %xmm1
movapd 0x50(%rsp), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm1, %xmm3
unpcklpd 0x20(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
mulpd %xmm3, %xmm0
addpd %xmm4, %xmm0
movapd %xmm0, 0x20(%rsp)
subsd %xmm2, %xmm9
movapd %xmm9, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movapd %xmm0, %xmm2
mulsd 0x10(%rsp), %xmm2
mulsd 0x50(%rsp), %xmm2
movapd 0x60(%rsp), %xmm1
mulsd 0x90(%rsp), %xmm1
movapd 0x40(%rsp), %xmm0
subsd 0x30(%rsp), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x70(%rsp), %xmm2
addsd %xmm0, %xmm2
movapd 0x20(%rsp), %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4e7f
sqrtsd %xmm0, %xmm0
jmp 0x4e90
movsd %xmm2, 0x8(%rsp)
callq 0x2120
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
addq $0xa8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4772
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4837
leaq 0x93d1(%rip), %rbx      # 0xe2a0
movapd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm1, %xmm1
movapd %xmm1, 0x50(%rsp)
leaq 0x93da(%rip), %r14      # 0xe2c8
addsd %xmm2, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
leaq 0x93f5(%rip), %rax      # 0xe2f8
movsd (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x93cd(%rip), %rax      # 0xe2e0
movsd (%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movapd 0x90e1(%rip), %xmm6     # 0xe020
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 0x2070
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 0x5008
sqrtsd %xmm0, %xmm0
jmp 0x5019
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_O3/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 $0x48, %rsp
cmpl $0x3, %edi
jae 0x53c9
movl %esi, %ebx
cmpl $0x3, %esi
jae 0x53e8
movl %edx, %ebp
cmpl $0x3, %edx
jae 0x5407
movl %edi, %r14d
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x5029
movl %r14d, %esi
movl %ebp, %r14d
movq %r15, %rdi
movq %r14, %rdx
callq 0xa1d2
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movl %ebx, %esi
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0xa1d2
movaps 0x10(%rsp), %xmm1
xorps 0x8cab(%rip), %xmm1     # 0xe020
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rdi)
movlps %xmm1, 0x8(%rdi)
movq %rax, %rsi
callq 0x3968
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xa1c4
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8daf(%rip), %rdi      # 0xe17f
leaq 0x8fb9(%rip), %rsi      # 0xe390
leaq 0x8fc0(%rip), %rcx      # 0xe39e
movl $0xc9, %edx
callq 0x20f0
leaq 0x8df5(%rip), %rdi      # 0xe1e4
leaq 0x8f9a(%rip), %rsi      # 0xe390
leaq 0x8fa1(%rip), %rcx      # 0xe39e
movl $0xca, %edx
callq 0x20f0
leaq 0x8ded(%rip), %rdi      # 0xe1fb
leaq 0x8f7b(%rip), %rsi      # 0xe390
leaq 0x8f82(%rip), %rcx      # 0xe39e
movl $0xcb, %edx
callq 0x20f0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa1c4
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8b38(%rip), %rcx      # 0xe330
mulsd (%rcx), %xmm0
movl %eax, %edi
callq 0x543b
mulsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
testl %edx, %edx
jne 0x5857
xorpd 0x87c9(%rip), %xmm1     # 0xe020
movsd %xmm1, 0x28(%rsp)
jne 0x5869
movsd 0x8c71(%rip), %xmm3     # 0xe4d8
jmp 0x5871
movsd 0x8c5f(%rip), %xmm3     # 0xe4d0
mulsd %xmm0, %xmm3
jne 0x5881
movsd 0x8c69(%rip), %xmm1     # 0xe4e8
jmp 0x5889
movsd 0x8c57(%rip), %xmm1     # 0xe4e0
mulsd %xmm0, %xmm1
movsd 0xd90b(%rip), %xmm2     # 0x131a0
leaq -0xe0(%rip), %rdi       # 0x57bc
movq %rsp, %rsi
movapd %xmm3, %xmm0
callq 0xa808
andpd 0x8c10(%rip), %xmm0     # 0xe4c0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/First_Peak.cpp
// Function: FEE_x(double, double const*)
double FEE_x(double E, const double *p)
{
	int alpha = p[0];
	int beta = p[1];
	double Yrho = p[2];
	double delta = p[3];
	bool max = p[4] > 0;

	return First_Extremum_Exact(alpha, beta, E, Yrho, delta, max) / E;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
cvttsd2si (%rdi), %eax
cvttsd2si 0x8(%rdi), %esi
movsd 0x10(%rdi), %xmm1
movsd 0x18(%rdi), %xmm2
movsd 0x20(%rdi), %xmm4
xorpd %xmm3, %xmm3
xorl %edx, %edx
ucomisd %xmm3, %xmm4
seta %dl
movl %eax, %edi
callq 0x580d
divsd (%rsp), %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
xorps %xmm2, %xmm2
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 -0xb0(%rip), %rdi       # 0x58b5
leaq -0x7e(%rip), %rsi       # 0x58ee
movsd 0x8b7c(%rip), %xmm0     # 0xe4f0
movsd 0x8b7c(%rip), %xmm1     # 0xe4f8
movl $0x64, %edx
callq 0x9ebc
addq $0x38, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x68, %rsp
cmpl $0x3, %edi
jae 0x5aca
movl %esi, %r14d
cmpl $0x3, %esi
jae 0x5ae9
movl %edx, %r15d
cmpl $0x3, %edx
jae 0x5b08
movl %ecx, %r12d
cmpl $0x3, %ecx
jae 0x5b27
movl %r8d, %ebp
cmpl $0x3, %r8d
jae 0x5b46
movl %r9d, 0x8(%rsp)
cmpl $0x3, %r9d
jae 0x5b65
movl %edi, %r13d
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3275
movl %r13d, %r13d
movl %r15d, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa1d2
movq %rax, %r15
movl %r14d, %r14d
movl %r12d, %edx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xa1d2
movq %rax, %r12
movl %ebp, %edx
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0xa1d2
movups (%r12), %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq %rax, %rsi
callq 0x3968
leaq 0x10(%rsp), %rdi
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
xorps 0x85ca(%rip), %xmm1     # 0xe020
leaq 0x58(%rsp), %rsi
movsd %xmm0, (%rsi)
movlps %xmm1, 0x8(%rsi)
movups (%r15), %xmm0
movaps %xmm0, (%rdi)
callq 0x3968
movaps 0x10(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movl 0x8(%rsp), %edx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xa1d2
leaq 0x10(%rsp), %rdi
movaps 0x40(%rsp), %xmm0
movaps %xmm0, (%rdi)
movq %rax, %rsi
callq 0x3968
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xa1c4
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x86ae(%rip), %rdi      # 0xe17f
leaq 0x8a48(%rip), %rsi      # 0xe520
leaq 0x8a4c(%rip), %rcx      # 0xe52b
movl $0x13, %edx
callq 0x20f0
leaq 0x86f4(%rip), %rdi      # 0xe1e4
leaq 0x8a29(%rip), %rsi      # 0xe520
leaq 0x8a2d(%rip), %rcx      # 0xe52b
movl $0x14, %edx
callq 0x20f0
leaq 0x8a5b(%rip), %rdi      # 0xe56a
leaq 0x8a0a(%rip), %rsi      # 0xe520
leaq 0x8a0e(%rip), %rcx      # 0xe52b
movl $0x15, %edx
callq 0x20f0
leaq 0x8a4d(%rip), %rdi      # 0xe57b
leaq 0x89eb(%rip), %rsi      # 0xe520
leaq 0x89ef(%rip), %rcx      # 0xe52b
movl $0x16, %edx
callq 0x20f0
leaq 0x8a3f(%rip), %rdi      # 0xe58c
leaq 0x89cc(%rip), %rsi      # 0xe520
leaq 0x89d0(%rip), %rcx      # 0xe52b
movl $0x17, %edx
callq 0x20f0
leaq 0x8a31(%rip), %rdi      # 0xe59d
leaq 0x89ad(%rip), %rsi      # 0xe520
leaq 0x89b1(%rip), %rcx      # 0xe52b
movl $0x18, %edx
callq 0x20f0
jmp 0x5b86
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa1c4
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x20(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movl %edi, %ebp
callq 0x29c5
callq 0x2070
movaps %xmm0, 0x50(%rsp)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x3275
cmpl %ebx, %ebp
je 0x5d08
xorpd %xmm0, %xmm0
jmp 0x5d10
movsd 0x8308(%rip), %xmm0     # 0xe018
movsd %xmm0, 0x8(%rsp)
movslq %ebp, %r14
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa1d2
movq %rax, %r15
movslq %ebx, %rbx
leaq 0x38(%rsp), %rdi
movl $0x2, %edx
movq %rbx, %rsi
callq 0xa1d2
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
xorps 0x82d2(%rip), %xmm1     # 0xe020
leaq 0x98(%rsp), %rsi
movsd %xmm0, (%rsi)
movlps %xmm1, 0x8(%rsi)
movupd (%r15), %xmm0
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
callq 0x3968
movapd 0x10(%rsp), %xmm0
movapd %xmm0, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x2, %edx
movq %r14, %rsi
callq 0xa1d2
movq %rax, %r15
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa1d2
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
xorps 0x826f(%rip), %xmm1     # 0xe020
leaq 0x88(%rsp), %rsi
movsd %xmm0, (%rsi)
movlps %xmm1, 0x8(%rsi)
movupd (%r15), %xmm0
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
callq 0x3968
movapd 0x20(%rsp), %xmm0
addpd 0x10(%rsp), %xmm0
movapd %xmm0, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x2, %edx
movq %r14, %rsi
callq 0xa1d2
movupd (%rax), %xmm0
movapd %xmm0, 0x60(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x2, %edx
movq %rbx, %rsi
callq 0xa1d2
movapd 0x60(%rsp), %xmm0
mulpd 0x86de(%rip), %xmm0     # 0xe500
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
movq %rax, %rsi
callq 0x3968
leaq 0x10(%rsp), %rdi
movsd (%rdi), %xmm0
subsd 0x8(%rsp), %xmm0
movsd 0x8(%rdi), %xmm1
leaq 0x78(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm1, 0x8(%rsi)
movapd 0x20(%rsp), %xmm0
movapd %xmm0, (%rdi)
callq 0x3968
movapd 0x50(%rsp), %xmm0
xorpd 0x81ae(%rip), %xmm0     # 0xe020
mulsd 0x10(%rsp), %xmm0
movapd %xmm0, 0x50(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xa1c4
movaps 0x50(%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ea3
jmp 0x5ea3
jmp 0x5ea3
jmp 0x5ea3
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xa1c4
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x98, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, (%rsp)
movl %esi, %ebx
movl %edi, %ebp
callq 0x29c5
callq 0x22c0
movsd %xmm0, 0x8(%rsp)
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x3275
cmpl %ebx, %ebp
je 0x5f06
xorpd %xmm0, %xmm0
jmp 0x5f0e
movsd 0x810a(%rip), %xmm0     # 0xe018
movsd %xmm0, (%rsp)
movslq %ebp, %r14
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xa1d2
movq %rax, %r15
movslq %ebx, %rbx
leaq 0x38(%rsp), %rdi
movl $0x2, %edx
movq %rbx, %rsi
callq 0xa1d2
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
xorps 0x80d2(%rip), %xmm1     # 0xe020
leaq 0x88(%rsp), %rsi
movsd %xmm0, (%rsi)
movlps %xmm1, 0x8(%rsi)
movupd (%r15), %xmm0
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
callq 0x3968
movapd 0x10(%rsp), %xmm0
movapd %xmm0, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x2, %edx
movq %r14, %rsi
callq 0xa1d2
movq %rax, %r15
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
movq %rbx, %rsi
callq 0xa1d2
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
xorps 0x806c(%rip), %xmm1     # 0xe020
leaq 0x78(%rsp), %rsi
movsd %xmm0, (%rsi)
movlps %xmm1, 0x8(%rsi)
movupd (%r15), %xmm0
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
callq 0x3968
movapd 0x20(%rsp), %xmm0
addpd 0x10(%rsp), %xmm0
movapd %xmm0, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x2, %edx
movq %r14, %rsi
callq 0xa1d2
movupd (%rax), %xmm0
movapd %xmm0, 0x50(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x2, %edx
movq %rbx, %rsi
callq 0xa1d2
movapd 0x50(%rsp), %xmm0
mulpd 0x84de(%rip), %xmm0     # 0xe500
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
movq %rax, %rsi
callq 0x3968
leaq 0x10(%rsp), %rdi
movsd (%rdi), %xmm0
subsd (%rsp), %xmm0
movsd 0x8(%rdi), %xmm1
leaq 0x68(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm1, 0x8(%rsi)
movapd 0x20(%rsp), %xmm0
movapd %xmm0, (%rdi)
callq 0x3968
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xa1c4
movsd 0x8(%rsp), %xmm0
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x609b
jmp 0x609b
jmp 0x609b
jmp 0x609b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xa1c4
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61a6
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movl $0x1, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x598c
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x39d8
leaq 0xd087(%rip), %rax      # 0x13188
mulsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5b9b
movaps %xmm0, 0x40(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5c30
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2a9f
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2b3e
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
xorps %xmm0, %xmm0
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 0x8401(%rip), %rdi      # 0xe5ae
leaq 0x836c(%rip), %rsi      # 0xe520
leaq 0x840c(%rip), %rcx      # 0xe5c7
movl $0x3d, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62dd
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movl $0x2, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x598c
movsd %xmm0, 0x38(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x39d8
leaq 0xcf72(%rip), %rax      # 0x13188
mulsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5b9b
movsd %xmm0, 0x28(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5c30
movaps %xmm0, 0x50(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5cb9
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2a9f
movaps %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2b3e
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
xorps %xmm0, %xmm0
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 0x82ca(%rip), %rdi      # 0xe5ae
leaq 0x8235(%rip), %rsi      # 0xe520
leaq 0x8303(%rip), %rcx      # 0xe5f5
movl $0x4a, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6416
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movl $0x2, %edx
movl $0x2, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x598c
movsd %xmm0, 0x38(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x39d8
leaq 0xce35(%rip), %rax      # 0x13188
mulsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5b9b
movaps %xmm0, 0x50(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5c30
movsd %xmm0, 0x28(%rsp)
movl %r14d, %edi
movl %ebp, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5eb8
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2a9f
movaps %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x2b3e
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
xorps %xmm0, %xmm0
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 0x8191(%rip), %rdi      # 0xe5ae
leaq 0x80fc(%rip), %rsi      # 0xe520
leaq 0x81f8(%rip), %rcx      # 0xe623
movl $0x58, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc664(%rip), %rbx      # 0x13188
movsd (%rbx), %xmm2
movapd %xmm2, %xmm3
leaq 0x7775(%rip), %rax      # 0xe2a8
movsd (%rax), %xmm0
mulsd 0x79d1(%rip), %xmm0     # 0xe510
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm2
leaq 0xc64a(%rip), %rax      # 0x1319c
cvtsi2sdl (%rax), %xmm4
subsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x6b72
sqrtsd %xmm0, %xmm0
jmp 0x6b8d
movsd %xmm2, 0x8(%rsp)
movsd %xmm4, (%rsp)
callq 0x2120
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm2
mulsd %xmm4, %xmm0
leaq 0xc5f8(%rip), %rax      # 0x13190
movsd (%rax), %xmm1
mulsd (%rbx), %xmm1
addsd %xmm0, %xmm2
leaq 0x76ed(%rip), %rax      # 0xe298
mulsd (%rax), %xmm1
mulsd 0x7451(%rip), %xmm2     # 0xe008
addsd %xmm1, %xmm2
movapd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movapd %xmm0, %xmm3
leaq 0x7138(%rip), %rax      # 0xe328
mulsd (%rax), %xmm1
leaq 0xbf8d(%rip), %rbx      # 0x13188
movsd (%rbx), %xmm4
leaq 0xbf96(%rip), %r15      # 0x1319c
movl (%r15), %ebp
movapd %xmm4, %xmm2
subsd %xmm0, %xmm2
leaq 0x7090(%rip), %rax      # 0xe2a8
movsd (%rax), %xmm8
mulsd 0x72ea(%rip), %xmm8     # 0xe510
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm8
movapd %xmm8, %xmm0
movapd %xmm4, 0x60(%rsp)
mulsd %xmm4, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm3, 0x10(%rsp)
jb 0x7258
sqrtsd %xmm0, %xmm5
jmp 0x7285
movsd %xmm1, 0x8(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0x2120
xorpd %xmm2, %xmm2
movsd 0x20(%rsp), %xmm8
movapd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm5
mulsd 0x70ab(%rip), %xmm1     # 0xe338
movsd %xmm1, 0x8(%rsp)
leaq 0xbef6(%rip), %r14      # 0x13190
movsd (%r14), %xmm7
movsd (%rbx), %xmm6
leaq 0x6fee(%rip), %rax      # 0xe298
movsd (%rax), %xmm4
movl (%r15), %r15d
movapd %xmm6, %xmm0
subsd %xmm3, %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm6, %xmm8
addsd %xmm0, %xmm8
ucomisd %xmm2, %xmm8
jb 0x72d8
xorps %xmm0, %xmm0
sqrtsd %xmm8, %xmm0
jmp 0x7318
movapd %xmm8, %xmm0
movapd %xmm4, 0x20(%rsp)
movapd %xmm5, 0x50(%rsp)
movapd %xmm6, 0x40(%rsp)
movapd %xmm7, 0x30(%rsp)
callq 0x2120
movapd 0x30(%rsp), %xmm7
movapd 0x40(%rsp), %xmm6
movapd 0x50(%rsp), %xmm5
movapd 0x20(%rsp), %xmm4
movapd 0x10(%rsp), %xmm3
unpcklpd %xmm0, %xmm5            # xmm5 = xmm5[0],xmm0[0]
movapd 0x60(%rsp), %xmm2
unpcklpd %xmm6, %xmm2            # xmm2 = xmm2[0],xmm6[0]
movd %r15d, %xmm0
movd %ebp, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd %xmm3, %xmm0
unpcklpd %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
cvtdq2pd %xmm1, %xmm1
addpd %xmm2, %xmm0
mulpd %xmm5, %xmm1
movhpd (%r14), %xmm7           # xmm7 = xmm7[0],mem[0]
movhpd (%rbx), %xmm6           # xmm6 = xmm6[0],mem[0]
mulpd %xmm7, %xmm6
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm6, %xmm4
movapd %xmm0, %xmm2
addpd %xmm1, %xmm2
subpd %xmm1, %xmm0
movsd %xmm2, %xmm0            # xmm0 = xmm2[0],xmm0[1]
mulpd 0x734c(%rip), %xmm0     # 0xe6c0
addpd %xmm4, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
subsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd %xmm3, %xmm0
callq 0x6c76
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2070
mulsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x6c58(%rip), %xmm1     # 0xe018
subsd %xmm0, %xmm1
leaq 0x78(%rsp), %rbx
movsd %xmm1, (%rbx)
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcf56
movsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xcaf4
movsd 0x8(%rsp), %xmm0
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7afc
movl %esi, %ebp
movq %rdi, %rbx
movl $0x3, %esi
movl $0x3, %edx
callq 0xa076
movsd 0x8(%rsp), %xmm0
callq 0x6e4a
leaq 0x69b9(%rip), %rax      # 0xe318
movsd (%rax), %xmm1
movsd %xmm1, 0x10(%rsp)
subsd %xmm1, %xmm0
callq 0x22c0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6e4a
subsd 0x10(%rsp), %xmm0
callq 0x2070
testb $0x1, %bpl
je 0x7ac6
movsd %xmm0, 0x10(%rsp)
leaq 0xb7eb(%rip), %rax      # 0x13190
movsd (%rax), %xmm0
leaq 0x6940(%rip), %rax      # 0xe2f0
mulsd (%rax), %xmm0
leaq 0x691d(%rip), %rax      # 0xe2d8
mulsd (%rax), %xmm0
leaq 0xb7c2(%rip), %rax      # 0x13188
mulsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6ea7
movsd %xmm0, 0x20(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa1d2
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 0x6ea7
movsd %xmm0, 0x20(%rsp)
movl $0x1, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa1d2
movsd 0x18(%rsp), %xmm1
divsd 0x20(%rsp), %xmm1
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x710c
movsd %xmm0, 0x18(%rsp)
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa1d2
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 0x710c
movsd %xmm0, 0x8(%rsp)
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa1d2
movsd 0x10(%rsp), %xmm1
divsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0xa1d2
movsd (%rax), %xmm0
addsd 0x6535(%rip), %xmm0     # 0xe018
movsd %xmm0, (%rax)
incq %r14
cmpq $0x3, %r14
jne 0x7ac9
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6aab(%rip), %rdi      # 0xe5ae
leaq 0x6bc6(%rip), %rsi      # 0xe6d0
leaq 0x6bcb(%rip), %rcx      # 0xe6dc
movl $0x5e, %edx
callq 0x20f0
jmp 0x7b1d
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1c4
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
cmpl $0x3, %edi
jae 0x7d6c
movl %esi, %ebx
cmpl $0x3, %esi
jae 0x7d8b
movl %edx, %ebp
cmpl $0x3, %edx
jae 0x7daa
cmpl $0x2, %ecx
jae 0x7dc9
movl %edi, %r14d
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ecx, %esi
callq 0x7bc1
movl %r14d, %esi
movl %ebp, %r14d
movq %r15, %rdi
movq %r14, %rdx
callq 0xa1d2
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movl %ebx, %esi
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0xa1d2
movaps 0x10(%rsp), %xmm1
xorps 0x6308(%rip), %xmm1     # 0xe020
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rdi)
movlps %xmm1, 0x8(%rdi)
movq %rax, %rsi
callq 0x3968
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xa1c4
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x640c(%rip), %rdi      # 0xe17f
leaq 0x6956(%rip), %rsi      # 0xe6d0
leaq 0x69c5(%rip), %rcx      # 0xe746
movl $0x81, %edx
callq 0x20f0
leaq 0x6452(%rip), %rdi      # 0xe1e4
leaq 0x6937(%rip), %rsi      # 0xe6d0
leaq 0x69a6(%rip), %rcx      # 0xe746
movl $0x82, %edx
callq 0x20f0
leaq 0x644a(%rip), %rdi      # 0xe1fb
leaq 0x6918(%rip), %rsi      # 0xe6d0
leaq 0x6987(%rip), %rcx      # 0xe746
movl $0x83, %edx
callq 0x20f0
leaq 0x67de(%rip), %rdi      # 0xe5ae
leaq 0x68f9(%rip), %rsi      # 0xe6d0
leaq 0x6968(%rip), %rcx      # 0xe746
movl $0x84, %edx
callq 0x20f0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa1c4
movq %rbx, %rdi
callq 0x22a0