LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::get_output() const
std::vector<double> Network::get_output() const
{
    std::vector<double> output;
    for (auto& neuron: this->motor_neurons) {
        int decimals = pow(10, this->precision);
        output.push_back(roundf(neuron->potential * decimals) / decimals);
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x19610
movq -0x68(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x19de0
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
callq 0x19e30
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x19e90
testb $0x1, %al
jne 0x18538
jmp 0x185e1
leaq -0x10(%rbp), %rdi
callq 0x19ed0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x48(%rbp)
movl (%rax), %esi
movl $0xa, %edi
callq 0x19650
movsd %xmm0, -0x80(%rbp)
jmp 0x1855f
movsd -0x80(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movsd 0xa0(%rax), %xmm0
movl -0x4c(%rbp), %eax
movl %eax, -0x84(%rbp)
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x162e0
movl -0x84(%rbp), %eax
movq -0x78(%rbp), %rdi
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x19f10
jmp 0x185ba
jmp 0x185bc
leaq -0x10(%rbp), %rdi
callq 0x19ef0
jmp 0x18522
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x19910
jmp 0x18613
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x185f4
movq -0x78(%rbp), %rdi
callq 0x19910
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1863c
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1863c
movq -0x90(%rbp), %rdi
callq 0x164e0
callq 0x16340
nopw %cs:(%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/network.hpp
// Function: std::vector<Neuron*, std::allocator<Neuron*>> random_sample<std::vector<Neuron*, std::allocator<Neuron*>>>(std::vector<Neuron*, std::allocator<Neuron*>>, unsigned int)
RandomSampling random_sample(
    RandomSampling neurons,
    unsigned int sample_length
)
{
    RandomSampling sample;
    std::sample(neurons.begin(), neurons.end(), std::back_inserter(sample),
        sample_length, std::mt19937{std::random_device{}()});
    return sample;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x27a0, %rsp           # imm = 0x27A0
movq %rsi, -0x2778(%rbp)
movq %rdi, -0x2770(%rbp)
movq %rdi, %rax
movq %rax, -0x2780(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x2720(%rbp)
movq %rsi, -0x2728(%rbp)
movl %edx, -0x272c(%rbp)
movb $0x0, -0x272d(%rbp)
callq 0x195f0
movq -0x2778(%rbp), %rdi
callq 0x19160
movq -0x2778(%rbp), %rdi
movq %rax, -0x2738(%rbp)
callq 0x191b0
movq -0x2770(%rbp), %rdi
movq %rax, -0x2740(%rbp)
callq 0x1f4f0
movq %rax, -0x2768(%rbp)
jmp 0x18e7b
movq -0x2768(%rbp), %rax
movq %rax, -0x2748(%rbp)
movl -0x272c(%rbp), %eax
movl %eax, -0x2784(%rbp)
leaq -0x2718(%rbp), %rdi
callq 0x1c760
jmp 0x18ea3
leaq -0x2718(%rbp), %rdi
callq 0x1c840
movl %eax, -0x2788(%rbp)
jmp 0x18eb7
movl -0x2788(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x1390(%rbp), %rdi
callq 0x1f540
jmp 0x18ecf
movl -0x2784(%rbp), %ecx
movq -0x2738(%rbp), %rdi
movq -0x2740(%rbp), %rsi
movq -0x2748(%rbp), %rdx
leaq -0x1390(%rbp), %r8
callq 0x1f460
movq %rax, -0x2790(%rbp)
jmp 0x18eff
movq -0x2790(%rbp), %rax
movq %rax, -0x2760(%rbp)
leaq -0x2718(%rbp), %rdi
callq 0x1c9c0
movb $0x1, -0x272d(%rbp)
testb $0x1, -0x272d(%rbp)
jne 0x18f6b
jmp 0x18f5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2750(%rbp)
movl %eax, -0x2754(%rbp)
jmp 0x18f8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2750(%rbp)
movl %eax, -0x2754(%rbp)
leaq -0x2718(%rbp), %rdi
callq 0x1c9c0
jmp 0x18f8d
movq -0x2770(%rbp), %rdi
callq 0x19100
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x18fc5
movq -0x2780(%rbp), %rax
addq $0x27a0, %rsp           # imm = 0x27A0
popq %rbp
retq
movq -0x2770(%rbp), %rdi
callq 0x19100
movq -0x2750(%rbp), %rax
movq %rax, -0x2798(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x18fc5
movq -0x2798(%rbp), %rdi
callq 0x164e0
callq 0x16340
nopw (%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: parse_iterable(std::vector<double, std::allocator<double>>&, _object*)
void parse_iterable(std::vector<double> &arr, PyObject *iter)
{
    while (true) {
        PyObject *next = PyIter_Next(iter);
        if (!next) {
            // nothing left in the iterator
            Py_XDECREF(next);
            break;
        }

        if (!PyFloat_Check(next)) {
            throw
                "One of the arguments contains an illegal "
                "value (other than float)"
            ;
        }

        double val = PyFloat_AsDouble(next);
        Py_XDECREF(next);
        arr.push_back(val);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x164d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x23d6c
movq -0x28(%rbp), %rdi
callq 0x23e10
jmp 0x23deb
movq -0x28(%rbp), %rdi
movq 0xd259(%rip), %rsi      # 0x30fd0
callq 0x23e40
cmpl $0x0, %eax
jne 0x23dc2
movl $0x8, %edi
callq 0x16130
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
leaq 0x3707(%rip), %rcx      # 0x274a0
movq %rcx, (%rax)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x23e03
movq -0x30(%rbp), %rdi
movq 0xd1af(%rip), %rsi      # 0x30f68
xorl %eax, %eax
movl %eax, %edx
callq 0x16490
movq -0x28(%rbp), %rdi
callq 0x161f0
movsd %xmm0, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x23e10
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x25bd0
jmp 0x23d4d
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x23e03
addq $0x30, %rsp
popq %rbp
retq
callq 0x16340
nopl (%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_init(PyNeuron*, _object*)
static int PyNeuron_init(PyNeuron *self, PyObject *args)
{
    PyNetwork * network;

    if (! PyArg_ParseTuple(args, "O", &network))
        return -1;

    Py_XINCREF(network);

    self->ptrObj = new Neuron(*network->ptrObj);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x3263(%rip), %rsi      # 0x2757b
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x16430
cmpl $0x0, %eax
jne 0x24331
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x2438e
movq -0x10(%rbp), %rdi
callq 0x24950
movl $0xb0, %edi
callq 0x162c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x166c0
jmp 0x2435d
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
jmp 0x2438e
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0xb0, %esi
callq 0x162d0
jmp 0x243af
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x243d2
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x243d2
movq -0x50(%rbp), %rdi
callq 0x164e0
callq 0x16340
nopw (%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: main
int main(int argc, char *argv[])
{
    glob_argc = argc;
    glob_argv = argv;

    wchar_t *program = Py_DecodeLocale(argv[0], NULL);

    /* Pass argv[0] to the Python interpreter */
    Py_SetProgramName(program);

    /* Initialize the Python interpreter.  Required. */
    Py_Initialize();

    /* Add a static module */
    initcplexus();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq 0xcb37(%rip), %rax      # 0x30f60
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq 0xcb92(%rip), %rax      # 0x30fc8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x163c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16370
callq 0x16520
callq 0x24400
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNetwork_get_output(PyNetwork*, void*)
static PyObject * PyNetwork_get_output(PyNetwork *self, void *closure)
{
    std::vector<double> output;

    output = (self->ptrObj)->get_output();

    PyObject *PList = PyList_New(0);

    for (const auto& i: output) {
        PyObject *value = Py_BuildValue("d", i);
        PyList_Append(PList, value);
        Py_XDECREF(value);
    }

    return PList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x50(%rbp)
movq %rsi, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x19610
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x184c0
jmp 0x24cec
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0x98(%rbp)
callq 0x19a30
movq -0x98(%rbp), %rdi
callq 0x19910
xorl %eax, %eax
movl %eax, %edi
callq 0x16260
movq %rax, -0x90(%rbp)
jmp 0x24d1e
movq -0x90(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x19f40
movq %rax, -0x40(%rbp)
movq -0x78(%rbp), %rdi
callq 0x19f90
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x19ff0
testb $0x1, %al
jne 0x24d5e
jmp 0x24ddc
leaq -0x40(%rbp), %rdi
callq 0x1a030
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movsd (%rax), %xmm0
leaq 0x2799(%rip), %rdi      # 0x27513
movb $0x1, %al
callq 0x16210
movq %rax, -0xa0(%rbp)
jmp 0x24d8a
movq -0xa0(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x16170
jmp 0x24daa
movq -0x88(%rbp), %rdi
callq 0x23e10
jmp 0x24db8
jmp 0x24dba
leaq -0x40(%rbp), %rdi
callq 0x1a050
jmp 0x24d4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x19910
jmp 0x24e12
movq -0x70(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x19910
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x24e3b
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x24e3b
movq -0xb0(%rbp), %rdi
callq 0x164e0
callq 0x16340
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNetwork_neuron_PyList_builder(std::vector<Neuron*, std::allocator<Neuron*>>)
static PyObject * PyNetwork_neuron_PyList_builder(std::vector<Neuron*> neurons)
{
    PyObject *PList = PyList_New(0);
    Py_XINCREF(PList);

    for (Neuron* i: neurons) {
        PyNeuron * neuron = PyObject_New(PyNeuron, &PyNeuronType);
        neuron->ptrObj = i;
        PyList_Append(PList, Py_BuildValue("O", neuron));
    }
    return PList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x16260
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x24950
movq -0x48(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x19160
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
callq 0x191b0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x19210
testb $0x1, %al
jne 0x253e8
jmp 0x25445
leaq -0x10(%rbp), %rdi
callq 0x19250
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq 0xc441(%rip), %rdi      # 0x31840
callq 0x16190
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rsi
leaq 0x2154(%rip), %rdi      # 0x2757b
movb $0x0, %al
callq 0x16210
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x16170
leaq -0x10(%rbp), %rdi
callq 0x19350
jmp 0x253d5
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x25469
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
callq 0x16340
nop
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_set_index(PyNeuron*, _object*, void*)
static int PyNeuron_set_index(PyNeuron *self, PyObject *value, void *closue)
{
    if (value == NULL) {
        PyErr_SetString(
            PyExc_TypeError,
            "Cannot delete the position attribute"
        );
        return -1;
    }

    if (! PyLong_Check(value)) {
        PyErr_SetString(
            PyExc_TypeError,
            "The position attribute value must be an integer"
        );
        return -1;
    }

    self->ptrObj->index = PyLong_AsLong(value);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2557a
movq 0xba56(%rip), %rax      # 0x30fb8
movq (%rax), %rdi
leaq 0x267a(%rip), %rsi      # 0x27be6
callq 0x16360
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x255cf
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1000000, %esi        # imm = 0x1000000
callq 0x25a80
cmpl $0x0, %eax
jne 0x255b0
movq 0xba20(%rip), %rax      # 0x30fb8
movq (%rax), %rdi
leaq 0x2669(%rip), %rsi      # 0x27c0b
callq 0x16360
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x255cf
movq -0x18(%rbp), %rdi
callq 0x16040
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_get_position(PyNeuron*, void*)
static PyObject * PyNeuron_get_position(PyNeuron *self, void *closure)
{
    PyObject *PList = PyList_New(0);
    Py_XINCREF(PList);
    PyList_Append(
        PList,
        Py_BuildValue(
            "i",
            std::get<0>(self->ptrObj->position)
        )
    );
    PyList_Append(
        PList,
        Py_BuildValue(
            "i",
            std::get<1>(self->ptrObj->position)
        )
    );
    return PyList_AsTuple(PList);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x16260
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24950
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x14, %rdi
callq 0x26370
movl (%rax), %esi
leaq 0x2353(%rip), %rdi      # 0x27a3b
movb $0x0, %al
callq 0x16210
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x16170
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x14, %rdi
callq 0x26390
movl (%rax), %esi
leaq 0x231e(%rip), %rdi      # 0x27a3b
movb $0x0, %al
callq 0x16210
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x16170
movq -0x18(%rbp), %rdi
callq 0x16110
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_set_position(PyNeuron*, _object*, void*)
static int PyNeuron_set_position(PyNeuron *self, PyObject *value, void *closue)
{
    if (value == NULL) {
        PyErr_SetString(
            PyExc_TypeError,
            "Cannot delete the position attribute"
        );
        return -1;
    }

    if (! PyTuple_Check(value)) {
        PyErr_SetString(
            PyExc_TypeError,
            "The position attribute value must be a tuple"
        );
        return -1;
    }

    PyObject *x = PyTuple_GetItem(value, 0);
    PyObject *y = PyTuple_GetItem(value, 1);

    if (! PyFloat_Check(x) || ! PyFloat_Check(y)) {
        PyErr_SetString(
            PyExc_TypeError,
            "The elements of position attribute must be float"
        );
        return -1;
    }

    std::get<0>(self->ptrObj->position) = PyFloat_AsDouble(x);
    std::get<1>(self->ptrObj->position) = PyFloat_AsDouble(y);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2577d
movq 0xb856(%rip), %rax      # 0x30fb8
movq (%rax), %rdi
leaq 0x247a(%rip), %rsi      # 0x27be6
callq 0x16360
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25875
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x4000000, %esi        # imm = 0x4000000
callq 0x25a80
cmpl $0x0, %eax
jne 0x257b6
movq 0xb81d(%rip), %rax      # 0x30fb8
movq (%rax), %rdi
leaq 0x2496(%rip), %rsi      # 0x27c3b
callq 0x16360
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25875
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16550
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x16550
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq 0xb7ec(%rip), %rsi      # 0x30fd0
callq 0x23e40
cmpl $0x0, %eax
je 0x25803
movq -0x30(%rbp), %rdi
movq 0xb7d7(%rip), %rsi      # 0x30fd0
callq 0x23e40
cmpl $0x0, %eax
jne 0x25822
movq 0xb7ae(%rip), %rax      # 0x30fb8
movq (%rax), %rdi
leaq 0x2454(%rip), %rsi      # 0x27c68
callq 0x16360
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25875
movq -0x28(%rbp), %rdi
callq 0x161f0
cvttsd2si %xmm0, %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x14, %rdi
callq 0x26370
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x161f0
cvttsd2si %xmm0, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x14, %rdi
callq 0x26390
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: PyNeuron_connections_PyDict_build(std::unordered_map<Neuron*, double, std::hash<Neuron*>, std::equal_to<Neuron*>, std::allocator<std::pair<Neuron* const, double>>>)
static PyObject * PyNeuron_connections_PyDict_build(
    std::unordered_map<Neuron*,
    double> connections
)
{
    PyObject *PDict = PyDict_New();
    Py_XINCREF(PDict);

    for (auto& it: connections) {
        PyNeuron * neuron = PyObject_New(PyNeuron, &PyNeuronType);
        neuron->ptrObj = it.first;
        PyDict_SetItem(
            PDict,
            Py_BuildValue("O", neuron),
            Py_BuildValue("d", it.second)
        );
    }
    return PDict;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
callq 0x16350
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x24950
movq -0x48(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x19500
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
callq 0x19530
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x193d0
testb $0x1, %al
jne 0x25b24
jmp 0x25ba3
leaq -0x10(%rbp), %rdi
callq 0x19560
movq %rax, -0x38(%rbp)
leaq 0xbd08(%rip), %rdi      # 0x31840
callq 0x16190
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rsi
leaq 0x1a18(%rip), %rdi      # 0x2757b
movb $0x0, %al
callq 0x16210
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x1995(%rip), %rdi      # 0x27513
movb $0x1, %al
callq 0x16210
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x160d0
leaq -0x10(%rbp), %rdi
callq 0x195c0
jmp 0x25b11
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x25bc7
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
callq 0x16340
nopl (%rax)
// File: Funcke[P]cpp_server/lib/http_request_lifecycle.cpp
// Function: http::HttpRequestLifecycle::HttpRequestLifecycle(int)
HttpRequestLifecycle::HttpRequestLifecycle(int socket) {
        this->socket = socket;
        this->request.first_line(this->read_line());
        printf("%s\n", this->request.protocol.c_str());
        while(true) {
            std::string* raw_header = this->read_line();
            if(raw_header->length() == 1)
                break;
            this->request.add_header_from_string(raw_header);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3bc0
movq -0x38(%rbp), %rdi
leaq 0xc2f1(%rip), %rax      # 0xfd18
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x3be0
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0xc8(%rdi)
callq 0x3af0
movq %rax, -0x30(%rbp)
jmp 0x3a56
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x41a0
jmp 0x3a65
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x65bc(%rip), %rdi      # 0xa038
xorl %eax, %eax
callq 0x3050
jmp 0x3a85
jmp 0x3a87
jmp 0x3a89
movq -0x38(%rbp), %rdi
callq 0x3af0
movq %rax, -0x50(%rbp)
jmp 0x3a98
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x33b0
cmpq $0x1, %rax
jne 0x3ac8
jmp 0x3add
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3c40
jmp 0x3ae3
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0x4380
jmp 0x3adb
jmp 0x3a87
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: Funcke[P]cpp_server/lib/http_request_lifecycle.cpp
// Function: http::HttpRequestLifecycle::read_line[abi:cxx11]()
std::string* HttpRequestLifecycle::read_line() {
        std::string* line = new std::string();
        char next;
        do{
        read(this->socket, &next, 1); 
        if(next != '\n')
            *line += next;
        }while(next != '\n');
        return line;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x20, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
callq 0x3350
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movl 0xc8(%rax), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x3380
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
je 0x3b52
movb -0x11(%rbp), %al
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x31b0
jmp 0x3b54
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x3b22
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Funcke[P]cpp_server/lib/request.cpp
// Function: http::Request::first_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Request::first_line(std::string* first) {
        std::istringstream iss(*first);
        std::vector<std::string> results(std::istream_iterator<std::string>{iss},std::istream_iterator<std::string>());
        this->method = results[0];
        this->path = results[1];
        this->protocol = results[2];                   
    }

// 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, -0x230(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x228(%rbp)
movl $0x8, %edx
callq 0x33f0
movq -0x228(%rbp), %rsi
leaq -0x1d8(%rbp), %rdi
callq 0x4730
jmp 0x41ef
leaq -0x218(%rbp), %rdi
callq 0x4790
jmp 0x41fd
leaq -0x219(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x47d0
movq -0x238(%rbp), %rcx
leaq -0x1a8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
leaq -0x218(%rbp), %rdx
callq 0x47f0
jmp 0x4233
leaq -0x219(%rbp), %rdi
callq 0x48f0
leaq -0x218(%rbp), %rdi
callq 0x4910
leaq -0x1d8(%rbp), %rdi
callq 0x4910
xorl %eax, %eax
movl %eax, %esi
leaq -0x1a8(%rbp), %rdi
callq 0x4930
movq -0x230(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rdi
callq 0x3040
jmp 0x427c
leaq -0x1a8(%rbp), %rdi
movl $0x1, %esi
callq 0x4930
movq -0x230(%rbp), %rdi
movq %rax, %rsi
callq 0x3040
jmp 0x429e
leaq -0x1a8(%rbp), %rdi
movl $0x2, %esi
callq 0x4930
movq -0x230(%rbp), %rdi
movq %rax, %rsi
addq $0x40, %rdi
callq 0x3040
jmp 0x42c4
leaq -0x1a8(%rbp), %rdi
callq 0x4950
leaq -0x190(%rbp), %rdi
callq 0x3160
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
jmp 0x4363
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
jmp 0x4337
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
leaq -0x219(%rbp), %rdi
callq 0x48f0
leaq -0x218(%rbp), %rdi
callq 0x4910
leaq -0x1d8(%rbp), %rdi
callq 0x4910
jmp 0x4363
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x4950
leaq -0x190(%rbp), %rdi
callq 0x3160
movq -0x1e0(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: Funcke[P]cpp_server/lib/request.cpp
// Function: http::Request::add_header_from_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Request::add_header_from_string(std::string* raw_header) {
        const std::string delimiter(": ");
        int split_pos = raw_header->find(delimiter);
        std::string key = raw_header->substr(0, split_pos);
        std::string value = raw_header->substr(split_pos + 2, raw_header->size());
        if(key == "Cookie")
            this->add_cookie(&value);
        else
            this->add_header(&key, &value);
        std::cout << key << std::endl;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3420
movq -0x90(%rbp), %rdx
leaq 0x5ca7(%rip), %rsi      # 0xa063
leaq -0x30(%rbp), %rdi
callq 0x36b0
jmp 0x43c7
leaq -0x31(%rbp), %rdi
callq 0x32f0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xa0(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x3470
movq -0xa0(%rbp), %rdx
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movslq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x32b0
jmp 0x4405
movq -0x10(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl -0x48(%rbp), %eax
addl $0x2, %eax
cltq
movq %rax, -0xa8(%rbp)
callq 0x31f0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
leaq -0x88(%rbp), %rdi
callq 0x32b0
jmp 0x4443
leaq 0x5c1c(%rip), %rsi      # 0xa066
leaq -0x68(%rbp), %rdi
callq 0x49b0
movb %al, -0xb1(%rbp)
jmp 0x445b
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x4467
jmp 0x44d4
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4560
jmp 0x447c
jmp 0x44ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32f0
jmp 0x4556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x454d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4544
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x31a0
jmp 0x4544
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x46f0
jmp 0x44ed
jmp 0x44ef
movq 0xbada(%rip), %rdi      # 0xffd0
leaq -0x68(%rbp), %rsi
callq 0x3260
movq %rax, -0xc0(%rbp)
jmp 0x4508
movq -0xc0(%rbp), %rdi
movq 0xbaa2(%rip), %rsi      # 0xffb8
callq 0x32d0
jmp 0x451d
leaq -0x88(%rbp), %rdi
callq 0x31a0
leaq -0x68(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x40(%rbp), %rdi
callq 0x3410
nop
// File: Funcke[P]cpp_server/lib/request.cpp
// Function: http::Request::add_cookie(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Request::add_cookie(std::string* cookie) {
        const std::string delimiter("=");
        int split_pos = cookie->find(delimiter);
        const std::string key = cookie->substr(0, split_pos);
        const std::string value = cookie->substr(split_pos + 1, cookie->size());
        this->cookies[key] = value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3420
movq -0x90(%rbp), %rdx
leaq 0x5ad1(%rip), %rsi      # 0xa06d
leaq -0x30(%rbp), %rdi
callq 0x36b0
jmp 0x45a7
leaq -0x31(%rbp), %rdi
callq 0x32f0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xa0(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x3470
movq -0xa0(%rbp), %rdx
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movslq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x32b0
jmp 0x45e5
movq -0x10(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl -0x48(%rbp), %eax
incl %eax
cltq
movq %rax, -0xa8(%rbp)
callq 0x31f0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
leaq -0x88(%rbp), %rdi
callq 0x32b0
jmp 0x4622
movq -0x98(%rbp), %rdi
addq $0x90, %rdi
leaq -0x68(%rbp), %rsi
callq 0x49e0
movq %rax, -0xb8(%rbp)
jmp 0x4642
movq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3040
jmp 0x4657
leaq -0x88(%rbp), %rdi
callq 0x31a0
leaq -0x68(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32f0
jmp 0x46db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x46d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x46c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x31a0
leaq -0x68(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x40(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: Funcke[P]cpp_server/lib/server.cpp
// Function: http::Server::Server(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Server::Server(int port, std::string host) {
        this->network_access.sin_port = htons(port);
        this->network_access.sin_addr.s_addr = inet_addr(host.c_str());
        this->network_access.sin_family = AF_INET;
        this->threadpool = new Threadpool(120);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movzwl -0xc(%rbp), %edi
callq 0x3060
movq -0x40(%rbp), %rdi
movw %ax, %cx
movq -0x38(%rbp), %rax
movw %cx, 0xe(%rax)
callq 0x3110
movq %rax, %rdi
callq 0x3290
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movw $0x2, 0xc(%rax)
movl $0xd0, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x78, %esi
callq 0x6e40
jmp 0x6ae3
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xd0, %esi
callq 0x32a0
movq -0x20(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: Funcke[P]cpp_server/lib/server.cpp
// Function: http::Server::connect_to_network()
void Server::connect_to_network() {
        //memset(&this->network_access, 0, sizeof(this->network_access));
        this->network_socket = socket( AF_INET, SOCK_STREAM, 0 );
        
        if(bind(this->network_socket, (struct sockaddr*)&this->network_access, sizeof(this->network_access)) > 0) {
            this->abort(-1, "Could not bind server to socket!\n");
        }

        if(listen(this->network_socket, 100) < 0) {
            this->abort(-2, "Connection queue overrun!\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30a0
movq -0x70(%rbp), %rsi
movl %eax, 0x8(%rsi)
movl 0x8(%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x3070
cmpl $0x0, %eax
jle 0x6c11
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3420
movq -0x78(%rbp), %rdx
leaq 0x34dd(%rip), %rsi      # 0xa08a
leaq -0x28(%rbp), %rdi
callq 0x36b0
jmp 0x6bb8
movq -0x70(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rdx
callq 0x6ce0
jmp 0x6bcc
leaq -0x28(%rbp), %rdi
callq 0x31a0
leaq -0x29(%rbp), %rdi
callq 0x32f0
jmp 0x6c11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6c03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31a0
leaq -0x29(%rbp), %rdi
callq 0x32f0
jmp 0x6ca9
movq -0x70(%rbp), %rax
movl 0x8(%rax), %edi
movl $0x64, %esi
callq 0x3320
cmpl $0x0, %eax
jge 0x6ca0
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3420
movq -0x80(%rbp), %rdx
leaq 0x346d(%rip), %rsi      # 0xa0ac
leaq -0x60(%rbp), %rdi
callq 0x36b0
jmp 0x6c4a
movq -0x70(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq -0x60(%rbp), %rdx
callq 0x6ce0
jmp 0x6c5e
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x61(%rbp), %rdi
callq 0x32f0
jmp 0x6ca0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6c95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x61(%rbp), %rdi
callq 0x32f0
jmp 0x6ca9
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: Funcke[P]cpp_server/lib/server.cpp
// Function: http::Server::wait_for_requests()
void Server::wait_for_requests() {
        socklen_t len;
        len = sizeof(this->network_access);
        int connection = accept(this->network_socket, (struct sockaddr*)&this->network_access, &len);
        if(connection < 0) {
            this->abort(-3, "Client could not connect\n");
        }
        HttpRequestLifecycle* lc = new HttpRequestLifecycle(connection);
        this->threadpool->add_job(lc);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movl $0x10, -0xc(%rbp)
movl 0x8(%rsi), %edi
addq $0xc, %rsi
leaq -0xc(%rbp), %rdx
callq 0x30e0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x6ddd
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3420
movq -0x60(%rbp), %rdx
leaq 0x334b(%rip), %rsi      # 0xa0c7
leaq -0x30(%rbp), %rdi
callq 0x36b0
jmp 0x6d87
movq -0x58(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
leaq -0x30(%rbp), %rdx
callq 0x6ce0
jmp 0x6d9b
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x31(%rbp), %rdi
callq 0x32f0
jmp 0x6ddd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6dd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x31(%rbp), %rdi
callq 0x32f0
jmp 0x6e33
movl $0xd0, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movl -0x10(%rbp), %esi
callq 0x3a00
jmp 0x6dfb
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
movq -0x50(%rbp), %rsi
callq 0x7170
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0xd0, %esi
callq 0x32a0
movq -0x40(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: Funcke[P]cpp_server/lib/threadpool.cpp
// Function: Threadpool::Threadpool(int)
Threadpool::Threadpool(int size) {
    this->size = size;
    this->terminated = false;
    for(int i = 0; i < size; i++) {
        this->pool.push_back(std::thread(&Threadpool::worker_loop, this));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7330
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x48(%rbp)
callq 0x7350
jmp 0x6e80
movq -0x50(%rbp), %rdi
addq $0xb0, %rdi
movq %rdi, -0x60(%rbp)
callq 0x7380
movq -0x50(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0xa8(%rax)
movb $0x0, 0xc8(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6f4d
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0xb0, %rcx
movq %rcx, -0x68(%rbp)
leaq 0xac(%rip), %rcx        # 0x6f80
movq %rcx, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x73d0
jmp 0x6ef7
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x73a0
jmp 0x6f06
leaq -0x28(%rbp), %rdi
callq 0x7490
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6eaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x6f65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x6f53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7490
jmp 0x6f53
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x74c0
movq -0x48(%rbp), %rdi
callq 0x7520
movq -0x58(%rbp), %rdi
callq 0x3440
movq -0x18(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: Funcke[P]cpp_server/lib/threadpool.cpp
// Function: Threadpool::worker_loop()
void Threadpool::worker_loop() {
    while(1) {
        {
            Job* j;
            std::unique_lock<std::mutex> lock(this->job_mutex);
            this->condition.wait(lock, [this]{ return (this->job_queue.size() != 0 || this->terminated);});
            j = std::move(this->job_queue.front());
            this->job_queue.pop();
            printf("Job read\n");
            lock.unlock();
            j->run();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x7540
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
callq 0x7200
jmp 0x6fc3
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
callq 0x7640
movq %rax, -0x50(%rbp)
jmp 0x6fd6
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x58, %rdi
callq 0x7660
jmp 0x6ff0
leaq 0x30f8(%rip), %rdi      # 0xa0ef
xorl %eax, %eax
callq 0x3050
jmp 0x7000
leaq -0x20(%rbp), %rdi
callq 0x75b0
jmp 0x700b
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x7019
leaq -0x20(%rbp), %rdi
callq 0x7600
jmp 0x6f94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7600
movq -0x30(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: Funcke[P]cpp_server/lib/threadpool.cpp
// Function: Threadpool::~Threadpool()
Threadpool::~Threadpool() {
    delete(&(this->job_mutex));
    delete(&(this->condition));
    delete(&(this->job_queue));
    delete(&(this->size));
    delete(&(this->pool));
    delete(&(this->terminated));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7078
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x32a0
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x70a1
movq -0x18(%rbp), %rdi
callq 0x3440
movq -0x18(%rbp), %rdi
movl $0x30, %esi
callq 0x32a0
movq -0x10(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x70ca
movq -0x20(%rbp), %rdi
callq 0x7520
movq -0x20(%rbp), %rdi
movl $0x50, %esi
callq 0x32a0
movq -0x10(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x70ec
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x32a0
movq -0x10(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7117
movq -0x30(%rbp), %rdi
callq 0x74c0
movq -0x30(%rbp), %rdi
movl $0x18, %esi
callq 0x32a0
movq -0x10(%rbp), %rax
addq $0xc8, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x7139
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x32a0
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
callq 0x74c0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x7520
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x3440
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Funcke[P]cpp_server/lib/threadpool.cpp
// Function: Threadpool::add_job(Job*)
void Threadpool::add_job(Job* j) {
    std::unique_lock<std::mutex> lock(this->job_mutex);
    this->job_queue.push(j);
    printf("Job added\n");
    lock.unlock();
    this->condition.notify_all();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7540
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
leaq -0x10(%rbp), %rsi
callq 0x7580
jmp 0x71a4
leaq 0x2f39(%rip), %rdi      # 0xa0e4
xorl %eax, %eax
callq 0x3050
jmp 0x71b4
leaq -0x20(%rbp), %rdi
callq 0x75b0
jmp 0x71bf
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x3400
leaq -0x20(%rbp), %rdi
callq 0x7600
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7600
movq -0x28(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/main.cpp
// Function: main
int main()
{
  Cart newCart;
  vector<Video> videoList;  //creates an empty vector of Videos called videoList to store movie data from file
    
  if(!importMovieDataFromFile(videoList))  //read in data from CSV
    return 1;  //if the file can't be opened, immediately end the program;

  mainMenu(newCart, videoList);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8190
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2680
movq -0x68(%rbp), %rdi
callq 0x2a50
movb %al, -0x59(%rbp)
jmp 0x2603
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x263c
jmp 0x260c
movl $0x1, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x2659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x26a0
leaq -0x30(%rbp), %rdi
callq 0x2700
jmp 0x2674
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3640
jmp 0x264b
movl $0x0, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x26a0
leaq -0x30(%rbp), %rdi
callq 0x2700
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: systemPause()
void systemPause()
{
	cin.clear();
	std::cin.ignore(1024, '\n');	// Discart old input
	std::cout << "Press enter to continue...";
	std::cin.get();			// Proceed after new input from user
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa1d5(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0xa1cb(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2320
movq 0xa1b9(%rip), %rdi      # 0xcfe0
movl $0x400, %esi            # imm = 0x400
movl $0xa, %edx
callq 0x2160
movq 0xa193(%rip), %rdi      # 0xcfd0
leaq 0x6227(%rip), %rsi      # 0x906b
callq 0x21f0
movq 0xa190(%rip), %rdi      # 0xcfe0
callq 0x2270
popq %rbp
retq
nopw (%rax,%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: mainMenu(Cart&, std::vector<Video, std::allocator<Video>>&)
void mainMenu(Cart& newCart, vector<Video> &videoList)
{
	int choiceMain;						//Variable to hold user's menu choice
	do //If choiceMain == 0, the program terminates
	{
		displayMainMenu();  //Display main menu
   		cin >> choiceMain;  //Get user's choice
    		validateMainMenuChoice(choiceMain); //Make sure user enter valid choice
    		mainMenuSwitch(choiceMain, newCart, videoList); //Conduct menu navigation
	}
  	while (choiceMain != 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3690
movq 0x9984(%rip), %rdi      # 0xcfe0
leaq -0x14(%rbp), %rsi
callq 0x2140
leaq -0x14(%rbp), %rdi
callq 0x3810
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rdi
callq 0x38e0
cmpl $0x0, -0x14(%rbp)
jne 0x3650
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: displayMainMenu()
void displayMainMenu()
{
	clearScreen();	//Clear screen before displaying menu
	cout << ":::::::::::::::::::\n";
	cout << "::..Welcome to...::\n";
	cout << "::..BawkBuster!..::\n";
	cout << ":::::::::::::::::::\n" << endl;
	cout << "Select One of the Following Options:\n" << endl;
	cout << "	1: Search Movies by Title" << endl;
	cout << "	2: Search Movies by Genre" << endl;
	cout << "	3: Search Movies by Director" << endl;
	cout << "	4: Review Movies in Your Cart" << endl;
	cout << "	5: Check the Rental Price of the Movies in Your Cart" << endl;
	cout << "	6: Checkout\n" << endl;
	cout << "Please Enter a Number between 1 and 6" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2de0
movq 0x9930(%rip), %rdi      # 0xcfd0
leaq 0x5b98(%rip), %rsi      # 0x923f
callq 0x21f0
movq 0x991d(%rip), %rdi      # 0xcfd0
leaq 0x5b9a(%rip), %rsi      # 0x9254
callq 0x21f0
movq 0x990a(%rip), %rdi      # 0xcfd0
leaq 0x5b9c(%rip), %rsi      # 0x9269
callq 0x21f0
movq 0x98f7(%rip), %rdi      # 0xcfd0
leaq 0x5b5f(%rip), %rsi      # 0x923f
callq 0x21f0
movq %rax, %rdi
movq 0x98d1(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x98d5(%rip), %rdi      # 0xcfd0
leaq 0x5b7c(%rip), %rsi      # 0x927e
callq 0x21f0
movq %rax, %rdi
movq 0x98af(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x98b3(%rip), %rdi      # 0xcfd0
leaq 0x5b80(%rip), %rsi      # 0x92a4
callq 0x21f0
movq %rax, %rdi
movq 0x988d(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x9891(%rip), %rdi      # 0xcfd0
leaq 0x5b79(%rip), %rsi      # 0x92bf
callq 0x21f0
movq %rax, %rdi
movq 0x986b(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x986f(%rip), %rdi      # 0xcfd0
leaq 0x5b72(%rip), %rsi      # 0x92da
callq 0x21f0
movq %rax, %rdi
movq 0x9849(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x984d(%rip), %rdi      # 0xcfd0
leaq 0x5b6e(%rip), %rsi      # 0x92f8
callq 0x21f0
movq %rax, %rdi
movq 0x9827(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x982b(%rip), %rdi      # 0xcfd0
leaq 0x5b6b(%rip), %rsi      # 0x9317
callq 0x21f0
movq %rax, %rdi
movq 0x9805(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x9809(%rip), %rdi      # 0xcfd0
leaq 0x5b7f(%rip), %rsi      # 0x934d
callq 0x21f0
movq %rax, %rdi
movq 0x97e3(%rip), %rsi      # 0xcfc0
callq 0x2220
movq 0x97e7(%rip), %rdi      # 0xcfd0
leaq 0x5b6b(%rip), %rsi      # 0x935b
callq 0x21f0
movq %rax, %rdi
movq 0x97c1(%rip), %rsi      # 0xcfc0
callq 0x2220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KitchMKelly[P]Team-9-OSU-Hackathon-Winter-2018/BawkBusterFunctions.cpp
// Function: validateMainMenuChoice(int&)
void validateMainMenuChoice(int &choiceMain)
{
	//While the user input is not of the "int" datatype,
	//or the user input is larger than 6 or smaller than 1
	while (!cin || choiceMain > 6 || choiceMain < 1)
	{
		cin.clear();	//Clear bad input flag
		cin.ignore(10000, '\n');	//Discard input
		cout << "Please enter a number between 1 and 6" << endl;
		cin >> choiceMain;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x97bd(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x97b3(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
callq 0x2110
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x385d
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x6, (%rcx)
movb %al, -0x9(%rbp)
jg 0x385d
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
setl %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x3866
jmp 0x38cf
movq 0x9773(%rip), %rax      # 0xcfe0
movq (%rax), %rax
movq 0x9769(%rip), %rdi      # 0xcfe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2320
movq 0x9757(%rip), %rdi      # 0xcfe0
movl $0x2710, %esi           # imm = 0x2710
movl $0xa, %edx
callq 0x2160
movq 0x9731(%rip), %rdi      # 0xcfd0
leaq 0x5adb(%rip), %rsi      # 0x9381
callq 0x21f0
movq %rax, %rdi
movq 0x970b(%rip), %rsi      # 0xcfc0
callq 0x2220
movq -0x8(%rbp), %rsi
movq 0x971b(%rip), %rdi      # 0xcfe0
callq 0x2140
jmp 0x381c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)