LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ExceptionTranslatorRegistry::translateActiveException[abi:cxx11]() const
virtual std::string translateActiveException() const {
            try {
#ifdef __OBJC__
                // In Objective-C try objective-c exceptions first
                @try {
                    throw;
                }
                @catch (NSException *exception) {
                    return toString( [exception description] );
                }
#else
                throw;
#endif
            }
            catch( TestFailureException& ) {
                throw;
            }
            catch( std::exception& ex ) {
                return ex.what();
            }
            catch( std::string& msg ) {
                return msg;
            }
            catch( const char* msg ) {
                return msg;
            }
            catch(...) {
                return tryTranslators( m_translators.begin() );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa450
jmp 0x15503
movq %rdx, %r15
movq %rax, %rdi
cmpl $0x5, %r15d
je 0x154f9
cmpl $0x4, %r15d
jne 0x15495
callq 0xa130
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10f70
jmp 0x154e7
cmpl $0x3, %r15d
jne 0x154bb
callq 0xa130
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2bee4
jmp 0x154e7
callq 0xa130
cmpl $0x2, %r15d
jne 0x154d8
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10f70
jmp 0x154e7
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1556e
callq 0xa540
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xa130
callq 0xa450
movq %rax, %rbx
callq 0xa540
jmp 0x15533
movq %rax, %rbx
callq 0xa540
jmp 0x15533
movq %rax, %rbx
callq 0xa540
jmp 0x15533
movq %rax, %rbx
callq 0xa540
jmp 0x15533
movq %rax, %rbx
callq 0xa540
movq %rbx, %rdi
callq 0xa5c0
movq %rax, %rdi
callq 0x1105d
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ExceptionTranslatorRegistry::tryTranslators[abi:cxx11](__gnu_cxx::__normal_iterator<Catch::IExceptionTranslator const* const*, std::vector<Catch::IExceptionTranslator const*, std::allocator<Catch::IExceptionTranslator const*>>>) const
std::string tryTranslators( std::vector<const IExceptionTranslator*>::const_iterator it ) const {
            if( it == m_translators.end() )
                return "Unknown exception";

            try {
                return (*it)->translate();
            }
            catch(...) {
                return tryTranslators( it+1 );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdx, 0x10(%rsi)
je 0x15590
movq %rdx, %r14
movq %rsi, %r15
movq (%rdx), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x155ad
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2930a(%rip), %rsi     # 0x3e8a8
leaq 0x29314(%rip), %rdx     # 0x3e8b9
movq %rbx, %rdi
callq 0x2bf74
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0xa130
addq $0x8, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1556e
callq 0xa540
jmp 0x155ad
movq %rax, %rbx
callq 0xa540
movq %rbx, %rdi
callq 0xa5c0
movq %rax, %rdi
callq 0x1105d
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Context::findGeneratorsForCurrentTest()
IGeneratorsForTest* findGeneratorsForCurrentTest() {
            std::string testName = getResultCapture()->getCurrentTestName();

            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
            m_generatorsByTestName.find( testName );
            return it != m_generatorsByTestName.end()
                ? it->second
                : NULL;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *0x38(%rcx)
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x15caa
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x15c5c
movq 0x40(%rax), %rbx
jmp 0x15c5e
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15c79
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15ca2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::operator[](Catch::Clara::UnpositionalTag)
ArgBuilder operator[]( UnpositionalTag ) {
            if( m_floatingArg.get() )
                throw std::logic_error( "Only one unpositional argument can be added" );
            m_floatingArg = ArgAutoPtr( new Arg() );
            ArgBuilder builder( m_floatingArg.get() );
            return builder;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x50(%rdi)
jne 0x185f6
movq %rdi, %rbx
movl $0xa8, %edi
callq 0xa310
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), %rdx
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
leaq 0x90(%rax), %rdx
movq %rdx, 0x80(%rax)
movq %rcx, 0x88(%rax)
movb %cl, 0x90(%rax)
movl $0xffffffff, 0xa0(%rax) # imm = 0xFFFFFFFF
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa160
movq %rax, %rbx
leaq 0x2682f(%rip), %rsi     # 0x3ee39
movq %rax, %rdi
callq 0xa430
movq 0x3e9b7(%rip), %rsi     # 0x56fd0
movq 0x3e998(%rip), %rdx     # 0x56fb8
movq %rbx, %rdi
callq 0xa580
movq %rax, %r14
movq %rbx, %rdi
callq 0xa270
movq %r14, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Clara::Detail::BoundBinaryFunction<Catch::ConfigData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::setFlag(Catch::ConfigData&) const
inline void deleteAll( ContainerT& container ) {
        typename ContainerT::const_iterator it = container.begin();
        typename ContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
            delete *it;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movl $0x10, %edi
callq 0xa160
movq %rax, %r14
leaq 0x24bda(%rip), %rsi     # 0x3ece0
movq %rax, %rdi
callq 0xa110
movq 0x3cedb(%rip), %rsi     # 0x56ff0
movq 0x3ce8c(%rip), %rdx     # 0x56fa8
movq %r14, %rdi
callq 0xa580
movq %rax, %rbx
jmp 0x1a134
movq %rax, %rbx
movq %r14, %rdi
callq 0xa270
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1a14a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(int, char const* const*, Catch::ConfigData&) const
std::vector<Parser::Token> parseInto( int argc, char const * const * argv, ConfigT& config ) const {
            std::string processName = argv[0];
            std::size_t lastSlash = processName.find_last_of( "/\\" );
            if( lastSlash != std::string::npos )
                processName = processName.substr( lastSlash+1 );
            m_boundProcessName.set( config, processName );
            std::vector<Parser::Token> tokens;
            Parser parser;
            parser.parseIntoTokens( argc, argv, tokens );
            return populate( tokens, config );
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rcx), %rsi
leaq 0x20(%rsp), %r13
movq %rsp, %rdx
movq %r13, %rdi
callq 0x10f70
leaq 0x2440b(%rip), %rsi     # 0x3ee9b
movl $0x2, %ecx
movq %r13, %rdi
movq $-0x1, %rdx
callq 0xa670
cmpq $-0x1, %rax
je 0x1aaef
incq %rax
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0xa360
leaq 0x20(%rsp), %rdi
movq %rsp, %r13
movq %r13, %rsi
callq 0xa3e0
movq (%r13), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1aaef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
movq (%r15), %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movl $0x3a3d0920, (%r13)     # imm = 0x3A3D0920
movq $0x4, -0x8(%r13)
movb $0x0, 0x4(%r13)
movq %rsp, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x1b460
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x1b574
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ab67
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x40(%rsp), %rdi
callq 0x17eb6
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ab8c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1aba0
movq %rax, %rbx
jmp 0x1abc8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1abbe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x40(%rsp), %rdi
callq 0x17eb6
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1abe3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Session::showHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void showHelp( std::string const& processName ) {
            std::cout << "\nCatch v"    << libraryVersion.majorVersion << "."
                                        << libraryVersion.minorVersion << " build "
                                        << libraryVersion.buildNumber;
            if( libraryVersion.branchName != std::string( "master" ) )
                std::cout << " (" << libraryVersion.branchName << " branch)";
            std::cout << "\n";

            m_cli.usage( std::cout, processName );
            std::cout << "For more detail usage please see the project docs\n" << std::endl;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, %r15
movq 0x3c3b8(%rip), %rbx     # 0x56fc0
leaq 0x24312(%rip), %rsi     # 0x3ef21
movl $0x8, %edx
movq %rbx, %rdi
callq 0xa390
movl 0x3c786(%rip), %esi     # 0x573a8
movq %rbx, %rdi
callq 0xa200
movq %rax, %r12
leaq 0x24bd3(%rip), %rsi     # 0x3f807
movl $0x1, %edx
movq %rax, %rdi
callq 0xa390
movl 0x3c765(%rip), %esi     # 0x573ac
movq %r12, %rdi
callq 0xa200
movq %rax, %r12
leaq 0x242d1(%rip), %rsi     # 0x3ef2a
movl $0x7, %edx
movq %rax, %rdi
callq 0xa390
movl 0x3c744(%rip), %esi     # 0x573b0
movq %r12, %rdi
callq 0xa200
movq 0x3c73d(%rip), %r12     # 0x573b8
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x23a7a(%rip), %rsi     # 0x3e705
leaq 0x23a79(%rip), %rdx     # 0x3e70b
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x2bf74
movq %r13, %rdi
movq %r12, %rsi
callq 0xa0d0
movl %eax, %ebp
movq (%r13), %rdi
cmpq %r14, %rdi
je 0x1acc2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
testl %ebp, %ebp
je 0x1ad3a
movq 0x3c2f3(%rip), %r12     # 0x56fc0
leaq 0x2422c(%rip), %rsi     # 0x3ef00
movl $0x2, %edx
movq %r12, %rdi
callq 0xa390
movq 0x3c6d0(%rip), %r13     # 0x573b8
testq %r13, %r13
je 0x1ad09
movq %r13, %rdi
callq 0xa140
movq 0x3c2c4(%rip), %rdi     # 0x56fc0
movq %r13, %rsi
movq %rax, %rdx
callq 0xa390
jmp 0x1ad22
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0xa560
movq 0x3c297(%rip), %rdi     # 0x56fc0
leaq 0x24202(%rip), %rsi     # 0x3ef32
movl $0x8, %edx
callq 0xa390
leaq 0x24829(%rip), %rsi     # 0x3f56a
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa390
movq %r15, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x1b3be
leaq 0x241d7(%rip), %rsi     # 0x3ef3b
movl $0x32, %edx
movq %rbx, %rdi
callq 0xa390
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xa2f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa030
movq %rax, %rdi
callq 0xa210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Config::Config(Catch::ConfigData const&)
Config( ConfigData const& data )
        :   m_data( data ),
            m_os( std::cout.rdbuf() )
        {
            if( !data.testsOrTags.empty() ) {
                TestSpecParser parser( ITagAliasRegistry::get() );
                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
                    parser.parse( data.testsOrTags[i] );
                m_testSpec = parser.testSpec();
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
leaq 0x3748f(%rip), %rax     # 0x55520
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x1e2d4
movq $0x0, 0xc8(%rbx)
movb $0x0, 0xd0(%rbx)
leaq 0xd8(%rbx), %rdi
movq 0x38f00(%rip), %rax     # 0x56fc0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rsi
callq 0xa120
xorps %xmm0, %xmm0
movups %xmm0, 0x1e8(%rbx)
movq $0x0, 0x1f8(%rbx)
movq 0xa0(%r15), %rax
cmpq 0xa8(%r15), %rax
je 0x1e23f
movq %r14, (%rsp)
callq 0x1026a
leaq 0x48(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x30(%r13)
leaq 0x39293(%rip), %rax     # 0x573c8
movq %rax, 0x40(%r13)
movq 0xa0(%r15), %rsi
cmpq %rsi, 0xa8(%r15)
je 0x1e17f
xorl %ebp, %ebp
leaq 0x20(%rsp), %r12
xorl %r14d, %r14d
addq %rbp, %rsi
movq %r12, %rdi
callq 0x1e442
incq %r14
movq 0xa0(%r15), %rsi
movq 0xa8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %rax, %r14
jb 0x1e153
leaq 0x20(%rsp), %rdi
callq 0x1e87c
leaq 0x70(%rsp), %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1f2e6
leaq 0x58(%rsp), %r14
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x1e8(%rbx), %rax
movups 0x1f0(%rbx), %xmm0
leaq 0x8(%rsp), %r12
movq (%r12), %rcx
movq %rcx, 0x1e8(%rbx)
movq 0x8(%r12), %rcx
movq %rcx, 0x1f0(%rbx)
movq 0x10(%r12), %rcx
movq %rcx, 0x1f8(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r12)
movq %rdx, 0x8(%r12)
movq %rsi, 0x10(%r12)
callq 0x1f406
movq %r12, %rdi
callq 0x1f406
movq %r15, %rdi
callq 0x1f406
movq %r14, %rdi
callq 0x1eeba
movq -0x20(%r14), %rdi
cmpq %r13, %rdi
je 0x1e23f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa330
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, (%rsp)
movq %rax, %r15
jmp 0x1e287
jmp 0x1e25c
movq %rax, %r15
leaq 0x1e8(%rbx), %r12
leaq 0x20(%rsp), %rdi
callq 0x1e4e4
movq %r12, %rdi
callq 0x1f406
addq $0xe0, %rbx
movq %rbx, %rdi
callq 0xa0f0
movq (%rsp), %rdi
callq 0x17e3c
movq %r15, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::TestSpec::NamePattern::NamePattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) {
                if( startsWith( m_name, "*" ) ) {
                    m_name = m_name.substr( 1 );
                    m_wildcard = WildcardAtStart;
                }
                if( endsWith( m_name, "*" ) ) {
                    m_name = m_name.substr( 0, m_name.size()-1 );
                    m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x8(%rdi)
leaq 0x36085(%rip), %rax     # 0x55200
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0xca77
movl %ebp, 0x30(%rbx)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x204e6(%rip), %rsi     # 0x3f684
leaq 0x204e0(%rip), %rdx     # 0x3f685
movq %rsp, %rdi
callq 0x2bf74
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc5c4
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1f1d0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
testb %bpl, %bpl
je 0x1f216
movq %rsp, %rdi
movl $0x1, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0xa360
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa3e0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1f20f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
movl $0x1, 0x30(%rbx)
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x20461(%rip), %rsi     # 0x3f684
leaq 0x2045b(%rip), %rdx     # 0x3f685
callq 0x2bf74
movq %rsp, %rsi
movq %r14, %rdi
callq 0xd904
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1f252
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
testb %bpl, %bpl
je 0x1f292
movq 0x18(%rbx), %rcx
decq %rcx
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa360
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa3e0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1f28e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
orb $0x2, 0x30(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f2c2
jmp 0x1f2c2
jmp 0x1f2a7
jmp 0x1f2c2
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1f2c5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x1f2c5
movq %rax, %r14
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x1f2dd
movq (%rbx), %rsi
incq %rsi
callq 0xa330
movq %r14, %rdi
callq 0xa5c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::~RunContext()
virtual ~RunContext() {
            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
            m_context.setRunner( m_prevRunner );
            m_context.setConfig( NULL );
            m_context.setResultCapture( m_prevResultCapture );
            m_context.setConfig( m_prevConfig );
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x34b9c(%rip), %rax     # 0x566c0
movq %rax, (%rdi)
leaq 0x34bf2(%rip), %rax     # 0x56720
movq %rax, 0x8(%rdi)
movq 0x1a8(%rdi), %r14
movq 0x170(%rdi), %rdi
movq 0x180(%rbx), %r13
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, %ebp
leaq 0x333c2(%rip), %r15     # 0x54f18
leaq 0x10(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq %rsi, %rdx
callq 0x2bee4
movslq %ebp, %rax
cmpq %rax, %r13
movups 0x178(%rbx), %xmm0
movups 0x188(%rbx), %xmm1
movups 0x198(%rbx), %xmm2
leaq 0x8(%rsp), %rsi
movups %xmm2, 0x48(%rsi)
movups %xmm1, 0x38(%rsi)
movups %xmm0, 0x28(%rsi)
sete 0x58(%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x78(%rax)
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x21bce
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x30(%rbx), %rdi
movq 0x1c8(%rbx), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x30(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq (%rdi), %rax
callq *0x48(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21c05
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq 0x1d0(%rbx), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x30(%rbx), %rdi
leaq 0x1d8(%rbx), %r14
movq (%rdi), %rax
movq %r14, %rsi
callq *0x48(%rax)
leaq 0x250(%rbx), %rdi
callq 0x21d1a
movq 0x228(%rbx), %rdi
leaq 0x238(%rbx), %rax
cmpq %rax, %rdi
je 0x21c54
movq (%rax), %rsi
incq %rsi
callq 0xa330
movq 0x200(%rbx), %rdi
leaq 0x210(%rbx), %rax
cmpq %rax, %rdi
je 0x21c72
movq (%rax), %rsi
incq %rsi
callq 0xa330
movq 0x1e0(%rbx), %rdi
leaq 0x1f0(%rbx), %rax
cmpq %rax, %rdi
je 0x21c90
movq (%rax), %rsi
incq %rsi
callq 0xa330
movq (%r14), %rdi
testq %rdi, %rdi
je 0x21c9e
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x1b0(%rbx), %rdi
callq 0x11a08
movq 0x1a8(%rbx), %rdi
testq %rdi, %rdi
je 0x21cbc
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x170(%rbx), %rdi
testq %rdi, %rdi
je 0x21cce
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0xb8(%rbx), %rdi
callq 0xc1bc
leaq 0x40(%rbx), %rdi
callq 0x22452
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x21cfb
movq (%rbx), %rsi
incq %rsi
callq 0xa330
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21d12
jmp 0x21d12
jmp 0x21d12
jmp 0x21d12
movq %rax, %rdi
callq 0x1105d
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xa400
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0xa390
movq %rax, %r13
leaq 0x1c80c(%rip), %rsi     # 0x3e818
movl $0x1, %edx
movq %rax, %rdi
callq 0xa390
leaq 0x40(%r15), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xbc0a
movq 0x40(%r14), %r13
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xa4d0
movq %rsp, %rsi
movq %r13, %rdi
callq 0x230c8
movl %eax, %ebp
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22061
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
testb %bpl, %bpl
je 0x220a6
leaq 0x200(%r14), %rdi
movq %r12, %rsi
callq 0xa190
movq 0x60(%r15), %rax
movq %rax, 0x220(%r14)
movq 0x1a8(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x48(%rax)
movq 0x188(%r14), %rax
movq %rax, 0x10(%rbx)
movups 0x178(%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x34f03(%rip), %rsi     # 0x56fb0
leaq 0x20(%rsp), %rdi
callq 0xa180
leaq 0x90(%rsp), %rdi
callq 0xa0f0
movl %ebp, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x220fd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x220fd
jmp 0x220fa
movq %rax, %rbx
movq 0x34eac(%rip), %rsi     # 0x56fb0
leaq 0x20(%rsp), %rdi
callq 0xa180
leaq 0x90(%rsp), %rdi
callq 0xa0f0
movq %rbx, %rdi
callq 0xa5c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movsd %xmm0, (%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa050
testb %al, %al
je 0x221d4
addq $0x250, %rbx            # imm = 0x250
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd (%rsp), %xmm0
callq 0x23610
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23890
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22195
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x221b0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22280
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x22280
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq 0x178(%rbx), %rax
subq (%r15), %rax
movq %rax, (%r12)
movq 0x180(%rbx), %rax
subq 0x8(%r15), %rax
movq %rax, 0x8(%r12)
movq 0x188(%rbx), %rax
subq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x236e8
movl %eax, %ebp
movq 0x40(%rbx), %rdi
callq 0x2373c
movq 0x1a8(%rbx), %r15
movzbl %bpl, %ecx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movsd (%rsp), %xmm0
callq 0x23780
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x60(%rax)
leaq 0x8(%rsp), %rdi
callq 0x1041c
movq 0x1b0(%rbx), %rsi
addq $0x1b0, %rbx            # imm = 0x1B0
movq %rbx, %rdi
callq 0x23098
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1041c
jmp 0x222ae
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22404
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x230fe
cmpb $0x0, 0x68(%rbx)
jne 0x230e6
movq %rax, %rcx
movl 0x20(%rax), %edx
cmpl $0x3, %edx
jne 0x230ea
xorl %eax, %eax
popq %rbx
retq
movq %rcx, 0x60(%rbx)
movb $0x1, %al
testl %edx, %edx
jne 0x230e8
movl $0x1, 0x20(%rcx)
jmp 0x230e8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x232a2
movq %rax, %rcx
leaq 0x30(%r15), %r13
leaq 0x40(%rax), %rdx
xorl %ebp, %ebp
movl $0x0, %eax
cmpq %r13, %rcx
cmovneq %rdx, %rax
jne 0x2322c
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2bee4
movl %ebp, 0x20(%r12)
leaq 0x38(%rsp), %rax
movl %ebp, (%rax)
movq %rbp, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rbp, 0x20(%rax)
movq %r15, 0x28(%rax)
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2358a
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0x2332c
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
callq 0x224e0
movq -0x28(%r15), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x231ce
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x231e9
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x224e0
movq -0x28(%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x23211
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq %r14, %rdi
movq %rbx, %rsi
callq 0x232a2
movq %rax, %rcx
leaq 0x40(%rax), %rdx
xorl %eax, %eax
cmpq %r13, %rcx
cmovneq %rdx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x23262
jmp 0x23250
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x224b8
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x23ba6
movq 0x60(%rbx), %rax
movq 0x58(%rax), %rax
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x23760
movb $0x1, 0x68(%rbx)
popq %rbx
retq
leaq 0x1b9b4(%rip), %rdi     # 0x3f11b
leaq 0x1b00f(%rip), %rsi     # 0x3e77d
leaq 0x1b9bf(%rip), %rcx     # 0x3f134
movl $0x1308, %edx           # imm = 0x1308
callq 0xa1f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
leaq 0x30(%rdi), %r14
cmpq %r14, %rax
sete %cl
je 0x23bd8
cmpl $0x3, 0x60(%rax)
jne 0x23bcd
movq %rax, %rdi
callq 0xa3a0
jmp 0x23bb5
movl $0x2, 0x20(%rbx)
testb %cl, %cl
je 0x23bdf
movl $0x3, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x26942
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x26942
movq %rsi, %r15
movq 0x40(%rbx), %r12
leaq 0x17e1d(%rip), %rsi     # 0x3e70f
movl $0x1, %edx
movq %r12, %rdi
callq 0xa390
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0xa390
leaq 0x18a71(%rip), %rsi     # 0x3f386
movl $0x2, %edx
movq %rax, %rdi
callq 0xa390
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26952
movq 0x40(%rbx), %rdi
leaq 0x188a9(%rip), %rsi     # 0x3f1e1
movl $0x1, %edx
callq 0xa390
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x26cc4
movl %edx, %ebp
movq %rsi, %r14
movb (%rbx), %r15b
cmpb $0x1, %r15b
jne 0x26c9b
movq 0x40(%rbx), %rdi
leaq 0x17d1f(%rip), %rsi     # 0x3e9ad
movl $0x2, %edx
callq 0xa390
movb $0x0, (%rbx)
andb %bpl, %r15b
cmpb $0x1, %r15b
jne 0x26cb5
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0xa390
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26952
movb $0x1, 0x1(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x3bf9(%rip), %rbx      # 0x6200
movq %rbx, %rdi
callq 0x22e0
movl 0x3be6(%rip), %r14d     # 0x61fc
leal 0x1(%r14), %eax
movl %eax, 0x3bdc(%rip)      # 0x61fc
movq %rbx, %rdi
callq 0x21c0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %r13
leaq 0x40(%rsp), %rbp
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2a02
movq %r13, %rdi
leaq 0x1bcc(%rip), %rsi      # 0x4249
callq 0x2080
testl %eax, %eax
je 0x27ab
leaq 0x3b6f(%rip), %r12      # 0x6200
movq %r12, %rdi
callq 0x22e0
movl 0x3b5c(%rip), %r15d     # 0x61fc
leal 0x1(%r15), %eax
movl %eax, 0x3b52(%rip)      # 0x61fc
movq %r12, %rdi
callq 0x21c0
movl $0x1, %edx
movq 0x390a(%rip), %rdi      # 0x5fc8
leaq 0x193f(%rip), %rsi      # 0x4004
callq 0x2280
movq 0x38f7(%rip), %rdi      # 0x5fc8
movl %r15d, %esi
callq 0x2350
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
leaq 0x191b(%rip), %rsi      # 0x4006
callq 0x2280
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x2280
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq %rbp, %rdi
callq 0x2180
movl $0x11, %edx
leaq 0x50(%rsp), %rdi
leaq 0x18c5(%rip), %rsi      # 0x4009
callq 0x2280
leaq 0x50(%rsp), %rdi
movl %r15d, %esi
callq 0x2350
movq %r14, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2310
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a6e
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x278a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2250
movq %rbp, %rdi
movq 0x3814(%rip), %rsi      # 0x5fa8
callq 0x21a0
leaq 0xc0(%rsp), %rdi
callq 0x20c0
jmp 0x2668
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x27cf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2250
xorl %eax, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x280b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2250
jmp 0x280b
jmp 0x282b
jmp 0x282b
movq %rax, %rbx
movq 0x3796(%rip), %rsi      # 0x5fa8
leaq 0x40(%rsp), %rdi
callq 0x21a0
leaq 0xc0(%rsp), %rdi
callq 0x20c0
jmp 0x282e
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq (%rsp), %rdi
cmpq %rax, %rdi
je 0x2849
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x2968
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x2b56
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x2320
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x2150
movq 0x3702(%rip), %rsi      # 0x5fa8
leaq 0x28(%rsp), %rdi
callq 0x21a0
leaq 0xa8(%rsp), %rdi
callq 0x20c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28d8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2250
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x2240
movq %rax, %rbx
movl 0x4(%rsp), %esi
movq %rax, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x2b94
movq 0x36c9(%rip), %r14      # 0x5fc8
leaq 0x1725(%rip), %rsi      # 0x402b
movl $0xf, %edx
movq %r14, %rdi
callq 0x2280
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
leaq -0x30e(%rip), %r14      # 0x2633
movq %rbx, %rdi
callq 0x38aa
movq %rax, %r15
movl $0x8, %edi
callq 0x2240
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2390
jmp 0x2941
movq 0x3681(%rip), %rdi      # 0x5ff0
leaq 0x16a5(%rip), %rsi      # 0x401b
callq 0x2230
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x2230
leaq 0x1696(%rip), %rsi      # 0x4023
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2100
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2290
movq %rax, %r14
movl $0x1e0, %esi            # imm = 0x1E0
movq %rbx, %rdi
jmp 0x29f0
movq %rax, %r14
movq 0x35ea(%rip), %rsi      # 0x5fa8
leaq 0x28(%rsp), %rdi
callq 0x21a0
leaq 0xa8(%rsp), %rdi
callq 0x20c0
jmp 0x29da
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2250
jmp 0x29fa
movq %rax, %r14
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq 0x2e10(%rip), %rdi      # 0x3fd8
movl $0xa, %esi
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x90, %rsp
movw $0x1, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x2c(%rsp)
movaps 0x1681(%rip), %xmm1     # 0x3010
movups %xmm1, 0x3c(%rsp)
xorl %eax, %eax
movq %rax, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x70(%rsp)
movq %rax, 0x80(%rsp)
leaq 0x1775(%rip), %rdi      # 0x3131
xorl %esi, %esi
xorl %eax, %eax
callq 0x1180
testl %eax, %eax
js 0x1a13
movl %eax, %ebp
leaq 0x8(%rsp), %r14
movl %eax, 0x50(%r14)
movl $0x1, 0x80(%r14)
movl $0x20, %edx
movl %eax, %edi
movq %r14, %rsi
callq 0x21bb
movl %eax, %ebx
cmpl $0x0, 0x78(%r14)
je 0x1a1a
movl %ebp, %edi
callq 0x10e0
movl $0xffffffff, 0x58(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x88(%rsp)
jmp 0x1a1a
callq 0x1050
movl (%rax), %ebx
testl %ebx, %ebx
jne 0x1b31
leaq 0x8(%rsp), %rdi
callq 0x1b5e
testl %eax, %eax
jne 0x1b38
movq 0x30(%rsp), %rax
movq 0x50(%rsp), %rbx
xorps %xmm0, %xmm0
testq %rax, %rax
je 0x1a55
xorl %ecx, %ecx
addss (%rbx,%rcx,4), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x1a48
divss 0x15d3(%rip), %xmm0     # 0x3030
addss 0x15cf(%rip), %xmm0     # 0x3034
andps 0x15b4(%rip), %xmm0     # 0x3020
movss 0x15c4(%rip), %xmm1     # 0x3038
ucomiss %xmm0, %xmm1
jbe 0x1b3f
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a95
callq 0x1030
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1aad
callq 0x1030
movq $0x0, 0x28(%rsp)
testq %rbx, %rbx
je 0x1acb
cmpq $0x0, 0x60(%rsp)
jne 0x1acb
movq %rbx, %rdi
callq 0x1030
movq $0x0, 0x50(%rsp)
cmpl $0x0, 0x80(%rsp)
je 0x1aed
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1170
movq $0x0, 0x60(%rsp)
movl 0x58(%rsp), %edi
testl %edi, %edi
js 0x1b02
callq 0x10e0
movl $0xffffffff, 0x58(%rsp) # imm = 0xFFFFFFFF
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1b1a
callq 0x1030
movq $0x0, 0x70(%rsp)
leaq 0x176b(%rip), %rdi      # 0x328c
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1060
movl %ebx, %edi
callq 0x1268
movl %eax, %edi
callq 0x1294
leaq 0x1630(%rip), %rdi      # 0x3176
leaq 0x15bb(%rip), %rsi      # 0x3108
leaq 0x1672(%rip), %rcx      # 0x31c6
movl $0x79, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x88, %rsp
leaq 0x1204(%rip), %rdi      # 0x3213
leaq 0x123b(%rip), %rsi      # 0x3251
callq 0x1190
testq %rax, %rax
je 0x2191
movq %rax, %rbx
movq %rax, %rdi
callq 0x1130
movq %rsp, %rsi
movw $0x1, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x24(%rsi)
movaps 0xfc3(%rip), %xmm1      # 0x3010
movups %xmm1, 0x34(%rsi)
xorl %ecx, %ecx
movq %rcx, 0x48(%rsi)
movl $0x0, 0x50(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x68(%rsi)
movq %rcx, 0x78(%rsi)
movl $0x20, %edx
movl %eax, %edi
callq 0x21bb
testl %eax, %eax
jne 0x2082
movq %rsp, %rdi
callq 0x1b5e
testl %eax, %eax
jne 0x2196
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x2172
movq 0x48(%rsp), %r14
xorl %ecx, %ecx
xorl %edx, %edx
addq (%r14,%rdx,8), %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x20a1
cmpq $0x1356, %rcx           # imm = 0x1356
jne 0x2172
movq %rbx, %rdi
callq 0x1080
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20da
callq 0x1030
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x20f2
callq 0x1030
movq $0x0, 0x20(%rsp)
testq %r14, %r14
je 0x2110
cmpq $0x0, 0x58(%rsp)
jne 0x2110
movq %r14, %rdi
callq 0x1030
movq $0x0, 0x48(%rsp)
cmpl $0x0, 0x78(%rsp)
je 0x212f
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x1170
movq $0x0, 0x58(%rsp)
movl 0x50(%rsp), %edi
testl %edi, %edi
js 0x2144
callq 0x10e0
movl $0xffffffff, 0x50(%rsp) # imm = 0xFFFFFFFF
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x215c
callq 0x1030
movq $0x0, 0x68(%rsp)
leaq 0x1143(%rip), %rdi      # 0x32a6
addq $0x88, %rsp
popq %rbx
popq %r14
jmp 0x1060
leaq 0xfaa(%rip), %rdi       # 0x3123
leaq 0xf88(%rip), %rsi       # 0x3108
leaq 0x10b2(%rip), %rcx      # 0x3239
movl $0xce, %edx
callq 0x10d0
callq 0x1352
movl %eax, %edi
callq 0x1326
// File: /workspace/github_cpp_makefile_star2_O1/onai[P]npio/npio_test_c.c
// Function: main
int main()
{
  test1();
  test2();
  test3();
  test4();
  test5();
  return 0;
}

// Assembly:
pushq %rax
callq 0x145c
callq 0x16d9
callq 0x1964
callq 0x1d20
callq 0x1ffe
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/onai[P]npio/./npio.h
// Function: npio_load_header_fd3
static inline int npio_load_header_fd3(int fd, npio_Array* array, size_t max_dim)
{
  ssize_t file_size;
  char *p;

  /* Store the file descriptor for load_data */
  if (!array->_opened)
    array->_fd = fd;

  /* Get the file size in preparation to mmap */
  file_size = lseek(fd, 0, SEEK_END);

  /* If we could not lseek, fallback on read. */
  if (file_size < 0)
    return npio_load_header_fd_read_(fd, array, max_dim);

  /* map-in the file */
  p = (char*) mmap(0, file_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
  if (p == MAP_FAILED)
  {
    if (lseek(fd, 0, SEEK_SET))
      return errno;
    return npio_load_header_fd_read_(fd, array, max_dim);
  }

  array->_mmapped = 1;
  array->_buf = p;
  array->_buf_size = file_size;

  return npio_load_header_mem4(p, file_size, array, max_dim);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x0, 0x80(%rsi)
jne 0x21d6
movl %ebp, 0x50(%rbx)
movl %ebp, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10c0
testq %rax, %rax
js 0x226e
movq %rax, %r14
xorl %edi, %edi
movq %rax, %rsi
movl $0x3, %edx
movl $0x2, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x10a0
cmpq $-0x1, %rax
je 0x2252
movl $0x1, 0x78(%rbx)
movq %rax, 0x58(%rbx)
movq %r14, 0x60(%rbx)
movl $0x16, %ecx
cmpq $0x10, %r14
jb 0x2308
movl $0x4d554e93, %ecx       # imm = 0x4D554E93
xorl (%rax), %ecx
movzwl 0x4(%rax), %edx
xorl $0x5950, %edx           # imm = 0x5950
orl %ecx, %edx
je 0x2285
xorl %edx, %edx
movl $0x16, %ecx
movq %rax, %rsi
jmp 0x22e1
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10c0
testq %rax, %rax
je 0x226e
callq 0x1050
movl (%rax), %ecx
jmp 0x2308
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2321
movzbl 0x6(%rax), %ecx
movb %cl, (%rbx)
movb 0x7(%rax), %dl
movb %dl, 0x1(%rbx)
cmpl $0x2, %ecx
je 0x22af
cmpl $0x1, %ecx
jne 0x2315
movsbl 0x8(%rax), %edx
movsbl 0x9(%rax), %ecx
shll $0x8, %ecx
addl %edx, %ecx
movl $0xa, %esi
jmp 0x22d3
movsbl 0x8(%rax), %ecx
movsbl 0x9(%rax), %edx
shll $0x8, %edx
addl %ecx, %edx
movsbl 0xa(%rax), %esi
shll $0x10, %esi
movzbl 0xb(%rax), %ecx
shll $0x18, %ecx
addl %esi, %ecx
addl %edx, %ecx
movl $0xc, %esi
movslq %ecx, %rcx
movq %rcx, 0x8(%rbx)
addq %rax, %rsi
xorl %ecx, %ecx
movb $0x1, %dl
testb %dl, %dl
je 0x2308
addq %r14, %rax
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2472
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %edx, %edx
movl $0x5f, %ecx
jmp 0x224a
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addq $0x8, %rdi
movq 0x10(%r14), %rdx
leaq 0x88c4(%rip), %rcx      # 0xe468
movl $0x9, %r8d
xorl %esi, %esi
callq 0x33d0
movl %ebx, 0x150(%r14)
movl $0x1, (%r14)
movq 0x220(%r14), %rdx
addq $0x218, %r14            # imm = 0x218
leaq 0x889e(%rip), %rcx      # 0xe472
movl $0xb, %r8d
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x33d0