LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x60, %rsp
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
fstpt -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
fldt -0x20(%rbp)
fldt (%rdi)
fsubrp %st, %st(1)
fstpt -0x30(%rbp)
addq $0x20, %rdi
leaq 0x2c59(%rip), %rsi      # 0xb198
callq 0x88a0
testb $0x1, %al
jne 0x854a
jmp 0x856e
movq -0x38(%rbp), %rax
fldt -0x30(%rbp)
fstpt -0x44(%rbp)
fldt (%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x8310
movq -0x38(%rbp), %rax
fldt -0x44(%rbp)
fmulp %st, %st(1)
fstpt 0x10(%rax)
jmp 0x85ac
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
leaq 0x2c1e(%rip), %rsi      # 0xb19b
callq 0x88a0
testb $0x1, %al
jne 0x8588
jmp 0x85aa
movq -0x38(%rbp), %rax
fldt -0x30(%rbp)
fstpt -0x50(%rbp)
fldt (%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x8380
movq -0x38(%rbp), %rax
fldt -0x50(%rbp)
fmulp %st, %st(1)
fstpt 0x10(%rax)
jmp 0x85ac
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
fldz
fstpt -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x8646
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x8880
fldt (%rax)
fstpt -0x44(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3160
fldt -0x44(%rbp)
fldt 0x10(%rax)
fldt -0x20(%rbp)
fxch %st(2)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpt -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x85e4
fldt -0x20(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x877a
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3060
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
movl 0x40(%rax), %eax
movl %eax, %esi
callq 0x88d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
fldt 0x10(%rax)
fstpt -0x50(%rbp)
movq -0x18(%rbp), %rax
fldt (%rax)
fstpt -0x7c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x82d0
movq -0x68(%rbp), %rax
fldt -0x7c(%rbp)
fmulp %st, %st(1)
fldt 0x10(%rax)
movq -0x20(%rbp), %rax
fldt (%rax)
fldt -0x50(%rbp)
fmulp %st, %st(1)
fxch %st(2)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpt -0x60(%rbp)
fldt -0x60(%rbp)
movq -0x38(%rbp), %rax
fstpt 0x10(%rax)
fldt -0x60(%rbp)
movq -0x38(%rbp), %rax
fldt (%rax)
faddp %st, %st(1)
fstpt (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x86ca
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x22a0
leaq -0x50(%rbp), %rdi
callq 0x22a0
movq -0x200(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
callq 0x2060
jmp 0x922c
movl $0x10, %edi
movl $0x8, %esi
callq 0x9b30
movl %eax, -0x204(%rbp)
jmp 0x9243
movl -0x204(%rbp), %edx
leaq -0x1e8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2310
jmp 0x925b
leaq -0x1e8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2280
jmp 0x926d
movq -0x200(%rbp), %rdi
callq 0x91b0
movb %al, -0x205(%rbp)
jmp 0x9281
movb -0x205(%rbp), %al
testb $0x1, %al
jne 0x92a2
jmp 0x928d
leaq -0x50(%rbp), %rdi
leaq 0x1f07(%rip), %rsi      # 0xb19f
callq 0x20c0
cmpl $0x0, %eax
je 0x92d5
callq 0x2130
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x9355
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2180
jmp 0x9355
jmp 0x92d7
movq -0x1e8(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1e8(%rbp,%rax), %rdi
callq 0x2380
movb %al, -0x206(%rbp)
jmp 0x92f7
movb -0x206(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9305
jmp 0x932e
leaq -0x1e8(%rbp), %rdi
leaq -0x1ec(%rbp), %rsi
callq 0x2050
jmp 0x931a
movq -0x10(%rbp), %rdi
leaq -0x1ec(%rbp), %rsi
callq 0x9b50
jmp 0x932c
jmp 0x92d7
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x50(%rbp), %rdi
callq 0x2150
leaq -0x30(%rbp), %rdi
callq 0x2150
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x2150
leaq -0x30(%rbp), %rdi
callq 0x2150
movq -0x58(%rbp), %rdi
callq 0x2360
// File: 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
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x22a0
leaq -0x50(%rbp), %rdi
callq 0x22a0
movq -0x1f8(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
callq 0x2060
jmp 0x93bc
movl $0x10, %edi
movl $0x8, %esi
callq 0x9b30
movl %eax, -0x1fc(%rbp)
jmp 0x93d3
movl -0x1fc(%rbp), %edx
leaq -0x1e8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2310
jmp 0x93eb
leaq -0x1e8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2280
jmp 0x93fd
movq -0x1f8(%rbp), %rdi
callq 0x91b0
movb %al, -0x1fd(%rbp)
jmp 0x9411
movb -0x1fd(%rbp), %al
testb $0x1, %al
jne 0x9432
jmp 0x941d
leaq -0x50(%rbp), %rdi
leaq 0x1d81(%rip), %rsi      # 0xb1a9
callq 0x20c0
cmpl $0x0, %eax
je 0x945f
callq 0x2130
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x9498
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2180
jmp 0x9498
movq -0x10(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x2090
jmp 0x9471
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x50(%rbp), %rdi
callq 0x2150
leaq -0x30(%rbp), %rdi
callq 0x2150
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x2150
leaq -0x30(%rbp), %rdi
callq 0x2150
movq -0x58(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x22a0
leaq -0x50(%rbp), %rdi
callq 0x22a0
movq -0x1f8(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
callq 0x2060
jmp 0x950c
movl $0x10, %edi
movl $0x8, %esi
callq 0x9b30
movl %eax, -0x1fc(%rbp)
jmp 0x9523
movl -0x1fc(%rbp), %edx
leaq -0x1e8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2310
jmp 0x953b
leaq -0x1e8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2280
jmp 0x954d
movq -0x1f8(%rbp), %rdi
callq 0x91b0
movb %al, -0x1fd(%rbp)
jmp 0x9561
movb -0x1fd(%rbp), %al
testb $0x1, %al
jne 0x9582
jmp 0x956d
leaq -0x50(%rbp), %rdi
leaq 0x1c36(%rip), %rsi      # 0xb1ae
callq 0x20c0
cmpl $0x0, %eax
je 0x95af
callq 0x2130
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x95e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2180
jmp 0x95e8
movq -0x10(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x2280
jmp 0x95c1
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x50(%rbp), %rdi
callq 0x2150
leaq -0x30(%rbp), %rdi
callq 0x2150
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x2150
leaq -0x30(%rbp), %rdi
callq 0x2150
movq -0x58(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x22a0
leaq -0x50(%rbp), %rdi
callq 0x22a0
movq -0x1f8(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
callq 0x2060
jmp 0x965c
movl $0x10, %edi
movl $0x8, %esi
callq 0x9b30
movl %eax, -0x1fc(%rbp)
jmp 0x9673
movl -0x1fc(%rbp), %edx
leaq -0x1e8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2310
jmp 0x968b
leaq -0x1e8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2280
jmp 0x969d
movq -0x1f8(%rbp), %rdi
callq 0x91b0
movb %al, -0x1fd(%rbp)
jmp 0x96b1
movb -0x1fd(%rbp), %al
testb $0x1, %al
jne 0x96d2
jmp 0x96bd
leaq -0x50(%rbp), %rdi
leaq 0x1af9(%rip), %rsi      # 0xb1c1
callq 0x20c0
cmpl $0x0, %eax
je 0x96ff
callq 0x2130
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x9738
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2180
jmp 0x9738
movq -0x10(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x2090
jmp 0x9711
leaq -0x1e8(%rbp), %rdi
callq 0x2180
leaq -0x50(%rbp), %rdi
callq 0x2150
leaq -0x30(%rbp), %rdi
callq 0x2150
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x2150
leaq -0x30(%rbp), %rdi
callq 0x2150
movq -0x58(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x22a0
movq -0x218(%rbp), %rdi
movq -0x210(%rbp), %rsi
callq 0x2060
jmp 0x981c
movl $0x10, %edi
movl $0x8, %esi
callq 0x9b30
movl %eax, -0x21c(%rbp)
jmp 0x9833
movl -0x21c(%rbp), %edx
leaq -0x1c8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2310
jmp 0x984b
leaq -0x1e8(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x22a0
movq -0x228(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x2280
jmp 0x9873
leaq -0x1e8(%rbp), %rdi
leaq 0x194a(%rip), %rsi      # 0xb1cb
callq 0x20c0
cmpl $0x0, %eax
jne 0x992d
jmp 0x9891
leaq -0x1c8(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x2090
movq %rax, -0x230(%rbp)
jmp 0x98ad
movq -0x230(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2270
movb %al, -0x231(%rbp)
jmp 0x98cb
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0x98d7
jmp 0x992b
movq -0x10(%rbp), %rdi
fldt -0x200(%rbp)
fstpl -0x208(%rbp)
leaq -0x208(%rbp), %rsi
callq 0x3130
jmp 0x98f5
jmp 0x9891
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x996c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2150
leaq -0x1c8(%rbp), %rdi
callq 0x2180
jmp 0x996c
jmp 0x992d
movq -0x10(%rbp), %rdi
callq 0x2ff0
movl %eax, -0x238(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2150
leaq -0x1c8(%rbp), %rdi
callq 0x2180
leaq -0x30(%rbp), %rdi
callq 0x2150
movl -0x238(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2150
movq -0x38(%rbp), %rdi
callq 0x2360
nop
// File: 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
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x22a0
movq -0x218(%rbp), %rdi
movq -0x210(%rbp), %rsi
callq 0x2060
jmp 0x99cc
movl $0x10, %edi
movl $0x8, %esi
callq 0x9b30
movl %eax, -0x21c(%rbp)
jmp 0x99e3
movl -0x21c(%rbp), %edx
leaq -0x1c8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2310
jmp 0x99fb
leaq -0x1e8(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x22a0
movq -0x228(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x2280
jmp 0x9a23
leaq -0x1e8(%rbp), %rdi
leaq 0x179e(%rip), %rsi      # 0xb1cf
callq 0x20c0
cmpl $0x0, %eax
jne 0x9add
jmp 0x9a41
leaq -0x1c8(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x2090
movq %rax, -0x230(%rbp)
jmp 0x9a5d
movq -0x230(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2270
movb %al, -0x231(%rbp)
jmp 0x9a7b
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0x9a87
jmp 0x9adb
movq -0x10(%rbp), %rdi
fldt -0x200(%rbp)
fstpl -0x208(%rbp)
leaq -0x208(%rbp), %rsi
callq 0x3130
jmp 0x9aa5
jmp 0x9a41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9b1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2150
leaq -0x1c8(%rbp), %rdi
callq 0x2180
jmp 0x9b1c
jmp 0x9add
movq -0x10(%rbp), %rdi
callq 0x2ff0
movl %eax, -0x238(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2150
leaq -0x1c8(%rbp), %rdi
callq 0x2180
leaq -0x30(%rbp), %rdi
callq 0x2150
movl -0x238(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2150
movq -0x38(%rbp), %rdi
callq 0x2360
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x40e0, %edi           # imm = 0x40E0
callq 0x7340
movq %rax, 0x30(%rsp)
jmp 0x888d
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
movzwl 0x8(%rax), %edx
callq 0x19ad0
jmp 0x88a5
movq 0x30(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x19bc0
jmp 0x88b6
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
leaq 0x78(%rsp), %rsi
callq 0x19c40
jmp 0x88cb
leaq 0x78(%rsp), %rdi
callq 0xe880
jmp 0x88d7
movq 0x28(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
addq $0x60, %rdi
callq 0x19d20
movq %rax, 0x20(%rsp)
jmp 0x88f8
movq 0x20(%rsp), %rdi
callq 0x19d70
movq %rax, 0x10(%rsp)
jmp 0x8909
movq 0x28(%rsp), %rcx
leaq 0x1151b(%rip), %rax     # 0x19e30
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x1161c(%rip), %r8      # 0x19f50
leaq 0x50(%rsp), %rdi
callq 0x19d80
jmp 0x8940
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x50(%rsp), %rdx
callq 0x19cc0
jmp 0x895a
jmp 0x8a38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x89a5
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0x7310
jmp 0x89a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xe880
jmp 0x89a3
jmp 0x89a5
movl 0x6c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8a51
movq 0x70(%rsp), %rdi
callq 0x7150
movq %rax, 0x38(%rsp)
movq 0x3461c(%rip), %rdi     # 0x3cfe8
leaq 0x20cb8(%rip), %rsi     # 0x2968b
callq 0x7330
movq %rax, 0x8(%rsp)
jmp 0x89df
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7330
movq %rax, (%rsp)
jmp 0x8a00
movq (%rsp), %rdi
movq 0x3459d(%rip), %rsi     # 0x3cfa8
callq 0x7350
jmp 0x8a12
movb $0x0, 0x97(%rsp)
callq 0x7550
jmp 0x8a40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0x7550
jmp 0x8a36
jmp 0x8a51
movb $0x1, 0x97(%rsp)
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x7590
movq %rax, %rdi
callq 0x84c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0xede0
testb $0x1, %al
jne 0x19e58
jmp 0x19eb0
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
callq 0x19d20
movq %rax, %rdi
movq 0x20(%rsp), %rax
movq %rax, %rsi
addq $0x78, %rsi
movzwl 0x70(%rax), %edx
callq 0x1dd20
movq 0x20(%rsp), %rdi
callq 0x8860
testb $0x1, %al
jne 0x19eae
movq 0x23155(%rip), %rdi     # 0x3cfe8
leaq 0xf925(%rip), %rsi      # 0x297bf
callq 0x7330
movq %rax, %rdi
movq 0x230ff(%rip), %rsi     # 0x3cfa8
callq 0x7350
jmp 0x19f2d
movq 0x23131(%rip), %rdi     # 0x3cfe8
leaq 0xf1a6(%rip), %rsi      # 0x29064
callq 0x7330
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8470
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x72e0
movq %rax, 0x18(%rsp)
jmp 0x19ef2
movq 0x18(%rsp), %rdi
movq 0x230aa(%rip), %rsi     # 0x3cfa8
callq 0x7350
jmp 0x19f05
leaq 0x38(%rsp), %rdi
callq 0x7200
jmp 0x19f2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x7200
jmp 0x19f2b
jmp 0x19f32
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x7590
movq %rax, %rdi
callq 0x84c0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0xc8, %rsp
movw %dx, %ax
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movw %ax, 0xb6(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1df10
movq 0x10(%rsp), %rsi
movzwl 0xb6(%rsp), %edx
leaq 0x98(%rsp), %rdi
callq 0xe4e0
movq 0x18(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1e2f0
movq 0x20(%rsp), %rcx
leaq 0x2d7(%rip), %rax       # 0x1e080
movq %rax, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq -0x3e78(%rip), %r8      # 0x19f50
leaq 0x58(%rsp), %rdi
callq 0x1df40
jmp 0x1ddd4
movq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x1de60
jmp 0x1dded
leaq 0x58(%rsp), %rdi
callq 0x1e380
jmp 0x1ddf9
leaq 0x48(%rsp), %rdi
callq 0xe880
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1de37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1e380
jmp 0x1de35
jmp 0x1de37
leaq 0x48(%rsp), %rdi
callq 0xe880
jmp 0x1de43
jmp 0x1de45
movq 0x30(%rsp), %rdi
callq 0x7590
movq %rax, %rdi
callq 0x84c0
nopw (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rdi
callq 0xede0
testb $0x1, %al
jne 0x21622
jmp 0x2170b
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
addq $0x20b2, %rdi           # imm = 0x20B2
movq 0x80(%rsp), %rax
movq (%rax), %rsi
callq 0x21430
movq 0x18(%rsp), %rsi
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1e2f0
movq 0x10(%rsp), %rcx
leaq 0x1fcc(%rip), %rax      # 0x23640
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq -0x7743(%rip), %r8      # 0x19f50
leaq 0x50(%rsp), %rdi
callq 0x1df40
jmp 0x2169f
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x235e0
jmp 0x216b9
leaq 0x50(%rsp), %rdi
callq 0x1e380
jmp 0x216c5
leaq 0x40(%rsp), %rdi
callq 0xe880
jmp 0x21715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x216fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1e380
jmp 0x216fb
jmp 0x216fd
leaq 0x40(%rsp), %rdi
callq 0xe880
jmp 0x21709
jmp 0x2171d
movq 0x18(%rsp), %rdi
callq 0x218b0
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x7590
movq %rax, %rdi
callq 0x84c0
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rdi
callq 0xede0
testb $0x1, %al
jne 0x217a2
jmp 0x2188b
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
addq $0xb2, %rdi
movq 0x80(%rsp), %rax
movq (%rax), %rsi
callq 0x21430
movq 0x18(%rsp), %rsi
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1e2f0
movq 0x10(%rsp), %rcx
leaq 0x409c(%rip), %rax      # 0x25890
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq -0x78c3(%rip), %r8      # 0x19f50
leaq 0x50(%rsp), %rdi
callq 0x1df40
jmp 0x2181f
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x235e0
jmp 0x21839
leaq 0x50(%rsp), %rdi
callq 0x1e380
jmp 0x21845
leaq 0x40(%rsp), %rdi
callq 0xe880
jmp 0x21895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x2187d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1e380
jmp 0x2187b
jmp 0x2187d
leaq 0x40(%rsp), %rdi
callq 0xe880
jmp 0x21889
jmp 0x2189d
movq 0x18(%rsp), %rdi
callq 0x218b0
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x7590
movq %rax, %rdi
callq 0x84c0
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x40b8, %rsi           # imm = 0x40B8
leaq 0x20(%rsp), %rdi
callq 0x25b50
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x1b540
movb %al, 0x13(%rsp)
jmp 0x218e8
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x218f2
jmp 0x2191e
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x27ca0
jmp 0x21902
jmp 0x2191e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x25fa0
jmp 0x2195d
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x1b540
movb %al, 0x7(%rsp)
jmp 0x21932
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2193c
jmp 0x2194e
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x27ca0
jmp 0x2194c
jmp 0x2194e
leaq 0x20(%rsp), %rdi
callq 0x25fa0
addq $0x38, %rsp
retq
jmp 0x2195f
movq 0x18(%rsp), %rdi
callq 0x7590
movq %rax, %rdi
callq 0x84c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
callq 0xede0
testb $0x1, %al
jne 0x23674
jmp 0x23758
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, (%rsp)
addq $0x20b2, %rdi           # imm = 0x20B2
movl $0x2000, %esi           # imm = 0x2000
callq 0x21430
movq 0x10(%rsp), %rsi
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1e2f0
movq 0x8(%rsp), %rcx
leaq -0x20df(%rip), %rax     # 0x215e0
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq -0x978e(%rip), %r8      # 0x19f50
leaq -0x1fb5(%rip), %r9      # 0x21730
leaq 0x48(%rsp), %rdi
callq 0x21490
jmp 0x236f1
movq (%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x213e0
jmp 0x23706
leaq 0x48(%rsp), %rdi
callq 0x21740
jmp 0x23712
leaq 0x38(%rsp), %rdi
callq 0xe880
jmp 0x23762
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x2374a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x21740
jmp 0x23748
jmp 0x2374a
leaq 0x38(%rsp), %rdi
callq 0xe880
jmp 0x23756
jmp 0x2376a
movq 0x10(%rsp), %rdi
callq 0x218b0
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x7590
movq %rax, %rdi
callq 0x84c0
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rdi
callq 0xede0
testb $0x1, %al
jne 0x258ca
jmp 0x259da
movq 0x18(%rsp), %rsi
addq $0xb0, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq 0x80(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x25b00
movq (%rsp), %rdi
callq 0x25a00
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
addq $0xb2, %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x21430
movq 0x18(%rsp), %rsi
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1e2f0
movq 0x10(%rsp), %rcx
leaq -0x41e0(%rip), %rax     # 0x21760
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq -0xba0f(%rip), %r8      # 0x19f50
leaq -0x4236(%rip), %r9      # 0x21730
leaq 0x50(%rsp), %rdi
callq 0x21490
jmp 0x25972
movq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x213e0
jmp 0x25988
leaq 0x50(%rsp), %rdi
callq 0x21740
jmp 0x25994
leaq 0x40(%rsp), %rdi
callq 0xe880
jmp 0x259e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x259cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x21740
jmp 0x259ca
jmp 0x259cc
leaq 0x40(%rsp), %rdi
callq 0xe880
jmp 0x259d8
jmp 0x259ec
movq 0x18(%rsp), %rdi
callq 0x218b0
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x7590
movq %rax, %rdi
callq 0x84c0
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0xb75e
movq -0x28(%rbp), %rax
movq 0x5589a(%rip), %rcx     # 0x60fd8
movq (%rcx), %rdi
movl -0x14(%rbp), %edx
movl (%rax), %ecx
leaq 0x4a90f(%rip), %rsi     # 0x5605c
movb $0x0, %al
callq 0x5470
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xb794
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cltd
idivl 0x4(%rcx)
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl 0x4(%rcx)
movq -0x28(%rbp), %rax
movl %edx, -0x1c(%rbp)
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ridgelab[P]Kmer-SSR/test/src/voidPointer.cpp
// Function: main
int main()
{
	Dummy d1(1, "one");
	
	Dummy* d2 = new Dummy(2, "two");
	delete d2;

	dummyFunc((void*) new Dummy(3, "THREE"));

	cout << "\n\033[0;34mVoid Pointer Test: ";

	bool pass = true;

	if (pass)
	{
		cout << "\033[0;32mOK\033[0m" << endl;
	}
	else
	{
		cout << "\033[0;31mFAIL\033[0m" << endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xd84(%rip), %rdx       # 0x200a
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x1430
movl $0x28, %edi
callq 0x1060
movq %rax, -0x50(%rbp)
jmp 0x12a4
movq -0x50(%rbp), %rdi
leaq 0xd5f(%rip), %rdx       # 0x200e
movl $0x2, %esi
callq 0x1430
jmp 0x12bb
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x12e8
movq -0x58(%rbp), %rdi
callq 0x1410
movq -0x58(%rbp), %rdi
movl $0x28, %esi
callq 0x1070
movl $0x28, %edi
callq 0x1060
movq %rax, -0x60(%rbp)
jmp 0x12f8
movq -0x60(%rbp), %rdi
leaq 0xd0f(%rip), %rdx       # 0x2012
movl $0x3, %esi
callq 0x1430
jmp 0x130f
movq -0x60(%rbp), %rdi
callq 0x1210
jmp 0x131a
movq 0x2cb7(%rip), %rdi      # 0x3fd8
leaq 0xcf0(%rip), %rsi       # 0x2018
callq 0x1050
jmp 0x132f
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
je 0x13ac
movq 0x2c98(%rip), %rdi      # 0x3fd8
leaq 0xced(%rip), %rsi       # 0x2034
callq 0x1050
movq %rax, -0x68(%rbp)
jmp 0x1352
movq -0x68(%rbp), %rdi
movq 0x2c6b(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x1364
jmp 0x13d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x13f2
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x28, %esi
callq 0x1070
jmp 0x13f2
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x28, %esi
callq 0x1070
jmp 0x13f2
movq 0x2c25(%rip), %rdi      # 0x3fd8
leaq 0xc88(%rip), %rsi       # 0x2042
callq 0x1050
movq %rax, -0x70(%rbp)
jmp 0x13c5
movq -0x70(%rbp), %rdi
movq 0x2bf8(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x13d7
jmp 0x13d9
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1410
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x1410
movq -0x40(%rbp), %rdi
callq 0x10c0
nopw %cs:(%rax,%rax)
nop
// File: nmmmnu[P]asyncore_cpp/net/test/test_redisprotocol.cc
// Function: main
int main(){
	net::protocol::RedisProtocol p;

	test(p, "*3\r\n$3\r\nSET\r\n$4\r\ncity\r\n$5\r\nSofia\r\n");

	test(p, "*2\r\n$3\r\nGET\r\n$4\r\ncity\r\n");

	test(p, "*92\r\n$3\r\nGET\r\n$4\r\ncity\r\n");
	test(p, "$2\r\n$3\r\nGET\r\n$4\r\ncity\r\n");
	test(p, "*2\r\n*3\r\nGET\r\n$4\r\ncity\r\n");

#if 0
	using Status = net::protocol::RedisProtocol::Status;

	const char *data = "*3\r\n$3\r\nSET\r\n$4\r\ncity\r\n$5\r\nSofia\r\n";

	for(int i = 0; i < 2500000; ++i){
		const auto &status = p(data);

		if (status == Status::BUFFER_NOT_READ)
			std::cout << "problem" << std::endl;
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x13b0
movq -0x30(%rbp), %rdi
leaq 0x1cd4(%rip), %rsi      # 0x3004
callq 0x1400
jmp 0x1337
leaq 0x1ce9(%rip), %rsi      # 0x3027
leaq -0x18(%rbp), %rdi
callq 0x1400
jmp 0x1349
leaq 0x1cef(%rip), %rsi      # 0x303f
leaq -0x18(%rbp), %rdi
callq 0x1400
jmp 0x135b
leaq 0x1cf6(%rip), %rsi      # 0x3058
leaq -0x18(%rbp), %rdi
callq 0x1400
jmp 0x136d
leaq 0x1cfc(%rip), %rsi      # 0x3070
leaq -0x18(%rbp), %rdi
callq 0x1400
jmp 0x137f
leaq -0x18(%rbp), %rdi
callq 0x14d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x14d0
movq -0x20(%rbp), %rdi
callq 0x1110
nop
// File: nmmmnu[P]asyncore_cpp/net/test/test_redisprotocol.cc
// Function: void test<net::protocol::RedisProtocol>(net::protocol::RedisProtocol&, char const*)
void test(PROTOCOL &p, const char *data){
	using Status = typename PROTOCOL::Status;

	const Status status = p(data);

	std::cout	<< "Result status: " << test_status(status) << std::endl
			<< std::endl
	;

	if (status == Status::OK)
		p.print();

	std::cout	<< "---(eof)---" << std::endl
			<< std::endl
	;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1d60
movq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1f30
movl %eax, -0x14(%rbp)
movq 0x4b9c(%rip), %rdi      # 0x5fd8
leaq 0x1c55(%rip), %rsi      # 0x3098
callq 0x10b0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x1da0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x10b0
movq %rax, %rdi
movq 0x4b5e(%rip), %rsi      # 0x5fc8
callq 0x10d0
movq %rax, %rdi
movq 0x4b4f(%rip), %rsi      # 0x5fc8
callq 0x10d0
cmpl $0x0, -0x14(%rbp)
jne 0x148d
movq -0x8(%rbp), %rdi
callq 0x1eb0
movq 0x4b44(%rip), %rdi      # 0x5fd8
leaq 0x1c0d(%rip), %rsi      # 0x30a8
callq 0x10b0
movq %rax, %rdi
movq 0x4b1e(%rip), %rsi      # 0x5fc8
callq 0x10d0
movq %rax, %rdi
movq 0x4b0f(%rip), %rsi      # 0x5fc8
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nmmmnu[P]asyncore_cpp/net/test/test_redisprotocol.cc
// Function: char const* test_status<net::protocol::ProtocolStatus>(net::protocol::ProtocolStatus)
const char *test_status(const PROTOCOL_STATUS status){
	using Status = PROTOCOL_STATUS;

	switch(status){
	case Status::OK			: return "OK"		;
	case Status::BUFFER_NOT_READ	: return "MORE"		;
	default:
	case Status::ERROR		: return "ERROR"	;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x1dc7
jmp 0x1db3
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x1dd4
jmp 0x1dbd
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x1de3
jmp 0x1de1
leaq 0x12e6(%rip), %rax      # 0x30b4
movq %rax, -0x8(%rbp)
jmp 0x1dee
leaq 0x12dc(%rip), %rax      # 0x30b7
movq %rax, -0x8(%rbp)
jmp 0x1dee
jmp 0x1de3
leaq 0x12d2(%rip), %rax      # 0x30bc
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Living::dec_hp(int)
void Living::dec_hp(int dmg){
    HealthPower -= dmg;
    cout << name << " was hit for " << dmg << " points of damage." << endl;
    if(HealthPower <= 0){
        cout << name << " just fainted. :(" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl 0x2c(%rsi), %eax
subl %ecx, %eax
movl %eax, 0x2c(%rsi)
addq $0x8, %rsi
movq 0x1a143(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, %rdi
leaq 0x103ac(%rip), %rsi     # 0x15248
callq 0x31e0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3320
movq %rax, %rdi
leaq 0x103a0(%rip), %rsi     # 0x15256
callq 0x31e0
movq %rax, %rdi
movq 0x1a0fb(%rip), %rsi     # 0x1efc0
callq 0x3210
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jg 0x4f06
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq 0x1a0ed(%rip), %rdi     # 0x1efd0
callq 0x31b0
movq %rax, %rdi
leaq 0x10377(%rip), %rsi     # 0x15269
callq 0x31e0
movq %rax, %rdi
movq 0x1a0bf(%rip), %rsi     # 0x1efc0
callq 0x3210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::Hero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int)
Hero::Hero(string nam, int hp, int mp, int str, int ag, int dex)
    :Living(nam,hp),MagicPower(mp),Strength(str),Agility(ag),Dexterity(dex){
    Money = 500;
    exp = 0;
    NextLvlExp = 20;
    Armor_Equiped = NULL;
    Weapon_Equiped = NULL;
    Defense = 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x30c0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4da0
jmp 0x4f58
leaq -0x40(%rbp), %rdi
callq 0x3120
movq -0x60(%rbp), %rdi
leaq 0x19a64(%rip), %rax     # 0x1e9d0
addq $0x10, %rax
movq %rax, (%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x34(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x38(%rdi)
movl -0x20(%rbp), %eax
movl %eax, 0x3c(%rdi)
movl 0x10(%rbp), %eax
movl %eax, 0x40(%rdi)
addq $0x68, %rdi
callq 0x75d0
movq -0x60(%rbp), %rdi
addq $0x80, %rdi
callq 0x75f0
movq -0x60(%rbp), %rdi
addq $0x98, %rdi
callq 0x7610
movq -0x60(%rbp), %rdi
addq $0xb0, %rdi
callq 0x7630
movq -0x60(%rbp), %rax
movl $0x1f4, 0x48(%rax)      # imm = 0x1F4
movl $0x0, 0x4c(%rax)
movl $0x14, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movl $0x5, 0x44(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3120
movq -0x48(%rbp), %rdi
callq 0x3330
nopl (%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::buy_Weapon(Weapon*)
void Hero::buy_Weapon(Weapon * w){
    if(Money < w->get_price()){
        cout << "Not enough money!" << endl;
        return;
    }

    Money -= w->get_price();
    Weapons.push_front(w);
    cout << "You succesfully bought a new WEAPON: " << w->get_name() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x48(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12670
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x51b4
movq 0x19e39(%rip), %rdi     # 0x1efd0
leaq 0x100dd(%rip), %rsi     # 0x1527b
callq 0x31e0
movq %rax, %rdi
movq 0x19e13(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x522e
movq -0x10(%rbp), %rdi
callq 0x12670
movq -0x48(%rbp), %rdi
movl %eax, %ecx
movl 0x48(%rdi), %eax
subl %ecx, %eax
movl %eax, 0x48(%rdi)
addq $0x68, %rdi
leaq -0x10(%rbp), %rsi
callq 0x7650
movq 0x19df1(%rip), %rdi     # 0x1efd0
leaq 0x100a7(%rip), %rsi     # 0x1528d
callq 0x31e0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x12640
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x31b0
movq %rax, -0x50(%rbp)
jmp 0x5213
movq -0x50(%rbp), %rdi
movq 0x19da2(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x5225
leaq -0x30(%rbp), %rdi
callq 0x3120
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::buy_Armor(Armor*)
void Hero::buy_Armor(Armor * a){
    if(Money < a->get_price()){
        cout << "Not enough money!" << endl;
        return;
    }

    Money -= a->get_price();
    Armors.push_front(a);
    cout << "You succesfully bought a new ARMOR: " << a->get_name() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x48(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12670
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x52b4
movq 0x19d39(%rip), %rdi     # 0x1efd0
leaq 0xffdd(%rip), %rsi      # 0x1527b
callq 0x31e0
movq %rax, %rdi
movq 0x19d13(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x5331
movq -0x10(%rbp), %rdi
callq 0x12670
movq -0x48(%rbp), %rdi
movl %eax, %ecx
movl 0x48(%rdi), %eax
subl %ecx, %eax
movl %eax, 0x48(%rdi)
addq $0x98, %rdi
leaq -0x10(%rbp), %rsi
callq 0x7690
movq 0x19cee(%rip), %rdi     # 0x1efd0
leaq 0xffca(%rip), %rsi      # 0x152b3
callq 0x31e0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x12640
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x31b0
movq %rax, -0x50(%rbp)
jmp 0x5316
movq -0x50(%rbp), %rdi
movq 0x19c9f(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x5328
leaq -0x30(%rbp), %rdi
callq 0x3120
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: kongrigoriou[P]Text-Based-RPG/src/Heroes.cpp
// Function: Hero::buy_Potion(Potion*)
void Hero::buy_Potion(Potion * p){
    if(Money < p->get_price()){
        cout << "Not enough money!" << endl;
        return;
    }

    Money -= p->get_price();
    Potions.push_front(p);
    cout << "You succesfully bought a new POTION: " << p->get_name() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x48(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12670
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x53b4
movq 0x19c39(%rip), %rdi     # 0x1efd0
leaq 0xfedd(%rip), %rsi      # 0x1527b
callq 0x31e0
movq %rax, %rdi
movq 0x19c13(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x5431
movq -0x10(%rbp), %rdi
callq 0x12670
movq -0x48(%rbp), %rdi
movl %eax, %ecx
movl 0x48(%rdi), %eax
subl %ecx, %eax
movl %eax, 0x48(%rdi)
addq $0xb0, %rdi
leaq -0x10(%rbp), %rsi
callq 0x76d0
movq 0x19bee(%rip), %rdi     # 0x1efd0
leaq 0xfeef(%rip), %rsi      # 0x152d8
callq 0x31e0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x12640
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x31b0
movq %rax, -0x50(%rbp)
jmp 0x5416
movq -0x50(%rbp), %rdi
movq 0x19b9f(%rip), %rsi     # 0x1efc0
callq 0x3210
jmp 0x5428
leaq -0x30(%rbp), %rdi
callq 0x3120
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)