LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: TBody[P]atomicpp/atomicpp/Spline/BilinearSpline.cpp
// Function: atomicpp::BilinearSpline::BilinearSpline(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
BilinearSpline::BilinearSpline(
	std::vector<double>& _x_values,
	std::vector<double>& _y_values,
	std::vector< std::vector<double> > & _z_values
	){
	x_values = _x_values;
	y_values = _y_values;
	z_values = _z_values;

	//Doesn't require initialisation
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x1cee0
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x48(%rbp)
callq 0x1cee0
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1c240
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22380
jmp 0x2174d
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rdi
callq 0x22380
jmp 0x21760
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rdi
callq 0x225d0
jmp 0x21773
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x19150
movq -0x48(%rbp), %rdi
callq 0x59b0
movq -0x38(%rbp), %rdi
callq 0x59b0
movq -0x28(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: TBody[P]atomicpp/atomicpp/Spline/BilinearSpline.cpp
// Function: atomicpp::BilinearSpline::call0D_shared(std::pair<int, double>, std::pair<int, double>)
double BilinearSpline::call0D_shared(const std::pair<int, double> x_interp, const std::pair<int, double> y_interp){

	int low_x = x_interp.first;
	int low_y = y_interp.first;

	double x = x_interp.second;
	double y = y_interp.second;

	// // Construct the simple interpolation grid
	// // Find weightings based on linear distance
	// // w01 ------ w11    y
	// //  | \     / |      |
	// //  |  w(x,y) |    --/--x
	// //  | /     \ |      |
	// // w00 ------ w10

	double eval_coeff =
	 (z_values[low_x+0][low_y+0]*(1-y) + z_values[low_x+0][low_y+1]*y)*(1-x)
	+(z_values[low_x+1][low_y+0]*(1-y) + z_values[low_x+1][low_y+1]*y)*x;

	return eval_coeff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %esi, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x30, %rdi
movl -0x2c(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rsi
callq 0x22870
movq %rax, %rdi
movl -0x30(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rsi
callq 0x5950
movq -0x70(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd 0x13f39(%rip), %xmm0    # 0x36008
subsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
addq $0x30, %rdi
movl -0x2c(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rsi
callq 0x22870
movq %rax, %rdi
movl -0x30(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5950
movsd -0x80(%rbp), %xmm0
movsd -0x78(%rbp), %xmm2
movq -0x70(%rbp), %rdi
movsd (%rax), %xmm1
mulsd -0x40(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x13ee0(%rip), %xmm0    # 0x36008
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x30, %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x22870
movq %rax, %rdi
movl -0x30(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rsi
callq 0x5950
movq -0x70(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x13e9e(%rip), %xmm0    # 0x36008
subsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
addq $0x30, %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x22870
movq %rax, %rdi
movl -0x30(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5950
movsd -0x68(%rbp), %xmm1
movsd -0x60(%rbp), %xmm4
movsd -0x58(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
movsd (%rax), %xmm3
mulsd -0x40(%rbp), %xmm3
mulsd %xmm4, %xmm1
addsd %xmm3, %xmm1
mulsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: TBody[P]atomicpp/atomicpp/Spline/BicubicSpline.cpp
// Function: atomicpp::BicubicSpline::call0D_shared(std::pair<int, double>, std::pair<int, double>)
double BicubicSpline::call0D_shared(const std::pair<int, double> x_interp, const std::pair<int, double> y_interp){

	int low_x = x_interp.first;
	int low_y = y_interp.first;

	double x = x_interp.second;
	double y = y_interp.second;

	// // Construct the simple interpolation grid
	// // Find weightings based on linear distance
	// // w01 ------ w11    y
	// //  | \     / |      |
	// //  |  w(x,y) |    --/--x
	// //  | /     \ |      |
	// // w00 ------ w10

	grid_matrix alpha_sub = alpha_coeff[low_x][low_y];

	double x_vector[4] = {1, x, x*x, x*x*x}; //Row vector
	double y_vector[4] = {1, y, y*y, y*y*y}; //Column vector

	double return_value = 0.0;
	for(int i=0; i<4; ++i){
		for(int j=0; j<4; ++j){
			return_value += x_vector[i] * alpha_sub[i][j] * y_vector[j];
		}
	}

	return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %esi, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x48, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x268e0
movq %rax, %rdi
movslq -0x30(%rbp), %rsi
callq 0x1ac80
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x20ee0
movsd 0x10968(%rip), %xmm0    # 0x36008
movsd %xmm0, -0x80(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x1092e(%rip), %xmm0    # 0x36008
movsd %xmm0, -0xa0(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movsd -0x40(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x40(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0xa8(%rbp)
movl $0x0, -0xac(%rbp)
cmpl $0x4, -0xac(%rbp)
jge 0x257df
movl $0x0, -0xb0(%rbp)
cmpl $0x4, -0xb0(%rbp)
jge 0x257c9
movslq -0xac(%rbp), %rax
movsd -0x80(%rbp,%rax,8), %xmm0
movsd %xmm0, -0xb8(%rbp)
movslq -0xac(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x22870
movq %rax, %rdi
movslq -0xb0(%rbp), %rsi
callq 0x5950
movsd -0xb8(%rbp), %xmm0
mulsd (%rax), %xmm0
movslq -0xb0(%rbp), %rax
movsd -0xa0(%rbp,%rax,8), %xmm2
movsd -0xa8(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0xa8(%rbp)
movl -0xb0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0x25744
jmp 0x257cb
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x2572d
movsd -0xa8(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x19150
movsd -0xc0(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: TBody[P]atomicpp/atomicpp/Spline/BivariateBSpline.cpp
// Function: atomicpp::BivariateBSpline::bispeu(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double const&, double const&)
double BivariateBSpline::bispeu(const std::vector<double>& tx,const std::vector<double>& ty,const std::vector<double>& c,const double& x,const double& y){
  // z = bispeu(tx,ty,c,kx,ky,x,y)

  int nx = tx.size();
  int ny = ty.size();
  int kx = 3;
  int ky = 3;

  double z = fpbisp(tx, nx, ty, ny, c, kx, ky, x, y);

  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d4d0
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d4d0
movq -0x58(%rbp), %rdi
movl %eax, -0x40(%rbp)
movl $0x3, -0x44(%rbp)
movl $0x3, -0x48(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %r10
movq -0x38(%rbp), %rax
leaq -0x3c(%rbp), %rdx
leaq -0x40(%rbp), %r8
leaq -0x44(%rbp), %rbx
leaq -0x48(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x2ea90
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
// File: TBody[P]atomicpp/atomicpp/Spline/BivariateBSpline.cpp
// Function: atomicpp::BivariateBSpline::fprota(double, double, double&, double&)
void BivariateBSpline::fprota(const double cos, const double sin, double& a, double& b){
  //  subroutine fprota applies a given rotation to a and b.
  double stor1 = a;
  double stor2 = b;

  b = cos * stor2 + sin * stor1;
  a = cos * stor1 - sin * stor2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TBody[P]atomicpp/atomicpp/Spline/BivariateBSpline.cpp
// Function: atomicpp::BivariateBSpline::fpgivs(double, double&, double&, double&)
void BivariateBSpline::fpgivs(const double piv, double& ww, double& cos, double& sin){
  //  subroutine fpgivs calculates the parameters of a given
  //  transformation .

  double dd;
  if(abs(piv)>=ww){
    dd = abs(piv)*sqrt(1+(ww/piv)*(ww/piv));
  } else {
    dd = ww*sqrt(1+(piv/ww)*(piv/ww));
  }
  cos = ww/dd;
  sin = piv/dd;
  ww = dd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x2f470
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jb 0x2e192
movsd -0x10(%rbp), %xmm0
callq 0x2f470
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
divsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
divsd -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x7e92(%rip), %xmm1     # 0x36008
addsd %xmm1, %xmm0
callq 0x42f0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x2e1df
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
divsd (%rax), %xmm0
movsd -0x10(%rbp), %xmm1
movq -0x18(%rbp), %rax
divsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x7e43(%rip), %xmm1     # 0x36008
addsd %xmm1, %xmm0
callq 0x42f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
divsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: TBody[P]atomicpp/atomicpp/RateEquations.cpp
// Function: atomicpp::RateEquations::resetDerivatives()
void RateEquations::resetDerivatives(){
	Pcool                    = 0.0;
	Prad                     = 0.0;
	dNe                      = 0.0;
	F_i                      = 0.0;
	dNn                      = 0.0;
	F_n                      = 0.0;
	
	for(int k = 0; k<= Z; ++k){
		dNzk[k] = 0.0;
		F_zk[k] = 0.0;
		dNzk_correction[k] = 0.0;
		F_zk_correction[k] = 0.0;
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xd0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xd8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xe0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xe8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x34(%rcx), %eax
jg 0x32767
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5950
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x88, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5950
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0xa0, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5950
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0xb8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5950
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x326e7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: TBody[P]atomicpp/atomicpp/RateEquations.cpp
// Function: atomicpp::RateEquations::calculateIonIonDrag(double, double, double, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
void RateEquations::calculateIonIonDrag(
	const double Ne,
	const double Te,
	const double Vi,
	const std::vector<double>& Nzk,
	const std::vector<double>& Vzk
	){
	
	//Assume that Te = Ti (isothermal), Ne = Ni (quasi-neutrality for Z=1 dominant ion)
	double collision_frequency_ii_PF = calculateIonIonDragFactor(Te, Ne);
	//ii is 'ion ion'
	//PF is 'Point Factor' -- i.e. a constant value shared for this point

	for(int k=1; k <= Z; ++k){//Don't consider the ground state -- not an ion so must be treated separately
		if(Nzk[k] > Nthres){
			double collision_frequency_s_ii = collision_frequency_ii_PF * k*k;
			double IonIonDrag_FF = mz * amu_to_kg * ((Vi+1) - Vzk[k]) * collision_frequency_s_ii;
			F_zk[k] += IonIonDrag_FF; //Calculate the force on the impurity ion due to ion-ion drag
			F_i     -= IonIonDrag_FF; //Calculate the force on the dominant ion due to ion-ion drag
		};
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x32420
movsd %xmm0, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x3c(%rbp), %eax
cmpl 0x34(%rcx), %eax
jg 0x34c31
movq -0x28(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x26b60
movq %rax, %rcx
movq -0x58(%rbp), %rax
movsd (%rcx), %xmm0
ucomisd 0x40(%rax), %xmm0
jbe 0x34c21
movq -0x58(%rbp), %rax
movsd -0x38(%rbp), %xmm0
cvtsi2sdl -0x3c(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl -0x3c(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x46f7(%rip), %xmm0     # 0x39288
mulsd 0x38(%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x1465(%rip), %xmm0     # 0x36008
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x26b60
movsd -0x70(%rbp), %xmm1
movsd -0x68(%rbp), %xmm0
movq -0x58(%rbp), %rdi
subsd (%rax), %xmm1
mulsd %xmm1, %xmm0
mulsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
addq $0x88, %rdi
movslq -0x3c(%rbp), %rsi
callq 0x5950
movsd -0x60(%rbp), %xmm0
movq %rax, %rcx
movq -0x58(%rbp), %rax
addsd (%rcx), %xmm0
movsd %xmm0, (%rcx)
movsd -0x50(%rbp), %xmm1
movsd 0xd8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0xd8(%rax)
jmp 0x34c23
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x34b36
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TBody[P]atomicpp/atomicpp/RateEquations.cpp
// Function: atomicpp::RateEquations::calculateIonNeutralDrag(double, double, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
void RateEquations::calculateIonNeutralDrag(
	const double Nn,
	const double Vn,
	const std::vector<double>& Nzk,
	const std::vector<double>& Vzk
	){

	// Hard sphere's approximation
	// Radius of Carbon and Hydrogen atoms are ~ 50pm
	// a12 radius = a1+a2 = 100pm = 100e-12 = 1e-10
	// a12^2 = 1e-20
	// The cross-section (from Lieberman & Lichtenberg, 1994, Principles of Plasma Discharges & Materials Processing, eqn 3.1.4) is
	double sigma = M_PI * 1e-20;

	for(int k=0; k <= Z; ++k){//Don't consider the ground state -- not an ion so must be treated separately
		if(Nzk[k] > Nthres){
			double velocity_shear = Vn - Vzk[k];
			double IonNeutralDrag_FF = mz * amu_to_kg * Nn * sigma * (velocity_shear*velocity_shear);
			F_zk[k] += IonNeutralDrag_FF; //Calculate the force on the impurity ion due to ion-neutral drag
			F_n     -= IonNeutralDrag_FF; //Calculate the force on the dominant neutral due to ion-neutral drag
		};
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd 0x4622(%rip), %xmm0     # 0x39290
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x34(%rcx), %eax
jg 0x34d57
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x26b60
movq %rax, %rcx
movq -0x50(%rbp), %rax
movsd (%rcx), %xmm0
ucomisd 0x40(%rax), %xmm0
jbe 0x34d47
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x26b60
movsd -0x60(%rbp), %xmm0
movq -0x50(%rbp), %rdi
subsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x45aa(%rip), %xmm0     # 0x39288
mulsd 0x38(%rdi), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x88, %rdi
movslq -0x34(%rbp), %rsi
callq 0x5950
movsd -0x58(%rbp), %xmm0
movq %rax, %rcx
movq -0x50(%rbp), %rax
addsd (%rcx), %xmm0
movsd %xmm0, (%rcx)
movsd -0x48(%rbp), %xmm1
movsd 0xe8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0xe8(%rax)
jmp 0x34d49
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x34c7a
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: TBody[P]atomicpp/atomicpp/RateEquations.cpp
// Function: atomicpp::RateEquations::calculateChargeExchangePowerEquation(double, std::vector<double, std::allocator<double>> const&, double, double)
void RateEquations::calculateChargeExchangePowerEquation(
	const double Nn,
	const std::vector<double>& Nzk,
	const double Te,
	const double Ne
	){
	//Calculate the power - doesn't need as high precision since everything is positive
	
	std::shared_ptr<RateCoefficient> cx_power_coefficient = rate_coefficients["cx_power"];
	for(int k=0; k < Z; ++k){
		double cx_power_coefficient_evaluated = cx_power_coefficient->call0D(k, Te, Ne);
		double cx_power_rate = cx_power_coefficient_evaluated * Nn * Nzk[k+1];
		Prad  += cx_power_rate;
		Pcool += cx_power_rate;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rax, -0x90(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x45f0
movq -0x88(%rbp), %rdx
leaq 0x2885(%rip), %rsi      # 0x37957
leaq -0x58(%rbp), %rdi
callq 0x44d0
jmp 0x350dd
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x13990
movq %rax, -0xa0(%rbp)
jmp 0x350f6
movq -0xa0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x13960
leaq -0x58(%rbp), %rdi
callq 0x4220
leaq -0x59(%rbp), %rdi
callq 0x4410
movl $0x0, -0x70(%rbp)
movq -0x90(%rbp), %rcx
movl -0x70(%rbp), %eax
cmpl 0x34(%rcx), %eax
jge 0x35217
leaq -0x38(%rbp), %rdi
callq 0x5970
movq %rax, %rdi
movl -0x70(%rbp), %esi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x1aa40
movsd %xmm0, -0xa8(%rbp)
jmp 0x3515a
movsd -0xa8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x78(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
movl -0x70(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x26b60
movsd -0xb0(%rbp), %xmm0
movq %rax, %rcx
movq -0x90(%rbp), %rax
mulsd (%rcx), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x80(%rbp), %xmm0
addsd 0x68(%rax), %xmm0
movsd %xmm0, 0x68(%rax)
movsd -0x80(%rbp), %xmm0
addsd 0x60(%rax), %xmm0
movsd %xmm0, 0x60(%rax)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x3511f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x351f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4220
leaq -0x59(%rbp), %rdi
callq 0x4410
jmp 0x35229
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5990
jmp 0x35229
leaq -0x38(%rbp), %rdi
callq 0x5990
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: TBody[P]atomicpp/atomicpp/RateEquations.cpp
// Function: atomicpp::RateEquations::makeDerivativeStruct()
DerivStruct RateEquations::makeDerivativeStruct(){
	DerivStruct derivative_struct;

	derivative_struct.Pcool = Pcool;
	derivative_struct.Prad  = Prad;
	derivative_struct.dNzk  = dNzk;
	derivative_struct.F_zk  = F_zk;
	derivative_struct.dNe   = dNe;
	derivative_struct.F_i   = F_i;
	derivative_struct.dNn   = dNn;
	derivative_struct.F_n   = F_n;

	return derivative_struct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x35830
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movsd 0x60(%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
addq $0x70, %rsi
addq $0x10, %rdi
callq 0x22380
jmp 0x35296
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x88, %rsi
addq $0x28, %rdi
callq 0x22380
jmp 0x352b0
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movsd 0xd0(%rcx), %xmm0
movsd %xmm0, 0x40(%rax)
movsd 0xd8(%rcx), %xmm0
movsd %xmm0, 0x48(%rax)
movsd 0xe0(%rcx), %xmm0
movsd %xmm0, 0x50(%rax)
movsd 0xe8(%rcx), %xmm0
movsd %xmm0, 0x58(%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x35318
jmp 0x3530f
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5a10
jmp 0x35322
movq -0x30(%rbp), %rdi
callq 0x5a10
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: TBody[P]atomicpp/atomicpp/RateEquations.cpp
// Function: atomicpp::RateEquations::computeDerivsHydrogen(double, double, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
DerivStruct RateEquations::computeDerivsHydrogen(
	const double Te,
	const double Ne,
	const std::vector<double>& Nhk,
	const std::vector<double>& Vhk){

	resetDerivatives(); //Reset all the derivatives to zero, since the object has a memory of the previous step

	calculateElectronImpactPopulationEquation(Ne, Nhk, Vhk, Te);

	//Apply neumairSum corrections
	for(int k=0; k<=Z; ++k){
		dNzk[k] += dNzk_correction[k]; //Uses 'z' notation since these are the attributes stored in RateEquations object
		F_zk[k] += F_zk_correction[k]; //
	}

	verifyNeumaierSummation(Te, Ne);
	
	calculateElectronImpactPowerEquation(Ne, Nhk, Te);

	// auto derivative_tuple = makeDerivativeTuple();
	// return derivative_tuple;
	DerivStruct derivative_struct = makeDerivativeStruct();
	return derivative_struct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x32690
movq -0x40(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movsd -0x18(%rbp), %xmm1
callq 0x32770
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x34(%rcx), %eax
jg 0x35423
movq -0x40(%rbp), %rdi
addq $0xa0, %rdi
movslq -0x34(%rbp), %rsi
callq 0x5950
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
addq $0x70, %rdi
movslq -0x34(%rbp), %rsi
callq 0x5950
movsd -0x60(%rbp), %xmm0
movq -0x40(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0xb8, %rdi
movslq -0x34(%rbp), %rsi
callq 0x5950
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x88, %rdi
movslq -0x34(%rbp), %rsi
callq 0x5950
movsd -0x58(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3538c
movq -0x40(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd 0xbcf(%rip), %xmm2      # 0x36008
callq 0x34750
movq -0x40(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rsi
movsd -0x18(%rbp), %xmm1
callq 0x34d60
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movb $0x0, -0x35(%rbp)
callq 0x35240
movb $0x1, -0x35(%rbp)
testb $0x1, -0x35(%rbp)
jne 0x35479
movq -0x50(%rbp), %rdi
callq 0x5a10
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TBody[P]atomicpp/atomicpp/RateEquations.cpp
// Function: atomicpp::neumaierSum(std::vector<double, std::allocator<double>> const&, double)
std::pair<double, double> atomicpp::neumaierSum(const std::vector<double>& list_to_sum, const double previous_correction /* = 0.0*/){
    double sum = 0.0;

    double correction = previous_correction;                 // A running compensation for lost low-order bits. Use previous result to restart summation

    for(int i=0; i < (int)(list_to_sum.size()); ++i){
        double temporary_sum = sum + list_to_sum[i];
        if (std::fabs(sum) >= std::fabs(list_to_sum[i])){
            correction += (sum - temporary_sum) + list_to_sum[i]; // If sum is bigger, low-order digits of list_to_sum[i] are lost.
        } else {
            correction += (list_to_sum[i] - temporary_sum) + sum; // Else low-order digits of sum are lost
        }
        sum = temporary_sum;
	}

	std::pair<double, double> neumaier_pair(sum, correction);

	return neumaier_pair;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d4d0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x355a6
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x26b60
movsd -0x58(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movaps 0x3768(%rip), %xmm1     # 0x38c70
pand %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x26b60
movsd -0x50(%rbp), %xmm0
movsd (%rax), %xmm1
movaps 0x3742(%rip), %xmm2     # 0x38c70
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x35569
movsd -0x28(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x26b60
movsd -0x60(%rbp), %xmm0
addsd (%rax), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x3558e
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x26b60
movsd (%rax), %xmm0
subsd -0x40(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x354ba
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x26d60
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuron.cpp
// Function: Neuron::initialiseWeights()
void Neuron::initialiseWeights() {
 // Initialise all weights with a random number between -1 and 1
  for (double& weight : weights) {
      weight = -1 + 2*randomize();
  }

  threshold = -1 + 2*randomize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a40
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2a70
testb $0x1, %al
jne 0x2669
jmp 0x269e
leaq -0x18(%rbp), %rdi
callq 0x2ab0
movq %rax, -0x28(%rbp)
callq 0x26d0
addsd %xmm0, %xmm0
movsd 0xb981(%rip), %xmm1     # 0xe008
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x2ad0
jmp 0x2656
callq 0x26d0
movq -0x30(%rbp), %rax
addsd %xmm0, %xmm0
movsd 0xb955(%rip), %xmm1     # 0xe008
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuron.cpp
// Function: randomize()
double randomize() {
  short min = 0;
  short max = 100;

  std::mt19937 rng;
  rng.seed(std::random_device()());
  std::uniform_int_distribution<std::mt19937::result_type>dist(min, max);
  double random_number = (double)dist(rng)/(double)max;
  return random_number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2760, %rsp           # imm = 0x2760
movw $0x0, -0x2(%rbp)
movw $0x64, -0x4(%rbp)
leaq -0x1390(%rbp), %rdi
callq 0x2ba0
leaq -0x2718(%rbp), %rdi
movq %rdi, -0x2750(%rbp)
callq 0x2c80
movq -0x2750(%rbp), %rdi
callq 0x2d20
movl %eax, -0x2744(%rbp)
jmp 0x271a
movl -0x2744(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x1390(%rbp), %rdi
callq 0x2bc0
jmp 0x2732
leaq -0x2718(%rbp), %rdi
callq 0x2d40
movswq -0x2(%rbp), %rsi
movswq -0x4(%rbp), %rdx
leaq -0x2738(%rbp), %rdi
movq %rdi, -0x2758(%rbp)
callq 0x2d70
movq -0x2758(%rbp), %rdi
leaq -0x1390(%rbp), %rsi
callq 0x2da0
movq %rax, %xmm0
movaps 0xb8a6(%rip), %xmm1     # 0xe020
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xb8aa(%rip), %xmm1     # 0xe030
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movswl -0x4(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x2740(%rbp)
movsd -0x2740(%rbp), %xmm0
addq $0x2760, %rsp           # imm = 0x2760
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2720(%rbp)
movl %eax, -0x2724(%rbp)
leaq -0x2718(%rbp), %rdi
callq 0x2d40
movq -0x2720(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuron.cpp
// Function: Neuron::activate(std::vector<double, std::allocator<double>>)
void Neuron::activate(std::vector<double> inputs) {
    unsigned int number_of_inputs = inputs.size();
    action_potential = 0;

    for (unsigned int i = 0; i < number_of_inputs; ++i) {
      action_potential += (weights.at(i) * inputs.at(i));
    }

    // Add weighted bias
    action_potential += (bias * threshold);

    output = sigmoid(action_potential);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2af0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x2893
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2b10
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2b10
movsd -0x38(%rbp), %xmm0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movsd (%rcx), %xmm2
movsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2835
movq -0x20(%rbp), %rdi
movsd 0x10(%rdi), %xmm0
movsd 0x18(%rdi), %xmm2
movsd 0x8(%rdi), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x8(%rdi), %xmm0
callq 0x2b50
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/layer.cpp
// Function: Layer::Layer(unsigned short, unsigned short)
Layer::Layer(unsigned short number_of_neurons, unsigned short number_of_inputs) {

  neurons = std::vector<Neuron>(number_of_neurons);
  inputs = std::vector<double>(number_of_inputs);

  for (Neuron& neuron : neurons) {
      neuron.reshape(number_of_inputs);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x44d0
movaps -0xb0(%rbp), %xmm0
movq -0xa0(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq %rdi, -0x98(%rbp)
movups %xmm0, 0x18(%rax)
movq $0x0, 0x28(%rax)
callq 0x44f0
movzwl -0xa(%rbp), %eax
movq %rax, -0x90(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4510
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x4530
jmp 0x41dd
movq -0xb8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
movq %rsi, -0xd0(%rbp)
callq 0x45a0
movq -0xd0(%rbp), %rdi
callq 0x45d0
leaq -0x29(%rbp), %rdi
callq 0x4630
movzwl -0xc(%rbp), %eax
movq %rax, -0xc8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x28d0
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x28f0
jmp 0x4241
movq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2960
leaq -0x58(%rbp), %rdi
callq 0x2990
leaq -0x59(%rbp), %rdi
callq 0x29f0
movq -0xb8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x4650
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x4680
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x46b0
testb $0x1, %al
jne 0x429f
jmp 0x4304
leaq -0x70(%rbp), %rdi
callq 0x46f0
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
movzwl -0xc(%rbp), %esi
callq 0x2580
jmp 0x42bb
jmp 0x42bd
leaq -0x70(%rbp), %rdi
callq 0x4710
jmp 0x428c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4630
jmp 0x430d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x29f0
jmp 0x430d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x430d
addq $0xd0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x45d0
movq -0xa0(%rbp), %rdi
callq 0x2990
movq -0x38(%rbp), %rdi
callq 0x2310
nop
// File: gkosae[P]ArduinoNeuralNet/layer.cpp
// Function: Layer::getOutputs()
std::vector<double> Layer::getOutputs() {
    std::vector<double> outputs{};
    for (Neuron& neuron : neurons){
        outputs.push_back(neuron.output);
    }

    return outputs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20b0
movq -0x58(%rbp), %rdi
callq 0x44d0
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4650
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4680
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x46b0
testb $0x1, %al
jne 0x4465
jmp 0x44a5
leaq -0x28(%rbp), %rdi
callq 0x46f0
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x4820
jmp 0x4481
jmp 0x4483
leaq -0x28(%rbp), %rdi
callq 0x4710
jmp 0x4452
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2990
jmp 0x44c2
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x44b8
movq -0x58(%rbp), %rdi
callq 0x2990
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::forward()
void NeuralNet::forward() {
    // set inputs as output of the input layer
    unsigned short input_layer_size = layers.front().size();

    for(auto i = 0; i < input_layer_size; ++i) {
      layers.front().neurons.at(i).output = layers.front().inputs.at(i);
    }

     layers.at(1).feed(layers.front().getOutputs());

     unsigned short number_of_layers = layers.size();

     for(auto i = 1; i < number_of_layers; ++i) {
        layers.at(i).forward();

        if(i != (number_of_layers - 1)){
            layers.at(i+1).feed(layers.at(i).getOutputs());
        }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x18, %rdi
callq 0x81f0
movq %rax, %rdi
callq 0x8220
movw %ax, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5ed1
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0x81f0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x2b10
movq -0x60(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
addq $0x18, %rdi
callq 0x81f0
movq %rax, %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8240
movsd -0x68(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5e73
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x80(%rbp)
movl $0x1, %esi
callq 0x8280
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x81f0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x43f0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x82c0
jmp 0x5f13
leaq -0x28(%rbp), %rdi
callq 0x2990
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0x82e0
movw %ax, -0x36(%rbp)
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movzwl -0x36(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6012
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movslq -0x3c(%rbp), %rsi
callq 0x8280
movq %rax, %rdi
callq 0x4330
movl -0x3c(%rbp), %eax
movzwl -0x36(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x6002
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x98(%rbp)
movl -0x3c(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0x8280
movq -0x98(%rbp), %rdi
movq %rax, -0x90(%rbp)
movslq -0x3c(%rbp), %rsi
callq 0x8280
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x43f0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x82c0
jmp 0x5fc9
leaq -0x58(%rbp), %rdi
callq 0x2990
jmp 0x6002
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2990
jmp 0x601b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2990
jmp 0x601b
jmp 0x6004
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5f34
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::calculateOverallError()
double NeuralNet::calculateOverallError() {
    double error = 0;

    // Quadratic Cost Function
    for(auto i = 0; i < current_sample; ++i) {
        unsigned short output_layer_size = layers.back().size();
        for(auto j = 0; j < output_layer_size; ++j) {
            error += (0.5*pow(expected_output[i][j] - actual_output[i][j], 2));
        }
    }

    unsigned short number_of_samples = input_data.size();

    error = error/number_of_samples + lambda/2*getRegularizationTerm();
    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x78(%rcx), %eax
jae 0x614c
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x8310
movq %rax, %rdi
callq 0x8220
movw %ax, -0x16(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movzwl -0x16(%rbp), %ecx
cmpl %ecx, %eax
jge 0x613c
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0x8430
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3b50
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x8430
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3b50
movsd -0x30(%rbp), %xmm0
subsd (%rax), %xmm0
movl $0x2, %edi
callq 0x8400
movsd -0x10(%rbp), %xmm1
movsd 0x7fef(%rip), %xmm2     # 0xe110
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60b3
jmp 0x613e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6083
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
callq 0x7fc0
movq -0x28(%rbp), %rdi
movw %ax, -0x1e(%rbp)
movsd -0x10(%rbp), %xmm0
movzwl -0x1e(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x80(%rdi), %xmm0
movsd 0x7f81(%rip), %xmm1     # 0xe108
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x6770
movsd -0x40(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::getRegularizationTerm()
double NeuralNet::getRegularizationTerm() {
    double term = 0;

    // sum the square of all weights
    unsigned short count = layers.size();

    for(auto i = 1; i < count; ++i) {
        unsigned short current_layer_size = layers.at(i).size();

        for(auto j = 0; j < current_layer_size; ++j) {
            std::vector<double> weights = layers.at(i).neurons.at(j).weights;

            for(auto weight : weights) {
                term += pow(weight,2);
            }
        }
    }

    term = term/input_data.size();
    return term;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
addq $0x18, %rdi
callq 0x82e0
movw %ax, -0x12(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jge 0x68ce
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0x8280
movq %rax, %rdi
callq 0x8220
movw %ax, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x68be
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0x8280
movq %rax, %rdi
addq $0x18, %rdi
movslq -0x20(%rbp), %rsi
callq 0x8240
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdi
callq 0x4730
leaq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2a10
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2a40
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2a70
testb $0x1, %al
jne 0x684b
jmp 0x68a7
leaq -0x48(%rbp), %rdi
callq 0x2ab0
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movl $0x2, %edi
callq 0x8400
movsd %xmm0, -0x78(%rbp)
jmp 0x6873
movsd -0x78(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2ad0
jmp 0x6838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2990
jmp 0x6928
leaq -0x38(%rbp), %rdi
callq 0x2990
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x67d6
jmp 0x68c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x67a3
movq -0x70(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
addq $0x60, %rdi
callq 0x7fc0
movsd -0x80(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x772a(%rip), %xmm2     # 0xe020
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x772e(%rip), %xmm2     # 0xe030
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::buildInfoString[abi:cxx11]()
std::string NeuralNet::buildInfoString() {
  stringstream ss{};
  getNetworkInfo(ss);
  getLayerInfo(ss);
  getNeuronInfo(ss);
  return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x20e0
movq -0x1b8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
callq 0x6af0
jmp 0x6a67
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x6c10
jmp 0x6a7c
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x6d10
jmp 0x6a91
movq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2180
jmp 0x6aa6
leaq -0x198(%rbp), %rdi
callq 0x2100
movq -0x1c0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2100
movq -0x1a0(%rbp), %rdi
callq 0x2310
nopl (%rax)
// File: gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::getNetworkInfo(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&)
void NeuralNet::getNetworkInfo(stringstream& ss) {
  ss << "NETWORK INFO\n";
  ss << "Number of inputs: " << layers.front().size() << '\n';
  ss << "Number of outputs: " << layers.back().size() << '\n';
  ss << "Number of hidden layers: " << layers.size() - 2 << '\n';
  ss << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7651(%rip), %rsi      # 0xe168
callq 0x2190
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x764b(%rip), %rsi      # 0xe176
callq 0x2190
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0x81f0
movq %rax, %rdi
callq 0x8220
movq -0x30(%rbp), %rdi
movzwl %ax, %esi
callq 0x22d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2210
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7618(%rip), %rsi      # 0xe189
callq 0x2190
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0x8310
movq %rax, %rdi
callq 0x8220
movq -0x28(%rbp), %rdi
movzwl %ax, %esi
callq 0x22d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2210
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x75e6(%rip), %rsi      # 0xe19d
callq 0x2190
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x82e0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
subq $0x2, %rsi
callq 0x2040
movq %rax, %rdi
movl $0xa, %esi
callq 0x2210
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl $0xa, %esi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)