LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/Session.h
// Function: fprime::Session::pushInbound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void pushInbound(string rawMsg) {
            unique_lock<mutex> lock(inboundLock);
            inboundQueue.push(rawMsg);
            lock.unlock();
            inboundCondition.notify_one();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1e0(%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x2fb70
movb $0x1, 0x8(%r15)
leaq 0x300(%rbx), %rdi
movq %r14, %rsi
callq 0x2fe00
movq %rsp, %rdi
callq 0x2e060
addq $0x208, %rbx            # imm = 0x208
movq %rbx, %rdi
callq 0x2eb10
movq %rsp, %rdi
callq 0x2e720
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2e720
movq %rbx, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/Session.h
// Function: fprime::Session::pushOutbound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void pushOutbound(string rawMsg) {
            unique_lock<mutex> lock(outboundLock);
            outboundQueue.push(rawMsg);
            lock.unlock();
            outboundCondition.notify_one();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2b8(%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x2fb70
movb $0x1, 0x8(%r15)
leaq 0x268(%rbx), %rdi
movq %r14, %rsi
callq 0x2fe00
movq %rsp, %rdi
callq 0x2e060
addq $0x238, %rbx            # imm = 0x238
movq %rbx, %rdi
callq 0x2eb10
movq %rsp, %rdi
callq 0x2e720
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2e720
movq %rbx, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/CallbacksManager.cpp
// Function: fprime::CallbacksManager::executeCallback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, fprime::Message, fprime::Session*)
void CallbacksManager::executeCallback(string methodName,  fprime::Message msg, fprime::Session* sessionPtr) {
        typename std::map<string, Callback>::iterator it;
        future<void> f1;
        it = callbacksMap.find(methodName);
        if (it != callbacksMap.end()) {
            try {
                CallBackType task = it->second.getCallback();
                if (it->second.getlaunchAsync()) {
                    f1 = std::async(std::launch::async, task, msg, sessionPtr);
                } else
                    task(msg, sessionPtr);
            } catch (...) {
                
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r12
movq %rcx, 0x38(%rsp)
addq $0x8, %rdi
callq 0x2e3b0
addq $0x10, %r12
cmpq %r12, %rax
je 0x351e1
movq %rax, %r15
leaq 0x40(%rax), %rsi
leaq 0x18(%rsp), %rdi
callq 0x2ebc0
cmpb $0x1, 0x60(%r15)
jne 0x35183
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %r8
movl $0x1, %esi
movq %rbx, %rcx
callq 0x2fc50
movq 0x10(%rsp), %rbx
jmp 0x351bb
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x2ec60
movq %r14, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x351f0
leaq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq *0x18(%rdi)
leaq 0x40(%rsp), %rdi
callq 0x2f070
xorl %ebx, %ebx
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x351d4
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
testq %rbx, %rbx
je 0x351e1
movq %rbx, %rdi
callq 0x2f370
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2e780
jmp 0x351f7
movq %rax, %rbx
jmp 0x35211
movq %rax, %rdi
callq 0x320e8
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2f070
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x35231
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x35231
jmp 0x351fc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2e8b0
callq 0x30740
jmp 0x351e1
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Component.cpp
// Function: fprime::Component::getControlField()
fprime::Field::FieldPtr Component::getControlField() {
        if (controlField != nullptr)
            return controlField;
        else
            throw runtime_error("at Component.getControlField: Control field for component " +  name + " is null.");
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x36b7d
movq %rax, (%rdi)
movq 0x40(%r14), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x36b6f
movq 0x3a2f7(%rip), %rcx     # 0x70e58
cmpb $0x0, (%rcx)
je 0x36b6b
incl 0x8(%rax)
jmp 0x36b6f
lock
incl 0x8(%rax)
movq %rdi, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
addq $0x48, %r14
leaq 0x23dfa(%rip), %rsi     # 0x5a98f
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x2f510
leaq 0x23e21(%rip), %rsi     # 0x5a9ca
leaq 0x28(%rsp), %rdi
callq 0x30e50
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x36bd4
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x36be1
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x306f0
xorl %ebp, %ebp
movq 0x3a3c7(%rip), %rsi     # 0x70fd8
movq 0x3a1a8(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36c32
callq 0x2f6c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36c45
callq 0x2f6c0
testb %bpl, %bpl
jne 0x36c67
jmp 0x36c6f
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36c67
callq 0x2f6c0
jmp 0x36c67
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Field.cpp
// Function: fprime::Field::Field(unsigned int)
Field::Field(unsigned int id) {
        if (id)
            _id = id;
        else
            throw std::runtime_error("at Field.Constructor attribute could not be empty.");
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x382dd(%rip), %rax     # 0x70c18
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %r13
movq %r13, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
leaq 0x58(%rdi), %rcx
movl %eax, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movq %rcx, 0x68(%rdi)
movq %rcx, 0x70(%rdi)
movq %rax, 0x78(%rdi)
leaq 0x88(%rdi), %rcx
movl %eax, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movq %rcx, 0x98(%rdi)
movq %rcx, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
testl %esi, %esi
je 0x389b3
movl %esi, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x222d8(%rip), %rsi     # 0x5ac9f
movq %rax, %rdi
callq 0x2e800
movq 0x38602(%rip), %rsi     # 0x70fd8
movq 0x383e3(%rip), %rdx     # 0x70dc0
movq %r15, %rdi
callq 0x308e0
movq %rax, %r14
jmp 0x389f5
movq %rax, %r14
movq %r15, %rdi
callq 0x2f150
leaq 0x50(%rbx), %r15
leaq 0x80(%rbx), %rdi
callq 0x30c30
movq %r15, %rdi
callq 0x2f470
movq 0x30(%rbx), %rdi
cmpq %r13, %rdi
je 0x38a1b
callq 0x2f6c0
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
je 0x38a29
callq 0x2f6c0
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Field.cpp
// Function: fprime::Field::setId(unsigned int)
void Field::setId(unsigned int id) {
        if (id)
            _id = id;
        else
            throw std::runtime_error("at Field.setId: Id attribute could not be empty.");
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x38aa5
movl %esi, 0x8(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x22219(%rip), %rsi     # 0x5acd2
movq %rax, %rdi
callq 0x2e800
movq 0x38510(%rip), %rsi     # 0x70fd8
movq 0x382f1(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Field.cpp
// Function: fprime::Field::getId()
unsigned int Field::getId() {
        if (_id)
            return _id;
        else
            throw std::runtime_error("at Field.getId: Id attribute is empty.");
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x38bbd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x221a4(%rip), %rsi     # 0x5ad75
movq %rax, %rdi
callq 0x2e800
movq 0x383f8(%rip), %rsi     # 0x70fd8
movq 0x381d9(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/FixDictionary.cpp
// Function: fprime::FixDictionary::getProtocol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
fprime::Protocol::ProtocolPtr FixDictionary::getProtocol(string version) {
        map<string,fprime::Protocol::ProtocolPtr>::iterator search;
        search = protocols.find(version);
        if (search != protocols.end())
            return search->second;
        else
            throw std::runtime_error("at FixDictionary.getProtocol: Protocol " + version + " does not exists in dictionary");
 
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x31020
addq $0x10, %r15
cmpq %r15, %rax
je 0x399a9
movq 0x40(%rax), %rcx
movq %rcx, (%rbx)
movq 0x48(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x3999b
movq 0x374cb(%rip), %rcx     # 0x70e58
cmpb $0x0, (%rcx)
je 0x39997
incl 0x8(%rax)
jmp 0x3999b
lock
incl 0x8(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x214d6(%rip), %rsi     # 0x5ae93
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x2f510
leaq 0x214ea(%rip), %rsi     # 0x5aebb
leaq 0x28(%rsp), %rdi
callq 0x30e50
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x399fc
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x39a09
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x306f0
xorl %ebp, %ebp
movq 0x3759f(%rip), %rsi     # 0x70fd8
movq 0x37380(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x39a5a
callq 0x2f6c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39a6d
callq 0x2f6c0
testb %bpl, %bpl
jne 0x39a8f
jmp 0x39a97
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39a8f
callq 0x2f6c0
jmp 0x39a8f
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/FixLoader.cpp
// Function: fprime::FixLoader::parseFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Json::Value FixLoader::parseFile(string fileName) {
        Json::Value root;
        Json::Reader reader;
        std::ifstream stream(fileName, std::ifstream::binary);

        bool parsingSuccessful = reader.parse(stream, root, false);

        if (!parsingSuccessful) {
            // report to the user the failure and their locations in the document.
            std::cout << "Error loading file " << fileName << ": " << reader.getFormattedErrorMessages() << endl;
            std::runtime_error("Error loading file " + fileName);
        } else {
            return root;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x350, %rsp            # imm = 0x350
movq %rdx, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x2e950
leaq 0x38(%rsp), %rdi
callq 0x2f940
leaq 0x148(%rsp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x306d0
leaq 0x38(%rsp), %rdi
leaq 0x148(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x30ca0
testb %al, %al
je 0x3a0fb
leaq 0x148(%rsp), %rdi
callq 0x2e4b0
leaq 0x130(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a0be
callq 0x2f6c0
leaq 0xe8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a0d4
callq 0x2f6c0
leaq 0x88(%rsp), %rdi
callq 0x2eee0
leaq 0x38(%rsp), %rdi
callq 0x2faa0
movq %rbx, %rax
addq $0x350, %rsp            # imm = 0x350
popq %rbx
popq %r14
popq %r15
retq
movq 0x36d5e(%rip), %rdi     # 0x70e60
leaq 0x20e31(%rip), %rsi     # 0x5af3a
movl $0x13, %edx
callq 0x2fb10
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x36d3f(%rip), %rdi     # 0x70e60
callq 0x2fb10
movq %rax, %r15
leaq 0x213f9(%rip), %rsi     # 0x5b529
movl $0x2, %edx
movq %rax, %rdi
callq 0x2fb10
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x30500
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2fb10
movq %rax, %rdi
callq 0x2eab0
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x3a179
callq 0x2f6c0
leaq 0x20dba(%rip), %rsi     # 0x5af3a
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x2f510
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x306f0
leaq 0x28(%rsp), %rdi
callq 0x310f0
leaq 0x8(%rsp), %rdi
callq 0x2e9e0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x3a1d2
jmp 0x3a1e8
jmp 0x3a1e5
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a1e8
callq 0x2f6c0
jmp 0x3a1e8
jmp 0x3a1e5
movq %rax, %r14
jmp 0x3a1f5
movq %rax, %r14
jmp 0x3a1ff
movq %rax, %r14
leaq 0x148(%rsp), %rdi
callq 0x2e4b0
leaq 0x38(%rsp), %rdi
callq 0x2fc80
movq %rbx, %rdi
callq 0x2ebb0
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/FixParser.cpp
// Function: fprime::FixParser::parseMessage(fprime::FixParser::FlatMessage)
fprime::Message FixParser::parseMessage(fprime::FixParser::FlatMessage message) {
        fprime::Message fixMessage = protocolPtr->getMessage(message.getMsgType());
        unsigned int position = 0;
        bool result = false;
        result = parseLevel(message.orderedMap, position, fixMessage.getHeader(), 0, false);
        result = parseLevel(message.orderedMap, position, fixMessage.getBody(), 0, false);
        result = parseLevel(message.orderedMap, position, fixMessage.getTrailer(), 0, false);
        return fixMessage;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x2e210
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x30130
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a954
callq 0x2f6c0
movl $0x0, 0xc(%rsp)
leaq 0xc0(%rsp), %rdi
movq %r15, %rsi
callq 0x2efe0
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x2e8c0
leaq 0xc0(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %r14, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2e390
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x3a9a8
callq 0x2f370
leaq 0xc0(%rsp), %rdi
callq 0x2f630
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x2efe0
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x2e540
leaq 0x90(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2e390
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3aa01
callq 0x2f370
leaq 0x90(%rsp), %rdi
callq 0x2f630
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0x2efe0
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x2ea60
leaq 0x60(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2e390
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3aa54
callq 0x2f370
leaq 0x60(%rsp), %rdi
callq 0x2f630
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3aa89
callq 0x2f370
jmp 0x3aa89
movq %rax, %r14
leaq 0x60(%rsp), %rdi
jmp 0x3aad0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3aaa7
callq 0x2f370
jmp 0x3aaa7
movq %rax, %r14
leaq 0x90(%rsp), %rdi
jmp 0x3aad0
movq %rax, %r14
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x3aac8
callq 0x2f370
jmp 0x3aac8
movq %rax, %r14
leaq 0xc0(%rsp), %rdi
callq 0x2f630
jmp 0x3aaf2
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3aafa
callq 0x2f6c0
jmp 0x3aafa
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f070
movq %r14, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/FixParser.cpp
// Function: fprime::FixParser::checkSum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::uint8_t FixParser::checkSum(string msg) {
        size_t startPos = msg.find("8=FIX");
        if (startPos == string::npos)
            throw runtime_error("at FixParser.checkSum: begin string did not found");
        size_t endPos = msg.find("\00110=") + 1;
        if (endPos == string::npos)
            throw runtime_error("at FixParser.checkSum: Checksum field did not found");
        string _msg = msg.substr(startPos, msg.size() - (msg.size() - endPos));
        uint8_t cs = std::accumulate(_msg.begin(), _msg.end(), static_cast<std::uint8_t> (0));
        return cs % 256;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x1f191(%rip), %rsi     # 0x5a18c
movl $0x5, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x309a0
cmpq $-0x1, %rax
je 0x3b080
movq %rax, %r14
leaq 0x1f178(%rip), %rsi     # 0x5a192
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x309a0
incq %rax
cmpq $-0x1, %rax
je 0x3b09e
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0x2f8b0
movq (%r15), %rdi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x3b063
xorl %ecx, %ecx
xorl %ebx, %ebx
addb (%rdi,%rcx), %bl
incq %rcx
cmpq %rcx, %rax
jne 0x3b056
jmp 0x3b065
xorl %ebx, %ebx
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3b074
callq 0x2f6c0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x1fee6(%rip), %rsi     # 0x5af7a
movq %rax, %rdi
callq 0x2e800
jmp 0x3b0ba
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x1fefa(%rip), %rsi     # 0x5afac
movq %rax, %rdi
callq 0x2e800
movq 0x35f17(%rip), %rsi     # 0x70fd8
movq 0x35cf8(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
jmp 0x3b0d2
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Initiator.cpp
// Function: fprime::Initiator::start()
bool Initiator::start() {
        try {
            thread t1(std::bind(&Initiator::startInitiator, this));
            t1.detach();
            usleep(10000);
            return sessionRunning;
        } catch (SocketException& e) {
            //TODO: log error
            this->stop();
            return false;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x35319(%rip), %rax     # 0x70ce8
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movq %rdi, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x2efa0
leaq 0x8(%rsp), %rdi
callq 0x309e0
movl $0x2710, %edi           # imm = 0x2710
callq 0x301a0
cmpq $0x0, 0x8(%rsp)
jne 0x3ba43
movb 0x1d8(%rbx), %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x3ba21
cmpq $0x0, 0x8(%rsp)
jne 0x3ba43
movq %rax, %r14
cmpl $0x1, %edx
jne 0x3ba50
movq %r14, %rdi
callq 0x2e8b0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
callq 0x30740
xorl %eax, %eax
jmp 0x3ba0f
callq 0x2e550
movq %rax, %r14
callq 0x30740
movq %r14, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/IntDataHolder.cpp
// Function: fprime::IntDataHolder::validate()
bool IntDataHolder::validate() {
        try {
            nativeData = boost::lexical_cast<int>(baseData);
            return true;
        } catch (boost::bad_lexical_cast& e) {
            return false;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x2f8f0
testb %al, %al
je 0x3be9c
movl 0xc(%rsp), %eax
movl %eax, 0x28(%rbx)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x34f5d(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x34e3a(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x34d47(%rip), %rax     # 0x70c08
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3bee2
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x3bef9
callq 0x2e8b0
callq 0x30740
xorl %eax, %eax
jmp 0x3be94
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/DataHolder.h
// Function: fprime::DataHolder::toInt()
virtual int toInt() {
            try {
                return boost::lexical_cast<int>(baseData);
            } catch(exception& e) {
                throw runtime_error("Invalid data type conversion");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x2f8f0
testb %al, %al
je 0x3bf6a
movl 0xc(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x34e8f(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x34d6c(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x34c79(%rip), %rax     # 0x70c08
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3bfb0
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c005
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1f1cd(%rip), %rsi     # 0x5b19f
movq %rax, %rdi
callq 0x2e800
movq 0x34ff7(%rip), %rsi     # 0x70fd8
movq 0x34dd8(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
jmp 0x3c000
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30740
movq %rbx, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/DataHolder.h
// Function: fprime::DataHolder::toUsignedInt()
virtual unsigned int toUsignedInt() {
            try {
                return boost::lexical_cast<unsigned int>(baseData);
            } catch(exception& e) {
                throw runtime_error("Invalid data type conversion");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x30f90
testb %al, %al
je 0x3c054
movl 0xc(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x34da5(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x34c82(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x34eaf(%rip), %rax     # 0x70f28
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3c09a
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c0ef
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1f0e3(%rip), %rsi     # 0x5b19f
movq %rax, %rdi
callq 0x2e800
movq 0x34f0d(%rip), %rsi     # 0x70fd8
movq 0x34cee(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
jmp 0x3c0ea
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30740
movq %rbx, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/DataHolder.h
// Function: fprime::DataHolder::tofloat()
virtual float tofloat() {
            try {
                return boost::lexical_cast<float>(baseData);
            } catch(exception& e) {
                throw runtime_error("Invalid data type conversion");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x2f6b0
testb %al, %al
je 0x3c140
movss 0xc(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x34cb9(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x34b96(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x34d73(%rip), %rax     # 0x70ed8
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3c186
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c1db
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1eff7(%rip), %rsi     # 0x5b19f
movq %rax, %rdi
callq 0x2e800
movq 0x34e21(%rip), %rsi     # 0x70fd8
movq 0x34c02(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
jmp 0x3c1d6
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30740
movq %rbx, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/DataHolder.h
// Function: fprime::DataHolder::toDouble()
virtual double toDouble() {
            try {
                return boost::lexical_cast<double>(baseData);
            } catch(exception& e) {
                throw runtime_error("Invalid data type conversion");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x2e940
testb %al, %al
je 0x3c22d
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x34bcc(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x34aa9(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x34d7e(%rip), %rax     # 0x70fd0
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3c273
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c2c8
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1ef0a(%rip), %rsi     # 0x5b19f
movq %rax, %rdi
callq 0x2e800
movq 0x34d34(%rip), %rsi     # 0x70fd8
movq 0x34b15(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
jmp 0x3c2c3
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30740
movq %rbx, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/DataHolder.h
// Function: fprime::DataHolder::toLong()
virtual long toLong() {
            try {
                return boost::lexical_cast<long>(baseData);
            } catch(exception& e) {
                throw runtime_error("Invalid data type conversion");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x304e0
testb %al, %al
je 0x3c318
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x34ae1(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x349be(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x34c3b(%rip), %rax     # 0x70f78
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3c35e
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c3b3
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1ee1f(%rip), %rsi     # 0x5b19f
movq %rax, %rdi
callq 0x2e800
movq 0x34c49(%rip), %rsi     # 0x70fd8
movq 0x34a2a(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
jmp 0x3c3ae
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30740
movq %rbx, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/DataHolder.h
// Function: fprime::DataHolder::toLongInt()
virtual long int toLongInt() {
            try {
                return boost::lexical_cast<long int>(baseData);
            } catch(exception& e) {
                throw runtime_error("Invalid data type conversion");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x304e0
testb %al, %al
je 0x3c404
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x349f5(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x348d2(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x34b4f(%rip), %rax     # 0x70f78
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3c44a
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c49f
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1ed33(%rip), %rsi     # 0x5b19f
movq %rax, %rdi
callq 0x2e800
movq 0x34b5d(%rip), %rsi     # 0x70fd8
movq 0x3493e(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
jmp 0x3c49a
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30740
movq %rbx, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/DataHolder.h
// Function: fprime::DataHolder::toLongDouble()
virtual long double toLongDouble() {
            try {
                return boost::lexical_cast<long double>(baseData);
            } catch(exception& e) {
                throw runtime_error("Invalid data type conversion");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
fldz
fstpt (%rsp)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rsp, %rsi
callq 0x30f00
testb %al, %al
je 0x3c4ea
fldt (%rsp)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x3490f(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x347ec(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x34a81(%rip), %rax     # 0x70f90
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3c530
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c585
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1ec4d(%rip), %rsi     # 0x5b19f
movq %rax, %rdi
callq 0x2e800
movq 0x34a77(%rip), %rsi     # 0x70fd8
movq 0x34858(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
jmp 0x3c580
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30740
movq %rbx, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/include/DataHolder.h
// Function: fprime::DataHolder::toShort()
virtual short toShort() {
            try {
                return boost::lexical_cast<short>(baseData);
            } catch(exception& e) {
                throw runtime_error("Invalid data type conversion");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0xe(%rsp), %rsi
movw $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x2f010
testb %al, %al
je 0x3c5d4
movzwl 0xe(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x34825(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x34702(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x347a7(%rip), %rax     # 0x70da0
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x3c61a
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c66f
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1eb63(%rip), %rsi     # 0x5b19f
movq %rax, %rdi
callq 0x2e800
movq 0x3498d(%rip), %rsi     # 0x70fd8
movq 0x3476e(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
jmp 0x3c66a
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30740
movq %rbx, %rdi
callq 0x30a10
movq %rax, %rdi
callq 0x320e8
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Message.cpp
// Function: fprime::Message::operator=(fprime::Message&)
fprime::Message& Message::operator=(fprime::Message& other) {
        header.reset(new fprime::Node(*(other.header)));
        body.reset(new fprime::Node(*(other.body)));
        trailer.reset(new fprime::Node(*(other.trailer)));
        _id = other._id;
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0xe8, %edi
callq 0x2f830
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x30c80
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x30870
movl $0xe8, %edi
callq 0x2f830
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x30c80
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x30870
movl $0xe8, %edi
callq 0x2f830
movq %rax, %r15
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x30c80
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x30870
addq $0x38, %r14
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x2ec40
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3e0ab
jmp 0x3e0ab
movq %rax, %rbx
movq %r15, %rdi
callq 0x2f6c0
movq %rbx, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Node.cpp
// Function: fprime::Node::appendChild(std::shared_ptr<fprime::Node>)
void Node::appendChild(fprime::Node::NodePtr nodePtr) {

        if (!nestingRule(_type, nodePtr->getType())) {
            throw InvalidNodeNesting(decodeNodeType(_type), decodeNodeType(nodePtr->getType()));
        }

        if (nodePtr->getType() == fprime::Node::GROUP_INSTANCE) {
            unsigned int instanceId = (this->childsByFieldId.size()) + 1;
            childsByFieldId[instanceId] = nodePtr;
        }

        if ((nodePtr->getType() == fprime::Node::REPEATING_GROUP) || (nodePtr->getType() == fprime::Node::FIELD_NODE)) {
            childsByFieldId[nodePtr->field->getId()] = nodePtr;
        }
        childsVector.push_back(nodePtr);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %edx
movq (%rsi), %rax
movl 0x8(%rax), %ecx
testl %edx, %edx
je 0x3f319
cmpl $0x3, %edx
je 0x3f319
cmpl $0x2, %edx
jne 0x3f372
cmpl $0x3, %ecx
jne 0x3f372
leaq 0x50(%r15), %rdi
movl 0x78(%r15), %eax
incl %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
callq 0x30610
movq (%r14), %rcx
movq %rcx, (%rax)
leaq 0x8(%rax), %rdi
leaq 0x8(%r14), %rsi
callq 0x30ce0
movq (%r14), %rax
movl 0x8(%rax), %ecx
jmp 0x3f322
cmpl $0x3, %ecx
je 0x3f372
testl %ecx, %ecx
je 0x3f372
decl %ecx
cmpl $0x1, %ecx
ja 0x3f358
leaq 0x50(%r15), %rbx
movq 0x28(%rax), %rdi
callq 0x2f6e0
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x2f1a0
movq (%r14), %rcx
movq %rcx, (%rax)
leaq 0x8(%rax), %rdi
leaq 0x8(%r14), %rsi
callq 0x30ce0
addq $0x38, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fd80
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x2eae0
movq %rax, %rbx
movl 0x8(%r15), %edx
leaq 0x8(%rsp), %rdi
callq 0x2ecd0
movq (%r14), %rax
movl 0x8(%rax), %edx
leaq 0x28(%rsp), %rdi
callq 0x2ecd0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x30800
xorl %ebp, %ebp
movq 0x31b2d(%rip), %rsi     # 0x70ee8
movq 0x3199e(%rip), %rdx     # 0x70d60
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f3e0
callq 0x2f6c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f3f3
callq 0x2f6c0
testb %bpl, %bpl
jne 0x3f415
jmp 0x3f41d
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f415
callq 0x2f6c0
jmp 0x3f415
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Node.cpp
// Function: fprime::Node::decodeNodeType[abi:cxx11](fprime::Node::NodeType)
string Node::decodeNodeType(NodeType t) {
        string typeStr;
        switch (t) {

            case ROOT_NODE:
            {
                typeStr = "ROOT_NODE";
                break;
            }
            case GROUP_INSTANCE:
            {
                typeStr = "GROUP_INSTANCE";
                break;
            }
            case FIELD_NODE:
            {
                typeStr = "FIELD_NODE";
                break;
            }
            case REPEATING_GROUP:
            {
                typeStr = "REPEATING_GROUP";
                break;
            }
            default:
            {
                typeStr = "INVALID";
                break;
            }
        }
        return typeStr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x4, %edx
jae 0x3f489
movl %edx, %eax
leaq 0x1be73(%rip), %rdx     # 0x5b2e8
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0x1c115(%rip), %rdx     # 0x5b598
movq (%rdx,%rax,8), %r8
jmp 0x3f496
movl $0x7, %r8d
leaq 0x1c0ca(%rip), %rcx     # 0x5b560
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x304d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3f4bb
callq 0x2f6c0
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Node.cpp
// Function: fprime::Node::appendGroupInstance()
void Node::appendGroupInstance() {
        if (_type != Node::NodeType::REPEATING_GROUP) {
            throw std::runtime_error("appendGroupInstance is only allowed for BlockRepeating.");
        } else {
            Node::NodePtr newInstance(new Node(Node::NodeType::GROUP_INSTANCE));
            newInstance->resolveComponent(this->componentPtr);
            this->appendChild(newInstance);
            this->value->set(boost::lexical_cast<string>(childsByFieldId.size()));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
cmpl $0x2, 0x8(%rdi)
jne 0x3f657
movq %rdi, %rbx
movl $0xe8, %edi
callq 0x2f830
movq %rax, %r14
movq %rax, %rdi
movl $0x3, %esi
callq 0x30880
leaq 0x30(%rsp), %r15
movq %r14, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e4a0
movq -0x8(%r15), %rdi
movq 0xd8(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0xe0(%rbx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x3f541
movq 0x31925(%rip), %rcx     # 0x70e58
cmpb $0x0, (%rcx)
je 0x3f53d
incl 0x8(%rax)
jmp 0x3f541
lock
incl 0x8(%rax)
leaq 0x18(%rsp), %rsi
callq 0x2fb00
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3f55a
callq 0x2f370
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x3f588
movq 0x318de(%rip), %rcx     # 0x70e58
cmpb $0x0, (%rcx)
je 0x3f584
incl 0x8(%rax)
jmp 0x3f588
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2fe90
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3f5a4
callq 0x2f370
movq 0x10(%rbx), %r14
movq 0x78(%rbx), %rax
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x5a(%rsp), %rcx
movq %rcx, 0x2e(%rcx)
leaq 0x82(%rsp), %rbx
movq %rbx, 0xe(%rbx)
leaq 0x98(%rsp), %rdi
movq %rax, (%rdi)
movq %rbx, 0x8(%rdi)
movb $0x30, 0x10(%rdi)
movl $0x30, 0x14(%rdi)
callq 0x2f760
movq %rax, 0x88(%rsp)
movq %rbx, 0x90(%rsp)
leaq 0x38(%rsp), %rdi
movq 0x8(%rdi), %rdx
subq %rax, %rbx
xorl %esi, %esi
movq %rax, %rcx
movq %rbx, %r8
callq 0x2fad0
movq (%r14), %rax
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x3f63b
callq 0x2f6c0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3f64a
callq 0x2f370
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1bd72(%rip), %rsi     # 0x5b3dd
movq %rax, %rdi
callq 0x2e800
movq 0x3195e(%rip), %rsi     # 0x70fd8
movq 0x3173f(%rip), %rdx     # 0x70dc0
movq %r14, %rdi
callq 0x308e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
jmp 0x3f6e4
jmp 0x3f6c3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x3f6aa
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3f6d5
callq 0x2f370
jmp 0x3f6d5
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f6c0
jmp 0x3f6e4
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x3f6d5
callq 0x2f6c0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3f6e4
callq 0x2f370
movq %rbx, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Node.cpp
// Function: fprime::Node::getChild(unsigned int)
fprime::Node::NodePtr Node::getChild(unsigned int fieldId) {
        if (_type == Node::NodeType::REPEATING_GROUP) {
            throw runtime_error("The operator () is not available for repeating groups. Use []");
        }
        NodeMap::iterator search = childsByFieldId.find(fieldId);

        if (search != childsByFieldId.end()) {
            return search->second;
        } else {
            stringstream msg;
            msg << "at Node.operator(): Node for field " << fieldId << " does not exists";
            throw InvalidField(msg.str());
        }

    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
cmpl $0x2, 0x8(%rsi)
je 0x3fce4
movl %edx, %ebx
movq 0x60(%rsi), %rcx
testq %rcx, %rcx
je 0x3fc5f
addq $0x58, %rsi
movq %rsi, %rax
xorl %edx, %edx
cmpl %ebx, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x3fc07
cmpq %rsi, %rax
je 0x3fc5f
cmpl %ebx, 0x20(%rax)
ja 0x3fc5f
movq 0x28(%rax), %rcx
movq %rcx, (%rdi)
movq 0x30(%rax), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x3fc50
movq 0x31216(%rip), %rcx     # 0x70e58
cmpb $0x0, (%rcx)
je 0x3fc4c
incl 0x8(%rax)
jmp 0x3fc50
lock
incl 0x8(%rax)
movq %rdi, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x2f130
leaq 0x38(%rsp), %r14
leaq 0x1b7de(%rip), %rsi     # 0x5b453
movl $0x23, %edx
movq %r14, %rdi
callq 0x2fb10
movl %ebx, %esi
movq %r14, %rdi
callq 0x2f090
leaq 0x1b7e4(%rip), %rsi     # 0x5b477
movl $0x10, %edx
movq %rax, %rdi
callq 0x2fb10
movl $0x28, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x305c0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ee70
xorl %ebp, %ebp
movq 0x310e3(%rip), %rsi     # 0x70db8
movq 0x31064(%rip), %rdx     # 0x70d40
movq %rbx, %rdi
callq 0x308e0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x1b71d(%rip), %rsi     # 0x5b415
movq %rax, %rdi
callq 0x2e800
movq 0x312d1(%rip), %rsi     # 0x70fd8
movq 0x310b2(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fd2c
callq 0x2f6c0
testb %bpl, %bpl
jne 0x3fd36
jmp 0x3fd50
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
jmp 0x3fd50
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
jmp 0x3fd6e
movq %rax, %r14
movq 0x30f29(%rip), %rsi     # 0x70c80
leaq 0x28(%rsp), %rdi
callq 0x2f190
leaq 0xa8(%rsp), %rdi
callq 0x2e700
movq %r14, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Node.cpp
// Function: fprime::Node::getInstance(unsigned int)
fprime::Node::NodePtr Node::getInstance(unsigned int instanceIndex) {
        if (_type != Node::NodeType::REPEATING_GROUP) {
            throw runtime_error("The operator[] is only available for repeating groups.");
        }

        NodeMap::iterator search = childsByFieldId.find(instanceIndex);
        if (search != childsByFieldId.end())
            return search->second;
        else
            throw runtime_error("at Node.operator[] : Invalid repeating group instance");
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, 0x8(%rsi)
jne 0x3fe08
movq 0x60(%rsi), %rcx
testq %rcx, %rcx
je 0x3fdea
addq $0x58, %rsi
movq %rsi, %rax
xorl %r8d, %r8d
cmpl %edx, 0x20(%rcx)
setb %r8b
cmovaeq %rcx, %rax
movq 0x10(%rcx,%r8,8), %rcx
testq %rcx, %rcx
jne 0x3fd94
cmpq %rsi, %rax
je 0x3fdea
cmpl %edx, 0x20(%rax)
ja 0x3fdea
movq 0x28(%rax), %rcx
movq %rcx, (%rdi)
movq 0x30(%rax), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x3fddf
movq 0x31087(%rip), %rcx     # 0x70e58
cmpb $0x0, (%rcx)
je 0x3fddb
incl 0x8(%rax)
jmp 0x3fddf
lock
incl 0x8(%rax)
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x1b6c1(%rip), %rsi     # 0x5b4bf
movq %rax, %rdi
callq 0x2e800
jmp 0x3fe24
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x1b66c(%rip), %rsi     # 0x5b488
movq %rax, %rdi
callq 0x2e800
movq 0x311ad(%rip), %rsi     # 0x70fd8
movq 0x30f8e(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
jmp 0x3fe3c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Protocol.cpp
// Function: fprime::Protocol::getComponent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
fprime::Component::ComponentPtr Protocol::getComponent(string compName) {
        auto search = components.find(compName);
        if (search == components.end())
            throw ComponentNotFound(compName);
        else
            return search->second;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xf0(%rsi), %rdi
movq %rdx, %rsi
callq 0x300d0
addq $0xf8, %r15
cmpq %r15, %rax
je 0x411dd
movq 0x40(%rax), %rcx
movq %rcx, (%rbx)
movq 0x48(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x411cf
movq 0x2fc97(%rip), %rcx     # 0x70e58
cmpb $0x0, (%rcx)
je 0x411cb
incl 0x8(%rax)
jmp 0x411cf
lock
incl 0x8(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2e8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2e9c0
xorl %ebp, %ebp
movq 0x2faf0(%rip), %rsi     # 0x70d10
movq 0x2fa49(%rip), %rdx     # 0x70c70
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x41241
callq 0x2f6c0
testb %bpl, %bpl
jne 0x4124b
jmp 0x41253
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
nop