LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movsd 0x18(%rbp), %xmm8
movsd 0x10(%rbp), %xmm8
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x30(%rbp)
movsd %xmm6, -0x38(%rbp)
movsd %xmm7, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
movq %r8, -0x68(%rbp)
movsd -0x10(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x58(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x60(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x18(%rbp), %xmm0
subsd 0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x68(%rbp), %rax
movsd %xmm0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x42cd(%rip), %rdi      # 0xafd8
leaq 0x163c(%rip), %rsi      # 0x834e
callq 0x2180
movq %rax, %rdi
movq 0x429f(%rip), %rsi      # 0xafc0
callq 0x21b0
movq 0x42ab(%rip), %rdi      # 0xafd8
leaq 0x166a(%rip), %rsi      # 0x839e
callq 0x2180
movq %rax, %rdi
movq 0x427d(%rip), %rsi      # 0xafc0
callq 0x21b0
movq 0x4289(%rip), %rdi      # 0xafd8
leaq 0x169c(%rip), %rsi      # 0x83f2
callq 0x2180
movq %rax, %rdi
movq 0x425b(%rip), %rsi      # 0xafc0
callq 0x21b0
movq 0x4267(%rip), %rdi      # 0xafd8
leaq 0x16ce(%rip), %rsi      # 0x8446
callq 0x2180
movq %rax, %rdi
movq 0x4239(%rip), %rsi      # 0xafc0
callq 0x21b0
movq 0x4245(%rip), %rdi      # 0xafd8
leaq 0x1700(%rip), %rsi      # 0x849a
callq 0x2180
movq %rax, %rdi
movq 0x4217(%rip), %rsi      # 0xafc0
callq 0x21b0
movq 0x4223(%rip), %rdi      # 0xafd8
leaq 0x1732(%rip), %rsi      # 0x84ee
callq 0x2180
movq %rax, %rdi
movq 0x41f5(%rip), %rsi      # 0xafc0
callq 0x21b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x2290
leaq -0x240(%rbp), %rdi
callq 0x2240
movq $0x0, -0x248(%rbp)
movq $0x0, -0x250(%rbp)
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x2230
movb %al, -0x25d(%rbp)
jmp 0x710e
movb -0x25d(%rbp), %al
testb $0x1, %al
jne 0x711d
jmp 0x725b
jmp 0x711f
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2050
movq %rax, -0x268(%rbp)
jmp 0x713b
movq -0x268(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2230
movb %al, -0x269(%rbp)
jmp 0x7159
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x7168
jmp 0x7259
leaq -0x220(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x2140
movq %rax, -0x278(%rbp)
jmp 0x7184
movq -0x278(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x2140
jmp 0x7199
movq -0x10(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x7c50
jmp 0x71ab
movq -0x18(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x7c50
jmp 0x71bd
movsd -0x248(%rbp), %xmm0
movq 0x3e0c(%rip), %rdi      # 0xafd8
callq 0x2320
movq %rax, -0x280(%rbp)
jmp 0x71da
movq -0x280(%rbp), %rdi
leaq 0x1208(%rip), %rsi      # 0x83f0
callq 0x2180
movq %rax, -0x288(%rbp)
jmp 0x71f6
movq -0x288(%rbp), %rdi
movsd -0x250(%rbp), %xmm0
callq 0x2320
movq %rax, -0x290(%rbp)
jmp 0x7213
movq -0x290(%rbp), %rdi
movq 0x3d9f(%rip), %rsi      # 0xafc0
callq 0x21b0
jmp 0x7228
jmp 0x711f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x20e0
leaq -0x220(%rbp), %rdi
callq 0x2060
jmp 0x72cd
jmp 0x72ac
movq 0x3d76(%rip), %rdi      # 0xafd8
leaq 0x12d9(%rip), %rsi      # 0x8542
callq 0x2180
movq %rax, -0x298(%rbp)
jmp 0x7277
movq -0x298(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2170
movq %rax, -0x2a0(%rbp)
jmp 0x7290
movq -0x2a0(%rbp), %rdi
leaq 0x12cc(%rip), %rsi      # 0x856a
callq 0x2180
jmp 0x72a5
xorl %edi, %edi
callq 0x2210
leaq -0x240(%rbp), %rdi
callq 0x20e0
leaq -0x220(%rbp), %rdi
callq 0x2060
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x258(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x20a0
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x21e0
movl $0x0, -0x21c(%rbp)
movl -0x21c(%rbp), %eax
movq %rax, -0x238(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x238(%rbp), %rax
cmpq %rcx, %rax
jae 0x73fe
movq -0x10(%rbp), %rdi
movl -0x21c(%rbp), %eax
movl %eax, %esi
callq 0x4130
movsd (%rax), %xmm0
leaq -0x218(%rbp), %rdi
callq 0x2320
movq %rax, -0x240(%rbp)
jmp 0x736d
movq -0x240(%rbp), %rdi
leaq 0x1075(%rip), %rsi      # 0x83f0
callq 0x2180
movq %rax, -0x248(%rbp)
jmp 0x7389
movq -0x18(%rbp), %rdi
movl -0x21c(%rbp), %eax
movl %eax, %esi
callq 0x4130
movq -0x248(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2320
movq %rax, -0x250(%rbp)
jmp 0x73b3
movq -0x250(%rbp), %rdi
movq 0x3bff(%rip), %rsi      # 0xafc0
callq 0x21b0
jmp 0x73c8
jmp 0x73ca
movl -0x21c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x21c(%rbp)
jmp 0x731a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2270
jmp 0x7413
leaq -0x218(%rbp), %rdi
callq 0x2270
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x22d0
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x747e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4130
movsd (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x743b
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movsd -0x28(%rbp), %xmm0
movq %rax, %xmm1
movaps 0xb6e(%rip), %xmm2      # 0x8010
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xb72(%rip), %xmm2      # 0x8020
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x752e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x74eb
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movsd -0x28(%rbp), %xmm0
movq %rax, %xmm1
movaps 0xabe(%rip), %xmm2      # 0x8010
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xac2(%rip), %xmm2      # 0x8020
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x76e9
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x76e7
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4130
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4130
movsd -0x68(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4130
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4130
movsd -0x60(%rbp), %xmm2
movsd -0x58(%rbp), %xmm0
subsd (%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4130
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7420
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4130
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7420
movsd -0x48(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
subsd %xmm1, %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x75cd
jmp 0x76fc
movq 0x38e8(%rip), %rdi      # 0xafd8
leaq 0xe79(%rip), %rsi       # 0x8570
callq 0x2180
movsd -0x18(%rbp), %xmm1
divsd -0x20(%rbp), %xmm1
movsd 0x932(%rip), %xmm0      # 0x8040
subsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movl %edi, 0x1c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
movb %al, 0xf(%rsp)
jl 0x2837
cmpl $0x2, 0x1c(%rsp)
setle %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2841
jmp 0x2843
jmp 0x2862
leaq 0xf7e6(%rip), %rdi      # 0x12030
leaq 0xf7f8(%rip), %rsi      # 0x12049
movl $0xf, %edx
leaq 0xf7fa(%rip), %rcx      # 0x12057
callq 0x20d0
movsd 0x20(%rsp), %xmm0
callq 0x28a0
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, 0x1c(%rsp)
jne 0x2891
movsd 0x20(%rsp), %xmm0
callq 0x29d0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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 $0x48, %rsp
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x94e0
leaq 0x14934(%rip), %rax     # 0x171f0
subsd (%rax), %xmm0
callq 0x22d0
movsd %xmm0, 0x38(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x9530
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x9380
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x9530
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x9380
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd 0xf6dd(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x18(%rsp)
movsd 0xf6ca(%rip), %xmm0     # 0x12008
leaq 0x148c3(%rip), %rax     # 0x17208
mulsd (%rax), %xmm0
leaq 0x14878(%rip), %rax     # 0x171c8
mulsd (%rax), %xmm0
leaq 0x14855(%rip), %rax     # 0x171b0
mulsd (%rax), %xmm0
leaq 0x1489a(%rip), %rax     # 0x17200
mulsd (%rax), %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0xf690(%rip), %xmm1     # 0x12008
callq 0x22a0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x20f0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd 0xf64c(%rip), %xmm1     # 0x12008
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movl %edi, 0x1c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
movb %al, 0xf(%rsp)
jl 0x2aa7
cmpl $0x2, 0x1c(%rsp)
setle %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2ab1
jmp 0x2ab3
jmp 0x2ad2
leaq 0xf576(%rip), %rdi      # 0x12030
leaq 0xf588(%rip), %rsi      # 0x12049
movl $0x17, %edx
leaq 0xf5a8(%rip), %rcx      # 0x12075
callq 0x20d0
movsd 0x20(%rsp), %xmm0
callq 0x2b10
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, 0x1c(%rsp)
jne 0x2b01
movsd 0x20(%rsp), %xmm0
callq 0x2c40
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movl %edi, 0x1c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
movb %al, 0xf(%rsp)
jl 0x2d17
cmpl $0x2, 0x1c(%rsp)
setle %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2d21
jmp 0x2d23
jmp 0x2d42
leaq 0xf306(%rip), %rdi      # 0x12030
leaq 0xf318(%rip), %rsi      # 0x12049
movl $0x1f, %edx
leaq 0xf356(%rip), %rcx      # 0x12093
callq 0x20d0
movsd 0x20(%rsp), %xmm0
callq 0x2d80
movsd %xmm0, 0x10(%rsp)
cmpl $0x2, 0x1c(%rsp)
jne 0x2d71
movsd 0x20(%rsp), %xmm0
callq 0x2da0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movl %edi, 0x14(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0x13(%rsp)
jl 0x2f17
cmpl $0x2, 0x14(%rsp)
setle %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x2f21
jmp 0x2f23
jmp 0x2f42
leaq 0xf106(%rip), %rdi      # 0x12030
leaq 0xf118(%rip), %rsi      # 0x12049
movl $0x4b, %edx
leaq 0xf174(%rip), %rcx      # 0x120b1
callq 0x20d0
cmpl $0x2, 0x14(%rsp)
jge 0x2f7a
movsd 0x18(%rsp), %xmm0
callq 0x2b10
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x28a0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x2fb1
movsd 0x18(%rsp), %xmm0
movl $0x2, %edi
callq 0x2a80
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movl $0x2, %edi
callq 0x2810
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movl %edi, 0x14(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0x13(%rsp)
jl 0x2fe7
cmpl $0x2, 0x14(%rsp)
setle %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x2ff1
jmp 0x2ff3
jmp 0x3012
leaq 0xf036(%rip), %rdi      # 0x12030
leaq 0xf048(%rip), %rsi      # 0x12049
movl $0x53, %edx
leaq 0xf0c4(%rip), %rcx      # 0x120d1
callq 0x20d0
cmpl $0x2, 0x14(%rsp)
jge 0x304a
movsd 0x18(%rsp), %xmm0
callq 0x2d80
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x28a0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3081
movsd 0x18(%rsp), %xmm0
movl $0x2, %edi
callq 0x2cf0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movl $0x2, %edi
callq 0x2810
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movl %edi, 0x14(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0x13(%rsp)
jl 0x30b7
cmpl $0x2, 0x14(%rsp)
setle %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x30c1
jmp 0x30c3
jmp 0x30e2
leaq 0xef66(%rip), %rdi      # 0x12030
leaq 0xef78(%rip), %rsi      # 0x12049
movl $0x5b, %edx
leaq 0xf014(%rip), %rcx      # 0x120f1
callq 0x20d0
cmpl $0x2, 0x14(%rsp)
jge 0x311a
movsd 0x18(%rsp), %xmm0
callq 0x2d80
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2b10
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3151
movsd 0x18(%rsp), %xmm0
movl $0x2, %edi
callq 0x2cf0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movl $0x2, %edi
callq 0x2a80
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movl %edi, 0x94(%rsp)
movl %esi, 0x90(%rsp)
movl %edx, 0x8c(%rsp)
movsd %xmm0, 0x80(%rsp)
movsd %xmm1, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x94(%rsp)
movb %al, 0x3b(%rsp)
jl 0x3f7e
cmpl $0x2, 0x94(%rsp)
setle %al
movb %al, 0x3b(%rsp)
movb 0x3b(%rsp), %al
testb $0x1, %al
jne 0x3f88
jmp 0x3f8a
jmp 0x3fa9
leaq 0xe1ee(%rip), %rdi      # 0x1217f
leaq 0xe0b1(%rip), %rsi      # 0x12049
movl $0xa6, %edx
leaq 0xe1f4(%rip), %rcx      # 0x12198
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x90(%rsp)
movb %al, 0x3a(%rsp)
jl 0x3fc8
cmpl $0x2, 0x90(%rsp)
setle %al
movb %al, 0x3a(%rsp)
movb 0x3a(%rsp), %al
testb $0x1, %al
jne 0x3fd2
jmp 0x3fd4
jmp 0x3ff3
leaq 0xe209(%rip), %rdi      # 0x121e4
leaq 0xe067(%rip), %rsi      # 0x12049
movl $0xa7, %edx
leaq 0xe1aa(%rip), %rcx      # 0x12198
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x8c(%rsp)
movb %al, 0x39(%rsp)
jl 0x4012
cmpl $0x2, 0x8c(%rsp)
setle %al
movb %al, 0x39(%rsp)
movb 0x39(%rsp), %al
testb $0x1, %al
jne 0x401c
jmp 0x401e
jmp 0x403d
leaq 0xe1d6(%rip), %rdi      # 0x121fb
leaq 0xe01d(%rip), %rsi      # 0x12049
movl $0xa8, %edx
leaq 0xe160(%rip), %rcx      # 0x12198
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x74(%rsp)
movb %al, 0x38(%rsp)
jl 0x4056
cmpl $0x2, 0x74(%rsp)
setle %al
movb %al, 0x38(%rsp)
movb 0x38(%rsp), %al
testb $0x1, %al
jne 0x4060
jmp 0x4062
jmp 0x4081
leaq 0xdfc7(%rip), %rdi      # 0x12030
leaq 0xdfd9(%rip), %rsi      # 0x12049
movl $0xa9, %edx
leaq 0xe11c(%rip), %rcx      # 0x12198
callq 0x20d0
movsd 0x80(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
movl 0x74(%rsp), %esi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3dd0
movq 0x28(%rsp), %rdi
movslq 0x94(%rsp), %rsi
movslq 0x8c(%rsp), %rdx
callq 0xce30
movq %rax, 0x30(%rsp)
jmp 0x40c4
movq 0x30(%rsp), %rdi
callq 0x46f0
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
jmp 0x40dc
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd %xmm1, 0x48(%rsp)
movsd %xmm0, 0x50(%rsp)
movslq 0x90(%rsp), %rsi
movslq 0x8c(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0xce30
movq %rax, 0x10(%rsp)
jmp 0x4115
movq 0x10(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x46b0
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
jmp 0x4131
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x98(%rsp)
movsd %xmm0, 0xa0(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xce00
movsd 0x98(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm1
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xce00
movq 0x40(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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, %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
movb %al, 0x12793(%rip)      # 0x17198
movb 0x1278d(%rip), %dl      # 0x17198
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x1277b(%rip)     # 0x1719c
cvtsi2sdl 0x12773(%rip), %xmm0 # 0x1719c
movsd 0xd85f(%rip), %xmm1     # 0x12290
mulsd %xmm1, %xmm0
movsd %xmm0, 0x12753(%rip)    # 0x17190
movsd 0x1274b(%rip), %xmm0    # 0x17190
movsd 0xd833(%rip), %xmm1     # 0x12280
subsd %xmm1, %xmm0
movsd %xmm0, 0x127a7(%rip)    # 0x17200
movsd 0xd827(%rip), %xmm0     # 0x12288
divsd 0x12797(%rip), %xmm0    # 0x17200
movsd %xmm0, 0x12797(%rip)    # 0x17208
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x78(%rsp)
movq %rdi, %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0x100(%rsp)
movsd %xmm0, 0xf8(%rsp)
movsd %xmm1, 0xf0(%rsp)
movsd 0xf8(%rsp), %xmm0
callq 0x22d0
movsd %xmm0, 0x70(%rsp)
movsd 0xf8(%rsp), %xmm0
callq 0x2060
movaps %xmm0, %xmm1
movsd 0x70(%rsp), %xmm0
leaq 0xe0(%rsp), %rdi
callq 0x4750
movq 0x78(%rsp), %rdi
movb $0x0, 0xdf(%rsp)
movl $0x3, %edx
movq %rdx, %rsi
callq 0xcaa0
movq 0x78(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x80(%rsp)
jmp 0x4b1b
movq 0x80(%rsp), %rdi
movsd 0xd4ed(%rip), %xmm0     # 0x12018
callq 0x5200
jmp 0x4b32
movsd 0xf0(%rsp), %xmm0
callq 0x22d0
movq 0x78(%rsp), %rdi
movsd %xmm0, 0x58(%rsp)
movl $0x1, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x60(%rsp)
jmp 0x4b5f
movsd 0x58(%rsp), %xmm0
movq 0x60(%rsp), %rdi
callq 0x5200
jmp 0x4b71
movsd 0xf0(%rsp), %xmm0
callq 0x2060
movsd %xmm0, 0xb0(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x5230
movsd %xmm1, 0x48(%rsp)
movsd %xmm0, 0x50(%rsp)
jmp 0x4bab
movq 0x78(%rsp), %rdi
movsd 0x48(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
movsd %xmm1, 0xb8(%rsp)
movsd %xmm0, 0xc0(%rsp)
movl $0x1, %esi
movl $0x2, %edx
callq 0xce30
movq %rax, 0x40(%rsp)
jmp 0x4be4
movq 0x40(%rsp), %rax
movups 0xb8(%rsp), %xmm0
movups %xmm0, (%rax)
movsd 0xf0(%rsp), %xmm0
callq 0x2060
movaps 0xd417(%rip), %xmm1     # 0x12020
pxor %xmm1, %xmm0
movlpd %xmm0, 0x98(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x46f0
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x38(%rsp)
jmp 0x4c31
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd %xmm1, 0x88(%rsp)
movsd %xmm0, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x5230
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x28(%rsp)
jmp 0x4c72
movq 0x78(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd %xmm1, 0xa0(%rsp)
movsd %xmm0, 0xa8(%rsp)
movl $0x2, %esi
movl $0x1, %edx
callq 0xce30
movq %rax, 0x18(%rsp)
jmp 0x4cab
movq 0x18(%rsp), %rax
movups 0xa0(%rsp), %xmm0
movups %xmm0, (%rax)
movsd 0xf0(%rsp), %xmm0
callq 0x22d0
movq 0x78(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movl $0x2, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x10(%rsp)
jmp 0x4ce8
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdi
callq 0x5200
jmp 0x4cfa
movb $0x1, 0xdf(%rsp)
testb $0x1, 0xdf(%rsp)
jne 0x4d38
jmp 0x4d2e
movq 0x78(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
callq 0xce00
jmp 0x4d45
movq 0x78(%rsp), %rdi
callq 0xce00
movq 0x68(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq 0xd0(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movb $0x0, 0x77(%rsp)
movl $0x3, %edx
movq %rdx, %rsi
callq 0xcaa0
movsd 0x78(%rsp), %xmm0
callq 0x22d0
movq 0x48(%rsp), %rdi
movsd %xmm0, 0x50(%rsp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x58(%rsp)
jmp 0x4dbd
movsd 0x50(%rsp), %xmm0
movq 0x58(%rsp), %rdi
callq 0x5200
jmp 0x4dcf
movsd 0x78(%rsp), %xmm0
callq 0x2060
movq 0x48(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xce30
movq %rax, 0x38(%rsp)
jmp 0x4dfa
movsd 0x30(%rsp), %xmm0
movq 0x38(%rsp), %rdi
callq 0x5200
jmp 0x4e0c
movq 0x48(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x28(%rsp)
jmp 0x4e25
movq 0x28(%rsp), %rdi
movsd 0xd1e6(%rip), %xmm0     # 0x12018
callq 0x5200
jmp 0x4e39
movsd 0x78(%rsp), %xmm0
callq 0x2060
movq 0x48(%rsp), %rdi
movaps 0xd1d0(%rip), %xmm1     # 0x12020
pxor %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %esi
callq 0xce30
movq %rax, 0x20(%rsp)
jmp 0x4e6f
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rdi
callq 0x5200
jmp 0x4e81
movsd 0x78(%rsp), %xmm0
callq 0x22d0
movq 0x48(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movl $0x2, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x10(%rsp)
jmp 0x4eab
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdi
callq 0x5200
jmp 0x4ebd
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x4eef
jmp 0x4ee5
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0xce00
jmp 0x4efc
movq 0x48(%rsp), %rdi
callq 0xce00
movq 0x40(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movb $0x0, 0x77(%rsp)
movl $0x3, %edx
movq %rdx, %rsi
callq 0xcaa0
movsd 0x78(%rsp), %xmm0
callq 0x22d0
movq 0x48(%rsp), %rdi
movsd %xmm0, 0x50(%rsp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x58(%rsp)
jmp 0x4f6d
movsd 0x50(%rsp), %xmm0
movq 0x58(%rsp), %rdi
callq 0x5200
jmp 0x4f7f
movsd 0x78(%rsp), %xmm0
callq 0x2060
movq 0x48(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xce30
movq %rax, 0x38(%rsp)
jmp 0x4faa
movsd 0x30(%rsp), %xmm0
movq 0x38(%rsp), %rdi
callq 0x5200
jmp 0x4fbc
movsd 0x78(%rsp), %xmm0
callq 0x2060
movq 0x48(%rsp), %rdi
movaps 0xd04d(%rip), %xmm1     # 0x12020
pxor %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0xce30
movq %rax, 0x28(%rsp)
jmp 0x4ff2
movsd 0x20(%rsp), %xmm0
movq 0x28(%rsp), %rdi
callq 0x5200
jmp 0x5004
movsd 0x78(%rsp), %xmm0
callq 0x22d0
movq 0x48(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movl $0x1, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x18(%rsp)
jmp 0x502e
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rdi
callq 0x5200
jmp 0x5040
movq 0x48(%rsp), %rdi
movl $0x2, %edx
movq %rdx, %rsi
callq 0xce30
movq %rax, 0x8(%rsp)
jmp 0x5059
movq 0x8(%rsp), %rdi
movsd 0xcfb2(%rip), %xmm0     # 0x12018
callq 0x5200
jmp 0x506d
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x509f
jmp 0x5095
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0xce00
jmp 0x50ac
movq 0x48(%rsp), %rdi
callq 0xce00
movq 0x40(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
leaq 0xcf01(%rip), %rax      # 0x122d8
movsd (%rax), %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0xceff(%rip), %xmm1     # 0x122e8
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0xceb6(%rip), %rax      # 0x122b0
movsd (%rax), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x52b0
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0xcea8(%rip), %rax      # 0x122d0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0xcbcf(%rip), %xmm0     # 0x12008
leaq 0x11da0(%rip), %rax     # 0x171e0
mulsd (%rax), %xmm0
callq 0x2060
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x2060
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0xcb8d(%rip), %xmm1     # 0x12008
callq 0x22a0
movaps %xmm0, %xmm1
movsd 0xcb8d(%rip), %xmm0     # 0x12018
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xcb6b(%rip), %xmm0     # 0x12008
leaq 0x11d4c(%rip), %rax     # 0x171f0
mulsd (%rax), %xmm0
callq 0x2060
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2060
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0xcb35(%rip), %xmm1     # 0x12008
callq 0x22a0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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 $0x68, %rsp
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x5a40
movsd 0xc26b(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x8(%rsp)
callq 0x5be0
movsd %xmm0, 0x10(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x5a40
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x5c40
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x5b20
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x5b60
movsd %xmm0, 0x40(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x59f0
movsd 0xc199(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x28(%rsp)
callq 0x5be0
movsd %xmm0, 0x30(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x59f0
movsd 0x28(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x30(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
callq 0x5c40
movsd 0x38(%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x40(%rsp), %xmm0
addsd %xmm1, %xmm2
movsd 0x58(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x50(%rsp), %xmm0
divsd 0x48(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movsd %xmm0, 0x80(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd 0x80(%rsp), %xmm0
callq 0x5c70
movsd %xmm0, 0x70(%rsp)
movsd 0x80(%rsp), %xmm0
callq 0x5d30
movsd %xmm0, 0x68(%rsp)
movsd 0x70(%rsp), %xmm0
movsd 0xbb3c(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x8(%rsp)
leaq 0xbdc2(%rip), %rax      # 0x122a0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x68(%rsp), %xmm0
movsd 0xbb13(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd (%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xbdb9(%rip), %rax      # 0x122c8
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0xbadf(%rip), %xmm0     # 0x12008
mulsd 0x70(%rsp), %xmm0
mulsd 0x68(%rsp), %xmm0
leaq 0x10c94(%rip), %rax     # 0x171d0
mulsd (%rax), %xmm0
leaq 0x10c71(%rip), %rax     # 0x171b8
mulsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x78(%rsp), %xmm0
callq 0x22d0
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x70(%rsp), %xmm0
movsd 0xba81(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x28(%rsp)
leaq 0xbd2f(%rip), %rax      # 0x122c8
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x68(%rsp), %xmm0
movsd 0xba57(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd 0x20(%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
leaq 0xbcd4(%rip), %rax      # 0x122a0
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0xba22(%rip), %xmm0     # 0x12008
mulsd 0x70(%rsp), %xmm0
mulsd 0x68(%rsp), %xmm0
leaq 0x10bd7(%rip), %rax     # 0x171d0
mulsd (%rax), %xmm0
leaq 0x10bb4(%rip), %rax     # 0x171b8
mulsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x78(%rsp), %xmm0
callq 0x22d0
movsd 0x30(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x38(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x70(%rsp), %xmm0
movsd 0xb9ad(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x40(%rsp)
movsd 0x68(%rsp), %xmm0
movsd 0xb994(%rip), %xmm1     # 0x12008
callq 0x22a0
movaps %xmm0, %xmm1
movsd 0x40(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x78(%rsp), %xmm0
callq 0x2060
movaps %xmm0, %xmm1
movsd 0x48(%rsp), %xmm0
mulsd %xmm1, %xmm0
leaq 0x10b0d(%rip), %rax     # 0x171b8
mulsd (%rax), %xmm0
leaq 0x10b1a(%rip), %rax     # 0x171d0
mulsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x60(%rsp), %xmm0
mulsd 0x58(%rsp), %xmm0
callq 0x20f0
movaps %xmm0, %xmm1
movsd 0x50(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/Exact.cpp
// Function: Exact::Talphabetai(int, int, int, double, double)
std::complex<double> Talphabetai(int alpha, int beta, int i, double a, double delta)
{
	assert (alpha >= 0 && alpha <= 2); // alpha valid for 0, 1, 2
	assert (beta >= 0 && beta <= 2); // beta valid for 0, 1, 2
	assert (i >= 0 && i <= 2); // i valid for 0, 1, 2

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

// Assembly:
subq $0xa8, %rsp
movl %edi, 0x94(%rsp)
movl %esi, 0x90(%rsp)
movl %edx, 0x8c(%rsp)
movsd %xmm0, 0x80(%rsp)
movsd %xmm1, 0x78(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x94(%rsp)
movb %al, 0x43(%rsp)
jl 0x6a5a
cmpl $0x2, 0x94(%rsp)
setle %al
movb %al, 0x43(%rsp)
movb 0x43(%rsp), %al
testb $0x1, %al
jne 0x6a64
jmp 0x6a66
jmp 0x6a85
leaq 0xb712(%rip), %rdi      # 0x1217f
leaq 0xb8ac(%rip), %rsi      # 0x12320
movl $0xc9, %edx
leaq 0xb8ae(%rip), %rcx      # 0x1232e
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x90(%rsp)
movb %al, 0x42(%rsp)
jl 0x6aa4
cmpl $0x2, 0x90(%rsp)
setle %al
movb %al, 0x42(%rsp)
movb 0x42(%rsp), %al
testb $0x1, %al
jne 0x6aae
jmp 0x6ab0
jmp 0x6acf
leaq 0xb72d(%rip), %rdi      # 0x121e4
leaq 0xb862(%rip), %rsi      # 0x12320
movl $0xca, %edx
leaq 0xb864(%rip), %rcx      # 0x1232e
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x8c(%rsp)
movb %al, 0x41(%rsp)
jl 0x6aee
cmpl $0x2, 0x8c(%rsp)
setle %al
movb %al, 0x41(%rsp)
movb 0x41(%rsp), %al
testb $0x1, %al
jne 0x6af8
jmp 0x6afa
jmp 0x6b19
leaq 0xb6fa(%rip), %rdi      # 0x121fb
leaq 0xb818(%rip), %rsi      # 0x12320
movl $0xcb, %edx
leaq 0xb81a(%rip), %rcx      # 0x1232e
callq 0x20d0
movsd 0x80(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
leaq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x66f0
movq 0x30(%rsp), %rdi
movslq 0x94(%rsp), %rsi
movslq 0x8c(%rsp), %rdx
callq 0xce30
movq %rax, 0x38(%rsp)
jmp 0x6b58
movq 0x38(%rsp), %rdi
callq 0x46f0
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x28(%rsp)
jmp 0x6b70
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd %xmm1, 0x50(%rsp)
movsd %xmm0, 0x58(%rsp)
movslq 0x90(%rsp), %rsi
movslq 0x8c(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0xce30
movq %rax, 0x18(%rsp)
jmp 0x6ba9
movq 0x18(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x46b0
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
jmp 0x6bc6
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x98(%rsp)
movsd %xmm0, 0xa0(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xce00
movsd 0x98(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm1
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xce00
movq 0x48(%rsp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/Experiment.cpp
// Function: set_experimental_parameters(int, double*, double*)
void set_experimental_parameters(int exp_num, double *Yrho, double *L)
{
	assert (exp_num >= 0 && exp_num <= 2); // 0: DUNE, 1: NOvA, 2: T2K/T2HK
	switch (exp_num)
	{
		case 0: // DUNE
			*Yrho = 1.4; // YrhoE over E
			*L = 1300;
			break;
		case 1: // NOvA
			*Yrho = 1.4; // YrhoE over E
			*L = 810;
			break;
		case 2: // T2K/T2HK
			*Yrho = 1.15; // YrhoE over E
			*L = 295;
			break;
	}
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x24(%rsp)
movb %al, 0xf(%rsp)
jl 0x6feb
cmpl $0x2, 0x24(%rsp)
setle %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x6ff5
jmp 0x6ff7
jmp 0x7016
leaq 0xb3da(%rip), %rdi      # 0x123d8
leaq 0xb3f0(%rip), %rsi      # 0x123f5
movl $0xf, %edx
leaq 0xb3f7(%rip), %rcx      # 0x12408
callq 0x20d0
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x703a
jmp 0x7024
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x705e
jmp 0x702f
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x7082
jmp 0x70a4
movq 0x18(%rsp), %rax
movsd 0xb381(%rip), %xmm0     # 0x123c8
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movsd 0xb378(%rip), %xmm0     # 0x123d0
movsd %xmm0, (%rax)
jmp 0x70a4
movq 0x18(%rsp), %rax
movsd 0xb35d(%rip), %xmm0     # 0x123c8
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movsd 0xb344(%rip), %xmm0     # 0x123c0
movsd %xmm0, (%rax)
jmp 0x70a4
movq 0x18(%rsp), %rax
movsd 0xb329(%rip), %xmm0     # 0x123b8
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movsd 0xb310(%rip), %xmm0     # 0x123b0
movsd %xmm0, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/First_Peak.cpp
// Function: PL(double, double const*)
double PL(double L, const double * p)
{
	int alpha = p[0];
	int beta = p[1];
	double E = p[2];
	double Yrho = p[3];
	double delta = p[4];
	int sign = p[5];
	return sign * Exact::Palphabeta(alpha, beta, Yrho * E * Y_to_a, L / E, delta);
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
cvttsd2si (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rax
cvttsd2si 0x28(%rax), %eax
movl %eax, 0x14(%rsp)
cvtsi2sdl 0x14(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x34(%rsp), %edi
movl 0x30(%rsp), %esi
movsd 0x20(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
leaq 0xb1a1(%rip), %rax      # 0x122e0
mulsd (%rax), %xmm0
movsd 0x40(%rsp), %xmm1
divsd 0x28(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x6c30
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/First_Peak.cpp
// Function: First_Extremum_Exact(int, int, double, double, double, bool)
double First_Extremum_Exact(int alpha, int beta, double E, double Yrho, double delta, bool max)
{
	double L_range_min, L_range_max;
	double p[6];
	p[0] = alpha;
	p[1] = beta;
	p[2] = E;
	p[3] = Yrho;
	p[4] = delta;
	p[5] = (alpha == beta) ? 1 : -1;
	p[5] *= (max) ? 1 : -1; // switch sign for max/min

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

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

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
movsd %xmm2, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
cvtsi2sdl 0x64(%rsp), %xmm0
movsd %xmm0, (%rsp)
cvtsi2sdl 0x60(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x64(%rsp), %edx
movl 0x60(%rsp), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x28(%rsp)
movb 0x47(%rsp), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
testb $0x1, 0x47(%rsp)
je 0x7247
movsd 0xb23b(%rip), %xmm0     # 0x12460
mulsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0xb21f(%rip), %xmm0     # 0x12458
mulsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x726f
movsd 0xb201(%rip), %xmm0     # 0x12450
mulsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0xb1e5(%rip), %xmm0     # 0x12448
mulsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0xff1d(%rip), %xmm2     # 0x171a0
movq %rsp, %rsi
leaq -0x1dd(%rip), %rdi      # 0x70b0
callq 0xdce0
callq 0x7490
addq $0x68, %rsp
retq
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/First_Peak.cpp
// Function: FEE_x(double, double const*)
double FEE_x(double E, const double *p)
{
	int alpha = p[0];
	int beta = p[1];
	double Yrho = p[2];
	double delta = p[3];
	bool max = p[4] > 0;

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

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cvttsd2si (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rax
movsd 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
movsd 0x30(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x7170
divsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)