LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: PeterDenton[P]Nu-Pert/src/First_Peak.cpp
// Function: FP_line(int, int, double, double, bool, double*, double*)
void FP_line(int alpha, int beta, double Yrho, double delta, bool max, double *m, double *b)
{
	double p[5];
	p[0] = alpha;
	p[1] = beta;
	p[2] = Yrho;
	p[3] = delta;
	p[4] = 1; // look for a max

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

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
cvtsi2sdl 0x64(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
cvtsi2sdl 0x60(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0xabd6(%rip), %xmm0     # 0x12018
movsd %xmm0, 0x30(%rsp)
leaq 0x10(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
leaq -0x1be(%rip), %rdi      # 0x72a0
leaq -0x125(%rip), %rsi      # 0x7340
movsd 0xaffb(%rip), %xmm0     # 0x12468
movsd 0xaffb(%rip), %xmm1     # 0x12470
movl $0x64, %edx
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
callq 0xc700
addq $0x68, %rsp
retq
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::C21(int, int, double, double, int)
double C21(int alpha, int Beta, double a, double delta, int order)
{
	assert (order >= 0 && order <= 1); // order valid for 0, 1
	double C210 = -ReUm4(a, delta, alpha, Beta, 1, 1, 0, 0);
	double C1 = epsp(a) * Dmsqee;
	double F1 = GF::F1(alpha, Beta, a, delta);
	double F2 = GF::F2(alpha, Beta, a, delta);
	double Dl31 = Check::Dl31(a, order);
	double Dl32 = Check::Dl32(a, order);
	double C211 = C1 * (F1 / Dl31 + F2 / Dl32);
	return C210 + order * C211;
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x4c(%rsp)
movb %al, 0xf(%rsp)
jl 0x8405
cmpl $0x1, 0x4c(%rsp)
setle %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x840f
jmp 0x8411
jmp 0x8430
leaq 0xa116(%rip), %rdi      # 0x1252e
leaq 0xa081(%rip), %rsi      # 0x124a0
movl $0x3d, %edx
leaq 0xa11c(%rip), %rcx      # 0x12547
callq 0x20d0
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movl $0x1, %ecx
xorl %r9d, %r9d
movl %ecx, %edx
movl %r9d, %r8d
callq 0x74b0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x58(%rsp), %xmm0
callq 0x4990
leaq 0xed7b(%rip), %rax      # 0x17200
mulsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0x78b0
movsd %xmm0, 0x30(%rsp)
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0x7980
movsd %xmm0, 0x28(%rsp)
movsd 0x58(%rsp), %xmm0
movl 0x4c(%rsp), %edi
callq 0x2fc0
movsd %xmm0, 0x20(%rsp)
movsd 0x58(%rsp), %xmm0
movl 0x4c(%rsp), %edi
callq 0x3090
movsd %xmm0, 0x18(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
divsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
divsd 0x18(%rsp), %xmm2
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm1
cvtsi2sdl 0x4c(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::C31(int, int, double, double, int)
double C31(int alpha, int Beta, double a, double delta, int order)
{
	assert (order >= 0 && order <= 1); // order valid for 0, 1
	double C310 = -ReUm4(a, delta, alpha, Beta, 2, 2, 0, 0);
	double C1 = epsp(a) * Dmsqee;
	double F1 = GF::F1(alpha, Beta, a, delta);
	double F2 = GF::F2(alpha, Beta, a, delta);
	double G1 = GF::G1(alpha, Beta, a, delta);
	double Dl31 = Check::Dl31(a, order);
	double Dl32 = Check::Dl32(a, order);
	double C311 = C1 * ((F1 + G1) / Dl31 - F2 / Dl32);
	return C310 + order * C311;
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x4c(%rsp)
movb %al, 0x7(%rsp)
jl 0x8585
cmpl $0x1, 0x4c(%rsp)
setle %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x858f
jmp 0x8591
jmp 0x85b0
leaq 0x9f96(%rip), %rdi      # 0x1252e
leaq 0x9f01(%rip), %rsi      # 0x124a0
movl $0x4a, %edx
leaq 0x9fca(%rip), %rcx      # 0x12575
callq 0x20d0
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movl $0x2, %ecx
xorl %r9d, %r9d
movl %ecx, %edx
movl %r9d, %r8d
callq 0x74b0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x58(%rsp), %xmm0
callq 0x4990
leaq 0xebfb(%rip), %rax      # 0x17200
mulsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0x78b0
movsd %xmm0, 0x30(%rsp)
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0x7980
movsd %xmm0, 0x28(%rsp)
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0x7a30
movsd %xmm0, 0x20(%rsp)
movsd 0x58(%rsp), %xmm0
movl 0x4c(%rsp), %edi
callq 0x2fc0
movsd %xmm0, 0x18(%rsp)
movsd 0x58(%rsp), %xmm0
movl 0x4c(%rsp), %edi
callq 0x3090
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
addsd 0x20(%rsp), %xmm1
divsd 0x18(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
divsd 0x10(%rsp), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rsp), %xmm1
cvtsi2sdl 0x4c(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/GF.cpp
// Function: GF::C32(int, int, double, double, int)
double C32(int alpha, int Beta, double a, double delta, int order)
{
	assert (order >= 0 && order <= 1); // order valid for 0, 1
	double C320 = -ReUm4(a, delta, alpha, Beta, 2, 2, 1, 1);
	double C1 = epsp(a) * Dmsqee;
	double F1 = GF::F1(alpha, Beta, a, delta);
	double F2 = GF::F2(alpha, Beta, a, delta);
	double G2 = GF::G2(alpha, Beta, a, delta);
	double Dl31 = Check::Dl31(a, order);
	double Dl32 = Check::Dl32(a, order);
	double C321 = C1 * (-F1 / Dl31 + (F2 + G2) / Dl32);
	return C320 + order * C321;
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x4c(%rsp)
movb %al, 0x7(%rsp)
jl 0x8725
cmpl $0x1, 0x4c(%rsp)
setle %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x872f
jmp 0x8731
jmp 0x8750
leaq 0x9df6(%rip), %rdi      # 0x1252e
leaq 0x9d61(%rip), %rsi      # 0x124a0
movl $0x58, %edx
leaq 0x9e58(%rip), %rcx      # 0x125a3
callq 0x20d0
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movl $0x2, %ecx
movl $0x1, %r9d
movl %ecx, %edx
movl %r9d, %r8d
callq 0x74b0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x58(%rsp), %xmm0
callq 0x4990
leaq 0xea58(%rip), %rax      # 0x17200
mulsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0x78b0
movsd %xmm0, 0x30(%rsp)
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0x7980
movsd %xmm0, 0x28(%rsp)
movl 0x64(%rsp), %edi
movl 0x60(%rsp), %esi
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
callq 0x7f00
movsd %xmm0, 0x20(%rsp)
movsd 0x58(%rsp), %xmm0
movl 0x4c(%rsp), %edi
callq 0x2fc0
movsd %xmm0, 0x18(%rsp)
movsd 0x58(%rsp), %xmm0
movl 0x4c(%rsp), %edi
callq 0x3090
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
divsd 0x18(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
addsd 0x20(%rsp), %xmm2
divsd 0x10(%rsp), %xmm2
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rsp), %xmm1
cvtsi2sdl 0x4c(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/Hat.cpp
// Function: Hat::lp(double)
double lp(double a)
{
	double x = Dmsqee + a;
	double y = normal_sign * sqrt(pow(Dmsqee - a, 2) + 4 * s13sq * a * Dmsqee);
	double z = eps * Dmsqee * s12sq;
	return (x + y) / 2. + z;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
leaq 0xdf4f(%rip), %rax      # 0x17200
movsd (%rax), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0xded4(%rip), %rax      # 0x1719c
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0xdf28(%rip), %rax      # 0x17200
movsd (%rax), %xmm0
subsd 0x20(%rsp), %xmm0
movsd 0x8d1e(%rip), %xmm1     # 0x12008
callq 0x22a0
movaps %xmm0, %xmm1
movsd 0x8fee(%rip), %xmm0     # 0x122e8
leaq 0x8fa7(%rip), %rax      # 0x122a8
mulsd (%rax), %xmm0
mulsd 0x20(%rsp), %xmm0
leaq 0xdeee(%rip), %rax      # 0x17200
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x20f0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0xdecc(%rip), %rax      # 0x17208
movsd (%rax), %xmm0
leaq 0xdeb9(%rip), %rax      # 0x17200
mulsd (%rax), %xmm0
leaq 0x8f46(%rip), %rax      # 0x12298
mulsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd 0x8c98(%rip), %xmm1     # 0x12008
divsd %xmm1, %xmm0
addsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: PeterDenton[P]Nu-Pert/src/Hat.cpp
// Function: Hat::Pee(double, double)
double Pee(double a, double LE)
{
	double L4E = km_per_GeV_to_per_eV2 * LE / 4; // in eV^-2 now
	double Deltapm = (lp(a) - lm(a)) * L4E;
	double P = 1 - pow(s2phi(a) * sin(Deltapm), 2);
	ProbabilityWarning W(&P);
	return P;
}

// Assembly:
subq $0x88, %rsp
movsd %xmm0, 0x80(%rsp)
movsd %xmm1, 0x78(%rsp)
leaq 0x8c9b(%rip), %rax      # 0x122d8
movsd (%rax), %xmm0
mulsd 0x78(%rsp), %xmm0
movsd 0x8c99(%rip), %xmm1     # 0x122e8
divsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x80(%rsp), %xmm0
callq 0x92a0
movsd %xmm0, (%rsp)
movsd 0x80(%rsp), %xmm0
callq 0x9380
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movsd 0x80(%rsp), %xmm0
callq 0x9460
movsd %xmm0, 0x8(%rsp)
movsd 0x68(%rsp), %xmm0
callq 0x2060
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x8942(%rip), %xmm1     # 0x12008
callq 0x22a0
movaps %xmm0, %xmm1
movsd 0x8942(%rip), %xmm0     # 0x12018
subsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x110a0
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x47e0
movsd 0x10(%rsp), %xmm0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/Hat.cpp
// Function: Hat::Talphabetai(int, int, int, double, double, int)
std::complex<double> Talphabetai(int alpha, int beta, int i, double a, double delta, int order)
{
	assert (alpha >= 0 && alpha <= 2); // alpha valid for 0, 1, 2
	assert (beta >= 0 && beta <= 2); // beta valid for 0, 1, 2
	assert (i >= 0 && i <= 2); // i valid for 0, 1, 2
	assert (order >= 0 && order <= 1); // order valid for 0, 1

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

// Assembly:
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 0xa13e
cmpl $0x2, 0x94(%rsp)
setle %al
movb %al, 0x3b(%rsp)
movb 0x3b(%rsp), %al
testb $0x1, %al
jne 0xa148
jmp 0xa14a
jmp 0xa169
leaq 0x802e(%rip), %rdi      # 0x1217f
leaq 0x84e2(%rip), %rsi      # 0x1263a
movl $0x81, %edx
leaq 0x854c(%rip), %rcx      # 0x126b0
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x90(%rsp)
movb %al, 0x3a(%rsp)
jl 0xa188
cmpl $0x2, 0x90(%rsp)
setle %al
movb %al, 0x3a(%rsp)
movb 0x3a(%rsp), %al
testb $0x1, %al
jne 0xa192
jmp 0xa194
jmp 0xa1b3
leaq 0x8049(%rip), %rdi      # 0x121e4
leaq 0x8498(%rip), %rsi      # 0x1263a
movl $0x82, %edx
leaq 0x8502(%rip), %rcx      # 0x126b0
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x8c(%rsp)
movb %al, 0x39(%rsp)
jl 0xa1d2
cmpl $0x2, 0x8c(%rsp)
setle %al
movb %al, 0x39(%rsp)
movb 0x39(%rsp), %al
testb $0x1, %al
jne 0xa1dc
jmp 0xa1de
jmp 0xa1fd
leaq 0x8016(%rip), %rdi      # 0x121fb
leaq 0x844e(%rip), %rsi      # 0x1263a
movl $0x83, %edx
leaq 0x84b8(%rip), %rcx      # 0x126b0
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x74(%rsp)
movb %al, 0x38(%rsp)
jl 0xa216
cmpl $0x1, 0x74(%rsp)
setle %al
movb %al, 0x38(%rsp)
movb 0x38(%rsp), %al
testb $0x1, %al
jne 0xa220
jmp 0xa222
jmp 0xa241
leaq 0x8305(%rip), %rdi      # 0x1252e
leaq 0x840a(%rip), %rsi      # 0x1263a
movl $0x84, %edx
leaq 0x8474(%rip), %rcx      # 0x126b0
callq 0x20d0
movsd 0x80(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
movl 0x74(%rsp), %esi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x9f90
movq 0x28(%rsp), %rdi
movslq 0x94(%rsp), %rsi
movslq 0x8c(%rsp), %rdx
callq 0xce30
movq %rax, 0x30(%rsp)
jmp 0xa284
movq 0x30(%rsp), %rdi
callq 0x46f0
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
jmp 0xa29c
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 0xa2d5
movq 0x10(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x46b0
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
jmp 0xa2f1
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/Hyperbolas.cpp
// Function: Hyperbolas::l2(double)
double l2(double a)
{
	double ax = cos(2 * t12) * eps * Dmsqee;
	double ax12 = lb - la(0);
	double ax13 = lc - la(0);
	double atr = (ax13 - ax12) / 2.; // ansatz that simple average is right, perhaps weighted average by the X's is better

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

}

// Assembly:
subq $0x68, %rsp
movsd %xmm0, 0x58(%rsp)
movsd 0x76b6(%rip), %xmm0     # 0x12008
leaq 0xc887(%rip), %rax      # 0x171e0
mulsd (%rax), %xmm0
callq 0x22d0
leaq 0xc89f(%rip), %rax      # 0x17208
mulsd (%rax), %xmm0
leaq 0xc88c(%rip), %rax      # 0x17200
mulsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0xc892(%rip), %xmm0     # 0x17218
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
callq 0xa7e0
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0xc871(%rip), %xmm0     # 0x17220
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
callq 0xa7e0
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
subsd 0x48(%rsp), %xmm0
movsd 0x7624(%rip), %xmm1     # 0x12008
divsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x58(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xaa8f
movsd 0x58(%rsp), %xmm0
subsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x58(%rsp), %xmm0
subsd 0x50(%rsp), %xmm0
movsd 0x75de(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x18(%rsp)
movsd 0x58(%rsp), %xmm0
callq 0xa830
movsd 0x75c0(%rip), %xmm1     # 0x12008
callq 0x22a0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
callq 0x20f0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd 0xc7a4(%rip), %xmm1     # 0x17218
movsd 0x7cbc(%rip), %xmm2     # 0x12738
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rsp)
jmp 0xab11
movsd 0x58(%rsp), %xmm0
callq 0xa7e0
addsd 0xc77e(%rip), %xmm0     # 0x17220
movsd %xmm0, 0x10(%rsp)
movsd 0x58(%rsp), %xmm0
callq 0xa7e0
subsd 0xc765(%rip), %xmm0     # 0x17220
movsd 0x7545(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x8(%rsp)
movsd 0xc752(%rip), %xmm0     # 0x17228
movsd 0x752a(%rip), %xmm1     # 0x12008
callq 0x22a0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
callq 0x20f0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x7c31(%rip), %xmm0     # 0x12738
mulsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/Hyperbolas.cpp
// Function: Hyperbolas::s12msq(double)
double s12msq(double D)
{
	double x = (pow(Hyperbolas::l2(D), 2) - alpha() * Hyperbolas::l2(D) + beta()) * Hyperbolas::Dl31(D);
	double s12msq_n = -x;
	double s12msq_d = Hyperbolas::Dl32(D) * (pow(Hyperbolas::l1(D), 2) - alpha() * Hyperbolas::l1(D) + beta()) - x;
	return s12msq_n / s12msq_d;
}

// Assembly:
subq $0x68, %rsp
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0xa940
movsd 0x71db(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x8(%rsp)
callq 0xac70
movsd %xmm0, 0x10(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0xa940
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 0xacd0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0xabf0
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 0xac30
movsd %xmm0, 0x40(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0xa870
movsd 0x7109(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x28(%rsp)
callq 0xac70
movsd %xmm0, 0x30(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0xa870
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 0xacd0
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/Matrix.cpp
// Function: Matrix<std::complex<double>>::operator=(Matrix<std::complex<double>>)
Matrix<T> Matrix<T>::operator = (const Matrix other)
{
	rows = other.rows;
	cols = other.cols;
	buffer = new T[rows * cols];
	std::copy(other.buffer, other.buffer + rows * cols, buffer);
	return *this;
}

// Assembly:
subq $0x78, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq (%rdx), %rax
movq %rax, (%rcx)
movq 0x8(%rdx), %rax
movq %rax, 0x8(%rcx)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movq %rax, 0x40(%rsp)
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x48(%rsp)
cmpq $0x0, %rax
je 0xd0eb
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rdx
shlq $0x4, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x4750
jmp 0xd0d3
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0xd0bc
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rdi
movq 0x10(%rcx), %rsi
movq (%rax), %rcx
imulq 0x8(%rax), %rcx
shlq $0x4, %rcx
addq %rcx, %rsi
movq 0x10(%rax), %rdx
callq 0xcdb0
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xcc80
movq 0x30(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x21d0
movq 0x58(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::operator+=(Matrix<std::complex<double>>)
Matrix<T> Matrix<T>::operator += (const Matrix other)
{
	assert(rows == other.rows);
	assert(cols == other.cols);

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

// Assembly:
subq $0x48, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rax), %rax
cmpq (%rdx), %rax
jne 0xd199
jmp 0xd1b8
leaq 0x574e(%rip), %rdi      # 0x128ee
leaq 0x5659(%rip), %rsi      # 0x12800
movl $0x40, %edx
leaq 0x574e(%rip), %rcx      # 0x12901
callq 0x20d0
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
jne 0xd1ce
jmp 0xd1ed
leaq 0x578b(%rip), %rdi      # 0x12960
leaq 0x5624(%rip), %rsi      # 0x12800
movl $0x41, %edx
leaq 0x5719(%rip), %rcx      # 0x12901
callq 0x20d0
movq $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rax
movq (%rdx), %rcx
imulq 0x8(%rdx), %rcx
cmpq %rcx, %rax
jae 0xd24c
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x28(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rsi
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x4780
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xd1f6
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0xcc80
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::operator+(Matrix<std::complex<double>>) const
Matrix<T> Matrix<T>::operator + (const Matrix other) const
{
	assert(rows == other.rows);
	assert(cols == other.cols);

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

// Assembly:
subq $0x78, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%rax), %rax
cmpq (%rdx), %rax
jne 0xd2a9
jmp 0xd2c8
leaq 0x563e(%rip), %rdi      # 0x128ee
leaq 0x5549(%rip), %rsi      # 0x12800
movl $0x4b, %edx
leaq 0x56b0(%rip), %rcx      # 0x12973
callq 0x20d0
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
jne 0xd2de
jmp 0xd2fd
leaq 0x567b(%rip), %rdi      # 0x12960
leaq 0x5514(%rip), %rsi      # 0x12800
movl $0x4c, %edx
leaq 0x567b(%rip), %rcx      # 0x12973
callq 0x20d0
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movb $0x0, 0x5f(%rsp)
movq 0x8(%rax), %rsi
movq (%rax), %rdx
callq 0xcaa0
movq $0x0, 0x50(%rsp)
movq 0x28(%rsp), %rdx
movq 0x50(%rsp), %rax
movq (%rdx), %rcx
imulq 0x8(%rdx), %rcx
cmpq %rcx, %rax
jae 0xd3d9
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x50(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x10(%rcx), %rsi
addq %rax, %rsi
callq 0x9150
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
jmp 0xd36f
movq 0x18(%rsp), %rax
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x40(%rsp)
movsd %xmm0, 0x48(%rsp)
movq 0x10(%rax), %rax
movq 0x50(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0xd321
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xce00
jmp 0xd3f9
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0xd3ef
movq 0x18(%rsp), %rdi
callq 0xce00
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::operator*(Matrix<std::complex<double>>) const
Matrix<T> Matrix<T>::operator * (const Matrix rhs) const
{
	assert(cols == rhs.rows);

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

	return ret;
}

// Assembly:
subq $0xb8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rax), %rax
cmpq (%rdx), %rax
jne 0xd459
jmp 0xd478
leaq 0x5577(%rip), %rdi      # 0x129d7
leaq 0x5399(%rip), %rsi      # 0x12800
movl $0x57, %edx
leaq 0x5575(%rip), %rcx      # 0x129e8
callq 0x20d0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movb $0x0, 0x9f(%rsp)
movq (%rcx), %rsi
movq 0x8(%rax), %rdx
callq 0xcaa0
movq $0x0, 0x90(%rsp)
movq 0x38(%rsp), %rcx
movq 0x90(%rsp), %rax
cmpq (%rcx), %rax
jae 0xd62f
movq $0x0, 0x88(%rsp)
movq 0x20(%rsp), %rcx
movq 0x88(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0xd614
movq $0x0, 0x80(%rsp)
movq 0x38(%rsp), %rcx
movq 0x80(%rsp), %rax
cmpq (%rcx), %rax
jae 0xd5f9
movq 0x38(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0xd670
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
jmp 0xd52a
movq 0x20(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd %xmm1, 0x60(%rsp)
movsd %xmm0, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0xcf20
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x48(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x46b0
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
jmp 0xd584
movq 0x28(%rsp), %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x70(%rsp)
movsd %xmm0, 0x78(%rsp)
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0xce30
movq %rax, %rdi
leaq 0x70(%rsp), %rsi
callq 0x4780
jmp 0xd5c4
jmp 0xd5c6
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0xd4ec
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0xce00
jmp 0xd658
jmp 0xd5fb
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
jmp 0xd4c9
jmp 0xd616
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0xd4a7
movb $0x1, 0x9f(%rsp)
testb $0x1, 0x9f(%rsp)
jne 0xd64b
movq 0x28(%rsp), %rdi
callq 0xce00
movq 0x30(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::Transpose()
void Matrix<T>::Transpose()
{
	T * tmp = new T[rows * cols];
	std::copy(buffer, buffer + rows * cols, tmp);

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

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movq %rax, 0x48(%rsp)
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x50(%rsp)
cmpq $0x0, %rax
je 0xd81a
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rdx
shlq $0x4, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x28(%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x4750
jmp 0xd802
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, 0x38(%rsp)
jne 0xd7eb
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x10(%rcx), %rdi
movq 0x10(%rcx), %rsi
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq 0x78(%rsp), %rdx
callq 0xcdb0
movq $0x0, 0x60(%rsp)
movq 0x40(%rsp), %rcx
movq 0x60(%rsp), %rax
cmpq (%rcx), %rax
jae 0xd936
movq $0x0, 0x58(%rsp)
movq 0x40(%rsp), %rcx
movq 0x58(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0xd921
movq 0x40(%rsp), %rdi
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xca70
movq 0x40(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xca70
movq 0x18(%rsp), %rcx
movq %rax, %rdx
movq 0x20(%rsp), %rax
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xd86f
movq 0x50(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0x21d0
jmp 0xd958
jmp 0xd923
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0xd853
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xd950
movq 0x8(%rsp), %rdi
callq 0x21d0
addq $0x88, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/Matrix.cpp
// Function: Matrix<std::complex<double>>::Hermitian()
void Matrix<T>::Hermitian()
{
	T * tmp = new T[rows * cols];
	std::copy(buffer, buffer + rows * cols, tmp);

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

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movq %rax, 0x38(%rsp)
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x40(%rsp)
cmpq $0x0, %rax
je 0xda1a
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rdx
shlq $0x4, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x4750
jmp 0xda02
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0xd9eb
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x10(%rcx), %rdi
movq 0x10(%rcx), %rsi
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq 0x78(%rsp), %rdx
callq 0xcdb0
movq $0x0, 0x60(%rsp)
movq 0x30(%rsp), %rcx
movq 0x60(%rsp), %rax
cmpq (%rcx), %rax
jae 0xdb3d
movq $0x0, 0x58(%rsp)
movq 0x30(%rsp), %rcx
movq 0x58(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0xdb28
movq 0x30(%rsp), %rdi
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xca70
movq 0x8(%rsp), %rdi
shlq $0x4, %rax
addq %rax, %rdi
callq 0x46f0
movq 0x30(%rsp), %rdi
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x50(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xca70
movq %rax, %rcx
movq 0x10(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x48(%rsp), %rcx
movq %rcx, (%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xda6f
movq 0x40(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0x21d0
jmp 0xdb5d
jmp 0xdb2a
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0xda53
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xdb55
movq (%rsp), %rdi
callq 0x21d0
addq $0x88, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/Mixed.cpp
// Function: Mixed::s12msq(double, int)
double s12msq(double D, int order)
{
	double x = (pow(Check::l2(D, order), 2) - alpha() * Check::l2(D, order) + beta()) * Check::Dl31(D, order);
	double s12msq_n = -x;
	double s12msq_d = Check::Dl32(D, order) * (pow(Check::l1(D, order), 2) - alpha() * Check::l1(D, order) + beta()) - x;
	return s12msq_n / s12msq_d;
}

// Assembly:
subq $0x68, %rsp
movsd %xmm0, 0x60(%rsp)
movl %edi, 0x5c(%rsp)
movsd 0x60(%rsp), %xmm0
movl 0x5c(%rsp), %edi
callq 0x2a80
movsd 0x3e43(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, (%rsp)
callq 0xdfe0
movsd %xmm0, 0x8(%rsp)
movsd 0x60(%rsp), %xmm0
movl 0x5c(%rsp), %edi
callq 0x2a80
movsd (%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0xe040
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x60(%rsp), %xmm0
movl 0x5c(%rsp), %edi
callq 0x2fc0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x60(%rsp), %xmm0
movl 0x5c(%rsp), %edi
callq 0x3090
movsd %xmm0, 0x38(%rsp)
movsd 0x60(%rsp), %xmm0
movl 0x5c(%rsp), %edi
callq 0x2810
movsd 0x3d63(%rip), %xmm1     # 0x12008
callq 0x22a0
movsd %xmm0, 0x20(%rsp)
callq 0xdfe0
movsd %xmm0, 0x28(%rsp)
movsd 0x60(%rsp), %xmm0
movl 0x5c(%rsp), %edi
callq 0x2810
movsd 0x20(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
callq 0xe040
movsd 0x30(%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
addsd %xmm1, %xmm2
movsd 0x50(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x48(%rsp), %xmm0
divsd 0x40(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/Mixed.cpp
// Function: Mixed::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

	Matrix<std::complex<double> > U = UMNSm(a, delta, order);
	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)
movl %ecx, 0x74(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x94(%rsp)
movb %al, 0x3b(%rsp)
jl 0xef7e
cmpl $0x2, 0x94(%rsp)
setle %al
movb %al, 0x3b(%rsp)
movb 0x3b(%rsp), %al
testb $0x1, %al
jne 0xef88
jmp 0xef8a
jmp 0xefa9
leaq 0x31ee(%rip), %rdi      # 0x1217f
leaq 0x3b13(%rip), %rsi      # 0x12aab
movl $0x76, %edx
leaq 0x3b15(%rip), %rcx      # 0x12ab9
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x90(%rsp)
movb %al, 0x3a(%rsp)
jl 0xefc8
cmpl $0x2, 0x90(%rsp)
setle %al
movb %al, 0x3a(%rsp)
movb 0x3a(%rsp), %al
testb $0x1, %al
jne 0xefd2
jmp 0xefd4
jmp 0xeff3
leaq 0x3209(%rip), %rdi      # 0x121e4
leaq 0x3ac9(%rip), %rsi      # 0x12aab
movl $0x77, %edx
leaq 0x3acb(%rip), %rcx      # 0x12ab9
callq 0x20d0
xorl %eax, %eax
cmpl $0x0, 0x8c(%rsp)
movb %al, 0x39(%rsp)
jl 0xf012
cmpl $0x2, 0x8c(%rsp)
setle %al
movb %al, 0x39(%rsp)
movb 0x39(%rsp), %al
testb $0x1, %al
jne 0xf01c
jmp 0xf01e
jmp 0xf03d
leaq 0x31d6(%rip), %rdi      # 0x121fb
leaq 0x3a7f(%rip), %rsi      # 0x12aab
movl $0x78, %edx
leaq 0x3a81(%rip), %rcx      # 0x12ab9
callq 0x20d0
movsd 0x80(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
movl 0x74(%rsp), %esi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xebc0
movq 0x28(%rsp), %rdi
movslq 0x94(%rsp), %rsi
movslq 0x8c(%rsp), %rdx
callq 0xce30
movq %rax, 0x30(%rsp)
jmp 0xf080
movq 0x30(%rsp), %rdi
callq 0x46f0
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
jmp 0xf098
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 0xf0d1
movq 0x10(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x46b0
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
jmp 0xf0ed
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
// File: PeterDenton[P]Nu-Pert/src/Progress.cpp
// Function: Progress_Bar::Progress_Bar()
Progress_Bar::Progress_Bar()
{
	progress = 0;
	bar_width = 55;
	start_time = time(NULL);
	elapsed_time = 0;
	N_stats = 0;
	update(0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x77f6(%rip), %rcx      # 0x16d80
addq $0x10, %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movl $0x37, 0x8(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2130
movq 0x8(%rsp), %rdi
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x18(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rdi)
movl $0x0, 0x670(%rdi)
xorps %xmm0, %xmm0
callq 0xf5e0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/Warning.cpp
// Function: IndexWarning::IndexWarning(int, int, double)
IndexWarning::IndexWarning(int _min, int _max, double _val)
: min(_min), max(_max), val(_val)
{
	name = "IndexWarning";
	std::ostringstream tmp;
	tmp << "Index range = [" << min << ", " << max << "], " << val << " was provided.";
	message = tmp.str();
	N_IndexWarning++;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movl %esi, 0x1ec(%rsp)
movl %edx, 0x1e8(%rsp)
movsd %xmm0, 0x1e0(%rsp)
movq 0x1f0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x10ab0
movq 0x30(%rsp), %rdi
movl 0x1ec(%rsp), %eax
movl %eax, 0x48(%rdi)
movl 0x1e8(%rsp), %eax
movl %eax, 0x4c(%rdi)
movsd 0x1e0(%rsp), %xmm0
movsd %xmm0, 0x50(%rdi)
leaq 0x1f55(%rip), %rsi      # 0x12ccb
callq 0x2200
jmp 0x10d7d
leaq 0x58(%rsp), %rdi
callq 0x21f0
jmp 0x10d89
leaq 0x1f48(%rip), %rsi      # 0x12cd8
leaq 0x58(%rsp), %rdi
callq 0x2160
movq %rax, 0x28(%rsp)
jmp 0x10da1
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x48(%rax), %esi
callq 0x2290
movq %rax, 0x20(%rsp)
jmp 0x10dba
movq 0x20(%rsp), %rdi
leaq 0x1f23(%rip), %rsi      # 0x12ce9
callq 0x2160
movq %rax, 0x18(%rsp)
jmp 0x10dd2
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x4c(%rax), %esi
callq 0x2290
movq %rax, 0x10(%rsp)
jmp 0x10deb
movq 0x10(%rsp), %rdi
leaq 0x1ef1(%rip), %rsi      # 0x12ce8
callq 0x2160
movq %rax, 0x8(%rsp)
jmp 0x10e03
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movsd 0x50(%rax), %xmm0
callq 0x22e0
movq %rax, (%rsp)
jmp 0x10e1d
movq (%rsp), %rdi
leaq 0x1ec4(%rip), %rsi      # 0x12cec
callq 0x2160
jmp 0x10e2f
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2170
jmp 0x10e40
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
leaq 0x38(%rsp), %rsi
callq 0x21c0
leaq 0x38(%rsp), %rdi
callq 0x20c0
movl 0x63dd(%rip), %eax      # 0x17240
addl $0x1, %eax
movl %eax, 0x63d4(%rip)      # 0x17240
leaq 0x58(%rsp), %rdi
callq 0x2070
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d8(%rsp)
movl %eax, 0x1d4(%rsp)
jmp 0x10eb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d8(%rsp)
movl %eax, 0x1d4(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2070
movq 0x30(%rsp), %rdi
callq 0x10ba0
movq 0x1d8(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: PeterDenton[P]Nu-Pert/src/Warning.cpp
// Function: EdgeCaseWarning::EdgeCaseWarning(double, double, double)
EdgeCaseWarning::EdgeCaseWarning(double _min, double _max, double _val)
: min(_min), max(_max), val(_val)
{
	name = "EdgeCaseWarning";
	std::ostringstream tmp;
	tmp << "Range = [" << min << ", " << max << "], " << val << " was returned.";
	message = tmp.str();
	N_EdgeCaseWarning++;
}

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x200(%rsp)
movsd %xmm0, 0x1f8(%rsp)
movsd %xmm1, 0x1f0(%rsp)
movsd %xmm2, 0x1e8(%rsp)
movq 0x200(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x10ab0
movq 0x38(%rsp), %rdi
movsd 0x1f8(%rsp), %xmm0
movsd %xmm0, 0x48(%rdi)
movsd 0x1f0(%rsp), %xmm0
movsd %xmm0, 0x50(%rdi)
movsd 0x1e8(%rsp), %xmm0
movsd %xmm0, 0x58(%rdi)
leaq 0x1db9(%rip), %rsi      # 0x12cfb
callq 0x2200
jmp 0x10f49
leaq 0x60(%rsp), %rdi
callq 0x21f0
jmp 0x10f55
leaq 0x1daf(%rip), %rsi      # 0x12d0b
leaq 0x60(%rsp), %rdi
callq 0x2160
movq %rax, 0x30(%rsp)
jmp 0x10f6d
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rax
movsd 0x48(%rax), %xmm0
callq 0x22e0
movq %rax, 0x28(%rsp)
jmp 0x10f88
movq 0x28(%rsp), %rdi
leaq 0x1d55(%rip), %rsi      # 0x12ce9
callq 0x2160
movq %rax, 0x20(%rsp)
jmp 0x10fa0
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movsd 0x50(%rax), %xmm0
callq 0x22e0
movq %rax, 0x18(%rsp)
jmp 0x10fbb
movq 0x18(%rsp), %rdi
leaq 0x1d21(%rip), %rsi      # 0x12ce8
callq 0x2160
movq %rax, 0x10(%rsp)
jmp 0x10fd3
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movsd 0x58(%rax), %xmm0
callq 0x22e0
movq %rax, 0x8(%rsp)
jmp 0x10fee
movq 0x8(%rsp), %rdi
leaq 0x1d1b(%rip), %rsi      # 0x12d15
callq 0x2160
jmp 0x11001
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2170
jmp 0x11012
movq 0x38(%rsp), %rdi
addq $0x20, %rdi
leaq 0x40(%rsp), %rsi
callq 0x21c0
leaq 0x40(%rsp), %rdi
callq 0x20c0
movl 0x620f(%rip), %eax      # 0x17244
addl $0x1, %eax
movl %eax, 0x6206(%rip)      # 0x17244
leaq 0x60(%rsp), %rdi
callq 0x2070
addq $0x208, %rsp            # imm = 0x208
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
jmp 0x11084
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2070
movq 0x38(%rsp), %rdi
callq 0x10ba0
movq 0x1e0(%rsp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: PeterDenton[P]Nu-Pert/src/Warning.cpp
// Function: ProbabilityWarning::ProbabilityWarning(double*)
ProbabilityWarning::ProbabilityWarning(double *P)
{
	if (*P >= 0 and *P <= 1)
	{
		N_Warning--;
		warn = false;		
	}
	else
	{
		name = "ProbabilityWarning";
		std::ostringstream tmp;
		tmp << "P = " << *P << ", is outside of [0, 1]. Setting P to " << (*P < 0 ? 0 : 1) << ".";
		*P = (*P < 0 ? 0 : 1);
		message = tmp.str();
		N_ProbabilityWarning++;
	}
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x10ab0
movq 0x1d8(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x11111
movq 0x1d8(%rsp), %rax
movsd 0xf2a(%rip), %xmm0      # 0x12018
ucomisd (%rax), %xmm0
jb 0x11111
movq 0x28(%rsp), %rax
movl 0x613d(%rip), %ecx      # 0x1723c
addl $-0x1, %ecx
movl %ecx, 0x6134(%rip)      # 0x1723c
movb $0x0, 0x40(%rax)
jmp 0x1125d
movq 0x28(%rsp), %rdi
leaq 0x1c07(%rip), %rsi      # 0x12d24
callq 0x2200
jmp 0x11124
leaq 0x50(%rsp), %rdi
callq 0x21f0
jmp 0x11130
leaq 0x1c00(%rip), %rsi      # 0x12d37
leaq 0x50(%rsp), %rdi
callq 0x2160
movq %rax, 0x20(%rsp)
jmp 0x11148
movq 0x20(%rsp), %rdi
movq 0x1d8(%rsp), %rax
movsd (%rax), %xmm0
callq 0x22e0
movq %rax, 0x18(%rsp)
jmp 0x11165
movq 0x18(%rsp), %rdi
leaq 0x1bcb(%rip), %rsi      # 0x12d3c
callq 0x2160
movq %rax, 0x10(%rsp)
jmp 0x1117d
movq 0x10(%rsp), %rdi
movq 0x1d8(%rsp), %rax
movsd (%rax), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
setbe %al
movzbl %al, %esi
callq 0x2290
movq %rax, 0x8(%rsp)
jmp 0x111a7
movq 0x8(%rsp), %rdi
leaq 0x1b46(%rip), %rsi      # 0x12cf9
callq 0x2160
jmp 0x111ba
movq 0x1d8(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
cmpnltsd %xmm1, %xmm0
movsd 0xe42(%rip), %xmm1      # 0x12018
pand %xmm1, %xmm0
movlpd %xmm0, (%rax)
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2170
jmp 0x111ef
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
leaq 0x30(%rsp), %rsi
callq 0x21c0
leaq 0x30(%rsp), %rdi
callq 0x20c0
movl 0x6036(%rip), %eax      # 0x17248
addl $0x1, %eax
movl %eax, 0x602d(%rip)      # 0x17248
leaq 0x50(%rsp), %rdi
callq 0x2070
jmp 0x1125d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d0(%rsp)
movl %eax, 0x1cc(%rsp)
jmp 0x11265
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d0(%rsp)
movl %eax, 0x1cc(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2070
jmp 0x11265
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x28(%rsp), %rdi
callq 0x10ba0
movq 0x1d0(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc6.cc
// Function: operator<<(std::ostream&, TOKENTYPE const&)
ostream& operator<<(ostream& out, const TOKENTYPE& t) {
    string repr;
    switch(t) {
        case TOKENTYPE::ENDOFFILE:
            repr = "ENDOFFILE";
            break;
        case TOKENTYPE::INTEGER:
            repr = "INTEGER";
            break;
        case TOKENTYPE::PLUS:
            repr = "PLUS";
            break;
        case TOKENTYPE::MINUS:
            repr = "MINUS";
            break;
        case TOKENTYPE::MUL:
            repr = "MUL";
            break;
        case TOKENTYPE::DIV:
            repr = "DIV";
            break;
        case TOKENTYPE::LPAREN:
            repr = "LPAREN";
            break;
        case TOKENTYPE::RPAREN:
            repr = "RPAREN";
            break;
    }

    out << repr;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x48(%rbp)
subq $0x7, %rax
ja 0x254e
movq -0x48(%rbp), %rax
leaq 0x1b7c(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b8c(%rip), %rsi      # 0x4024
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24a3
jmp 0x254e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x2578
leaq 0x1b65(%rip), %rsi      # 0x402e
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24d4
jmp 0x254e
leaq 0x1b59(%rip), %rsi      # 0x4036
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24e8
jmp 0x254e
leaq 0x1b4a(%rip), %rsi      # 0x403b
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24fc
jmp 0x254e
leaq 0x1b3c(%rip), %rsi      # 0x4041
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x2510
jmp 0x254e
leaq 0x1b2c(%rip), %rsi      # 0x4045
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x2524
jmp 0x254e
leaq 0x1b1c(%rip), %rsi      # 0x4049
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x2538
jmp 0x254e
leaq 0x1b0f(%rip), %rsi      # 0x4050
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x254c
jmp 0x254e
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2160
jmp 0x255d
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc6.cc
// Function: Lexer::integer()
long Lexer::integer() {
    string result("");

    while (_current_char != '\0' && isdigit(_current_char)) {
        result += _current_char;
        advance();
    }

    return stol(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x22c0
movq -0x48(%rbp), %rdx
leaq 0x15be(%rip), %rsi      # 0x409a
leaq -0x28(%rbp), %rdi
callq 0x3300
jmp 0x2ae7
leaq -0x29(%rbp), %rdi
callq 0x21c0
movq -0x50(%rbp), %rax
movsbl 0x10(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x51(%rbp)
je 0x2b18
movq -0x50(%rbp), %rax
movsbl 0x10(%rax), %edi
callq 0x2170
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x2b21
jmp 0x2b6f
movq -0x50(%rbp), %rax
movsbl 0x10(%rax), %esi
leaq -0x28(%rbp), %rdi
callq 0x20f0
jmp 0x2b34
movq -0x50(%rbp), %rdi
callq 0x2bb0
jmp 0x2b3f
jmp 0x2af0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x21c0
jmp 0x2b9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20e0
jmp 0x2b9a
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
movl $0xa, %edx
callq 0x33b0
movq %rax, -0x60(%rbp)
jmp 0x2b87
leaq -0x28(%rbp), %rdi
callq 0x20e0
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)