LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::populateFixedArgs(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const
std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
            std::vector<Parser::Token> unusedTokens;
            int position = 1;
            for( std::size_t i = 0; i < tokens.size(); ++i ) {
                Parser::Token const& token = tokens[i];
                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
                if( it != m_positionalArgs.end() )
                    it->second.boundField.set( config, token.data );
                else
                    unusedTokens.push_back( token );
                if( token.type == Parser::Token::Positional )
                    position++;
            }
            return unusedTokens;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, %r15
movq %rsi, %r12
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, 0x10(%rsp)
movups %xmm0, (%rdi)
leaq 0xc(%rsp), %rax
movl $0x1, (%rax)
leaq 0x20(%rsi), %rax
movq %rax, 0x20(%rsp)
addq $0x28, %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
movq (%r15), %rbp
movq 0x8(%r15), %rax
subq %rbp, %rax
cqto
pushq $0x28
popq %rcx
idivq %rcx
cmpq %rax, %r14
jae 0x1f59f
movq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1f90c
movq %rbp, %rbx
addq %r13, %rbx
cmpq %r12, %rax
je 0x1f580
leaq 0x8(,%r13), %rdx
addq %rbp, %rdx
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rsp), %rsi
callq *0x10(%rax)
jmp 0x1f58d
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x1ed94
cmpl $0x0, (%rbx)
jne 0x1f596
incl 0xc(%rsp)
incq %r14
addq $0x28, %r13
jmp 0x1f533
movq 0x10(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x1c46a
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::populateFloatingArgs(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const
std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
            if( !m_floatingArg.get() )
                return tokens;
            std::vector<Parser::Token> unusedTokens;
            for( std::size_t i = 0; i < tokens.size(); ++i ) {
                Parser::Token const& token = tokens[i];
                if( token.type == Parser::Token::Positional )
                    m_floatingArg->boundField.set( config, token.data );
                else
                    unusedTokens.push_back( token );
            }
            return unusedTokens;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rsi)
je 0x1f646
movq %rsi, %r12
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
xorl %r13d, %r13d
pushq $0x28
popq %rbp
xorl %r15d, %r15d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
idivq %rbp
cmpq %rax, %r15
jae 0x1f651
cmpl $0x0, (%rsi,%r13)
je 0x1f623
addq %r13, %rsi
movq %rbx, %rdi
callq 0x1ed94
jmp 0x1f63d
movq 0x50(%r12), %rax
leaq (%rsi,%r13), %rdx
addq $0x8, %rdx
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rsp), %rsi
callq *0x10(%rax)
incq %r15
addq $0x28, %r13
jmp 0x1f5fb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f95e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c46a
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>::Arg::commands[abi:cxx11]() const
std::string commands() const {
                std::ostringstream oss;
                bool first = true;
                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
                for(; it != itEnd; ++it ) {
                    if( first )
                        first = false;
                    else
                        oss << ", ";
                    oss << "-" << *it;
                }
                if( !longName.empty() ) {
                    if( !first )
                        oss << ", ";
                    oss << "--" << longName;
                }
                if( !placeholder.empty() )
                    oss << " <" << placeholder << ">";
                return oss.str();
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xc640
movq 0x68(%rbx), %r12
movq %rbx, (%rsp)
movq 0x70(%rbx), %r14
movb $0x1, %bl
leaq 0x174f4(%rip), %r13     # 0x36c17
leaq 0x162ad(%rip), %rbp     # 0x359d7
cmpq %r14, %r12
je 0x1f75f
testb $0x1, %bl
je 0x1f738
xorl %ebx, %ebx
jmp 0x1f743
movq %r15, %rdi
movq %rbp, %rsi
callq 0xc4d0
movq %r15, %rdi
movq %r13, %rsi
callq 0xc4d0
movq %rax, %rdi
movq %r12, %rsi
callq 0xc430
addq $0x20, %r12
jmp 0x1f72a
movq (%rsp), %r15
cmpq $0x0, 0x88(%r15)
movq 0x8(%rsp), %r14
je 0x1f7a8
testb $0x1, %bl
jne 0x1f788
leaq 0x16259(%rip), %rsi     # 0x359d7
leaq 0x10(%rsp), %rdi
callq 0xc4d0
leaq 0x169e5(%rip), %rsi     # 0x36174
leaq 0x10(%rsp), %rdi
callq 0xc4d0
leaq 0x80(%r15), %rsi
movq %rax, %rdi
callq 0xc430
cmpq $0x0, 0x50(%r15)
je 0x1f7de
leaq 0x16c59(%rip), %rsi     # 0x3640f
leaq 0x10(%rsp), %rdi
callq 0xc4d0
addq $0x48, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xc430
leaq 0x1648d(%rip), %rsi     # 0x35c63
movq %rax, %rdi
callq 0xc4d0
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0xc720
leaq 0x10(%rsp), %rdi
callq 0xc0e0
movq %r14, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f80c
movq %rax, %rbx
leaq 0x10(%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::Clara::CommandLine<Catch::ConfigData>::argSynopsis(std::ostream&) const
void argSynopsis( std::ostream& os ) const {
            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
                if( i > 1 )
                    os << " ";
                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
                if( it != m_positionalArgs.end() )
                    os << "<" << it->second.placeholder << ">";
                else if( m_floatingArg.get() )
                    os << "<" << m_floatingArg->placeholder << ">";
                else
                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
            }
            // !TBD No indication of mandatory args
            if( m_floatingArg.get() ) {
                if( m_highestSpecifiedArgPosition > 1 )
                    os << " ";
                os << "[<" << m_floatingArg->placeholder << "> ...]";
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x28(%rdi), %rbp
pushq $0x1
popq %rax
leaq 0x160c2(%rip), %r12     # 0x35c63
movl %eax, 0x4(%rsp)
movl 0x58(%rbx), %ecx
cmpl %ecx, %eax
jg 0x1fc34
cmpl $0x2, %eax
jl 0x1fbc4
movq %r14, %rdi
leaq 0x15ddc(%rip), %rsi     # 0x3599b
callq 0xc4d0
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
callq 0x1f90c
cmpq %rbp, %rax
je 0x1fbf4
movq %rax, %r13
movq %r14, %rdi
leaq 0x1682d(%rip), %rsi     # 0x36410
callq 0xc4d0
addq $0x70, %r13
movq %rax, %rdi
movq %r13, %rsi
jmp 0x1fc19
cmpq $0x0, 0x50(%rbx)
je 0x1fc8c
movq %r14, %rdi
leaq 0x16807(%rip), %rsi     # 0x36410
callq 0xc4d0
movq 0x50(%rbx), %rsi
addq $0x48, %rsi
movq %rax, %rdi
callq 0xc430
movq %rax, %rdi
movq %r12, %rsi
callq 0xc4d0
movl 0x4(%rsp), %eax
incl %eax
jmp 0x1fba1
cmpq $0x0, 0x50(%rbx)
je 0x1fc7d
cmpl $0x2, %ecx
jl 0x1fc4f
leaq 0x15d54(%rip), %rsi     # 0x3599b
movq %r14, %rdi
callq 0xc4d0
leaq 0x16895(%rip), %rsi     # 0x364eb
movq %r14, %rdi
callq 0xc4d0
movq 0x50(%rbx), %rsi
addq $0x48, %rsi
movq %rax, %rdi
callq 0xc430
leaq 0x16879(%rip), %rsi     # 0x364ee
movq %rax, %rdi
callq 0xc4d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x16812(%rip), %rsi     # 0x364b0
movq %rax, %rdi
callq 0xc680
movq 0x3431b(%rip), %rsi     # 0x53fc8
movq 0x342e4(%rip), %rdx     # 0x53f98
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
movq %r14, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::list(Catch::Config const&)
inline Option<std::size_t> list( Config const& config ) {
        Option<std::size_t> listedCount;
        if( config.listTests() )
            listedCount = listedCount.valueOr(0) + listTests( config );
        if( config.listTestNamesOnly() )
            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
        if( config.listTags() )
            listedCount = listedCount.valueOr(0) + listTags( config );
        if( config.listReporters() )
            listedCount = listedCount.valueOr(0) + listReporters( config );
        return listedCount;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
movq %rsi, %r14
cmpb $0x1, 0x10(%rsi)
jne 0x2049a
movq %r14, %rdi
callq 0x208a1
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
cmpb $0x0, 0x13(%r14)
je 0x204ba
movq (%rcx), %r15
jmp 0x204a4
cmpb $0x0, 0x13(%r14)
je 0x204c6
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x20c67
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
cmpb $0x0, 0x11(%r14)
je 0x204e6
movq (%rcx), %r15
jmp 0x204d0
cmpb $0x0, 0x11(%r14)
je 0x2050f
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x20df2
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
cmpb $0x0, 0x12(%r14)
je 0x20506
movq (%rcx), %r15
movq %r14, %rdi
callq 0x21377
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, 0x12(%r14)
je 0x20506
xorl %r15d, %r15d
jmp 0x204f0
jmp 0x20521
jmp 0x20521
jmp 0x20521
andq $0x0, (%rbx)
movq %rax, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Config::Config(Catch::ConfigData const&)
Config( ConfigData const& data )
        :   m_data( data ),
            m_stream( openStream() )
        {
            if( !data.testsOrTags.empty() ) {
                TestSpecParser parser( ITagAliasRegistry::get() );
                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
                    parser.parse( data.testsOrTags[i] );
                m_testSpec = parser.testSpec();
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
andl $0x0, 0x8(%rdi)
movq %rsi, %r12
leaq 0x31b90(%rip), %rax     # 0x520e0
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x206c6
movq %r14, %rdi
callq 0x20790
movq %rax, 0xc8(%r14)
xorps %xmm0, %xmm0
andq $0x0, 0xe0(%r14)
movups %xmm0, 0xd0(%r14)
movq 0xa0(%r12), %rax
cmpq 0xa8(%r12), %rax
je 0x20640
leaq 0xd0(%r14), %rax
movq %rax, 0x8(%rsp)
callq 0x1119a
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
leaq 0x34049(%rip), %rcx     # 0x54618
movq %rcx, 0x40(%rax)
xorl %ebp, %ebp
leaq 0x28(%rsp), %r13
xorl %r15d, %r15d
movq 0xa0(%r12), %rsi
movq 0xa8(%r12), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r15
jae 0x2060d
addq %rbp, %rsi
movq %r13, %rdi
callq 0x11ecc
incq %r15
addq $0x20, %rbp
jmp 0x205dd
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x11f48
leaq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x18470
movq %rbx, %rdi
callq 0x184c2
leaq 0x28(%rsp), %rdi
callq 0x11f74
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20659
movq %rax, %r12
jmp 0x20682
movq %rax, %r12
leaq 0x28(%rsp), %rdi
callq 0x11f74
movq 0x8(%rsp), %rdi
callq 0x184c2
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
je 0x20682
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x1c42e
movq %r12, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::listTestsNamesOnly(Catch::Config const&)
inline std::size_t listTestsNamesOnly( Config const& config ) {
        TestSpec testSpec = config.testSpec();
        if( !config.testSpec().hasFilters() )
            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
        std::size_t matchedTests = 0;
        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
                it != itEnd;
                ++it ) {
            matchedTests++;
            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
            Catch::cout() << testCaseInfo.name << std::endl;
        }
        return matchedTests;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1764e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x20d34
callq 0x1119a
leaq 0x80(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
leaq 0x33948(%rip), %rcx     # 0x54618
movq %rcx, 0x40(%rax)
leaq 0x15e66(%rip), %rsi     # 0x36b41
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x11ecc
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x11f48
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %r14
movq %r14, %rsi
callq 0x18470
movq %r14, %rdi
callq 0x184c2
leaq 0x20(%rsp), %rdi
callq 0xc978
leaq 0x58(%rsp), %rdi
callq 0x11f74
movq %rbx, %rdi
callq 0xd6cd
leaq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
movq %rbx, %rcx
callq 0xdb98
movq 0x58(%rsp), %r14
movq 0x60(%rsp), %r12
xorl %ebx, %ebx
movq 0x33244(%rip), %r15     # 0x53fa8
cmpq %r12, %r14
je 0x20d88
movq %r15, %rdi
movq %r14, %rsi
callq 0xc430
movq %rax, %rdi
callq 0xc220
addq $0x118, %r14            # imm = 0x118
incq %rbx
jmp 0x20d64
leaq 0x58(%rsp), %rdi
callq 0x12522
leaq 0x8(%rsp), %rdi
callq 0x184c2
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x20dc0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc978
leaq 0x58(%rsp), %rdi
callq 0x11f74
jmp 0x20de0
jmp 0x20dce
movq %rax, %rbx
jmp 0x20de0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x12522
leaq 0x8(%rsp), %rdi
callq 0x184c2
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TagInfo::all[abi:cxx11]() const
std::string all() const {
            std::string out;
            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
                        it != itEnd;
                        ++it )
                out += "[" + *it + "]";
            return out;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %r12
addq $0x8, %r14
leaq 0x8(%rsp), %r13
leaq 0x14f5d(%rip), %rbp     # 0x364f3
leaq 0x28(%rsp), %r15
cmpq %r14, %r12
je 0x215ea
leaq 0x20(%r12), %rdx
movq %r13, %rdi
leaq 0x14750(%rip), %rsi     # 0x35cff
callq 0x12399
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x12772
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc900
movq %r15, %rdi
callq 0xc978
movq %r13, %rdi
callq 0xc978
movq %r12, %rdi
callq 0xc570
movq %rax, %r12
jmp 0x2159b
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2161d
movq %rax, %r14
jmp 0x21613
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xc978
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %rbx, %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::sortTests(Catch::IConfig const&, std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&)
inline std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {

        std::vector<TestCase> sorted = unsortedTestCases;

        switch( config.runOrder() ) {
            case RunTests::InLexicographicalOrder:
                std::sort( sorted.begin(), sorted.end(), LexSort() );
                break;
            case RunTests::InRandomOrder:
                {
                    seedRng( config );

                    RandomNumberGenerator rng;
                    std::random_shuffle( sorted.begin(), sorted.end(), rng );
                }
                break;
            case RunTests::InDeclarationOrder:
                // already in declaration order
                break;
        }
        return sorted;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x21fee
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
cmpl $0x1, %eax
je 0x21fc2
cmpl $0x2, %eax
jne 0x21fce
movq %r14, %rdi
callq 0xf6e2
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0x7(%rsp), %rdx
callq 0x2204a
jmp 0x21fce
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x2220c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x21fdb
movq %rax, %r14
movq %rbx, %rdi
callq 0x12522
movq %r14, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
XmlWriter& startElement( std::string const& name ) {
            ensureTagClosed();
            newlineIfNecessary();
            stream() << m_indent << "<" << name;
            m_tags.push_back( name );
            m_indent += "  ";
            m_tagIsOpen = true;
            return *this;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x244f0
movq %rbx, %rdi
callq 0x1b2b0
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %r15
movq %r15, %rsi
callq 0xc430
leaq 0x12005(%rip), %rsi     # 0x36410
movq %rax, %rdi
callq 0xc4d0
movq %rax, %rdi
movq %r14, %rsi
callq 0xc430
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1da94
leaq 0x1205b(%rip), %rsi     # 0x3648c
movq %r15, %rdi
callq 0xc8d0
movb $0x1, (%rbx)
movq %rbx, %rax
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::XmlEncode::encodeTo(std::ostream&) const
void encodeTo( std::ostream& os ) const {

            // Apostrophe escaping not necessary if we always use " to write attributes
            // (see: http://www.w3.org/TR/xml/#syntax)

            for( std::size_t i = 0; i < m_str.size(); ++ i ) {
                char c = m_str[i];
                switch( c ) {
                    case '<':   os << "&lt;"; break;
                    case '&':   os << "&amp;"; break;

                    case '>':
                        // See: http://www.w3.org/TR/xml/#syntax
                        if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' )
                            os << "&gt;";
                        else
                            os << c;
                        break;

                    case '\"':
                        if( m_forWhat == ForAttributes )
                            os << "&quot;";
                        else
                            os << c;
                        break;

                    default:
                        // Escape control chars - based on contribution by @espenalb in PR #465
                        if ( ( c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' )
                            os << "&#x" << std::uppercase << std::hex << static_cast<int>( c );
                        else
                            os << c;
                }
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x122cd(%rip), %r12     # 0x367f6
leaq 0x122c1(%rip), %r15     # 0x367f1
cmpq 0x8(%r14), %r13
jae 0x24620
movq (%r14), %rcx
movzbl (%rcx,%r13), %eax
cmpl $0x22, %eax
je 0x24590
cmpl $0x26, %eax
je 0x2455e
cmpl $0x3e, %eax
je 0x24566
cmpl $0x3c, %eax
jne 0x245a8
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x245a1
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x245a1
cmpq $0x3, %r13
jb 0x245ff
cmpb $0x5d, -0x1(%rcx,%r13)
jne 0x245ff
cmpb $0x5d, -0x2(%rcx,%r13)
jne 0x245ff
movq %rbx, %rdi
leaq 0x1226e(%rip), %rsi     # 0x367fc
jmp 0x245a1
cmpl $0x1, 0x20(%r14)
jne 0x24606
movq %rbx, %rdi
leaq 0x12260(%rip), %rsi     # 0x36801
callq 0xc4d0
jmp 0x24611
movsbl %al, %ebp
cmpb $0x9, %bpl
jl 0x245c3
leal -0xe(%rax), %ecx
cmpb $0x12, %cl
setae %cl
cmpb $0x7f, %al
setne %al
testb %cl, %al
jne 0x24619
movq %rbx, %rdi
leaq 0x1223b(%rip), %rsi     # 0x36808
callq 0xc4d0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
orl $0x4000, 0x18(%rax,%rdx) # imm = 0x4000
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0xc810
jmp 0x24611
movq %rbx, %rdi
pushq $0x3e
jmp 0x2460b
movq %rbx, %rdi
pushq $0x22
popq %rsi
callq 0xc590
incq %r13
jmp 0x24530
movq %rbx, %rdi
movl %ebp, %esi
jmp 0x2460c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
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::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
XmlWriter& writeText( std::string const& text, bool indent = true ) {
            if( !text.empty() ){
                bool tagWasOpen = m_tagIsOpen;
                ensureTagClosed();
                if( tagWasOpen && indent )
                    stream() << m_indent;
                stream() << XmlEncode( text );
                m_needsNewline = true;
            }
            return *this;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x247e8
movl %edx, %ebp
movq %rsi, %r14
andb (%rbx), %bpl
movq %rbx, %rdi
callq 0x244f0
cmpb $0x1, %bpl
jne 0x247b5
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %rsi
callq 0xc430
movq 0x40(%rbx), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xc650
andl $0x0, 0x20(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2450e
leaq 0x8(%rsp), %rdi
callq 0xc978
movb $0x1, 0x1(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%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::JunitReporter::writeAssertions(Catch::CumulativeReporterBase::SectionNode const&)
void writeAssertions( SectionNode const& sectionNode ) {
            for( SectionNode::Assertions::const_iterator
                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
                    it != itEnd;
                    ++it )
                writeAssertion( *it );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rsi), %r14
movq 0xc8(%rsi), %r15
cmpq %r15, %r14
je 0x25431
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25438
addq $0x108, %r14            # imm = 0x108
jmp 0x25418
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::ConsoleReporter::lazyPrint()
void lazyPrint() {

            if( !currentTestRunInfo.used )
                lazyPrintRunInfo();
            if( !currentGroupInfo.used )
                lazyPrintGroupInfo();

            if( !m_headerPrinted ) {
                printTestCaseAndSectionHeader();
                m_headerPrinted = true;
            }
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x48(%rdi)
jne 0x2573e
movq %rbx, %rdi
callq 0x25af4
cmpb $0x0, 0x88(%rbx)
jne 0x2574f
movq %rbx, %rdi
callq 0x25c2c
cmpb $0x0, 0x1c9(%rbx)
jne 0x25767
movq %rbx, %rdi
callq 0x25c96
movb $0x1, 0x1c9(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::AssertionPrinter::print() const
void print() const {
                printSourceInfo();
                if( stats.totals.assertions.total() > 0 ) {
                    if( result.isOk() )
                        stream << "\n";
                    printResultType();
                    printOriginalExpression();
                    printReconstructedExpression();
                }
                else {
                    stream << "\n";
                }
                printMessage();
            }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x26052
movq 0x8(%rbx), %rax
movq 0xe0(%rax), %rcx
addq 0xd8(%rax), %rcx
addq 0xe8(%rax), %rcx
jne 0x25a7f
movq (%rbx), %rdi
leaq 0x10f79(%rip), %rsi     # 0x369f1
callq 0xc4d0
jmp 0x25abb
movq 0x10(%rbx), %rax
testb $0x10, 0xb0(%rax)
je 0x25a94
movl 0x68(%rax), %eax
andl $0x8, %eax
je 0x25aa3
movq (%rbx), %rdi
leaq 0x10f53(%rip), %rsi     # 0x369f1
callq 0xc4d0
movq %rbx, %rdi
callq 0x260da
movq %rbx, %rdi
callq 0x2613a
movq %rbx, %rdi
callq 0x261da
movq %rbx, %rdi
popq %rbx
jmp 0x262d0
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::lazyPrintRunInfo()
void lazyPrintRunInfo() {
            stream  << "\n" << getLineOfChars<'~'>() << "\n";
            Colour colour( Colour::SecondaryText );
            stream  << currentTestRunInfo->name
                    << " is a Catch v"  << libraryVersion << " host application.\n"
                    << "Run with -? for options\n\n";

            if( m_config->rngSeed() != 0 )
                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";

            currentTestRunInfo.used = true;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x10eeb(%rip), %rsi     # 0x369f1
callq 0xc4d0
cmpb $0x0, 0x2eb6e(%rip)     # 0x54680
jne 0x25b45
movaps 0xfc75(%rip), %xmm0     # 0x35790
movups %xmm0, 0x2eb9d(%rip)    # 0x546bf
movaps %xmm0, 0x2eb87(%rip)    # 0x546b0
movaps %xmm0, 0x2eb70(%rip)    # 0x546a0
movaps %xmm0, 0x2eb59(%rip)    # 0x54690
movaps %xmm0, 0x2eb42(%rip)    # 0x54680
movb $0x0, 0x2eb8a(%rip)     # 0x546cf
leaq 0x2eb34(%rip), %rsi     # 0x54680
movq %rax, %rdi
callq 0xc4d0
leaq 0x10e96(%rip), %rsi     # 0x369f1
movq %rax, %rdi
callq 0xc4d0
movb $0x0, 0x7(%rsp)
pushq $0x17
popq %rdi
callq 0xe4b0
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0xc430
leaq 0x10e33(%rip), %rsi     # 0x369b7
movq %rax, %rdi
callq 0xc4d0
movq %rax, %r14
leaq 0x2ea22(%rip), %rsi     # 0x545b8
movq %rax, %rdi
callq 0xedbe
leaq 0x10e20(%rip), %rsi     # 0x369c5
movq %r14, %rdi
callq 0xc4d0
leaq 0x10e25(%rip), %rsi     # 0x369d9
movq %rax, %rdi
callq 0xc4d0
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testl %eax, %eax
je 0x25c00
movq 0x18(%rbx), %rdi
leaq 0x10e1e(%rip), %rsi     # 0x369f3
callq 0xc4d0
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0xc340
leaq 0x10df8(%rip), %rsi     # 0x369f0
movq %rax, %rdi
callq 0xc4d0
movb $0x1, 0x48(%rbx)
leaq 0x7(%rsp), %rdi
callq 0xe5a2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0xe5a2
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
            std::size_t i = _string.find( ": " );
            if( i != std::string::npos )
                i+=2;
            else
                i = 0;
            stream << Text( _string, TextAttributes()
                                        .setIndent( indent+i)
                                        .setInitialIndent( indent ) ) << "\n";
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10334(%rip), %rsi     # 0x362ff
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0xc930
leaq 0x2(%rax), %rcx
cmpq $-0x1, %rax
cmoveq %r12, %rcx
movq 0x18(%r15), %r15
leaq 0x58(%rsp), %rdx
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
addq %rbx, %rcx
movq %rcx, 0x8(%rdx)
movq %rbx, (%rdx)
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e530
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1e4de
leaq 0x109ce(%rip), %rsi     # 0x369f1
movq %rax, %rdi
callq 0xc4d0
movq %rsp, %rdi
callq 0x1e8c0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1e8c0
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::AssertionPrinter::printOriginalExpression() const
void printOriginalExpression() const {
                if( result.hasExpression() ) {
                    Colour colourGuard( Colour::OriginalExpression );
                    stream  << "  ";
                    stream << result.getExpressionInMacro();
                    stream << "\n";
                }
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
cmpq $0x0, 0x50(%rax)
je 0x261ac
movq %rdi, %rbx
movb $0x0, 0x7(%rsp)
pushq $0x5
popq %rdi
callq 0xe4b0
movq (%rbx), %rdi
leaq 0x10326(%rip), %rsi     # 0x3648c
callq 0xc4d0
movq (%rbx), %r14
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0xe782
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xc430
leaq 0x8(%rsp), %rdi
callq 0xc978
movq (%rbx), %rdi
leaq 0x10854(%rip), %rsi     # 0x369f1
callq 0xc4d0
leaq 0x7(%rsp), %rdi
callq 0xe5a2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc978
jmp 0x261c8
jmp 0x261c5
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0xe5a2
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::AssertionPrinter::printReconstructedExpression() const
void printReconstructedExpression() const {
                if( result.hasExpandedExpression() ) {
                    stream << "with expansion:\n";
                    Colour colourGuard( Colour::ReconstructedExpression );
                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
                }
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0xe826
testb %al, %al
je 0x26292
movq (%r14), %rdi
leaq 0x10941(%rip), %rsi     # 0x36b43
callq 0xc4d0
movb $0x0, 0xf(%rsp)
pushq $0x6
popq %rdi
callq 0xe4b0
movq (%r14), %rbx
movq 0x10(%r14), %rsi
addq $0x70, %rsi
leaq 0x10(%rsp), %rdi
callq 0xc650
leaq 0x88(%rsp), %rdx
orq $-0x1, (%rdx)
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
movq $0x2, 0x8(%rdx)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1e530
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e4de
leaq 0x10785(%rip), %rsi     # 0x369f1
movq %rax, %rdi
callq 0xc4d0
leaq 0x30(%rsp), %rdi
callq 0x1e8c0
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0xf(%rsp), %rdi
callq 0xe5a2
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x262b4
movq %rax, %rbx
jmp 0x262be
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1e8c0
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0xf(%rsp), %rdi
callq 0xe5a2
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::AssertionPrinter::printMessage() const
void printMessage() const {
                if( !messageLabel.empty() )
                    stream << messageLabel << ":" << "\n";
                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
                        it != itEnd;
                        ++it ) {
                    // If this assertion is a warning ignore any INFO messages
                    if( printInfoMessages || it->type != ResultWas::Info )
                        stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x26312
leaq 0x40(%rbx), %rsi
movq (%rbx), %rdi
callq 0xc430
leaq 0xf96d(%rip), %rsi      # 0x35c68
movq %rax, %rdi
callq 0xc4d0
leaq 0x106e7(%rip), %rsi     # 0x369f1
movq %rax, %rdi
callq 0xc4d0
movq 0x80(%rbx), %r14
movq 0x88(%rbx), %r12
addq $0x50, %r14
leaq 0x20(%rsp), %r15
leaq 0x106c1(%rip), %r13     # 0x369f1
leaq -0x50(%r14), %rax
cmpq %r12, %rax
je 0x2639a
cmpb $0x0, 0x98(%rbx)
jne 0x26349
cmpl $0x1, -0x8(%r14)
je 0x26394
movq (%rbx), %rbp
orq $-0x1, (%rsp)
movq $0x4f, 0x10(%rsp)
movb $0x9, 0x18(%rsp)
movq $0x2, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq 0x1e530
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1e4de
movq %rax, %rdi
movq %r13, %rsi
callq 0xc4d0
movq %r15, %rdi
callq 0x1e8c0
addq $0x78, %r14
jmp 0x26330
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1e8c0
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::SummaryColumn::addRow(unsigned long)
SummaryColumn addRow( std::size_t count ) {
                std::ostringstream oss;
                oss << count;
                std::string row = oss.str();
                for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
                    while( it->size() < row.size() )
                        *it = " " + *it;
                    while( it->size() > row.size() )
                        row = " " + row;
                }
                rows.push_back( row );
                return *this;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0xc640
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc340
movq %r12, 0x8(%rsp)
leaq 0x58(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xc720
leaq 0x28(%r14), %r15
movq 0x28(%r14), %r12
leaq 0xef92(%rip), %r13      # 0x3599b
leaq 0x30(%rsp), %rbp
leaq 0x10(%rsp), %rbx
cmpq 0x30(%r14), %r12
je 0x26a81
movq 0x8(%r12), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x26a76
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x12399
movq %r12, %rdi
movq %rbp, %rsi
callq 0xc5d0
movq %rbp, %rdi
callq 0xc978
jmp 0x26a19
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x12399
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xc5d0
movq %rbp, %rdi
callq 0xc978
movq 0x8(%r12), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
ja 0x26a4b
addq $0x20, %r12
jmp 0x26a13
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x1da94
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26ecc
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x50(%rsp), %rdi
callq 0xc0e0
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26ac9
movq %rax, %rbx
jmp 0x26adf
jmp 0x26ad2
jmp 0x26ad2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x50(%rsp), %rdi
callq 0xc0e0
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::printSummaryRow(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::ConsoleReporter::SummaryColumn, std::allocator<Catch::ConsoleReporter::SummaryColumn>> const&, unsigned long)
void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
            for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
                std::string value = it->rows[row];
                if( it->label.empty() ) {
                    stream << label << ": ";
                    if( value != "0" )
                        stream << value;
                    else
                        stream << Colour( Colour::Warning ) << "- none -";
                }
                else if( value != "0" ) {
                    stream  << Colour( Colour::LightGrey ) << " | ";
                    stream  << Colour( it->colour )
                            << value << " " << it->label;
                }
            }
            stream << "\n";
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq (%rdx), %r13
shlq $0x5, %rbx
leaq 0x18(%rsp), %rbp
cmpq 0x8(%r14), %r13
je 0x26c42
movq 0x28(%r13), %rsi
addq %rbx, %rsi
movq %rbp, %rdi
callq 0xc650
cmpq $0x0, 0x8(%r13)
je 0x26bca
movq %rbp, %rdi
leaq 0x11a48(%rip), %rsi     # 0x385a2
callq 0x12ee7
testb %al, %al
je 0x26c31
movq 0x18(%r15), %r12
movb $0x0, 0xf(%rsp)
pushq $0x17
popq %rdi
callq 0xe4b0
movq %r12, %rdi
leaq 0x10097(%rip), %rsi     # 0x36c19
callq 0xc4d0
leaq 0xf(%rsp), %rdi
callq 0xe5a2
movq 0x18(%r15), %r12
movl 0x20(%r13), %edi
movb $0x0, 0xf(%rsp)
callq 0xe4b0
movq %r12, %rdi
movq %rbp, %rsi
callq 0xc430
movq %rax, %rdi
leaq 0xede3(%rip), %rsi      # 0x3599b
callq 0xc4d0
movq %rax, %rdi
movq %r13, %rsi
callq 0xc430
jmp 0x26c27
movq 0x18(%r15), %rdi
movq 0x10(%rsp), %rsi
callq 0xc430
movq %rax, %rdi
leaq 0xf71d(%rip), %rsi      # 0x362ff
callq 0xc4d0
movq %rbp, %rdi
leaq 0x119b1(%rip), %rsi     # 0x385a2
callq 0x12ee7
movq 0x18(%r15), %r12
testb %al, %al
je 0x26c0b
movq %r12, %rdi
movq %rbp, %rsi
callq 0xc430
jmp 0x26c31
movb $0x0, 0xf(%rsp)
pushq $0x6
popq %rdi
callq 0xe4b0
movq %r12, %rdi
leaq 0xffee(%rip), %rsi      # 0x36c10
callq 0xc4d0
leaq 0xf(%rsp), %rdi
callq 0xe5a2
movq %rbp, %rdi
callq 0xc978
addq $0x40, %r13
jmp 0x26b30
movq 0x18(%r15), %rdi
leaq 0xfda4(%rip), %rsi      # 0x369f1
callq 0xc4d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26c70
jmp 0x26c6b
jmp 0x26c6b
jmp 0x26c70
jmp 0x26c6b
movq %rax, %rbx
jmp 0x26c7d
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xe5a2
leaq 0x18(%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::CompactReporter::AssertionPrinter::printReconstructedExpression() const
void printReconstructedExpression() const {
                if( result.hasExpandedExpression() ) {
                    {
                        Colour colour( dimColour() );
                        stream << " for: ";
                    }
                    stream << result.getExpandedExpression();
                }
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xe826
testb %al, %al
je 0x27940
movb $0x0, 0x8(%rsp)
pushq $0x17
popq %rdi
callq 0xe4b0
movq (%rbx), %rdi
leaq 0xf388(%rip), %rsi      # 0x36c8c
callq 0xc4d0
leaq 0x8(%rsp), %rdi
callq 0xe5a2
movq (%rbx), %r14
movq 0x10(%rbx), %rsi
addq $0x70, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc650
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc430
leaq 0x8(%rsp), %rdi
callq 0xc978
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc978
jmp 0x27964
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe5a2
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CompactReporter::AssertionPrinter::printExpressionWas()
void printExpressionWas() {
                if( result.hasExpression() ) {
                    stream << ";";
                    {
                        Colour colour( dimColour() );
                        stream << " expression was:";
                    }
                    printOriginalExpression();
                }
            }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %rax
cmpq $0x0, 0x50(%rax)
je 0x27baf
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xec83(%rip), %rsi      # 0x367fa
callq 0xc4d0
movb $0x0, 0xf(%rsp)
pushq $0x17
popq %rdi
callq 0xe4b0
movq (%rbx), %rdi
leaq 0xf10c(%rip), %rsi      # 0x36c9f
callq 0xc4d0
leaq 0xf(%rsp), %rdi
callq 0xe5a2
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x2786c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xe5a2
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::StreamBufImpl<Catch::OutputDebugWriter, 256ul>::overflow(int)
int overflow( int c ) {
            sync();

            if( c != EOF ) {
                if( pbase() == epptr() )
                    m_writer( std::string( 1, static_cast<char>( c ) ) );
                else
                    sputc( static_cast<char>( c ) );
            }
            return 0;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $-0x1, %ebx
je 0x28bf2
movq 0x20(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x28bc4
movsbl %bl, %esi
movq %r14, %rdi
callq 0xc1d0
jmp 0x28bf2
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movsbl %bl, %edx
leaq 0x8(%rsp), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xc580
movq %rbx, %rdi
callq 0xf9f3
leaq 0x8(%rsp), %rdi
callq 0xc978
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::circular_queue_factory(unsigned long, bool, std::function<int (gdc::circular_queue<char>&)>)
circular_queue_factory(
			size_type capacity,
			bool sync = true,
			mdinit_type metadata_initializer = [](Q&) -> int { return 0; }) :
			_capacity(capacity),
			_sync(sync),
			_metadata_initializer(metadata_initializer),
			_q(nullptr, null_queue_destroyer)
		{
			assert(capacity >= 0);
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, 0x20(%rdi)
movb %dl, 0x28(%rdi)
addq $0x30, %rdi
movq %rcx, %rsi
callq 0x2cf62
leaq 0x2f5(%rip), %rax       # 0x2cfa8
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %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::ExpressionLhs<gdc::circular_queue_factory<char, gdc::circular_queue<char>> const&>::endExpression()
void endExpression() {
        bool value = m_lhs ? true : false;
        m_rb
            .setLhs( Catch::toString( value ) )
            .setResultType( value )
            .endExpression();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rbx
movq 0x8(%rdi), %rax
movq 0x58(%rax), %r15
xorl %esi, %esi
testq %r15, %r15
setne %sil
movq %rsp, %r14
movq %r14, %rdi
callq 0x1001a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10444
xorl %esi, %esi
testq %r15, %r15
setne %sil
movq %rax, %rdi
callq 0x10430
movq %rax, %rdi
callq 0x10486
movq %rsp, %rdi
callq 0xc978
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
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/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::create_shared(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, bool, std::function<int (gdc::circular_queue<char>&)>)
static void create_shared(
			const std::string& name,
			size_type capacity,
			bool sync,
			mdinit_type metadata_initializer)
		{
			void* mdinit_context = &metadata_initializer;
			int status = ::gdc_circular_queue_create_shared(
				name.c_str(),
				capacity,
				sync,
				default_metadata_init,
				mdinit_context);

			if (status != 0)
			{
				std::string what("Failed to create shared memory queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r8
movq (%rdi), %rdi
leaq 0x320(%rip), %rcx       # 0x2d410
callq 0x34ba8
testl %eax, %eax
jne 0x2d101
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xac8e(%rip), %rsi      # 0x37d96
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x11b1a
callq 0xc040
movl (%rax), %edi
callq 0xc160
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc8d0
pushq $0x18
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2cee8
leaq 0x26898(%rip), %rsi     # 0x539e8
leaq -0x357(%rip), %rdx      # 0x2ce00
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
jmp 0x2d16f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %r14, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::unmap_shared(gdc::circular_queue<char>*)
static void unmap_shared(Q* q)
		{
			auto qq = reinterpret_cast<gdc_circular_queue*>(q);
			int status = ::gdc_circular_queue_unmap_shared(qq);
			
			if (status != 0)
			{
				std::string what("Failed to unmap shared memory queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x34f25
testl %eax, %eax
jne 0x2d236
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xaba4(%rip), %rsi      # 0x37de1
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x11b1a
callq 0xc040
movl (%rax), %edi
callq 0xc160
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc8d0
pushq $0x18
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2cee8
leaq 0x26763(%rip), %rsi     # 0x539e8
leaq -0x48c(%rip), %rdx      # 0x2ce00
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
jmp 0x2d2a4
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %r14, %rdi
callq 0xc840