LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Matchers::Impl::Generic::AllOf<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::toString() const
virtual std::string toString() const {
                std::ostringstream oss;
                oss << "( ";
                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
                    if( i != 0 )
                        oss << " and ";
                    oss << m_matchers[i]->toString();
                }
                oss << " )";
                return oss.str();
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0xb5f0
leaq 0x250ad(%rip), %rsi     # 0x44ae6
movl $0x2, %edx
movq %r15, %rdi
callq 0xb530
movq %rbx, 0x8(%rsp)
movq 0x10(%r14), %rax
cmpq %rax, 0x18(%r14)
je 0x1fadd
leaq 0x20(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r12
xorl %r13d, %r13d
testq %r13, %r13
je 0x1fa8d
movl $0x5, %edx
movq %r12, %rdi
leaq 0x252c7(%rip), %rsi     # 0x44d48
callq 0xb530
movq 0x10(%r14), %rax
addq %rbx, %rax
movq (%rax), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0xb530
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1fac2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb4a0
incq %r13
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $0x8, %rbx
cmpq %rcx, %r13
jb 0x1fa6d
leaq 0x24ea2(%rip), %rsi     # 0x44986
leaq 0x30(%rsp), %rdi
movl $0x2, %edx
callq 0xb530
movq 0x8(%rsp), %rbx
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xb6f0
movq 0x4047c(%rip), %rsi     # 0x5ff88
leaq 0x30(%rsp), %rdi
callq 0xb220
leaq 0xa0(%rsp), %rdi
callq 0xb120
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1fb3c
jmp 0x1fb3c
movq %rax, %rbx
jmp 0x1fb5b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1fb5b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x40426(%rip), %rsi     # 0x5ff88
leaq 0x30(%rsp), %rdi
callq 0xb220
leaq 0xa0(%rsp), %rdi
callq 0xb120
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlWriter::endElement()
XmlWriter& endElement() {
            newlineIfNecessary();
            m_indent = m_indent.substr( 0, m_indent.size()-2 );
            if( m_tagIsOpen ) {
                stream() << "/>\n";
                m_tagIsOpen = false;
            }
            else {
                stream() << m_indent << "</" << m_tags.back() << ">\n";
            }
            m_tags.pop_back();
            return *this;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x1(%rdi)
jne 0x20391
movq 0x40(%rbx), %rdi
leaq 0x2565d(%rip), %rsi     # 0x459e0
movl $0x1, %edx
callq 0xb530
movb $0x0, 0x1(%rbx)
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb4d0
movq %r14, %rdi
movq %r15, %rsi
callq 0xb590
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x203d2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x40(%rbx), %rdi
cmpb $0x1, (%rbx)
jne 0x203f1
leaq 0x2496c(%rip), %rsi     # 0x44d4e
movl $0x3, %edx
callq 0xb530
movb $0x0, (%rbx)
jmp 0x2043d
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0xb530
movq %rax, %r14
leaq 0x2494a(%rip), %rsi     # 0x44d52
movl $0x2, %edx
movq %rax, %rdi
callq 0xb530
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq %r14, %rdi
callq 0xb530
leaq 0x2491f(%rip), %rsi     # 0x44d4f
movl $0x2, %edx
movq %rax, %rdi
callq 0xb530
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x20461
movq (%rax), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
OptBuilder operator[]( std::string const& optName ) {
            m_options.push_back( Arg() );
            addOptName( m_options.back(), optName );
            OptBuilder builder( &m_options.back() );
            return builder;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x8(%rsi), %rdi
xorl %eax, %eax
leaq 0x28(%rsp), %r13
movq %rax, -0x18(%r13)
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq 0xa0(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq %rax, -0x8(%rbx)
movb %al, (%rbx)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rsi
callq 0x22fc2
leaq 0x78(%rsp), %r12
movq 0x18(%r12), %rdi
cmpq %rbx, %rdi
je 0x21cb4
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %r12, %rdi
callq 0x13df2
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x21cd3
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x21cea
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x21d01
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x21d11
movq (%rdi), %rax
callq *0x8(%rax)
movq $-0xa8, %rbx
movq 0x10(%r14), %rdi
addq %rbx, %rdi
movq (%rsp), %rsi
callq 0x22ad4
addq 0x10(%r14), %rbx
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x22a3e
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::addWarning(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void addWarning( ConfigData& config, std::string const& _warning ) {
        if( _warning == "NoAssertions" )
            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
        else
            throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x231d5(%rip), %rsi     # 0x45289
movq %r14, %rdi
callq 0xb100
testl %eax, %eax
jne 0x220cf
orb $0x1, 0x18(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xb1f0
movq %rax, %rbx
leaq 0x231b3(%rip), %rsi     # 0x45296
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x149d5
leaq 0x2312f(%rip), %rsi     # 0x45226
leaq 0x8(%rsp), %rdi
callq 0xb8b0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x22122
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2212f
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xb720
xorl %ebp, %ebp
movq 0x3de91(%rip), %rsi     # 0x5fff0
movq 0x3de1a(%rip), %rdx     # 0x5ff80
movq %rbx, %rdi
callq 0xb7d0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x22188
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x221a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
testb %bpl, %bpl
jne 0x221cd
jmp 0x221d5
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x221cd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x221cd
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::operator[](Catch::Clara::UnpositionalTag)
ArgBuilder operator[]( UnpositionalTag ) {
            if( m_floatingArg.get() )
                throw std::logic_error( "Only one unpositional argument can be added" );
            m_floatingArg.reset( new Arg() );
            ArgBuilder builder( m_floatingArg.get() );
            return builder;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x50(%rdi)
jne 0x22264
movq %rdi, %rbx
movl $0xa8, %edi
callq 0xb480
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), %rdx
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
leaq 0x90(%rax), %rdx
movq %rdx, 0x80(%rax)
movq %rcx, 0x88(%rax)
movb %cl, 0x90(%rax)
movl $0xffffffff, 0xa0(%rax) # imm = 0xFFFFFFFF
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb1f0
movq %rax, %rbx
leaq 0x23036(%rip), %rsi     # 0x452ae
movq %rax, %rdi
callq 0xb640
movq 0x3dd41(%rip), %rsi     # 0x5ffc8
movq 0x3dd0a(%rip), %rdx     # 0x5ff98
movq %rbx, %rdi
callq 0xb7d0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::setRngSeed(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setRngSeed( ConfigData& config, std::string const& seed ) {
        if( seed == "time" ) {
            config.rngSeed = static_cast<unsigned int>( std::time(0) );
        }
        else {
            std::stringstream ss;
            ss << seed;
            ss >> config.rngSeed;
            if( ss.fail() )
                throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" );
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x22a7d(%rip), %rsi     # 0x4532a
movq %r14, %rdi
callq 0xb100
testl %eax, %eax
je 0x2290e
movq %rsp, %rdi
callq 0xb330
leaq 0x10(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0xb530
addq $0x10, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xb810
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x22923
movq 0x3d639(%rip), %rsi     # 0x5ff30
movq %rsp, %rdi
callq 0xb380
leaq 0x80(%rsp), %rdi
callq 0xb120
jmp 0x22918
xorl %edi, %edi
callq 0xb430
movl %eax, 0x10(%rbx)
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb1f0
movq %rax, %r14
leaq 0x229f8(%rip), %rsi     # 0x4532f
movq %rax, %rdi
callq 0xb170
movq 0x3d6aa(%rip), %rsi     # 0x5fff0
movq 0x3d633(%rip), %rdx     # 0x5ff80
movq %r14, %rdi
callq 0xb7d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xb360
jmp 0x22965
movq %rax, %rbx
movq 0x3d5c4(%rip), %rsi     # 0x5ff30
movq %rsp, %rdi
callq 0xb380
leaq 0x80(%rsp), %rdi
callq 0xb120
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::Detail::BoundUnaryFunction<Catch::ConfigData>::set(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
virtual void set( C& obj, std::string const& stringValue ) const {
                bool value;
                convertInto( stringValue, value );
                if( value )
                    function( obj );
            }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rdi
callq 0xb330
leaq 0x50(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0xb530
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0xb280
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rsp,%rax)
jne 0x23e55
movq 0x3c100(%rip), %rsi     # 0x5ff30
leaq 0x40(%rsp), %rdi
callq 0xb380
leaq 0xc0(%rsp), %rdi
callq 0xb120
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xb1f0
movq %rax, %rbx
leaq 0x213bf(%rip), %rsi     # 0x45228
movq %rsp, %rdi
movq %r14, %rdx
callq 0x149d5
leaq 0x213c0(%rip), %rsi     # 0x4523b
movq %rsp, %rdi
callq 0xb8b0
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x23ea4
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x23eb1
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xb720
xorl %ebp, %ebp
movq 0x3c10f(%rip), %rsi     # 0x5fff0
movq 0x3c098(%rip), %rdx     # 0x5ff80
movq %rbx, %rdi
callq 0xb7d0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x23f0a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23f25
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
testb %bpl, %bpl
jne 0x23f4f
jmp 0x23f5c
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23f4f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x23f4f
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
jmp 0x23f5c
movq %rax, %r14
movq 0x3bfcd(%rip), %rsi     # 0x5ff30
leaq 0x40(%rsp), %rdi
callq 0xb380
leaq 0xc0(%rsp), %rdi
callq 0xb120
movq %r14, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Session::run(int, char const**)
int run( int argc, char const* argv[] ) {

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ecx
callq 0x2421c
testl %eax, %eax
je 0x24212
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x2443e
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Session::run()
int run() {
            if( m_configData.showHelp )
                return 0;

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

                seedRng( *m_config );

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

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
cmpb $0x0, 0x87(%rdi)
jne 0x2451b
movq %rdi, %rbx
callq 0x2741a
movq 0x138(%rbx), %rdi
callq 0x100be
leaq 0x138(%rbx), %r14
cmpb $0x1, 0x8a(%rbx)
jne 0x24480
movq (%r14), %rdi
callq 0xcead
movq %rbx, %rdi
callq 0x2741a
movq %rax, %rbx
movq $0x0, 0x8(%rsp)
cmpb $0x1, 0x10(%rax)
jne 0x244b9
movq %rbx, %rdi
callq 0x27931
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq %r14, (%rax)
movq %rax, -0x8(%rax)
cmpb $0x0, 0x13(%rbx)
jne 0x244c2
jmp 0x244d9
cmpb $0x1, 0x13(%rbx)
jne 0x244e1
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x27f93
addq %rax, %r14
leaq 0x10(%rsp), %rax
movq %r14, (%rax)
movq %rax, -0x8(%rax)
cmpb $0x0, 0x11(%rbx)
jne 0x244ea
jmp 0x24501
cmpb $0x1, 0x11(%rbx)
jne 0x24523
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x281f5
addq %rax, %r14
leaq 0x10(%rsp), %rax
movq %r14, (%rax)
movq %rax, -0x8(%rax)
cmpb $0x0, 0x12(%rbx)
je 0x24517
movq %rbx, %rdi
callq 0x28b70
addq %r14, %rax
movq %rax, 0x10(%rsp)
movl 0x10(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
cmpb $0x1, 0x12(%rbx)
jne 0x2452e
xorl %r14d, %r14d
jmp 0x24507
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xc8a4
jmp 0x24517
jmp 0x24549
jmp 0x24549
jmp 0x24549
jmp 0x24549
jmp 0x24549
jmp 0x24549
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2458d
movq %rbx, %rdi
callq 0xb190
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x3ba7f(%rip), %rdi     # 0x5ffe8
movq %rax, %rsi
callq 0xb470
movq %rax, %rdi
callq 0xb1e0
callq 0xb750
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x2451b
movq %rax, %rbx
callq 0xb750
movq %rbx, %rdi
callq 0xb820
movq %rax, %rdi
callq 0x14d37
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(int, char const**, Catch::ConfigData&) const
std::vector<Parser::Token> parseInto( int argc, char const* argv[], ConfigT& config ) const {
            std::string processName = argv[0];
            std::size_t lastSlash = processName.find_last_of( "/\\" );
            if( lastSlash != std::string::npos )
                processName = processName.substr( lastSlash+1 );
            m_boundProcessName.set( config, processName );
            std::vector<Parser::Token> tokens;
            Parser parser;
            parser.parseIntoTokens( argc, argv, tokens );
            return populate( tokens, config );
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rcx), %rsi
leaq 0x20(%rsp), %r13
movq %rsp, %rdx
movq %r13, %rdi
callq 0x13d78
leaq 0x20dac(%rip), %rsi     # 0x45380
movl $0x2, %ecx
movq %r13, %rdi
movq $-0x1, %rdx
callq 0xb910
cmpq $-0x1, %rax
je 0x24633
incq %rax
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0xb4d0
leaq 0x20(%rsp), %rdi
movq %rsp, %r13
movq %r13, %rsi
callq 0xb590
movq (%r13), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x24633
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq (%r15), %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movl $0x3a3d0920, (%r13)     # imm = 0x3A3D0920
movq $0x4, -0x8(%r13)
movb $0x0, 0x4(%r13)
movq %rsp, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x24e7a
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x24f8e
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x246ab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x40(%rsp), %rdi
callq 0x21ad4
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x246d0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x246e4
movq %rax, %rbx
jmp 0x2470c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x24702
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x40(%rsp), %rdi
callq 0x21ad4
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24727
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Tbc::operator<<(std::ostream&, Catch::Tbc::Text const&)
inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
                it != itEnd; ++it ) {
                if( it != _text.begin() )
                    _stream << "\n";
                _stream << *it;
            }
            return _stream;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rsi), %r12
movq 0x48(%rsi), %r13
cmpq %r13, %r12
je 0x2481e
movq %rsi, %r14
leaq 0x211f2(%rip), %r15     # 0x459e0
cmpq 0x40(%r14), %r12
je 0x24804
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb530
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xb530
addq $0x20, %r12
cmpq %r13, %r12
jne 0x247ee
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::usage(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void usage( std::ostream& os, std::string const& procName ) const {
            validate();
            os << "usage:\n  " << procName << " ";
            argSynopsis( os );
            if( !m_options.empty() ) {
                os << " [options]\n\nwhere options are: \n";
                optUsage( os, 2 );
            }
            os << "\n";
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2573e
leaq 0x20682(%rip), %rsi     # 0x45474
movl $0x9, %edx
movq %rbx, %rdi
callq 0xb530
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xb530
leaq 0x1fb7a(%rip), %rsi     # 0x4498f
movl $0x1, %edx
movq %rax, %rdi
callq 0xb530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x266b2
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x24e60
leaq 0x20640(%rip), %rsi     # 0x4547e
movl $0x20, %edx
movq %rbx, %rdi
callq 0xb530
movl $0x2, %edx
movl $0x50, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26872
leaq 0x20b79(%rip), %rsi     # 0x459e0
movl $0x1, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb530
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::populate(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const
std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
            validate();
            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
            unusedTokens = populateFixedArgs( unusedTokens, config );
            unusedTokens = populateFloatingArgs( unusedTokens, config );
            return unusedTokens;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2573e
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x257be
movq %rsp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x25e80
movq 0x10(%rbx), %rax
movq %rsp, %r12
movaps (%r12), %xmm0
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rbx)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
callq 0x21ad4
movq %r12, %rdi
callq 0x21ad4
movq %rsp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x25f76
movq 0x10(%rbx), %rax
movq %rsp, %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0x21ad4
movq %r14, %rdi
callq 0x21ad4
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x25077
movq %rax, %r14
movq %rbx, %rdi
callq 0x21ad4
movq %r14, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25f4d
movq %rdx, %r15
movq %rsi, %r12
leaq 0x28(%rsi), %rbp
movl $0x1, %r14d
xorl %ebx, %ebx
leaq (%rbx,%rbx,4), %rcx
leaq (%rax,%rcx,8), %r13
movq 0x30(%r12), %rcx
testq %rcx, %rcx
je 0x25efc
movq %rbp, %rax
xorl %edx, %edx
cmpl %r14d, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x25eda
cmpq %rbp, %rax
je 0x25efc
cmpl 0x20(%rax), %r14d
jge 0x25f38
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x254a0
cmpl $0x1, (%r13)
adcl $0x0, %r14d
incq %rbx
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
cmpq %rcx, %rbx
jb 0x25ec5
jmp 0x25f4d
leaq 0x8(%r13), %rdx
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rsp), %rsi
callq *0x10(%rax)
jmp 0x25f09
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 0x21ad4
movq %r14, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2600a
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x26015
xorl %r13d, %r13d
movabsq $-0x3333333333333333, %rbp # imm = 0xCCCCCCCCCCCCCCCD
xorl %r15d, %r15d
cmpl $0x0, (%rsi,%r13)
je 0x25fd0
addq %r13, %rsi
movq %rbx, %rdi
callq 0x254a0
jmp 0x25fea
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 0x25fbc
jmp 0x26015
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2639e
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 0x21ad4
movq %r14, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb5f0
movq 0x68(%r12), %rbp
movq 0x70(%r12), %rbx
cmpq %rbx, %rbp
je 0x2618b
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movb $0x1, %r14b
leaq 0x1fafd(%rip), %r15     # 0x45c06
leaq 0x10(%rsp), %r12
leaq 0x1e8b6(%rip), %r13     # 0x449cb
testb $0x1, %r14b
je 0x26120
xorl %r14d, %r14d
jmp 0x26130
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0xb530
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0xb530
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %r12, %rdi
callq 0xb530
addq $0x20, %rbp
cmpq %rbx, %rbp
jne 0x26115
movq (%rsp), %r12
cmpq $0x0, 0x88(%r12)
movq 0x8(%rsp), %r15
je 0x261c6
testb $0x1, %r14b
jne 0x26196
leaq 0x1e851(%rip), %rsi     # 0x449cb
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0xb530
jmp 0x26196
cmpq $0x0, 0x88(%r12)
je 0x261c6
leaq 0x1efcb(%rip), %rsi     # 0x45168
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0xb530
movq 0x80(%r12), %rsi
movq 0x88(%r12), %rdx
leaq 0x10(%rsp), %rdi
callq 0xb530
cmpq $0x0, 0x50(%r12)
je 0x2620c
leaq 0x1f229(%rip), %rsi     # 0x453fe
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0xb530
movq 0x48(%r12), %rsi
movq 0x50(%r12), %rdx
leaq 0x10(%rsp), %rdi
callq 0xb530
leaq 0x1ea58(%rip), %rsi     # 0x44c57
movl $0x1, %edx
movq %rax, %rdi
callq 0xb530
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0xb6f0
movq 0x39d68(%rip), %rsi     # 0x5ff88
leaq 0x10(%rsp), %rdi
callq 0xb220
leaq 0x80(%rsp), %rdi
callq 0xb120
movq %r15, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2624e
movq %rax, %rbx
movq 0x39d30(%rip), %rsi     # 0x5ff88
leaq 0x10(%rsp), %rdi
callq 0xb220
leaq 0x80(%rsp), %rdi
callq 0xb120
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
cmpl $0x0, 0x58(%rdi)
jle 0x267ca
leaq 0x28(%r14), %r12
movl $0x1, %r15d
leaq 0x1e579(%rip), %r13     # 0x44c57
cmpl $0x2, %r15d
jb 0x266f8
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x1e29c(%rip), %rsi     # 0x4498f
callq 0xb530
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x26726
movq %r12, %rbp
xorl %ecx, %ecx
cmpl %r15d, 0x20(%rax)
setl %cl
cmovgeq %rax, %rbp
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0x26704
cmpq %r12, %rbp
je 0x26726
cmpl 0x20(%rbp), %r15d
jge 0x26786
cmpq $0x0, 0x50(%r14)
je 0x2682d
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x1ecbf(%rip), %rsi     # 0x453ff
callq 0xb530
movq 0x50(%r14), %rbp
leaq 0x48(%rbp), %rax
addq $0x50, %rbp
movq (%rax), %rsi
movq (%rbp), %rdx
movq %rbx, %rdi
callq 0xb530
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0xb530
leal 0x1(%r15), %ecx
movl 0x58(%r14), %eax
cmpl %eax, %r15d
movl %ecx, %r15d
jl 0x266de
jmp 0x267a4
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x1ec6a(%rip), %rsi     # 0x453ff
callq 0xb530
leaq 0x70(%rbp), %rax
addq $0x78, %rbp
jmp 0x26751
cmpq $0x0, 0x50(%r14)
je 0x2681e
addq $0x50, %r14
cmpl $0x2, %eax
jl 0x267d5
leaq 0x1e1d4(%rip), %rsi     # 0x4498f
movl $0x1, %edx
movq %rbx, %rdi
callq 0xb530
jmp 0x267d5
cmpq $0x0, 0x50(%r14)
je 0x2681e
addq $0x50, %r14
leaq 0x1ecfe(%rip), %rsi     # 0x454da
movl $0x2, %edx
movq %rbx, %rdi
callq 0xb530
movq (%r14), %rax
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0xb530
leaq 0x1ecda(%rip), %rsi     # 0x454dd
movl $0x6, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb530
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xb1f0
movq %rax, %rbx
leaq 0x1ec5e(%rip), %rsi     # 0x4549f
movq %rax, %rdi
callq 0xb640
movq 0x39778(%rip), %rsi     # 0x5ffc8
movq 0x39741(%rip), %rdx     # 0x5ff98
movq %rbx, %rdi
callq 0xb7d0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb360
movq %r14, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
leaq 0x36cc5(%rip), %rax     # 0x5e168
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x276ac
movq %r14, %rdi
callq 0x277ea
movq %rax, 0xc8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%r14)
movq $0x0, 0xe0(%r14)
movq 0xa0(%r15), %rax
cmpq 0xa8(%r15), %rax
je 0x27611
movq %rbx, 0x8(%rsp)
callq 0x12f5c
leaq 0x58(%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 0x390d4(%rip), %rax     # 0x605f8
movq %rax, 0x40(%r13)
movq 0xa0(%r15), %rsi
cmpq %rsi, 0xa8(%r15)
je 0x2756d
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
xorl %ebx, %ebx
addq %rbp, %rsi
movq %r12, %rdi
callq 0x142d4
incq %rbx
movq 0xa0(%r15), %rsi
movq 0xa8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %rax, %rbx
jb 0x27541
leaq 0x30(%rsp), %rdi
callq 0x1c9fe
leaq 0x80(%rsp), %r15
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1c3e2
leaq 0x68(%rsp), %rbx
movq 0xe0(%r14), %rax
leaq 0x10(%rsp), %r12
movaps (%r12), %xmm0
movq 0x10(%r12), %rcx
movq %rcx, 0xe0(%r14)
movups 0xd0(%r14), %xmm1
movups %xmm0, 0xd0(%r14)
leaq 0xa0(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
callq 0x1d338
movq %r12, %rdi
callq 0x1d338
movq %r15, %rdi
callq 0x1d338
movq %rbx, %rdi
callq 0x1c67e
movq -0x20(%rbx), %rdi
cmpq %r13, %rdi
je 0x27611
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb4a0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x8(%rsp)
movq %rax, %r15
jmp 0x2765d
jmp 0x2762f
movq %rax, %r15
leaq 0xd0(%r14), %r12
leaq 0x30(%rsp), %rdi
callq 0x14376
movq %r12, %rdi
callq 0x1d338
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
je 0x2765d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x21a6c
movq %r15, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28f7f
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x1c61d(%rip), %rbp     # 0x454e2
leaq 0x20(%r15), %rdx
movq %r13, %rdi
leaq 0x1be20(%rip), %rsi     # 0x44cf3
callq 0x149d5
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb8b0
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x28f06
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x28f0e
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 0xb110
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x28f4f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x28f6b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %r15, %rdi
callq 0xb540
movq %rax, %r15
cmpq %r14, %rax
jne 0x28ec5
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x28fd1
movq %rax, %r14
jmp 0x28fb5
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x28fb5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x28fd1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x28fe9
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xb4a0
movq %r14, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c0b1
movq 0x40(%rbx), %rdi
leaq 0x18cab(%rip), %rsi     # 0x44d4f
movl $0x2, %edx
callq 0xb530
movb $0x0, (%rbx)
cmpb $0x1, 0x1(%rbx)
jne 0x2c0d0
movq 0x40(%rbx), %rdi
leaq 0x1991e(%rip), %rsi     # 0x459e0
movl $0x1, %edx
callq 0xb530
movb $0x0, 0x1(%rbx)
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %r15
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0xb530
movq %rax, %r12
leaq 0x19310(%rip), %rsi     # 0x453ff
movl $0x1, %edx
movq %rax, %rdi
callq 0xb530
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0xb530
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x23a92
leaq 0x1935d(%rip), %rsi     # 0x4547b
movq %r15, %rdi
callq 0xb8b0
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c5cf
movq %rsi, %r14
cmpb $0x1, (%rbx)
jne 0x2c57c
movl %edx, %ebp
movq 0x40(%rbx), %rdi
leaq 0x187f6(%rip), %rsi     # 0x44d4f
movl $0x2, %edx
callq 0xb530
movb $0x0, (%rbx)
testb %bpl, %bpl
je 0x2c57c
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0xb530
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 0x319ec
movl $0x0, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2c22c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2c5cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
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 0x2c5f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2dbea
movq %rbx, %rdi
callq 0x2e146
cmpb $0x0, 0x88(%rbx)
jne 0x2dbfb
movq %rbx, %rdi
callq 0x2e2c6
cmpb $0x0, 0x1c9(%rbx)
jne 0x2dc13
movq %rbx, %rdi
callq 0x2e352
movb $0x1, 0x1c9(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e84a
movq 0x8(%rbx), %rax
movq 0xe0(%rax), %rcx
addq 0xd8(%rax), %rcx
addq 0xe8(%rax), %rcx
jne 0x2e0a0
movq (%rbx), %rdi
leaq 0x1794c(%rip), %rsi     # 0x459e0
movl $0x1, %edx
callq 0xb530
jmp 0x2e0e1
movq 0x10(%rbx), %rax
testb $0x10, 0xb0(%rax)
je 0x2e0b5
movl 0x68(%rax), %eax
andl $0x8, %eax
je 0x2e0c9
movq (%rbx), %rdi
leaq 0x17921(%rip), %rsi     # 0x459e0
movl $0x1, %edx
callq 0xb530
movq %rbx, %rdi
callq 0x2e914
movq %rbx, %rdi
callq 0x2e97e
movq %rbx, %rdi
callq 0x2ea56
movq %rbx, %rdi
popq %rbx
jmp 0x2ebf0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17883(%rip), %rsi     # 0x459e0
movl $0x1, %edx
movq %r14, %rdi
callq 0xb530
cmpb $0x0, 0x324ef(%rip)     # 0x60660
jne 0x2e1a4
movaps 0x15eb6(%rip), %xmm0    # 0x44030
movups %xmm0, 0x3251e(%rip)    # 0x6069f
movaps %xmm0, 0x32508(%rip)    # 0x60690
movaps %xmm0, 0x324f1(%rip)    # 0x60680
movaps %xmm0, 0x324da(%rip)    # 0x60670
movaps %xmm0, 0x324c3(%rip)    # 0x60660
movb $0x0, 0x3250b(%rip)     # 0x606af
leaq 0x324b5(%rip), %r15     # 0x60660
movq %r15, %rdi
callq 0xb1a0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb530
leaq 0x17818(%rip), %rsi     # 0x459e0
movl $0x1, %edx
movq %r14, %rdi
callq 0xb530
movb $0x0, 0xf(%rsp)
movl $0x17, %edi
callq 0xe19c
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xb530
movq %rax, %r14
leaq 0x177a4(%rip), %rsi     # 0x459a6
movl $0xd, %edx
movq %rax, %rdi
callq 0xb530
leaq 0x32382(%rip), %rsi     # 0x60598
movq %r14, %rdi
callq 0xf197
leaq 0x1778f(%rip), %rsi     # 0x459b4
movl $0x13, %edx
movq %r14, %rdi
callq 0xb530
leaq 0x1778f(%rip), %rsi     # 0x459c8
movl $0x19, %edx
movq %r14, %rdi
callq 0xb530
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testl %eax, %eax
je 0x2e294
movq 0x18(%rbx), %r14
leaq 0x17783(%rip), %rsi     # 0x459e2
movl $0x16, %edx
movq %r14, %rdi
callq 0xb530
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0xb300
leaq 0x17758(%rip), %rsi     # 0x459df
movl $0x2, %edx
movq %rax, %rdi
callq 0xb530
movb $0x1, 0x48(%rbx)
xorl %edi, %edi
callq 0xe19c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x14d37
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xe206
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16b96(%rip), %rsi     # 0x452f3
xorl %r12d, %r12d
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0xb7f0
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 0x2482c
movq 0x40(%r15), %r12
movq 0x48(%r15), %r15
cmpq %r15, %r12
je 0x2e7ed
leaq 0x17224(%rip), %r14     # 0x459e0
cmpq 0x40(%rsp), %r12
je 0x2e7d3
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb530
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xb530
addq $0x20, %r12
cmpq %r15, %r12
jne 0x2e7bc
leaq 0x171ec(%rip), %rsi     # 0x459e0
movl $0x1, %edx
movq %rbx, %rdi
callq 0xb530
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x13df2
movq -0x40(%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2e829
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2e837
movq %rax, %rbx
movq %rsp, %rdi
callq 0x24db0
movq %rbx, %rdi
callq 0xb820