LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tonymugen[P]sampleSNPs/random.cpp
// Function: sampFiles::RanDraw::runifnz()
volatile double RanDraw::runifnz(){
	double rnz = 0.0;
	do {
		rnz = this->runif();
	} while (rnz == 0.0); // simply reject 0.0
	
	return rnz;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %xmm1
punpckldq 0x1754(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x175c(%rip), %xmm1     # 0x144b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x23c0(%rip), %xmm0     # 0x15128
ucomisd 0x17d8(%rip), %xmm0     # 0x14548
jne 0x12d74
jnp 0x12d36
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12d8c
jnp 0x12e52
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movsd (%rdx), %xmm2
ucomisd %xmm2, %xmm0
ja 0x12e4b
movq %rdi, %r14
ucomisd 0x1731(%rip), %xmm0     # 0x144e0
jne 0x12e53
jp 0x12e53
movapd %xmm2, (%rsp)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %xmm1
punpckldq 0x16ca(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x16d2(%rip), %xmm1     # 0x144b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x2336(%rip), %xmm0     # 0x15128
mulsd (%rsp), %xmm0
callq 0x4490
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x2328(%rip), %xmm1     # 0x15138
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
movsd (%rbx), %xmm2
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
orq %rcx, %rax
cvttsd2si %xmm2, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
cmpq %rsi, %rax
je 0x12dbb
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
divsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rsp)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %xmm1
punpckldq 0x1620(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1628(%rip), %xmm1     # 0x144b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x228c(%rip), %xmm0     # 0x15128
ucomisd 0x163c(%rip), %xmm0     # 0x144e0
jne 0x12ea8
jnp 0x12e6a
movsd (%rbx), %xmm1
xorl %eax, %eax
movsd 0x227a(%rip), %xmm2     # 0x15130
movsd (%rsp), %xmm3
movsd 0x10(%rsp), %xmm4
ucomisd %xmm0, %xmm4
jbe 0x12e4b
incq %rax
addsd %xmm2, %xmm3
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm4
divsd %xmm1, %xmm4
jmp 0x12ec1
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
leaq 0x120(%rdi), %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x10de5
movq (%r14), %r15
leaq 0x20(%rsp), %rdi
movq %rbx, -0x8(%rdi)
addq $0x98, %rbx
movq %r14, %rsi
callq 0x28de6
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x10e06
leaq 0x28(%rsp), %rdi
callq 0x18f4e
leaq 0x10(%rsp), %rdi
callq 0x18f4e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x18f4e
leaq 0x10(%rsp), %rdi
callq 0x18f4e
movq %rbx, %rdi
callq 0xaac0
// File: /workspace/github_cpp_makefile_star2_O2/DMLfor[P]TinyWebServer/./ServerBase.hpp
// Function: WebServer::ServerBase<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>>>>>>::start()
void WebServer::ServerBase<socket_type>::start()
{
	// 默认资源回放在 vector 的末尾，用作默认应答
	// 默认的请求会在找不到匹配请求路径时, 进行访问,故在最后添加
	for(auto it = resource.begin(); it != resource.end(); it++)
		all_resources.push_back(it);

	for(auto it = default_resource.begin(); it != default_resource.end(); it++)
		all_resources.push_back(it);
	// 调用 socket 的连接方式，还需要子类来实现 accept() 逻辑
	accept();
	// 如果 num_threads>1, 那么 m_io_service.run()
	// 将运行 (num_threads-1) 线程成为线程池
	for(size_t c = 1; c<num_threads; c++)
	{
		threads.emplace_back([this]()
				{
					m_io_service.run();
				});
	}
	// 主线程
	m_io_service.run();

	// 等待其他线程, 如果有的话，就等待这些线程的结束
	for(auto &t :threads)
		t.join();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
leaq 0x10(%rdi), %r12
leaq 0x108(%rdi), %r14
movq %rsp, %r15
movq %rax, (%rsp)
cmpq %r12, %rax
je 0x29146
movq %r14, %rdi
movq %r15, %rsi
callq 0x29c9c
movq (%rsp), %rdi
callq 0xa4c0
jmp 0x29127
movq 0x50(%rbx), %rax
leaq 0x40(%rbx), %r12
movq %rsp, %r15
movq %rax, (%rsp)
cmpq %r12, %rax
je 0x29170
movq %r14, %rdi
movq %r15, %rsi
callq 0x29c9c
movq (%rsp), %rdi
callq 0xa4c0
jmp 0x29151
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0xf0(%rbx), %r14
pushq $0x1
popq %r12
movq %rsp, %r15
cmpq 0xe8(%rbx), %r12
jae 0x291a4
movq %rbx, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x29cba
incq %r12
jmp 0x29187
leaq 0x68(%rbx), %rdi
callq 0x29ce6
movq 0xf0(%rbx), %r14
movq 0xf8(%rbx), %rbx
cmpq %rbx, %r14
je 0x291ce
movq %r14, %rdi
callq 0xaa80
addq $0x8, %r14
jmp 0x291bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: readLiqVapInput(double&, double&, double&)
void readLiqVapInput(double &p0, double &ro0, double &c0)
{
    ifstream strmRefStates("input/refState.txt");
    string line("");
    if (strmRefStates) {
        for (int i=1; i<5; i++) {getline(strmRefStates,line);}
        p0 = stod(line);
        getline(strmRefStates,line); getline(strmRefStates,line);
        ro0 = stod(line);
        getline(strmRefStates,line); getline(strmRefStates,line);
        c0 = stod(line);
    }
    else {
        cout << "Error : reading refState.txt file\n"; exit(0);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2cab(%rip), %rsi      # 0x5098
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2240
leaq 0x2d78(%rip), %rsi      # 0x5179
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3058
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x50(%rsp,%rax)
jne 0x24d7
pushq $0x4
popq %rbp
leaq 0x30(%rsp), %r12
leaq 0x10(%rsp), %r13
subl $0x1, %ebp
jb 0x2443
movq %r12, %rdi
movq %r13, %rsi
callq 0x2040
jmp 0x2431
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x3093
movsd %xmm0, (%r15)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2040
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2040
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x3093
movsd %xmm0, (%r14)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2040
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2040
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x3093
movsd %xmm0, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x30(%rsp), %rdi
callq 0x2050
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5afa(%rip), %rdi      # 0x7fd8
leaq 0x2bc6(%rip), %rsi      # 0x50ab
callq 0x2150
xorl %edi, %edi
callq 0x2190
movq %rax, %rbx
jmp 0x2505
jmp 0x24f8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x30(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x464f
movapd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x464f
movapd (%rsp), %xmm3
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq (%rbx), %rdx
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
xorpd %xmm0, %xmm0
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0x257f
movsd (%rdx,%rsi,8), %xmm1
movsd (%rax,%rsi,8), %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
subpd %xmm3, %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
addpd %xmm1, %xmm0
incl %esi
jmp 0x2556
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x464f
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x464f
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_O2/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
sarq $0x3, %rcx
movq (%rdi), %rsi
movq (%rdx), %rdx
xorpd %xmm1, %xmm1
xorl %edi, %edi
movl %edi, %edi
cmpq %rdi, %rcx
jbe 0x2610
movsd (%rax,%rdi,8), %xmm2
divsd (%rdx,%rdi,8), %xmm2
movsd (%rsi,%rdi,8), %xmm3
unpcklpd %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0]
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm3, %xmm2
addpd %xmm2, %xmm1
incl %edi
jmp 0x25e6
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm6, 0x28(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
subsd %xmm5, %xmm4
movapd %xmm1, %xmm5
subsd %xmm3, %xmm5
divsd %xmm5, %xmm4
movsd %xmm4, 0x20(%rsp)
movsd %xmm1, 0x10(%rsp)
subsd %xmm0, %xmm1
movsd %xmm0, 0x18(%rsp)
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
divsd %xmm5, %xmm7
movsd %xmm7, 0x30(%rsp)
movapd 0x299a(%rip), %xmm0     # 0x5010
xorpd %xmm0, %xmm1
divsd %xmm5, %xmm1
movapd %xmm1, 0x50(%rsp)
xorpd %xmm0, %xmm3
movsd %xmm5, 0x8(%rsp)
divsd %xmm5, %xmm3
movapd %xmm3, 0x40(%rsp)
xorl %eax, %eax
xorpd %xmm1, %xmm1
movl %eax, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x273f
movsd (%rax,%r15,8), %xmm0
movsd %xmm1, 0x38(%rsp)
callq 0x2110
movapd %xmm0, %xmm2
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm1
mulsd 0x30(%rsp), %xmm1
addsd 0x20(%rsp), %xmm1
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
divsd %xmm0, %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
callq 0x2110
mulsd 0x50(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm0
addsd 0x28(%rsp), %xmm0
callq 0x2110
movsd 0x38(%rsp), %xmm1
mulsd 0x40(%rsp), %xmm0
addsd (%rsp), %xmm0
addsd %xmm0, %xmm1
leal 0x1(%r15), %eax
jmp 0x269e
cvtsi2sd %rcx, %xmm0
divsd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
subsd 0x18(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
subq %rcx, %rax
sarq $0x3, %rax
movq (%rdi), %rdx
xorl %esi, %esi
xorpd %xmm1, %xmm1
movl %esi, %esi
cmpq %rsi, %rax
jbe 0x27a5
movsd (%rcx,%rsi,8), %xmm2
movsd (%rdx,%rsi,8), %xmm3
addsd %xmm0, %xmm3
divsd %xmm3, %xmm2
addsd %xmm2, %xmm1
incl %esi
jmp 0x2784
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
sarq $0x3, %rcx
movq (%rdi), %rsi
movq (%rdx), %rdx
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
xorpd %xmm1, %xmm1
xorl %edi, %edi
movl %edi, %edi
cmpq %rdi, %rcx
jbe 0x2851
movsd (%rax,%rdi,8), %xmm3
movsd (%rsi,%rdi,8), %xmm4
addsd %xmm2, %xmm4
divsd %xmm4, %xmm3
movsd (%rdx,%rdi,8), %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
subpd %xmm0, %xmm4
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm4, %xmm3
addpd %xmm3, %xmm1
incl %edi
jmp 0x281b
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
sarq $0x3, %rcx
movq (%rdi), %rsi
movq %rcx, %xmm4
punpckldq 0x27a0(%rip), %xmm4 # xmm4 = xmm4[0],mem[0],xmm4[1],mem[1]
subpd 0x27a8(%rip), %xmm4     # 0x5030
movq (%rdx), %rdx
movapd %xmm4, %xmm6
unpckhpd %xmm4, %xmm6            # xmm6 = xmm6[1],xmm4[1]
addsd %xmm4, %xmm6
movsd 0x27c1(%rip), %xmm5     # 0x5060
divsd %xmm6, %xmm5
xorpd %xmm4, %xmm4
xorl %edi, %edi
xorpd %xmm7, %xmm7
movapd 0x275a(%rip), %xmm8     # 0x5010
mulsd %xmm1, %xmm5
xorpd %xmm6, %xmm6
movl %edi, %edi
cmpq %rdi, %rcx
jbe 0x2955
movsd (%rax,%rdi,8), %xmm9
movsd (%rsi,%rdi,8), %xmm10
addsd %xmm3, %xmm10
divsd %xmm10, %xmm9
movapd %xmm9, %xmm11
divsd %xmm10, %xmm11
movsd (%rdx,%rdi,8), %xmm10
movapd %xmm10, %xmm12
mulsd %xmm0, %xmm12
movapd %xmm5, %xmm13
addsd %xmm9, %xmm13
unpcklpd %xmm9, %xmm12           # xmm12 = xmm12[0],xmm9[0]
subsd %xmm0, %xmm10
mulsd %xmm9, %xmm10
movapd %xmm11, %xmm14
addsd %xmm2, %xmm14
mulsd %xmm9, %xmm14
subsd %xmm1, %xmm9
mulsd %xmm11, %xmm9
xorpd %xmm8, %xmm11
unpcklpd %xmm13, %xmm11          # xmm11 = xmm11[0],xmm13[0]
mulpd %xmm11, %xmm12
addpd %xmm12, %xmm4
addsd %xmm10, %xmm7
subsd %xmm9, %xmm14
addsd %xmm14, %xmm6
incl %edi
jmp 0x28be
mulsd %xmm7, %xmm6
movapd %xmm4, %xmm0
unpckhpd %xmm4, %xmm0            # xmm0 = xmm0[1],xmm4[1]
mulsd %xmm0, %xmm4
subsd %xmm6, %xmm4
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm4
movapd %xmm4, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
sarq $0x3, %rcx
movq (%rsi), %rsi
movq (%rdx), %rdx
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
xorpd %xmm1, %xmm1
xorl %edi, %edi
xorpd %xmm4, %xmm4
movl %edi, %edi
cmpq %rdi, %rcx
jbe 0x29ec
movsd (%rax,%rdi,8), %xmm5
movsd (%rsi,%rdi,8), %xmm6
movhpd (%rdx,%rdi,8), %xmm6    # xmm6 = xmm6[0],mem[0]
subpd %xmm0, %xmm6
movapd %xmm5, %xmm7
subsd %xmm2, %xmm7
mulsd %xmm5, %xmm7
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm6, %xmm5
addpd %xmm5, %xmm1
addsd %xmm7, %xmm4
incl %edi
jmp 0x29b2
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm1
divsd %xmm4, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
sarq $0x3, %rcx
movq (%rsi), %rdx
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
xorpd %xmm1, %xmm1
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0x2a49
movsd (%rax,%rsi,8), %xmm3
movsd (%rdx,%rsi,8), %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
subpd %xmm0, %xmm4
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm4, %xmm3
addpd %xmm3, %xmm1
incl %esi
jmp 0x2a20
xorpd 0x25bf(%rip), %xmm2     # 0x5010
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: displayHeader()
void displayHeader()
{
    cout << "  _   _           _____  _____    _____      _ _ _               _   _         " << endl;
    cout << " | \\ | |   /\\    / ____|/ ____|  / ____|    | (_) |             | | (_)            " << endl;
    cout << " |  \\| |  /  \\  | (___ | |  __  | |     __ _| |_| |__  _ __ __ _| |_ _  ___  _ __  " << endl;
    cout << " | . ` | / /\\ \\  \\___ \\| | |_ | | |    / _` | | | '_ \\| '__/ _` | __| |/ _ \\| '_ \\ " << endl;
    cout << " | |\\  |/ ____ \\ ____) | |__| | | |___| (_| | | | |_) | | | (_| | |_| | (_) | | | |" << endl;
    cout << " |_| \\_/_/    \\_\\_____/ \\_____|  \\_____\\__,_|_|_|_.__/|_|  \\__,_|\\__|_|\\___/|_| |_|" << endl;
}

// Assembly:
pushq %rbx
movq 0x3e38(%rip), %rbx      # 0x7fd8
leaq 0x11d9(%rip), %rsi      # 0x5380
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x1212(%rip), %rsi      # 0x53d0
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x124f(%rip), %rsi      # 0x5424
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x128c(%rip), %rsi      # 0x5478
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x12c9(%rip), %rsi      # 0x54cc
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x1306(%rip), %rsi      # 0x5520
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
popq %rbx
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
void readFile(string const &file, vector<double> &tab_x, vector<double> &tab_y)
{
    // Purpose : read experimental data file with two columns and a header (ignored)
    ifstream streamFile(file);
    string line;
    double data1(0.), data2(0.);

    if (streamFile) {
        while (getline(streamFile,line)) {
            streamFile >> data1 >> data2; 
            tab_x.push_back(data1);
            tab_y.push_back(data2);
            cout << data1 << " " << data2 << endl;
        }
    } 
    else {
        cout << "Error : reading experimental data file " << file << ".txt\n"; exit(0);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x21e0
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andq $0x0, 0x8(%rsp)
movb $0x0, (%rax)
andq $0x0, (%rsp)
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x50(%rsp,%rax)
jne 0x4522
leaq 0x30(%rsp), %r15
leaq 0x8(%rsp), %r13
movq %rsp, %rbp
leaq 0xfa1(%rip), %r12       # 0x5422
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x44fc
movq %r15, %rdi
movq %r13, %rsi
callq 0x20e0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x20e0
movq %r14, %rdi
movq %r13, %rsi
callq 0x4a36
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4a36
movsd 0x8(%rsp), %xmm0
movq 0x3b03(%rip), %rdi      # 0x7fd8
callq 0x21d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
movsd (%rsp), %xmm0
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20b0
jmp 0x4481
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x30(%rsp), %rdi
callq 0x2050
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3aaf(%rip), %rdi      # 0x7fd8
leaq 0x1044(%rip), %rsi      # 0x5574
callq 0x2150
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x1055(%rip), %rsi      # 0x559c
movq %rax, %rdi
callq 0x2150
xorl %edi, %edi
callq 0x2190
jmp 0x4558
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x30(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rsi
movq %rsp, %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x2180
xorl %r13d, %r13d
leaq 0xe7a(%rip), %r12       # 0x5422
movl %r13d, %r13d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x45f5
movsd (%rax,%r13,8), %xmm0
movq %r15, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
movq (%rbx), %rcx
movsd (%rcx,%r13,8), %xmm0
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20b0
incl %r13d
jmp 0x45a8
movq %rsp, %rdi
callq 0x21b0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
subq %rcx, %rax
sarq $0x3, %rax
xorl %edx, %edx
xorpd %xmm0, %xmm0
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x4645
addsd (%rcx,%rdx,8), %xmm0
incl %edx
jmp 0x4635
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
subq %rcx, %rax
sarq $0x3, %rax
xorl %edx, %edx
xorpd %xmm0, %xmm0
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x4673
addsd (%rcx,%rdx,8), %xmm0
incl %edx
jmp 0x4663
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2551
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x256e
cmpl $0x2, %ebx
jne 0x254b
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x263e
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x9ad8(%rip), %rdi      # 0xc030
leaq 0x9aea(%rip), %rsi      # 0xc049
leaq 0x9af1(%rip), %rcx      # 0xc057
pushq $0xf
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x63e2
leaq 0x9d94(%rip), %rax      # 0xc318
subsd (%rax), %xmm0
callq 0x2290
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x641d
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x62c5
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x641d
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x62c5
leaq 0xeba2(%rip), %rax      # 0x11180
movsd (%rax), %xmm1
addsd %xmm1, %xmm1
leaq 0x9d03(%rip), %rax      # 0xc2f0
mulsd (%rax), %xmm1
movsd 0x18(%rsp), %xmm2
subsd %xmm0, %xmm2
leaq 0x9cd6(%rip), %rax      # 0xc2d8
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm2
leaq 0xeb67(%rip), %rax      # 0x11178
mulsd (%rax), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
sqrtsd %xmm1, %xmm1
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x99cf(%rip), %xmm0     # 0xc008
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2704
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x2721
cmpl $0x2, %ebx
jne 0x26fe
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x27ed
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x9925(%rip), %rdi      # 0xc030
leaq 0x9937(%rip), %rsi      # 0xc049
leaq 0x995c(%rip), %rcx      # 0xc075
pushq $0x17
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28b3
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x6214
cmpl $0x2, %ebx
jne 0x28ad
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x28d5
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x9776(%rip), %rdi      # 0xc030
leaq 0x9788(%rip), %rsi      # 0xc049
leaq 0x97cb(%rip), %rcx      # 0xc093
pushq $0x1f
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
cmpl $0x3, %edi
jae 0x2a32
cmpl $0x2, %edi
movsd %xmm0, 0x8(%rsp)
jne 0x2a0a
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0x26bf
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x250c
jmp 0x2a1f
callq 0x2721
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x256e
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x95f7(%rip), %rdi      # 0xc030
leaq 0x9609(%rip), %rsi      # 0xc049
leaq 0x966a(%rip), %rcx      # 0xc0b1
pushq $0x4b
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
cmpl $0x3, %edi
jae 0x2aaa
cmpl $0x2, %edi
movsd %xmm0, 0x8(%rsp)
jne 0x2a82
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0x286e
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x250c
jmp 0x2a97
callq 0x6214
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x256e
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x957f(%rip), %rdi      # 0xc030
leaq 0x9591(%rip), %rsi      # 0xc049
leaq 0x9612(%rip), %rcx      # 0xc0d1
pushq $0x53
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
cmpl $0x3, %edi
jae 0x2b22
cmpl $0x2, %edi
movsd %xmm0, 0x8(%rsp)
jne 0x2afa
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0x286e
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
movl %ebx, %edi
callq 0x26bf
jmp 0x2b0f
callq 0x6214
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2721
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x9507(%rip), %rdi      # 0xc030
leaq 0x9519(%rip), %rsi      # 0xc049
leaq 0x95ba(%rip), %rcx      # 0xc0f1
pushq $0x5b
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
cmpl $0x3, %edi
jae 0x3349
movl %esi, %ebx
cmpl $0x3, %esi
jae 0x3368
movl %edx, %ebp
cmpl $0x3, %edx
jae 0x3387
cmpl $0x3, %ecx
jae 0x33a6
movl %edi, %r14d
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl %ecx, %esi
callq 0x31bf
movl %r14d, %esi
movl %ebp, %r14d
movq %r15, %rdi
movq %r14, %rdx
callq 0x87b0
movsd 0x8(%rax), %xmm0
xorps 0x8d2d(%rip), %xmm0     # 0xc020
movsd (%rax), %xmm1
movsd %xmm1, 0x10(%rsp)
movlps %xmm0, 0x18(%rsp)
movl %ebx, %esi
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x87b0
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3719
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x87a2
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8e2f(%rip), %rdi      # 0xc17f
leaq 0x8cf2(%rip), %rsi      # 0xc049
leaq 0x8e3a(%rip), %rcx      # 0xc198
movl $0xa6, %edx
callq 0x2100
leaq 0x8e75(%rip), %rdi      # 0xc1e4
leaq 0x8cd3(%rip), %rsi      # 0xc049
leaq 0x8e1b(%rip), %rcx      # 0xc198
movl $0xa7, %edx
callq 0x2100
leaq 0x8e6d(%rip), %rdi      # 0xc1fb
leaq 0x8cb4(%rip), %rsi      # 0xc049
leaq 0x8dfc(%rip), %rcx      # 0xc198
movl $0xa8, %edx
callq 0x2100
leaq 0x8c83(%rip), %rdi      # 0xc030
leaq 0x8c95(%rip), %rsi      # 0xc049
leaq 0x8ddd(%rip), %rcx      # 0xc198
movl $0xa9, %edx
callq 0x2100
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x87a2
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/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, 0xd99e(%rip)      # 0x11188
decl %edi
orl $0x1, %edi
cvtsi2sd %edi, %xmm0
mulsd 0x8a6d(%rip), %xmm0     # 0xc268
movl %edi, 0xd98b(%rip)      # 0x1118c
movsd %xmm0, 0xd967(%rip)     # 0x11170
addsd 0x8a5f(%rip), %xmm0     # 0xc270
movsd %xmm0, 0xd95f(%rip)     # 0x11178
movsd 0x8a57(%rip), %xmm1     # 0xc278
divsd %xmm0, %xmm1
movsd %xmm1, 0xd953(%rip)     # 0x11180
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2290
movaps %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2060
movaps %xmm0, 0x10(%rsp)
pushq $0x3
popq %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x8682
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x87b0
movsd 0x8798(%rip), %xmm0     # 0xc018
movups %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x20(%rsp)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x87b0
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
andq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2060
movaps %xmm0, 0x20(%rsp)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x87b0
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 0x2060
movaps %xmm0, 0x10(%rsp)
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x87b0
movapd 0x8707(%rip), %xmm0     # 0xc020
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 0x2290
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x87b0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
andq $0x0, 0x8(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x3972
jmp 0x3972
movq %rax, %r14
movq %rbx, %rdi
callq 0x87a2
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/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
pushq $0x3
popq %rdx
movq %rdx, %rsi
callq 0x8682
movsd 0x8(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x87b0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
andq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2060
movsd %xmm0, 0x10(%rsp)
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x87b0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
andq $0x0, 0x8(%rax)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x87b0
movsd 0x8609(%rip), %xmm0     # 0xc018
movups %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2060
movaps %xmm0, 0x10(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x87b0
movaps 0x10(%rsp), %xmm0
xorps 0x85e5(%rip), %xmm0     # 0xc020
movlps %xmm0, (%rax)
andq $0x0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x87b0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
andq $0x0, 0x8(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x87a2
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/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 0x85fb(%rip), %rax      # 0xc328
mulsd (%rax), %xmm1
mulsd 0x85ff(%rip), %xmm1     # 0xc338
movsd %xmm1, 0x8(%rsp)
leaq 0x856a(%rip), %rax      # 0xc2b0
movsd (%rax), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
callq 0x647a
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x8564(%rip), %rbx      # 0xc2d0
leaq 0x8595(%rip), %rax      # 0xc308
movsd (%rax), %xmm0
addsd %xmm0, %xmm0
callq 0x2060
mulsd (%rbx), %xmm0
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2060
movaps %xmm0, 0x10(%rsp)
leaq 0x8577(%rip), %rax      # 0xc318
movsd (%rax), %xmm0
addsd %xmm0, %xmm0
callq 0x2060
movapd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2060
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 0x8233(%rip), %xmm0     # 0xc018
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_O2/PeterDenton[P]Nu-Pert/src/Exact.cpp
// Function: Exact::s12msq(double)
double s12msq(double D)
{
	double x = (pow(M2sq(D), 2) - alpha() * M2sq(D) + beta()) * DM31sq(D);
	double s12msq_n = -x;
	double s12msq_d = DM32sq(D) * (pow(M1sq(D), 2) - alpha() * M1sq(D) + beta()) - x;
	return s12msq_n / s12msq_d;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x4264
mulsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x4354
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4264
mulsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x4394
addsd 0x10(%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x42c1
movapd 0x10(%rsp), %xmm1
xorpd 0x7b25(%rip), %xmm1     # 0xc020
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x42f4
movsd %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x424f
mulsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x4354
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x424f
mulsd 0x28(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x4394
addsd 0x10(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/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 0x43c1
movaps %xmm0, 0x60(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x444d
movapd %xmm0, 0x90(%rsp)
leaq 0x7b30(%rip), %rax      # 0xc2a0
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 0x7b30(%rip), %rax      # 0xc2c8
movsd (%rax), %xmm2
movaps %xmm2, 0x40(%rsp)
addsd %xmm1, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, 0x80(%rsp)
leaq 0x7b3f(%rip), %rax      # 0xc2f8
movsd (%rax), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x7b17(%rip), %rax      # 0xc2e0
movsd (%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2290
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2290
movapd 0x782b(%rip), %xmm7     # 0xc020
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 0x2290
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 0x48ee
sqrtsd %xmm0, %xmm0
jmp 0x48ff
movsd %xmm2, 0x8(%rsp)
callq 0x2120
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
addq $0xa8, %rsp
retq