LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
movaps %xmm0, 0x20(%rdi)
movq %rdi, -0x38(%rbp)
movq $0x0, 0x30(%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
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x2d74
movq %r13, %rdi
callq 0x2c68
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 0x26ee
movl 0x4(%rax,%r12,4), %r14d
movq -0x38(%rbp), %rax
movq 0x28(%rax), %r15
movq %r13, %rdi
movl %r14d, %esi
movl %ebx, %edx
movq -0x50(%rbp), %rcx
callq 0x45d2
addq $-0x18, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x2f9e
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x2724
callq 0x21f0
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x2739
callq 0x21f0
incl %ebx
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpl (%rax,%r12,4), %ebx
jbe 0x26ee
incq %r12
cmpq -0x48(%rbp), %r12
jne 0x269e
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rax), %rdi
addq $-0x60, %rdi
fld1
fstpt (%rsp)
callq 0x46a8
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27a5
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2c68
jmp 0x27a8
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2c9c
jmp 0x27a8
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x2cce
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rdi
subq (%rax), %rdi
sarq $0x5, %rdi
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rdi
decq %rdi
cmpq %rdi, %rsi
jne 0x28f7
cmpq %rcx, %rdx
je 0x2855
movq %r12, %r15
movl $0x1, %r12d
xorl %eax, %eax
movq 0x20(%rbx), %rdx
leaq (%rax,%rax,2), %rdi
shlq $0x5, %rdi
addq (%rdx), %rdi
fldl (%rcx,%rax,8)
fstpt (%rsp)
callq 0x46a8
movl %r12d, %eax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
incl %r12d
cmpq %rax, %rdx
ja 0x281b
movq 0x20(%rbx), %rax
movq %r15, %r12
movq 0x28(%rbx), %rcx
cmpq %rax, %rcx
je 0x28e8
movl $0x1, %edi
movl $0x1, %edx
leaq (%rdx,%rdx,2), %r13
movq (%rax,%r13,8), %rdx
cmpq %rdx, 0x8(%rax,%r13,8)
je 0x28d0
movq %rdi, -0x30(%rbp)
leal -0x1(%rdi), %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %r14
movl $0x1, %r15d
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdi
shlq $0x5, %rdi
addq %rdx, %rdi
movq %r14, %rsi
callq 0x4774
movl %r15d, %ecx
movq 0x20(%rbx), %rax
movq (%rax,%r13,8), %rdx
movq 0x8(%rax,%r13,8), %rsi
subq %rdx, %rsi
sarq $0x5, %rsi
imulq %r12, %rsi
incl %r15d
cmpq %rcx, %rsi
ja 0x2892
movq 0x28(%rbx), %rcx
movq -0x30(%rbp), %rdi
incl %edi
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
imulq %r12, %rsi
movq %rdi, %rdx
cmpq %rdi, %rsi
jae 0x286c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3726(%rip), %rdi      # 0x6024
leaq 0x3792(%rip), %rsi      # 0x6097
leaq 0x379a(%rip), %rcx      # 0x60a6
movl $0x1b, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %rdx
movq %rbx, %rdi
callq 0x2240
leaq 0x2d5d(%rip), %rsi      # 0x60f0
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x33ee
movl $0x1, %r12d
xorl %ecx, %ecx
leaq 0x2d38(%rip), %r15      # 0x60f0
movsd (%rax,%rcx,8), %xmm0
movq %rbx, %rdi
callq 0x22f0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2240
movl %r12d, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x33b8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %rdx
movq %rbx, %rdi
callq 0x2240
leaq 0x2ca9(%rip), %rsi      # 0x60f0
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x34ce
movl $0x1, %r15d
xorl %r12d, %r12d
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x22f0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x2c68(%rip), %rsi      # 0x60ee
callq 0x2240
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x20e0
movq %r13, %rdi
callq 0x22f0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2c40(%rip), %rsi      # 0x60f0
callq 0x2240
movl %r15d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %r15d
cmpq %r12, %rcx
ja 0x3466
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x40(%rbp)
movl %edx, %r12d
movq %rdi, %r13
leaq 0x20(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x30(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x48(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
movq %rax, 0x58(%rdi)
testl %esi, %esi
je 0x465b
movl %esi, %ebx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x261c
movq 0x50(%r13), %rsi
cmpq 0x58(%r13), %rsi
je 0x464c
movaps -0x60(%rbp), %xmm0
movaps -0x50(%rbp), %xmm1
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
addq $0x20, 0x50(%r13)
jmp 0x4657
movq %r14, %rdi
movq %r15, %rdx
callq 0x4a20
decl %ebx
jne 0x4624
movl %r12d, 0x40(%r13)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2120
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x467d
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x468d
callq 0x21f0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x469f
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq 0x8(%rsi), %rdx
fldz
subq %rax, %rdx
je 0x47cc
fstp %st(0)
sarq $0x5, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movl 0x40(%rbx), %edx
fldz
movl $0x1, %esi
shlq $0x5, %rdx
fldt (%rax)
movq 0x48(%rax), %rdi
fldt (%rdi,%rdx)
fmulp %st, %st(1)
faddp %st, %st(1)
movl %esi, %edi
addq $0x60, %rax
incl %esi
cmpq %rdi, %rcx
ja 0x47b2
fstpt -0x1c(%rbp)
leaq 0x20(%rbx), %r14
leaq 0x19b0(%rip), %rsi      # 0x618a
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x480e
leaq 0x19a0(%rip), %rsi      # 0x618d
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
jne 0x481b
fldt -0x1c(%rbp)
fchs
fstpt (%rsp)
callq 0x2050
fld1
fadd %st, %st(1)
fdivp %st, %st(1)
jmp 0x4819
fldt -0x1c(%rbp)
fstpt (%rsp)
callq 0x21a0
fstpt (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x40, %rsp
movq %rdi, %rbx
fldt 0x10(%rbp)
fldt (%rdi)
fsubrp %st, %st(1)
fstpt -0x34(%rbp)
leaq 0x20(%rdi), %r14
leaq 0x1943(%rip), %rsi      # 0x618a
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x4892
leaq 0x1933(%rip), %rsi      # 0x618d
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
jne 0x48c0
fldt (%rbx)
fchs
fld %st(0)
fstpt -0x1c(%rbp)
fstpt (%rsp)
callq 0x2050
fstpt -0x28(%rbp)
fldt -0x1c(%rbp)
fstpt (%rsp)
callq 0x2050
fld1
faddp %st, %st(1)
fmul %st, %st(0)
fldt -0x28(%rbp)
fdivp %st, %st(1)
jmp 0x48b8
fldt (%rbx)
fld %st(0)
fstpt -0x1c(%rbp)
fstpt (%rsp)
callq 0x21a0
fstpt -0x28(%rbp)
fldt -0x1c(%rbp)
fstpt (%rsp)
callq 0x21a0
fldt -0x28(%rbp)
fmulp %st, %st(1)
fld1
fsubp %st, %st(1)
fldt -0x34(%rbp)
fmulp %st, %st(1)
fstpt 0x10(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
fldz
decq %rcx
je 0x491c
pushq %rbp
movq %rsp, %rbp
fstp %st(0)
movq 0x48(%rdi), %rdx
addq $0x10, %rax
fldz
movl $0x1, %esi
fldt (%rdx)
fldt (%rax)
fmulp %st, %st(1)
faddp %st, %st(1)
movl %esi, %edi
addq $0x20, %rdx
addq $0x60, %rax
incl %esi
cmpq %rdi, %rcx
ja 0x4902
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x1f8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x1f8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4d00
leaq 0x1553(%rip), %rsi      # 0x6191
leaq -0x50(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x4d00
movq -0x1f8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1d8(%rbp,%rax)
jne 0x4cb3
leaq -0x1f8(%rbp), %r14
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2330
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4c93
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4c9e
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5510
movq -0x1f8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1d8(%rbp,%rax)
je 0x4c6f
movq 0x4306(%rip), %rsi      # 0x8fc0
leaq -0x1f8(%rbp), %rdi
callq 0x2180
leaq -0x178(%rbp), %rdi
callq 0x20a0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x4ce0
callq 0x21f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4cee
callq 0x21f0
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2130
jmp 0x4d0e
jmp 0x4d09
movq %rax, %rbx
jmp 0x4d30
movq %rax, %rbx
movq 0x42a8(%rip), %rsi      # 0x8fc0
leaq -0x1f8(%rbp), %rdi
callq 0x2180
leaq -0x178(%rbp), %rdi
callq 0x20a0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x4d3e
callq 0x21f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4d4c
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x1e8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x1e8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4e54
leaq 0x13ae(%rip), %rsi      # 0x619b
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x4e54
leaq -0x1e8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2250
movq 0x41b0(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4e36
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x4e44
callq 0x21f0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2130
jmp 0x4e7f
movq %rax, %rbx
movq 0x415b(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
jmp 0x4e82
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4e90
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x4e9e
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x1e8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x1e8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4fa6
leaq 0x1261(%rip), %rsi      # 0x61a0
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x4fa6
leaq -0x1e8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2270
movq 0x405e(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4f88
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x4f96
callq 0x21f0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2130
jmp 0x4fd1
movq %rax, %rbx
movq 0x4009(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
jmp 0x4fd4
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4fe2
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x4ff0
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x1e8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x1e8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x50f8
leaq 0x1122(%rip), %rsi      # 0x61b3
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x50f8
leaq -0x1e8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2250
movq 0x3f0c(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x50da
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x50e8
callq 0x21f0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2130
jmp 0x5123
movq %rax, %rbx
movq 0x3eb7(%rip), %rsi      # 0x8fc0
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x168(%rbp), %rdi
callq 0x20a0
jmp 0x5126
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5134
callq 0x21f0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x5142
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x51ab
movq %rax, 0x8(%rbx)
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x218(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x68(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x218(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2270
leaq 0xf9a(%rip), %rsi       # 0x61bd
leaq -0x78(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x5297
leaq -0x218(%rbp), %r14
leaq -0x90(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5293
fldt -0x90(%rbp)
fstpl -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5286
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5242
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3230
jmp 0x5242
leaq -0x48(%rbp), %r15
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x52ac
callq 0x21f0
movq 0x3d0d(%rip), %rsi      # 0x8fc0
leaq -0x218(%rbp), %rdi
callq 0x2180
leaq -0x198(%rbp), %rdi
callq 0x20a0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x52d9
callq 0x21f0
subq %r14, %rbx
shrq $0x3, %rbx
movl %ebx, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52ff
jmp 0x52f8
movq %rax, %rbx
jmp 0x532f
jmp 0x52ff
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x5310
callq 0x21f0
movq 0x3ca9(%rip), %rsi      # 0x8fc0
leaq -0x218(%rbp), %rdi
callq 0x2180
leaq -0x198(%rbp), %rdi
callq 0x20a0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x5341
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x5371
movq %rax, 0x8(%rbx)
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %edx
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x2360
leaq -0x218(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x18, %edx
callq 0x22e0
leaq -0x68(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x218(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2270
leaq 0xdd8(%rip), %rsi       # 0x61c1
leaq -0x78(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x545d
leaq -0x218(%rbp), %r14
leaq -0x90(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5459
fldt -0x90(%rbp)
fstpl -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x544c
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5408
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3230
jmp 0x5408
leaq -0x48(%rbp), %r15
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x5472
callq 0x21f0
movq 0x3b47(%rip), %rsi      # 0x8fc0
leaq -0x218(%rbp), %rdi
callq 0x2180
leaq -0x198(%rbp), %rdi
callq 0x20a0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x549f
callq 0x21f0
subq %r14, %rbx
shrq $0x3, %rbx
movl %ebx, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54c5
jmp 0x54be
movq %rax, %rbx
jmp 0x54f5
jmp 0x54c5
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x54d6
callq 0x21f0
movq 0x3ae3(%rip), %rsi      # 0x8fc0
leaq -0x218(%rbp), %rdi
callq 0x2180
leaq -0x198(%rbp), %rdi
callq 0x20a0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x5507
callq 0x21f0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7330
movq %rax, %r15
movq (%rbx), %rsi
movzwl 0x8(%rbx), %edx
movq %rax, %rdi
callq 0xf8fc
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xf990
leaq 0x60(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xfa26
movq 0x10(%rsp), %r15
testq %r15, %r15
je 0x8aae
lock
decl 0x8(%r15)
jne 0x8aae
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
lock
decl 0xc(%r15)
jne 0x8aae
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r14), %rdx
testq %rdx, %rdx
je 0x8af7
addq $0x10, %rdx
leaq 0x6fb7(%rip), %rax      # 0xfa78
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
movq $0x0, 0x8(%r8)
movq %rbx, 0x10(%r8)
movq 0x10(%rbx), %rdi
leaq 0x18(%rbx), %rsi
addq $0x30, %rbx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x10440
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xeaef(%rip), %rdi      # 0x175ed
leaq 0xeaf0(%rip), %rsi      # 0x175f5
leaq 0xec96(%rip), %rcx      # 0x177a2
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x7220
jmp 0x8b3a
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd4f4
jmp 0x8b40
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x7300
jmp 0x8b40
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x8b9d
movq %rbx, %rdi
callq 0x7170
movq %rax, %rbx
movq 0x1b490(%rip), %rdi     # 0x23fe8
leaq 0xeb92(%rip), %rsi      # 0x176f1
movl $0x14, %edx
callq 0x7360
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x1b46f(%rip), %rdi     # 0x23fe8
movq %rax, %rsi
callq 0x7320
movq %rax, %rdi
callq 0x71a0
callq 0x74f0
xorl %eax, %eax
jmp 0x8aed
movq %rax, %rbx
callq 0x74f0
movq %rbx, %rdi
callq 0x7520
movq %rax, %rdi
callq 0x882e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfb0a
movq %rsi, %r14
movq 0x14555(%rip), %rbx     # 0x23fe8
leaq 0x7606(%rip), %rsi      # 0x170a0
movl $0x7, %edx
movq %rbx, %rdi
callq 0x7360
movq 0x8(%r14), %rsi
movl (%r14), %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x7360
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7310
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7230
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfb2f
callq 0x7300
jmp 0xfb2f
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0xfb80
leaq 0x78(%rbx), %rsi
movzwl 0x70(%rbx), %edx
callq 0x113f6
movq %rbx, %rdi
callq 0x8a3e
testb %al, %al
je 0xfb37
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x144aa(%rip), %rbx     # 0x23fe8
leaq 0x7ce0(%rip), %rsi      # 0x17825
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x7360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7310
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x7230
leaq 0x7a66(%rip), %rdi      # 0x175ed
leaq 0x7a67(%rip), %rsi      # 0x175f5
leaq 0x7c0d(%rip), %rcx      # 0x177a2
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x7220
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfbb5
callq 0x7300
movq %rbx, %rdi
callq 0x7520
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0xaa32
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12bdf
cmpb $0x1, 0x4(%r15)
je 0x114ec
movzwl %bp, %edx
leaq 0x6c(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xb5b4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11874
leaq 0x236(%rip), %rsi       # 0x11698
leaq -0x18ac(%rip), %r8      # 0xfbbd
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x115b3
addq $0x60, %rbx
leaq 0x6c(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x11546
movq 0x40(%rsp), %rbx
testq %rbx, %rbx
je 0x114b6
lock
decl 0x8(%rbx)
jne 0x114b6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x114b6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x114de
lock
decl 0x8(%rbx)
jne 0x114de
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x114de
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xbaca
movq %rbx, %rdi
callq 0x923b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xd4f4
jmp 0x1152c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8dc0
jmp 0x11536
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0x7520
movq %rax, %rdi
callq 0x882e
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x12ee7
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x130ea
leaq 0x20b2(%rbx), %rax
movq (%rdx), %rcx
movl $0x2000, %edx           # imm = 0x2000
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11874
leaq 0xd70(%rip), %rsi       # 0x13c8e
leaq -0x3368(%rip), %r8      # 0xfbbd
leaq 0x30(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x115b3
addq $0x10, %rbx
leaq 0x50(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0xf(%rsp), %rcx
callq 0x13d96
movq 0x48(%rsp), %rbx
testq %rbx, %rbx
je 0x12f7c
lock
decl 0x8(%rbx)
jne 0x12f7c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x12f7c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x18(%rsp), %rbx
testq %rbx, %rbx
je 0x12fa4
lock
decl 0x8(%rbx)
jne 0x12fa4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x12fa4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xd4f4
jmp 0x12fbe
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0x7520
movq %rax, %rdi
callq 0x882e
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0x12ff9
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x130ea
leaq 0xb2(%rbx), %rax
movq (%rdx), %rcx
movl $0x2000, %edx           # imm = 0x2000
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11874
leaq 0x19fe(%rip), %rsi      # 0x14a2e
leaq -0x347a(%rip), %r8      # 0xfbbd
leaq 0x30(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x115b3
addq $0x60, %rbx
leaq 0x50(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0xf(%rsp), %rcx
callq 0x13d96
movq 0x48(%rsp), %rbx
testq %rbx, %rbx
je 0x1308e
lock
decl 0x8(%rbx)
jne 0x1308e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x1308e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x18(%rsp), %rbx
testq %rbx, %rbx
je 0x130b6
lock
decl 0x8(%rbx)
jne 0x130b6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x130b6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xd4f4
jmp 0x130d0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0x7520
movq %rax, %rdi
callq 0x882e
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x14e70
cmpl $-0x1, 0x18(%rbx)
je 0x13117
leaq 0x10(%rbx), %rdi
callq 0x15f90
cmpl $-0x1, 0x68(%rbx)
je 0x13129
addq $0x60, %rbx
movq %rbx, %rdi
callq 0x15f90
cmpb $0x1, 0x8(%rsp)
jne 0x13139
movq (%rsp), %rdi
callq 0x1597c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpb $0x1, 0x8(%rsp)
jne 0x13152
movq (%rsp), %rdi
callq 0x1597c
movq %rbx, %rdi
callq 0x7520
movq %rax, %rdi
callq 0x882e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13cad
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x130ea
leaq 0x20b2(%rbx), %rax
movq %rax, 0x10(%rsp)
movq $0x2000, 0x18(%rsp)     # imm = 0x2000
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11874
leaq -0xe0f(%rip), %rsi      # 0x12ec8
leaq -0x4121(%rip), %r8      # 0xfbbd
leaq -0xd0d(%rip), %r9       # 0x12fd8
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x12de0
addq $0x60, %rbx
leaq 0x40(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x13162
movq 0x38(%rsp), %rbx
testq %rbx, %rbx
je 0x13d39
lock
decl 0x8(%rbx)
jne 0x13d39
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x13d39
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x13d61
lock
decl 0x8(%rbx)
jne 0x13d61
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x13d61
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xd4f4
jmp 0x13d7b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0x7520
movq %rax, %rdi
callq 0x882e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14a4d
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x130ea
movzwl 0xb0(%rbx), %eax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
callq 0x14b50
leaq 0xb2(%rbx), %rax
movq %rax, 0x10(%rsp)
movq $0x2000, 0x18(%rsp)     # imm = 0x2000
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11874
leaq -0x1ab8(%rip), %rsi     # 0x12fda
leaq -0x4edc(%rip), %r8      # 0xfbbd
leaq -0x1ac8(%rip), %r9      # 0x12fd8
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x12de0
addq $0x10, %rbx
leaq 0x40(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x13162
movq 0x38(%rsp), %rbx
testq %rbx, %rbx
je 0x14af4
lock
decl 0x8(%rbx)
jne 0x14af4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x14af4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x14b1c
lock
decl 0x8(%rbx)
jne 0x14b1c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
lock
decl 0xc(%rbx)
jne 0x14b1c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xd4f4
jmp 0x14b36
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0x7520
movq %rax, %rdi
callq 0x882e
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3c0b6(%rip), %rdi     # 0x45c58
movl 0x3c0a8(%rip), %esi     # 0x45c50
movq %rbx, %rdx
callq 0x43f0
testq %rax, %rax
je 0x9c1e
movq 0x3c09c(%rip), %r14     # 0x45c58
movq %r14, %rdi
movl $0xa, %esi
callq 0x4280
testq %rax, %rax
jne 0x9c1e
movq %r14, %rdi
movl $0xd, %esi
callq 0x4280
testq %rax, %rax
jne 0x9c1e
movslq 0x3c069(%rip), %r15     # 0x45c50
addq %r15, %r15
movl %r15d, 0x3c05f(%rip)    # 0x45c50
movq %r14, %rdi
movq %r15, %rsi
callq 0x4420
movq %rax, %r14
movq %rax, 0x3c052(%rip)     # 0x45c58
movq %rax, %rdi
callq 0x4110
cltq
addq %rax, %r14
subl %eax, %r15d
movq %r14, %rdi
movl %r15d, %esi
jmp 0x9ba8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9cab
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 0x3b325(%rip), %rdx     # 0x44fd8
movq (%rdx), %rdi
leaq 0x2e150(%rip), %rsi     # 0x37e0d
movl %eax, %edx
xorl %eax, %eax
callq 0x4360
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
leaq 0x20(%rsp), %rdi
callq 0x2280
leaq 0x220(%rsp), %rbx
movq %rbx, %rdi
callq 0x2280
leaq 0x2a8e(%rip), %rsi      # 0xff08
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x2050
leaq 0x2a88(%rip), %rsi      # 0xff1b
movq %rbx, %rdi
movl $0x10, %edx
callq 0x2050
leaq 0x1e89(%rip), %rax      # 0xf330
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movb $0x1, %bpl
leaq 0x27a3(%rip), %r15      # 0xfc5e
movzbl %bpl, %edi
andl $0x1, %edi
callq 0x3a1f
movsd 0x2989(%rip), %xmm1     # 0xfe58
movq %r14, %rdi
movsd %xmm1, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x2260
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x6e5a
movq %r12, %rdi
callq 0x2260
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movsd 0x18(%rsp), %xmm0
callq 0x29d5
movq %r12, %rdi
callq 0x2260
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movsd 0x8(%rsp), %xmm1
addsd 0x28ff(%rip), %xmm1     # 0xfe70
movsd 0x28ef(%rip), %xmm0     # 0xfe68
ucomisd %xmm1, %xmm0
jae 0xd4cf
movq %r14, %rdi
callq 0x2210
movq %rbx, %r14
testb $0x1, %bpl
movl $0x0, %ebp
jne 0xd4bb
movq 0x6a24(%rip), %rax      # 0x13fc8
movq (%rax), %r14
movq 0x18(%rax), %r15
movq $-0x400, %r12           # imm = 0xFC00
leaq 0x318(%rsp), %rbx
movq %r14, -0xf8(%rbx)
movq -0x18(%r14), %rax
movq %r15, -0xf8(%rbx,%rax)
leaq -0xf0(%rbx), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x20a0
addq $-0x200, %rbx           # imm = 0xFE00
addq $0x200, %r12            # imm = 0x200
jne 0xd5ba
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2220
jmp 0xd66d
jmp 0xd616
jmp 0xd616
movq %rax, %rbx
movq 0x69a8(%rip), %rax      # 0x13fc8
movq (%rax), %r15
movq 0x18(%rax), %r12
movq $-0x400, %r13           # imm = 0xFC00
leaq 0x318(%rsp), %r14
movq %r15, -0xf8(%r14)
movq -0x18(%r15), %rax
movq %r12, -0xf8(%r14,%rax)
leaq -0xf0(%r14), %rdi
callq 0x2150
movq %r14, %rdi
callq 0x20a0
addq $-0x200, %r14           # imm = 0xFE00
addq $0x200, %r13            # imm = 0x200
jne 0xd636
movq %rbx, %rdi
callq 0x22b0