LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %rsi, %r14
movq %rdi, -0x50(%rbp)
movq %rsi, %rdi
callq 0x1e770
movq %r14, %rdi
movsd -0x30(%rbp), %xmm0
movq %r15, -0x48(%rbp)
movq %r15, %rsi
movq %rbx, %rdx
movsd -0x38(%rbp), %xmm1
callq 0x1e810
leaq 0xa0(%r14), %rax
movq %rax, -0x58(%rbp)
leaq 0x70(%r14), %r13
leaq 0xb8(%r14), %rbx
movq %r14, %r12
leaq 0x88(%r14), %r15
xorl %r14d, %r14d
movslq 0x34(%r12), %rax
cmpq %rax, %r14
jg 0x20521
movq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x537c
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x537c
movsd -0x40(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x537c
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x537c
movsd -0x40(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
incq %r14
jmp 0x204b9
movsd 0xadf(%rip), %xmm2      # 0x21008
movq %r12, %rdi
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
callq 0x1fbee
movq %r12, %rdi
movsd -0x30(%rbp), %xmm0
movq -0x48(%rbp), %rsi
movsd -0x38(%rbp), %xmm1
callq 0x2008e
movq -0x50(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x203b2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
andq $0x0, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
xorps %xmm1, %xmm1
movaps %xmm1, -0x20(%rbp)
xorl %r14d, %r14d
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x126f4
cltq
cmpq %rax, %r14
jge 0x20667
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17efc
movsd (%rax), %xmm0
movapd -0x20(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movapd %xmm1, -0x20(%rbp)
movapd 0x351a(%rip), %xmm0     # 0x23af0
andpd %xmm0, %xmm1
movapd %xmm1, -0x50(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17efc
movsd (%rax), %xmm0
andpd 0x34fa(%rip), %xmm0     # 0x23af0
movapd -0x50(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x20620
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17efc
movsd (%rax), %xmm0
subsd -0x28(%rbp), %xmm0
movapd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
jmp 0x20643
movapd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movapd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17efc
movapd -0x20(%rbp), %xmm1
addsd (%rax), %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm1
movsd %xmm1, -0x40(%rbp)
incq %r14
movaps %xmm1, -0x20(%rbp)
jmp 0x20594
leaq -0x60(%rbp), %rbx
leaq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x18028
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/TBody[P]atomicpp/atomicpp/RateEquations.cpp
// Function: atomicpp::RateEquations::printDerivativeStruct(atomicpp::DerivStruct&)
void RateEquations::printDerivativeStruct(DerivStruct& derivative_struct){
	double Pcool             = derivative_struct.Pcool;
	double Prad              = derivative_struct.Prad;
	std::vector<double> dNzk = derivative_struct.dNzk;
	std::vector<double> F_zk = derivative_struct.F_zk;
	double dNe               = derivative_struct.dNe;
	double F_i               = derivative_struct.F_i;
	double dNn               = derivative_struct.dNn;
	double F_n               = derivative_struct.F_n;

	//Print-verifying the return from computeDerivs
	std::printf("Pcool:       %+.2e [J m^-3 s^-1]\n", Pcool);
	std::printf("Prad:        %+.2e [J m^-3 s^-1]\n" , Prad);
	for(int k=0; k<=Z; ++k){
	std::printf("dNz^(%i)/dt:  %+.2e [p m^-3 s^-1]\n",k ,dNzk[k]);
	}
	for(int k=0; k<=Z; ++k){
	std::printf("Fz^(%i):      %+.2e [N]\n",k ,F_zk[k]);
	}
	std::printf("dNe/dt:      %+.2e [p m^-3 s^-1]\n",dNe);
	std::printf("F_i:         %+.2e [N]\n",F_i);
	std::printf("dNn/dt:      %+.2e [p m^-3 s^-1]\n",dNn);
	std::printf("F_n:         %+.2e [N]\n",F_n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x10, %rsi
leaq -0x68(%rbp), %rdi
callq 0x14812
leaq 0x28(%r14), %rsi
leaq -0x80(%rbp), %rdi
callq 0x14812
movsd 0x40(%r14), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x48(%r14), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x50(%r14), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x58(%r14), %xmm0
movsd %xmm0, -0x40(%rbp)
leaq 0x3af9(%rip), %rdi      # 0x241fc
movsd -0x48(%rbp), %xmm0
movb $0x1, %al
callq 0x4080
leaq 0x3b08(%rip), %rdi      # 0x2421e
movsd -0x50(%rbp), %xmm0
movb $0x1, %al
callq 0x4080
xorl %r14d, %r14d
leaq -0x68(%rbp), %r15
leaq 0x3b10(%rip), %r12      # 0x24240
movslq 0x34(%rbx), %rax
cmpq %rax, %r14
jg 0x2075a
movq %r15, %rdi
movq %r14, %rsi
callq 0x537c
movsd (%rax), %xmm0
movq %r12, %rdi
movl %r14d, %esi
movb $0x1, %al
callq 0x4080
incq %r14
jmp 0x20730
xorl %r14d, %r14d
leaq -0x80(%rbp), %r15
leaq 0x3afb(%rip), %r12      # 0x24263
cltq
cmpq %rax, %r14
jg 0x20793
movq %r15, %rdi
movq %r14, %rsi
callq 0x537c
movsd (%rax), %xmm0
movq %r12, %rdi
movl %r14d, %esi
movb $0x1, %al
callq 0x4080
incq %r14
movl 0x34(%rbx), %eax
jmp 0x20768
leaq 0x3ae2(%rip), %rdi      # 0x2427c
movsd -0x28(%rbp), %xmm0
movb $0x1, %al
callq 0x4080
leaq 0x3af1(%rip), %rdi      # 0x2429e
movsd -0x30(%rbp), %xmm0
movb $0x1, %al
callq 0x4080
leaq 0x3af6(%rip), %rdi      # 0x242b6
movsd -0x38(%rbp), %xmm0
movb $0x1, %al
callq 0x4080
leaq 0x3b05(%rip), %rdi      # 0x242d8
movsd -0x40(%rbp), %xmm0
movb $0x1, %al
callq 0x4080
leaq -0x80(%rbp), %rdi
callq 0x53a6
leaq -0x68(%rbp), %rdi
callq 0x53a6
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x53a6
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r15
callq 0x24ba
addsd %xmm0, %xmm0
addsd 0x3b69(%rip), %xmm0     # 0x6008
cmpq %r15, %r14
je 0x24af
movsd %xmm0, (%r14)
addq $0x8, %r14
jmp 0x248e
movsd %xmm0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x2710, %rsp           # imm = 0x2710
leaq 0x1388(%rsp), %rdi
callq 0x2692
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x26d4
movq %rbx, %rdi
callq 0x2190
movl %eax, %esi
leaq 0x1388(%rsp), %rdi
callq 0x269c
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x272a
andq $0x0, (%rbx)
movq $0x64, 0x8(%rbx)
movq %rsp, %rdi
leaq 0x1388(%rsp), %rsi
callq 0x273a
movq %rax, %xmm1
punpckldq 0x3afb(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3b03(%rip), %xmm1     # 0x6030
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd 0x3acf(%rip), %xmm0     # 0x6010
addq $0x2710, %rsp           # imm = 0x2710
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x272a
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
shrq $0x3, %rax
andq $0x0, 0x8(%rdi)
leaq 0x20(%rdi), %r15
movl %eax, %r13d
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x25cd
movq %r15, %rdi
movq %r12, %rsi
callq 0x264c
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x264c
movsd 0x8(%rsp), %xmm1
mulsd (%rax), %xmm1
addsd 0x8(%rbx), %xmm1
movsd %xmm1, 0x8(%rbx)
incq %r12
jmp 0x258f
movsd 0x10(%rbx), %xmm0
mulsd 0x18(%rbx), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x266e
movsd %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl %esi, %esi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2d50
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f4e
movq %r15, %rdi
callq 0x2da2
movzwl %bp, %r15d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x25fa
leaq 0x10(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2926
movq %r12, %rdi
callq 0x281e
movq 0x18(%rbx), %r12
movq 0x20(%rbx), %r13
cmpq %r13, %r12
je 0x2c72
movq %r12, %rdi
movl %r15d, %esi
callq 0x243c
addq $0x40, %r12
jmp 0x2c5c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c85
jmp 0x2c85
movq %rax, %r15
movq %r14, %rdi
callq 0x2da2
movq %rbx, %rdi
callq 0x281e
movq %r15, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %r15
cmpq %r15, %r14
je 0x2d33
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e12
addq $0x40, %r14
jmp 0x2d1d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x281e
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
movq 0x18(%rdi), %rax
movl 0x20(%rax), %ecx
subl 0x18(%rax), %ecx
leaq 0x18(%rdi), %rbx
shrl $0x6, %ecx
movzwl %cx, %r15d
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x3339
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x264c
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
callq 0x479e
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r14
jmp 0x3303
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x47c0
movq %rax, %r13
movq (%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2d02
movq %r13, %rdi
movq %r14, %rsi
callq 0x4830
leaq 0x20(%rsp), %rdi
callq 0x281e
movq 0x20(%r12), %rax
subq 0x18(%r12), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movzwl %ax, %r13d
leal -0x1(%r13), %ebp
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq %r13, %r15
jae 0x33f5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x47c0
movq %rax, %rdi
callq 0x2ca0
leaq 0x1(%r15), %r12
cmpq %r15, %rbp
je 0x33f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x47c0
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x47c0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x2d02
movq %r14, %rdi
movq %r15, %rsi
callq 0x4830
movq %r15, %rdi
callq 0x281e
movq %r12, %r15
jmp 0x3393
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, (%rsp)
jmp 0x340a
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x281e
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movl 0x78(%rdi), %eax
movq 0x20(%rdi), %rcx
movq 0x30(%rdi), %rdx
movq 0x48(%rdi), %rsi
xorpd %xmm2, %xmm2
xorl %r8d, %r8d
movsd 0x2cc3(%rip), %xmm0     # 0x6118
cmpq %rax, %r8
je 0x34a4
movl -0x10(%rcx), %r9d
subl -0x18(%rcx), %r9d
shrl $0x6, %r9d
movzwl %r9w, %r9d
imulq $0x18, %r8, %r10
leaq (%rsi,%r10), %r11
addq %rdx, %r10
xorl %ebx, %ebx
cmpq %rbx, %r9
je 0x349f
movq (%r11), %r14
movsd (%r14,%rbx,8), %xmm1
movq (%r10), %r14
subsd (%r14,%rbx,8), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm2
incq %rbx
jmp 0x3477
incq %r8
jmp 0x3455
movq 0x68(%rdi), %rax
subq 0x60(%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movzwl %ax, %eax
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0x80(%rdi), %xmm0
mulsd 0x2c43(%rip), %xmm0     # 0x6118
movsd %xmm0, 0x8(%rsp)
callq 0x3900
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rdi), %r14
movq 0x20(%rdi), %rax
movq %rdi, 0x8(%rsp)
subq 0x18(%rdi), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movzwl %ax, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
pushq $0x1
popq %r15
leaq 0x10(%rsp), %r12
cmpq %rbp, %r15
jae 0x39c7
movq %r14, %rdi
movq %r15, %rsi
callq 0x47c0
movl 0x20(%rax), %ecx
subl 0x18(%rax), %ecx
shrl $0x6, %ecx
movzwl %cx, %ebx
xorl %r13d, %r13d
cmpq %rbx, %r13
je 0x39bf
movq %r14, %rdi
movq %r15, %rsi
callq 0x47c0
leaq 0x18(%rax), %rdi
movq %r13, %rsi
callq 0x479e
leaq 0x20(%rax), %rsi
movq %r12, %rdi
callq 0x2dc4
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movsd (%rsp), %xmm1
cmpq %rcx, %rax
je 0x39ad
movsd (%rax), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
addq $0x8, %rax
jmp 0x3996
movsd %xmm1, (%rsp)
movq %r12, %rdi
callq 0x281e
incq %r13
jmp 0x395f
incq %r15
jmp 0x393c
movq 0x8(%rsp), %rcx
movq 0x68(%rcx), %rax
subq 0x60(%rcx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %xmm0
punpckldq 0x2637(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x263f(%rip), %xmm0     # 0x6030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b04
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3bd6
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3cae
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x10(%rsi), %rbx
leaq 0x2657(%rip), %rsi      # 0x6170
movq %rbx, %rdi
callq 0x2150
leaq 0x2656(%rip), %rsi      # 0x617e
movq %rbx, %rdi
callq 0x2150
movq 0x18(%r14), %rcx
movl 0x20(%rcx), %esi
subl 0x18(%rcx), %esi
shrl $0x6, %esi
movl $0xffff, %r15d          # imm = 0xFFFF
andl %r15d, %esi
movq %rax, %rdi
callq 0x2230
pushq $0xa
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x2180
leaq 0x262f(%rip), %rsi      # 0x6191
movq %rbx, %rdi
callq 0x2150
movq 0x20(%r14), %rcx
movl -0x10(%rcx), %esi
subl -0x18(%rcx), %esi
shrl $0x6, %esi
andl %r15d, %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
movl %ebp, %esi
callq 0x2180
leaq 0x2612(%rip), %rsi      # 0x61a5
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
leaq -0x2(%rax), %rsi
callq 0x20c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2180
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::getNeuronInfo(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&)
void NeuralNet::getNeuronInfo(stringstream &ss) {
  ss << "DETAILED INFO\n";

  // print detailed info of all layers starting from the first hidden layer
  unsigned short count  = layers.size();

  for(auto i = 1; i < count; i++) {

    if(i == count - 1) ss << "Output Layer\n";
    else
        ss << "Hidden Layer " << i << '\n';

    unsigned short current_layer_size = layers.at(i).size();
    for(auto j = 0; j < current_layer_size; j++) {
      ss << "Neuron " << j+1 << ": weights ( ";

      for(auto weight : layers.at(i).neurons.at(j).weights) {
        ss << weight << " ";
      }

      ss << ") , threshold ( " << layers.at(i).neurons.at(j).threshold << " )\n";
    }

    ss << '\n';
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x10, %rbx
leaq 0x2514(%rip), %rsi      # 0x61e1
movq %rbx, %rdi
callq 0x2150
leaq 0x18(%r15), %rcx
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
movq %rcx, %r15
pushq $0x30
popq %rcx
cqto
idivq %rcx
movzwl %ax, %eax
movq %rax, 0x8(%rsp)
decl %eax
movq %rax, (%rsp)
pushq $0x1
popq %r13
leaq 0x2523(%rip), %r12      # 0x6228
cmpq 0x8(%rsp), %r13
jae 0x3e58
cmpq (%rsp), %r13
jne 0x3d27
movq %rbx, %rdi
leaq 0x24d0(%rip), %rsi      # 0x61f0
callq 0x2150
jmp 0x3d4c
movq %rbx, %rdi
leaq 0x24cd(%rip), %rsi      # 0x61fe
callq 0x2150
movq %rax, %rdi
movl %r13d, %esi
callq 0x2250
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x2180
movq %r15, %rdi
movq %r13, %rsi
callq 0x47c0
movl 0x20(%rax), %ecx
subl 0x18(%rax), %ecx
shrl $0x6, %ecx
movzwl %cx, %eax
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
movq %r13, 0x10(%rsp)
cmpq 0x18(%rsp), %rbp
je 0x3e45
movq %rbx, %rdi
leaq 0x25af(%rip), %rsi      # 0x6333
callq 0x2150
leaq 0x1(%rbp), %rsi
movq %rax, %rdi
movq %rsi, 0x20(%rsp)
callq 0x2250
movq %rax, %rdi
leaq 0x2468(%rip), %rsi      # 0x620c
callq 0x2150
movq %r13, %rsi
movq %r15, %r13
movq %r15, %rdi
callq 0x47c0
leaq 0x18(%rax), %rdi
movq %rbp, %rsi
callq 0x479e
movq 0x20(%rax), %r14
movq 0x28(%rax), %r15
cmpq %r15, %r14
je 0x3dee
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
addq $0x8, %r14
jmp 0x3dcb
movq %rbx, %rdi
leaq 0x2421(%rip), %rsi      # 0x6219
callq 0x2150
movq %rax, %r14
movq %r13, %r15
movq %r13, %rdi
movq 0x10(%rsp), %r13
movq %r13, %rsi
callq 0x47c0
leaq 0x18(%rax), %rdi
movq %rbp, %rsi
callq 0x479e
movsd 0x18(%rax), %xmm0
movq %r14, %rdi
callq 0x21f0
movq %rax, %rdi
leaq 0x23f4(%rip), %rsi      # 0x622a
callq 0x2150
movq 0x20(%rsp), %rbp
jmp 0x3d6f
movq %rbx, %rdi
pushq $0xa
popq %rsi
callq 0x2180
incq %r13
jmp 0x3d05
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::buildCodeString[abi:cxx11]()
std::string NeuralNet::buildCodeString() {
    stringstream ss{};
    includeHeaders(ss);
    writeBody(ss);
    return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x20d0
movq %r15, %rsi
callq 0x3f46
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3f88
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::includeHeaders(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&)
void NeuralNet::includeHeaders(stringstream& ss) {
    ss << "#include <StandardCplusplus.h>\n";
    ss << "#include <system_configuration.h>\n";
    ss << "#include \"neuralnet.h\"\n\n";
    ss << "using namespace std;\n\n";
}

// Assembly:
pushq %rbx
leaq 0x10(%rsi), %rbx
leaq 0x22dc(%rip), %rsi      # 0x622e
movq %rbx, %rdi
callq 0x2150
leaq 0x22ed(%rip), %rsi      # 0x624e
movq %rbx, %rdi
callq 0x2150
leaq 0x2301(%rip), %rsi      # 0x6271
movq %rbx, %rdi
callq 0x2150
leaq 0x230b(%rip), %rsi      # 0x628a
movq %rbx, %rdi
popq %rbx
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/gkosae[P]ArduinoNeuralNet/main.cpp
// Function: createInputSamples()
vector<vector<double>> createInputSamples() {

  cout << "Entering createInputSamples" << endl;

  vector<vector<double>> samples{};
  vector<double> buffer{};
  double temp = 0;

  string input_data_file = "training_data/processed_inputs.dat";

  ifstream ifs{input_data_file};

  while(ifs >> temp) {

      buffer.clear();
      buffer.push_back(temp/NORMALIZER);

      for(auto i = 0; i < 9; ++i) {
        ifs >> temp;
        buffer.push_back(temp/NORMALIZER);
      }
   samples.push_back(buffer);
 }

  number_of_samples = samples.size();
  cout << "Leaving createInputSamples" << endl;
  return samples;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %rbx
movq 0x4fc3(%rip), %rdi      # 0x9fd8
leaq 0x14c2(%rip), %rsi      # 0x64de
callq 0x2150
movq %rax, %rdi
callq 0x2090
xorpd %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movq %rbx, 0x8(%rsp)
movupd %xmm0, (%rbx)
andq $0x0, 0x30(%rsp)
movapd %xmm0, 0x20(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x14a6(%rip), %rsi      # 0x64fa
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x2742
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x2200
leaq 0x60(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
leaq 0x18(%rsp), %r13
pushq $0x9
popq %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x20b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x511a
movq 0x20(%rsp), %rax
cmpq %rax, 0x28(%rsp)
je 0x50b6
movq %rax, 0x28(%rsp)
movsd 0x10(%rsp), %xmm0
divsd 0xf4c(%rip), %xmm0      # 0x6010
movsd %xmm0, 0x18(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5a1c
movl %ebx, %ebp
subl $0x1, %ebp
jb 0x5108
movq %r14, %rdi
movq %r15, %rsi
callq 0x20b0
movsd 0x10(%rsp), %xmm0
divsd 0xf1b(%rip), %xmm0      # 0x6010
movsd %xmm0, 0x18(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5a1c
jmp 0x50d7
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x55e0
jmp 0x508c
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl %eax, 0x503c(%rip)      # 0xa170
movq 0x4e9d(%rip), %rdi      # 0x9fd8
leaq 0x13db(%rip), %rsi      # 0x651d
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x60(%rsp), %rdi
callq 0x2030
leaq 0x40(%rsp), %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
callq 0x281e
movq 0x8(%rsp), %rax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x51a3
movq %rax, %r14
jmp 0x51ad
jmp 0x5196
jmp 0x5196
jmp 0x5196
jmp 0x5196
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x2030
leaq 0x40(%rsp), %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
callq 0x281e
movq 0x8(%rsp), %rdi
callq 0x473e
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/gkosae[P]ArduinoNeuralNet/main.cpp
// Function: createOutputSamples()
vector<vector<double>> createOutputSamples() {

  cout << "Entering createOutputSamples" << endl;
  vector<vector<double>> samples{};

  for(auto i = 0; i < number_of_samples; ++i) {
    samples.push_back(vector<double>{18.00/NORMALIZER, 50.00/NORMALIZER});
  }

  cout << "Leaving createOutputSamples" << endl;

  return samples;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x4df7(%rip), %rdi      # 0x9fd8
leaq 0x1350(%rip), %rsi      # 0x6538
callq 0x2150
movq %rax, %rdi
callq 0x2090
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %ebp, %ebp
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r15
pushq $0x2
popq %r12
leaq 0xf(%rsp), %r13
cmpl 0x4f55(%rip), %ebp      # 0xa170
jge 0x5251
movaps 0x127c(%rip), %xmm0     # 0x64a0
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x560c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d38
movq %r14, %rdi
callq 0x281e
incl %ebp
jmp 0x5215
movq 0x4d80(%rip), %rdi      # 0x9fd8
leaq 0x12f6(%rip), %rsi      # 0x6555
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x528f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x281e
jmp 0x5292
movq %rax, %r14
movq %rbx, %rdi
callq 0x473e
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/gkosae[P]ArduinoNeuralNet/main.cpp
// Function: testNetwork(NeuralNet&)
void testNetwork(NeuralNet& network) {

    vector<double> input_one{25.04, 25, 25, 25, 25, 30, 22, 31, 25, 28};
    vector<double> input_two{34, 31, 26, 22, 21, 35, 22, 31, 25, 18};
    vector<double> input_three{22.04, 35, 29.55, 23, 26, 31, 33, 21, 22, 41};
    vector<double> input_four{50, 50, 50, 50, 50, 50, 50, 50, 50, 50};

    printResults(network, input_one);
    printResults(network, input_two);
    printResults(network, input_three);
    printResults(network, input_four);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x12d2(%rip), %rsi      # 0x6588
pushq $0xa
popq %r14
leaq 0x68(%rsp), %rax
movq %r14, %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rcx
movq %rax, %rsi
movq %r14, %rdx
callq 0x560c
leaq 0x12f4(%rip), %rsi      # 0x65d8
leaq 0x68(%rsp), %rax
movq %r14, %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rcx
movq %rax, %rsi
movq %r14, %rdx
callq 0x560c
leaq 0x131a(%rip), %rsi      # 0x6628
pushq $0xa
popq %rdx
leaq 0x68(%rsp), %rax
movq %rdx, %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %rax, %rsi
callq 0x560c
leaq 0x1340(%rip), %rsi      # 0x6678
pushq $0xa
popq %rdx
leaq 0x68(%rsp), %rax
movq %rdx, %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movq %rax, %rsi
callq 0x560c
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x5404
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x5404
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5404
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5404
leaq 0x8(%rsp), %rdi
callq 0x281e
leaq 0x20(%rsp), %rdi
callq 0x281e
leaq 0x38(%rsp), %rdi
callq 0x281e
leaq 0x50(%rsp), %rdi
callq 0x281e
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x53de
movq %rax, %rbx
jmp 0x53e8
movq %rax, %rbx
jmp 0x53f2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x281e
leaq 0x20(%rsp), %rdi
callq 0x281e
leaq 0x38(%rsp), %rdi
callq 0x281e
leaq 0x50(%rsp), %rdi
callq 0x281e
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/gkosae[P]ArduinoNeuralNet/main.cpp
// Function: printResults(NeuralNet&, std::vector<double, std::allocator<double>>&)
void printResults(NeuralNet& network, vector<double>& inputs) {

    cout << "Inputs: ";
    for(auto& input : inputs) {
      cout << input << " ";
      input = input/NORMALIZER;
    }

    cout << endl;

    network.feed(inputs);
    network.forward();
    vector<double> outputs = network.getOutputs();

    cout << "Outputs: ";
    for(auto& output : outputs) {
      output = output * NORMALIZER;
      cout << output << " ";
    }

    cout << endl << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4bb9(%rip), %r15      # 0x9fd8
leaq 0x114b(%rip), %rsi      # 0x6571
movq %r15, %rdi
callq 0x2150
movq (%r14), %r13
movq 0x8(%r14), %rbp
leaq 0xdec(%rip), %r12       # 0x6228
cmpq %rbp, %r13
je 0x5474
movsd (%r13), %xmm0
movq %r15, %rdi
callq 0x21f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
movsd (%r13), %xmm0
divsd 0xba8(%rip), %xmm0      # 0x6010
movsd %xmm0, (%r13)
addq $0x8, %r13
jmp 0x543c
movq 0x4b5d(%rip), %rdi      # 0x9fd8
callq 0x2090
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2dc4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4760
leaq 0x20(%rsp), %rdi
callq 0x281e
movq %rbx, %rdi
callq 0x32da
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4788
movq 0x4b17(%rip), %rdi      # 0x9fd8
leaq 0x10b2(%rip), %rsi      # 0x657a
callq 0x2150
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r12
movq 0x4afa(%rip), %rbx      # 0x9fd8
leaq 0xd43(%rip), %r14       # 0x6228
cmpq %r12, %r15
je 0x5515
movsd (%r15), %xmm0
mulsd 0xb19(%rip), %xmm0      # 0x6010
movsd %xmm0, (%r15)
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2150
addq $0x8, %r15
jmp 0x54e5
movq 0x4abc(%rip), %rdi      # 0x9fd8
callq 0x2090
movq %rax, %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x281e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x5556
jmp 0x554e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x281e
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/book.cc
// Function: main
int main()
{
    // use the hypothetical bookstore exceptions 
    Sales_data item1, item2, sum;
    while (cin >> item1 >> item2) {  // read two transactions
        try {
            sum = item1 + item2;     // calculate their sum
            // use sum
        } catch (const isbn_mismatch &e) {
          cerr << e.what() << ": left isbn(" << e.left
               << ") right isbn(" << e.right << ")" << endl;
        }
    }
     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq -0xb0(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x2c34(%rip), %rbx      # 0x4fd8
leaq -0xc0(%rbp), %r14
leaq -0x90(%rbp), %r15
leaq -0xf0(%rbp), %r12
leaq -0x60(%rbp), %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2748
movq %rax, %rdi
movq %r15, %rsi
callq 0x2748
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2499
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2690
movq %r13, %rdi
movq %r12, %rsi
callq 0x2512
movq %r12, %rdi
callq 0x2080
jmp 0x23bd
movq %rax, -0x30(%rbp)
cmpl $0x1, %edx
jne 0x24e7
movq -0x30(%rbp), %rdi
callq 0x2060
movq %rax, %rdi
movq (%rax), %rax
movq %rdi, -0x30(%rbp)
callq *0x10(%rax)
movq 0x2bbe(%rip), %rdi      # 0x4ff0
movq %rax, %rsi
callq 0x2100
movq %rax, %rdi
leaq 0xbd0(%rip), %rsi       # 0x3014
callq 0x2100
movq -0x30(%rbp), %rcx
leaq 0x10(%rcx), %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0xbbe(%rip), %rsi       # 0x3021
callq 0x2100
movq -0x30(%rbp), %rsi
addq $0x30, %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0xbad(%rip), %rsi       # 0x302f
callq 0x2100
movq %rax, %rdi
callq 0x2090
callq 0x2170
jmp 0x23bd
leaq -0x60(%rbp), %rdi
callq 0x2080
leaq -0x90(%rbp), %rdi
callq 0x2080
leaq -0xc0(%rbp), %rdi
callq 0x2080
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24e3
movq %rax, -0x30(%rbp)
callq 0x2170
jmp 0x24e7
movq %rax, %rdi
callq 0x2535
movq %rax, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2080
leaq -0x90(%rbp), %rdi
callq 0x2080
leaq -0xc0(%rbp), %rdi
callq 0x2080
movq -0x30(%rbp), %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/Sales_data.cc
// Function: Sales_data::operator+=(Sales_data const&)
Sales_data& Sales_data::operator+=(const Sales_data &rhs)
{
    if (isbn() != rhs.isbn())
        throw isbn_mismatch("wrong isbns", isbn(), rhs.isbn());
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x2140
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x2140
leaq -0x50(%rbp), %rbx
leaq -0x70(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a09
movl %eax, %r13d
movq %r12, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2080
testb %r13b, %r13b
jne 0x25ca
movl 0x20(%r14), %eax
addl %eax, 0x20(%r15)
movsd 0x28(%r14), %xmm0
addsd 0x28(%r15), %xmm0
movsd %xmm0, 0x28(%r15)
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0xa55(%rip), %rsi       # 0x3031
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x2050
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0x2140
leaq -0x90(%rbp), %rdi
movq %r14, %rsi
callq 0x2140
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movq %rbx, %rdi
callq 0x2a16
xorl %r15d, %r15d
leaq 0x2748(%rip), %rsi      # 0x4d70
leaq 0x44f(%rip), %rdx       # 0x2a7e
movq %rbx, %rdi
callq 0x2180
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0x2080
jmp 0x264e
movq %rax, %r14
movb $0x1, %r15b
leaq -0x70(%rbp), %rdi
callq 0x2080
jmp 0x265f
movq %rax, %r14
movb $0x1, %r15b
leaq -0x50(%rbp), %rdi
callq 0x2080
testb %r15b, %r15b
jne 0x2672
jmp 0x2688
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
jmp 0x2688
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2080
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/Necrelox[P]Auto_Presence/src/main.cpp
// Function: main
int main(int ac, char **av)
{
    try
    {
        if (ac < 4 || ac > 5)
            throw CError("Error number of arguments");
        else {
            automatic_presence presence(ac, av);
            presence.AutomaticPresence();
            return OK;
        }
    }
    catch(const CError& e)
    {
        std::cerr << e.get_error_msg() << '\n';
        if (ac < 4 || ac > 5)
            std::cout << "\nFor use Precense : \n\t./presence (file of meetingAttendanceReport by Teams) (Hour of start activity) (Hour of end activity) [limit late]" << std::endl;
    }
    return ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp            # imm = 0x260
movq %rsi, %rdx
movl %edi, %esi
leal -0x6(%rsi), %ebp
cmpl $-0x3, %ebp
jbe 0x4700
leaq 0x8(%rsp), %rdi
callq 0x357c
leaq 0x8(%rsp), %rdi
callq 0x3a9a
leaq 0x8(%rsp), %rdi
callq 0x3a5c
xorl %eax, %eax
addq $0x260, %rsp            # imm = 0x260
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x3140
movq %rax, %r14
leaq 0xa77(%rip), %rsi       # 0x5189
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x4086
movb $0x1, %r12b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4806
xorl %r12d, %r12d
leaq 0x3635(%rip), %rsi      # 0x7d70
leaq -0x57e(%rip), %rdx      # 0x41c4
movq %r14, %rdi
callq 0x3340
movq %rdx, %r15
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3100
testb %r12b, %r12b
jne 0x4767
jmp 0x4789
movq %rdx, %r15
movq %rax, %rbx
movq %r14, %rdi
callq 0x3180
jmp 0x4789
movq %rdx, %r15
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3a5c
jmp 0x4789
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x1, %r15d
jne 0x47ee
movq %rbx, %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x4800
movq 0x384a(%rip), %rdi      # 0x7ff0
movq %rax, %rsi
callq 0x3200
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3270
cmpl $-0x3, %ebp
ja 0x47d9
movq 0x380b(%rip), %rdi      # 0x7fd0
leaq 0x9d7(%rip), %rsi       # 0x51a3
callq 0x3220
movq %rax, %rdi
callq 0x3130
callq 0x3310
pushq $-0x1
popq %rax
jmp 0x46f0
movq %rax, %rbx
callq 0x3310
movq %rbx, %rdi
callq 0x3350
movq %rax, %rdi
callq 0x41e4
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/exercises/ex11_07.cc
// Function: main
int main(int argc, char const *argv[])
{
	map<string, vector<string>> families;

	for (string last_name; cout << "Input family's last name:" << endl, cin >> last_name;) {
		for (string child_name; cout << "Input children's name:" << endl, cin >> child_name;) {
			families[last_name].push_back(child_name);
		}
		cin.clear();
	}
	cout << "===========================" << endl;

	for (const auto& family : families) {
		cout << family.first << ":" << endl;
		for (const auto& child : family.second)
			cout << child << " ";
		cout << endl;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq -0x90(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2ca0(%rip), %rbx      # 0x4fd0
movq 0x2ca9(%rip), %r15      # 0x4fe0
leaq -0x68(%rbp), %r12
leaq 0xcdc(%rip), %r13       # 0x301e
leaq -0x48(%rbp), %r14
movq %rbx, %rdi
leaq 0xcb4(%rip), %rsi       # 0x3004
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23ed
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
movq %r14, %rsi
callq 0x2130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23cf
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
callq 0x24e4
movq %rax, %rdi
movq %r14, %rsi
callq 0x254e
jmp 0x2387
movq %r14, %rdi
callq 0x2080
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x2190
jmp 0x2346
leaq -0x68(%rbp), %rdi
callq 0x2080
movq 0x2bd3(%rip), %rdi      # 0x4fd0
leaq 0xc31(%rip), %rsi       # 0x3035
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq -0x80(%rbp), %r15
movq 0x2bb4(%rip), %rbx      # 0x4fd0
leaq 0xc2e(%rip), %r12       # 0x3051
leaq -0x90(%rbp), %rax
cmpq %rax, %r15
je 0x2490
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x20e0
movq %rax, %rdi
leaq 0xbee(%rip), %rsi       # 0x3033
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq 0x40(%r15), %r13
movq 0x48(%r15), %r14
cmpq %r14, %r13
je 0x247b
movq %rbx, %rdi
movq %r13, %rsi
callq 0x20e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x20f0
addq $0x20, %r13
jmp 0x245a
movq %rbx, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x20b0
movq %rax, %r15
jmp 0x2423
leaq -0x98(%rbp), %rdi
callq 0x2598
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24b6
jmp 0x24b6
movq %rax, %rbx
jmp 0x24c7
movq %rax, %rbx
jmp 0x24d0
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2080
leaq -0x68(%rbp), %rdi
callq 0x2080
leaq -0x98(%rbp), %rdi
callq 0x2598
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/dsudheerdantuluri[P]quantlab/TradeStreamReader.cc
// Function: TradeStreamReader::next()
Trade TradeStreamReader::next()
{
  std::string line;
  getline(m_fs, line);
  std::vector<std::string> tokens = split(line, ',');
  return Trade(stoul(tokens[0]), 
               tokens[1], 
               stoul(tokens[2]), 
               stoul(tokens[3]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq -0x48(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x3060
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
pushq $0x2c
popq %rcx
callq 0x43f2
movq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x4504
movq %rax, %r14
movq -0x38(%rbp), %r15
leaq 0x40(%r15), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x4504
movq %rax, %r12
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x4504
addq $0x20, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x487c
leaq -0x38(%rbp), %rdi
callq 0x4526
leaq -0x58(%rbp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43cf
movq %rax, %rbx
jmp 0x43e0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4526
leaq -0x58(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dsudheerdantuluri[P]quantlab/TradeStreamReader.cc
// Function: TradeStreamReader::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> TradeStreamReader::split(const std::string& s, 
                                                  char delimiter)
{
  std::vector<std::string> tokens;
  std::string token;
  std::istringstream tokenStream(s);
  while (std::getline(tokenStream, token, delimiter)) {
    tokens.push_back(token);
  }
  return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %ecx, %r14d
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x1c0(%rbp), %rdi
pushq $0x8
popq %rax
movq %rdx, %rsi
movl %eax, %edx
callq 0x32e0
movsbl %r14b, %r14d
leaq -0x1c0(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x3300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4471
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4552
jmp 0x4448
leaq -0x1c0(%rbp), %rdi
callq 0x3130
leaq -0x40(%rbp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x44ad
movq %rax, %r14
leaq -0x1c0(%rbp), %rdi
callq 0x3130
leaq -0x40(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x4526
movq %r14, %rdi
callq 0x32f0