LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::assertionEnded(Catch::AssertionStats const&)
virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
        bool clearBuffer = false;
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            clearBuffer |= (*it)->assertionEnded( assertionStats );
        return clearBuffer;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x10, %rdi
callq 0x366b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x366e0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
callq 0x36720
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x366e0
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x36750
testb $0x1, %al
jne 0x36007
jmp 0x3604a
leaq -0x20(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x58(%rax)
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x367b0
jmp 0x35ff4
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::sectionEnded(Catch::SectionStats const&)
virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->sectionEnded( sectionStats );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
callq 0x366b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x366e0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x36720
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x366e0
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x36750
testb $0x1, %al
jne 0x360c3
jmp 0x360ec
leaq -0x18(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x60(%rax)
leaq -0x18(%rbp), %rdi
callq 0x367b0
jmp 0x360b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testGroupEnded(Catch::TestGroupStats const&)
virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testGroupEnded( testGroupStats );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
callq 0x366b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x366e0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x36720
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x366e0
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x36750
testb $0x1, %al
jne 0x36203
jmp 0x3622c
leaq -0x18(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x70(%rax)
leaq -0x18(%rbp), %rdi
callq 0x367b0
jmp 0x361f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testRunEnded( testRunStats );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
callq 0x366b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x366e0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x36720
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x366e0
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x36750
testb $0x1, %al
jne 0x362a3
jmp 0x362cc
leaq -0x18(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x78(%rax)
leaq -0x18(%rbp), %rdi
callq 0x367b0
jmp 0x36290
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::skipTest(Catch::TestCaseInfo const&)
virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->skipTest( testInfo );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
callq 0x366b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x366e0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x36720
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x366e0
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x36750
testb $0x1, %al
jne 0x36343
jmp 0x3636f
leaq -0x18(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x80(%rax)
leaq -0x18(%rbp), %rdi
callq 0x367b0
jmp 0x36330
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x372c0
movq -0x30(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
addq $0x20, %rdi
callq 0xe480
movq -0x38(%rbp), %rsi
movq %rax, %rcx
subq $0x2, %rcx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xe6d0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0xe800
leaq -0x28(%rbp), %rdi
callq 0xecd8
movq -0x30(%rbp), %rax
testb $0x1, (%rax)
je 0x3724d
movq -0x30(%rbp), %rdi
callq 0x37300
movq %rax, %rdi
leaq 0x46b53(%rip), %rsi     # 0x7dd92
callq 0xe670
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0x372a1
movq -0x30(%rbp), %rdi
callq 0x37300
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x46b26(%rip), %rsi     # 0x7dd96
callq 0xe670
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
callq 0x37320
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x46af7(%rip), %rsi     # 0x7dd93
callq 0xe670
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x37360
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
addq $0x8, %rax
movq %rax, -0xe0(%rbp)
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3bc80
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x3bc50
jmp 0x3a3d6
leaq -0xc0(%rbp), %rdi
callq 0x3bcf0
movq -0xe8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c1b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3bd20
movq -0xe8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c1b0
movq -0xf8(%rbp), %rdi
movq %rax, %rsi
callq 0x3c1f0
movq -0xf0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x3bcf0
movq -0xc8(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x43972(%rip), %rsi     # 0x7e2cd
callq 0x1c1d0
testb $0x1, %al
jne 0x3a966
jmp 0x3a97c
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
orl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x3aa33
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0xe310
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x43941(%rip), %rsi     # 0x7e2da
leaq -0x50(%rbp), %rdi
callq 0x1a170
jmp 0x3a9a4
leaq 0x438bf(%rip), %rdx     # 0x7e26a
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1ad20
jmp 0x3a9ba
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xea50
jmp 0x3a9c9
movq -0x68(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
movq 0x7a618(%rip), %rsi     # 0xb4ff0
movq 0x7a599(%rip), %rdx     # 0xb4f78
callq 0xeb10
jmp 0x3aa42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3aa20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3aa17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x50(%rbp), %rdi
callq 0xecd8
testb $0x1, -0x5d(%rbp)
jne 0x3aa28
jmp 0x3aa31
movq -0x68(%rbp), %rdi
callq 0xe4c0
jmp 0x3aa39
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x50, %rdi
callq 0x3e750
cmpq $0x0, %rax
je 0x3aac3
movl $0x10, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x43864(%rip), %rsi     # 0x7e2f2
callq 0xe920
jmp 0x3aa95
movq -0x38(%rbp), %rdi
movq 0x7a528(%rip), %rsi     # 0xb4fc8
movq 0x7a4e9(%rip), %rdx     # 0xb4f90
callq 0xeb10
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xe4c0
jmp 0x3ab34
movq -0x30(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x48(%rbp)
movl $0xa8, %edi
callq 0xe680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x3bc80
jmp 0x3aaea
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3e780
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
callq 0x3e750
movq %rax, %rsi
leaq -0x8(%rbp), %rdi
callq 0x3e7b0
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xa8, %esi
callq 0xe6a0
movq -0x20(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x42ff0(%rip), %rsi     # 0x7e36e
callq 0x1c1d0
testb $0x1, %al
jne 0x3b389
jmp 0x3b3a0
xorl %eax, %eax
movl %eax, %edi
callq 0xe5f0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x3b491
leaq -0x198(%rbp), %rdi
callq 0xe490
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe5a0
jmp 0x3b3be
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
leaq -0x198(%rbp), %rdi
callq 0xe0a0
jmp 0x3b3d4
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
callq 0xe030
movb %al, -0x1a5(%rbp)
jmp 0x3b3f4
movb -0x1a5(%rbp), %al
testb $0x1, %al
jne 0x3b400
jmp 0x3b475
movl $0x10, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
leaq 0x42f55(%rip), %rsi     # 0x7e373
callq 0xe220
jmp 0x3b425
movq -0x1b0(%rbp), %rdi
movq 0x79bbd(%rip), %rsi     # 0xb4ff0
movq 0x79b3e(%rip), %rdx     # 0xb4f78
callq 0xeb10
jmp 0x3b4a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x3b483
movq -0x1b0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
callq 0xe4c0
jmp 0x3b483
leaq -0x198(%rbp), %rdi
callq 0xe500
jmp 0x3b491
leaq -0x198(%rbp), %rdi
callq 0xe500
jmp 0x3b49a
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::Detail::BoundArgFunction<Catch::ConfigData>::operator=(Catch::Clara::Detail::BoundArgFunction<Catch::ConfigData> const&)
BoundArgFunction& operator = ( BoundArgFunction const& other ) {
                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL;
                delete functionObj;
                functionObj = newFunctionObj;
                return *this;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3b9a5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, -0x28(%rbp)
jmp 0x3b9ad
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x3b9ad
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3b9d0
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x3d4e0
testb $0x1, -0x19(%rbp)
je 0x3e27d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xe490
leaq -0x188(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xe5a0
jmp 0x3e4f1
movq -0x10(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0xe3d0
jmp 0x3e503
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
callq 0xe030
movb %al, -0x1ea(%rbp)
jmp 0x3e523
movb -0x1ea(%rbp), %al
testb $0x1, %al
jne 0x3e532
jmp 0x3e63c
movb $0x1, -0x1e9(%rbp)
movl $0x10, %edi
callq 0xe310
movq %rax, -0x1f8(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x3fd17(%rip), %rsi     # 0x7e26c
leaq -0x1e8(%rbp), %rdi
callq 0x1a170
jmp 0x3e563
leaq 0x3fd15(%rip), %rdx     # 0x7e27f
leaq -0x1c8(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x1ad20
jmp 0x3e57f
movq -0x1f8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xea50
jmp 0x3e594
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x1e9(%rbp)
movq 0x76a47(%rip), %rsi     # 0xb4ff0
movq 0x769c8(%rip), %rdx     # 0xb4f78
callq 0xeb10
jmp 0x3e669
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x3e651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x3e623
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x3e617
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xecd8
leaq -0x1e8(%rbp), %rdi
callq 0xecd8
testb $0x1, -0x1e9(%rbp)
jne 0x3e62e
jmp 0x3e63a
movq -0x1f8(%rbp), %rdi
callq 0xe4c0
jmp 0x3e651
leaq -0x198(%rbp), %rdi
callq 0xe500
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0xe500
movq -0x1a0(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x3f400
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3f3f1
movq -0x28(%rbp), %rdi
callq 0x3f6f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
testb $0x1, 0x87(%rax)
je 0x3f71c
movl $0x0, -0x4(%rbp)
jmp 0x3f8de
movq -0x78(%rbp), %rdi
callq 0x44920
jmp 0x3f727
movq -0x78(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x449c0
movq %rax, -0x80(%rbp)
jmp 0x3f73d
movq -0x80(%rbp), %rdi
callq 0x13f00
jmp 0x3f748
movq -0x78(%rbp), %rax
testb $0x1, 0x8a(%rax)
je 0x3f78f
movq -0x78(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x449c0
movq %rax, -0x88(%rbp)
jmp 0x3f76e
movq -0x88(%rbp), %rdi
callq 0x10420
jmp 0x3f77c
jmp 0x3f78f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3f816
movq -0x78(%rbp), %rdi
callq 0x44920
movq %rax, -0x90(%rbp)
jmp 0x3f7a1
movq -0x90(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x449e0
jmp 0x3f7b3
leaq -0x30(%rbp), %rdi
callq 0x44c10
movq %rax, -0x98(%rbp)
jmp 0x3f7c5
movq -0x98(%rbp), %rax
cmpq $0x0, %rax
je 0x3f88f
leaq -0x30(%rbp), %rdi
callq 0x44c40
movq %rax, -0xa0(%rbp)
jmp 0x3f7e8
movq -0xa0(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x4(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x3f896
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x44c60
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x3f8ea
movq -0x18(%rbp), %rdi
callq 0xe240
movq %rax, -0x70(%rbp)
callq 0x10b70
movq %rax, -0xb0(%rbp)
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0xe670
movq %rax, -0xa8(%rbp)
jmp 0x3f864
movq -0xa8(%rbp), %rdi
movq 0x756c6(%rip), %rsi     # 0xb4f38
callq 0xe6f0
jmp 0x3f879
callq 0x40430
movl %eax, -0x4(%rbp)
movl $0x1, -0x34(%rbp)
callq 0xea70
jmp 0x3f8de
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x44c60
movl -0x34(%rbp), %eax
testl %eax, %eax
je 0x3f8aa
jmp 0x3f8a8
jmp 0x3f8de
movq -0x78(%rbp), %rsi
addq $0x138, %rsi            # imm = 0x138
leaq -0x68(%rbp), %rdi
callq 0xfe10
jmp 0x3f8c0
movq -0x60(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x3f8de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xea70
jmp 0x3f8dc
jmp 0x3f8ea
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xeb60
movq %rax, %rdi
callq 0x1aa10
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xeb70
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x18c80
jmp 0x3f991
leaq -0x49(%rbp), %rdi
callq 0xe710
leaq -0x48(%rbp), %rdi
leaq 0x3ea1f(%rip), %rsi     # 0x7e3c4
movq $-0x1, %rdx
callq 0xe640
movq %rax, -0x68(%rbp)
cmpq $-0x1, -0x68(%rbp)
je 0x3fa25
movq -0x68(%rbp), %rdx
incq %rdx
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq $-0x1, %rcx
callq 0xe6d0
jmp 0x3f9dc
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xe800
leaq -0x88(%rbp), %rdi
callq 0xecd8
jmp 0x3fa25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0xe710
jmp 0x3fafd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3faf4
movq -0xd8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x40440
jmp 0x3fa3b
leaq -0xa0(%rbp), %rdi
callq 0x39fc0
leaq -0xc0(%rbp), %rdi
callq 0x40470
jmp 0x3fa55
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rcx
callq 0x404e0
jmp 0x3fa71
movq -0xd8(%rbp), %rsi
movq -0xe8(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq -0xa0(%rbp), %rdx
callq 0x40680
jmp 0x3fa91
leaq -0xc0(%rbp), %rdi
callq 0x40780
leaq -0xa0(%rbp), %rdi
callq 0x3a160
leaq -0x48(%rbp), %rdi
callq 0xecd8
movq -0xe0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3fae8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x40780
leaq -0xa0(%rbp), %rdi
callq 0x3a160
leaq -0x48(%rbp), %rdi
callq 0xecd8
movq -0x58(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x435f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43620
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x18df0
testb $0x1, %al
jne 0x3fc5d
jmp 0x3fcb5
movq -0x10(%rbp), %rdi
callq 0x435f0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x18df0
testb $0x1, %al
jne 0x3fc7d
jmp 0x3fc8d
movq -0x8(%rbp), %rdi
leaq 0x3eda1(%rip), %rsi     # 0x7ea29
callq 0xe670
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x18e30
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xe5a0
leaq -0x18(%rbp), %rdi
callq 0x18ec0
jmp 0x3fc4a
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x41650
movq -0x10(%rbp), %rdi
leaq 0x3e111(%rip), %rsi     # 0x7e4bd
callq 0xe670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x3d60c(%rip), %rsi     # 0x7d9d3
callq 0xe670
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43860
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x42110
testb $0x1, %al
jne 0x40411
movq -0x10(%rbp), %rdi
leaq 0x3e0d2(%rip), %rsi     # 0x7e4c7
callq 0xe670
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
movl $0x50, %ecx
callq 0x43a60
movq -0x10(%rbp), %rdi
leaq 0x3e60d(%rip), %rsi     # 0x7ea29
callq 0xe670
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x41650
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x41750
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x41e90
jmp 0x406e3
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x3fb10
movq -0x88(%rbp), %rdi
callq 0x3a160
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x41ff0
jmp 0x4071a
movq -0x70(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3fb10
leaq -0x68(%rbp), %rdi
callq 0x3a160
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x4075c
jmp 0x40753
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3a160
jmp 0x40769
movq -0x70(%rbp), %rdi
callq 0x3a160
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::validate() const
void validate() const
        {
            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
                throw std::logic_error( "No options or arguments specified" );

            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
                                                            itEnd = m_options.end();
                    it != itEnd; ++it )
                it->validate();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x42110
testb $0x1, %al
jne 0x41673
jmp 0x416e9
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x42150
testb $0x1, %al
jne 0x41686
jmp 0x416e9
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
callq 0x3e750
cmpq $0x0, %rax
jne 0x416e9
movl $0x10, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x3cd18(%rip), %rsi     # 0x7e3cc
callq 0xe920
jmp 0x416bb
movq -0x38(%rbp), %rdi
movq 0x73902(%rip), %rsi     # 0xb4fc8
movq 0x738c3(%rip), %rdx     # 0xb4f90
callq 0xeb10
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xe4c0
jmp 0x41740
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x42170
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x421a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x421d0
testb $0x1, %al
jne 0x4171e
jmp 0x4173a
leaq -0x20(%rbp), %rdi
callq 0x42210
movq %rax, %rdi
callq 0x42230
leaq -0x20(%rbp), %rdi
callq 0x422b0
jmp 0x4170b
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x39fc0
movl $0x1, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x412b0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x41fbd
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x42380
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x42ac0
movq %rax, -0x80(%rbp)
jmp 0x41f1f
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
callq 0x42b20
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x42af0
testb $0x1, %al
jne 0x41f4b
jmp 0x41f87
leaq -0x40(%rbp), %rdi
callq 0x42b50
movq %rax, %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x8, %rdx
callq 0x40440
jmp 0x41f6e
jmp 0x41f98
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3a160
jmp 0x41fdd
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x40cc0
jmp 0x41f96
jmp 0x41f98
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x41faa
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x41fac
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x41ed6
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x41fd0
movq -0x70(%rbp), %rdi
callq 0x3a160
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x50, %rdi
callq 0x3e750
cmpq $0x0, %rax
jne 0x4203c
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42ea0
jmp 0x420fd
movq -0x60(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0x39fc0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x412b0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x420e8
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x42380
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x420c4
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
callq 0x42f90
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x8, %rdx
callq 0x40440
jmp 0x420ab
jmp 0x420d5
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3a160
jmp 0x42107
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x40cc0
jmp 0x420d3
jmp 0x420d5
jmp 0x420d7
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x42051
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x420fb
movq -0x60(%rbp), %rdi
callq 0x3a160
jmp 0x420fd
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xe8d0
movq -0x1b8(%rbp), %rdi
movb $0x1, -0x189(%rbp)
addq $0x68, %rdi
callq 0x224f0
movq -0x1b8(%rbp), %rdi
movq %rax, -0x198(%rbp)
addq $0x68, %rdi
callq 0x22520
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x18df0
testb $0x1, %al
jne 0x4254c
jmp 0x425e4
testb $0x1, -0x189(%rbp)
je 0x4255e
movb $0x0, -0x189(%rbp)
jmp 0x42598
leaq 0x3b4aa(%rip), %rsi     # 0x7da0f
leaq -0x188(%rbp), %rdi
callq 0xe670
jmp 0x42573
jmp 0x42598
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xe130
jmp 0x426eb
leaq 0x3c6b0(%rip), %rsi     # 0x7ec4f
leaq -0x188(%rbp), %rdi
callq 0xe670
movq %rax, -0x1d0(%rbp)
jmp 0x425b4
leaq -0x198(%rbp), %rdi
callq 0x18e30
movq -0x1d0(%rbp), %rdi
movq %rax, %rsi
callq 0xe5a0
jmp 0x425d1
jmp 0x425d3
leaq -0x198(%rbp), %rdi
callq 0x18ec0
jmp 0x42530
movq -0x1b8(%rbp), %rdi
addq $0x68, %rdi
addq $0x18, %rdi
callq 0xea90
testb $0x1, %al
jne 0x42653
testb $0x1, -0x189(%rbp)
jne 0x4261c
leaq 0x3b403(%rip), %rsi     # 0x7da0f
leaq -0x188(%rbp), %rdi
callq 0xe670
jmp 0x4261a
jmp 0x4261c
leaq 0x3bb89(%rip), %rsi     # 0x7e1ac
leaq -0x188(%rbp), %rdi
callq 0xe670
movq %rax, -0x1d8(%rbp)
jmp 0x42638
movq -0x1d8(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
subq $-0x80, %rsi
callq 0xe5a0
jmp 0x42651
jmp 0x42653
movq -0x1b8(%rbp), %rdi
addq $0x48, %rdi
callq 0xea90
testb $0x1, %al
jne 0x426ba
leaq 0x3bdd9(%rip), %rsi     # 0x7e447
leaq -0x188(%rbp), %rdi
callq 0xe670
movq %rax, -0x1e0(%rbp)
jmp 0x42683
movq -0x1e0(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
addq $0x48, %rsi
callq 0xe5a0
movq %rax, -0x1e8(%rbp)
jmp 0x426a3
movq -0x1e8(%rbp), %rdi
leaq 0x3b5ea(%rip), %rsi     # 0x7dc9b
callq 0xe670
jmp 0x426b8
jmp 0x426ba
movq -0x1c8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xe6b0
jmp 0x426cf
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x1c0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::list(Catch::Config const&)
inline Option<std::size_t> list( Config const& config ) {
        Option<std::size_t> listedCount;
        if( config.listTests() )
            listedCount = listedCount.valueOr(0) + listTests( config );
        if( config.listTestNamesOnly() )
            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
        if( config.listTags() )
            listedCount = listedCount.valueOr(0) + listTags( config );
        if( config.listReporters() )
            listedCount = listedCount.valueOr(0) + listReporters( config );
        return listedCount;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x45400
movq -0x10(%rbp), %rdi
callq 0x45420
movb %al, -0x69(%rbp)
jmp 0x44a15
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x44a1e
jmp 0x44a8e
movq -0x80(%rbp), %rdi
movq $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x45440
movq %rax, -0x88(%rbp)
jmp 0x44a3c
movq -0x10(%rbp), %rdi
callq 0x45480
movq %rax, -0x90(%rbp)
jmp 0x44a4e
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rcx
movq -0x88(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x45ba0
jmp 0x44a72
jmp 0x44a8e
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x44c60
jmp 0x44c07
movq -0x10(%rbp), %rdi
callq 0x45be0
movb %al, -0x91(%rbp)
jmp 0x44a9f
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x44aab
jmp 0x44b01
movq -0x80(%rbp), %rdi
movq $0x0, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x45440
movq %rax, -0xa0(%rbp)
jmp 0x44ac9
movq -0x10(%rbp), %rdi
callq 0x45c00
movq %rax, -0xa8(%rbp)
jmp 0x44adb
movq -0x80(%rbp), %rdi
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x45ba0
jmp 0x44aff
jmp 0x44b01
movq -0x10(%rbp), %rdi
callq 0x45ed0
movb %al, -0xa9(%rbp)
jmp 0x44b12
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x44b1e
jmp 0x44b74
movq -0x80(%rbp), %rdi
movq $0x0, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x45440
movq %rax, -0xb8(%rbp)
jmp 0x44b3c
movq -0x10(%rbp), %rdi
callq 0x45ef0
movq %rax, -0xc0(%rbp)
jmp 0x44b4e
movq -0x80(%rbp), %rdi
movq -0xc0(%rbp), %rcx
movq -0xb8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x45ba0
jmp 0x44b72
jmp 0x44b74
movq -0x10(%rbp), %rdi
callq 0x46820
movb %al, -0xc1(%rbp)
jmp 0x44b85
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x44b91
jmp 0x44be7
movq -0x80(%rbp), %rdi
movq $0x0, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x45440
movq %rax, -0xd0(%rbp)
jmp 0x44baf
movq -0x10(%rbp), %rdi
callq 0x46840
movq %rax, -0xd8(%rbp)
jmp 0x44bc1
movq -0x80(%rbp), %rdi
movq -0xd8(%rbp), %rcx
movq -0xd0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x45ba0
jmp 0x44be5
jmp 0x44be7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x44bfa
movq -0x80(%rbp), %rdi
callq 0x44c60
movq -0x78(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xeb60
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x44f30
movq -0xc0(%rbp), %rdi
leaq 0x6dfdf(%rip), %rax     # 0xb2cb0
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x44f70
jmp 0x44cea
movq -0xc0(%rbp), %rdi
movq %rdi, %rax
addq $0xc8, %rax
movq %rax, -0xd0(%rbp)
callq 0x450a0
movq %rax, -0xc8(%rbp)
jmp 0x44d0f
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rdi
callq 0x45290
movq -0xc0(%rbp), %rdi
addq $0xd0, %rdi
movq %rdi, -0xd8(%rbp)
callq 0x29600
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x18c10
testb $0x1, %al
jne 0x44e75
callq 0x10370
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x196a0
jmp 0x44d6a
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x223d0
movq %rax, %rcx
movq -0xe0(%rbp), %rax
cmpq %rcx, %rax
jae 0x44e2e
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
movq -0x98(%rbp), %rsi
callq 0x44900
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x196f0
jmp 0x44dce
jmp 0x44dd0
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x44d75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x44ea2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x44e96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x44e7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x19870
jmp 0x44e7e
leaq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x197d0
jmp 0x44e43
movq -0xc0(%rbp), %rdi
addq $0xd0, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x19820
leaq -0xb0(%rbp), %rdi
callq 0x19850
leaq -0x90(%rbp), %rdi
callq 0x19870
addq $0xe0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x19850
movq -0xd0(%rbp), %rdi
callq 0x452b0
movq -0xb8(%rbp), %rdi
callq 0x3a100
movq -0xc0(%rbp), %rdi
callq 0x45320
movq -0x18(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)