LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&)
virtual bool sectionStarted (
            SectionInfo const& sectionInfo,
            Counts& assertions
        )
        {
            std::ostringstream oss;
            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;

            if( !m_testCaseTracker->enterSection( oss.str() ) )
                return false;

            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;

            m_reporter->sectionStarting( sectionInfo );

            assertions = m_totals.assertions;

            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0xb700
movq -0x1e0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb4c0
movq %rax, -0x1d8(%rbp)
jmp 0x380fe
movq -0x1d8(%rbp), %rdi
leaq 0x406c4(%rip), %rsi     # 0x787d0
callq 0xb520
movq %rax, -0x1f0(%rbp)
jmp 0x3811a
movq -0x1f0(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
callq 0xcef0
jmp 0x38130
movq -0x1e8(%rbp), %rdi
addq $0x40, %rdi
callq 0x3a3d0
movq %rax, -0x1f8(%rbp)
jmp 0x38149
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xb560
jmp 0x3815e
movq -0x1f8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x3a3f0
movb %al, -0x1f9(%rbp)
jmp 0x38179
movb -0x1f9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1fa(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xb330
movb -0x1fa(%rbp), %al
testb $0x1, %al
jne 0x3819f
jmp 0x381ec
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
jmp 0x38267
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x38281
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xb330
jmp 0x38281
movq -0x1e8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
addq $0x200, %rdi            # imm = 0x200
callq 0x3a390
jmp 0x38209
movq -0x1e8(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x37d10
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
jmp 0x3822e
movq -0x1e8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x178(%rcx), %rdx
movq %rdx, (%rax)
movq 0x180(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x188(%rcx), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xb100
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0xb100
movq -0x1a0(%rbp), %rdi
callq 0xb920
nopl (%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::sectionEnded(Catch::SectionInfo const&, Catch::Counts const&, double)
virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) {
            if( std::uncaught_exception() ) {
                m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) );
                return;
            }

            Counts assertions = m_totals.assertions - prevAssertions;
            bool missingAssertions = testForMissingAssertions( assertions );

            m_testCaseTracker->leaveSection();

            m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) );
            m_messages.clear();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
callq 0xb070
testb $0x1, %al
jne 0x382d2
jmp 0x3834f
movq -0x178(%rbp), %rax
addq $0x250, %rax            # imm = 0x250
movq %rax, -0x188(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x3b3a0
movq -0x188(%rbp), %rdi
movq -0x180(%rbp), %rsi
callq 0x3b370
jmp 0x3831b
leaq -0xa8(%rbp), %rdi
callq 0x38900
jmp 0x38424
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x38900
jmp 0x3844b
movq -0x178(%rbp), %rsi
addq $0x178, %rsi            # imm = 0x178
movq -0x18(%rbp), %rdx
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x3b400
movq -0x178(%rbp), %rdi
movq -0x1a0(%rbp), %rsi
callq 0x3b470
movq -0x178(%rbp), %rdi
movb %al, -0xd1(%rbp)
addq $0x40, %rdi
callq 0x3a3d0
movq %rax, %rdi
callq 0x3b510
movq -0x178(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x37d10
movq -0x1a0(%rbp), %rdx
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
movzbl -0xd1(%rbp), %ecx
andl $0x1, %ecx
leaq -0x170(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x3b580
movq -0x198(%rbp), %rdi
movq -0x190(%rbp), %rsi
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
jmp 0x38405
leaq -0x170(%rbp), %rdi
callq 0x12250
movq -0x178(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x39090
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x12250
movq -0xb0(%rbp), %rdi
callq 0xb920
nopw (%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TestCaseTracker::enterSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool enterSection( std::string const& name ) {
            TrackedSection* child = m_currentSection->acquireChild( name );
            if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed )
                return false;

            m_currentSection = child;
            m_currentSection->enter();
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a460
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
testb $0x1, 0x68(%rax)
jne 0x3a434
movq -0x20(%rbp), %rdi
callq 0x3a5c0
cmpl $0x3, %eax
jne 0x3a43a
movb $0x0, -0x1(%rbp)
jmp 0x3a453
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq 0x60(%rax), %rdi
callq 0x3a5e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TrackedSection::acquireChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TrackedSection* acquireChild( std::string const& childName ) {
            if( TrackedSection* child = findChild( childName ) )
                return child;
            m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) );
            return findChild( childName );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x128(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3a610
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3a49f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a598
movq -0x128(%rbp), %rdx
movq %rdx, %rax
addq $0x28, %rax
movq %rax, -0x140(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0x138(%rbp)
leaq -0x100(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x3a710
movq -0x138(%rbp), %rsi
movq -0x130(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x3a6d0
jmp 0x3a4ee
movq -0x140(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3a690
movb %dl, -0x149(%rbp)
movq %rax, -0x148(%rbp)
jmp 0x3a510
movb -0x149(%rbp), %al
movq -0x148(%rbp), %rcx
movq %rcx, -0x120(%rbp)
movb %al, -0x118(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3a760
leaq -0x100(%rbp), %rdi
callq 0x38a70
movq -0x128(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a610
movq %rax, -0x8(%rbp)
jmp 0x3a598
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x3a58a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3a760
leaq -0x100(%rbp), %rdi
callq 0x38a70
jmp 0x3a5a5
movq -0x8(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0xb920
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TrackedSection::findChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TrackedSection* findChild( std::string const& childName ) {
            TrackedSections::iterator it = m_children.find( childName );
            return it != m_children.end()
                ? &it->second
                : NULL;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x3a790
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
callq 0x3a7f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3a7c0
testb $0x1, %al
jne 0x3a65d
jmp 0x3a670
leaq -0x18(%rbp), %rdi
callq 0x3a820
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x3a678
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x3a678
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::testForMissingAssertions(Catch::Counts&)
bool testForMissingAssertions( Counts& assertions ) {
            if( assertions.total() != 0 ||
                    !m_config->warnAboutMissingAssertions() ||
                    m_testCaseTracker->currentSectionHasChildren() )
                return false;
            m_totals.assertions.failed++;
            assertions.failed++;
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3bf90
cmpq $0x0, %rax
jne 0x3b4d1
movq -0x20(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x14910
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0x3b4b6
jmp 0x3b4d1
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x3a3d0
movq %rax, %rdi
callq 0x3bfb0
testb $0x1, %al
jne 0x3b4d1
jmp 0x3b4d7
movb $0x0, -0x1(%rbp)
jmp 0x3b501
movq -0x20(%rbp), %rax
movq 0x180(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x180(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TestCaseTracker::leaveSection()
void leaveSection() {
            m_currentSection->leave();
            m_currentSection = m_currentSection->getParent();
            assert( m_currentSection != NULL );
            m_completedASectionThisRun = true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x60(%rax), %rdi
callq 0x3c050
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3c100
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
cmpq $0x0, 0x60(%rax)
je 0x3b54e
jmp 0x3b56d
leaq 0x3db83(%rip), %rdi     # 0x790d8
leaq 0x3d1d9(%rip), %rsi     # 0x78735
movl $0x1308, %edx           # imm = 0x1308
leaq 0x3db89(%rip), %rcx     # 0x790f1
callq 0xb380
movq -0x10(%rbp), %rax
movb $0x1, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TrackedSection::leave()
void leave() {
            for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end();
                    it != itEnd;
                    ++it )
                if( it->second.runState() != Completed ) {
                    m_runState = ExecutingChildren;
                    return;
                }
            m_runState = Completed;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
callq 0x3c120
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3c150
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x3a7f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3c150
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3c170
testb $0x1, %al
jne 0x3c0af
jmp 0x3c0e3
leaq -0x10(%rbp), %rdi
callq 0x3c1a0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x3a5c0
cmpl $0x3, %eax
je 0x3c0d6
movq -0x30(%rbp), %rax
movl $0x2, 0x20(%rax)
jmp 0x3c0ee
jmp 0x3c0d8
leaq -0x10(%rbp), %rdi
callq 0x3c1c0
jmp 0x3c09c
movq -0x30(%rbp), %rax
movl $0x3, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlWriter::writeAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
            if( !name.empty() && !attribute.empty() ) {
                stream() << " " << name << "=\"";
                writeEncodedText( attribute );
                stream() << "\"";
            }
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb890
testb $0x1, %al
jne 0x45dee
movq -0x18(%rbp), %rdi
callq 0xb890
testb $0x1, %al
jne 0x45dee
movq -0x20(%rbp), %rdi
callq 0x21590
movq %rax, %rdi
leaq 0x3291e(%rip), %rsi     # 0x786c7
callq 0xb520
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xb4c0
movq %rax, %rdi
leaq 0x3357f(%rip), %rsi     # 0x79343
callq 0xb520
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45e40
movq -0x20(%rbp), %rdi
callq 0x21590
movq %rax, %rdi
leaq 0x333b5(%rip), %rsi     # 0x7919e
callq 0xb520
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
XmlWriter& writeText( std::string const& text, bool indent = true ) {
            if( !text.empty() ){
                bool tagWasOpen = m_tagIsOpen;
                ensureTagClosed();
                if( tagWasOpen && indent )
                    stream() << m_indent;
                writeEncodedText( text );
                m_needsNewline = true;
            }
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb890
testb $0x1, %al
jne 0x463b6
movq -0x20(%rbp), %rdi
movb (%rdi), %al
andb $0x1, %al
movb %al, -0x12(%rbp)
callq 0x45e00
testb $0x1, -0x12(%rbp)
je 0x463a1
testb $0x1, -0x11(%rbp)
je 0x463a1
movq -0x20(%rbp), %rdi
callq 0x21590
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0xb4c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45e40
movq -0x20(%rbp), %rax
movb $0x1, 0x1(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: minimind[P]simple-graph/unittest/../graph/graph.hpp
// Function: Graph<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::remove_node(SimpleGraph::NodeIterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
typename Graph<N,E>::node_iterator Graph<N,E>::remove_node( typename Graph<N,E>::node_iterator& n )
{
  // You can only remove a node it it has no edges in it
  if ( !n.m_iterator->second->m_edges.empty() )
  {
    throw std::runtime_error( "Cannot remove a node if it is still connected by an edge" );
  }

  typename Graph<N,E>::node_iterator toReturn = n;
  ++toReturn;

  nodes.m_nodes.erase( n.m_iterator );
  return toReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x56f00
movq %rax, %rdi
addq $0x8, %rdi
callq 0x56f20
movq %rax, %rdi
addq $0x28, %rdi
callq 0x5f570
testb $0x1, %al
jne 0x5ef5d
movl $0x10, %edi
callq 0xb290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x1ba72(%rip), %rsi     # 0x7a99a
callq 0xb1c0
jmp 0x5ef2f
movq -0x48(%rbp), %rdi
movq 0x4e0b6(%rip), %rsi     # 0xacff0
movq 0x4e05f(%rip), %rdx     # 0xacfa0
callq 0xb8d0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb400
jmp 0x5ef97
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x55590
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x5fb30
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xb920
// File: minimind[P]simple-graph/unittest/../graph/graph.hpp
// Function: Graph<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::add_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
typename Graph<N,E>::node_iterator Graph<N,E>::add_node( const N& n, const unsigned long key )
{
  if ( nodes.m_nodes.find( key ) != nodes.m_nodes.end() )
  {
    throw std::runtime_error( "Key already exists in graph" );
  }
  else if ( key >= m_counter )
  {
    m_counter = key + 1;
  }

  return hidden_add_node( n, key );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x57660
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x576b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x57630
testb $0x1, %al
jne 0x60d49
jmp 0x60d99
movl $0x10, %edi
callq 0xb290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x1a003(%rip), %rsi     # 0x7ad67
callq 0xb1c0
jmp 0x60d6b
movq -0x50(%rbp), %rdi
movq 0x4c27a(%rip), %rsi     # 0xacff0
movq 0x4c223(%rip), %rdx     # 0xacfa0
callq 0xb8d0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xb400
jmp 0x60dd8
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x48(%rcx), %rax
jb 0x60db7
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
jmp 0x60db9
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x558c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xb920
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: minimind[P]simple-graph/unittest/../graph/graph.hpp
// Function: Graph<(anonymous namespace)::CopyFunctor::node_type, (anonymous namespace)::CopyFunctor::edge_type>* copy_topology<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (anonymous namespace)::CopyFunctor>(Graph<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, (anonymous namespace)::CopyFunctor&)
Graph< typename F::node_type, typename F::edge_type > *copy_topology( const Graph<N,E>& originalGraph, F& creator )
{
  // We need to go through all the nodes and edges, using the function to copy them.
  std::auto_ptr< Graph< typename F::node_type, typename F::edge_type > > toReturn( new Graph< typename F::node_type, typename F::edge_type >() );

  hidden_copy_topology( *toReturn, originalGraph, creator );

  return toReturn.release();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x50, %edi
callq 0xb530
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x54c10
jmp 0x653cb
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5fd90
movq -0x38(%rbp), %rdi
callq 0x6c0c0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x658f0
jmp 0x653f7
leaq -0x18(%rbp), %rdi
callq 0x5fe60
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5fe80
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0xb550
jmp 0x65448
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5fe80
movq -0x20(%rbp), %rdi
callq 0xb920
nopw %cs:(%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::Detail::rangeToString<__gnu_cxx::__normal_iterator<(anonymous namespace)::DoubleString const*, std::vector<(anonymous namespace)::DoubleString, std::allocator<(anonymous namespace)::DoubleString>>>>(__gnu_cxx::__normal_iterator<(anonymous namespace)::DoubleString const*, std::vector<(anonymous namespace)::DoubleString, std::allocator<(anonymous namespace)::DoubleString>>>, __gnu_cxx::__normal_iterator<(anonymous namespace)::DoubleString const*, std::vector<(anonymous namespace)::DoubleString, std::allocator<(anonymous namespace)::DoubleString>>>)
std::string rangeToString( InputIterator first, InputIterator last ) {
        std::ostringstream oss;
        oss << "{ ";
        if( first != last ) {
            oss << toString( *first );
            for( ++first ; first != last ; ++first ) {
                oss << ", " << toString( *first );
            }
        }
        oss << " }";
        return oss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0xb700
movq -0x1e8(%rbp), %rdi
leaq 0xf55f(%rip), %rsi      # 0x7b0f8
callq 0xb520
jmp 0x6bba0
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6bd30
testb $0x1, %al
jne 0x6bbb6
jmp 0x6bccb
leaq -0x10(%rbp), %rdi
callq 0x6bda0
movq %rax, %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x6bd70
jmp 0x6bbd0
leaq -0x190(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xb4c0
jmp 0x6bbe5
leaq -0x1c0(%rbp), %rdi
callq 0xb330
leaq -0x10(%rbp), %rdi
callq 0x6bdc0
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6bd30
testb $0x1, %al
jne 0x6bc10
jmp 0x6bcc9
leaq 0xd2bf(%rip), %rsi      # 0x78ed6
leaq -0x190(%rbp), %rdi
callq 0xb520
movq %rax, -0x200(%rbp)
jmp 0x6bc2c
leaq -0x10(%rbp), %rdi
callq 0x6bda0
movq %rax, %rsi
leaq -0x1e0(%rbp), %rdi
callq 0x6bd70
jmp 0x6bc46
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xb4c0
jmp 0x6bc5b
leaq -0x1e0(%rbp), %rdi
callq 0xb330
leaq -0x10(%rbp), %rdi
callq 0x6bdc0
jmp 0x6bbfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x6bd11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xb330
jmp 0x6bd11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0xb330
jmp 0x6bd11
jmp 0x6bccb
leaq 0xf429(%rip), %rsi      # 0x7b0fb
leaq -0x190(%rbp), %rdi
callq 0xb520
jmp 0x6bce0
movq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xb560
jmp 0x6bcf5
leaq -0x190(%rbp), %rdi
callq 0xb100
movq -0x1f0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0xb100
movq -0x198(%rbp), %rdi
callq 0xb920
nopl (%rax)
// File: plasma-umass[P]simplesocket/server.cpp
// Function: messageNumber()
int messageNumber () {
  static int number = 0;
  static pthread_mutex_t numberLock = PTHREAD_MUTEX_INITIALIZER;
  int v;
  pthread_mutex_lock (&numberLock);
  v = number;
  number++;
  pthread_mutex_unlock (&numberLock);
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4c51(%rip), %rdi      # 0x8270
callq 0x33a0
movl 0x4c42(%rip), %eax      # 0x826c
movl %eax, -0x4(%rbp)
movl 0x4c39(%rip), %eax      # 0x826c
addl $0x1, %eax
movl %eax, 0x4c30(%rip)      # 0x826c
leaq 0x4c2d(%rip), %rdi      # 0x8270
callq 0x31e0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: plasma-umass[P]simplesocket/server.cpp
// Function: serve(void*)
void * serve (void * cv)
{
  // Just read exactly one string.
  auto * c = (simplesocket *) cv; 
  string buffer;
  while (true) {
    *c >> buffer;
    if (buffer == "") {
      break;
    }
    int num = messageNumber();
    cout << "[" << num << "] " << buffer << endl;
    // Now reply.
    stringstream str;
    str << "Received message " << num;
    *c << str.str();
  }
  delete c;
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3360
jmp 0x3682
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3aa0
jmp 0x3691
leaq 0x2bb1(%rip), %rsi      # 0x6249
leaq -0x30(%rbp), %rdi
callq 0x3b10
movb %al, -0x1e9(%rbp)
jmp 0x36a9
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x36b5
jmp 0x36cb
jmp 0x3812
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3844
callq 0x3610
movl %eax, -0x40(%rbp)
movq 0x48ee(%rip), %rdi      # 0x7fc8
leaq 0x2923(%rip), %rsi      # 0x6004
callq 0x3280
movq %rax, -0x1f8(%rbp)
jmp 0x36ef
movq -0x1f8(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x3400
movq %rax, -0x200(%rbp)
jmp 0x3707
movq -0x200(%rbp), %rdi
leaq 0x28f1(%rip), %rsi      # 0x6006
callq 0x3280
movq %rax, -0x208(%rbp)
jmp 0x3723
movq -0x208(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3250
movq %rax, -0x210(%rbp)
jmp 0x373c
movq -0x210(%rbp), %rdi
movq 0x486e(%rip), %rsi      # 0x7fb8
callq 0x32b0
jmp 0x3751
leaq -0x1c8(%rbp), %rdi
callq 0x31a0
jmp 0x375f
leaq -0x1b8(%rbp), %rdi
leaq 0x289c(%rip), %rsi      # 0x6009
callq 0x3280
movq %rax, -0x218(%rbp)
jmp 0x377b
movq -0x218(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x3400
jmp 0x378c
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x3270
jmp 0x37ac
movq -0x220(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x3b40
jmp 0x37c1
leaq -0x1e8(%rbp), %rdi
callq 0x3160
leaq -0x1c8(%rbp), %rdi
callq 0x31c0
jmp 0x3680
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3804
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x3160
leaq -0x1c8(%rbp), %rdi
callq 0x31c0
jmp 0x3844
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
cmpq $0x0, %rax
je 0x3830
movq -0x228(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x30(%rbp), %rdi
callq 0x3160
xorl %eax, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: plasma-umass[P]simplesocket/server.cpp
// Function: main
int main (int argc, char * argv[])
{
  if (argc < 2) {
    cerr << "Usage: " << argv[0] << " <port>" << endl;
    exit (-1);
  }
  int port;
  stringstream (argv[1]) >> port;
  serversocket * s = new serversocket (port);
  cout << "Entering loop.\n" << endl;
  while (true) {
    // Create one thread per connection.
    auto c = s->accept();
    pthread_t * t = new pthread_t;
    pthread_create (t, NULL, serve, (void *) c);
  }
  // We will never get here...
  s->close();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x38c9
movq 0x476a(%rip), %rdi      # 0x7ff0
leaq 0x278e(%rip), %rsi      # 0x601b
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3280
movq %rax, %rdi
leaq 0x2778(%rip), %rsi      # 0x6023
callq 0x3280
movq %rax, %rdi
movq 0x46fe(%rip), %rsi      # 0x7fb8
callq 0x32b0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3310
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x200(%rbp)
leaq -0x1c1(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x3420
movq -0x200(%rbp), %rsi
movq -0x1f8(%rbp), %rdx
leaq -0x1c0(%rbp), %rdi
callq 0x3c80
jmp 0x3907
movl $0x10, %edi
movl $0x8, %esi
callq 0x3d30
movl %eax, -0x204(%rbp)
jmp 0x391e
movl -0x204(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x33c0
jmp 0x3939
leaq -0x1a0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3c50
jmp 0x394b
leaq -0x1a0(%rbp), %rdi
callq 0x31c0
leaq -0x1c0(%rbp), %rdi
callq 0x3160
leaq -0x1c1(%rbp), %rdi
callq 0x32d0
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x3290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x210(%rbp)
movl -0x14(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3d50
jmp 0x3997
movq -0x210(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movq 0x461c(%rip), %rdi      # 0x7fc8
leaq 0x2678(%rip), %rsi      # 0x602b
callq 0x3280
movq %rax, %rdi
movq 0x45f6(%rip), %rsi      # 0x7fb8
callq 0x32b0
movq -0x1e0(%rbp), %rdi
callq 0x5210
movq %rax, -0x1e8(%rbp)
movl $0x8, %edi
callq 0x3290
movq %rax, -0x1f0(%rbp)
movq -0x1f0(%rbp), %rdi
movq -0x1e8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x3a4(%rip), %rdx      # 0x3660
callq 0x3450
jmp 0x39c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0x3a5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0x3a51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31c0
leaq -0x1c0(%rbp), %rdi
callq 0x3160
leaq -0x1c1(%rbp), %rdi
callq 0x32d0
jmp 0x3a8e
movq -0x210(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
movl $0x1e0, %esi            # imm = 0x1E0
callq 0x32a0
movq -0x1d0(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: willprice[P]parallel-cpp-workshop/sum.cpp
// Function: main
int main(int argc, char **argv)
{
    int (*a)(int, int) = &sum;
    auto result = a(3, 7);
    std::cout << result << std::endl;
    return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq -0x3c(%rip), %rax       # 0x11b0
movq %rax, 0x10(%rsp)
movl $0x3, %edi
movl $0x7, %esi
callq *0x10(%rsp)
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
movq 0x2dca(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2dab(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: onai[P]npio/npio_test_c.c
// Function: test1
void test1()
{
  int err;
  size_t i;
  int64_t *data, total;
  npio_Array array;

  npio_init_array(&array);
  err = npio_load("test1.npy", &array);
  if (err)
  {
    fprintf(stderr, "npio_load: %s\n", strerror(err));
    exit(1);
  }

  printf("data type: ");
  if (array.floating_point)
    printf("%d-bit float\n", array.bit_width);
  else if (array.is_signed)
    printf("%d-bit signed integer\n", array.bit_width);
  else
    printf("%d-bit unsigned integer\n", array.bit_width);

  printf("shape: ");
  for (i = 0; i < array.dim; ++i)
    printf("%ld ", array.shape[i]);
  printf("\n");

  assert(array.bit_width == 64 && !array.floating_point && array.is_signed);

  data = (int64_t*) array.data;
  total = 0;
  for (i = 0; i < array.size; ++i)
    total += data[i];

  assert(total == 4950);

  npio_free_array(&array);
  printf("test1 passed\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq -0xa8(%rbp), %rdi
callq 0x14d0
leaq 0x2f41(%rip), %rdi      # 0x423f
leaq -0xa8(%rbp), %rsi
callq 0x15c0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x134e
movq 0x4cde(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movl -0x4(%rbp), %edi
callq 0x11c0
movq -0xb0(%rbp), %rdi
movq %rax, %rdx
leaq 0x2d13(%rip), %rsi      # 0x4050
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x11b0
leaq 0x2d0a(%rip), %rdi      # 0x405f
movb $0x0, %al
callq 0x1090
cmpl $0x0, -0x70(%rbp)
je 0x1375
movl -0x68(%rbp), %esi
leaq 0x2cff(%rip), %rdi      # 0x406b
movb $0x0, %al
callq 0x1090
jmp 0x13a1
cmpl $0x0, -0x6c(%rbp)
je 0x138e
movl -0x68(%rbp), %esi
leaq 0x2cf4(%rip), %rdi      # 0x4079
movb $0x0, %al
callq 0x1090
jmp 0x139f
movl -0x68(%rbp), %esi
leaq 0x2cf8(%rip), %rdi      # 0x4090
movb $0x0, %al
callq 0x1090
jmp 0x13a1
leaq 0x2d01(%rip), %rdi      # 0x40a9
movb $0x0, %al
callq 0x1090
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x90(%rbp), %rax
jae 0x13ef
movq -0x88(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x2cd7(%rip), %rdi      # 0x40b1
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x13b7
leaq 0x2d37(%rip), %rdi      # 0x412d
movb $0x0, %al
callq 0x1090
cmpl $0x40, -0x68(%rbp)
jne 0x1411
cmpl $0x0, -0x70(%rbp)
jne 0x1411
cmpl $0x0, -0x6c(%rbp)
je 0x1411
jmp 0x1430
leaq 0x2c9e(%rip), %rdi      # 0x40b6
leaq 0x2cd9(%rip), %rsi      # 0x40f8
movl $0x28, %edx
leaq 0x2cdb(%rip), %rcx      # 0x4106
callq 0x10b0
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x80(%rbp), %rax
jae 0x1474
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1448
cmpq $0x1356, -0x20(%rbp)    # imm = 0x1356
jne 0x1480
jmp 0x149f
leaq 0x2c8c(%rip), %rdi      # 0x4113
leaq 0x2c6a(%rip), %rsi      # 0x40f8
movl $0x2f, %edx
leaq 0x2c6c(%rip), %rcx      # 0x4106
callq 0x10b0
leaq -0xa8(%rbp), %rdi
callq 0x15f0
leaq 0x2c6f(%rip), %rdi      # 0x4121
movb $0x0, %al
callq 0x1090
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: onai[P]npio/npio_test_c.c
// Function: test3
void test3()
{
  int i, err;
  float *data, total;
  npio_Array array;

  npio_init_array(&array);
  err = npio_load_header("test2.npy", &array);
  if (err)
  {
    fprintf(stderr, "npio_load_header: %s\n", strerror(err));
    exit(1);
  }

  err = npio_load_data(&array);
  if (err)
  {
    fprintf(stderr, "npio_load_data: %s\n", strerror(err));
    exit(1);
  }

  data = (float*) array.data;
  total = 0;
  for (i = 0; i < array.size; ++i)
    total += data[i];
  assert(fabs(total / 5005.37f - 1.0f) < 1e-6f);

  npio_free_array(&array);
  printf("test3 passed\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq -0xa0(%rbp), %rdi
callq 0x14d0
leaq 0x2811(%rip), %rdi      # 0x412f
leaq -0xa0(%rbp), %rsi
callq 0x1a80
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x196e
movq 0x46be(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movl -0x8(%rbp), %edi
callq 0x11c0
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
leaq 0x284b(%rip), %rsi      # 0x41a8
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x11b0
leaq -0xa0(%rbp), %rdi
callq 0x1ab0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x19be
movq 0x466e(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movl -0x8(%rbp), %edi
callq 0x11c0
movq -0xb0(%rbp), %rdi
movq %rax, %rdx
leaq 0x2811(%rip), %rsi      # 0x41be
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x11b0
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq -0x78(%rbp), %rax
jae 0x1a01
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x19d5
movss -0x14(%rbp), %xmm0
movss 0x2616(%rip), %xmm1     # 0x4024
divss %xmm1, %xmm0
movss 0x2606(%rip), %xmm1     # 0x4020
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x25e7(%rip), %xmm0     # 0x4010
pand %xmm0, %xmm1
movsd 0x25d3(%rip), %xmm0     # 0x4008
ucomisd %xmm1, %xmm0
jbe 0x1a3d
jmp 0x1a5c
leaq 0x2730(%rip), %rdi      # 0x4174
leaq 0x26ad(%rip), %rsi      # 0x40f8
movl $0x79, %edx
leaq 0x277b(%rip), %rcx      # 0x41d2
callq 0x10b0
leaq -0xa0(%rbp), %rdi
callq 0x15f0
leaq 0x2770(%rip), %rdi      # 0x41df
movb $0x0, %al
callq 0x1090
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: onai[P]npio/npio_test_c.c
// Function: test4
void test4()
{
  int i, err;
  int64_t *data;
  float total;
  FILE *f;
  void *p;
  size_t sz;
  npio_Array array;

  npio_init_array(&array);
  f = fopen("test1.npy", "r");
  if (!f)
  {
    fprintf(stderr, "could not open test1.npy\n");
    exit(1);
  }

  fseek(f, 0, SEEK_END);
  sz = ftell(f);
  fseek(f, 0, SEEK_SET);
  p = malloc(sz);
  if (fread(p, 1, sz, f) != sz)
  {
    perror("fread");
    exit(1);
  }

  err = npio_load_mem(p, sz, &array);
  if (err)
  {
    fprintf(stderr, "npio_load_mem: %s\n", strerror(err));
    exit(1);
  }

  fclose(f);

  data = (int64_t*) array.data;
  total = 0;
  for (i = 0; i < array.size; ++i)
    total += data[i];

  assert(total == 4950);

  npio_free_array(&array);
  free(p);
  printf("test4 passed\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0xb8(%rbp), %rdi
callq 0x14d0
leaq 0x2751(%rip), %rdi      # 0x423f
leaq 0x2792(%rip), %rsi      # 0x4287
callq 0x1190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1b27
movq 0x44ec(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x26d7(%rip), %rsi      # 0x41ed
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x11b0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1140
movq -0x20(%rbp), %rdi
callq 0x1100
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1140
movq -0x30(%rbp), %rdi
callq 0x1130
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1050
cmpq -0x30(%rbp), %rax
je 0x1b94
leaq 0x2682(%rip), %rdi      # 0x4207
callq 0x11a0
movl $0x1, %edi
callq 0x11b0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x1ca0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1bec
movq 0x4440(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl -0x8(%rbp), %edi
callq 0x11c0
movq -0xc0(%rbp), %rdi
movq %rax, %rdx
leaq 0x2632(%rip), %rsi      # 0x420d
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x11b0
movq -0x20(%rbp), %rdi
callq 0x1060
movq -0x70(%rbp), %rax
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq -0x90(%rbp), %rax
jae 0x1c3c
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
cvtsi2ssq (%rax,%rcx,8), %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1c0c
movss -0x14(%rbp), %xmm0
movss 0x23df(%rip), %xmm1     # 0x4028
ucomiss %xmm1, %xmm0
jne 0x1c52
jp 0x1c52
jmp 0x1c71
leaq 0x24ba(%rip), %rdi      # 0x4113
leaq 0x2498(%rip), %rsi      # 0x40f8
movl $0xaa, %edx
leaq 0x25b4(%rip), %rcx      # 0x4220
callq 0x10b0
leaq -0xb8(%rbp), %rdi
callq 0x15f0
movq -0x28(%rbp), %rdi
callq 0x1030
leaq 0x25a0(%rip), %rdi      # 0x422d
movb $0x0, %al
callq 0x1090
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: onai[P]npio/npio_test_c.c
// Function: test5
void test5()
{
  int fd, err;
  npio_Array array;
  size_t sz, i;
  FILE* f;
  int64_t *data, total;

  f = popen("cat test1.npy", "r");
  if (f == 0)
  {
    perror("popen");
    exit(1);
  }

  fd = fileno(f);
  npio_init_array(&array);
  if ((err = npio_load_fd(fd, &array)))
  {
    fprintf(stderr, "npio_load_fd: %s\n", strerror(err));
    exit(1);
  }

  data = (int64_t*) array.data;
  total = 0;
  for (i = 0; i < array.size; ++i)
    total += data[i];
  assert(total == 4950);

  fclose(f);
  npio_free_array(&array);
  printf("test5 passed\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x2559(%rip), %rdi      # 0x423b
leaq 0x259e(%rip), %rsi      # 0x4287
callq 0x1180
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x1d15
leaq 0x2543(%rip), %rdi      # 0x4249
callq 0x11a0
movl $0x1, %edi
callq 0x11b0
movq -0xa8(%rbp), %rdi
callq 0x1120
movl %eax, -0x4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x14d0
movl -0x4(%rbp), %edi
leaq -0x90(%rbp), %rsi
callq 0x1e50
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
je 0x1d82
movq 0x42aa(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movl -0x8(%rbp), %edi
callq 0x11c0
movq -0xc0(%rbp), %rdi
movq %rax, %rdx
leaq 0x24de(%rip), %rsi      # 0x424f
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x11b0
movq -0x48(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq $0x0, -0xb8(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0x1de4
movq -0xb0(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0xb8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x1da3
cmpq $0x1356, -0xb8(%rbp) # imm = 0x1356
jne 0x1df3
jmp 0x1e12
leaq 0x2319(%rip), %rdi      # 0x4113
leaq 0x22f7(%rip), %rsi      # 0x40f8
movl $0xce, %edx
leaq 0x2454(%rip), %rcx      # 0x4261
callq 0x10b0
movq -0xa8(%rbp), %rdi
callq 0x1060
leaq -0x90(%rbp), %rdi
callq 0x15f0
leaq 0x243d(%rip), %rdi      # 0x426e
movb $0x0, %al
callq 0x1090
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: onai[P]npio/npio_test_c.c
// Function: main
int main()
{
  test1();
  test2();
  test3();
  test4();
  test5();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x12e0
callq 0x16f0
callq 0x1900
callq 0x1ad0
callq 0x1cd0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: onai[P]npio/./npio.h
// Function: npio_load_header3
static inline int npio_load_header3(const char* filename, npio_Array* array
  , size_t max_dim)
{
  int fd, err;
  fd = open(filename, O_RDONLY);
  if (fd < 0)
    return errno;
  array->_fd = fd;
  array->_opened = 1;
  err = npio_load_header_fd3(fd, array, max_dim);

  /* we don't need to hang on the fd if we managed to map */
  if (array->_mmapped)
  {
    close(fd);
    array->_fd = -1;
    array->_opened = 0;
  }
  return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1170
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x2d36
callq 0x1040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2d92
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x80(%rax)
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f60
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x78(%rax)
je 0x2d8c
movl -0x24(%rbp), %edi
callq 0x10c0
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl $0x0, 0x80(%rax)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chfeder[P]turbulence_generator/./TurbGen.h
// Function: TurbGen::Constructor(int)
void Constructor(const int PE)
    {
        ClassSignature = "TurbGen: ";
        this->PE = PE;
        verbose = 1; // default verbose level
        evolfile = "TurbGen.dat";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
leaq 0xde16(%rip), %rsi      # 0x15438
callq 0x3460
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x150(%rdi)
movl $0x1, (%rdi)
addq $0x218, %rdi            # imm = 0x218
leaq 0xddfa(%rip), %rsi      # 0x15442
callq 0x3460
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chfeder[P]turbulence_generator/./TurbGen.h
// Function: TurbGen::TurbGen_printf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ...)
void TurbGen_printf(std::string format, ...) {
        // ******************************************************
        // special printf prepends string and only lets PE=0 print
        // ******************************************************
        va_list args;
        va_start(args, format);
        std::string new_format = ClassSignature+format;
        if (PE == 0) vfprintf(stdout, new_format.c_str(), args);
        va_end(args);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movb %al, -0x109(%rbp)
movq %rdx, %rax
movq %rsi, %rdx
movb -0x109(%rbp), %sil
testb %sil, %sil
je 0x9a42
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x108(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
callq 0xec70
movq -0x108(%rbp), %rax
cmpl $0x0, 0x150(%rax)
jne 0x9adf
movq 0x114ff(%rip), %rax     # 0x1afb8
movq (%rax), %rax
movq %rax, -0x118(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3120
movq -0x118(%rbp), %rdi
movq %rax, %rsi
leaq -0x30(%rbp), %rdx
callq 0x3450
leaq -0x50(%rbp), %rdi
callq 0x31e0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: chfeder[P]turbulence_generator/./TurbGen.h
// Function: TurbGen::set_number_of_components()
void set_number_of_components(void) {
        // error check on user setting of ndim
        if ((ndim != 1) && (ndim != 1.5) && (ndim != 2) && (ndim != 2.5) && (ndim != 3)) {
            TurbGen_printf("ERROR: number of dimensions must be in [1, 1.5, 2, 2.5, 3].\n");
            exit(-1);
        }
        // set the number of vector field components
        if (ndim == 1) ncmp = 1;
        if (ndim == 2) ncmp = 2;
        if ((ndim == 1.5) || (ndim == 2.5) || (ndim == 3)) ncmp = 3;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd 0x158(%rax), %xmm0
movsd 0xa284(%rip), %xmm1     # 0x15018
ucomisd %xmm1, %xmm0
jne 0xada1
jp 0xada1
jmp 0xaea6
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa2b3(%rip), %xmm1     # 0x15068
ucomisd %xmm1, %xmm0
jne 0xadc2
jp 0xadc2
jmp 0xaea6
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa25a(%rip), %xmm1     # 0x15030
ucomisd %xmm1, %xmm0
jne 0xade3
jp 0xade3
jmp 0xaea6
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa279(%rip), %xmm1     # 0x15070
ucomisd %xmm1, %xmm0
jne 0xae04
jp 0xae04
jmp 0xaea6
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa230(%rip), %xmm1     # 0x15048
ucomisd %xmm1, %xmm0
jne 0xae25
jp 0xae25
jmp 0xaea6
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3560
movq -0x50(%rbp), %rdx
leaq 0xa94e(%rip), %rsi      # 0x1578b
leaq -0x28(%rbp), %rdi
callq 0x4620
jmp 0xae48
movq -0x48(%rbp), %rdi
xorl %eax, %eax
leaq -0x28(%rbp), %rsi
callq 0x99f0
jmp 0xae59
leaq -0x28(%rbp), %rdi
callq 0x31e0
leaq -0x29(%rbp), %rdi
callq 0x3350
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x33d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xae98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31e0
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0xaf66
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa15e(%rip), %xmm1     # 0x15018
ucomisd %xmm1, %xmm0
jne 0xaed0
jp 0xaed0
movq -0x48(%rbp), %rax
movl $0x1, 0x160(%rax)
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa14c(%rip), %xmm1     # 0x15030
ucomisd %xmm1, %xmm0
jne 0xaefa
jp 0xaefa
movq -0x48(%rbp), %rax
movl $0x2, 0x160(%rax)
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa15a(%rip), %xmm1     # 0x15068
ucomisd %xmm1, %xmm0
jne 0xaf18
jp 0xaf18
jmp 0xaf52
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa144(%rip), %xmm1     # 0x15070
ucomisd %xmm1, %xmm0
jne 0xaf36
jp 0xaf36
jmp 0xaf52
movq -0x48(%rbp), %rax
movsd 0x158(%rax), %xmm0
movsd 0xa0fe(%rip), %xmm1     # 0x15048
ucomisd %xmm1, %xmm0
jne 0xaf60
jp 0xaf60
movq -0x48(%rbp), %rax
movl $0x3, 0x160(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3550
nop