LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xjrueda[P]fixprime/src/Field.cpp
// Function: fprime::Field::setDataType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Field::setDataType(string dataType) {
        if (!dataType.empty())
            _dataType = dataType;
        else
            throw std::runtime_error("at Field.setDataType: DataType attribute could not be empty.");

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xa2940
testb $0x1, %al
jne 0xbde73
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x972c0
jmp 0xbdec3
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x44f6f(%rip), %rsi     # 0x102dfd
callq 0x99380
jmp 0xbde95
movq -0x40(%rbp), %rdi
movq 0x75138(%rip), %rsi     # 0x132fd8
movq 0x74ef9(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9b9c0
jmp 0xbdec9
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x8(%rax)
je 0xbdf07
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x44f18(%rip), %rsi     # 0x102e3a
callq 0x99380
jmp 0xbdf29
movq -0x28(%rbp), %rdi
movq 0x750a4(%rip), %rsi     # 0x132fd8
movq 0x74e65(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
movq -0x10(%rbp), %rdi
callq 0xa3520
nop
// File: xjrueda[P]fixprime/src/Field.cpp
// Function: fprime::Field::getName[abi:cxx11]()
string Field::getName() {
        if (!_name.empty())
            return _name;
        else
            throw std::runtime_error("at Field.getName: Name attribute is empty.");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10, %rdi
callq 0xa2940
testb $0x1, %al
jne 0xbdfab
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
callq 0x998d0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x44e9b(%rip), %rsi     # 0x102e61
callq 0x99380
jmp 0xbdfcd
movq -0x40(%rbp), %rdi
movq 0x75000(%rip), %rsi     # 0x132fd8
movq 0x74dc1(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9b9c0
movq -0x18(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: xjrueda[P]fixprime/src/Field.cpp
// Function: fprime::Field::getDataType[abi:cxx11]()
string Field::getDataType() {
        if (!_dataType.empty())
            return _dataType;
        else
            throw std::runtime_error("at Field.getDataType: DataType attribute is empty.");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x30, %rdi
callq 0xa2940
testb $0x1, %al
jne 0xbe05b
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x30, %rsi
callq 0x998d0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x44e16(%rip), %rsi     # 0x102e8c
callq 0x99380
jmp 0xbe07d
movq -0x40(%rbp), %rdi
movq 0x74f50(%rip), %rsi     # 0x132fd8
movq 0x74d11(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9b9c0
movq -0x18(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: xjrueda[P]fixprime/src/Field.cpp
// Function: fprime::Field::addValidValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Field::addValidValue(string val, string desc) {
        if (!val.empty()) {
            _validValues[val] = desc;
        } else
            throw std::runtime_error("at Field.addValidValue: valid value attribute could not be empty.");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xa2940
testb $0x1, %al
jne 0xbe117
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
callq 0x97330
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x972c0
jmp 0xbe167
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x44d8d(%rip), %rsi     # 0x102ebf
callq 0x99380
jmp 0xbe139
movq -0x50(%rbp), %rdi
movq 0x74e94(%rip), %rsi     # 0x132fd8
movq 0x74c55(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9b9c0
jmp 0xbe16d
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: xjrueda[P]fixprime/src/Field.cpp
// Function: fprime::Field::validateValidValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Field::validateValidValue(string val) {
        map<string, string>::iterator search = _validValues.find(val);
        if (search != _validValues.end())
            return true;
        else
            return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x50, %rdi
callq 0x9a4a0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x50, %rdi
callq 0x9b7b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9ce90
testb $0x1, %al
jne 0xbe1c9
jmp 0xbe1cf
movb $0x1, -0x1(%rbp)
jmp 0xbe1d3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa4240
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x9cdd0
movq -0x88(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0xa15b0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa1f60
testb $0x1, %al
jne 0xc01fd
jmp 0xc0229
leaq -0x20(%rbp), %rdi
callq 0x9bdf0
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x9ed20
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movb $0x1, -0x7d(%rbp)
movl $0x10, %edi
callq 0x99e80
movq -0x90(%rbp), %rdx
movq %rax, -0xa8(%rbp)
leaq 0x42d0c(%rip), %rsi     # 0x102f58
leaq -0x70(%rbp), %rdi
callq 0x9cf50
jmp 0xc0257
leaq 0x42d22(%rip), %rdx     # 0x102f80
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x98100
jmp 0xc026d
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa2430
jmp 0xc027f
movq -0xa8(%rbp), %rdi
movb $0x0, -0x7d(%rbp)
movq 0x72d47(%rip), %rsi     # 0x132fd8
movq 0x72b08(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc02f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xc02d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xc02d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa4f00
leaq -0x70(%rbp), %rdi
callq 0xa4f00
testb $0x1, -0x7d(%rbp)
jne 0xc02e1
jmp 0xc02ed
movq -0xa8(%rbp), %rdi
callq 0x9b9c0
jmp 0xc02ef
movq -0x78(%rbp), %rdi
callq 0xa3520
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, %rax
movq -0x78(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x3e669(%rip), %rsi     # 0x102152
xorl %eax, %eax
movl %eax, %edx
callq 0xa4c70
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0xc3b50
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0x3f527(%rip), %rsi     # 0x10303f
callq 0x99380
jmp 0xc3b1f
movq -0x80(%rbp), %rdi
movq 0x6f4ae(%rip), %rsi     # 0x132fd8
movq 0x6f26f(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9b9c0
jmp 0xc3ca3
movq -0x70(%rbp), %rdi
leaq 0x3e5fd(%rip), %rsi     # 0x102158
xorl %eax, %eax
movl %eax, %edx
callq 0xa4c70
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0xc3bcf
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
leaq 0x3f4e0(%rip), %rsi     # 0x103071
callq 0x99380
jmp 0xc3b98
movq -0x88(%rbp), %rdi
movq 0x6f432(%rip), %rsi     # 0x132fd8
movq 0x6f1f3(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9b9c0
jmp 0xc3ca3
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x9b8b0
movq -0x70(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x9b8b0
movq -0xa8(%rbp), %rcx
movq -0x70(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, %rdi
movq -0x30(%rbp), %rax
subq %rdi, %rax
addq %rax, %rcx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x9dfa0
movq -0x98(%rbp), %rdi
callq 0x9cca0
movq -0x98(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x9ab40
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
xorl %edx, %edx
callq 0x9ce30
movb %al, -0x89(%rbp)
jmp 0xc3c59
movb -0x89(%rbp), %al
movb %al, -0x51(%rbp)
movzbl -0x51(%rbp), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xa9(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa4f00
movb -0xa9(%rbp), %al
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa4f00
movq -0x20(%rbp), %rdi
callq 0xa3520
nopl (%rax)
// File: xjrueda[P]fixprime/include/FixParser.h
// Function: fprime::FixParser::FlatMessage::getMsgType[abi:cxx11]()
string getMsgType() {
                TagsMap::iterator search = tagsMap.find(35);
                if (search != tagsMap.end())
                    return search->second;
                else
                    throw runtime_error("at SerializedMessage.getMsgType: message type not specified.");
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x30, %rdi
movl $0x23, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x99190
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x30, %rdi
callq 0xa4550
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x981a0
testb $0x1, %al
jne 0xc3e8f
jmp 0xc3eb2
leaq -0x18(%rbp), %rdi
callq 0x9b4d0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x998d0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x3f1d8(%rip), %rsi     # 0x1030a5
callq 0x99380
jmp 0xc3ed4
movq -0x58(%rbp), %rdi
movq 0x6f0f9(%rip), %rsi     # 0x132fd8
movq 0x6eeba(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x9b9c0
movq -0x30(%rbp), %rdi
callq 0xa3520
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x6d225(%rip), %rcx     # 0x132ca0
movq %rcx, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x9adf0
jmp 0xc5a9e
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9b260
jmp 0xc5aad
leaq -0x18(%rbp), %rdi
callq 0xa3410
jmp 0xc5ab8
movl $0x2710, %edi           # imm = 0x2710
callq 0xa0c10
jmp 0xc5ac4
movq -0x68(%rbp), %rax
movb 0x1d8(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xa1aa0
jmp 0xc5b49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xc5b01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xa1aa0
movl -0x54(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc5b54
movq -0x50(%rbp), %rdi
callq 0x99540
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0xc5b29
movb $0x0, -0x1(%rbp)
callq 0xa2520
jmp 0xc5b49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0xa2520
jmp 0xc5b47
jmp 0xc5b54
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
callq 0x9e680
movl %eax, -0x2c(%rbp)
jmp 0xc6762
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xc67a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc67ab
movq -0x18(%rbp), %rdi
callq 0x99540
movq %rax, -0x28(%rbp)
movb $0x0, -0x1(%rbp)
callq 0xa2520
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x9e680
movl %eax, -0x24(%rbp)
jmp 0xc686e
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc6903
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x3c958(%rip), %rsi     # 0x10320f
callq 0x99380
jmp 0xc68be
movq -0x30(%rbp), %rdi
movq 0x6c70f(%rip), %rsi     # 0x132fd8
movq 0x6c4d0(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc6914
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xc68fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa2520
jmp 0xc6901
jmp 0xc6903
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x99560
movl %eax, -0x24(%rbp)
jmp 0xc693e
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc69d3
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x3c888(%rip), %rsi     # 0x10320f
callq 0x99380
jmp 0xc698e
movq -0x30(%rbp), %rdi
movq 0x6c63f(%rip), %rsi     # 0x132fd8
movq 0x6c400(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc69e4
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xc69ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa2520
jmp 0xc69d1
jmp 0xc69d3
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x9e4c0
movss %xmm0, -0x24(%rbp)
jmp 0xc6a10
movss -0x24(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc6aa7
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x3c7b4(%rip), %rsi     # 0x10320f
callq 0x99380
jmp 0xc6a62
movq -0x30(%rbp), %rdi
movq 0x6c56b(%rip), %rsi     # 0x132fd8
movq 0x6c32c(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc6ab8
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xc6a9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa2520
jmp 0xc6aa5
jmp 0xc6aa7
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x9f6d0
movsd %xmm0, -0x28(%rbp)
jmp 0xc6ae0
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc6b77
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x3c6e4(%rip), %rsi     # 0x10320f
callq 0x99380
jmp 0xc6b32
movq -0x30(%rbp), %rdi
movq 0x6c49b(%rip), %rsi     # 0x132fd8
movq 0x6c25c(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc6b88
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xc6b6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa2520
jmp 0xc6b75
jmp 0xc6b77
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x9ed50
movq %rax, -0x28(%rbp)
jmp 0xc6baf
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc6c45
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x3c616(%rip), %rsi     # 0x10320f
callq 0x99380
jmp 0xc6c00
movq -0x30(%rbp), %rdi
movq 0x6c3cd(%rip), %rsi     # 0x132fd8
movq 0x6c18e(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc6c56
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xc6c3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa2520
jmp 0xc6c43
jmp 0xc6c45
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x9ed50
movq %rax, -0x28(%rbp)
jmp 0xc6c7f
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc6d15
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x3c546(%rip), %rsi     # 0x10320f
callq 0x99380
jmp 0xc6cd0
movq -0x30(%rbp), %rdi
movq 0x6c2fd(%rip), %rsi     # 0x132fd8
movq 0x6c0be(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc6d26
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xc6d0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa2520
jmp 0xc6d13
jmp 0xc6d15
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x9a9d0
fstpt -0x2c(%rbp)
jmp 0xc6d4e
fldt -0x2c(%rbp)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc6de3
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x3c478(%rip), %rsi     # 0x10320f
callq 0x99380
jmp 0xc6d9e
movq -0x38(%rbp), %rdi
movq 0x6c22f(%rip), %rsi     # 0x132fd8
movq 0x6bff0(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc6df4
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xc6dda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa2520
jmp 0xc6de1
jmp 0xc6de3
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xa2a90
movw %ax, -0x22(%rbp)
jmp 0xc6e1f
movw -0x22(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc6eb5
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x3c3a6(%rip), %rsi     # 0x10320f
callq 0x99380
jmp 0xc6e70
movq -0x30(%rbp), %rdi
movq 0x6c15d(%rip), %rsi     # 0x132fd8
movq 0x6bf1e(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xc6ec6
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xc6eac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa2520
jmp 0xc6eb3
jmp 0xc6eb5
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0xe8, %edi
callq 0x9dc00
movq %rax, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x98560
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xa4060
jmp 0xca55d
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0xa2db0
movq -0x40(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
movl $0xe8, %edi
callq 0x9dc00
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x98560
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xa4060
jmp 0xca5a3
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0xa2db0
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x70(%rbp)
movl $0xe8, %edi
callq 0x9dc00
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x98560
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xa4060
jmp 0xca5e9
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0xa2db0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x972c0
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9d660
jmp 0xca658
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9d660
jmp 0xca658
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9d660
movq -0x18(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x70(%rbp)
callq 0x98080
movq %rax, %rdi
callq 0xa0820
movq -0x78(%rbp), %rdi
movl -0x70(%rbp), %esi
movl %eax, %edx
callq 0x973d0
testb $0x1, %al
jne 0xcc87e
movb $0x1, -0x61(%rbp)
movl $0x48, %edi
callq 0x99e80
movq -0x78(%rbp), %rsi
movq %rax, -0x90(%rbp)
movl 0x8(%rsi), %edx
leaq -0x30(%rbp), %rdi
callq 0x9a650
jmp 0xcc7d0
movq -0x80(%rbp), %rdi
callq 0x98080
movq %rax, %rdi
callq 0xa0820
movq -0x78(%rbp), %rsi
movl %eax, %edx
leaq -0x60(%rbp), %rdi
callq 0x9a650
jmp 0xcc7f2
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0xa2b80
jmp 0xcc808
movq -0x90(%rbp), %rdi
movb $0x0, -0x61(%rbp)
movq 0x666b6(%rip), %rsi     # 0x132ed0
movq 0x6650f(%rip), %rdx     # 0x132d30
callq 0xa2fe0
jmp 0xcc95f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xcc865
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xcc85c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa4f00
leaq -0x30(%rbp), %rdi
callq 0xa4f00
testb $0x1, -0x61(%rbp)
jne 0xcc86d
jmp 0xcc879
movq -0x90(%rbp), %rdi
callq 0x9b9c0
jmp 0xcc956
movq -0x80(%rbp), %rdi
callq 0x98080
movq %rax, %rdi
callq 0xa0820
cmpl $0x3, %eax
jne 0xcc8c5
movq -0x78(%rbp), %rdi
addq $0x50, %rdi
callq 0xa4910
movq -0x78(%rbp), %rdi
addq $0x1, %rax
movl %eax, -0x68(%rbp)
addq $0x50, %rdi
leaq -0x68(%rbp), %rsi
callq 0xa20e0
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x9ec30
movq -0x80(%rbp), %rdi
callq 0x98080
movq %rax, %rdi
callq 0xa0820
cmpl $0x2, %eax
je 0xcc8f1
movq -0x80(%rbp), %rdi
callq 0x98080
movq %rax, %rdi
callq 0xa0820
cmpl $0x1, %eax
jne 0xcc93c
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x98(%rbp)
callq 0x98080
movq %rax, %rdi
addq $0x28, %rdi
callq 0x9d390
movq %rax, %rdi
callq 0x9d720
movq -0x98(%rbp), %rdi
movl %eax, -0x6c(%rbp)
leaq -0x6c(%rbp), %rsi
callq 0x9bbb0
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x9ec30
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
callq 0x9f5c0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xa3520
nop
// File: xjrueda[P]fixprime/src/Node.cpp
// Function: fprime::Node::nestingRule(fprime::Node::NodeType, fprime::Node::NodeType)
bool Node::nestingRule(NodeType parentType, NodeType nestedType) {
        bool result = false;
        switch (parentType) {
            case ROOT_NODE:
            case GROUP_INSTANCE:
            {
                if (nestedType == ROOT_NODE || nestedType == GROUP_INSTANCE)
                    result = false;
                else
                    result = true;
                break;
            }
            case FIELD_NODE:
            {
                result = false;
                break;
            }
            case REPEATING_GROUP:
            {
                if (nestedType != GROUP_INSTANCE)
                    result = false;
                else
                    result = true;
                break;
            }
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0xcc9c3
movq -0x20(%rbp), %rax
leaq 0x369ae(%rip), %rcx     # 0x103338
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, -0x10(%rbp)
je 0xcc99f
cmpl $0x3, -0x10(%rbp)
jne 0xcc9a5
movb $0x0, -0x11(%rbp)
jmp 0xcc9a9
movb $0x1, -0x11(%rbp)
jmp 0xcc9c3
movb $0x0, -0x11(%rbp)
jmp 0xcc9c3
cmpl $0x3, -0x10(%rbp)
je 0xcc9bd
movb $0x0, -0x11(%rbp)
jmp 0xcc9c1
movb $0x1, -0x11(%rbp)
jmp 0xcc9c3
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xa0780
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0xcca7f
movq -0x30(%rbp), %rax
leaq 0x36939(%rip), %rcx     # 0x103348
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x40(%rbp), %rdi
leaq 0x36b79(%rip), %rsi     # 0x10359c
callq 0xa0390
jmp 0xcca2a
jmp 0xcca93
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xa4f00
jmp 0xccab0
movq -0x40(%rbp), %rdi
leaq 0x36b58(%rip), %rsi     # 0x1035a6
callq 0xa0390
jmp 0xcca55
jmp 0xcca93
movq -0x40(%rbp), %rdi
leaq 0x36b53(%rip), %rsi     # 0x1035b5
callq 0xa0390
jmp 0xcca69
jmp 0xcca93
movq -0x40(%rbp), %rdi
leaq 0x36b4a(%rip), %rsi     # 0x1035c0
callq 0xa0390
jmp 0xcca7d
jmp 0xcca93
movq -0x40(%rbp), %rdi
leaq 0x36b46(%rip), %rsi     # 0x1035d0
callq 0xa0390
jmp 0xcca91
jmp 0xcca93
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xccaa6
movq -0x40(%rbp), %rdi
callq 0xa4f00
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xa3520
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $0x2, 0x8(%rax)
je 0xccb30
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0x36955(%rip), %rsi     # 0x10344d
callq 0x99380
jmp 0xccaff
movq -0x80(%rbp), %rdi
movq 0x664ce(%rip), %rsi     # 0x132fd8
movq 0x6628f(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
jmp 0xcccc2
movl $0xe8, %edi
callq 0x9dc00
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movl $0x3, %esi
callq 0xa2e10
jmp 0xccb53
movq -0x88(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa2850
movq -0xa0(%rbp), %rdi
callq 0x98080
movq -0x78(%rbp), %rsi
movq %rax, -0x98(%rbp)
addq $0xd8, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x9cbf0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x9eb00
jmp 0xccbad
leaq -0x38(%rbp), %rdi
callq 0x9f150
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x97cd0
movq -0x78(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x9fad0
jmp 0xccbdc
leaq -0x48(%rbp), %rdi
callq 0x997e0
movq -0x78(%rbp), %rdi
addq $0x10, %rdi
callq 0x9a6e0
movq -0x78(%rbp), %rdi
movq %rax, -0xb0(%rbp)
addq $0x50, %rdi
callq 0xa4910
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9f040
jmp 0xccc19
movq -0xb0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x68(%rbp), %rsi
callq *%rax
jmp 0xccc2f
leaq -0x68(%rbp), %rdi
callq 0xa4f00
leaq -0x28(%rbp), %rdi
callq 0x997e0
jmp 0xcccb9
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9d660
jmp 0xcccc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9f150
jmp 0xcccae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x997e0
jmp 0xcccae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xcccae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa4f00
leaq -0x28(%rbp), %rdi
callq 0x997e0
jmp 0xcccc2
addq $0xb0, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xa3520
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f0(%rbp)
cmpl $0x2, 0x8(%rax)
jne 0xcd444
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x208(%rbp)
leaq 0x3607f(%rip), %rsi     # 0x103485
callq 0x99380
jmp 0xcd40d
movq -0x208(%rbp), %rdi
movq 0x65bbd(%rip), %rsi     # 0x132fd8
movq 0x6597e(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x208(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9b9c0
jmp 0xcd5c2
movq -0x1f0(%rbp), %rdi
addq $0x50, %rdi
leaq -0x14(%rbp), %rsi
callq 0x9ba70
movq -0x1f0(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x50, %rdi
callq 0x99340
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9d6f0
testb $0x1, %al
jne 0xcd483
jmp 0xcd4af
leaq -0x30(%rbp), %rdi
callq 0xa4400
movq -0x200(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x97cd0
movq -0x1f8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x1c0(%rbp), %rdi
callq 0x9b940
leaq -0x1b0(%rbp), %rdi
leaq 0x35ffa(%rip), %rsi     # 0x1034c3
callq 0x9dba0
movq %rax, -0x210(%rbp)
jmp 0xcd4d7
movq -0x210(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa0150
movq %rax, -0x218(%rbp)
jmp 0xcd4ef
movq -0x218(%rbp), %rdi
leaq 0x35fea(%rip), %rsi     # 0x1034e7
callq 0x9dba0
jmp 0xcd504
movb $0x1, -0x1e1(%rbp)
movl $0x28, %edi
callq 0x99e80
movq %rax, -0x220(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x9da80
jmp 0xcd531
movq -0x220(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x9ae70
jmp 0xcd546
movq -0x220(%rbp), %rdi
movb $0x0, -0x1e1(%rbp)
movq 0x6583d(%rip), %rsi     # 0x132d98
movq 0x657ae(%rip), %rdx     # 0x132d10
callq 0xa2fe0
jmp 0xcd5cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xcd5b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xcd59d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0xa4f00
testb $0x1, -0x1e1(%rbp)
jne 0xcd5a8
jmp 0xcd5b4
movq -0x220(%rbp), %rdi
callq 0x9b9c0
jmp 0xcd5b6
leaq -0x1c0(%rbp), %rdi
callq 0x9bca0
movq -0x20(%rbp), %rdi
callq 0xa3520
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x2, 0x8(%rax)
je 0xcd64f
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x35ee1(%rip), %rsi     # 0x1034f8
callq 0x99380
jmp 0xcd61e
movq -0x58(%rbp), %rdi
movq 0x659af(%rip), %rsi     # 0x132fd8
movq 0x65770(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9b9c0
jmp 0xcd6f9
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
leaq -0x14(%rbp), %rsi
callq 0x9ba70
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x50, %rdi
callq 0x99340
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9d6f0
testb $0x1, %al
jne 0xcd688
jmp 0xcd6ab
leaq -0x30(%rbp), %rdi
callq 0xa4400
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x97cd0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x35e69(%rip), %rsi     # 0x10352f
callq 0x99380
jmp 0xcd6cd
movq -0x60(%rbp), %rdi
movq 0x65900(%rip), %rsi     # 0x132fd8
movq 0x656c1(%rip), %rdx     # 0x132da0
callq 0xa2fe0
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9b9c0
movq -0x20(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x78(%rbp)
movq %rsi, %rax
movq -0x78(%rbp), %rsi
movq %rdi, -0x70(%rbp)
movq %rdi, %rcx
movq %rcx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0xf0, %rdi
callq 0xa0330
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xf0, %rdi
callq 0x98290
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x988e0
testb $0x1, %al
jne 0xd187f
jmp 0xd1902
movb $0x1, -0x55(%rbp)
movl $0x28, %edi
callq 0x99e80
movq -0x78(%rbp), %rsi
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x998d0
jmp 0xd18a0
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x99990
jmp 0xd18af
movq -0x80(%rbp), %rdi
movb $0x0, -0x55(%rbp)
movq 0x6141a(%rip), %rsi     # 0x132cd8
movq 0x6134b(%rip), %rdx     # 0x132c10
callq 0xa2fe0
jmp 0xd1931
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xd18ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa4f00
testb $0x1, -0x55(%rbp)
jne 0xd18f7
jmp 0xd1900
movq -0x80(%rbp), %rdi
callq 0x9b9c0
jmp 0xd1928
leaq -0x20(%rbp), %rdi
callq 0xa05d0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x9cbf0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: xjrueda[P]fixprime/src/Protocol.cpp
// Function: fprime::Protocol::getField(unsigned int)
fprime::Field::FieldPtr Protocol::getField(unsigned int id) {
        map<unsigned int, fprime::Field::FieldPtr >::iterator search;
        search = fields.find(id);
        if (search != fields.end())
            return search->second;
        else {
            stringstream msg;
            msg << "Field " << id << "does not exists in protocol " << version;
            throw runtime_error(msg.str());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x208(%rbp)
movq %rdi, %rax
movq %rax, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa4d70
movq -0x1f8(%rbp), %rdi
addq $0x60, %rdi
leaq -0x14(%rbp), %rsi
callq 0x9ef30
movq -0x1f8(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x60, %rdi
callq 0xa0cb0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa17c0
testb $0x1, %al
jne 0xd19c2
jmp 0xd19ee
leaq -0x20(%rbp), %rdi
callq 0x983d0
movq -0x208(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0xa06b0
movq -0x200(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
leaq -0x1b8(%rbp), %rdi
callq 0x9b940
leaq -0x1a8(%rbp), %rdi
leaq 0x31c1a(%rip), %rsi     # 0x103622
callq 0x9dba0
movq %rax, -0x210(%rbp)
jmp 0xd1a16
movq -0x210(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa0150
movq %rax, -0x218(%rbp)
jmp 0xd1a2e
movq -0x218(%rbp), %rdi
leaq 0x31fb1(%rip), %rsi     # 0x1039ed
callq 0x9dba0
movq %rax, -0x220(%rbp)
jmp 0xd1a4a
movq -0x220(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
addq $0x8, %rsi
callq 0x9cf40
jmp 0xd1a63
movb $0x1, -0x1e9(%rbp)
movl $0x10, %edi
callq 0x99e80
movq %rax, -0x228(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x9da80
jmp 0xd1a90
movq -0x228(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0xa2430
jmp 0xd1aa5
movq -0x228(%rbp), %rdi
movb $0x0, -0x1e9(%rbp)
movq 0x6151e(%rip), %rsi     # 0x132fd8
movq 0x612df(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xd1b3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0xd1b27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0xd1b0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0xa4f00
testb $0x1, -0x1e9(%rbp)
jne 0xd1b19
jmp 0xd1b25
movq -0x228(%rbp), %rdi
callq 0x9b9c0
jmp 0xd1b27
leaq -0x1b8(%rbp), %rdi
callq 0x9bca0
movq -0x1c0(%rbp), %rdi
callq 0xa3520
nop