LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tonymugen[P]sampleSNPs/random.cpp
// Function: sampFiles::RanDraw::vitterA(double const&, double const&)
volatile uint64_t RanDraw::vitterA(const double &n, const double &N){
	// The notation follows Vitter's (1987) as closely as possible
	// Note that my runif() is on [0,1] (Vitter assumes (0,1)), so I have to sometimes adjust accordingly
	uint64_t S  = 0;
	double top  = N - n;
	double quot = top/N;
	double v;
	
	// some trivial conditions first
	if ( (n == 0) || (n > N) ) {
		return S;
	} else if (n == 1) {
		do {
			S = static_cast<uint64_t>(floor(N * this->runif()));
			
		} while (S == static_cast<uint64_t>(N)); // s == N would be a problem because it would overshoot the end of the array/file (in base-0 space); effectively sampling [0,1) uniform to prevent this
		return S;
	}
	// [0,1) uniform
	do {
		v = this->runif();
	} while (v == 1.0); // i.e. only repeat if v == 1.0
	
	double Nloc = N;
	while (quot > v) {
		S++;
		top--;
		Nloc--;
		quot = quot*top/Nloc;
	}
	
	return S;
}

// Assembly:
movsd (%rsi), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17662
jnp 0x177c2
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movsd (%rdx), %xmm1
ucomisd %xmm1, %xmm0
ja 0x177bb
movq %rdi, %r14
ucomisd 0xe5b(%rip), %xmm0      # 0x184e0
jne 0x17728
jp 0x17728
movsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %xmm1
punpckldq 0xdef(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xdf7(%rip), %xmm1      # 0x184b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x1a5b(%rip), %xmm0     # 0x19128
mulsd 0x8(%rsp), %xmm0
callq 0x4490
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x1a4c(%rip), %xmm1     # 0x19138
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
movsd (%rbx), %xmm0
cvttsd2si %xmm0, %rcx
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
movq %rcx, %rsi
sarq $0x3f, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
cmpq %rsi, %rax
je 0x17691
jmp 0x177bb
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %xmm1
punpckldq 0xd4a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xd52(%rip), %xmm1      # 0x184b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x19b6(%rip), %xmm0     # 0x19128
ucomisd 0xd66(%rip), %xmm0      # 0x184e0
jne 0x1777e
jnp 0x17740
movsd 0x8(%rsp), %xmm4
ucomisd %xmm0, %xmm4
jbe 0x177b9
movsd (%rbx), %xmm1
xorl %eax, %eax
movsd 0x1998(%rip), %xmm2     # 0x19130
movsd 0x10(%rsp), %xmm3
incq %rax
addsd %xmm2, %xmm3
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm4
divsd %xmm1, %xmm4
ucomisd %xmm0, %xmm4
ja 0x1779e
jmp 0x177bb
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DMLfor[P]TinyWebServer/./ServerHttps.hpp
// Function: WebServer::Server<boost::asio::ssl::stream<boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::execution::any_executor<boost::asio::execution::context_as_t<boost::asio::execution_context&>, boost::asio::execution::detail::blocking::never_t<0>, boost::asio::execution::prefer_only<boost::asio::execution::detail::blocking::possibly_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::tracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::untracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::fork_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::continuation_t<0>>>>>>::accept()
void accept()
		{
			auto socket = std::make_shared<HTTPS>(m_io_service, context);

			acceptor.async_accept(
					(*socket).lowest_layer(),
					[this, socket](const boost::system::error_code &ec)
					{
						accept();
			
						if(!ec)
						{
							(*socket).async_handshake(boost::asio::ssl::stream_base::server,
								[this, socket](const boost::system::error_code &ec)
								{
									if(!ec) process_request_and_respond(socket);
								});
						}
					});
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x68(%rdi), %rcx
leaq 0x120(%rdi), %r8
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x18(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x12fa4
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq %rbx, (%r15)
movq %rdx, 0x8(%r15)
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0xcd2d
movq 0x3d291(%rip), %rcx     # 0x49fb0
cmpb $0x0, (%rcx)
je 0xcd29
incl 0x8(%rax)
jmp 0xcd2d
lock
incl 0x8(%rax)
movq 0x98(%rbx), %rdi
leaq 0xa0(%rbx), %rsi
addq $0xb8, %rbx
leaq 0x18(%rsp), %r8
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x1562c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xcd60
callq 0x1d2a8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcd6f
callq 0x1d2a8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xcd8b
callq 0x1d2a8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcd9a
callq 0x1d2a8
movq %rbx, %rdi
callq 0xaa80
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computecpG(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double computecpG(vector<double> const& hGexp, vector<double> const& ThGexp)
{
    // Purpose : compute heat capacity at constant pressure of vapor phase with LSM
    // More : the exp. data hG(T) is used
    // See eq. (50)
    double mHg, mThg, num(0.), den(0.);
    mHg = meanValue(hGexp);
    mThg = meanValue(ThGexp);
    for (unsigned int i = 0; i < hGexp.size(); i++) {
        num += ThGexp[i]*(hGexp[i]-mHg);
        den += ThGexp[i]*(ThGexp[i]-mThg);
    }
    return num/den;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x52cb
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x52cb
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
je 0x2771
sarq $0x3, %rcx
movq (%rbx), %rdx
xorpd %xmm2, %xmm2
xorl %esi, %esi
xorpd %xmm1, %xmm1
movsd (%rsp), %xmm5
movsd (%rdx,%rsi,8), %xmm3
movsd (%rax,%rsi,8), %xmm4
subsd %xmm5, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm1
movapd %xmm3, %xmm4
subsd %xmm0, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm2
incq %rsi
movl %esi, %edi
cmpq %rdi, %rcx
ja 0x273b
divsd %xmm2, %xmm1
jmp 0x2779
movsd 0x388f(%rip), %xmm1     # 0x6008
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeQg(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double)
double computeQg(vector<double> const& hGexp, vector<double> const& ThGexp, double cpG)
{
    // Purpose : compute formation energy of vapor phase 
    // See eq. (51)
    double mHg, mThg;
    mHg = meanValue(hGexp);
    mThg = meanValue(ThGexp);
    return (mHg-cpG*mThg);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
callq 0x52cb
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x52cb
mulsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computecvG(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double)
double computecvG(vector<double> const& vGexp, vector<double> const& Texp, vector<double> const& psatExp, double cpG)
{
    // Purpose : commpute heat capacity at constant volum of vapor phase with LSM
    // More : vGexp, Texp and psatExp are concording experimental points
    // See eq. (55)
    double num(0.), den(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        num += vGexp[i]*(Texp[i]/psatExp[i]);
        den += (Texp[i]/psatExp[i])*(Texp[i]/psatExp[i]);
    }
    return (cpG - num/den);
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x280e
sarq $0x3, %rcx
movq (%rdi), %rsi
movq (%rdx), %rdx
xorpd %xmm2, %xmm2
xorl %edi, %edi
xorpd %xmm1, %xmm1
movsd (%rax,%rdi,8), %xmm3
divsd (%rdx,%rdi,8), %xmm3
movsd (%rsi,%rdi,8), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm2
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x27de
divsd %xmm2, %xmm1
jmp 0x2816
movsd 0x37f2(%rip), %xmm1     # 0x6008
subsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeQprimG(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, double, double, double, double, double, double, double, double)
double computeQprimG(vector<double> p, vector<double> T, double cpL, double cpG, double cvL, double cvG, double qL, double qG, double pinfL, double bL)
{
    // Purpose : compute the vapor entropy constant qPrimG with LSM
    // See equation (72) 
    double A,B,C,D,E,sum(0.);
    B = (qL-qG)/(cpG-cvG);
    C = (cpG-cpL)/(cpG-cvG);
    D = (cpL-cvL)/(cpG-cvG);
    E = bL/(cpG-cvG);
    for (unsigned int i = 0; i < p.size(); i++) {
        sum += log(p[i])-(B+E*p[i])/T[i] - C*log(T[i]) - D*log(p[i]+pinfL);
    }
    A = sum/p.size();
    return (A*(cpG-cvG)+cpG-cpL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm7, (%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movapd %xmm1, %xmm7
subsd %xmm3, %xmm7
subq %rax, %rcx
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
je 0x2957
movq %rsi, %rbx
movq %rdi, %r14
subsd %xmm5, %xmm4
divsd %xmm7, %xmm4
movsd %xmm4, 0x30(%rsp)
movsd (%rsp), %xmm3
divsd %xmm7, %xmm3
movsd %xmm3, (%rsp)
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
subsd %xmm0, %xmm1
movapd 0x37c6(%rip), %xmm0     # 0x6050
xorpd %xmm0, %xmm1
divsd %xmm7, %xmm1
movapd %xmm1, 0x40(%rsp)
xorpd %xmm0, %xmm3
divsd %xmm7, %xmm3
movapd %xmm3, 0x50(%rsp)
xorpd %xmm2, %xmm2
movl $0x1, %ebp
xorl %r15d, %r15d
movsd %xmm6, 0x28(%rsp)
movsd %xmm2, 0x38(%rsp)
movsd (%rax,%r15,8), %xmm0
callq 0x20f0
movapd %xmm0, %xmm2
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm1
mulsd (%rsp), %xmm1
addsd 0x30(%rsp), %xmm1
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
divsd %xmm0, %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
callq 0x20f0
mulsd 0x40(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm0
addsd 0x28(%rsp), %xmm0
callq 0x20f0
movsd 0x38(%rsp), %xmm2
mulsd 0x50(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addsd %xmm0, %xmm2
movl %ebp, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r15, %rcx
ja 0x28b8
jmp 0x295f
sarq $0x3, %rcx
xorpd %xmm2, %xmm2
movq %rcx, %xmm0
punpckldq 0x36f4(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x36fc(%rip), %xmm0     # 0x6070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm2
mulsd 0x10(%rsp), %xmm2
addsd 0x18(%rsp), %xmm2
subsd 0x20(%rsp), %xmm2
movapd %xmm2, %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeMeanTp(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double)
double computeMeanTp(vector<double> const& psatExp, vector<double> const& Texp, double pinfL)
{
    // Purpose : compute the mean value seen in (64) and (65)
    double mtp(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        mtp += Texp[i]/(psatExp[i]+pinfL);  
    }
    mtp /= Texp.size(); 
    return mtp;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rcx, %rdx
je 0x29ef
movapd %xmm0, %xmm1
movq (%rdi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm2
movsd (%rdx,%rsi,8), %xmm3
addsd %xmm1, %xmm3
divsd %xmm3, %xmm2
addsd %xmm2, %xmm0
incq %rsi
movl %esi, %edi
cmpq %rdi, %rax
ja 0x29cd
jmp 0x29f3
xorpd %xmm0, %xmm0
movq %rax, %xmm1
punpckldq 0x3660(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3668(%rip), %xmm1     # 0x6070
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeMeanTp2(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double)
double computeMeanTp2(vector<double> const& psatExp, vector<double> const& Texp, double pinfL)
{
    // Purpose : compute a variation of the mean value seen in (64) and (65)
    double mtp(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        mtp += Texp[i]/((psatExp[i]+pinfL)*(psatExp[i]+pinfL));  
    }
    mtp /= Texp.size(); 
    return mtp;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rcx, %rdx
je 0x2a62
movapd %xmm0, %xmm1
movq (%rdi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm2
movsd (%rdx,%rsi,8), %xmm3
addsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
divsd %xmm3, %xmm2
addsd %xmm2, %xmm0
incq %rsi
movl %esi, %edi
cmpq %rdi, %rax
ja 0x2a3c
jmp 0x2a66
xorpd %xmm0, %xmm0
movq %rax, %xmm1
punpckldq 0x35ed(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x35f5(%rip), %xmm1     # 0x6070
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeHeatCapDiffL(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double, double, double)
double computeHeatCapDiffL(vector<double> const& psatExp, vector<double> const& Texp, vector<double> const& vLexp, double mvL, double mTp, double pinfL)
{
    // Purpose : compute heat capacity cpL - cvL of liquid phase for pinfL iterative process with LSM 
    // More : this fn is also used to solve eq. (68) with Newton-Raphson 
    // Details : input values m'x' are the mean of the corresponding vector 'x'
    // See eq. (64)  
    double num(0.), den(0.), bf(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        bf = Texp[i]/(psatExp[i]+pinfL);
        num += bf*(vLexp[i]-mvL);
        den += bf*(bf-mTp);
    }
    return num/den;
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x2af0
sarq $0x3, %rcx
movq (%rdi), %rsi
movq (%rdx), %rdx
xorpd %xmm4, %xmm4
xorl %edi, %edi
xorpd %xmm3, %xmm3
movsd (%rax,%rdi,8), %xmm5
movsd (%rsi,%rdi,8), %xmm6
addsd %xmm2, %xmm6
divsd %xmm6, %xmm5
movsd (%rdx,%rdi,8), %xmm6
subsd %xmm0, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm6, %xmm3
movapd %xmm5, %xmm6
subsd %xmm1, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm6, %xmm4
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x2aac
divsd %xmm4, %xmm3
jmp 0x2af8
movsd 0x3510(%rip), %xmm3     # 0x6008
movapd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeDHeatCapDiffL(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double, double, double, double)
double computeDHeatCapDiffL(vector<double> const& psatExp, vector<double> const& Texp, vector<double> const& vLexp, double mvL, double mTp, double mTp2, double pinfL)
{
    // Purpose : compute pinfL derivative of fn computeHeatCapDiffL() for computePinfL Newton-Raphson process
    double m1(0.), m2(0.), m3(0.), m4(0.), bf1(0.), bf2(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        bf1 = Texp[i]/(psatExp[i]+pinfL);
        bf2 = bf1/(psatExp[i]+pinfL);
        m1 += -bf2*(vLexp[i]*mvL);
        m2 += bf1*(bf1 - (1./Texp.size())*mTp);
        m3 += bf1*(vLexp[i]-mvL);
        m4 += -bf2*(bf1-mTp)+bf1*(bf2+mTp2);
    }
    return (m1*m2-m3*m4)/(m2*m2);
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x2bee
sarq $0x3, %rcx
movq (%rdi), %rsi
movq %rcx, %xmm4
punpckldq 0x353f(%rip), %xmm4 # xmm4 = xmm4[0],mem[0],xmm4[1],mem[1]
subpd 0x3547(%rip), %xmm4     # 0x6070
movq (%rdx), %rdx
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
movsd 0x34cf(%rip), %xmm8     # 0x6010
divsd %xmm5, %xmm8
xorpd %xmm6, %xmm6
xorl %edi, %edi
mulsd %xmm1, %xmm8
xorpd %xmm7, %xmm7
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
movsd (%rax,%rdi,8), %xmm9
movsd (%rsi,%rdi,8), %xmm11
addsd %xmm3, %xmm11
divsd %xmm11, %xmm9
movapd %xmm9, %xmm10
divsd %xmm11, %xmm10
movsd (%rdx,%rdi,8), %xmm12
movapd %xmm12, %xmm11
mulsd %xmm0, %xmm11
movapd %xmm8, %xmm13
addsd %xmm9, %xmm13
subsd %xmm0, %xmm12
mulsd %xmm9, %xmm13
mulsd %xmm9, %xmm12
addsd %xmm12, %xmm7
movapd %xmm10, %xmm12
addsd %xmm13, %xmm5
addsd %xmm2, %xmm12
mulsd %xmm9, %xmm12
mulsd %xmm10, %xmm11
subsd %xmm1, %xmm9
mulsd %xmm10, %xmm9
subsd %xmm9, %xmm12
subsd %xmm11, %xmm4
addsd %xmm12, %xmm6
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x2b5d
jmp 0x2bfe
xorpd %xmm4, %xmm4
xorpd %xmm5, %xmm5
xorpd %xmm7, %xmm7
xorpd %xmm6, %xmm6
mulsd %xmm6, %xmm7
mulsd %xmm5, %xmm4
subsd %xmm7, %xmm4
mulsd %xmm5, %xmm5
divsd %xmm5, %xmm4
movapd %xmm4, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeCpL(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double, double, double, double)
double computeCpL(vector<double> const& Texp, vector<double> const& hLexp, vector<double> const& psatExp, double mhL, double mp, double mT, double bL)
{
    // Purpose : compute heat cap. liquid phase at p = cst with LSM
    // More : this fn is used to solve eq. (68) with Newton-Raphson 
    // Details : input values m'x' are the mean of the corresponding vector 'x'
    // See eq. (60)
    double num1(0.), num2(0.), num(0.), den(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        num1 += Texp[i]*(hLexp[i]-mhL);
        num2 += Texp[i]*(psatExp[i]-mp);
        den += Texp[i]*(Texp[i]-mT);
    }
    num = num1 - bL*num2; 
    return num/den;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x2ca5
sarq $0x3, %rcx
movq (%rsi), %rsi
movq (%rdx), %rdx
xorpd %xmm5, %xmm5
xorl %edi, %edi
xorpd %xmm6, %xmm6
xorpd %xmm4, %xmm4
movsd (%rax,%rdi,8), %xmm7
movsd (%rsi,%rdi,8), %xmm8
subsd %xmm0, %xmm8
mulsd %xmm7, %xmm8
addsd %xmm8, %xmm4
movsd (%rdx,%rdi,8), %xmm8
subsd %xmm1, %xmm8
mulsd %xmm7, %xmm8
addsd %xmm8, %xmm6
movapd %xmm7, %xmm8
subsd %xmm2, %xmm8
mulsd %xmm7, %xmm8
addsd %xmm8, %xmm5
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x2c55
jmp 0x2cb1
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
xorpd %xmm5, %xmm5
mulsd %xmm6, %xmm3
subsd %xmm3, %xmm4
divsd %xmm5, %xmm4
movapd %xmm4, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeDcpL(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double, double, double)
double computeDcpL(vector<double> const& Texp, vector<double> const& psatExp, double mp, double mT, double dbL)
{
    // Purpose : compute pinfL derivative fn of computeCpL() for computePinfL Newton-Raphson process
    double s1(0.), s2(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        s1 += Texp[i]*(psatExp[i]-mp);
        s2 += Texp[i]*(Texp[i]-mT);
    }
    return -dbL*(s1/s2);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x2d15
sarq $0x3, %rcx
movq (%rsi), %rdx
xorpd %xmm4, %xmm4
xorl %esi, %esi
xorpd %xmm3, %xmm3
movsd (%rax,%rsi,8), %xmm5
movsd (%rdx,%rsi,8), %xmm6
subsd %xmm0, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm6, %xmm3
movapd %xmm5, %xmm6
subsd %xmm1, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm6, %xmm4
incq %rsi
movl %esi, %edi
cmpq %rdi, %rcx
ja 0x2cdf
divsd %xmm4, %xmm3
jmp 0x2d1d
movsd 0x32eb(%rip), %xmm3     # 0x6008
xorpd 0x332b(%rip), %xmm2     # 0x6050
mulsd %xmm3, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: coeffPsatTh(double, double, double, double, double, double, double, double, double, double, double&, double&, double&, double&, double&)
void coeffPsatTh(double cpG, double cpL, double cvG, double cvL, double qG, double qL, double qPrimG, double qPrimL, double bG, double bL, double &A, double &B, double &C, double &D, double &E)
{
    // Purpose : compute coeff. of theoric saturation curve Psat(T)
    // See eq. (41)
    A = (cpL-cpG+qPrimG-qPrimL)/(cpG-cvG);
    B = (qL-qG)/(cpG-cvG);
    C = (cpG-cpL)/(cpG-cvG);
    D = (cpL-cvL)/(cpG-cvG);
    E = (bL-bG)/(cpG-cvG);
}

// Assembly:
movsd 0x10(%rsp), %xmm8
movapd %xmm1, %xmm9
subsd %xmm0, %xmm9
addsd %xmm6, %xmm9
subsd %xmm7, %xmm9
movapd %xmm0, %xmm6
subsd %xmm2, %xmm6
divsd %xmm6, %xmm9
movsd %xmm9, (%rdi)
subsd %xmm4, %xmm5
divsd %xmm6, %xmm5
movsd %xmm5, (%rsi)
subsd %xmm1, %xmm0
divsd %xmm6, %xmm0
movsd %xmm0, (%rdx)
subsd %xmm3, %xmm1
divsd %xmm6, %xmm1
movsd %xmm1, (%rcx)
subsd 0x8(%rsp), %xmm8
divsd %xmm6, %xmm8
movsd %xmm8, (%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: writePlotFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
void writePlotFile(string file, vector<double> &x, vector<double> &y)
{
    // Purpose : write file with two columns 
    ofstream strm(file.c_str());
    for (unsigned int i = 0; i < x.size(); i++) {
        strm << x[i] << " " << y[i] << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rsi
leaq 0x8(%rsp), %rdi
movl $0x10, %edx
callq 0x2170
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x5221
movl $0x1, %ebp
xorl %r15d, %r15d
leaq 0x1265(%rip), %r12      # 0x6410
movsd (%rax,%r15,8), %xmm0
leaq 0x8(%rsp), %rdi
callq 0x21d0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r13, %rdi
callq 0x21d0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movl %ebp, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r15, %rcx
ja 0x51ab
movq 0x3da8(%rip), %rax      # 0x8fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2110
leaq 0x100(%rsp), %rdi
callq 0x2060
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: meanValue(std::vector<double, std::allocator<double>>&)
double meanValue(vector<double> &tab)
{
    // Purpose : compute the mean value of a vector
    double buf(0.);
    for (unsigned int i = 0; i < tab.size(); i++) {
        buf += tab[i];
    }
    return (buf/tab.size());
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0x52a5
xorl %edx, %edx
addsd (%rcx,%rdx,8), %xmm0
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0x5296
movq %rax, %xmm1
punpckldq 0xdae(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xdb6(%rip), %xmm1      # 0x6070
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: meanValue(std::vector<double, std::allocator<double>> const&)
double meanValue(vector<double> const& tab)
{
    // Purpose : compute the mean value of a vector
    double buf(0.);
    for (unsigned int i = 0; i < tab.size(); i++) {
        buf += tab[i];
    }
    return (buf/tab.size());
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0x52f6
xorl %edx, %edx
addsd (%rcx,%rdx,8), %xmm0
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0x52e7
movq %rax, %xmm1
punpckldq 0xd5d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xd65(%rip), %xmm1      # 0x6070
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: residual(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
double residual(std::vector<double> &tabKnow, std::vector<double> &tabEstimated)
{
    // Purpose : compute the residual of an Ordinary Lest Squares (OLS) procedure
    // Linear fn y=f(x) - vector are y values
    double scr(0.), sct(0.);
    if (tabKnow.size() == tabEstimated.size()) {
        for (unsigned int i = 0; i < tabKnow.size(); i++) {
        scr += (tabKnow[i]-tabEstimated[i])*(tabKnow[i]-tabEstimated[i]);
        sct += (tabKnow[i]-meanValue(tabKnow))*(tabKnow[i]-meanValue(tabKnow)); 
        }
    }
    else {
        cout << "Error : residual can not be computed due to different vector size\n";
    }
    return (1.-(scr/sct));
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq %rdi, %rcx
subq %rax, %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
cmpq %rsi, %rcx
jne 0x53e4
cmpq %rax, %rdi
je 0x53fc
sarq $0x3, %rcx
movq %rcx, %xmm1
punpckldq 0xd09(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xd11(%rip), %xmm1      # 0x6070
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
xorl %esi, %esi
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm4
movsd (%rax,%rsi,8), %xmm3
movapd %xmm3, %xmm1
subsd (%rdx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm4, %xmm1
xorl %edi, %edi
xorpd %xmm5, %xmm5
addsd (%rax,%rdi,8), %xmm5
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x5395
divsd %xmm0, %xmm5
movapd %xmm3, %xmm4
subsd %xmm5, %xmm4
xorpd %xmm5, %xmm5
xorl %edi, %edi
addsd (%rax,%rdi,8), %xmm5
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x53b7
divsd %xmm0, %xmm5
subsd %xmm5, %xmm3
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm2
incl %esi
cmpq %rsi, %rcx
ja 0x5375
divsd %xmm2, %xmm1
jmp 0x5404
movq 0x3bed(%rip), %rdi      # 0x8fd8
leaq 0x119e(%rip), %rsi      # 0x6590
movl $0x42, %edx
callq 0x2180
movsd 0xc04(%rip), %xmm1      # 0x6008
movsd 0xc14(%rip), %xmm0      # 0x6020
subsd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::l1(double, int)
double l1(double a, int order)
{
	assert (order >= 0 && order <= 2); // order valid for 0, 1, 2
	double l1 = l10(a);
	if (order == 2)
		l1 += l12(a);
	return l1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x3, %edi
jae 0x2571
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x2590
cmpl $0x2, %ebx
jne 0x256b
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2675
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0xbab8(%rip), %rdi      # 0xe030
leaq 0xbaca(%rip), %rsi      # 0xe049
leaq 0xbad1(%rip), %rcx      # 0xe057
movl $0xf, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::l10(double)
double l10(double a)
{
	double c = cos(Hat::phi(a) - t13);
	double x = Hat::l0(a) + Hat::lm(a);
	double y = pow(Hat::l0(a) - Hat::lm(a), 2) + pow(2 * eps * c12 * s12 * Dmsqee * c, 2);
	return (x - sqrt(y)) / 2.;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x6e76
leaq 0xbd72(%rip), %rax      # 0xe318
subsd (%rax), %xmm0
callq 0x22c0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6eb1
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6bf1
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6eb1
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6bf1
movsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
leaq 0x10b82(%rip), %rax     # 0x13190
movsd (%rax), %xmm0
addsd %xmm0, %xmm0
leaq 0xbcd3(%rip), %rax      # 0xe2f0
mulsd (%rax), %xmm0
leaq 0xbcb0(%rip), %rax      # 0xe2d8
mulsd (%rax), %xmm0
leaq 0x10b55(%rip), %rax     # 0x13188
mulsd (%rax), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2655
sqrtsd %xmm0, %xmm0
jmp 0x265a
callq 0x2120
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0xb99c(%rip), %xmm1     # 0xe008
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::l2(double, int)
double l2(double a, int order)
{
	assert (order >= 0 && order <= 2); // order valid for 0, 1, 2
	double l2 = l20(a);
	if (order == 2)
		l2 += l22(a);
	return l2;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x3, %edi
jae 0x273b
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x275a
cmpl $0x2, %ebx
jne 0x2735
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x283f
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb8ee(%rip), %rdi      # 0xe030
leaq 0xb900(%rip), %rsi      # 0xe049
leaq 0xb925(%rip), %rcx      # 0xe075
movl $0x17, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2905
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x6b40
cmpl $0x2, %ebx
jne 0x28ff
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2929
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb724(%rip), %rdi      # 0xe030
leaq 0xb736(%rip), %rsi      # 0xe049
leaq 0xb779(%rip), %rcx      # 0xe093
movl $0x1f, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2aab
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x275a
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, %ebx
jne 0x2a8c
movsd 0x8(%rsp), %xmm0
callq 0x283f
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 0x2675
addsd 0x18(%rsp), %xmm0
jmp 0x2a97
movsd 0x8(%rsp), %xmm0
callq 0x2590
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xb57e(%rip), %rdi      # 0xe030
leaq 0xb590(%rip), %rsi      # 0xe049
leaq 0xb5f1(%rip), %rcx      # 0xe0b1
movl $0x4b, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b4a
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x6b40
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, %ebx
jne 0x2b2b
movsd 0x8(%rsp), %xmm0
callq 0x2929
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 0x2675
addsd 0x18(%rsp), %xmm0
jmp 0x2b36
movsd 0x8(%rsp), %xmm0
callq 0x2590
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xb4df(%rip), %rdi      # 0xe030
leaq 0xb4f1(%rip), %rsi      # 0xe049
leaq 0xb572(%rip), %rcx      # 0xe0d1
movl $0x53, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2be9
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x6b40
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, %ebx
jne 0x2bca
movsd 0x8(%rsp), %xmm0
callq 0x2929
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x275a
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x283f
addsd 0x18(%rsp), %xmm0
jmp 0x2bd5
movsd 0x8(%rsp), %xmm0
callq 0x275a
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xb440(%rip), %rdi      # 0xe030
leaq 0xb452(%rip), %rsi      # 0xe049
leaq 0xb4f3(%rip), %rcx      # 0xe0f1
movl $0x5b, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3537
movl %esi, %ebx
cmpl $0x3, %esi
jae 0x3556
movl %edx, %ebp
cmpl $0x3, %edx
jae 0x3575
cmpl $0x3, %ecx
jae 0x3594
movl %edi, %r14d
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ecx, %esi
callq 0x338c
movl %r14d, %esi
movl %ebp, %r14d
movq %r15, %rdi
movq %r14, %rdx
callq 0xa590
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 0xa590
movaps 0x10(%rsp), %xmm1
xorps 0xab3d(%rip), %xmm1     # 0xe020
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rdi)
movlps %xmm1, 0x8(%rdi)
movq %rax, %rsi
callq 0x3994
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xa582
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xac41(%rip), %rdi      # 0xe17f
leaq 0xab04(%rip), %rsi      # 0xe049
leaq 0xac4c(%rip), %rcx      # 0xe198
movl $0xa6, %edx
callq 0x20f0
leaq 0xac87(%rip), %rdi      # 0xe1e4
leaq 0xaae5(%rip), %rsi      # 0xe049
leaq 0xac2d(%rip), %rcx      # 0xe198
movl $0xa7, %edx
callq 0x20f0
leaq 0xac7f(%rip), %rdi      # 0xe1fb
leaq 0xaac6(%rip), %rsi      # 0xe049
leaq 0xac0e(%rip), %rcx      # 0xe198
movl $0xa8, %edx
callq 0x20f0
leaq 0xaa95(%rip), %rdi      # 0xe030
leaq 0xaaa7(%rip), %rsi      # 0xe049
leaq 0xabef(%rip), %rcx      # 0xe198
movl $0xa9, %edx
callq 0x20f0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa582
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0xf756(%rip)      # 0x13198
decl %edi
orl $0x1, %edi
cvtsi2sd %edi, %xmm0
mulsd 0xa815(%rip), %xmm0     # 0xe268
movl %edi, 0xf743(%rip)      # 0x1319c
movsd %xmm0, 0xf71f(%rip)     # 0x13180
addsd 0xa807(%rip), %xmm0     # 0xe270
movsd %xmm0, 0xf717(%rip)     # 0x13188
movsd 0xa7ff(%rip), %xmm1     # 0xe278
divsd %xmm0, %xmm1
movsd %xmm1, 0xf70b(%rip)     # 0x13190
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa436
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa590
movsd 0xa53c(%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 0xa590
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 0xa590
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 0xa590
movapd 0xa49c(%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 0xa590
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x3be4
jmp 0x3be4
movq %rax, %r14
movq %rbx, %rdi
callq 0xa582
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa436
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa590
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 0xa590
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa590
movsd 0xa387(%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 0xa590
movaps 0x10(%rsp), %xmm0
xorps 0xa361(%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 0xa590
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 0xa582
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa436
movsd 0x8(%rsp), %xmm0
callq 0x22c0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa590
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 0xa590
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 0xa590
movaps 0x10(%rsp), %xmm0
xorps 0xa258(%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 0xa590
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x2, %esi
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa590
movsd 0xa1f6(%rip), %xmm0     # 0xe018
movups %xmm0, (%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa582
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa34f(%rip), %rax      # 0xe328
mulsd (%rax), %xmm1
mulsd 0xa353(%rip), %xmm1     # 0xe338
movsd %xmm1, 0x8(%rsp)
leaq 0xa2be(%rip), %rax      # 0xe2b0
movsd (%rax), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
callq 0x6fad
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0xa2b8(%rip), %rbx      # 0xe2d0
leaq 0xa2e9(%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 0xa2cb(%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 0x9f87(%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_O1/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 0x479e
movaps %xmm0, 0x60(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4863
movapd %xmm0, 0x90(%rsp)
leaq 0x9573(%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 0x9573(%rip), %rax      # 0xe2c8
movsd (%rax), %xmm2
movaps %xmm2, 0x40(%rsp)
addsd %xmm1, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, 0x80(%rsp)
leaq 0x9582(%rip), %rax      # 0xe2f8
movsd (%rax), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x955a(%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 0x926e(%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 0x4eab
sqrtsd %xmm0, %xmm0
jmp 0x4ebc
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_O1/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 0x479e
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4863
leaq 0x93a5(%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 0x93ae(%rip), %r14      # 0xe2c8
addsd %xmm2, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
leaq 0x93c9(%rip), %rax      # 0xe2f8
movsd (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x93a1(%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 0x90b5(%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 0x5034
sqrtsd %xmm0, %xmm0
jmp 0x5045
movsd %xmm2, 0x8(%rsp)
callq 0x2120
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
retq