LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/net.cpp
// Function: Net::Net(std::vector<unsigned int, std::allocator<unsigned int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Net::Net(const vector<unsigned> &topology,const string &transferFunction){
	// size
 	unsigned numberOfLayers = topology.size();

 	//create a new  Layer on each interation
 	for (unsigned layerNumber = 0; layerNumber < numberOfLayers; layerNumber++){
 		layers.push_back(Layer());

 		//number of outputs to a neuron
		unsigned numberOutputs= (layerNumber==topology.size()-1) ? 0: topology[layerNumber+1] ;

 		// fill layer wiith neurons and  add bias neuron to the layer;
 		for (unsigned neuronNumber = 0; neuronNumber <= topology[layerNumber] ; neuronNumber++){
			layers.back().push_back(Neuron(numberOutputs,neuronNumber,transferFunction));
 		}
 	}

 	// Force the bias node's output to 1.0 (it was the last neuron pushed in this layer):
    layers.back().back().setOutputValue(1.0);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, -0x50(%rbp)
leaq 0x20(%rdi), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rdi)
movq %rdi, -0x38(%rbp)
movaps %xmm0, 0x20(%rdi)
movq 0x8(%rsi), %rax
movq %rsi, -0x40(%rbp)
subq (%rsi), %rax
shrq $0x2, %rax
movl %eax, %eax
movq %rax, -0x48(%rbp)
xorl %r12d, %r12d
leaq -0xb0(%rbp), %r13
cmpq -0x48(%rbp), %r12
je 0x265f
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
andq $0x0, -0xa0(%rbp)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x2b32
movq %r13, %rdi
callq 0x2a20
movq -0x40(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
decq %rcx
xorl %ebx, %ebx
movl $0x0, %r14d
cmpq %r12, %rcx
je 0x2651
movl 0x4(%rax,%r12,4), %r14d
jmp 0x2651
movq -0x38(%rbp), %rax
movq 0x28(%rax), %r15
movq %r13, %rdi
movl %r14d, %esi
movl %ebx, %edx
movq -0x50(%rbp), %rcx
callq 0x3ffa
addq $-0x18, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x2d52
movq %r13, %rdi
callq 0x2a4c
incl %ebx
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpl (%rax,%r12,4), %ebx
jbe 0x2618
incq %r12
jmp 0x25bf
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rax), %rdi
addq $-0x60, %rdi
fld1
fstpt (%rsp)
callq 0x409c
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x269e
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2a20
jmp 0x26b2
movq %rax, %rbx
jmp 0x26b2
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2a4c
movq -0x30(%rbp), %rdi
callq 0x2a70
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/net.cpp
// Function: Net::feedForward(std::vector<double, std::allocator<double>> const&)
void Net::feedForward(const vector<double> &inputValues){
	assert(inputValues.size()==layers[0].size() - 1 && " the inputValues size needs to be the same of the first layer - bias");

	for (unsigned i = 0; i < inputValues.size(); i++)	{
		layers[0][i].setOutputValue(inputValues[i]);
	}

	//forward propagation
 	//loop each layer and each neuron inside the layer
 	for (unsigned layerNumber = 1; layerNumber <= layers.size(); layerNumber++){
 		Layer &prevLayer = layers[layerNumber-1];
 		for (unsigned n = 0; n < layers[layerNumber].size(); n++){
 			layers[layerNumber][n].feedForward(prevLayer);
 		}
 	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
movq 0x20(%rbx), %rdx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x3, %rdi
pushq $0x60
popq %r8
cqto
idivq %r8
decq %rax
cmpq %rax, %rdi
jne 0x27bb
xorl %eax, %eax
movl %eax, %r15d
subq %rcx, %rsi
sarq $0x3, %rsi
cmpq %r15, %rsi
jbe 0x2741
movq 0x20(%rbx), %rax
imulq $0x60, %r15, %rdi
addq (%rax), %rdi
fldl (%rcx,%r15,8)
fstpt (%rsp)
callq 0x409c
leal 0x1(%r15), %eax
movq (%r14), %rcx
movq 0x8(%r14), %rsi
jmp 0x270e
movq 0x20(%rbx), %rcx
pushq $0x1
popq %r12
movl %r12d, %r12d
movq 0x28(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %r12, %rax
jb 0x27ac
leal -0x1(%r12), %eax
imulq $0x18, %rax, %r14
addq %rcx, %r14
xorl %eax, %eax
imulq $0x18, %r12, %r13
movl %eax, %r15d
movq (%rcx,%r13), %rdi
movq 0x8(%rcx,%r13), %rax
subq %rdi, %rax
cqto
pushq $0x60
popq %rsi
idivq %rsi
cmpq %r15, %rax
jbe 0x27a7
imulq $0x60, %r15, %rax
addq %rax, %rdi
movq %r14, %rsi
callq 0x4168
leal 0x1(%r15), %eax
movq 0x20(%rbx), %rcx
jmp 0x2772
incl %r12d
jmp 0x2749
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2862(%rip), %rdi      # 0x5024
leaq 0x28ce(%rip), %rsi      # 0x5097
leaq 0x28d6(%rip), %rcx      # 0x50a6
pushq $0x1b
popq %rdx
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/neural-net.cpp
// Function: showVectorValues(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void showVectorValues(string label, vector<double> &v,ofstream &file){
    file << label << " ";
    for (unsigned i = 0; i < v.size(); i++) {
        file << v[i] << " ";
    }
    file << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rdx, %rdi
callq 0x21b0
leaq 0x1fb1(%rip), %r15      # 0x50f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21f0
xorl %eax, %eax
movl %eax, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x3182
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x22d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21f0
leal 0x1(%r12), %eax
jmp 0x314c
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/neural-net.cpp
// Function: showTestVectorValues(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void showTestVectorValues(string label, vector<double> &v,ofstream &file){
    file << label << " ";
    for (unsigned i = 0; i < v.size(); i++) {
        file << v[i] <<" : "<<round(v[i]) << " ";
    }
    file << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rdx, %rdi
callq 0x21b0
leaq 0x1f38(%rip), %rsi      # 0x50f0
movq %rax, %rdi
callq 0x21f0
xorl %eax, %eax
leaq 0x1f25(%rip), %r12      # 0x50ee
movl %eax, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x3226
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x22d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21f0
movq %rax, %r13
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm0
callq 0x20d0
movq %r13, %rdi
callq 0x22d0
movq %rax, %rdi
leaq 0x1ed5(%rip), %rsi      # 0x50f0
callq 0x21f0
leal 0x1(%r15), %eax
jmp 0x31c9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::Neuron(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Neuron::Neuron(unsigned numberOutputs, unsigned index,  const string &transferFunction){
	for (unsigned c = 0; c < numberOutputs; c++){
		outputWeights.push_back(Connection());
	}
	this->index=index;
	this->transferFunction=transferFunction;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, -0x38(%rbp)
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r13
leaq 0x20(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x48(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
andq $0x0, 0x58(%rdi)
leaq -0x60(%rbp), %r15
subl $0x1, %ebx
jb 0x405e
movq %r15, %rdi
callq 0x252c
movq %r14, %rdi
movq %r15, %rsi
callq 0x4362
jmp 0x4044
movl %r12d, 0x40(%r13)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2130
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4080
movq %rax, %rbx
movq %r14, %rdi
callq 0x2aaa
movq -0x30(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::feedForward(std::vector<Neuron, std::allocator<Neuron>> const&)
void Neuron::feedForward(const Layer &prevLayer){
	long double sum=0.0;

	// Sum the previous layer's outputs (which are our inputs)
    // Include the bias node from the previous layer.
	for (unsigned n = 0; n < prevLayer.size();  n++){
		sum+=prevLayer[n].getOutputValue() * prevLayer[n].outputWeights[index].weight;
	}

	// activate function or transfer /sig /gaussian /linear/ step
	if (this->transferFunction=="th")
		outputValue = Neuron::transferFunctionTanH(sum);
	else if (this->transferFunction=="sig")
		outputValue = Neuron::transferFunctionSig(sum);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
pushq $0x60
popq %rsi
cqto
idivq %rsi
movl 0x40(%rdi), %edx
xorl %esi, %esi
fldz
shlq $0x5, %rdx
movl %esi, %esi
cmpq %rsi, %rax
jbe 0x41b1
imulq $0x60, %rsi, %rdi
fldt (%rcx,%rdi)
movq 0x48(%rcx,%rdi), %rdi
fldt (%rdi,%rdx)
fmulp %st, %st(1)
faddp %st, %st(1)
incl %esi
jmp 0x4193
fstpt -0x1c(%rbp)
leaq 0x20(%rbx), %r14
leaq 0xfa1(%rip), %rsi       # 0x5160
movq %r14, %rdi
callq 0x4351
testb %al, %al
je 0x41d8
fldt -0x1c(%rbp)
fstpt (%rsp)
callq 0x2190
jmp 0x41f6
leaq 0xf84(%rip), %rsi       # 0x5163
movq %r14, %rdi
callq 0x4351
testb %al, %al
je 0x41f8
fldt -0x1c(%rbp)
fstpt (%rsp)
callq 0x40f0
fstpt (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::calculateOutputGradients(long double)
void Neuron::calculateOutputGradients(long double targetValue){
	long double delta= targetValue - outputValue;
	if (this->transferFunction=="th")
		gradient =delta * Neuron::transferFunctionTanHDerivative(outputValue);
 	else if (this->transferFunction=="sig")
		gradient =delta * Neuron::transferFunctionSigDerivative(outputValue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
fldt 0x10(%rbp)
fldt (%rdi)
fsubrp %st, %st(1)
fstpt -0x1c(%rbp)
leaq 0x20(%rdi), %r14
leaq 0xf3b(%rip), %rsi       # 0x5160
movq %r14, %rdi
callq 0x4351
testb %al, %al
je 0x423d
fldt (%rbx)
fstpt (%rsp)
callq 0x40ba
jmp 0x425a
leaq 0xf1f(%rip), %rsi       # 0x5163
movq %r14, %rdi
callq 0x4351
testb %al, %al
je 0x4262
fldt (%rbx)
fstpt (%rsp)
callq 0x4112
fldt -0x1c(%rbp)
fmulp %st, %st(1)
fstpt 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::sumDOW(std::vector<Neuron, std::allocator<Neuron>> const&) const
long double Neuron::sumDOW(const Layer &nextLayer) const{
	long double sum = 0.0;

	// Sum our contributions of the errors at the nodes we feed.
	for(unsigned n = 0; n < nextLayer.size() -1; n++){
		sum+=outputWeights[n].weight * nextLayer[n].gradient;
  	}

  	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
movabsq $0x60, %rsi
cqto
idivq %rsi
decq %rax
movq 0x48(%rdi), %rdx
xorl %esi, %esi
fldz
movl %esi, %esi
cmpq %rsi, %rax
jbe 0x42b6
imulq $0x60, %rsi, %rdi
movq %rsi, %r8
shlq $0x5, %r8
fldt (%rdx,%r8)
fldt 0x10(%rcx,%rdi)
fmulp %st, %st(1)
faddp %st, %st(1)
incl %esi
jmp 0x4294
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/neuron.cpp
// Function: Neuron::updateInputWeights(std::vector<Neuron, std::allocator<Neuron>>&, long double const&, long double const&)
void Neuron::updateInputWeights(Layer &prevLayer, const long double &eta, const long double &alpha){
 	// 	The weights to be updated are in the Connection container
    // in the neurons in the preceding layer
	for(unsigned n = 0; n < prevLayer.size(); n++){
		Neuron &neuron = prevLayer[n];
		Connection &conn=neuron.outputWeights[index];

		long double oldDeltaWeight = conn.deltaWeight;
		long double newDeltaWeight =
                // Individual input, magnified by the gradient and train rate:
                eta
                * neuron.getOutputValue()
                * gradient
                // Also add momentum = a fraction of the previous delta weight;
                + alpha
                * oldDeltaWeight;

        conn.deltaWeight = newDeltaWeight;
        conn.weight += newDeltaWeight;
  	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %r8
movq (%rsi), %r9
movq 0x8(%rsi), %rax
subq %r9, %rax
movabsq $0x60, %rsi
cqto
idivq %rsi
movl 0x40(%rdi), %edx
fldt 0x10(%rdi)
xorl %esi, %esi
shlq $0x5, %rdx
movl %esi, %esi
cmpq %rsi, %rax
jbe 0x434d
imulq $0x60, %rsi, %rdi
movq 0x48(%r9,%rdi), %r10
fldt 0x10(%r10,%rdx)
fldt (%r8)
fldt (%r9,%rdi)
fmulp %st, %st(1)
fmul %st(2), %st
fldt (%rcx)
fmulp %st, %st(2)
faddp %st, %st(1)
fld %st(0)
fstpt 0x10(%r10,%rdx)
fldt (%r10,%rdx)
faddp %st, %st(1)
fstpt (%r10,%rdx)
incl %esi
jmp 0x4312
fstp %st(0)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getTopology(std::vector<unsigned int, std::allocator<unsigned int>>&)
void TrainingData::getTopology(vector<unsigned> &topology){
    string line;
    string label;

    getline(trainingDataFile, line);
    stringstream ss(line);
    ss >> label;
    if (this->isEof() || label.compare("topology:") != 0) {
        abort();
    }

    while (!ss.eof()) {
        unsigned n;
        ss >> n;
        topology.push_back(n);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x60(%rbp), %rsi
callq 0x2040
leaq -0x1e8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x22c0
leaq -0x1e8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x45f7
leaq 0xbe1(%rip), %rsi       # 0x5167
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x45f7
leaq -0x1e8(%rbp), %r14
leaq -0x1c(%rbp), %r15
movq -0x1e8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1c8(%rbp,%rax)
jne 0x45cb
movq %r14, %rdi
movq %r15, %rsi
callq 0x2310
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b98
jmp 0x459e
leaq -0x1e8(%rbp), %rdi
callq 0x2170
leaq -0x40(%rbp), %rdi
callq 0x20e0
leaq -0x60(%rbp), %rdi
callq 0x20e0
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2140
jmp 0x4605
jmp 0x4600
movq %rax, %rbx
jmp 0x4614
movq %rax, %rbx
leaq -0x1e8(%rbp), %rdi
callq 0x2170
leaq -0x40(%rbp), %rdi
callq 0x20e0
leaq -0x60(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getEta(long double&)
void TrainingData::getEta(long double &eta){
    string line;
    string label;

    getline(trainingDataFile, line);
    stringstream ss(line);
    ss >> label;
    if (this->isEof() || label.compare("eta:") != 0) {
        abort();
    }

    ss >> eta;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x50(%rbp), %rsi
callq 0x2040
leaq -0x1d8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x22c0
leaq -0x1d8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x46ea
leaq 0xacd(%rip), %rsi       # 0x5171
leaq -0x30(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x46ea
leaq -0x1d8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2220
leaq -0x1d8(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2140
jmp 0x46f1
movq %rax, %rbx
jmp 0x4705
movq %rax, %rbx
leaq -0x1d8(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getTransferFunction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void TrainingData::getTransferFunction(string &transferFunction){
    string line;
    string label;

    getline(trainingDataFile, line);
    stringstream ss(line);
    ss >> label;
    if (this->isEof() || label.compare("transfer_function:") != 0) {
        abort();
    }

    ss >> transferFunction;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x50(%rbp), %rsi
callq 0x2040
leaq -0x1d8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x22c0
leaq -0x1d8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x47dc
leaq 0x9e0(%rip), %rsi       # 0x5176
leaq -0x30(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x47dc
leaq -0x1d8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2240
leaq -0x1d8(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2140
jmp 0x47e3
movq %rax, %rbx
jmp 0x47f7
movq %rax, %rbx
leaq -0x1d8(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getMomentum(long double&)
void TrainingData::getMomentum(long double &momentum){
    string line;
    string label;

    getline(trainingDataFile, line);
    stringstream ss(line);
    ss >> label;
    if (this->isEof() || label.compare("momentum:") != 0) {
        abort();
    }

    ss >> momentum;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x50(%rbp), %rsi
callq 0x2040
leaq -0x1d8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x22c0
leaq -0x1d8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x48ce
leaq 0x901(%rip), %rsi       # 0x5189
leaq -0x30(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x48ce
leaq -0x1d8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2220
leaq -0x1d8(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2140
jmp 0x48d5
movq %rax, %rbx
jmp 0x48e9
movq %rax, %rbx
leaq -0x1d8(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getNextInputs(std::vector<double, std::allocator<double>>&)
unsigned TrainingData::getNextInputs(vector<double> &inputVals){
    inputVals.clear();

    string line;
    getline(trainingDataFile, line);
    stringstream ss(line);

    string label;
    ss >> label;
    if (label.compare("in:") == 0) {
        long double oneValue;
        while (ss >> oneValue) {
            inputVals.push_back(oneValue);
        }
    }

    return inputVals.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x495e
movq %rax, 0x8(%rbx)
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x68(%rbp), %rsi
callq 0x2040
leaq -0x208(%rbp), %rdi
leaq -0x68(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x22c0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x208(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2240
leaq 0x7e2(%rip), %rsi       # 0x5193
leaq -0x48(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x49fa
movq 0x8(%rbx), %r14
subq (%rbx), %r14
shrq $0x3, %r14
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x208(%rbp), %rdi
callq 0x2170
leaq -0x68(%rbp), %rdi
callq 0x20e0
movl %r14d, %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x208(%rbp), %r14
leaq -0x80(%rbp), %r15
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x49be
fldt -0x80(%rbp)
fstpl -0x28(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2f9a
jmp 0x4a09
jmp 0x4a40
jmp 0x4a39
movq %rax, %rbx
jmp 0x4a58
jmp 0x4a40
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x208(%rbp), %rdi
callq 0x2170
leaq -0x68(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/leonn[P]neuralNet/source/trainingdata.cpp
// Function: TrainingData::getTargetOutputs(std::vector<double, std::allocator<double>>&)
unsigned TrainingData::getTargetOutputs(vector<double> &targetOutputVals){
    targetOutputVals.clear();

    string line;
    getline(trainingDataFile, line);
    stringstream ss(line);

    string label;
    ss>> label;
    if (label.compare("out:") == 0) {
        long double oneValue;
        while (ss >> oneValue) {
            targetOutputVals.push_back(oneValue);
        }
    }

    return targetOutputVals.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x4a8c
movq %rax, 0x8(%rbx)
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x68(%rbp), %rsi
callq 0x2040
leaq -0x208(%rbp), %rdi
leaq -0x68(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x22c0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x208(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2240
leaq 0x6b8(%rip), %rsi       # 0x5197
leaq -0x48(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4b28
movq 0x8(%rbx), %r14
subq (%rbx), %r14
shrq $0x3, %r14
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x208(%rbp), %rdi
callq 0x2170
leaq -0x68(%rbp), %rdi
callq 0x20e0
movl %r14d, %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x208(%rbp), %r14
leaq -0x80(%rbp), %r15
leaq -0x28(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4aec
fldt -0x80(%rbp)
fstpl -0x28(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2f9a
jmp 0x4b37
jmp 0x4b6e
jmp 0x4b67
movq %rax, %rbx
jmp 0x4b86
jmp 0x4b6e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x208(%rbp), %rdi
callq 0x2170
leaq -0x68(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::acceptor::accept_connections()
bool accept_connections()
         {
            try
            {
               session_ = boost::shared_ptr<bridge>(new bridge(io_service_, delay_));

               acceptor_.async_accept(session_->downstream_socket(),
                    boost::bind(&acceptor::handle_accept,
                         this,
                         boost::asio::placeholders::error));
            }
            catch(std::exception& e)
            {
               std::cerr << "acceptor exception: " << e.what() << std::endl;
               return false;
            }

            return true;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x40e0, %edi           # imm = 0x40E0
callq 0x72e0
movq %rax, %r15
movq (%rbx), %rsi
movzwl 0x8(%rbx), %edx
movq %rax, %rdi
callq 0xd4da
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xd564
leaq 0x60(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xd5a0
leaq 0x10(%rsp), %rdi
callq 0xb736
movq %r14, %rdi
callq 0xd5f6
leaq 0x5769(%rip), %rcx      # 0xd620
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
andq $0x0, 0x8(%rdx)
leaq 0x10(%rax), %rsi
movq %rbx, 0x10(%rdx)
addq $0x10, %rbx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xd5da
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7f0a
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb736
jmp 0x7f10
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x72c0
jmp 0x7f10
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x7f64
movq %rbx, %rdi
callq 0x7150
movq %rax, %rbx
movq 0x190c0(%rip), %rdi     # 0x20fe8
leaq 0xb798(%rip), %rsi      # 0x136c7
callq 0x72d0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x72d0
movq %rax, %rdi
callq 0x7170
callq 0x74a0
xorl %eax, %eax
jmp 0x7edc
movq %rax, %rbx
callq 0x74a0
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::acceptor::handle_accept(boost::system::error_code const&)
void handle_accept(const boost::system::error_code& error)
         {
            if (!error)
            {
               session_->start(upstream_host_,upstream_port_);

               if (!accept_connections())
               {
                  std::cerr << "Failure during call to accept." << std::endl;
               }
            }
            else
            {
               std::cerr << "Error: " << error.message() << std::endl;
            }
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x4(%rsi)
je 0xd67a
movq %rsi, %r14
movq 0x139b1(%rip), %rdi     # 0x20fe8
leaq 0x5a62(%rip), %rsi      # 0x130a0
callq 0x72d0
movq %rax, %rbx
movq 0x8(%r14), %rsi
movl (%r14), %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7290
movq %rax, %rdi
callq 0x7170
leaq 0x8(%rsp), %rdi
callq 0x7350
jmp 0xd6a2
movq %rdi, %rbx
addq $0x60, %rdi
callq 0xd5f6
leaq 0x78(%rbx), %rsi
movzwl 0x70(%rbx), %edx
movq %rax, %rdi
callq 0xeb42
movq %rbx, %rdi
callq 0x7e58
testb %al, %al
je 0xd6aa
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x13937(%rip), %rdi     # 0x20fe8
leaq 0x6143(%rip), %rsi      # 0x137fb
callq 0x72d0
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x7170
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7350
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::start(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short)
void start(const std::string& upstream_host, unsigned short upstream_port)
      {
         // Attempt connection to remote server (upstream side)
         upstream_socket_.async_connect(
              ip::tcp::endpoint(
                   boost::asio::ip::address::from_string(upstream_host),
                   upstream_port),
               boost::bind(&bridge::handle_upstream_connect,
                    shared_from_this(),
                    boost::asio::placeholders::error));
      }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0xfe39
leaq 0x34(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xa41a
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xee62
leaq 0x18e(%rip), %rsi       # 0xed0e
leaq -0x149e(%rip), %r8      # 0xd6e9
leaq 0x10(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xec6d
addq $0x60, %rbx
leaq 0x34(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xebf6
leaq 0x28(%rsp), %rdi
callq 0xb736
leaq 0x8(%rsp), %rdi
callq 0xb736
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb736
jmp 0xebdb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb736
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
nop
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::handle_upstream_connect(boost::system::error_code const&)
void handle_upstream_connect(const boost::system::error_code& error)
      {
         if (!error)
         {
            // Setup async read from remote server (upstream)
            upstream_socket_.async_read_some(
                 boost::asio::buffer(upstream_data_,max_data_length),
                 boost::bind(&bridge::handle_upstream_read,
                      shared_from_this(),
                      boost::asio::placeholders::error,
                      boost::asio::placeholders::bytes_transferred));

            // Setup async read from client (downstream)
            downstream_socket_.async_read_some(
                 boost::asio::buffer(downstream_data_,max_data_length),
                 boost::bind(&bridge::handle_downstream_read,
                      shared_from_this(),
                      boost::asio::placeholders::error,
                      boost::asio::placeholders::bytes_transferred));
         }
         else
            close();
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0xed2d
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x1025a
leaq 0x20b2(%rbx), %rax
movq %rax, 0x8(%rsp)
movq $0x2000, 0x10(%rsp)     # imm = 0x2000
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xee62
leaq 0x1367(%rip), %rsi      # 0x100c0
leaq -0x1677(%rip), %r8      # 0xd6e9
leaq 0x1425(%rip), %r9       # 0x1018c
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1001c
leaq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x10000
leaq 0x30(%rsp), %rdi
callq 0xb736
leaq 0x50(%rsp), %rdi
callq 0xb736
leaq 0xb2(%rbx), %rax
movq %rax, 0x8(%rsp)
movq $0x2000, 0x10(%rsp)     # imm = 0x2000
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xee62
leaq 0x13c5(%rip), %rsi      # 0x1018e
leaq -0x16e7(%rip), %r8      # 0xd6e9
leaq 0x13b5(%rip), %r9       # 0x1018c
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1001c
addq $0x10, %rbx
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x10000
leaq 0x30(%rsp), %rdi
callq 0xb736
leaq 0x40(%rsp), %rdi
callq 0xb736
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xb736
jmp 0xee39
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xb736
jmp 0xee48
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb736
jmp 0xee52
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xb736
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::handle_upstream_read(boost::system::error_code const&, unsigned long const&)
void handle_upstream_read(const boost::system::error_code& error,
                                const size_t& bytes_transferred)
      {
         if (!error)
         {
            async_write(downstream_socket_,
                 boost::asio::buffer(upstream_data_,bytes_transferred),
                 boost::bind(&bridge::handle_downstream_write,
                      shared_from_this(),
                      boost::asio::placeholders::error));
         }
         else
            close();
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x100df
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x1025a
leaq 0x20b2(%rbx), %rax
movq (%rdx), %rcx
movl $0x2000, %edx           # imm = 0x2000
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xee62
leaq 0xacc(%rip), %rsi       # 0x10be2
leaq -0x2a34(%rip), %r8      # 0xd6e9
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xec6d
addq $0x10, %rbx
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x10bbb
leaq 0x40(%rsp), %rdi
callq 0xb736
leaq 0x10(%rsp), %rdi
callq 0xb736
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb736
jmp 0x10172
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb736
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::handle_downstream_read(boost::system::error_code const&, unsigned long const&)
void handle_downstream_read(const boost::system::error_code& error,
                                  const size_t& bytes_transferred)
      {
         if (!error)
         {
            async_write(upstream_socket_,
                  boost::asio::buffer(downstream_data_,bytes_transferred),
                  boost::bind(&bridge::handle_upstream_write,
                        shared_from_this(),
                        boost::asio::placeholders::error));
         }
         else
            close();
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x101ad
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x1025a
leaq 0xb2(%rbx), %rax
movq (%rdx), %rcx
movl $0x2000, %edx           # imm = 0x2000
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xee62
leaq 0x14a4(%rip), %rsi      # 0x11688
leaq -0x2b02(%rip), %r8      # 0xd6e9
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xec6d
addq $0x60, %rbx
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x10bbb
leaq 0x40(%rsp), %rdi
callq 0xb736
leaq 0x10(%rsp), %rdi
callq 0xb736
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb736
jmp 0x10240
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb736
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::close()
void close()
      {
         boost::mutex::scoped_lock lock(mutex_);

         if (downstream_socket_.is_open())
         {
            downstream_socket_.close();
         }

         if (upstream_socket_.is_open())
         {
            upstream_socket_.close();
         }
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x40b8(%rdi), %rsi
movq %rsp, %rdi
callq 0x11818
cmpl $-0x1, 0x18(%rbx)
je 0x10280
leaq 0x10(%rbx), %rdi
callq 0x124b4
cmpl $-0x1, 0x68(%rbx)
je 0x10292
addq $0x60, %rbx
movq %rbx, %rdi
callq 0x124b4
movq %rsp, %rdi
callq 0x11a5c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x11a5c
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
nop
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::handle_downstream_write(boost::system::error_code const&)
void handle_downstream_write(const boost::system::error_code& error)
      {
         if (!error)
         {
            upstream_socket_.async_read_some(
                 boost::asio::buffer(upstream_data_,max_data_length),
                 boost::bind(&bridge::handle_upstream_read,
                      shared_from_this(),
                      boost::asio::placeholders::error,
                      boost::asio::placeholders::bytes_transferred));
         }
         else
            close();
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x10c01
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x1025a
leaq 0x20b2(%rbx), %rax
movq %rax, 0x18(%rsp)
movq $0x2000, 0x20(%rsp)     # imm = 0x2000
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xee62
leaq -0xb6d(%rip), %rsi      # 0x100c0
leaq -0x354b(%rip), %r8      # 0xd6e9
leaq -0xaaf(%rip), %r9       # 0x1018c
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1001c
addq $0x60, %rbx
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x10000
leaq 0x40(%rsp), %rdi
callq 0xb736
leaq 0x10(%rsp), %rdi
callq 0xb736
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb736
jmp 0x10c8e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb736
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
// File: /workspace/github_cpp_makefile_star2_O2/kn-sumanth[P]tcpproxy_server/tcpproxy_server.cpp
// Function: tcp_proxy::bridge::handle_upstream_write(boost::system::error_code const&)
void handle_upstream_write(const boost::system::error_code& error)
      {
         if (!error)
         {
            boost::this_thread::sleep(boost::posix_time::milliseconds(delay_));
            downstream_socket_.async_read_some(
                 boost::asio::buffer(downstream_data_,max_data_length),
                 boost::bind(&bridge::handle_downstream_read,
                      shared_from_this(),
                      boost::asio::placeholders::error,
                      boost::asio::placeholders::bytes_transferred));
         }
         else
            close();
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x116a7
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x1025a
movzwl 0xb0(%rbx), %eax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
callq 0x11769
leaq 0xb2(%rbx), %rax
movq %rax, 0x18(%rsp)
movq $0x2000, 0x20(%rsp)     # imm = 0x2000
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xee62
leaq -0x1560(%rip), %rsi     # 0x1018e
leaq -0x400c(%rip), %r8      # 0xd6e9
leaq -0x1570(%rip), %r9      # 0x1018c
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1001c
addq $0x10, %rbx
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x10000
leaq 0x40(%rsp), %rdi
callq 0xb736
leaq 0x10(%rsp), %rdi
callq 0xb736
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb736
jmp 0x1174f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb736
movq %rbx, %rdi
callq 0x74d0
movq %rax, %rdi
callq 0x7c40
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/trainhmm.cpp
// Function: readline(_IO_FILE*)
static char* readline(FILE *fid) {
	int length = 0;
	
	if(fgets(line,max_line_length,fid) == NULL)
		return NULL;
	
	while(strrchr(line,'\n') == NULL && strrchr(line,'\r') == NULL) // do take both line endings
	{
		max_line_length *= 2;
		line = (char *) realloc(line, (size_t)max_line_length);
		length = (int) strlen(line);
		if(fgets(line+length,max_line_length-length,fid) == NULL)
			break;
	}
	return line;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x36b11(%rip), %rdi     # 0x3ec78
movl 0x36b03(%rip), %esi     # 0x3ec70
movq %rbx, %rdx
callq 0x4400
testq %rax, %rax
je 0x81f0
pushq $0xa
popq %rbp
pushq $0xd
popq %r14
movq 0x36af0(%rip), %r15     # 0x3ec78
movq %r15, %rdi
movl %ebp, %esi
callq 0x4290
testq %rax, %rax
jne 0x81f0
movq %r15, %rdi
movl %r14d, %esi
callq 0x4290
testq %rax, %rax
jne 0x81f0
movslq 0x36ac2(%rip), %r12     # 0x3ec70
addq %r12, %r12
movl %r12d, 0x36ab8(%rip)    # 0x3ec70
movq %r15, %rdi
movq %r12, %rsi
callq 0x4440
movq %rax, %r15
movq %rax, 0x36aab(%rip)     # 0x3ec78
movq %rax, %rdi
callq 0x40f0
cltq
addq %rax, %r15
subl %eax, %r12d
movq %r15, %rdi
movl %r12d, %esi
movq %rbx, %rdx
callq 0x4400
testq %rax, %rax
jne 0x8181
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<double>::get(int)
T StripedArray<T>::get(NDAT idx) {
	if(idx>(this->size-1)) {
		fprintf(stderr, "Exception! Element index %u exceeds array size %u\n",idx,this->size);
		return (T)0;
	}
	NDAT idx_stripe = idx / this->stripe_size;
	NDAT idx_within = idx % this->stripe_size;
//	if(idx_within>(this->size_last_stripe-1)) {
//		fprintf(stderr, "Exception! Element index in last stripe %d exceeds sltipe size %d\n",idx_within,this->size_last_stripe);
//		return NULL;
//	}
	return this->stripes[idx_stripe][idx_within];
}

// Assembly:
movl %esi, %eax
movl (%rdi), %ecx
cmpl %esi, %ecx
jle 0x8295
cltd
idivl 0x4(%rdi)
movq 0x10(%rdi), %rcx
cltq
movq (%rcx,%rax,8), %rax
movslq %edx, %rcx
movsd (%rax,%rcx,8), %xmm0
retq
pushq %rax
movq 0x35d3b(%rip), %rdx     # 0x3dfd8
movq (%rdx), %rdi
leaq 0x27b16(%rip), %rsi     # 0x2fdbd
movl %eax, %edx
xorl %eax, %eax
callq 0x4380
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Figures.cpp
// Function: Figures::Eigenvalues()
void Eigenvalues()
{
	double a;
	std::ofstream data[2];
	data[0].open("data/Eigenvalues_NO.txt");
	data[1].open("data/Eigenvalues_IO.txt");

	for (int i = 0; i < 2; i++)
	{
		set_ordering(i == 0);
		for (double Y = -40; Y <= 40; Y += 0.01)
		{
			a = Y * Y_to_a;
			data[i] << Y;
			data[i] << " " << Exact::M1sq(a) << " " << Exact::M2sq(a) << " " << Exact::M3sq(a);
			data[i] << " " << Check::l10(a) << " " << Check::l20(a) << " " << Check::l30(a);
			data[i] << std::endl;
		}
		data[i].close();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
leaq 0x20(%rsp), %rdi
callq 0x2250
leaq 0x220(%rsp), %rbx
movq %rbx, %rdi
callq 0x2250
leaq 0x2f71(%rip), %rsi      # 0xde80
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x2040
leaq 0x2f75(%rip), %rsi      # 0xde98
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x2040
leaq 0x23fb(%rip), %rax      # 0xd330
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %r12d, %r12d
leaq 0x2ce5(%rip), %rbx      # 0xdc2e
cmpq $0x2, %r12
je 0xb099
xorl %edi, %edi
testq %r12, %r12
sete %dil
callq 0x37e3
movq %r12, %rax
shlq $0x9, %rax
leaq (%rsp,%rax), %r14
addq $0x20, %r14
movsd 0x2e88(%rip), %xmm1     # 0xde00
movsd 0x2e88(%rip), %xmm0     # 0xde08
ucomisd %xmm1, %xmm0
jb 0xb089
movq %r14, %rdi
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x2230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x424f
movq %r15, %rdi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movsd 0x8(%rsp), %xmm0
callq 0x4264
movq %r15, %rdi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movsd 0x8(%rsp), %xmm0
callq 0x4279
movq %r15, %rdi
callq 0x2230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movsd 0x8(%rsp), %xmm0
callq 0x256e
movq %r15, %rdi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movsd 0x8(%rsp), %xmm0
callq 0x2721
movq %r15, %rdi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movsd 0x8(%rsp), %xmm0
callq 0x28d0
movq %r15, %rdi
callq 0x2230
movq %r14, %rdi
callq 0x20d0
movsd 0x10(%rsp), %xmm1
addsd 0x2d8c(%rip), %xmm1     # 0xde10
jmp 0xaf78
movq %r14, %rdi
callq 0x21f0
incq %r12
jmp 0xaf49
movl $0x200, %ebx            # imm = 0x200
movq $-0x200, %r14           # imm = 0xFE00
leaq (%rsp,%rbx), %rdi
addq $0x20, %rdi
callq 0x2200
addq %r14, %rbx
cmpq %r14, %rbx
jne 0xb0a5
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2200
jmp 0xb101
jmp 0xb0dc
jmp 0xb0dc
movq %rax, %rbx
movl $0x200, %r14d           # imm = 0x200
movq $-0x200, %r15           # imm = 0xFE00
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x2200
addq %r15, %r14
cmpq %r15, %r14
jne 0xb0ec
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/PeterDenton[P]Nu-Pert/src/Figures.cpp
// Function: Figures::Phases()
void Phases()
{
	std::ofstream data[2];
	data[0].open("data/Phases_NO.txt");
	data[1].open("data/Phases_IO.txt");

	double a;

	for (int i = 0; i < 2; i++)
	{
		set_ordering(i == 0);
		for (double Yrho = -40; Yrho <= 40; Yrho += 0.02)
		{
			a = Yrho * Y_to_a;
			data[i] << Yrho << " " << Hat::phi(a) << " " << Check::psi(a) << std::endl;
		} // Yrho
		data[i].close();
	} // i, ordering
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
leaq 0x20(%rsp), %rdi
callq 0x2250
leaq 0x220(%rsp), %rbx
movq %rbx, %rdi
callq 0x2250
leaq 0x2d78(%rip), %rsi      # 0xdeb0
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x2040
leaq 0x2d77(%rip), %rsi      # 0xdec3
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x2040
leaq 0x21d2(%rip), %rax      # 0xd330
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r12d, %r12d
leaq 0x2abc(%rip), %rbx      # 0xdc2e
cmpq $0x2, %r12
je 0xb23a
xorl %edi, %edi
testq %r12, %r12
sete %dil
callq 0x37e3
movq %r12, %rax
shlq $0x9, %rax
leaq (%rsp,%rax), %r14
addq $0x20, %r14
movsd 0x2c5f(%rip), %xmm1     # 0xde00
movsd 0x2c5f(%rip), %xmm0     # 0xde08
ucomisd %xmm1, %xmm0
jb 0xb22a
movq %r14, %rdi
movsd %xmm1, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x63e2
movq %r15, %rdi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %r15
movsd 0x18(%rsp), %xmm0
callq 0x299c
movq %r15, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20d0
movsd 0x8(%rsp), %xmm1
addsd 0x2bf3(%rip), %xmm1     # 0xde18
jmp 0xb1a1
movq %r14, %rdi
callq 0x21f0
incq %r12
jmp 0xb172
movl $0x200, %ebx            # imm = 0x200
movq $-0x200, %r14           # imm = 0xFE00
leaq (%rsp,%rbx), %rdi
addq $0x20, %rdi
callq 0x2200
addq %r14, %rbx
cmpq %r14, %rbx
jne 0xb246
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2200
jmp 0xb2a2
jmp 0xb27d
jmp 0xb27d
movq %rax, %rbx
movl $0x200, %r14d           # imm = 0x200
movq $-0x200, %r15           # imm = 0xFE00
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x2200
addq %r15, %r14
cmpq %r15, %r14
jne 0xb28d
movq %rbx, %rdi
callq 0x2280