LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::splitIntoBytes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::vector<std::byte> Coder::splitIntoBytes(std::string & string)
{
    std::vector<std::byte> vectorOfBytes;
    for(std::string::size_type i = 0; i < string.size(); i++)
    {
        vectorOfBytes.push_back(static_cast<std::byte>(string[i]));
    }
    
    return vectorOfBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8110
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6350
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x1079f
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6830
movq %rax, -0x60(%rbp)
jmp 0x10760
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rax
movb (%rax), %al
movb %al, -0x29(%rbp)
leaq -0x29(%rbp), %rsi
callq 0x11910
jmp 0x10778
jmp 0x1077a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x10730
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x8320
jmp 0x107bc
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x107b2
movq -0x50(%rbp), %rdi
callq 0x8320
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeBoolean(DataType&, bool&)
std::vector<std::byte> Coder::encodeBoolean(DataType & dataType, bool & data)
{
    std::vector<std::byte> dataVector;
    dataVector.push_back(encodeID(dataType));
    dataVector.push_back(static_cast<std::byte>(1));
    if (data)
    {
        dataVector.push_back(static_cast<std::byte>(0xFF)); 
    }
    else
    {
        dataVector.push_back(static_cast<std::byte>(0x00)); 
    }
    return dataVector;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x8110
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff20
movb %al, -0x38(%rbp)
jmp 0x10bb6
movq -0x50(%rbp), %rdi
movb -0x38(%rbp), %al
movb %al, -0x22(%rbp)
leaq -0x22(%rbp), %rsi
callq 0x11910
jmp 0x10bcb
movq -0x50(%rbp), %rdi
movb $0x1, -0x35(%rbp)
leaq -0x35(%rbp), %rsi
callq 0x11910
jmp 0x10bde
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0x10c13
movq -0x50(%rbp), %rdi
movb $-0x1, -0x36(%rbp)
leaq -0x36(%rbp), %rsi
callq 0x11910
jmp 0x10bfa
jmp 0x10c28
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8320
jmp 0x10c45
movq -0x50(%rbp), %rdi
movb $0x0, -0x37(%rbp)
leaq -0x37(%rbp), %rsi
callq 0x11910
jmp 0x10c26
jmp 0x10c28
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x10c3b
movq -0x50(%rbp), %rdi
callq 0x8320
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6790
nop
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeNULL(DataType&)
std::vector<std::byte> Coder::encodeNULL(DataType & dataType)
{
    std::vector<std::byte> dataVector;
    dataVector.push_back(encodeID(dataType));
    dataVector.push_back(static_cast<std::byte>(0));
    return dataVector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8110
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff20
movb %al, -0x2e(%rbp)
jmp 0x10c92
movq -0x48(%rbp), %rdi
movb -0x2e(%rbp), %al
movb %al, -0x1a(%rbp)
leaq -0x1a(%rbp), %rsi
callq 0x11910
jmp 0x10ca7
movq -0x48(%rbp), %rdi
movb $0x0, -0x2d(%rbp)
leaq -0x2d(%rbp), %rsi
callq 0x11910
jmp 0x10cba
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x10ce6
jmp 0x10cdd
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8320
jmp 0x10cf0
movq -0x48(%rbp), %rdi
callq 0x8320
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6790
nopl (%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::addInteger(DataType&, int&, int&, std::vector<std::byte, std::allocator<std::byte>>&)
void Coder::addInteger(DataType & dataType, int & data, int & lengthInBytes, std::vector<std::byte> & dataVector)
{
    std::vector<std::byte> vector;
    lengthInBytes += getNumberOfBytes(data) + 2;
    vector = encodeInteger(dataType, data);
    dataVector.insert(dataVector.end(), vector.begin(), vector.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8110
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x10ea0
movl %eax, -0x94(%rbp)
jmp 0x10d9d
movq -0xa0(%rbp), %rsi
movl -0x94(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl %edx, %ecx
movl %edi, %edx
leal 0x2(%rcx,%rdx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0xfce0
jmp 0x10dcd
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x68(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x11a90
movq -0xc0(%rbp), %rdi
callq 0x8320
movq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x119f0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x11a20
movq -0xb8(%rbp), %rdi
callq 0x11a60
movq -0xb8(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x119f0
movq -0xb0(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0x11940
movq %rax, -0xa8(%rbp)
jmp 0x10e5c
movq -0xa8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8320
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8320
movq -0x48(%rbp), %rdi
callq 0x6790
nopw (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::addOctetString(DataType&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&, std::vector<std::byte, std::allocator<std::byte>>&)
void Coder::addOctetString(DataType & dataType, std::string & data, int & lengthInBytes, std::vector<std::byte> & dataVector)
{
    std::vector<std::byte> vector;
    lengthInBytes += getNumberOfBytes(data) + 2;
    vector = encodeOctetString(dataType, data);
    dataVector.insert(dataVector.end(), vector.begin(), vector.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8110
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x61d0
jmp 0x10f02
movq -0xb8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x11050
movl %eax, -0xbc(%rbp)
jmp 0x10f1a
movl -0xbc(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %esi
movl %edx, %ecx
movl %esi, %edx
leal 0x2(%rcx,%rdx), %ecx
movl %ecx, (%rax)
leaq -0x60(%rbp), %rdi
callq 0x62e0
movq -0xb8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x88(%rbp), %rdi
callq 0x104c0
jmp 0x10f56
leaq -0x40(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x88(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
callq 0x11a90
movq -0xe0(%rbp), %rdi
callq 0x8320
movq -0x28(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x119f0
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x11a20
movq -0xd8(%rbp), %rdi
callq 0x11a60
movq -0xd8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x119f0
movq -0xd0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
callq 0x11940
movq %rax, -0xc8(%rbp)
jmp 0x10ffa
movq -0xc8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8320
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1103d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x62e0
leaq -0x40(%rbp), %rdi
callq 0x8320
movq -0x68(%rbp), %rdi
callq 0x6790
nop
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::addObjectIdentifier(DataType&, std::vector<unsigned int, std::allocator<unsigned int>>&, int&, std::vector<std::byte, std::allocator<std::byte>>&)
void Coder::addObjectIdentifier(DataType & dataType, std::vector<unsigned int> & data, int & lengthInBytes, std::vector<std::byte> & dataVector)
{
    std::vector<std::byte> vector;
    lengthInBytes += getNumberOfBytes(data) + 2;
    vector = encodeObjectIdentifier(dataType, data);
    dataVector.insert(dataVector.end(), vector.begin(), vector.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8110
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xba40
jmp 0x110c2
movq -0xb0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x11210
movl %eax, -0xb4(%rbp)
jmp 0x110da
movl -0xb4(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %esi
movl %edx, %ecx
movl %esi, %edx
leal 0x2(%rcx,%rdx), %ecx
movl %ecx, (%rax)
leaq -0x58(%rbp), %rdi
callq 0x8510
movq -0xb0(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x107d0
jmp 0x11113
leaq -0x40(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x80(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
callq 0x11a90
movq -0xd8(%rbp), %rdi
callq 0x8320
movq -0x28(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x119f0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x11a20
movq -0xd0(%rbp), %rdi
callq 0x11a60
movq -0xd0(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x119f0
movq -0xc8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq -0xa0(%rbp), %rcx
callq 0x11940
movq %rax, -0xc0(%rbp)
jmp 0x111b4
movq -0xc0(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8320
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x111f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8510
leaq -0x40(%rbp), %rdi
callq 0x8320
movq -0x60(%rbp), %rdi
callq 0x6790
nopl (%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::addBoolean(DataType&, bool&, int&, std::vector<std::byte, std::allocator<std::byte>>&)
void Coder::addBoolean(DataType & dataType, bool & data, int & lengthInBytes, std::vector<std::byte> & dataVector)
{
    std::vector<std::byte> vector;
    lengthInBytes += 3;
    vector = encodeBoolean(dataType, data);
    dataVector.insert(dataVector.end(), vector.begin(), vector.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8110
movq -0x98(%rbp), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x3, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x10b70
jmp 0x11298
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x58(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x11a90
movq -0xb8(%rbp), %rdi
callq 0x8320
movq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x119f0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x11a20
movq -0xb0(%rbp), %rdi
callq 0x11a60
movq -0xb0(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x119f0
movq -0xa8(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0x11940
movq %rax, -0xa0(%rbp)
jmp 0x11327
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8320
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8320
movq -0x60(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::addNULL(DataType&, int&, std::vector<std::byte, std::allocator<std::byte>>&)
void Coder::addNULL(DataType & dataType, int & lengthInBytes, std::vector<std::byte> & dataVector)
{
    std::vector<std::byte> vector;
    lengthInBytes += 2;
    vector = encodeNULL(dataType);
    dataVector.insert(dataVector.end(), vector.begin(), vector.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8110
movq -0x90(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x10c50
jmp 0x113c0
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x50(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x11a90
movq -0xb0(%rbp), %rdi
callq 0x8320
movq -0x20(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x119f0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x11a20
movq -0xa8(%rbp), %rdi
callq 0x11a60
movq -0xa8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x119f0
movq -0xa0(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x11940
movq %rax, -0x98(%rbp)
jmp 0x11449
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8320
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8320
movq -0x58(%rbp), %rdi
callq 0x6790
nopw (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::endSubSequence(int&, int&, std::vector<std::byte, std::allocator<std::byte>>&)
void Coder::endSubSequence(int & lengthInBytesUpper, int & lengthInBytesLower, std::vector<std::byte> & beginVector)
{
    lengthInBytesUpper += lengthInBytesLower + 2;
    std::vector<std::byte> lengthInBytesVector = encodeLength(lengthInBytesLower);
    beginVector.insert(beginVector.end(), lengthInBytesVector.begin(), lengthInBytesVector.end());
    m_endSequenceCount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x90(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl %ecx, %edx
movl %edi, %ecx
leal 0x2(%rcx,%rdx), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x10370
movq -0x20(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x119f0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x11a20
movq -0x88(%rbp), %rdi
callq 0x11a60
movq -0x88(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x119f0
movq -0x80(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x11940
movq %rax, -0x78(%rbp)
jmp 0x11609
movq -0x90(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
leaq -0x38(%rbp), %rdi
callq 0x8320
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8320
movq -0x60(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeSequence(std::vector<std::byte, std::allocator<std::byte>>&, std::vector<std::byte, std::allocator<std::byte>>&)
std::vector<std::byte> Coder::encodeSequence(std::vector<std::byte> & beginVector, std::vector<std::byte> & endVector)
{
    if (m_startSequenceCount == m_endSequenceCount)
    {
        beginVector.insert(beginVector.end(), endVector.begin(), endVector.end());
        return beginVector;
    }
    else
    {
        beginVector.clear();
        return beginVector;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jne 0x116f2
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x119f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11a20
movq -0x20(%rbp), %rdi
callq 0x11a60
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x119f0
movq -0x60(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x11940
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0xbb50
jmp 0x11708
movq -0x18(%rbp), %rdi
callq 0x11ac0
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbb50
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::splitIntoBytes(int&)
std::vector<std::byte> Coder::splitIntoBytes(int & number)
{
    std::vector<std::byte> vectorOfBytes;
    if (number != 0)
    {
        int numberOfBytes = getNumberOfBytes(number);
        for (int i = numberOfBytes - 1; i >= 0; i--)
        {
           vectorOfBytes.push_back(static_cast<std::byte>(((number >> i * 8) & 0xFF))); 
        }
    }
    else
    {
        vectorOfBytes.push_back(static_cast<std::byte>(0));
    }
    
    return vectorOfBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8110
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x118c8
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x10ea0
movl %eax, -0x54(%rbp)
jmp 0x1186d
movl -0x54(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0x118c6
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movb -0x30(%rbp), %cl
shlb $0x3, %cl
sarl %cl, %eax
movb %al, -0x31(%rbp)
leaq -0x31(%rbp), %rsi
callq 0x11910
jmp 0x118a2
jmp 0x118a4
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1187c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8320
jmp 0x118fa
jmp 0x118dd
movq -0x50(%rbp), %rdi
movb $0x0, -0x32(%rbp)
leaq -0x32(%rbp), %rsi
callq 0x11910
jmp 0x118db
jmp 0x118dd
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x118f0
movq -0x50(%rbp), %rdi
callq 0x8320
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/parser.cpp
// Function: Parser::parseLineForOIDDiminished(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
unsigned int Parser::parseLineForOIDDiminished(std::string & nodeLine, unsigned int & OID)
{
    std::regex patternOID("(\\d+)\\s\\}");
    std::smatch match;
    if (std::regex_search(nodeLine, match, patternOID))
    {
        OID = std::stoi(match.str(1));
        return OID;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x33a7a(%rip), %rsi     # 0x485a8
leaq -0x40(%rbp), %rdi
movl $0x10, %edx
callq 0x18ef0
leaq -0x60(%rbp), %rdi
callq 0x18eb0
jmp 0x14b47
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
xorl %ecx, %ecx
callq 0x18f90
movb %al, -0x95(%rbp)
jmp 0x14b62
movb -0x95(%rbp), %al
testb $0x1, %al
jne 0x14b71
jmp 0x14c08
leaq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x1, %edx
callq 0x18ff0
jmp 0x14b88
xorl %eax, %eax
movl %eax, %esi
leaq -0x90(%rbp), %rdi
movl $0xa, %edx
callq 0x19840
movl %eax, -0x9c(%rbp)
jmp 0x14ba5
movl -0x9c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
leaq -0x90(%rbp), %rdi
callq 0x62e0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x94(%rbp)
jmp 0x14c19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x14c40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x14c37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x62e0
jmp 0x14c37
movl $0x0, -0x4(%rbp)
movl $0x1, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x195a0
leaq -0x40(%rbp), %rdi
callq 0x19570
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x195a0
leaq -0x40(%rbp), %rdi
callq 0x19570
movq -0x68(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/parser.cpp
// Function: Parser::parseMIBFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Parser::parseMIBFile(std::string fileContent)
{
    parseCustomDataTypesInMain(fileContent);
    parseCustomDataTypeInformation();
    parseDiminishedNodes(fileContent);
    parseNodes(fileContent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x61d0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x171a0
jmp 0x18d3a
leaq -0x30(%rbp), %rdi
callq 0x62e0
movq -0x90(%rbp), %rdi
callq 0x178b0
movq -0x98(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x61d0
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x144b0
jmp 0x18d7b
leaq -0x60(%rbp), %rdi
callq 0x62e0
movq -0x98(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x61d0
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x156a0
jmp 0x18db0
leaq -0x80(%rbp), %rdi
callq 0x62e0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x62e0
jmp 0x18e05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x62e0
jmp 0x18e05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x62e0
movq -0x38(%rbp), %rdi
callq 0x6790
nop
// File: EmbeddedPaul166[P]SNMP-Agent/src/datatype.cpp
// Function: DataType::DataType(BaseDataType, EncodingComplexity, EncodingType, DataVisibility, unsigned int, unsigned int, unsigned int)
DataType::DataType(BaseDataType baseType, EncodingComplexity complexity, EncodingType encodingType, DataVisibility visibility, unsigned int lengthLimit, unsigned int rangeLimitLower, unsigned int rangeLimitUpper)
{
    m_baseType = baseType;
    m_complexity = complexity;
    m_encodingType = encodingType;
    m_visibility = visibility;
    m_lengthLimit = lengthLimit;
    m_rangeLimitLower = rangeLimitLower;
    m_rangeLimitUpper = rangeLimitUpper;
    m_tag = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x20, %rdi
callq 0x81e0
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x18e10
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl $0x0, 0x1c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/datatype.cpp
// Function: DataType::DataType()
DataType::DataType()
{
    m_baseType = BaseDataType::NULL_D;
    m_complexity = EncodingComplexity::PRIMITIVE;
    m_encodingType = EncodingType::UNIVERSAL;
    m_visibility = DataVisibility::UNIVERSAL;
    m_lengthLimit = 0;     
    m_rangeLimitLower = 0;
    m_rangeLimitUpper = 0;
    m_tag = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x20, %rdi
callq 0x81e0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x18e10
movq -0x10(%rbp), %rax
movl $0x4, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/tree.cpp
// Function: Tree::initializeRootOfTheTree()
void Tree::initializeRootOfTheTree()
{
    DataType rootType;
    std::list <Node *> emptyChildList;
    Node newNode(1, "iso", rootType, "", AccessType::NOT_ACCESSIBLE, StatusType::MANDATORY, nullptr, emptyChildList);
    m_nodeList.push_back(newNode);
    m_rootOfTheTree = &m_nodeList.back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x44a20
leaq -0x70(%rbp), %rdi
callq 0x455f0
leaq -0x151(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x67a0
movq -0x200(%rbp), %rdx
leaq 0x3a61(%rip), %rsi      # 0x485de
leaq -0x150(%rbp), %rdi
callq 0x8130
jmp 0x44b8b
leaq -0x1b8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb850
jmp 0x44b9d
leaq -0x1d9(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x67a0
movq -0x210(%rbp), %rdx
leaq 0x3c86(%rip), %rsi      # 0x48844
leaq -0x1d8(%rbp), %rdi
callq 0x8130
jmp 0x44bcc
leaq -0x1f8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x45640
jmp 0x44bde
movq %rsp, %rax
leaq -0x1f8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x8(%rax)
movl $0x0, (%rax)
leaq -0x130(%rbp), %rdi
movl $0x1, %esi
leaq -0x150(%rbp), %rdx
leaq -0x1b8(%rbp), %rcx
leaq -0x1d8(%rbp), %r8
movl $0x3, %r9d
callq 0x46bf0
jmp 0x44c28
leaq -0x1f8(%rbp), %rdi
callq 0x45700
leaq -0x1d8(%rbp), %rdi
callq 0x62e0
leaq -0x1d9(%rbp), %rdi
callq 0x64d0
leaq -0x1b8(%rbp), %rdi
callq 0x44a90
leaq -0x150(%rbp), %rdi
callq 0x62e0
leaq -0x151(%rbp), %rdi
callq 0x64d0
movq -0x208(%rbp), %rdi
addq $0x8, %rdi
leaq -0x130(%rbp), %rsi
callq 0x45720
jmp 0x44c89
movq -0x208(%rbp), %rdi
addq $0x8, %rdi
callq 0x457c0
movq %rax, %rcx
movq -0x208(%rbp), %rax
movq %rcx, (%rax)
leaq -0x130(%rbp), %rdi
callq 0x46dd0
leaq -0x70(%rbp), %rdi
callq 0x45700
leaq -0x58(%rbp), %rdi
callq 0x44a90
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
jmp 0x44d6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
jmp 0x44d62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
jmp 0x44d4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
jmp 0x44d3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x45700
leaq -0x1d8(%rbp), %rdi
callq 0x62e0
leaq -0x1d9(%rbp), %rdi
callq 0x64d0
leaq -0x1b8(%rbp), %rdi
callq 0x44a90
leaq -0x150(%rbp), %rdi
callq 0x62e0
leaq -0x151(%rbp), %rdi
callq 0x64d0
jmp 0x44d9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x46dd0
leaq -0x70(%rbp), %rdi
callq 0x45700
leaq -0x58(%rbp), %rdi
callq 0x44a90
movq -0x160(%rbp), %rdi
callq 0x6790
nopl (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/tree.cpp
// Function: Tree::recursiveSearch(std::vector<unsigned int, std::allocator<unsigned int>>, unsigned int, Node*)
Node * Tree::recursiveSearch(std::vector<unsigned int> vectorOfOID, unsigned int vectorPosition, Node * node)
{
    std::list<Node *> & childList = node -> m_childElementPointerList;
    for (std::list<Node *>::iterator it = childList.begin(); it != childList.end(); it++)
    {   
        unsigned int currentOID = (*it) -> m_objectIdentifier;
        if (currentOID ==  vectorOfOID.at(vectorPosition) && vectorOfOID.size() - 1 == vectorPosition)
        {
            return (*it);        
        }
        else if ((*it) -> m_objectIdentifier ==  vectorOfOID.at(vectorPosition))
        {
            vectorPosition++;
            Node * pNode = recursiveSearch(vectorOfOID, vectorPosition, (*it));
            return pNode;
        }
    } 
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x45800
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x45860
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x45830
testb $0x1, %al
jne 0x452da
jmp 0x45418
leaq -0x38(%rbp), %rdi
callq 0x45890
movq -0x90(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x94(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x45980
movq %rax, %rcx
movl -0x94(%rbp), %eax
cmpl (%rcx), %eax
jne 0x4533f
movq -0x90(%rbp), %rdi
callq 0x9580
subq $0x1, %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jne 0x4533f
leaq -0x38(%rbp), %rdi
callq 0x45890
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x45420
leaq -0x38(%rbp), %rdi
callq 0x45890
movq -0x90(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x98(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x45980
movq %rax, %rcx
movl -0x98(%rbp), %eax
cmpl (%rcx), %eax
jne 0x45400
movq -0x90(%rbp), %rsi
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xba40
movl -0x1c(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x45890
movq -0x88(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movl -0xa4(%rbp), %edx
movq (%rax), %rcx
callq 0x45270
movq %rax, -0xa0(%rbp)
jmp 0x453cb
leaq -0x68(%rbp), %rdi
callq 0x8510
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x45420
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8510
jmp 0x4542d
jmp 0x45402
jmp 0x45404
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x45950
movq %rax, -0x80(%rbp)
jmp 0x452b7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/tree.cpp
// Function: Tree::findNodeByObjectIdentifier(std::vector<unsigned int, std::allocator<unsigned int>>)
Node * Tree::findNodeByObjectIdentifier(std::vector<unsigned int> vectorOfOID)
{
    if (vectorOfOID.front() != 1)
    {
        return nullptr;
    }
    else
    {
        if (vectorOfOID.size() == 1)
        {
            return m_rootOfTheTree;
        }
        Node * pNode = recursiveSearch(vectorOfOID, 1, m_rootOfTheTree); 
        return pNode;    
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x459c0
cmpl $0x1, (%rax)
je 0x4547b
movq $0x0, -0x8(%rbp)
jmp 0x454f5
movq -0x58(%rbp), %rdi
callq 0x9580
cmpq $0x1, %rax
jne 0x45497
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x454f5
movq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xba40
movq -0x50(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rdi), %rcx
movl $0x1, %edx
callq 0x45270
movq %rax, -0x68(%rbp)
jmp 0x454c3
leaq -0x38(%rbp), %rdi
callq 0x8510
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x454f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8510
jmp 0x454ff
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6790
nopl (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/tree.cpp
// Function: Tree::findNodeByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Node * Tree::findNodeByName(std::string name)
{
    for (std::list<Node>::iterator it = m_nodeList.begin(); it != m_nodeList.end(); it++)
    {
        if ((*it).m_name == name)
        {
            return &(*it);
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
callq 0x19880
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x198e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x198b0
testb $0x1, %al
jne 0x4555d
jmp 0x4559e
leaq -0x20(%rbp), %rdi
callq 0x19910
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x8220
testb $0x1, %al
jne 0x4557c
jmp 0x4558b
leaq -0x20(%rbp), %rdi
callq 0x19910
movq %rax, -0x8(%rbp)
jmp 0x455a6
jmp 0x4558d
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x19970
movq %rax, -0x30(%rbp)
jmp 0x45539
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: EmbeddedPaul166[P]SNMP-Agent/src/node.cpp
// Function: Node::Node(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, DataType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, AccessType, StatusType, Node*, std::__cxx11::list<Node*, std::allocator<Node*>>)
Node::Node(unsigned int objectIdentifier, std::string name, DataType dataType, std::string description, AccessType accessType, StatusType statusType, Node * pParentElement, std::list<Node *> childElementPointerList)
{
    m_objectIdentifier = objectIdentifier;
    m_name = name;
    m_dataType = dataType;
    m_description = description;
    m_accessType = accessType;
    m_statusType = statusType;
    m_pParentElement = pParentElement;
    m_childElementPointerList = childElementPointerList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %r8, -0x78(%rbp)
movq %rcx, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x6600
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x48(%rbp)
callq 0x44a20
jmp 0x46c55
movq -0x50(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x88(%rbp)
callq 0x6600
movq -0x50(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x455f0
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
callq 0x6070
jmp 0x46c95
movq -0x70(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
callq 0x199a0
jmp 0x46ca8
movq -0x78(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x78, %rdi
callq 0x6070
jmp 0x46cbb
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, 0x98(%rdi)
movl 0x10(%rbp), %eax
movl %eax, 0x9c(%rdi)
movq 0x18(%rbp), %rax
movq %rax, 0xa0(%rdi)
addq $0xa8, %rdi
callq 0x46e20
jmp 0x46cee
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46d2f
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x45700
movq -0x88(%rbp), %rdi
callq 0x62e0
movq -0x48(%rbp), %rdi
callq 0x44a90
movq -0x58(%rbp), %rdi
callq 0x62e0
movq -0x38(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: shengzh-oOoO[P]CodeSim/src/assembly_moss.cpp
// Function: CodeFile::CreateHashList()
void CreateHashList(){
        FILE *fid = fopen(filename,"r");
        if(fid == NULL){
            printf("打开%s失败\n",filename);
            assert(false);
        }
        char ch = 0;
        char prev_ch = 0;
        int linecnt = 0;
        while(EOF!=(ch= fgetc(fid))){
            if (ch=='\t'){
                ch = ' ';
            }
            if(prev_ch == ' '&& ch ==' '){
                continue;
            }
            if(prev_ch == '\n'&& ch =='\n'){
                continue;
            }
            hashwindow.push_back(ch);
            prev_ch = ch;
            if (ch == '\n'){
                hashlist.push_back(RSHash());
                hashwindow.clear();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x38b4(%rip), %rsi      # 0x507f
callq 0x10f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x180c
movq -0x28(%rbp), %rsi
leaq 0x389b(%rip), %rdi      # 0x5081
movb $0x0, %al
callq 0x1030
leaq 0x3844(%rip), %rdi      # 0x5038
leaq 0x3843(%rip), %rsi      # 0x503e
movl $0x27, %edx
leaq 0x388a(%rip), %rcx      # 0x5091
callq 0x1090
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1120
movb %al, -0x11(%rbp)
movsbl %al, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x18c5
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
jne 0x1844
movb $0x20, -0x11(%rbp)
movsbl -0x12(%rbp), %eax
cmpl $0x20, %eax
jne 0x1858
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jne 0x1858
jmp 0x181b
movsbl -0x12(%rbp), %eax
cmpl $0xa, %eax
jne 0x186c
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x186c
jmp 0x181b
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
leaq -0x11(%rbp), %rsi
callq 0x1d90
movb -0x11(%rbp), %al
movb %al, -0x12(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x18c0
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, -0x30(%rbp)
callq 0x1e00
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x1dd0
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0x1ed0
jmp 0x181b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: shengzh-oOoO[P]CodeSim/src/assembly_moss.cpp
// Function: CodeFile::RSHash()
long RSHash(){
        long b = 378551;
        long a = 63689;
        long hash = 0;
        list<char>::iterator i;
        for (i = hashwindow.begin(); i != hashwindow.end(); i++){
            hash = hash * a + (long) (*i);
            a = a * b;
        }
        return hash;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x5c6b7, -0x10(%rbp)   # imm = 0x5C6B7
movq $0xf8c9, -0x18(%rbp)    # imm = 0xF8C9
movq $0x0, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2b90
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x2bb0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x1f50
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2be0
testb $0x1, %al
jne 0x1e72
jmp 0x1eb8
movq -0x20(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2c10
movq %rax, %rcx
movq -0x50(%rbp), %rax
movsbq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x2c30
movq %rax, -0x40(%rbp)
jmp 0x1e4e
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Mariotti94[P]BigFloat/Factorial.cpp
// Function: factorial(BigFloat const&)
BigFloat factorial(const BigFloat& n)
{
    if(n > 1)
        return n * factorial(n - 1);
    else if(n == 0)
        return 1;
    else
        return n;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq 0x148(%rsp), %rdi
movl $0x1, 0x144(%rsp)
leaq 0x144(%rsp), %rsi
callq 0x9f30
testb $0x1, %al
jne 0x251d
jmp 0x25c3
movq 0x148(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x3c(%rsp), %rdx
callq 0x6e10
movq 0x10(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x24d0
jmp 0x255a
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x58e0
jmp 0x2573
leaq 0xc0(%rsp), %rdi
callq 0x2780
leaq 0x40(%rsp), %rdi
callq 0x2780
jmp 0x2606
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x25b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x2780
leaq 0x40(%rsp), %rdi
callq 0x2780
jmp 0x2613
movq 0x148(%rsp), %rdi
movl $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x57a0
testb $0x1, %al
jne 0x25e3
jmp 0x25f4
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x27b0
jmp 0x2606
movq 0x18(%rsp), %rdi
movq 0x148(%rsp), %rsi
callq 0x2830
movq 0x20(%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
retq
movq 0x30(%rsp), %rdi
callq 0x2300
nopl (%rax)
// File: Mariotti94[P]BigFloat/Factorial.cpp
// Function: main
int main()
{
    //For reference, execution times on an old Core 2 Duo
    //200!  --> 375 digits  - no optimization: 5 seconds
    //300!  --> 615 digits  - no optimization: 20 seconds,   compiled with -O3: 1 seconds
    //500!  --> 1135 digits - no optimization: 115 seconds,  compiled with -O3: 4 seconds
    //1000! --> 2568 digits - no optimization: 1200 seconds, compiled with -O3: 47 seconds
    BigFloat fact, num(1000);
    fact = factorial(num);
    std::cout << fact << std::endl;
    std::cout << fact.Ints() << std::endl;
    return 0;
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movl $0x0, 0x1c4(%rsp)
leaq 0x140(%rsp), %rdi
callq 0x28c0
leaq 0xc0(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x27b0
jmp 0x2653
leaq 0x30(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x24d0
jmp 0x2667
leaq 0x140(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x30(%rsp), %rsi
movq %rsi, 0x18(%rsp)
callq 0x2950
movq 0x18(%rsp), %rdi
callq 0x2780
movq 0x20(%rsp), %rsi
movq 0x1293f(%rip), %rdi     # 0x14fd8
callq 0xa520
movq %rax, 0x28(%rsp)
jmp 0x26a5
movq 0x28(%rsp), %rdi
movq 0x1290f(%rip), %rsi     # 0x14fc0
callq 0x21f0
jmp 0x26b8
leaq 0x140(%rsp), %rdi
callq 0x29c0
movl %eax, 0x14(%rsp)
jmp 0x26cb
movl 0x14(%rsp), %esi
movq 0x12902(%rip), %rdi     # 0x14fd8
callq 0x22f0
movq %rax, 0x8(%rsp)
jmp 0x26e2
movq 0x8(%rsp), %rdi
movq 0x128d2(%rip), %rsi     # 0x14fc0
callq 0x21f0
jmp 0x26f5
movl $0x0, 0x1c4(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x2780
leaq 0x140(%rsp), %rdi
callq 0x2780
movl 0x1c4(%rsp), %eax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x2760
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x2780
leaq 0x140(%rsp), %rdi
callq 0x2780
movq 0xb8(%rsp), %rdi
callq 0x2300
nopw (%rax,%rax)
// File: Mariotti94[P]BigFloat/./BigFloat.h
// Function: BigFloat::BigFloat()
BigFloat()
    {
        sign = '\0';
        decimals = 0;
        error = 1;
        error_code = "Unset";
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x2e70
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
movq %rdi, 0x18(%rsp)
callq 0x2280
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movb $0x0, (%rax)
movl $0x0, 0x58(%rax)
movb $0x1, 0x5c(%rax)
leaq 0xd6f1(%rip), %rsi      # 0x10004
callq 0x2270
jmp 0x291a
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x20f0
movq 0x8(%rsp), %rdi
callq 0x29f0
movq 0x28(%rsp), %rdi
callq 0x2300
nopl (%rax,%rax)
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: BigFloat::Subtract(BigFloat const&, BigFloat const&)
BigFloat BigFloat::Subtract(const BigFloat& left, const BigFloat& right)
{
    BigFloat tmp;
    int carry = 0;
    int aus;

    for(size_t i = 0; i < left.number.size(); ++i) {
        int val1, val2;
        val1 = CharToInt(left.number[i]);
        val2 = (i > right.number.size() - 1) ? 0 : CharToInt(right.number[i]);

        val1 -= carry;

        if(val1 < val2) {
            aus = 10 + val1 - val2;
            carry = 1;
        }
        else {
            aus = val1 - val2;
            carry = 0;
        }

        tmp.number.push_back(IntToChar(aus));
    }

    return tmp;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movb $0x0, 0x6f(%rsp)
callq 0x28c0
movl $0x0, 0x68(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0x35c0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x4f83
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
movq 0x58(%rsp), %rsi
callq 0xb510
movq %rax, %rdi
callq 0xb570
movl %eax, 0x24(%rsp)
jmp 0x4e6b
movl 0x24(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x35c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x4ea4
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ecf
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
movq 0x58(%rsp), %rsi
callq 0xb510
movq %rax, %rdi
callq 0xb570
movl %eax, 0x10(%rsp)
jmp 0x4ec5
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x4ecf
movl 0x14(%rsp), %eax
movl %eax, 0x50(%rsp)
movl 0x68(%rsp), %ecx
movl 0x54(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0x4f25
movl 0x54(%rsp), %eax
addl $0xa, %eax
subl 0x50(%rsp), %eax
movl %eax, 0x64(%rsp)
movl $0x1, 0x68(%rsp)
jmp 0x4f39
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x2780
jmp 0x4fa6
movl 0x54(%rsp), %eax
subl 0x50(%rsp), %eax
movl %eax, 0x64(%rsp)
movl $0x0, 0x68(%rsp)
movq 0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
leaq 0x64(%rsp), %rdi
callq 0xb5c0
movb %al, 0xf(%rsp)
jmp 0x4f56
movq (%rsp), %rdi
movb 0xf(%rsp), %al
movb %al, 0x43(%rsp)
leaq 0x43(%rsp), %rsi
callq 0xb590
jmp 0x4f6e
jmp 0x4f70
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x4e21
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0x4f99
movq 0x30(%rsp), %rdi
callq 0x2780
movq 0x38(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x2300
// File: Mariotti94[P]BigFloat/BigFloat.cc
// Function: operator*(BigFloat const&, BigFloat const&)
BigFloat operator*(const BigFloat& left, const BigFloat& right)
{
    BigFloat tmp;
    if((left.error) || (right.error)) {
        return tmp;
    }

    tmp = BigFloat::Multiply(left, right);
    if(((left.sign == '-') && (right.sign == '-')) || ((left.sign == '+') && (right.sign == '+')))
        tmp.sign = '+';
    else
        tmp.sign = '-';

    tmp.decimals = left.decimals + right.decimals;
    tmp.error = 0;
    tmp.LeadTrim();

    return tmp;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movb $0x0, 0xaf(%rsp)
callq 0x28c0
movq 0xb8(%rsp), %rax
testb $0x1, 0x5c(%rax)
jne 0x5935
movq 0xb0(%rsp), %rax
testb $0x1, 0x5c(%rax)
je 0x594d
movb $0x1, 0xaf(%rsp)
movl $0x1, 0xa8(%rsp)
jmp 0x5a2c
movq 0xb8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x4fb0
jmp 0x5969
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2950
leaq 0x28(%rsp), %rdi
callq 0x2780
movq 0xb8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x59a2
movq 0xb0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x59c2
movq 0xb8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x59e6
movq 0xb0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x59e6
movq 0x8(%rsp), %rax
movb $0x2b, (%rax)
jmp 0x59ee
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x2780
jmp 0x5a4d
movq 0x8(%rsp), %rax
movb $0x2d, (%rax)
movq 0x8(%rsp), %rdi
movq 0xb8(%rsp), %rax
movl 0x58(%rax), %eax
movq 0xb0(%rsp), %rcx
movl 0x58(%rcx), %ecx
addl %ecx, %eax
movl %eax, 0x58(%rdi)
movb $0x0, 0x5c(%rdi)
callq 0x5d20
jmp 0x5a19
movb $0x1, 0xaf(%rsp)
movl $0x1, 0xa8(%rsp)
testb $0x1, 0xaf(%rsp)
jne 0x5a40
movq 0x8(%rsp), %rdi
callq 0x2780
movq 0x10(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x2300
nopw (%rax,%rax)