LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/manager.cpp
// Function: Manager::getOIDVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::vector<unsigned int> Manager::getOIDVector(std::string & input)
{
    unsigned int n = 0;
    std::vector<unsigned int> numbersVector;
    std::vector<unsigned int> digitsVector;
    while(input.size() != n)
    {
        if (std::isdigit(input[n]))
        {
            digitsVector.push_back(input[n] - '0');
        }
        else if (input[n] == '.')
        {
            if (digitsVector.size() == 1)
            {
                numbersVector.push_back(digitsVector.back());
                digitsVector.clear();
            }
            else
            {
                unsigned int multiplier = static_cast<unsigned int>(std::pow(10, digitsVector.size() - 1));
                unsigned int number = 0;
                for (std::vector<std::string>::size_type i = 0; i != digitsVector.size(); i++)
                {
                    number += digitsVector[i]*multiplier;
                    multiplier /= 10;
                }
                numbersVector.push_back(number);
                digitsVector.clear(); 
            }
        }
        n++;
    }
    return numbersVector;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
movupd %xmm0, (%rdi)
movapd %xmm0, (%r15)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
pushq $0xa
popq %rbp
movl %r13d, %r13d
cmpq %r13, 0x8(%r14)
je 0x5d8b
movq (%r14), %rax
movsbl (%rax,%r13), %eax
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x5cce
movl %ecx, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5688
jmp 0x5d83
cmpb $0x2e, %al
jne 0x5d83
movq 0x18(%rsp), %rsi
movq %rsi, %rax
subq 0x10(%rsp), %rax
cmpq $0x4, %rax
jne 0x5cf7
addq $-0x4, %rsi
movq %rbx, %rdi
callq 0x6654
jmp 0x5d72
sarq $0x2, %rax
decq %rax
movq %rax, %xmm0
punpckldq 0x13485(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1348d(%rip), %xmm0    # 0x191a0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x13489(%rip), %xmm0    # 0x191b0
callq 0x4520
andl $0x0, 0xc(%rsp)
cvttsd2si %xmm0, %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x5d67
movl (%rcx,%r8,4), %edx
imull %eax, %edx
addl %edx, %edi
movl %edi, 0xc(%rsp)
xorl %edx, %edx
divl %ebp
incq %r8
jmp 0x5d4c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6654
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x5d83
movq %rax, 0x18(%rsp)
incl %r13d
jmp 0x5c9d
leaq 0x10(%rsp), %rdi
callq 0x5654
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5dab
jmp 0x5dab
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5654
movq %rbx, %rdi
callq 0x5654
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/filehandler.cpp
// Function: FileHandler::readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string FileHandler::readFile(std::string filePath)
{
    std::ifstream file(filePath);
    if (file.is_open())
    {
        auto ss = std::ostringstream{};
        ss << file.rdbuf();
        m_fileContent = ss.str();
        return m_fileContent; 
    }
    else
    {
        return "";
    } 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x3a0, %rsp            # imm = 0x3A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x198(%rsp), %rdi
pushq $0x8
popq %rax
movq %rdx, %rsi
movl %eax, %edx
callq 0x44b0
leaq 0x210(%rsp), %rdi
callq 0x40a0
testb %al, %al
je 0x6e7e
leaq 0x20(%rsp), %rdi
callq 0x4400
leaq 0x1a8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x4080
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x4480
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x43b0
movq %r15, %rdi
callq 0x4170
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4410
leaq 0x20(%rsp), %rdi
callq 0x40b0
jmp 0x6e92
leaq 0x1294f(%rip), %rsi     # 0x197d4
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x5398
leaq 0x198(%rsp), %rdi
callq 0x40c0
movq %rbx, %rax
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6eb8
jmp 0x6eb3
movq %rax, %rbx
jmp 0x6ec5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x40b0
leaq 0x198(%rsp), %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeInteger(DataType&, int&)
std::vector<std::byte> Coder::encodeInteger(DataType & dataType, int & data)
{
    std::vector<std::byte> dataVector;
    dataVector.push_back(encodeID(dataType));
    int length = 0;
    std::vector<std::byte> dataInBytes = splitIntoBytes(data, length);
    std::vector<std::byte> lengthInBytes = encodeLength(length);
    dataVector.insert(dataVector.end(), lengthInBytes.begin(), lengthInBytes.end());
    dataVector.insert(dataVector.end(), dataInBytes.begin(), dataInBytes.end());
    return dataVector;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rdx, %rsi
callq 0x6fb8
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x79ec
leaq 0x4(%rsp), %rcx
andl $0x0, (%rcx)
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x7002
leaq 0x20(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x708e
movq 0x8(%rbx), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x79cc
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x79cc
leaq 0x20(%rsp), %rdi
callq 0x54f0
leaq 0x8(%rsp), %rdi
callq 0x54f0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x6f84
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x54f0
jmp 0x6f96
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x54f0
jmp 0x6fa7
jmp 0x6fa4
movq %rax, %r14
movq %rbx, %rdi
callq 0x54f0
movq %r14, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::splitIntoBytes(int&, int&)
std::vector<std::byte> Coder::splitIntoBytes(int & number, int & numberOfBytes)
{
    std::vector<std::byte> vectorOfBytes;
    if (number != 0)
    {
       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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpl $0x0, (%rdx)
je 0x7059
movq %rdx, %r14
movl $0x4, (%rcx)
pushq $0x3
popq %r12
pushq $0x18
popq %rbp
leaq 0xe(%rsp), %r15
testl %r12d, %r12d
js 0x7069
movl (%r14), %eax
movl %ebp, %ecx
sarl %cl, %eax
movb %al, 0xe(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79ec
decl %r12d
addl $-0x8, %ebp
jmp 0x7036
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x79ec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x707b
movq %rax, %r14
movq %rbx, %rdi
callq 0x54f0
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeLength(int&)
std::vector<std::byte> Coder::encodeLength(int & lengthInBytes)
{
    std::vector<std::byte> vectorOfBytes;
    
    int numberOfSeptets = 0;
    if (lengthInBytes != 0)
    {
        int len = lengthInBytes;
        while (len != 0)
        {
            len >>= 7;
            numberOfSeptets++;
        }  
        
        for (int i = 0; i < numberOfSeptets; i++)
        {
            if (i == numberOfSeptets - 1)
            {
                int8_t num = lengthInBytes >> (i * 7);
                num &= ~(1 << 7);
                vectorOfBytes.push_back(static_cast<std::byte>(num));
                
            }
            else
            {
                int8_t num = lengthInBytes >> (i * 7);
                num |= (1 << 7);
                vectorOfBytes.push_back(static_cast<std::byte>(num));
            }
        }
    }
    else
    {
        vectorOfBytes.push_back(static_cast<std::byte>(0));
    }
    
    return vectorOfBytes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl (%rdx), %eax
testl %eax, %eax
je 0x710d
movq %rdx, %r14
xorl %r12d, %r12d
pushq $-0x7
popq %rbp
testl %eax, %eax
je 0x70c5
sarl $0x7, %eax
incl %r12d
addl $0x7, %ebp
jmp 0x70b6
xorl %r15d, %r15d
leaq 0x5(%rsp), %r13
subl $0x1, %r12d
jb 0x711d
movl (%r14), %eax
jne 0x70f1
movl %ebp, %ecx
sarl %cl, %eax
andb $0x7f, %al
movb %al, 0x6(%rsp)
movq %rbx, %rdi
leaq 0x6(%rsp), %rsi
callq 0x79ec
jmp 0x7107
movl %r15d, %ecx
sarl %cl, %eax
orb $-0x80, %al
movb %al, 0x5(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x79ec
addl $0x7, %r15d
jmp 0x70cd
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x79ec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7133
jmp 0x7133
movq %rax, %r14
movq %rbx, %rdi
callq 0x54f0
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeOctetString(DataType&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::vector<std::byte> Coder::encodeOctetString(DataType & dataType, std::string & data)
{
    std::vector<std::byte> dataVector;
    dataVector.push_back(encodeID(dataType));
    int length = data.size();
    std::vector<std::byte> lengthInBytes = encodeLength(length);
    std::vector<std::byte> dataInBytes = splitIntoBytes(data);
    dataVector.insert(dataVector.end(), lengthInBytes.begin(), lengthInBytes.end());
    dataVector.insert(dataVector.end(), dataInBytes.begin(), dataInBytes.end());
    return dataVector;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rdx, %rsi
callq 0x6fb8
movq %rsp, %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x79ec
movl 0x8(%r14), %eax
leaq 0x1c(%rsp), %rdx
movl %eax, (%rdx)
movq %rsp, %rdi
callq 0x708e
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x720e
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x79cc
movq 0x8(%rbx), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x79cc
leaq 0x20(%rsp), %rdi
callq 0x54f0
movq %rsp, %rdi
callq 0x54f0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x71dd
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x54f0
jmp 0x71ef
movq %rax, %r14
movq %rsp, %rdi
callq 0x54f0
jmp 0x71fe
jmp 0x71fb
movq %rax, %r14
movq %rbx, %rdi
callq 0x54f0
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r12d, %r12d
leaq 0x7(%rsp), %r15
cmpq 0x8(%r14), %r12
jae 0x7250
movq (%r14), %rax
movb (%rax,%r12), %al
movb %al, 0x7(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79ec
incq %r12
jmp 0x722f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x54f0
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rdx, %rsi
callq 0x6fb8
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x79ec
leaq 0x6(%rsp), %rsi
movb $0x1, (%rsi)
movq %rbx, %rdi
callq 0x79ec
cmpb $0x1, (%r14)
jne 0x741e
leaq 0x5(%rsp), %rsi
movb $-0x1, (%rsi)
movq %rbx, %rdi
callq 0x79ec
jmp 0x742e
leaq 0x4(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x79ec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x743f
jmp 0x743f
jmp 0x743f
movq %rax, %r14
movq %rbx, %rdi
callq 0x54f0
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rdx, %rsi
callq 0x6fb8
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x79ec
leaq 0x6(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x79ec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x7498
movq %rax, %r14
movq %rbx, %rdi
callq 0x54f0
movq %r14, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %r8, %rbx
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rsp)
movaps %xmm0, (%rsp)
addl $0x6, (%rcx)
leaq 0x18(%rsp), %rdi
movq %rax, %rcx
callq 0x6ee4
movq %rsp, %r14
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7caa
movq %r15, %rdi
callq 0x54f0
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %rdi
callq 0x79cc
movq %rsp, %rdi
callq 0x54f0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x754a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54f0
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdx, %rsi
callq 0x4410
leaq 0x30(%rsp), %rdi
movl 0x8(%rdi), %eax
movl (%r13), %ecx
addl %ecx, %eax
addl $0x2, %eax
movl %eax, (%r13)
callq 0x4170
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x7146
movq %rsp, %r14
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7caa
movq %r15, %rdi
callq 0x54f0
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %rdi
callq 0x79cc
movq %rsp, %rdi
callq 0x54f0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x760d
jmp 0x760d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54f0
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdx, %rsi
callq 0x6672
leaq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x2, %rax
movl (%r12), %ecx
addl %ecx, %eax
incl %eax
movl %eax, (%r12)
callq 0x5654
leaq 0x18(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x7272
movq %rsp, %r14
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7caa
movq %r15, %rdi
callq 0x54f0
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %rdi
callq 0x79cc
movq %rsp, %rdi
callq 0x54f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x76cc
jmp 0x76cc
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54f0
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %r8, %rbx
movq %rdx, %rax
movq %rsi, %rdx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rsp)
movaps %xmm0, (%rsp)
addl $0x3, (%rcx)
leaq 0x18(%rsp), %rdi
movq %rax, %rcx
callq 0x73ca
movq %rsp, %r14
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7caa
movq %r15, %rdi
callq 0x54f0
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %rdi
callq 0x79cc
movq %rsp, %rdi
callq 0x54f0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x775f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54f0
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rsp)
movaps %xmm0, (%rsp)
addl $0x2, (%rdx)
leaq 0x18(%rsp), %rdi
movq %rsi, %rdx
callq 0x7452
movq %rsp, %r14
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7caa
movq %r15, %rdi
callq 0x54f0
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %rdi
callq 0x79cc
movq %rsp, %rdi
callq 0x54f0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x77dd
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54f0
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movl (%rdx), %eax
movl (%rsi), %ecx
leal 0x2(%rax,%rcx), %eax
movl %eax, (%rsi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x708e
movq 0x8(%r14), %rsi
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %r14, %rdi
callq 0x79cc
incl 0x4(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x54f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54f0
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl 0x4(%rsi), %eax
jne 0x78da
movq 0x8(%r14), %rsi
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
movq %r14, %rdi
callq 0x79cc
jmp 0x78e7
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x78e7
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpl $0x0, (%rdx)
je 0x7997
movq %rdx, %r14
pushq $0x3
popq %r12
pushq $0x18
popq %rbp
leaq 0xe(%rsp), %r15
testl %r12d, %r12d
js 0x79a7
movl (%r14), %eax
movl %ebp, %ecx
sarl %cl, %eax
movb %al, 0xe(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79ec
decl %r12d
addl $-0x8, %ebp
jmp 0x7974
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x79ec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x79b9
movq %rax, %r14
movq %rbx, %rdi
callq 0x54f0
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/parser.cpp
// Function: Parser::parseLineForNodeNameDiminished(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string Parser::parseLineForNodeNameDiminished(std::string & nodeLine, std::string & nodeName)
{
    std::regex patternNodeName("(\\S*)\\s*OBJECT IDENTIFIER");
    std::regex patternCutNodeName("");
    std::smatch match;
    if (std::regex_search(nodeLine, match, patternNodeName))
    {
        nodeName = match.str(1);
        patternCutNodeName.assign(nodeName);
        nodeLine = std::regex_replace(nodeLine, patternCutNodeName, "", std::regex_constants::format_first_only);
        return nodeName;
    }
    return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10aed(%rip), %rsi     # 0x1951e
leaq 0x60(%rsp), %rdi
pushq $0x10
popq %rbp
movl %ebp, %edx
callq 0xb4e0
leaq 0x10d8d(%rip), %rsi     # 0x197d4
leaq 0x20(%rsp), %rdi
movl %ebp, %edx
callq 0xb4e0
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
leaq 0x60(%rsp), %rdx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xb546
testb %al, %al
je 0x8aeb
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0xb562
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x43b0
movq %r12, %rdi
callq 0x4170
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0xb836
leaq 0x10d22(%rip), %rcx     # 0x197d4
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
movq %r15, %rsi
movl $0x400, %r8d            # imm = 0x400
callq 0xb853
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x43b0
movq %r12, %rdi
callq 0x4170
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4410
jmp 0x8afd
leaq 0x10ce2(%rip), %rsi     # 0x197d4
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5398
leaq 0x40(%rsp), %rdi
callq 0xb94c
leaq 0x20(%rsp), %rdi
callq 0xb786
leaq 0x60(%rsp), %rdi
callq 0xb786
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b39
jmp 0x8b39
jmp 0x8b39
movq %rax, %rbx
jmp 0x8b50
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb94c
leaq 0x20(%rsp), %rdi
callq 0xb786
leaq 0x60(%rsp), %rdi
callq 0xb786
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x109bf(%rip), %rsi     # 0x19538
leaq 0x48(%rsp), %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0xb4e0
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
xorl %ebp, %ebp
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xb546
testb %al, %al
je 0x8bd6
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
pushq $0x1
popq %rdx
callq 0xb562
leaq 0x28(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0xb8a3
movl %eax, (%rbx)
leaq 0x28(%rsp), %rdi
callq 0x4170
movl (%rbx), %ebp
movq %rsp, %rdi
callq 0xb94c
leaq 0x48(%rsp), %rdi
callq 0xb786
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4170
jmp 0x8c09
jmp 0x8c06
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb94c
leaq 0x48(%rsp), %rdi
callq 0xb786
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/parser.cpp
// Function: Parser::addParentNodes(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<unsigned int, std::allocator<unsigned int>>&)
void Parser::addParentNodes(std::vector<std::string> & parentVector, std::vector<unsigned int> & vectorOID)
{ 
    std::regex patternParentOID("\\(.\\)");
    std::smatch match;
    DataType dataType;
    for (std::vector<std::string>::size_type i = parentVector.size() - 1; i != (std::vector<std::string>::size_type) - 1; i--)
    {
        if (parentVector[i] == "iso")
        {
            m_pNode = m_pTree -> m_rootOfTheTree;
        }
        else
        {
            m_pNode = m_pTree -> addNode(vectorOID[i], parentVector[i], dataType, "", AccessType::NOT_ACCESSIBLE, StatusType::MANDATORY, m_pNode);
        }    
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x105c3(%rip), %rsi     # 0x19568
leaq 0x58(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0xb4e0
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x17fe4
movq 0x8(%r14), %r12
movq %r14, 0x20(%rsp)
subq (%r14), %r12
movq %r12, %rbp
sarq $0x5, %rbp
addq $-0x20, %r12
leaq 0x98(%rsp), %r13
leaq 0x108(%rsp), %r15
movq 0x10(%rsp), %r14
subq $0x1, %rbp
jb 0x90d4
movq %r15, %rbx
movq 0x20(%rsp), %r15
movq (%r15), %rdi
addq %r12, %rdi
leaq 0x10557(%rip), %rsi     # 0x1956e
callq 0x6c47
movq 0x60(%r14), %rcx
testb %al, %al
movq %r12, 0x28(%rsp)
je 0x9038
movq (%rcx), %rax
movq %rax, 0x68(%r14)
movq %rbx, %r15
jmp 0x90c6
movq %rcx, %r14
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %r13, %rdi
movl (%rax,%rbp,4), %eax
movl %eax, 0xc(%rsp)
movq (%r15), %rsi
addq %r12, %rsi
callq 0x4410
movq %rbx, %r15
movq %rbx, %rdi
leaq 0xb8(%rsp), %rsi
callq 0x65f4
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
leaq 0x1075a(%rip), %rsi     # 0x197d4
leaq 0xb(%rsp), %rdx
callq 0x5398
movq %r14, %rdi
movl 0xc(%rsp), %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
pushq $0x3
popq %r9
movq 0x10(%rsp), %r14
pushq 0x68(%r14)
pushq $0x0
callq 0x18212
popq %rcx
popq %rdx
movq %rax, 0x68(%r14)
movq %rbx, %rdi
callq 0x4170
movq %r15, %rdi
callq 0x18002
movq %r13, %rdi
callq 0x4170
movq 0x28(%rsp), %r12
addq $-0x20, %r12
jmp 0x8ff8
leaq 0xb8(%rsp), %rdi
callq 0x18002
leaq 0x30(%rsp), %rdi
callq 0xb94c
leaq 0x58(%rsp), %rdi
callq 0xb786
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x914f
movq %rax, %rbx
jmp 0x9142
movq %rax, %rbx
jmp 0x9128
movq %rax, %rbx
jmp 0x9135
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4170
leaq 0x108(%rsp), %rdi
callq 0x18002
leaq 0x98(%rsp), %rdi
callq 0x4170
leaq 0xb8(%rsp), %rdi
callq 0x18002
leaq 0x30(%rsp), %rdi
callq 0xb94c
leaq 0x58(%rsp), %rdi
callq 0xb786
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/parser.cpp
// Function: Parser::addNodeOneOrMore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
Node * Parser::addNodeOneOrMore(std::string & nodeName, unsigned int & OID, std::vector<std::string> & parentVector)
{
    
    DataType dataType;
    for (std::list<Node>::iterator it = m_pTree -> m_nodeList.begin(); it != m_pTree -> m_nodeList.end(); it++)
    {
        if ((*it).m_name == parentVector.front())
        {
            m_pNode = &(*it);
            break;
        }
    }
    return m_pTree -> addNode(OID, nodeName, dataType, "", AccessType::NOT_ACCESSIBLE, StatusType::MANDATORY, m_pNode);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x98(%rsp), %rdi
callq 0x17fe4
movq 0x60(%rbx), %rbp
addq $0x8, %rbp
movq (%rbp), %rbp
movq 0x60(%rbx), %r14
leaq 0x8(%r14), %rax
cmpq %rax, %rbp
je 0x91cc
leaq 0x18(%rbp), %rdi
movq (%r13), %rsi
callq 0x53d3
testb %al, %al
je 0x919e
addq $0x10, %rbp
movq %rbp, 0x68(%rbx)
movq 0x60(%rbx), %r14
movl (%r12), %ebp
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x4410
leaq 0x48(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x65f4
leaq 0x105de(%rip), %rsi     # 0x197d4
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5398
leaq 0x28(%rsp), %rdx
leaq 0x48(%rsp), %rcx
leaq 0x8(%rsp), %r8
pushq $0x3
popq %r9
movq %r14, %rdi
movl %ebp, %esi
pushq 0x68(%rbx)
pushq $0x0
callq 0x18212
popq %rcx
popq %rdx
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x18002
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x18002
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4170
jmp 0x927e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x18002
jmp 0x928d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4170
jmp 0x929c
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x18002
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x4410
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa320
leaq 0x40(%rsp), %rdi
callq 0x4170
movq %r14, %rdi
callq 0xa7be
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4410
movq %r14, %rdi
movq %rbx, %rsi
callq 0x871e
leaq 0x20(%rsp), %rdi
callq 0x4170
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4410
movq %r14, %rdi
movq %rbx, %rsi
callq 0x92b2
movq %rsp, %rdi
callq 0x4170
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb4ab
jmp 0xb4ab
movq %rax, %r14
movq %rbx, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x10(%rsp), %eax
movl 0x8(%rsp), %r10d
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movl %r9d, 0x10(%rdi)
movl %r10d, 0x14(%rdi)
movl %eax, 0x18(%rdi)
andl $0x0, 0x1c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x17fe4
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x14d6(%rip), %rsi      # 0x1956e
leaq 0x58(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5398
leaq 0x78(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x65f4
leaq 0x1714(%rip), %rsi      # 0x197d4
leaq 0x38(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x5398
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x185ac
subq $0x8, %rsp
leaq 0x120(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x60(%rsp), %rdx
leaq 0x80(%rsp), %rcx
leaq 0x40(%rsp), %r8
pushq $0x3
popq %r9
pushq %r14
pushq $0x0
pushq $0x0
callq 0x189b4
addq $0x20, %rsp
leaq 0x20(%rsp), %rdi
callq 0x18654
leaq 0x38(%rsp), %rdi
callq 0x4170
leaq 0x78(%rsp), %rdi
callq 0x18002
leaq 0x58(%rsp), %rdi
callq 0x4170
leaq 0x8(%rbx), %rdi
leaq 0x118(%rsp), %rsi
callq 0x185e6
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x118(%rsp), %rdi
callq 0x18b56
leaq 0x8(%rsp), %rdi
callq 0x18654
leaq 0xc8(%rsp), %rdi
callq 0x18002
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x18b56
jmp 0x181d9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x18654
jmp 0x181ac
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4170
jmp 0x181bb
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x18002
jmp 0x181ca
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x4170
jmp 0x181d9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18654
leaq 0xc8(%rsp), %rdi
callq 0x18002
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
addq $0xa8, %r15
movl %edx, %ebp
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x184af
movq 0x10(%r13), %rax
movl (%rax), %r14d
movq %r12, %rdi
movq %rbp, %rsi
callq 0x185fe
cmpl (%rax), %r14d
jne 0x18464
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x2, %rax
decq %rax
cmpq %rbp, %rax
je 0x184b3
movq 0x10(%r13), %rax
movl (%rax), %r14d
movq %r12, %rdi
movq %rbp, %rsi
callq 0x185fe
cmpl (%rax), %r14d
jne 0x1842f
incl %ebx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x6672
movq 0x10(%r13), %rcx
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x18408
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5654
jmp 0x184b7
xorl %ebx, %ebx
jmp 0x184b7
movq 0x10(%r13), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5654
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
xorl %ebx, %ebx
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x18584
leaq 0x18(%r12), %rdi
movq %r14, %rsi
callq 0x53d3
testb %al, %al
je 0x18563
addq $0x10, %r12
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rdi, %r12
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movl %esi, %r13d
leaq 0x8(%rdi), %rbp
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x17fe4
leaq 0x78(%r12), %rcx
leaq 0x88(%r12), %rax
movq %rax, 0x78(%r12)
andq $0x0, 0x80(%r12)
movb $0x0, 0x88(%r12)
leaq 0xa8(%r12), %rbx
movq %rbx, 0xb0(%r12)
movq %rbx, 0xa8(%r12)
andq $0x0, 0xb8(%r12)
movl %r13d, (%r12)
movq %rcx, %r13
movq %rbp, %rdi
movq %r15, %rsi
callq 0x41e0
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0xb8c0
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x41e0
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rax
movl 0x50(%rsp), %ecx
movl 0x4(%rsp), %edx
movl %edx, 0x98(%r12)
movl %ecx, 0x9c(%r12)
movq %rax, 0xa0(%r12)
movq %rbx, %rdi
callq 0x18b86
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x18acd
movq %rax, %r15
movq %rbx, %rdi
callq 0x18654
movq %r13, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x18002
movq %rbp, %rdi
callq 0x4170
movq %r15, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1b97(%rip), %rsi      # 0x307c
callq 0x10f0
testq %rax, %rax
je 0x1596
movq %rax, %r14
leaq -0x29(%rbp), %rax
movb $0x0, (%rax)
leaq 0x68(%rbx), %r12
leaq 0x80(%rbx), %r13
xorl %ecx, %ecx
movl %ecx, %r15d
movq %r14, %rdi
callq 0x1120
movb %al, -0x29(%rbp)
cmpb $0x9, %al
je 0x1529
movzbl %al, %ecx
cmpl $0xff, %ecx
jne 0x152f
jmp 0x1587
movb $0x20, -0x29(%rbp)
movb $0x20, %al
movl %r15d, %edx
xorb $0x20, %dl
movl %eax, %esi
xorb $0x20, %sil
movb $0x20, %cl
orb %dl, %sil
je 0x150a
xorb $0xa, %r15b
xorb $0xa, %al
orb %r15b, %al
movb $0xa, %cl
je 0x150a
movq %r12, %rdi
leaq -0x29(%rbp), %rsi
callq 0x16d8
movb -0x29(%rbp), %cl
cmpb $0xa, %cl
jne 0x150a
movq %rbx, %rdi
callq 0x16e8
movq %rax, -0x38(%rbp)
movq %r13, %rdi
leaq -0x38(%rbp), %rsi
callq 0x182a
movq %r12, %rdi
callq 0x171a
movb $0xa, %cl
jmp 0x150a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ae1(%rip), %rdi      # 0x307e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
leaq 0x1a8a(%rip), %rdi      # 0x3038
leaq 0x1a89(%rip), %rsi      # 0x303e
leaq 0x1ad2(%rip), %rcx      # 0x308e
pushq $0x27
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x68, %rdi
movl $0xf8c9, %ecx           # imm = 0xF8C9
xorl %eax, %eax
movq %rdi, %rdx
movq (%rdx), %rdx
cmpq %rdi, %rdx
je 0x1717
imulq %rcx, %rax
movsbq 0x10(%rdx), %rsi
addq %rsi, %rax
imulq $0x5c6b7, %rcx, %rcx    # imm = 0x5C6B7
jmp 0x16fa
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
movl $0x1, (%rsi)
movq %r14, %rdi
callq 0x6048
testb %al, %al
je 0x23f9
leaq 0xc(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x43d9
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x237c
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3925
leaq 0x10(%rsp), %rdi
callq 0x253c
leaq 0x90(%rsp), %rdi
callq 0x253c
jmp 0x2425
leaq 0x10(%rsp), %rsi
andl $0x0, (%rsi)
movq %r14, %rdi
callq 0x3860
testb %al, %al
je 0x241a
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2556
jmp 0x2425
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25b4
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x253c
jmp 0x2447
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x253c
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
leaq 0x8(%rsp), %rdi
callq 0x2610
leaq 0x88(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2556
leaq 0x108(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x237c
leaq 0x8(%rsp), %rbx
leaq 0x108(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2678
movq %r14, %rdi
callq 0x253c
movq 0xbb1a(%rip), %rdi      # 0xdfd8
movq %rbx, %rsi
callq 0x6365
movq %rax, %rdi
callq 0x2080
leaq 0x8(%rsp), %rdi
callq 0x26bc
movq 0xbaf9(%rip), %rdi      # 0xdfd8
movl %eax, %esi
callq 0x21f0
movq %rax, %rdi
callq 0x2080
leaq 0x88(%rsp), %rdi
callq 0x253c
leaq 0x8(%rsp), %rdi
callq 0x253c
xorl %eax, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
jmp 0x2519
movq %rax, %rbx
jmp 0x2529
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x253c
leaq 0x8(%rsp), %rdi
callq 0x253c
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mariotti94[P]BigFloat/./BigFloat.h
// Function: BigFloat::BigFloat()
BigFloat()
    {
        sign = '\0';
        decimals = 0;
        error = 1;
        error_code = "Unset";
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2726
leaq 0x70(%r15), %rax
movq %rax, 0x60(%r15)
andq $0x0, 0x68(%r15)
leaq 0x60(%r15), %r14
xorl %eax, %eax
movb %al, 0x70(%r15)
movb %al, (%r15)
andl $0x0, 0x58(%r15)
movb $0x1, 0x5c(%r15)
leaq 0x69b5(%rip), %rsi      # 0x9004
movq %r14, %rdi
callq 0x2220
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x26da
movq %r15, %rdi
callq 0x2200