LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movq %rcx, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x271b5
movq %rdx, %r15
movq %rsi, %r12
leaq 0x28(%rsi), %rbp
movl $0x1, %ebx
xorl %r14d, %r14d
movq 0x30(%r12), %rdx
movq %rbp, %rcx
testq %rdx, %rdx
je 0x27144
movq %rbp, %rcx
xorl %esi, %esi
cmpl %ebx, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x2712d
movq %rbp, %rsi
cmpq %rbp, %rcx
je 0x27156
cmpl 0x20(%rcx), %ebx
cmovlq %rbp, %rcx
movq %rcx, %rsi
leaq (%r14,%r14,4), %rcx
leaq (%rax,%rcx,8), %r13
cmpq %rbp, %rsi
je 0x27178
leaq 0x8(%r13), %rdx
movq 0x28(%rsi), %rdi
movq (%rdi), %rax
movq 0x10(%rsp), %rsi
callq *0x10(%rax)
jmp 0x27185
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x266ac
cmpl $0x1, (%r13)
adcl $0x0, %ebx
incq %r14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
cmpq %rcx, %r14
jb 0x2711d
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x22c02
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>::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 0x27272
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x2727d
xorl %r13d, %r13d
movabsq $-0x3333333333333333, %rbp # imm = 0xCCCCCCCCCCCCCCCD
xorl %r15d, %r15d
cmpl $0x0, (%rsi,%r13)
je 0x27238
addq %r13, %rsi
movq %rbx, %rdi
callq 0x266ac
jmp 0x27252
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
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %rbp, %rax
addq $0x28, %r13
cmpq %rax, %r15
jb 0x27224
jmp 0x2727d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27606
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 0x22c02
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>::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, %r12
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
callq 0xc5f0
movq 0x68(%r12), %rbx
movq 0x70(%r12), %r14
cmpq %r14, %rbx
je 0x273c6
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movb $0x1, %bpl
leaq 0x20899(%rip), %r15     # 0x47c06
leaq 0x10(%rsp), %r12
leaq 0x1f652(%rip), %r13     # 0x469cb
testb $0x1, %bpl
je 0x27383
xorl %ebp, %ebp
jmp 0x27393
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0xc530
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0xc530
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r12, %rdi
callq 0xc530
addq $0x20, %rbx
cmpq %r14, %rbx
jne 0x27379
movq 0x8(%rsp), %r15
movq (%rsp), %r12
jmp 0x273c9
movb $0x1, %bpl
cmpq $0x0, 0x88(%r12)
je 0x27420
testb $0x1, %bpl
jne 0x273f0
leaq 0x1f5ea(%rip), %rsi     # 0x469cb
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0xc530
leaq 0x1fd71(%rip), %rsi     # 0x47168
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0xc530
movq 0x80(%r12), %rsi
movq 0x88(%r12), %rdx
leaq 0x10(%rsp), %rdi
callq 0xc530
cmpq $0x0, 0x50(%r12)
je 0x27466
leaq 0x1ffcf(%rip), %rsi     # 0x473fe
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0xc530
movq 0x48(%r12), %rsi
movq 0x50(%r12), %rdx
leaq 0x10(%rsp), %rdi
callq 0xc530
leaq 0x1f7fe(%rip), %rsi     # 0x46c57
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0xc6f0
movq 0x3ab0e(%rip), %rsi     # 0x61f88
leaq 0x10(%rsp), %rdi
callq 0xc220
leaq 0x80(%rsp), %rdi
callq 0xc120
movq %r15, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x274a8
movq %rax, %rbx
movq 0x3aad6(%rip), %rsi     # 0x61f88
leaq 0x10(%rsp), %rdi
callq 0xc220
leaq 0x80(%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::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 $0xa8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
leaq 0x3779b(%rip), %rax     # 0x5fec0
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x28948
movq %r14, %rdi
callq 0x28a86
movq %rax, 0xc8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%r14)
movq $0x0, 0xe0(%r14)
movq 0xa0(%r15), %rax
cmpq 0xa8(%r15), %rax
je 0x288af
movq %rbx, (%rsp)
callq 0x13f96
leaq 0x48(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x30(%r13)
leaq 0x39e53(%rip), %rax     # 0x625f8
movq %rax, 0x40(%r13)
movq 0xa0(%r15), %rsi
cmpq %rsi, 0xa8(%r15)
je 0x287ee
xorl %ebp, %ebp
leaq 0x20(%rsp), %r12
xorl %ebx, %ebx
addq %rbp, %rsi
movq %r12, %rdi
callq 0x1530c
incq %rbx
movq 0xa0(%r15), %rsi
movq 0xa8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %rax, %rbx
jb 0x287c2
leaq 0x20(%rsp), %rdi
callq 0x1da1e
leaq 0x70(%rsp), %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1d3ec
leaq 0x58(%rsp), %rbx
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xd0(%r14), %rax
movups 0xd8(%r14), %xmm0
leaq 0x8(%rsp), %r12
movq (%r12), %rcx
movq %rcx, 0xd0(%r14)
movq 0x8(%r12), %rcx
movq %rcx, 0xd8(%r14)
movq 0x10(%r12), %rcx
movq %rcx, 0xe0(%r14)
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 0x1e398
movq %r12, %rdi
callq 0x1e398
movq %r15, %rdi
callq 0x1e398
movq %rbx, %rdi
callq 0x1d688
movq -0x20(%rbx), %rdi
cmpq %r13, %rdi
je 0x288af
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, (%rsp)
movq %rax, %r15
jmp 0x288fa
jmp 0x288cc
movq %rax, %r15
leaq 0xd0(%r14), %r12
leaq 0x20(%rsp), %rdi
callq 0x153ae
movq %r12, %rdi
callq 0x1e398
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
je 0x288fa
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
callq 0x22b9a
movq %r15, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x2a237
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x1d365(%rip), %rbp     # 0x474e2
leaq 0x20(%r15), %rdx
movq %r13, %rdi
leaq 0x1cb68(%rip), %rsi     # 0x46cf3
callq 0x15995
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc8b0
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2a1be
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x2a1c6
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xc110
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a207
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2a223
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %r15, %rdi
callq 0xc540
movq %rax, %r15
cmpq %r14, %rax
jne 0x2a17d
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2a289
movq %rax, %r14
jmp 0x2a26d
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a26d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2a289
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2a2a1
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xc4a0
movq %r14, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x2d391
movq 0x40(%rbx), %rdi
leaq 0x199cb(%rip), %rsi     # 0x46d4f
movl $0x2, %edx
callq 0xc530
movb $0x0, (%rbx)
cmpb $0x1, 0x1(%rbx)
jne 0x2d3b0
movq 0x40(%rbx), %rdi
leaq 0x1a63e(%rip), %rsi     # 0x479e0
movl $0x1, %edx
callq 0xc530
movb $0x0, 0x1(%rbx)
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %r15
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0xc530
movq %rax, %r12
leaq 0x1a030(%rip), %rsi     # 0x473ff
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0xc530
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x24bda
leaq 0x1a07d(%rip), %rsi     # 0x4747b
movq %r15, %rdi
callq 0xc8b0
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d8b5
movl %edx, %ebp
movq %rsi, %r14
movb (%rbx), %r15b
cmpb $0x1, %r15b
jne 0x2d848
movq 0x40(%rbx), %rdi
leaq 0x19514(%rip), %rsi     # 0x46d4f
movl $0x2, %edx
callq 0xc530
movb $0x0, (%rbx)
andb %bpl, %r15b
cmpb $0x1, %r15b
jne 0x2d862
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0xc530
movq 0x40(%rbx), %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x32cee
movl $0x0, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d50c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d8b1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movb $0x1, 0x1(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d8df
movq 0x18(%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::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 0x2eeda
movq %rbx, %rdi
callq 0x2f442
cmpb $0x0, 0x88(%rbx)
jne 0x2eeeb
movq %rbx, %rdi
callq 0x2f5c2
cmpb $0x0, 0x1c9(%rbx)
jne 0x2ef03
movq %rbx, %rdi
callq 0x2f64e
movb $0x1, 0x1c9(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fb44
movq 0x8(%rbx), %rax
movq 0xe0(%rax), %rcx
addq 0xd8(%rax), %rcx
addq 0xe8(%rax), %rcx
jne 0x2f39c
movq (%rbx), %rdi
leaq 0x18650(%rip), %rsi     # 0x479e0
movl $0x1, %edx
callq 0xc530
jmp 0x2f3dd
movq 0x10(%rbx), %rax
testb $0x10, 0xb0(%rax)
je 0x2f3b1
movl 0x68(%rax), %eax
andl $0x8, %eax
je 0x2f3c5
movq (%rbx), %rdi
leaq 0x18625(%rip), %rsi     # 0x479e0
movl $0x1, %edx
callq 0xc530
movq %rbx, %rdi
callq 0x2fc0e
movq %rbx, %rdi
callq 0x2fc78
movq %rbx, %rdi
callq 0x2fd50
movq %rbx, %rdi
popq %rbx
jmp 0x2feea
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x18587(%rip), %rsi     # 0x479e0
movl $0x1, %edx
movq %r14, %rdi
callq 0xc530
cmpb $0x0, 0x331f3(%rip)     # 0x62660
jne 0x2f4a0
movaps 0x16bba(%rip), %xmm0    # 0x46030
movups %xmm0, 0x33222(%rip)    # 0x6269f
movaps %xmm0, 0x3320c(%rip)    # 0x62690
movaps %xmm0, 0x331f5(%rip)    # 0x62680
movaps %xmm0, 0x331de(%rip)    # 0x62670
movaps %xmm0, 0x331c7(%rip)    # 0x62660
movb $0x0, 0x3320f(%rip)     # 0x626af
leaq 0x331b9(%rip), %r15     # 0x62660
movq %r15, %rdi
callq 0xc1a0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc530
leaq 0x1851c(%rip), %rsi     # 0x479e0
movl $0x1, %edx
movq %r14, %rdi
callq 0xc530
movb $0x0, 0xf(%rsp)
movl $0x17, %edi
callq 0xf168
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xc530
movq %rax, %r14
leaq 0x184a8(%rip), %rsi     # 0x479a6
movl $0xd, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x33086(%rip), %rsi     # 0x62598
movq %r14, %rdi
callq 0x1017d
leaq 0x18493(%rip), %rsi     # 0x479b4
movl $0x13, %edx
movq %r14, %rdi
callq 0xc530
leaq 0x18493(%rip), %rsi     # 0x479c8
movl $0x19, %edx
movq %r14, %rdi
callq 0xc530
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testl %eax, %eax
je 0x2f590
movq 0x18(%rbx), %r14
leaq 0x18487(%rip), %rsi     # 0x479e2
movl $0x16, %edx
movq %r14, %rdi
callq 0xc530
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0xc300
leaq 0x1845c(%rip), %rsi     # 0x479df
movl $0x2, %edx
movq %rax, %rdi
callq 0xc530
movb $0x1, 0x48(%rbx)
xorl %edi, %edi
callq 0xf168
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x15d1b
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xf1d2
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1789c(%rip), %rsi     # 0x472f3
xorl %r12d, %r12d
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0xc7f0
leaq 0x2(%rax), %rcx
cmpq $-0x1, %rax
cmoveq %r12, %rcx
movq 0x18(%rbx), %rbx
leaq 0x58(%rsp), %rdx
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
addq %r15, %rcx
movq %rcx, 0x8(%rdx)
movq %r15, (%rdx)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x259ec
movq 0x40(%r15), %r12
movq 0x48(%r15), %r15
cmpq %r15, %r12
je 0x2fae7
leaq 0x17f2a(%rip), %r14     # 0x479e0
cmpq 0x40(%rsp), %r12
je 0x2facd
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc530
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xc530
addq $0x20, %r12
cmpq %r15, %r12
jne 0x2fab6
leaq 0x17ef2(%rip), %rsi     # 0x479e0
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc530
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x14e2c
movq -0x40(%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2fb23
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2fb31
movq %rax, %rbx
movq %rsp, %rdi
callq 0x25f7a
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fd09
movq %rdi, %rbx
movb $0x0, 0x7(%rsp)
movl $0x5, %edi
callq 0xf168
movq (%rbx), %rdi
leaq 0x177d5(%rip), %rsi     # 0x4747b
movl $0x2, %edx
callq 0xc530
movq (%rbx), %r14
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0xf670
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xc530
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fcee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq (%rbx), %rdi
leaq 0x17ce8(%rip), %rsi     # 0x479e0
movl $0x1, %edx
callq 0xc530
xorl %edi, %edi
callq 0xf168
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x15d1b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fd3e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x2fd3e
jmp 0x2fd3b
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0xf1d2
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0xf7fa
testb %al, %al
je 0x2fe8f
movq (%r14), %rdi
leaq 0x17db4(%rip), %rsi     # 0x47b32
movl $0x10, %edx
callq 0xc530
movb $0x0, 0x7(%rsp)
movl $0x6, %edi
callq 0xf168
movq (%r14), %rbx
movq 0x10(%r14), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x70(%rax), %rsi
movq 0x78(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x32cee
leaq 0x80(%rsp), %rdx
movq $-0x1, (%rdx)
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
movq $0x2, 0x8(%rdx)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x259ec
movq 0x68(%rsp), %r12
movq 0x70(%rsp), %r13
cmpq %r13, %r12
je 0x2fe35
leaq 0x17bdc(%rip), %r14     # 0x479e0
cmpq 0x68(%rsp), %r12
je 0x2fe1b
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc530
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xc530
addq $0x20, %r12
cmpq %r13, %r12
jne 0x2fe04
leaq 0x17ba4(%rip), %rsi     # 0x479e0
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc530
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x14e2c
movq -0x40(%rbx), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2fe71
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2fe88
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
xorl %edi, %edi
callq 0xf168
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x15d1b
jmp 0x2feb4
movq %rax, %rbx
jmp 0x2fec1
movq %rax, %rbx
jmp 0x2fed8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x25f7a
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2fed8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x7(%rsp), %rdi
callq 0xf1d2
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x88, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rdx
testq %rdx, %rdx
je 0x2ff3e
movq (%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0xc530
movq %rax, %r14
leaq 0x16d3f(%rip), %rsi     # 0x46c5c
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x17aaf(%rip), %rsi     # 0x479e0
movl $0x1, %edx
movq %r14, %rdi
callq 0xc530
movq 0x80(%rbx), %r14
movq 0x88(%rbx), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, %r14
je 0x3002d
leaq 0x17a7f(%rip), %r13     # 0x479e0
cmpb $0x0, 0x98(%rbx)
jne 0x2ff75
cmpl $0x1, 0x48(%r14)
je 0x3001e
movq (%rbx), %rbp
leaq 0x50(%r14), %rsi
movq $-0x1, 0x10(%rsp)
movq $0x4f, 0x20(%rsp)
movb $0x9, 0x28(%rsp)
movq $0x2, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x259ec
movq 0x70(%rsp), %r12
movq 0x78(%rsp), %r15
cmpq %r15, %r12
je 0x2ffe8
cmpq 0x70(%rsp), %r12
je 0x2ffd1
movl $0x1, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0xc530
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbp, %rdi
callq 0xc530
addq $0x20, %r12
jmp 0x2ffb5
movl $0x1, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0xc530
leaq 0x70(%rsp), %rdi
callq 0x14e2c
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x3001e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x78, %r14
cmpq 0x8(%rsp), %r14
jne 0x2ff61
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30041
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x25f7a
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0xc5f0
movq %r12, %rdi
movq %r15, %rsi
callq 0xc300
movq %rbx, 0x28(%rsp)
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc6f0
movq 0x28(%r14), %r15
cmpq 0x30(%r14), %r15
je 0x30a7a
leaq 0x40(%rsp), %rbx
leaq 0x15fa5(%rip), %r12     # 0x4698f
leaq 0x30(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq 0x8(%r15), %rax
cmpq 0x10(%rsp), %rax
jae 0x30a61
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x15995
movq %r15, %rdi
movq %r13, %rsi
callq 0xc590
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x309f4
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x309f4
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x15995
movq %rbp, %rdi
movq %r13, %rsi
callq 0xc590
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x30a61
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x8(%r15), %rax
cmpq 0x10(%rsp), %rax
ja 0x30a31
addq $0x20, %r15
cmpq 0x30(%r14), %r15
jne 0x309f4
leaq 0x28(%r14), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x24bda
movq 0x28(%rsp), %r12
leaq 0x10(%r12), %rbx
movq %rbx, (%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x32cee
movl 0x20(%r14), %eax
movl %eax, 0x20(%r12)
leaq 0x28(%r12), %rdi
movq %r15, %rsi
callq 0x1b096
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30adc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x314a5(%rip), %rsi     # 0x61f88
leaq 0x50(%rsp), %rdi
callq 0xc220
leaq 0xc0(%rsp), %rdi
callq 0xc120
movq %r12, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x30b36
movq (%rbx), %rsi
incq %rsi
callq 0xc4a0
jmp 0x30b36
jmp 0x30b2a
movq %rax, %r14
jmp 0x30b51
jmp 0x30b33
jmp 0x30b33
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30b51
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x31430(%rip), %rsi     # 0x61f88
leaq 0x50(%rsp), %rdi
callq 0xc220
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::CompactReporter::AssertionPrinter::printReconstructedExpression() const
void printReconstructedExpression() const {
                if( result.hasExpandedExpression() ) {
                    {
                        Colour colour( dimColour() );
                        stream << " for: ";
                    }
                    stream << result.getExpandedExpression();
                }
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xf7fa
testb %al, %al
je 0x31f19
movb $0x0, (%rsp)
movl $0x17, %edi
callq 0xf168
movq (%rbx), %rdi
leaq 0x15dbe(%rip), %rsi     # 0x47c7b
movl $0x6, %edx
callq 0xc530
xorl %edi, %edi
callq 0xf168
movq (%rbx), %r14
movq 0x10(%rbx), %rax
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x70(%rax), %rsi
movq 0x78(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x32cee
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xc530
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x31f19
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x31f51
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x31f51
movq %rax, %rdi
callq 0x15d1b
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf1d2
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3222a
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x15600(%rip), %rsi     # 0x477e9
movl $0x1, %edx
callq 0xc530
movb $0x0, 0xf(%rsp)
movl $0x17, %edi
callq 0xf168
movq (%rbx), %rdi
leaq 0x15a82(%rip), %rsi     # 0x47c8e
movl $0x10, %edx
callq 0xc530
xorl %edi, %edi
callq 0xf168
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x31df6
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x15d1b
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xf1d2
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33894
movq 0x30(%r14), %rax
cmpq %rax, 0x20(%r14)
je 0x3384c
movq 0x28(%r14), %rcx
cmpq %rax, %rcx
jae 0x3389e
movb %bl, (%rcx)
incq 0x28(%r14)
jmp 0x33894
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movsbl %bl, %edx
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdi
callq 0xc550
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x2e730(%rip), %rdi     # 0x61fa8
callq 0xc530
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x33894
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movzbl %bl, %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x68(%rax)
jmp 0x33894
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x338c6
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/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, 0x20(%rdi)
movb %dl, 0x28(%rdi)
addq $0x30, %rdi
movq %rcx, %rsi
callq 0x39e2e
leaq 0x2df(%rip), %rax       # 0x39e94
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x39bdd
movq (%r15), %rsi
incq %rsi
callq 0xc4a0
movq %r14, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12073
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1266c
xorl %esi, %esi
testq %r15, %r15
setne %sil
movq %rax, %rdi
callq 0x12656
movq %rax, %rdi
callq 0x126ae
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39d8b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39db3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r8
movq (%rdi), %rdi
leaq 0x3ec(%rip), %rcx       # 0x3a400
callq 0x44dc0
testl %eax, %eax
jne 0x3a027
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xed4e(%rip), %rsi      # 0x48d85
leaq 0xed6d(%rip), %rdx      # 0x48dab
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x32d7e
callq 0xc050
movl (%rax), %edi
callq 0xc130
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc8b0
movl $0x18, %edi
callq 0xc1f0
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0xc5b0
leaq 0x27960(%rip), %rax     # 0x619e0
movq %rax, (%r14)
leaq 0x27986(%rip), %rax     # 0x61a10
movq %rax, 0x8(%r14)
leaq 0x2790b(%rip), %rsi     # 0x619a0
leaq -0x382(%rip), %rdx      # 0x39d1a
movq %r14, %rdi
callq 0xc7d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xc360
jmp 0x3a0b4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3a0ca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
callq 0x45157
testl %eax, %eax
jne 0x3a1ba
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xec06(%rip), %rsi      # 0x48dd0
leaq 0xec24(%rip), %rdx      # 0x48df5
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x32d7e
callq 0xc050
movl (%rax), %edi
callq 0xc130
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc8b0
movl $0x18, %edi
callq 0xc1f0
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0xc5b0
leaq 0x277cd(%rip), %rax     # 0x619e0
movq %rax, (%r14)
leaq 0x277f3(%rip), %rax     # 0x61a10
movq %rax, 0x8(%r14)
leaq 0x27778(%rip), %rsi     # 0x619a0
leaq -0x515(%rip), %rdx      # 0x39d1a
movq %r14, %rdi
callq 0xc7d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xc360
jmp 0x3a247
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3a25d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::create_private(unsigned long, bool, std::function<int (gdc::circular_queue<char>&)>)
static Q* create_private(
			size_type capacity,
			bool sync,
			mdinit_type metadata_initializer)
		{
			void* mdinit_context = &metadata_initializer;
			gdc_circular_queue* q = ::gdc_circular_queue_create_private(
				capacity,
				sync,
				default_metadata_init,
				mdinit_context);

			if (q == NULL)
			{
				std::string what("Failed to create private queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
			
			return reinterpret_cast<Q*>(q);
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rcx
leaq 0x187(%rip), %rdx       # 0x3a400
callq 0x44f33
testq %rax, %rax
je 0x3a28d
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xeb59(%rip), %rsi      # 0x48df6
leaq 0xeb72(%rip), %rdx      # 0x48e16
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x32d7e
callq 0xc050
movl (%rax), %edi
callq 0xc130
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc8b0
movl $0x18, %edi
callq 0xc1f0
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0xc5b0
leaq 0x276fa(%rip), %rax     # 0x619e0
movq %rax, (%r14)
leaq 0x27720(%rip), %rax     # 0x61a10
movq %rax, 0x8(%r14)
leaq 0x276a5(%rip), %rsi     # 0x619a0
leaq -0x5e8(%rip), %rdx      # 0x39d1a
movq %r14, %rdi
callq 0xc7d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xc360
jmp 0x3a31a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3a330
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::delete_private(gdc::circular_queue<char>*)
static void delete_private(Q* q)
		{
			auto qq = reinterpret_cast<gdc_circular_queue*>(q);
			int status = ::gdc_circular_queue_delete_private(qq);
			
			if (status != 0)
			{
				std::string what("Failed to delete private queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
callq 0x45152
testl %eax, %eax
jne 0x3a354
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xeab3(%rip), %rsi      # 0x48e17
leaq 0xeacc(%rip), %rdx      # 0x48e37
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x32d7e
callq 0xc050
movl (%rax), %edi
callq 0xc130
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc8b0
movl $0x18, %edi
callq 0xc1f0
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0xc5b0
leaq 0x27633(%rip), %rax     # 0x619e0
movq %rax, (%r14)
leaq 0x27659(%rip), %rax     # 0x61a10
movq %rax, 0x8(%r14)
leaq 0x275de(%rip), %rsi     # 0x619a0
leaq -0x6af(%rip), %rdx      # 0x39d1a
movq %r14, %rdi
callq 0xc7d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xc360
jmp 0x3a3e1
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3a3f7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::default_metadata_init(gdc_circular_queue*, void*)
static int default_metadata_init(gdc_circular_queue* q, void* context)
		{
			if (context != NULL)
			{
				auto init = reinterpret_cast<mdinit_type*>(context);
				auto qq = reinterpret_cast<Q*>(q);
				return (*init)(*qq);
			}
			
			return 0;
		}

// Assembly:
testq %rsi, %rsi
je 0x3a41b
cmpq $0x0, 0x10(%rsi)
je 0x3a41e
movq %rdi, %rax
movq 0x18(%rsi), %rcx
movq %rsi, %rdi
movq %rax, %rsi
jmpq *%rcx
xorl %eax, %eax
retq
pushq %rax
callq 0xc160
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ResultBuilder& Catch::ExpressionLhs<int const&>::captureExpression<(Catch::Internal::Operator)0, int>(int const&)
ResultBuilder& captureExpression( RhsT const& rhs ) {
        return m_rb
            .setResultType( Internal::compare<Op>( m_lhs, rhs ) )
            .setLhs( Catch::toString( m_lhs ) )
            .setRhs( Catch::toString( rhs ) )
            .setOp( Internal::OperatorTraits<Op>::getName() );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rbx), %eax
sete %sil
callq 0x12656
movq %rax, %r15
movq 0x8(%r14), %rax
movl (%rax), %esi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x11de6
movq %r15, %rdi
movq %r14, %rsi
callq 0x1266c
movq %rax, %r14
movl (%rbx), %esi
leaq 0x20(%rsp), %rdi
callq 0x11de6
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x12682
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xe99f(%rip), %rsi      # 0x48e38
leaq 0xe99a(%rip), %rdx      # 0x48e3a
movq %rsp, %rdi
callq 0x32d7e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12698
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3a4cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a4e7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a502
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3a52f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x3a52f
jmp 0x3a52c
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a551
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x3a551
jmp 0x3a54e
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a56c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.h
// Function: gdc::circular_queue<char>::push(char const*, unsigned long)
bool push(const_pointer data, size_type len)
		{
			auto p = alloc(len);
			
			if (p == nullptr)
			{
				return false;
			}
			
			std::memmove(p, data, len);
			commit(len);
			return true;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x44c3f
movq %rax, %r15
testq %rax, %rax
je 0x3a5ca
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xc740
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44d13
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: gdc_circular_queue_peek
void*
gdc_circular_queue_peek(gdc_circular_queue *q)
{
	size_t rp = atomic_load_explicit(&q->rpos, memory_order_relaxed);
	size_t wp = atomic_load_explicit(&q->wpos, memory_order_relaxed);
	
	if (rp == wp)
	{
		// Queue is empty.
		return NULL;
	}
	
	if (q->properties.sync)
	{
		// Memory fence after relaxed read of wpos.
		atomic_thread_fence(memory_order_acquire);
	}
	
	char *d = gdc_circular_queue_data(q);
	char *p = &d[rp];
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x40(%rdi), %rax
cmpq %rax, %r14
jne 0x44b8c
xorl %ebx, %ebx
jmp 0x44bbd
movq %rdi, %rbx
cmpl $0x0, 0x88(%rdi)
je 0x44b98
cmpq $-0x1, 0x1d9c0(%rip)    # 0x62560
jne 0x44bb3
movl $0x1e, %edi
callq 0xc2c0
movq %rax, 0x1d9ad(%rip)     # 0x62560
addq 0x1d9a6(%rip), %rbx     # 0x62560
addq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq