LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IConfig const> const&) const
virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
            FactoryMap::const_iterator it =  m_factories.find( name );
            if( it == m_factories.end() )
                return CATCH_NULL;
            return it->second->create( ReporterConfig( config ) );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x19190
addq $0x10, %r14
cmpq %r14, %rax
je 0x190cc
movq 0x40(%rax), %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11c00
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rax)
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11ae6
jmp 0x190ce
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11ae6
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/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 {
                    return tryTranslators();
                }
                @catch (NSException *exception) {
                    return Catch::toString( [exception description] );
                }
#else
                return tryTranslators();
#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 "Unknown exception";
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1939c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x5, %r14d
je 0x192dc
cmpl $0x4, %r14d
jne 0x19289
callq 0xc1c0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11b1a
jmp 0x192d2
cmpl $0x3, %r14d
jne 0x192a1
callq 0xc1c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc650
jmp 0x192d2
callq 0xc1c0
cmpl $0x2, %r14d
jne 0x192be
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11b1a
jmp 0x192d2
leaq 0x1c9a5(%rip), %rsi     # 0x35c6a
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x11b1a
callq 0xc790
jmp 0x1924c
callq 0xc1c0
callq 0xc6a0
movq %rax, %rbx
callq 0xc790
jmp 0x19316
movq %rax, %rbx
callq 0xc790
jmp 0x19316
movq %rax, %rbx
callq 0xc790
jmp 0x19316
movq %rax, %rbx
callq 0xc790
jmp 0x19316
movq %rax, %rbx
callq 0xc790
movq %rbx, %rdi
callq 0xc840
movq %rax, %rdi
callq 0x12660
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Context::getGeneratorsForCurrentTest()
IGeneratorsForTest& getGeneratorsForCurrentTest() {
            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
            if( !generators ) {
                std::string testName = getResultCapture()->getCurrentTestName();
                generators = createGeneratorsForTest();
                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
            }
            return *generators;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x19c60
movq %rax, %r14
testq %rax, %rax
jne 0x19c30
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rsp, %rdi
movq %rax, %rsi
callq *0x40(%rcx)
callq 0xe5e7
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xc650
leaq 0x20(%rsp), %rsi
movq %r14, 0x20(%rsi)
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x19d3e
leaq 0x20(%rsp), %rdi
callq 0xc978
movq %rsp, %rdi
callq 0xc978
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc978
jmp 0x19c4f
jmp 0x19c4c
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/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
                : CATCH_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 *0x40(%rcx)
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x19cc8
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x19c9c
movq 0x40(%rax), %rbx
jmp 0x19c9e
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::GeneratorsForTest::getGeneratorInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
            if( it == m_generatorsByName.end() ) {
                IGeneratorInfo* info = new GeneratorInfo( size );
                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
                m_generatorsInOrder.push_back( info );
                return *info;
            }
            return *it->second;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x1a17a
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x19fdf
movq 0x40(%rax), %rax
jmp 0x1a041
pushq $0x18
popq %rdi
callq 0xc4e0
movq %rax, %r13
leaq 0x39307(%rip), %rax     # 0x532f8
movq %rax, (%r13)
movq %r12, 0x8(%r13)
andq $0x0, 0x10(%r13)
movq %r13, (%rsp)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xc650
movq %r13, 0x20(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a218
leaq 0x8(%rsp), %rdi
callq 0xc978
addq $0x38, %rbx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a15c
movq (%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Matchers::Impl::Generic::AllOf<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
virtual bool match( ExpressionT const& expr ) const
            {
                for( std::size_t i = 0; i < m_matchers.size(); ++i )
                    if( !m_matchers[i]->match( expr ) )
                        return false;
                return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ecx, %ecx
movq %rcx, %r15
movq 0x10(%r14), %rax
movq 0x18(%r14), %r12
subq %rax, %r12
sarq $0x3, %r12
cmpq %r12, %rcx
jae 0x1a8c0
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x28(%rax)
leaq 0x1(%r15), %rcx
testb %al, %al
jne 0x1a894
cmpq %r12, %r15
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Matchers::Impl::Generic::AllOf<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::toString() const
virtual std::string toString() const {
                std::ostringstream oss;
                oss << "( ";
                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
                    if( i != 0 )
                        oss << " and ";
                    oss << m_matchers[i]->toString();
                }
                oss << " )";
                return oss.str();
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xc640
leaq 0x1b1f5(%rip), %rsi     # 0x35af2
movq %r15, %rdi
callq 0xc4d0
xorl %ebp, %ebp
movq %rsp, %r15
leaq 0x20(%rsp), %r12
leaq 0x1b43e(%rip), %r13     # 0x35d54
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbp
jae 0x1a963
testq %rbp, %rbp
je 0x1a93e
movq %r12, %rdi
movq %r13, %rsi
callq 0xc4d0
movq 0x10(%r14), %rax
movq (%rax,%rbp,8), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0xc430
movq %r15, %rdi
callq 0xc978
incq %rbp
jmp 0x1a916
leaq 0x1b028(%rip), %rsi     # 0x35992
leaq 0x20(%rsp), %rdi
callq 0xc4d0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xc720
leaq 0x20(%rsp), %rdi
callq 0xc0e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a9b1
jmp 0x1a9b1
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc978
jmp 0x1a9b4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc0e0
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->noMatchingTestCases( spec );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1acdb
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x28(%rax)
addq $0x8, %r14
jmp 0x1acc4
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testRunStarting(Catch::TestRunInfo const&)
virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testRunStarting( testRunInfo );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1ad09
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x30(%rax)
addq $0x8, %r14
jmp 0x1acf2
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testGroupStarting(Catch::GroupInfo const&)
virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testGroupStarting( groupInfo );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1ad37
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
addq $0x8, %r14
jmp 0x1ad20
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testCaseStarting(Catch::TestCaseInfo const&)
virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testCaseStarting( testInfo );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1ad65
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
addq $0x8, %r14
jmp 0x1ad4e
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::sectionStarting(Catch::SectionInfo const&)
virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->sectionStarting( sectionInfo );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1ad93
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x48(%rax)
addq $0x8, %r14
jmp 0x1ad7c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::assertionStarting(Catch::AssertionInfo const&)
virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->assertionStarting( assertionInfo );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1adc1
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r14
jmp 0x1adaa
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::assertionEnded(Catch::AssertionStats const&)
virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
        bool clearBuffer = false;
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            clearBuffer |= (*it)->assertionEnded( assertionStats );
        return clearBuffer;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x1adf6
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x58(%rax)
orb %al, %bpl
addq $0x8, %r14
jmp 0x1addc
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::sectionEnded(Catch::SectionStats const&)
virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->sectionEnded( sectionStats );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1ae2f
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x60(%rax)
addq $0x8, %r14
jmp 0x1ae18
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testCaseEnded(Catch::TestCaseStats const&)
virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testCaseEnded( testCaseStats );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1ae5d
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x68(%rax)
addq $0x8, %r14
jmp 0x1ae46
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testGroupEnded(Catch::TestGroupStats const&)
virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testGroupEnded( testGroupStats );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1ae8b
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x70(%rax)
addq $0x8, %r14
jmp 0x1ae74
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testRunEnded( testRunStats );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1aeb9
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x78(%rax)
addq $0x8, %r14
jmp 0x1aea2
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::skipTest(Catch::TestCaseInfo const&)
virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->skipTest( testInfo );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x1aeea
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x80(%rax)
addq $0x8, %r14
jmp 0x1aed0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlWriter::endElement()
XmlWriter& endElement() {
            newlineIfNecessary();
            m_indent = m_indent.substr( 0, m_indent.size()-2 );
            if( m_tagIsOpen ) {
                stream() << "/>\n";
                m_tagIsOpen = false;
            }
            else {
                stream() << m_indent << "</" << m_tags.back() << ">\n";
            }
            m_tags.pop_back();
            return *this;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x1b2b0
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc520
movq %r14, %rdi
movq %r15, %rsi
callq 0xc5d0
movq %r15, %rdi
callq 0xc978
movq 0x40(%rbx), %rdi
cmpb $0x1, (%rbx)
jne 0x1b264
leaq 0x1ab00(%rip), %rsi     # 0x35d5a
callq 0xc4d0
movb $0x0, (%rbx)
jmp 0x1b29a
movq %r14, %rsi
callq 0xc430
leaq 0x1aaeb(%rip), %rsi     # 0x35d5e
movq %rax, %rdi
callq 0xc4d0
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
movq %rax, %rdi
callq 0xc430
leaq 0x1aac9(%rip), %rsi     # 0x35d5b
movq %rax, %rdi
callq 0xc4d0
leaq 0x8(%rbx), %rdi
callq 0x1b2d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
OptBuilder operator[]( std::string const& optName ) {
            m_options.push_back( Arg() );
            addOptName( m_options.back(), optName );
            OptBuilder builder( &m_options.back() );
            return builder;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x1cf78
movq %r12, %rdi
movq %r13, %rsi
callq 0x1d246
leaq 0x8(%rsp), %rdi
callq 0x1cfb4
movq $-0xa8, %r12
movq 0x10(%r14), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x1cfca
addq 0x10(%r14), %r12
movq %r12, (%rbx)
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1cfb4
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::addWarning(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void addWarning( ConfigData& config, std::string const& _warning ) {
        if( _warning == "NoAssertions" )
            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
        else
            throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x199e2(%rip), %rsi     # 0x36295
movq %r14, %rdi
callq 0x12e35
testb %al, %al
je 0x1c8cc
orb $0x1, 0x18(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x199c4(%rip), %rsi     # 0x362a2
movq %rsp, %rdi
movq %r14, %rdx
callq 0x12399
leaq 0x19942(%rip), %rdx     # 0x36232
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x12772
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xc770
xorl %ebp, %ebp
movq 0x376da(%rip), %rsi     # 0x53ff0
movq 0x3766b(%rip), %rdx     # 0x53f88
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xc978
jmp 0x1c93a
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xc978
testb %bpl, %bpl
jne 0x1c94c
jmp 0x1c954
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
movq %r14, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/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.reset( new Arg() );
            ArgBuilder builder( m_floatingArg.get() );
            return builder;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x1c998
movq %rdi, %rbx
movl $0xa8, %edi
callq 0xc4e0
movq %rax, %r14
movq %rax, %rdi
callq 0x1cf78
addq $0x50, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1dea6
movq (%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x19910(%rip), %rsi     # 0x362ba
movq %rax, %rdi
callq 0xc680
movq 0x3760f(%rip), %rsi     # 0x53fc8
movq 0x375d8(%rip), %rdx     # 0x53f98
movq %rbx, %rdi
callq 0xc800
movq %rax, %r15
movq %rbx, %rdi
callq 0xc390
jmp 0x1c9e5
movq %rax, %r15
movl $0xa8, %esi
movq %r14, %rdi
callq 0xc500
movq %r15, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::loadTestNamesFromFile(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
        std::ifstream f( _filename.c_str() );
        if( !f.is_open() )
            throw std::domain_error( "Unable to load input file: " + _filename );

        std::string line;
        while( std::getline( f, line ) ) {
            line = trim(line);
            if( !line.empty() && !startsWith( line, "#" ) )
                addTestOrTags( config, "\"" + line + "\"," );
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x60(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0xc890
leaq 0xd8(%rsp), %rdi
callq 0xc0d0
testb %al, %al
je 0x1cbbd
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0xa0, %rbx
leaq 0x60(%rsp), %r14
movq %rsp, %r15
leaq 0x20(%rsp), %r12
leaq 0x40(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0xc0b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1cb99
movq %r12, %rdi
movq %r15, %rsi
callq 0xf453
movq %r15, %rdi
movq %r12, %rsi
callq 0xc5d0
movq %r12, %rdi
callq 0xc978
cmpq $0x0, 0x8(%rsp)
je 0x1cae5
movq %r12, %rdi
leaq 0x194fa(%rip), %rsi     # 0x3602c
movq %rbp, %rdx
callq 0x11b1a
movq %r15, %rdi
movq %r12, %rsi
callq 0xe8e2
movl %eax, %r13d
movq %r12, %rdi
callq 0xc978
testb %r13b, %r13b
jne 0x1cae5
movq %rbp, %rdi
leaq 0x18dc9(%rip), %rsi     # 0x35928
movq %r15, %rdx
callq 0x12399
movq %r12, %rdi
movq %rbp, %rsi
leaq 0x1978e(%rip), %rdx     # 0x36302
callq 0x12772
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1da94
movq %r12, %rdi
callq 0xc978
movq %rbp, %rdi
callq 0xc978
jmp 0x1cae5
movq %rsp, %rdi
callq 0xc978
leaq 0x60(%rsp), %rdi
callq 0xc100
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc230
movq %rax, %r14
leaq 0x19717(%rip), %rsi     # 0x362e6
movq %rsp, %rdi
movq %r15, %rdx
callq 0x12399
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc5b0
xorl %ebp, %ebp
movq 0x3736f(%rip), %rsi     # 0x53f60
movq 0x37388(%rip), %rdx     # 0x53f80
movq %r14, %rdi
callq 0xc800
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc978
testb %bpl, %bpl
jne 0x1cc15
jmp 0x1cc58
movq %rax, %rbx
movq %r14, %rdi
callq 0xc390
jmp 0x1cc58
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc978
jmp 0x1cc31
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x1cc42
jmp 0x1cc4d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc978
jmp 0x1cc50
jmp 0x1cc4d
jmp 0x1cc4d
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc978
leaq 0x60(%rsp), %rdi
callq 0xc100
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::setOrder(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setOrder( ConfigData& config, std::string const& order ) {
        if( startsWith( "declared", order ) )
            config.runOrder = RunTests::InDeclarationOrder;
        else if( startsWith( "lexical", order ) )
            config.runOrder = RunTests::InLexicographicalOrder;
        else if( startsWith( "random", order ) )
            config.runOrder = RunTests::InRandomOrder;
        else
            throw std::runtime_error( "Unrecognised ordering: '" + order + "'" );
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19686(%rip), %rsi     # 0x36305
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x11b1a
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xe8e2
movl %eax, %ebp
movq %rsp, %rdi
callq 0xc978
xorl %eax, %eax
testb %bpl, %bpl
jne 0x1cd0b
leaq 0x1965f(%rip), %rsi     # 0x3630e
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x11b1a
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xe8e2
movl %eax, %ebp
movq %rsp, %rdi
callq 0xc978
testb %bpl, %bpl
je 0x1ccda
pushq $0x1
jmp 0x1cd0a
leaq 0x19635(%rip), %rsi     # 0x36316
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x11b1a
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xe8e2
movl %eax, %ebp
movq %rsp, %rdi
callq 0xc978
testb %bpl, %bpl
je 0x1cd18
pushq $0x2
popq %rax
movl %eax, 0x20(%r14)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc230
movq %rax, %r14
leaq 0x195f3(%rip), %rsi     # 0x3631d
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0x12399
leaq 0x194f4(%rip), %rdx     # 0x36232
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x12772
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc770
xorl %ebp, %ebp
movq 0x3728e(%rip), %rsi     # 0x53ff0
movq 0x3721f(%rip), %rdx     # 0x53f88
movq %r14, %rdi
callq 0xc800
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc978
jmp 0x1cd84
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xc978
testb %bpl, %bpl
jne 0x1cd98
jmp 0x1cdba
movq %rax, %rbx
movq %r14, %rdi
callq 0xc390
jmp 0x1cdba
jmp 0x1cdaa
jmp 0x1cdb7
jmp 0x1cdaa
jmp 0x1cdb7
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc978
jmp 0x1cdba
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::setRngSeed(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setRngSeed( ConfigData& config, std::string const& seed ) {
        if( seed == "time" ) {
            config.rngSeed = static_cast<unsigned int>( std::time(0) );
        }
        else {
            std::stringstream ss;
            ss << seed;
            ss >> config.rngSeed;
            if( ss.fail() )
                throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" );
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1955d(%rip), %rsi     # 0x36336
movq %r14, %rdi
callq 0x12e35
testb %al, %al
je 0x1cdf1
xorl %edi, %edi
callq 0xc480
movl %eax, 0x10(%rbx)
jmp 0x1ce2c
movq %rsp, %rdi
callq 0xc360
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xc430
addq $0x10, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xc830
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x1ce37
movq %rsp, %rdi
callq 0xc3c0
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x194f2(%rip), %rsi     # 0x3633b
movq %rax, %rdi
callq 0xc1a0
movq 0x37198(%rip), %rsi     # 0x53ff0
movq 0x37129(%rip), %rdx     # 0x53f88
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
jmp 0x1ce77
movq %rax, %r14
movq %rsp, %rdi
callq 0xc3c0
movq %r14, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::Detail::BoundArgFunction<Catch::ConfigData>::operator=(Catch::Clara::Detail::BoundArgFunction<Catch::ConfigData> const&)
BoundArgFunction& operator = ( BoundArgFunction const& other ) {
                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL;
                delete functionObj;
                functionObj = newFunctionObj;
                return *this;
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1cec8
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %r14
jmp 0x1cecb
xorl %r14d, %r14d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ced9
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::Detail::convertInto(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&)
inline void convertInto( std::string const& _source, bool& _dest ) {
            std::string sourceLC = _source;
            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower );
            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
                _dest = true;
            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
                _dest = false;
            else
                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc650
movq (%r15), %r12
movq 0x8(%r15), %r15
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x1d808
movsbl (%r12,%r13), %edi
callq 0xc690
movb %al, (%r12,%r13)
incq %r13
jmp 0x1d7f0
leaq 0x1888c(%rip), %rsi     # 0x3609b
leaq 0x8(%rsp), %rdi
callq 0x12e35
movb $0x1, %bpl
testb %al, %al
jne 0x1d8ef
leaq 0x1aad6(%rip), %rsi     # 0x38301
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
jne 0x1d8ef
leaq 0x1abb1(%rip), %rsi     # 0x383f5
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
jne 0x1d8ef
leaq 0x1899b(%rip), %rsi     # 0x361f8
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
jne 0x1d8ef
leaq 0x188fb(%rip), %rsi     # 0x36171
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
jne 0x1d8ef
leaq 0x18680(%rip), %rsi     # 0x35f0b
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
jne 0x1d8ed
leaq 0x1ad02(%rip), %rsi     # 0x385a2
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
jne 0x1d8ed
leaq 0x18143(%rip), %rsi     # 0x359f8
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
jne 0x1d8ed
leaq 0x1872b(%rip), %rsi     # 0x35ff5
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
jne 0x1d8ed
leaq 0x1891d(%rip), %rsi     # 0x361fc
leaq 0x8(%rsp), %rdi
callq 0x12e35
testb %al, %al
je 0x1d90b
xorl %ebp, %ebp
movb %bpl, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0xc978
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x188e3(%rip), %rsi     # 0x36200
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x12399
leaq 0x18901(%rip), %rdx     # 0x36232
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x12772
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xc770
xorl %ebp, %ebp
movq 0x36697(%rip), %rsi     # 0x53ff0
movq 0x36628(%rip), %rdx     # 0x53f88
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xc978
jmp 0x1d97d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0xc978
testb %bpl, %bpl
jne 0x1d991
jmp 0x1d999
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %r14, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::Detail::BoundUnaryFunction<Catch::ConfigData>::set(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
virtual void set( C& obj, std::string const& stringValue ) const {
                bool value;
                convertInto( stringValue, value );
                if( value )
                    function( obj );
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf(%rsp), %r15
movq %rdx, %rdi
movq %r15, %rsi
callq 0x1d7c2
cmpb $0x1, (%r15)
jne 0x1dc91
movq %r14, %rdi
callq *0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: void Catch::Clara::Detail::convertInto<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
void convertInto( std::string const& _source, T& _dest ) {
            std::stringstream ss;
            ss << _source;
            ss >> _dest;
            if( ss.fail() )
                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rsp), %rdi
callq 0xc360
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0xc430
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0xc2c0
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x68(%rsp,%rax)
jne 0x1ddb9
leaq 0x48(%rsp), %rdi
callq 0xc3c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x18469(%rip), %rsi     # 0x36234
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x12399
leaq 0x18468(%rip), %rdx     # 0x36247
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x12772
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xc770
xorl %ebp, %ebp
movq 0x361e9(%rip), %rsi     # 0x53ff0
movq 0x3617a(%rip), %rdx     # 0x53f88
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xc978
jmp 0x1de2b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0xc978
testb %bpl, %bpl
jne 0x1de3f
jmp 0x1de4c
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
jmp 0x1de4c
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xc3c0
movq %r14, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Session::run(int, char const**)
int run( int argc, char const* argv[] ) {

            int returnCode = applyCommandLine( argc, argv );
            if( returnCode == 0 )
                returnCode = run();
            return returnCode;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rcx
callq 0x1e094
testl %eax, %eax
je 0x1e08a
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x1e250
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Session::applyCommandLine(int, char const**, Catch::Session::OnUnusedOptions::DoWhat)
int applyCommandLine( int argc, char const* argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
            try {
                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
                m_unusedTokens = m_cli.parseInto( argc, argv, m_configData );
                if( m_configData.showHelp )
                    showHelp( m_configData.processName );
                m_config.reset();
            }
            catch( std::exception& ex ) {
                {
                    Colour colourGuard( Colour::Red );
                    Catch::cerr()
                        << "\nError(s) in input:\n"
                        << Text( ex.what(), TextAttributes().setIndent(2) )
                        << "\n\n";
                }
                m_cli.usage( Catch::cout(), m_configData.processName );
                return (std::numeric_limits<int>::max)();
            }
            return 0;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %rax
movl %esi, %edx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpl $0x1, %ecx
sete 0x64(%rdi)
leaq 0x80(%rdi), %r8
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x1e324
leaq 0x68(%rbx), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x1fa50
movq %r15, %rdi
callq 0x1c46a
cmpb $0x1, 0x87(%rbx)
jne 0x1e0fe
leaq 0xe8(%rbx), %rsi
movq %rbx, %rdi
callq 0x1e44c
leaq 0x138(%rbx), %rdi
xorl %ebp, %ebp
callq 0x1e4c6
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e120
movq %rax, %r15
cmpl $0x1, %edx
jne 0x1e240
movq %r15, %rdi
callq 0xc1c0
movq %rax, %r12
movb $0x0, 0x6(%rsp)
pushq $0x2
popq %rdi
callq 0xe4b0
movq 0x35e9d(%rip), %rdi     # 0x53fe8
leaq 0x18225(%rip), %rsi     # 0x36377
callq 0xc4d0
movq %rax, %r15
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x11b1a
leaq 0x80(%rsp), %rdx
orq $-0x1, (%rdx)
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
movq $0x2, 0x8(%rdx)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1e530
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x1e4de
leaq 0x18837(%rip), %rsi     # 0x369f0
movq %rax, %rdi
callq 0xc4d0
leaq 0x28(%rsp), %rdi
callq 0x1e8c0
leaq 0x8(%rsp), %rdi
callq 0xc978
leaq 0x6(%rsp), %rdi
callq 0xe5a2
addq $0xe8, %rbx
movq 0x35dbb(%rip), %rsi     # 0x53fa8
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1e8d6
callq 0xc790
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jmp 0x1e10c
jmp 0x1e215
movq %rax, %r15
jmp 0x1e227
jmp 0x1e210
movq %rax, %r15
jmp 0x1e231
movq %rax, %r15
jmp 0x1e23b
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x1e8c0
leaq 0x8(%rsp), %rdi
callq 0xc978
leaq 0x6(%rsp), %rdi
callq 0xe5a2
callq 0xc790
movq %r15, %rdi
callq 0xc840
movq %rax, %rdi
callq 0x12660
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Session::run()
int run() {
            if( m_configData.showHelp )
                return 0;

            try
            {
                config(); // Force config to be constructed

                seedRng( *m_config );

                if( m_configData.filenamesAsTags )
                    applyFilenamesAsTags( *m_config );

                // Handle list request
                if( Option<std::size_t> listed = list( config() ) )
                    return static_cast<int>( *listed );

                return static_cast<int>( runTests( m_config ).assertions.failed );
            }
            catch( std::exception& ex ) {
                Catch::cerr() << ex.what() << std::endl;
                return (std::numeric_limits<int>::max)();
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
cmpb $0x0, 0x87(%rdi)
jne 0x1e2c3
movq %rdi, %r14
callq 0x20402
movq 0x138(%r14), %rdi
callq 0xf6e2
leaq 0x138(%r14), %rbx
cmpb $0x1, 0x8a(%r14)
jne 0x1e28f
movq (%rbx), %rdi
callq 0xd72f
movq %r14, %rdi
callq 0x20402
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x20466
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1e2b2
movl (%rax), %eax
jmp 0x1e2c3
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xd37a
movl 0x10(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x1e2cf
jmp 0x1e2cf
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x1e313
movq %rbx, %rdi
callq 0xc1c0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x35cf9(%rip), %rdi     # 0x53fe8
movq %rax, %rsi
callq 0xc4d0
movq %rax, %rdi
callq 0xc220
callq 0xc790
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x1e2c3
movq %rax, %rbx
callq 0xc790
movq %rbx, %rdi
callq 0xc840
movq %rax, %rdi
callq 0x12660
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(int, char const**, Catch::ConfigData&) const
std::vector<Parser::Token> parseInto( int argc, char 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 0x38(%rsp), %r13
leaq 0x18(%rsp), %rdx
movq %r13, %rdi
callq 0x11b1a
leaq 0x18030(%rip), %rsi     # 0x3638c
pushq $-0x1
popq %rdx
movq %r13, %rdi
callq 0xc4b0
cmpq $-0x1, %rax
je 0x1e39f
incq %rax
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %rax, %rdx
callq 0xc520
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %r13
movq %r13, %rsi
callq 0xc5d0
movq %r13, %rdi
callq 0xc978
movq (%r15), %rdi
movq (%rdi), %rax
leaq 0x38(%rsp), %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1e95c
leaq 0x18(%rsp), %rdi
movq %rsp, %rcx
movl %ebp, %esi
movq %r12, %rdx
callq 0x1e970
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x1ea2e
leaq 0x18(%rsp), %rdi
callq 0xc978
movq %rsp, %rdi
callq 0x1c46a
leaq 0x38(%rsp), %rdi
callq 0xc978
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e41f
movq %rax, %rbx
jmp 0x1e431
movq %rax, %rbx
jmp 0x1e439
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xc978
movq %rsp, %rdi
callq 0x1c46a
leaq 0x38(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Tbc::operator<<(std::ostream&, Catch::Tbc::Text const&)
inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
                it != itEnd; ++it ) {
                if( it != _text.begin() )
                    _stream << "\n";
                _stream << *it;
            }
            return _stream;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %r15
movq 0x48(%rsi), %r13
leaq 0x184f5(%rip), %r12     # 0x369f1
cmpq %r13, %r15
je 0x1e523
cmpq 0x40(%r14), %r15
je 0x1e512
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc4d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc430
addq $0x20, %r15
jmp 0x1e4fc
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::usage(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void usage( std::ostream& os, std::string const& procName ) const {
            validate();
            os << "usage:\n  " << procName << " ";
            argSynopsis( os );
            if( !m_options.empty() ) {
                os << " [options]\n\nwhere options are: \n";
                optUsage( os, 2 );
            }
            os << "\n";
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1efe8
leaq 0x17b95(%rip), %rsi     # 0x36485
movq %rbx, %rdi
callq 0xc4d0
movq %rax, %rdi
movq %r15, %rsi
callq 0xc430
leaq 0x17091(%rip), %rsi     # 0x3599b
movq %rax, %rdi
callq 0xc4d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fb7e
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x1e947
leaq 0x17b61(%rip), %rsi     # 0x3648f
movq %rbx, %rdi
callq 0xc4d0
pushq $0x2
popq %rdx
pushq $0x50
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fcd0
leaq 0x180a3(%rip), %rsi     # 0x369f1
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc4d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::populate(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const
std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
            validate();
            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
            unusedTokens = populateFixedArgs( unusedTokens, config );
            unusedTokens = populateFloatingArgs( unusedTokens, config );
            return unusedTokens;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1efe8
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1f066
movq %rsp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1f4ec
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1fa50
movq %r12, %rdi
callq 0x1c46a
movq %rsp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1f5c8
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fa50
movq %r14, %rdi
callq 0x1c46a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1eabd
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c46a
movq %r14, %rdi
callq 0xc840