LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
leaq 0x12(%rsp), %rax
movq %rax, 0x6(%rax)
leaq 0x14(%rsp), %rax
movq %rax, 0xc(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x4(%rax)
movq 0x10(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, 0xc(%rax)
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x2f6b0
testb %al, %al
je 0x3c2d4
movss 0xc(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x35b25(%rip), %rax     # 0x71e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x35a02(%rip), %rax     # 0x71cf0
movq %rax, 0x8(%rdi)
movq 0x35bdf(%rip), %rax     # 0x71ed8
movq %rax, 0x10(%rdi)
callq 0x2fd10
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305c0
jmp 0x3c31a
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c36f
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1fe63(%rip), %rsi     # 0x5c19f
movq %rax, %rdi
callq 0x2e800
movq 0x35c8d(%rip), %rsi     # 0x71fd8
movq 0x35a6e(%rip), %rdx     # 0x71dc0
movq %r14, %rdi
callq 0x308f0
movq %rax, %rbx
jmp 0x3c36a
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30750
movq %rbx, %rdi
callq 0x30a20
movq %rax, %rdi
callq 0x32108
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x12(%rsp), %rax
movq %rax, 0x6(%rax)
leaq 0x14(%rsp), %rax
movq %rax, 0xc(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x4(%rax)
movq 0x10(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, 0xc(%rax)
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x2e940
testb %al, %al
je 0x3c3db
movsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x35a1e(%rip), %rax     # 0x71e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x358fb(%rip), %rax     # 0x71cf0
movq %rax, 0x8(%rdi)
movq 0x35bd0(%rip), %rax     # 0x71fd0
movq %rax, 0x10(%rdi)
callq 0x2fd10
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305c0
jmp 0x3c421
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c476
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1fd5c(%rip), %rsi     # 0x5c19f
movq %rax, %rdi
callq 0x2e800
movq 0x35b86(%rip), %rsi     # 0x71fd8
movq 0x35967(%rip), %rdx     # 0x71dc0
movq %r14, %rdi
callq 0x308f0
movq %rax, %rbx
jmp 0x3c471
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30750
movq %rbx, %rdi
callq 0x30a20
movq %rax, %rdi
callq 0x32108
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x12(%rsp), %rax
movq %rax, 0x6(%rax)
leaq 0x14(%rsp), %rax
movq %rax, 0xc(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x4(%rax)
movq 0x10(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, 0xc(%rax)
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x304f0
testb %al, %al
je 0x3c4e0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x35919(%rip), %rax     # 0x71e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x357f6(%rip), %rax     # 0x71cf0
movq %rax, 0x8(%rdi)
movq 0x35a73(%rip), %rax     # 0x71f78
movq %rax, 0x10(%rdi)
callq 0x2fd10
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305c0
jmp 0x3c526
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c57b
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1fc57(%rip), %rsi     # 0x5c19f
movq %rax, %rdi
callq 0x2e800
movq 0x35a81(%rip), %rsi     # 0x71fd8
movq 0x35862(%rip), %rdx     # 0x71dc0
movq %r14, %rdi
callq 0x308f0
movq %rax, %rbx
jmp 0x3c576
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30750
movq %rbx, %rdi
callq 0x30a20
movq %rax, %rdi
callq 0x32108
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x12(%rsp), %rax
movq %rax, 0x6(%rax)
leaq 0x14(%rsp), %rax
movq %rax, 0xc(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x4(%rax)
movq 0x10(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, 0xc(%rax)
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x304f0
testb %al, %al
je 0x3c5e6
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x35813(%rip), %rax     # 0x71e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x356f0(%rip), %rax     # 0x71cf0
movq %rax, 0x8(%rdi)
movq 0x3596d(%rip), %rax     # 0x71f78
movq %rax, 0x10(%rdi)
callq 0x2fd10
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305c0
jmp 0x3c62c
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c681
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1fb51(%rip), %rsi     # 0x5c19f
movq %rax, %rdi
callq 0x2e800
movq 0x3597b(%rip), %rsi     # 0x71fd8
movq 0x3575c(%rip), %rdx     # 0x71dc0
movq %r14, %rdi
callq 0x308f0
movq %rax, %rbx
jmp 0x3c67c
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30750
movq %rbx, %rdi
callq 0x30a20
movq %rax, %rdi
callq 0x32108
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
fldz
fstpt (%rsp)
leaq 0x12(%rsp), %rax
movq %rax, 0x6(%rax)
leaq 0x14(%rsp), %rax
movq %rax, 0xc(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x4(%rax)
movq 0x10(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, 0xc(%rax)
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rsp, %rsi
callq 0x30f10
testb %al, %al
je 0x3c6e6
fldt (%rsp)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x35713(%rip), %rax     # 0x71e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x355f0(%rip), %rax     # 0x71cf0
movq %rax, 0x8(%rdi)
movq 0x35885(%rip), %rax     # 0x71f90
movq %rax, 0x10(%rdi)
callq 0x2fd10
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305c0
jmp 0x3c72c
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c781
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1fa51(%rip), %rsi     # 0x5c19f
movq %rax, %rdi
callq 0x2e800
movq 0x3587b(%rip), %rsi     # 0x71fd8
movq 0x3565c(%rip), %rdx     # 0x71dc0
movq %r14, %rdi
callq 0x308f0
movq %rax, %rbx
jmp 0x3c77c
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30750
movq %rbx, %rdi
callq 0x30a20
movq %rax, %rdi
callq 0x32108
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
leaq 0xe(%rsp), %rsi
movw $0x0, (%rsi)
leaq 0x12(%rsp), %rax
movq %rax, 0x6(%rax)
leaq 0x14(%rsp), %rax
movq %rax, 0xc(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x4(%rax)
movq 0x10(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, 0xc(%rax)
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x2f010
testb %al, %al
je 0x3c7ea
movzwl 0xe(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x3560f(%rip), %rax     # 0x71e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x354ec(%rip), %rax     # 0x71cf0
movq %rax, 0x8(%rdi)
movq 0x35591(%rip), %rax     # 0x71da0
movq %rax, 0x10(%rdi)
callq 0x2fd10
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305c0
jmp 0x3c830
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c885
movq %rbx, %rdi
callq 0x2e8b0
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1f94d(%rip), %rsi     # 0x5c19f
movq %rax, %rdi
callq 0x2e800
movq 0x35777(%rip), %rsi     # 0x71fd8
movq 0x35558(%rip), %rdx     # 0x71dc0
movq %r14, %rdi
callq 0x308f0
movq %rax, %rbx
jmp 0x3c880
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
callq 0x30750
movq %rbx, %rdi
callq 0x30a20
movq %rax, %rdi
callq 0x32108
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30c90
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x30880
movl $0xe8, %edi
callq 0x2f830
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x30c90
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x30880
movl $0xe8, %edi
callq 0x2f830
movq %rax, %r15
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x30c90
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x30880
addq $0x38, %r14
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x2ec40
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3e347
jmp 0x3e347
movq %rax, %rbx
movq %r15, %rdi
callq 0x2f6c0
movq %rbx, %rdi
callq 0x30a20
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %ecx
movq (%rsi), %rax
movl 0x8(%rax), %eax
cmpl $0x3, %ecx
je 0x3f591
cmpl $0x2, %ecx
je 0x3f5a0
testl %ecx, %ecx
jne 0x3f632
cmpl $0x3, %eax
setne %dl
testl %eax, %eax
setne %cl
andb %dl, %cl
jmp 0x3f5a6
cmpl $0x3, %eax
sete %cl
testb %cl, %cl
je 0x3f632
cmpl $0x3, %eax
jne 0x3f5dc
leaq 0x50(%r15), %rdi
movl 0x78(%r15), %eax
incl %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
callq 0x30620
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0x8(%rax), %rdi
leaq 0x8(%rbx), %rsi
callq 0x30cf0
movq (%rbx), %rax
movl 0x8(%rax), %ecx
decl %ecx
cmpl $0x1, %ecx
ja 0x3f618
leaq 0x50(%r15), %r14
movq 0x28(%rax), %rdi
callq 0x2f6e0
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x2f1a0
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0x8(%rax), %rdi
leaq 0x8(%rbx), %rsi
callq 0x30cf0
addq $0x38, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2fd90
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0x2eae0
movq %rax, %r14
movl 0x8(%r15), %edx
leaq 0x28(%rsp), %rdi
callq 0x2ecd0
movq (%rbx), %rax
movl 0x8(%rax), %edx
leaq 0x8(%rsp), %rdi
callq 0x2ecd0
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x30810
xorl %ebp, %ebp
movq 0x3286d(%rip), %rsi     # 0x71ee8
movq 0x326de(%rip), %rdx     # 0x71d60
movq %r14, %rdi
callq 0x308f0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f6a8
callq 0x2f6c0
jmp 0x3f6a8
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f6c3
callq 0x2f6c0
jmp 0x3f6c3
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3f6d0
movq %r14, %rdi
callq 0x2f150
movq %rbx, %rdi
callq 0x30a20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f73b
movl %edx, %eax
leaq 0x1cbc1(%rip), %rdx     # 0x5c2e8
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0x1ce63(%rip), %rdx     # 0x5c598
movq (%rdx,%rax,8), %r8
jmp 0x3f748
movl $0x7, %r8d
leaq 0x1ce18(%rip), %rcx     # 0x5c560
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x304e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3f76d
callq 0x2f6c0
movq %r14, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f909
movq %rdi, %rbx
movl $0xe8, %edi
callq 0x2f830
movq %rax, %r14
movq %rax, %rdi
movl $0x3, %esi
callq 0x30890
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 0x3f7f3
movq 0x32673(%rip), %rcx     # 0x71e58
cmpb $0x0, (%rcx)
je 0x3f7ef
incl 0x8(%rax)
jmp 0x3f7f3
lock
incl 0x8(%rax)
leaq 0x18(%rsp), %rsi
callq 0x2fb10
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3f80c
callq 0x2f370
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x3f83a
movq 0x3262c(%rip), %rcx     # 0x71e58
cmpb $0x0, (%rcx)
je 0x3f836
incl 0x8(%rax)
jmp 0x3f83a
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2fea0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3f856
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 0x2fae0
movq (%r14), %rax
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x3f8ed
callq 0x2f6c0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3f8fc
callq 0x2f370
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %r14
leaq 0x1cac0(%rip), %rsi     # 0x5c3dd
movq %rax, %rdi
callq 0x2e800
movq 0x326ac(%rip), %rsi     # 0x71fd8
movq 0x3248d(%rip), %rdx     # 0x71dc0
movq %r14, %rdi
callq 0x308f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f150
jmp 0x3f996
jmp 0x3f975
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x3f95c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3f987
callq 0x2f370
jmp 0x3f987
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f6c0
jmp 0x3f996
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x3f987
callq 0x2f6c0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3f996
callq 0x2f370
movq %rbx, %rdi
callq 0x30a20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ff1d
movl %edx, %ebx
movq 0x60(%rsi), %rcx
addq $0x58, %rsi
movq %rsi, %rax
testq %rcx, %rcx
je 0x3fece
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 0x3feb8
movq %rsi, %rcx
cmpq %rsi, %rax
je 0x3fee0
cmpl %ebx, 0x20(%rax)
cmovaq %rsi, %rax
movq %rax, %rcx
cmpq %rsi, %rcx
je 0x3ff4f
movq 0x28(%rcx), %rax
movq %rax, (%rdi)
movq 0x30(%rcx), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x3ff0e
movq 0x31f58(%rip), %rcx     # 0x71e58
cmpb $0x0, (%rcx)
je 0x3ff0a
incl 0x8(%rax)
jmp 0x3ff0e
lock
incl 0x8(%rax)
movq %rdi, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x1c4e4(%rip), %rsi     # 0x5c415
movq %rax, %rdi
callq 0x2e800
movq 0x32098(%rip), %rsi     # 0x71fd8
movq 0x31e79(%rip), %rdx     # 0x71dc0
movq %rbx, %rdi
callq 0x308f0
leaq 0x28(%rsp), %rdi
callq 0x2f130
leaq 0x38(%rsp), %r14
leaq 0x1c4ee(%rip), %rsi     # 0x5c453
movl $0x23, %edx
movq %r14, %rdi
callq 0x2fb20
movl %ebx, %esi
movq %r14, %rdi
callq 0x2f090
leaq 0x1c4f4(%rip), %rsi     # 0x5c477
movl $0x10, %edx
movq %rax, %rdi
callq 0x2fb20
movl $0x28, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x305d0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ee70
xorl %ebp, %ebp
movq 0x31df3(%rip), %rsi     # 0x71db8
movq 0x31d74(%rip), %rdx     # 0x71d40
movq %rbx, %rdi
callq 0x308f0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fff2
callq 0x2f6c0
jmp 0x3fff2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x40011
movq %rbx, %rdi
callq 0x2f150
jmp 0x40011
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
jmp 0x4002f
movq %rax, %r14
movq 0x31c68(%rip), %rsi     # 0x71c80
leaq 0x28(%rsp), %rdi
callq 0x2f190
leaq 0xa8(%rsp), %rdi
callq 0x2e700
movq %r14, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x400b8
movq 0x60(%rsi), %rcx
addq $0x58, %rsi
movq %rsi, %rax
testq %rcx, %rcx
je 0x4006d
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 0x40055
movq %rsi, %rcx
cmpq %rsi, %rax
je 0x4007f
cmpl %edx, 0x20(%rax)
cmovaq %rsi, %rax
movq %rax, %rcx
cmpq %rsi, %rcx
je 0x400d6
movq 0x28(%rcx), %rax
movq %rax, (%rdi)
movq 0x30(%rcx), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x400ad
movq 0x31db9(%rip), %rcx     # 0x71e58
cmpb $0x0, (%rcx)
je 0x400a9
incl 0x8(%rax)
jmp 0x400ad
lock
incl 0x8(%rax)
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x1c3bc(%rip), %rsi     # 0x5c488
movq %rax, %rdi
callq 0x2e800
jmp 0x400f2
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x1c3d5(%rip), %rsi     # 0x5c4bf
movq %rax, %rdi
callq 0x2e800
movq 0x31edf(%rip), %rsi     # 0x71fd8
movq 0x31cc0(%rip), %rdx     # 0x71dc0
movq %rbx, %rdi
callq 0x308f0
jmp 0x4010a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x300e0
addq $0xf8, %r15
cmpq %r15, %rax
je 0x414ad
movq 0x40(%rax), %rcx
movq %rcx, (%rbx)
movq 0x48(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x4149f
movq 0x309c7(%rip), %rcx     # 0x71e58
cmpb $0x0, (%rcx)
je 0x4149b
incl 0x8(%rax)
jmp 0x4149f
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 0x30820(%rip), %rsi     # 0x71d10
movq 0x30779(%rip), %rdx     # 0x71c70
movq %rbx, %rdi
callq 0x308f0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x41519
callq 0x2f6c0
jmp 0x41519
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x41526
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a20
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %rbx
movq 0x70(%rsi), %rdx
leaq 0x68(%rsi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x41568
movq %rax, %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x41551
movq %rax, %rdx
cmpq %rax, %rcx
je 0x4157a
cmpl %ebp, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x415b7
movq 0x28(%rdx), %rax
movq %rax, (%rdi)
movq 0x30(%rdx), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x415a8
movq 0x308be(%rip), %rcx     # 0x71e58
cmpb $0x0, (%rcx)
je 0x415a4
incl 0x8(%rax)
jmp 0x415a8
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 0x1b008(%rip), %rsi     # 0x5c5d5
movl $0x6, %edx
movq %r14, %rdi
callq 0x2fb20
movl %ebp, %esi
movq %r14, %rdi
callq 0x2f090
movq %rax, %r14
leaq 0x1b3b2(%rip), %rsi     # 0x5c9a0
movl $0x1c, %edx
movq %rax, %rdi
callq 0x2fb20
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x2fb20
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x305d0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x30700
xorl %ebp, %ebp
movq 0x30998(%rip), %rsi     # 0x71fd8
movq 0x30779(%rip), %rdx     # 0x71dc0
movq %rbx, %rdi
callq 0x308f0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4166d
callq 0x2f6c0
jmp 0x4166d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4167f
movq %rbx, %rdi
callq 0x2f150
jmp 0x4167f
movq %rax, %r14
movq 0x305fa(%rip), %rsi     # 0x71c80
leaq 0x28(%rsp), %rdi
callq 0x2f190
leaq 0xa8(%rsp), %rdi
callq 0x2e700
movq %r14, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/Protocol.cpp
// Function: fprime::Protocol::getMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
fprime::Message Protocol::getMessage(string msgId) {
        map<const string, fprime::Message>::iterator search;
        search = messages.find(msgId);
        if (search != messages.end())
            return search->second;
        else
            throw std::runtime_error("at Protocol.getMessage: Message type " + msgId + " does not exists in protocol " + version);

    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rsi), %rdi
movq %rdx, %rsi
callq 0x2f320
leaq 0xc8(%r14), %rcx
cmpq %rcx, %rax
je 0x45595
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ec60
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x173d0(%rip), %rsi     # 0x5c979
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x2f510
leaq 0x173e2(%rip), %rsi     # 0x5c99f
leaq 0x28(%rsp), %rdi
callq 0x30e60
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x455e8
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x455f5
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)
addq $0x8, %r14
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x303f0
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x30700
xorl %ebp, %ebp
movq 0x2c99d(%rip), %rsi     # 0x71fd8
movq 0x2c77e(%rip), %rdx     # 0x71dc0
movq %rbx, %rdi
callq 0x308f0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45668
callq 0x2f6c0
jmp 0x45668
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4567f
callq 0x2f6c0
jmp 0x4567f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4569a
callq 0x2f6c0
jmp 0x4569a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x456a7
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::create()
bool Socket::create() {
        m_sock = socket(AF_INET,
                SOCK_STREAM,
                0);

        if (!is_valid())
            return false;


        // TIME_WAIT - argh
        int on = 1;
        if (setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, (const char*) &on, sizeof ( on)) == -1)
            return false;


        return true;

    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2e490
movl %eax, 0x8(%r14)
cmpl $-0x1, %eax
je 0x46a39
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x30a50
cmpl $-0x1, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::accept(fprime::Socket*) const
bool Socket::accept(Socket* new_socket) const {
        int addr_length = sizeof ( m_addr);
        new_socket->m_sock = ::accept(m_sock, (sockaddr *) & m_addr, (socklen_t *) & addr_length);

        if (new_socket->m_sock <= 0)
            return false;
        else
            return true;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
movl 0x8(%rdi), %eax
leaq 0xc(%rdi), %rsi
movl %eax, %edi
callq 0x2e690
movl %eax, 0x8(%rbx)
testl %eax, %eax
setg %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Socket::send(const std::string s) const {
        int status = ::send(m_sock, s.c_str(), s.size(), 0);
        if (status == -1) {
            return false;
        } else {
            return true;
        }
    }

// Assembly:
pushq %rax
movl 0x8(%rdi), %edi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x2eb20
cmpl $-0x1, %eax
setne %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::recv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
int Socket::recv(std::string& s) const {
        char buf [ MAXRECV + 1 ];

        s = "";

        memset(buf, 0, MAXRECV + 1);

        int status = ::recv(m_sock, buf, MAXRECV, 0);

        if (status == -1) {
            std::cout << "status == -1   errno == " << errno << "  in Socket::recv\n";
            return 0;
        } else if (status == 0) {
            return 0;
        } else {
            s = buf;
            return status;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
leaq 0x14685(%rip), %rcx     # 0x5b198
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x304e0
movq %rsp, %r15
movl $0x401, %edx            # imm = 0x401
movq %r15, %rdi
xorl %esi, %esi
callq 0x2ecc0
movl 0x8(%r14), %edi
movl $0x400, %edx            # imm = 0x400
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x2e6e0
movq %rax, %r14
testl %r14d, %r14d
je 0x46bb8
cmpl $-0x1, %r14d
jne 0x46b96
movq 0x2b306(%rip), %rbx     # 0x71e60
leaq 0x15faf(%rip), %rsi     # 0x5cb10
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2fb20
callq 0x2e0d0
movl (%rax), %esi
movq %rbx, %rdi
callq 0x30990
leaq 0x15fa5(%rip), %rsi     # 0x5cb29
movl $0x12, %edx
movq %rax, %rdi
callq 0x2fb20
xorl %r14d, %r14d
jmp 0x46bb8
movq 0x8(%rbx), %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x2e980
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x304e0
movl %r14d, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::set_non_blocking(bool)
void Socket::set_non_blocking(const bool b) {

        int opts;

        opts = fcntl(m_sock,
                F_GETFL);

        if (opts < 0) {
            return;
        }

        if (b)
            opts = (opts | O_NONBLOCK);
        else
            opts = (opts & ~O_NONBLOCK);

        fcntl(m_sock,
                F_SETFL, opts);

    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x2ed10
testl %eax, %eax
js 0x46c65
movl %eax, %ecx
orl $0x800, %ecx            # imm = 0x800
andl $0x7ffff7ff, %eax       # imm = 0x7FFFF7FF
testb %bpl, %bpl
cmovnel %ecx, %eax
movl 0x8(%rbx), %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2ed10
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/SocketConnector.cpp
// Function: SocketConnector::SocketConnector(int)
SocketConnector::SocketConnector ( int port )
{
  if ( ! Socket::create() )
    {
      throw SocketException ( "Could not create server socket." );
    }

  if ( ! Socket::bind ( port ) )
    {
      throw SocketException ( "Could not bind to port." );
    }

  if ( ! Socket::listen() )
    {
      throw SocketException ( "Could not listen to socket." );
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2e070
movq 0x2b0cf(%rip), %rax     # 0x71d58
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2f360
testb %al, %al
je 0x46ccb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2f7e0
testb %al, %al
je 0x46d39
movq %rbx, %rdi
callq 0x30040
testb %al, %al
je 0x46da4
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15e64(%rip), %rsi     # 0x5cb4d
leaq 0x15e7c(%rip), %rdx     # 0x5cb6c
leaq 0x40(%rsp), %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2b2d3(%rip), %rsi     # 0x71ff8
movq 0x2afb4(%rip), %rdx     # 0x71ce0
movq %r15, %rdi
callq 0x308f0
jmp 0x46e0a
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15e16(%rip), %rsi     # 0x5cb6d
leaq 0x15e26(%rip), %rdx     # 0x5cb84
leaq 0x20(%rsp), %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2b265(%rip), %rsi     # 0x71ff8
movq 0x2af46(%rip), %rdx     # 0x71ce0
movq %r15, %rdi
callq 0x308f0
jmp 0x46e0a
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15dc3(%rip), %rsi     # 0x5cb85
leaq 0x15dd7(%rip), %rdx     # 0x5cba0
movq %rsp, %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2b1fd(%rip), %rsi     # 0x71ff8
movq 0x2aede(%rip), %rdx     # 0x71ce0
movq %r15, %rdi
callq 0x308f0
movq %rax, %r14
movq (%rsp), %rdi
jmp 0x46e29
jmp 0x46e35
movq %rax, %r14
movq 0x20(%rsp), %rdi
jmp 0x46e29
jmp 0x46e35
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x46e3b
callq 0x2f6c0
jmp 0x46e3b
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x46e4d
movq %r15, %rdi
callq 0x2f150
jmp 0x46e4d
movq %rax, %r14
movq %rbx, %rdi
callq 0x30df0
movq %r14, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/SocketConnector.cpp
// Function: SocketConnector::SocketConnector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
SocketConnector::SocketConnector ( std::string host, int port )
{
  if ( ! Socket::create() )
    {
      throw SocketException ( "Could not create client socket." );
    }

  if ( ! Socket::connect ( host, port ) )
    {
      throw SocketException ( "Could not bind to port." );
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2e070
movq 0x2aeda(%rip), %rax     # 0x71d58
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2f360
testb %al, %al
je 0x46ee0
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x2e8a0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x30180
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x46ece
callq 0x2f6c0
testb %bpl, %bpl
je 0x46f4b
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15ca3(%rip), %rsi     # 0x5cba1
leaq 0x15cbb(%rip), %rdx     # 0x5cbc0
leaq 0x40(%rsp), %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2b0be(%rip), %rsi     # 0x71ff8
movq 0x2ad9f(%rip), %rdx     # 0x71ce0
movq %r15, %rdi
callq 0x308f0
jmp 0x46fb1
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15c04(%rip), %rsi     # 0x5cb6d
leaq 0x15c14(%rip), %rdx     # 0x5cb84
movq %rsp, %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2b056(%rip), %rsi     # 0x71ff8
movq 0x2ad37(%rip), %rdx     # 0x71ce0
movq %r15, %rdi
callq 0x308f0
movq %rax, %r14
movq (%rsp), %rdi
jmp 0x46fc4
jmp 0x46fd0
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x46fd6
callq 0x2f6c0
jmp 0x46fd6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x46ffc
movq %r15, %rdi
callq 0x2f150
jmp 0x46ffc
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x46ffc
callq 0x2f6c0
jmp 0x46ffc
movq %rax, %r14
movq %rbx, %rdi
callq 0x30df0
movq %r14, %rdi
callq 0x30a20
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/StringDataHolder.cpp
// Function: fprime::StringDataHolder::validate()
bool StringDataHolder::validate() {
        try {
            int tmpData = boost::lexical_cast<unsigned int>(baseData);
            if (tmpData < 0)
                return false;
            else
                nativeData = tmpData;
                return true;
        } catch (boost::bad_lexical_cast& e) {
            return false;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
leaq 0x12(%rsp), %rax
movq %rax, 0x6(%rax)
leaq 0x14(%rsp), %rax
movq %rax, 0xc(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x4(%rax)
movq 0x10(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, 0xc(%rax)
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x30fa0
testb %al, %al
je 0x47411
movl 0xc(%rsp), %ecx
testl %ecx, %ecx
setns %al
js 0x47409
movl %ecx, 0x28(%rbx)
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x2a9e8(%rip), %rax     # 0x71e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x2a8c5(%rip), %rax     # 0x71cf0
movq %rax, 0x8(%rdi)
movq 0x2aaf2(%rip), %rax     # 0x71f28
movq %rax, 0x10(%rdi)
callq 0x2fd10
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305c0
jmp 0x47457
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x4746e
callq 0x2e8b0
callq 0x30750
xorl %eax, %eax
jmp 0x47409
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Features::strictMode()
Features Features::strictMode() {
  Features features;
  features.allowComments_ = false;
  features.strictRoot_ = true;
  features.allowDroppedNullPlaceholders_ = false;
  features.allowNumericKeys_ = false;
  return features;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x2f640
movl $0x100, (%rbx)          # imm = 0x100
movl $0x100, %eax            # imm = 0x100
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::normalizeEOL[abi:cxx11](char const*, char const*)
static std::string normalizeEOL(Reader::Location begin, Reader::Location end) {
  std::string normalized;
  normalized.reserve(end - begin);
  Reader::Location current = begin;
  while (current != end) {
    char c = *current++;
    if (c == '\r') {
      if (current != end && *current == '\n')
         // convert dos EOL
         ++current;
      // convert Mac EOL
      normalized += '\n';
    } else {
      normalized += c;
    }
  }
  return normalized;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rdx, %rsi
subq %r15, %rsi
callq 0x30560
cmpq %r14, %r15
je 0x495c7
leaq 0x1(%r15), %r13
movb (%r15), %al
cmpb $0xd, %al
jne 0x495b4
cmpq %r14, %r13
je 0x495a5
cmpb $0xa, 0x1(%r15)
jne 0x495a5
addq $0x2, %r15
movq %r15, %r13
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2f460
jmp 0x495bf
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2f460
movq %r13, %r15
cmpq %r14, %r13
jne 0x49587
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x495d6
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x495e6
callq 0x2f6c0
movq %r14, %rdi
callq 0x30a20
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Reader::recoverFromError(Json::Reader::TokenType)
bool Reader::recoverFromError(TokenType skipUntilToken) {
  int errorCount = int(errors_.size());
  Token skip;
  for (;;) {
    if (!readToken(skip))
      errors_.resize(errorCount); // discard errors caused by recovery
    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
      break;
  }
  errors_.resize(errorCount);
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x98(%rdi), %r13
movq 0x78(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rdi), %r12
movq 0x88(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rdi), %r15
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30640
movl 0x20(%rsp), %eax
cmpl %ebp, %eax
je 0x4988d
testl %eax, %eax
jne 0x49876
subq 0x8(%rsp), %r12
shrq $0x6, %r12
movl %r13d, %eax
subl 0x10(%rsp), %eax
negq %r13
movl $0x0, %ecx
sbbl %ecx, %ecx
leal (%rax,%rcx,8), %eax
andl $-0x8, %eax
subq 0x18(%rsp), %r15
shrq $0x6, %r15
addl %r12d, %r15d
addl %eax, %r15d
addq $0x50, %rbx
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x30100
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Reader::getLocationLineAndColumn[abi:cxx11](char const*) const
std::string Reader::getLocationLineAndColumn(Location location) const {
  int line, column;
  getLocationLineAndColumn(location, line, column);
  char buffer[18 + 16 + 16 + 1];
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
#if defined(WINCE)
  _snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
#else
  sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
#endif
#else
  snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
#endif
  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2e600
movl (%r14), %ecx
movl (%r15), %r8d
leaq 0x12fcc(%rip), %rdx     # 0x5d548
leaq 0x10(%rsp), %r14
movl $0x33, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x30650
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2e980
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e860
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::asBool() const
bool Value::asBool() const {
  switch (type_) {
  case booleanValue:
    return value_.bool_;
  case nullValue:
    return false;
  case intValue:
    return value_.int_ ? true : false;
  case uintValue:
    return value_.uint_ ? true : false;
  case realValue:
    return value_.real_ ? true : false;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to bool.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x4e2a5
leaq 0xebff(%rip), %rcx      # 0x5ce70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, (%rdi)
setne %al
jmp 0x4e29c
movb (%rdi), %al
jmp 0x4e29c
xorpd %xmm0, %xmm0
cmpneqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x4e29c
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ffe0
leaq 0xf74e(%rip), %rsi      # 0x5da07
movl $0x21, %edx
movq %rbx, %rdi
callq 0x2fb20
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x305d0
leaq 0x8(%rsp), %rdi
callq 0x30350
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e2fc
callq 0x2f6c0
jmp 0x4e2fc
jmp 0x4e2f9
movq %rax, %rbx
movq 0x23ae5(%rip), %rsi     # 0x71de8
leaq 0x28(%rsp), %rdi
callq 0x2ec30
leaq 0x98(%rsp), %rdi
callq 0x2e700
movq %rbx, %rdi
callq 0x30a20
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::operator>>(std::istream&, Json::Value&)
std::istream& operator>>(std::istream& sin, Value& root) {
  CharReaderBuilder b;
  std::string errs;
  bool ok = parseFromStream(b, sin, &root, &errs);
  if (!ok) {
    fprintf(stderr,
            "Error from reader: %s",
            errs.c_str());

    throwRuntimeError("reader error");
  }
  return sin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x30b90
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2e2a0
testb %al, %al
je 0x4f23f
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4f226
callq 0x2f6c0
leaq 0x48(%rsp), %rdi
callq 0x2f260
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x22c3a(%rip), %rax     # 0x71e80
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0xe442(%rip), %rsi      # 0x5d697
xorl %eax, %eax
callq 0x30270
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xe441(%rip), %rsi      # 0x5d6ad
leaq 0xe446(%rip), %rdx      # 0x5d6b9
leaq 0x28(%rsp), %rdi
callq 0x2e860
leaq 0x28(%rsp), %rdi
callq 0x2f490
jmp 0x4f29d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x4f2a0
callq 0x2f6c0
jmp 0x4f2a0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4f2af
callq 0x2f6c0
leaq 0x48(%rsp), %rdi
callq 0x2f260
movq %rbx, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::ValueIteratorBase::name[abi:cxx11]() const
std::string ValueIteratorBase::name() const {
  char const* key;
  char const* end;
  key = memberName(&end);
  if (!key) return std::string();
  return std::string(key, end);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x4f45d
movl 0x28(%rax), %edx
shrl $0x2, %edx
addq %rsi, %rdx
jmp 0x4f461
xorl %edx, %edx
xorl %esi, %esi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
testq %rsi, %rsi
je 0x4f477
movq %rbx, %rdi
callq 0x2e860
jmp 0x4f483
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq