LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestSpecParser::visitChar(char)
void visitChar( char c ) {
            if( m_mode == None ) {
                switch( c ) {
                case ' ': return;
                case '~': m_exclusion = true; return;
                case '[': return startNewMode( Tag, ++m_pos );
                case '"': return startNewMode( QuotedName, ++m_pos );
                default: startNewMode( Name, m_pos ); break;
                }
            }
            if( m_mode == Name ) {
                if( c == ',' ) {
                    addPattern<TestSpec::NamePattern>();
                    addFilter();
                }
                else if( c == '[' ) {
                    if( subString() == "exclude:" )
                        m_exclusion = true;
                    else
                        addPattern<TestSpec::NamePattern>();
                    startNewMode( Tag, ++m_pos );
                }
            }
            else if( m_mode == QuotedName && c == '"' )
                addPattern<TestSpec::NamePattern>();
            else if( m_mode == Tag && c == ']' )
                addPattern<TestSpec::TagPattern>();
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x1d6fd
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x1d72e
movsbl %sil, %eax
cmpl $0x5b, %eax
je 0x1d78f
cmpl $0x2c, %eax
jne 0x1d80e
movq %rbx, %rdi
callq 0x1d818
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1da1e
movsbl %sil, %eax
cmpl $0x5a, %eax
jg 0x1d74f
cmpl $0x20, %eax
je 0x1d80e
cmpl $0x22, %eax
jne 0x1d7e2
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl $0x2, (%rbx)
jmp 0x1d80a
cmpl $0x2, %eax
setne %cl
cmpb $0x22, %sil
setne %dl
orb %cl, %dl
jne 0x1d76a
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1d818
cmpl $0x5b, %eax
je 0x1d7f9
cmpl $0x7e, %eax
jne 0x1d7e2
movb $0x1, 0x4(%rbx)
jmp 0x1d80e
cmpl $0x3, %eax
setne %al
cmpb $0x5d, %sil
setne %cl
orb %al, %cl
jne 0x1d80e
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1dab0
leaq 0x18(%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
subq %rdx, %rcx
movq %rsp, %r14
movq %r14, %rdi
callq 0xc4d0
leaq 0x2947e(%rip), %rsi     # 0x46c2e
movq %r14, %rdi
callq 0xc100
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1d7d4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
testl %ebp, %ebp
je 0x1d7f5
movq %rbx, %rdi
callq 0x1d818
jmp 0x1d7f9
movq 0x10(%rbx), %rax
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x1d6c8
movb $0x1, 0x4(%rbx)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: void Catch::TestSpecParser::addPattern<Catch::TestSpec::TagPattern>()
void addPattern() {
            std::string token = subString();
            if( startsWith( token, "exclude:" ) ) {
                m_exclusion = true;
                token = token.substr( 8 );
            }
            if( !token.empty() ) {
                Ptr<TestSpec::Pattern> pattern = new T( token );
                if( m_exclusion )
                    pattern = new TestSpec::ExcludedPattern( pattern );
                m_currentFilter.m_patterns.push_back( pattern );
            }
            m_exclusion = false;
            m_mode = None;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0xc4d0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x29148(%rip), %rsi     # 0x46c2e
leaq 0x29149(%rip), %rdx     # 0x46c36
leaq 0x8(%rsp), %rdi
callq 0x32d7e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf96e
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1db1f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
testb %bpl, %bpl
je 0x1db6a
movb $0x1, 0x4(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
movq $-0x1, %rcx
callq 0xc4d0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0xc590
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1db6a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
cmpq $0x0, 0x30(%rsp)
je 0x1dc16
movl $0x30, %edi
callq 0xc480
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x41fa7(%rip), %rax     # 0x5fb38
movq %rax, (%r14)
movq %r14, %rdi
addq $0x10, %rdi
leaq 0x28(%rsp), %rsi
callq 0xf9fe
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpb $0x1, 0x4(%rbx)
jne 0x1dbf8
movl $0x18, %edi
callq 0xc480
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x41f9c(%rip), %rax     # 0x5fb70
movq %rax, (%r14)
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%r14)
testq %rdi, %rdi
je 0x1dbeb
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1dee0
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1df1c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1dc16
movq (%rdi), %rax
callq *0x18(%rax)
movb $0x0, 0x4(%rbx)
movl $0x0, (%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dc3b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0xc4a0
jmp 0x1dc8a
jmp 0x1dc9c
jmp 0x1dca4
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
jmp 0x1dc7e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dca7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1dca7
jmp 0x1dca4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1dca7
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1dca7
movq %rax, %rdi
callq 0x15d1b
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dcc2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::WildcardPattern::WildcardPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice)
WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity )
        :   m_caseSensitivity( caseSensitivity ),
            m_wildcard( NoWildcard ),
            m_pattern( adjustCase( pattern ) )
        {
            if( startsWith( m_pattern, "*" ) ) {
                m_pattern = m_pattern.substr( 1 );
                m_wildcard = WildcardAtStart;
            }
            if( endsWith( m_pattern, "*" ) ) {
                m_pattern = m_pattern.substr( 0, m_pattern.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 %rsi, %rax
movq %rdi, %rbx
leaq 0x418ed(%rip), %rcx     # 0x5fad8
movq %rcx, (%rdi)
movl %edx, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1e362
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x29915(%rip), %rsi     # 0x47b30
leaq 0x2990f(%rip), %rdx     # 0x47b31
movq %rsp, %rdi
callq 0x32d7e
movq %rsp, %rsi
movq %r14, %rdi
callq 0xf96e
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1e24d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
testb %bpl, %bpl
je 0x1e293
movq %rsp, %rdi
movl $0x1, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0xc4d0
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc590
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1e28c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movl $0x1, 0xc(%rbx)
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x29890(%rip), %rsi     # 0x47b30
leaq 0x2988a(%rip), %rdx     # 0x47b31
callq 0x32d7e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x10b55
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1e2cf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
testb %bpl, %bpl
je 0x1e30f
movq 0x18(%rbx), %rcx
decq %rcx
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc4d0
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc590
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1e30b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
orb $0x2, 0xc(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e33f
jmp 0x1e33f
jmp 0x1e324
jmp 0x1e33f
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1e342
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1e342
movq %rax, %r14
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x1e35a
movq (%rbx), %rsi
incq %rsi
callq 0xc4a0
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerContext::startRun()
inline ITracker& TrackerContext::startRun() {
        m_rootTracker = new SectionTracker( "{root}", *this, CATCH_NULL );
        m_currentTracker = CATCH_NULL;
        m_runState = Executing;
        return *m_rootTracker;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0xc480
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x28833(%rip), %rsi     # 0x46c37
leaq 0x28832(%rip), %rdx     # 0x46c3d
leaq 0x8(%rsp), %rdi
callq 0x32d7e
movl $0x0, 0x8(%rbx)
leaq 0x418a5(%rip), %rax     # 0x5fcc8
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq %rbx, %rax
addq $0x20, %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
callq 0x32cee
movq %r14, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movl $0x0, 0x58(%rbx)
leaq 0x41c39(%rip), %rax     # 0x600a0
movq %rax, (%rbx)
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ea64
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1e48e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq $0x0, 0x8(%r14)
movl $0x1, 0x10(%r14)
movq (%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movb $0x1, %bpl
jmp 0x1e4ce
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1e4ce
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
testb %bpl, %bpl
je 0x1e4e0
movl $0x60, %esi
movq %rbx, %rdi
callq 0xc4a0
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Totals::delta(Catch::Totals const&) const
Totals delta( Totals const& prevTotals ) const {
            Totals diff = *this - prevTotals;
            if( diff.assertions.failed > 0 )
                ++diff.testCases.failed;
            else if( diff.assertions.failedButOk > 0 )
                ++diff.testCases.failedButOk;
            else
                ++diff.testCases.passed;
            return diff;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1ecf0
xorl %eax, %eax
cmpq $0x0, 0x10(%rbx)
setne %al
shll $0x4, %eax
addq $0x18, %rax
cmpq $0x0, 0x8(%rbx)
movl $0x20, %ecx
cmoveq %rax, %rcx
incq (%rbx,%rcx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::FatalConditionHandler::handleSignal(int)
static void handleSignal( int sig ) {
            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
                if( sig == signalDefs[i].id )
                    fatal( signalDefs[i].name, -sig );
            fatal( "<unknown signal>", -sig );
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movl $0x8, %eax
leaq 0x43883(%rip), %rcx     # 0x624b0
cmpl %ebx, -0x8(%rax,%rcx)
je 0x1ec7c
addq $0x10, %rax
cmpq $0x68, %rax
jne 0x1ec2d
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x27ffb(%rip), %rsi     # 0x46c48
leaq 0x28004(%rip), %rdx     # 0x46c58
leaq 0x8(%rsp), %rdi
callq 0x32d7e
callq 0xf103
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *0x50(%rcx)
jmp 0x1ecab
movq (%rax,%rcx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x14db2
callq 0xf103
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *0x50(%rcx)
negl %ebx
movl %ebx, %edi
callq 0xc580
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x1ecd4
jmp 0x1ece8
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ece8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1ece8
jmp 0x1ece5
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Totals::operator-(Catch::Totals const&) const
Totals operator - ( Totals const& other ) const {
            Totals diff;
            diff.assertions = assertions - other.assertions;
            diff.testCases = testCases - other.testCases;
            return diff;
        }

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rdi
subq (%rdx), %rcx
subq 0x8(%rdx), %rdi
movq 0x10(%rsi), %r8
subq 0x10(%rdx), %r8
movq %rcx, (%rax)
movq %rdi, 0x8(%rax)
movq %r8, 0x10(%rax)
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rdi
subq 0x18(%rdx), %rcx
subq 0x20(%rdx), %rdi
movq 0x28(%rsi), %rsi
subq 0x28(%rdx), %rsi
movq %rcx, 0x18(%rax)
movq %rdi, 0x20(%rax)
movq %rsi, 0x28(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x1f23a
addq $0x10, %rbx
cmpq %rbx, %rax
je 0x1f169
movq 0x40(%rax), %rbx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x8(%rsp)
movq (%r14), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x1f146
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1f16b
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1f16b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x1f193
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1f18b
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xc820
movq %rax, %rdi
callq 0x15d1b
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f45c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x5, %r14d
je 0x1f3e7
cmpl $0x4, %r14d
jne 0x1f37d
callq 0xc190
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14db2
jmp 0x1f3dd
cmpl $0x3, %r14d
jne 0x1f3a3
callq 0xc190
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x32cee
jmp 0x1f3dd
callq 0xc190
cmpl $0x2, %r14d
jne 0x1f3c0
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14db2
jmp 0x1f3dd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x27890(%rip), %rsi     # 0x46c5e
leaq 0x2789a(%rip), %rdx     # 0x46c6f
movq %rbx, %rdi
callq 0x32d7e
callq 0xc750
jmp 0x1f33c
callq 0xc190
callq 0xc660
movq %rax, %rbx
callq 0xc750
jmp 0x1f421
movq %rax, %rbx
callq 0xc750
jmp 0x1f421
movq %rax, %rbx
callq 0xc750
jmp 0x1f421
movq %rax, %rbx
callq 0xc750
jmp 0x1f421
movq %rax, %rbx
callq 0xc750
movq %rbx, %rdi
callq 0xc820
movq %rax, %rdi
callq 0x15d1b
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
callq 0x1fe56
movq %rax, %rbx
testq %rax, %rax
jne 0x1fe05
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x40(%rcx)
movl $0x50, %edi
callq 0xc480
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
addq $0x10, %rax
leaq 0x41374(%rip), %rcx     # 0x610f8
movq %rcx, (%rbx)
movl $0x0, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x32cee
leaq 0x28(%rsp), %rsi
movq %rbx, 0x20(%rsi)
addq $0x20, %r14
movq %r14, %rdi
callq 0x1ff6a
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fdea
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fe05
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fe33
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1fe33
jmp 0x1fe30
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fe4e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fee0
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x1fe92
movq 0x40(%rax), %rbx
jmp 0x1fe94
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1feaf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
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 0x1fed8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x203a4
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x20216
movq 0x40(%rax), %rax
jmp 0x202b6
movl $0x18, %edi
callq 0xc480
leaq 0x40f19(%rip), %rcx     # 0x61140
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x32cee
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x20458
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x20287
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x202a0
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x202b1
addq $0x38, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x20624
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x202dc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0xc5f0
leaq 0x25f6d(%rip), %rsi     # 0x46ae6
movl $0x2, %edx
movq %r15, %rdi
callq 0xc530
movq %rbx, 0x8(%rsp)
movq 0x18(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x20c10
leaq 0x20(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x2619b(%rip), %r13     # 0x46d48
testq %rbx, %rbx
je 0x20bc2
movl $0x5, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0xc530
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0xc530
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x20bfc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
incq %rbx
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x3, %rax
cmpq %rax, %rbx
jb 0x20bad
leaq 0x25d6f(%rip), %rsi     # 0x46986
leaq 0x30(%rsp), %rdi
movl $0x2, %edx
callq 0xc530
movq 0x8(%rsp), %rbx
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xc6f0
movq 0x41349(%rip), %rsi     # 0x61f88
leaq 0x30(%rsp), %rdi
callq 0xc220
leaq 0xa0(%rsp), %rdi
callq 0xc120
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20c6f
jmp 0x20c6f
movq %rax, %rbx
jmp 0x20c8e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x20c8e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x412f3(%rip), %rsi     # 0x61f88
leaq 0x30(%rsp), %rdi
callq 0xc220
leaq 0xa0(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x1, 0x1(%rdi)
jne 0x214bf
movq 0x40(%rbx), %rdi
leaq 0x2652f(%rip), %rsi     # 0x479e0
movl $0x1, %edx
callq 0xc530
movb $0x0, 0x1(%rbx)
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc4d0
movq %r14, %rdi
movq %r15, %rsi
callq 0xc590
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x21500
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x40(%rbx), %rdi
cmpb $0x1, (%rbx)
jne 0x2151f
leaq 0x2583e(%rip), %rsi     # 0x46d4e
movl $0x3, %edx
callq 0xc530
movb $0x0, (%rbx)
jmp 0x2156b
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0xc530
movq %rax, %r14
leaq 0x2581c(%rip), %rsi     # 0x46d52
movl $0x2, %edx
movq %rax, %rdi
callq 0xc530
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq %r14, %rdi
callq 0xc530
leaq 0x257f1(%rip), %rsi     # 0x46d4f
movl $0x2, %edx
movq %rax, %rdi
callq 0xc530
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x2158f
movq (%rax), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x8(%rsi), %rdi
xorl %eax, %eax
leaq 0x28(%rsp), %r13
movq %rax, -0x18(%r13)
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq 0xa0(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq %rax, -0x8(%rbx)
movb %al, (%rbx)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rsi
callq 0x2412c
leaq 0x78(%rsp), %r12
movq 0x18(%r12), %rdi
cmpq %rbx, %rdi
je 0x22dd8
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %r12, %rdi
callq 0x14e2c
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x22df7
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x22e0e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x22e25
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x22e35
movq (%rdi), %rax
callq *0x8(%rax)
movq $-0xa8, %rbx
movq 0x10(%r14), %rdi
addq %rbx, %rdi
movq (%rsp), %rsi
callq 0x23c1c
addq 0x10(%r14), %rbx
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x23b86
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x240bd(%rip), %rsi     # 0x47289
movq %r14, %rdi
callq 0xc100
testl %eax, %eax
jne 0x231e7
orb $0x1, 0x18(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xc1f0
movq %rax, %rbx
leaq 0x2409b(%rip), %rsi     # 0x47296
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x15995
leaq 0x24017(%rip), %rsi     # 0x47226
leaq 0x28(%rsp), %rdi
callq 0xc8b0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2323a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x23247
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xc720
xorl %ebp, %ebp
movq 0x3ed79(%rip), %rsi     # 0x61ff0
movq 0x3ed02(%rip), %rdx     # 0x61f80
movq %rbx, %rdi
callq 0xc7d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x232a8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x232a8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x232cb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x232cb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x232d8
movq %rbx, %rdi
callq 0xc360
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x50(%rdi)
jne 0x23366
movq %rdi, %rbx
movl $0xa8, %edi
callq 0xc480
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 0xc1f0
movq %rax, %rbx
leaq 0x23f34(%rip), %rsi     # 0x472ae
movq %rax, %rdi
callq 0xc640
movq 0x3ec3f(%rip), %rsi     # 0x61fc8
movq 0x3ec08(%rip), %rdx     # 0x61f98
movq %rbx, %rdi
callq 0xc7d0
movq %rax, %r14
movq %rbx, %rdi
callq 0xc360
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23935(%rip), %rsi     # 0x4732a
movq %r14, %rdi
callq 0xc100
testl %eax, %eax
je 0x23a56
movq %rsp, %rdi
callq 0xc330
leaq 0x10(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0xc530
addq $0x10, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xc810
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x23a6b
movq 0x3e4f1(%rip), %rsi     # 0x61f30
movq %rsp, %rdi
callq 0xc380
leaq 0x80(%rsp), %rdi
callq 0xc120
jmp 0x23a60
xorl %edi, %edi
callq 0xc430
movl %eax, 0x10(%rbx)
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xc1f0
movq %rax, %r14
leaq 0x238b0(%rip), %rsi     # 0x4732f
movq %rax, %rdi
callq 0xc170
movq 0x3e562(%rip), %rsi     # 0x61ff0
movq 0x3e4eb(%rip), %rdx     # 0x61f80
movq %r14, %rdi
callq 0xc7d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xc360
jmp 0x23aad
movq %rax, %rbx
movq 0x3e47c(%rip), %rsi     # 0x61f30
movq %rsp, %rdi
callq 0xc380
leaq 0x80(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24834
cmpb $0x1, (%r15)
jne 0x24e75
movq %r14, %rdi
callq *0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rdi
callq 0xc330
leaq 0x50(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0xc530
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0xc280
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rsp,%rax)
jne 0x24fd5
movq 0x3cf80(%rip), %rsi     # 0x61f30
leaq 0x40(%rsp), %rdi
callq 0xc380
leaq 0xc0(%rsp), %rdi
callq 0xc120
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xc1f0
movq %rax, %rbx
leaq 0x2223f(%rip), %rsi     # 0x47228
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x15995
leaq 0x2223e(%rip), %rsi     # 0x4723b
leaq 0x20(%rsp), %rdi
callq 0xc8b0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25028
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x25034
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xc720
xorl %ebp, %ebp
movq 0x3cf8e(%rip), %rsi     # 0x61ff0
movq 0x3cf17(%rip), %rdx     # 0x61f80
movq %rbx, %rdi
callq 0xc7d0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x25092
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x25092
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x250b5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x250b5
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x250c7
movq %rbx, %rdi
callq 0xc360
jmp 0x250c7
movq %rax, %r14
movq 0x3ce62(%rip), %rsi     # 0x61f30
leaq 0x40(%rsp), %rdi
callq 0xc380
leaq 0xc0(%rsp), %rdi
callq 0xc120
movq %r14, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %ecx
callq 0x2538a
testl %eax, %eax
je 0x25380
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x255c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorl %eax, %eax
cmpb $0x0, 0x87(%rdi)
jne 0x256e8
movq %rdi, %r14
callq 0x2869e
movq 0x138(%r14), %rdi
callq 0x110ba
leaq 0x138(%r14), %rbx
cmpb $0x1, 0x8a(%r14)
jne 0x2560d
movq (%rbx), %rdi
callq 0xde45
movq %r14, %rdi
callq 0x2869e
movq %rax, %r14
movq $0x0, (%rsp)
cmpb $0x1, 0x10(%rax)
jne 0x2563a
movq %r14, %rdi
callq 0x28bd0
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, -0x8(%rcx)
cmpb $0x1, 0x13(%r14)
jne 0x25669
movq (%rsp), %rax
testq %rax, %rax
je 0x2564f
movq (%rax), %r15
jmp 0x25652
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x29249
addq %r15, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, -0x8(%rcx)
cmpb $0x1, 0x11(%r14)
jne 0x25698
movq (%rsp), %rax
testq %rax, %rax
je 0x2567e
movq (%rax), %r15
jmp 0x25681
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x294b1
addq %r15, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, -0x8(%rcx)
cmpb $0x1, 0x12(%r14)
jne 0x256c7
movq (%rsp), %rax
testq %rax, %rax
je 0x256ad
movq (%rax), %r15
jmp 0x256b0
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x29e28
addq %r15, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, -0x8(%rcx)
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x256d4
movl (%rcx), %eax
jmp 0x256d4
testq %rcx, %rcx
jne 0x256e8
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xd8bb
movl 0x8(%rsp), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x25709
jmp 0x256fa
jmp 0x256fa
jmp 0x256fa
movq %rax, %rbx
movq $0x0, (%rsp)
jmp 0x2570c
jmp 0x25709
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2574d
movq %rbx, %rdi
callq 0xc190
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x3c8bf(%rip), %rdi     # 0x61fe8
movq %rax, %rsi
callq 0xc470
movq %rax, %rdi
callq 0xc1e0
callq 0xc750
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x256e8
movq %rax, %rbx
callq 0xc750
movq %rbx, %rdi
callq 0xc820
movq %rax, %rdi
callq 0x15d1b
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20(%rsp), %r13
movq %rsp, %rdx
movq %r13, %rdi
callq 0x14db2
leaq 0x21bec(%rip), %rsi     # 0x47380
movl $0x2, %ecx
movq %r13, %rdi
movq $-0x1, %rdx
callq 0xc910
cmpq $-0x1, %rax
je 0x257f3
incq %rax
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0xc4d0
leaq 0x20(%rsp), %rdi
movq %rsp, %r13
movq %r13, %rsi
callq 0xc590
movq (%r13), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x257f3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
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 0x26044
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x26158
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2586b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x40(%rsp), %rdi
callq 0x22c02
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25890
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x258a4
movq %rax, %rbx
jmp 0x258cc
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x258c2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x40(%rsp), %rdi
callq 0x22c02
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x258e7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
movq 0x40(%rsi), %r12
movq 0x48(%rsi), %r13
cmpq %r13, %r12
je 0x259de
movq %rsi, %r14
leaq 0x22032(%rip), %r15     # 0x479e0
cmpq 0x40(%r14), %r12
je 0x259c4
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc530
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xc530
addq $0x20, %r12
cmpq %r13, %r12
jne 0x259ae
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26970
leaq 0x214b8(%rip), %rsi     # 0x47474
movl $0x9, %edx
movq %rbx, %rdi
callq 0xc530
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xc530
leaq 0x209b0(%rip), %rsi     # 0x4698f
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2791c
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x2602a
leaq 0x21476(%rip), %rsi     # 0x4747e
movl $0x20, %edx
movq %rbx, %rdi
callq 0xc530
movl $0x2, %edx
movl $0x50, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27ae4
leaq 0x219af(%rip), %rsi     # 0x479e0
movl $0x1, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc530
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x26970
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x269f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x270d8
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rbx), %rax
movups 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %r12
movq (%r12), %rcx
movq %rcx, (%rbx)
movq 0x8(%r12), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%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 0x22c02
movq %r12, %rdi
callq 0x22c02
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x271de
leaq 0x20(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rbx), %rax
movups 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %r14
movq (%r14), %rcx
movq %rcx, (%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r14)
movq %rdx, 0x8(%r14)
movq %rsi, 0x10(%r14)
callq 0x22c02
movq %r14, %rdi
callq 0x22c02
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x26283
movq %rax, %r14
movq %rbx, %rdi
callq 0x22c02
movq %r14, %rdi
callq 0xc820