LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&)
virtual bool sectionStarted (
            SectionInfo const& sectionInfo,
            Counts& assertions
        )
        {
            std::ostringstream oss;
            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;

            ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, oss.str() );
            if( !sectionTracker.isOpen() )
                return false;
            m_activeSections.push_back( &sectionTracker );

            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;

            m_reporter->sectionStarting( sectionInfo );

            assertions = m_totals.assertions;

            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0xe8d0
movq -0x1f0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe5a0
movq %rax, -0x1e8(%rbp)
jmp 0x22fee
movq -0x1e8(%rbp), %rdi
leaq 0x5ab5c(%rip), %rsi     # 0x7db58
callq 0xe670
movq %rax, -0x200(%rbp)
jmp 0x2300a
movq -0x200(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
callq 0x10b20
jmp 0x23020
movq -0x1f8(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
movq %rax, -0x208(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xe6b0
jmp 0x23049
movq -0x208(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x25780
movq %rax, -0x210(%rbp)
jmp 0x23065
leaq -0x1d0(%rbp), %rdi
callq 0xecd8
movq -0x210(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq -0x1b0(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movb %al, -0x211(%rbp)
jmp 0x23097
movb -0x211(%rbp), %al
testb $0x1, %al
jne 0x230f0
jmp 0x230a3
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x231a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x231bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xecd8
jmp 0x231bc
movq -0x1f8(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq -0x1b0(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x1e0(%rbp), %rsi
callq 0x25900
jmp 0x2311a
movq -0x1f8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
addq $0x180, %rdi            # imm = 0x180
callq 0x25740
jmp 0x23137
movq -0x1f8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x19db0
movq %rax, -0x220(%rbp)
jmp 0x23153
movq -0x220(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
jmp 0x23169
movq -0x1f8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x110(%rcx), %rdx
movq %rdx, (%rax)
movq 0x118(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x120(%rcx), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xe130
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0xe130
movq -0x1a0(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::RunContext::sectionEnded(Catch::SectionEndInfo const&)
virtual void sectionEnded( SectionEndInfo const& endInfo ) {
            Counts assertions = m_totals.assertions - endInfo.prevAssertions;
            bool missingAssertions = testForMissingAssertions( assertions );

            if( !m_activeSections.empty() ) {
                m_activeSections.back()->close();
                m_activeSections.pop_back();
            }

            m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) );
            m_messages.clear();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
addq $0x110, %rsi            # imm = 0x110
movq -0x10(%rbp), %rdx
addq $0x68, %rdx
leaq -0x28(%rbp), %rdi
callq 0x264c0
movq -0xe0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x26530
movq -0xe0(%rbp), %rdi
andb $0x1, %al
movb %al, -0x29(%rbp)
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x265e0
testb $0x1, %al
jne 0x23271
movq -0xe0(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x25f50
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0xe0(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x26620
movq -0xe0(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x19db0
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rsi
movsd 0x80(%rsi), %xmm0
movzbl -0x29(%rbp), %ecx
andl $0x1, %ecx
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x26650
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
jmp 0x232ce
leaq -0xc8(%rbp), %rdi
callq 0x177d0
movq -0xe0(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x24370
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x177d0
movq -0xd0(%rbp), %rdi
callq 0xeb60
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::RunContext::sectionEndedEarly(Catch::SectionEndInfo const&)
virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) {
            if( m_unfinishedSections.empty() )
                m_activeSections.back()->fail();
            else
                m_activeSections.back()->close();
            m_activeSections.pop_back();

            m_unfinishedSections.push_back( endInfo );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x26810
testb $0x1, %al
jne 0x2334a
jmp 0x23365
movq -0x18(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x25f50
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x2337e
movq -0x18(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x25f50
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0x18(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x26620
movq -0x18(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movq -0x10(%rbp), %rsi
callq 0x26850
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) {
            SectionTracker* section = CATCH_NULL;

            ITracker& currentTracker = ctx.currentTracker();
            if( ITracker* childTracker = currentTracker.findChild( name ) ) {
                section = dynamic_cast<SectionTracker*>( childTracker );
                assert( section );
            }
            else {
                section = new SectionTracker( name, ctx, &currentTracker );
                currentTracker.addChild( section );
            }
            if( !ctx.completedCycle() && !section->isComplete() ) {

                section->open();
            }
            return *section;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25930
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2582a
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x257ed
movq -0x48(%rbp), %rdi
leaq 0x8d679(%rip), %rsi     # 0xb2e50
leaq 0x8d732(%rip), %rdx     # 0xb2f10
xorl %eax, %eax
movl %eax, %ecx
callq 0xe780
movq %rax, -0x50(%rbp)
jmp 0x257f5
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x257f5
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x25806
jmp 0x25825
leaq 0x59391(%rip), %rdi     # 0x7eb9e
leaq 0x58222(%rip), %rsi     # 0x7da36
movl $0x15ea, %edx           # imm = 0x15EA
leaq 0x583e3(%rip), %rcx     # 0x7dc03
callq 0xe440
jmp 0x258c3
movl $0x60, %edi
callq 0xe680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x25950
jmp 0x25851
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x259a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq (%rdi), %rax
movq 0x68(%rax), %rax
callq *%rax
jmp 0x25885
leaq -0x40(%rbp), %rdi
callq 0x23d00
jmp 0x258c3
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x60, %esi
callq 0xe6a0
jmp 0x258f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x23d00
jmp 0x258f1
movq -0x8(%rbp), %rdi
callq 0x259e0
testb $0x1, %al
jne 0x258e7
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x258e7
movq -0x18(%rbp), %rdi
callq 0x25a00
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::open()
void open() {
            m_runState = Executing;
            moveToThis();
            if( m_parent )
                m_parent->openChild();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, 0x58(%rdi)
callq 0x25cb0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x25a39
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Counts::operator-(Catch::Counts const&) const
Counts operator - ( Counts const& other ) const {
            Counts diff;
            diff.passed = passed - other.passed;
            diff.failed = failed - other.failed;
            diff.failedButOk = failedButOk - other.failedButOk;
            return diff;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1bb30
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq -0x10(%rbp), %rsi
subq (%rsi), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rdx
movq -0x10(%rbp), %rsi
subq 0x8(%rsi), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::RunContext::testForMissingAssertions(Catch::Counts&)
bool testForMissingAssertions( Counts& assertions ) {
            if( assertions.total() != 0 )
                return false;
            if( !m_config->warnAboutMissingAssertions() )
                return false;
            if( m_trackerContext.currentTracker().hasChildren() )
                return false;
            m_totals.assertions.failed++;
            assertions.failed++;
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x266e0
cmpq $0x0, %rax
je 0x2655d
movb $0x0, -0x1(%rbp)
jmp 0x265cf
movq -0x20(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x19f20
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0x26580
movb $0x0, -0x1(%rbp)
jmp 0x265cf
movq -0x20(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x25930
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb $0x1, %al
jne 0x2659f
jmp 0x265a5
movb $0x0, -0x1(%rbp)
jmp 0x265cf
movq -0x20(%rbp), %rax
movq 0x118(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x118(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::RunContext::makeUnexpectedResultBuilder() const
ResultBuilder makeUnexpectedResultBuilder() const {
            return ResultBuilder(   m_lastAssertionInfo.macroName.c_str(),
                                    m_lastAssertionInfo.lineInfo,
                                    m_lastAssertionInfo.capturedExpression.c_str(),
                                    m_lastAssertionInfo.resultDisposition );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x160, %rdi            # imm = 0x160
callq 0xe260
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdi, %rax
addq $0x160, %rax            # imm = 0x160
addq $0x20, %rax
movq %rax, -0x28(%rbp)
addq $0x160, %rdi            # imm = 0x160
addq $0x48, %rdi
callq 0xe260
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl 0x1c8(%rax), %r8d
leaq 0x56ba1(%rip), %r9      # 0x7ea2a
callq 0x155f0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::RunContext::handleUnfinishedSections()
void handleUnfinishedSections() {
            // If sections ended prematurely due to an exception we stored their
            // infos here so we can tear them down outside the unwind process.
            for( std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
                        itEnd = m_unfinishedSections.rend();
                    it != itEnd;
                    ++it )
                sectionEnded( *it );
            m_unfinishedSections.clear();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x1d0, %rsi            # imm = 0x1D0
leaq -0x18(%rbp), %rdi
callq 0x280a0
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x280f0
movq -0x30(%rbp), %rsi
addq $0x1d0, %rsi            # imm = 0x1D0
leaq -0x28(%rbp), %rdi
callq 0x28120
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x280f0
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x28170
testb $0x1, %al
jne 0x27f05
jmp 0x27f26
leaq -0x10(%rbp), %rdi
callq 0x281a0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x20(%rax)
leaq -0x10(%rbp), %rdi
callq 0x281d0
jmp 0x27ef2
movq -0x30(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x28200
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: void Catch::TestSpecParser::addPattern<Catch::TestSpec::NamePattern>()
void addPattern() {
            std::string token = subString();
            if( startsWith( token, "exclude:" ) ) {
                m_exclusion = true;
                token = token.substr( 8 );
            }
            if( !token.empty() ) {
                Ptr<TestSpec::Pattern> pattern = new T( token );
                if( m_exclusion )
                    pattern = new TestSpec::ExcludedPattern( pattern );
                m_currentFilter.m_patterns.push_back( pattern );
            }
            m_exclusion = false;
            m_mode = None;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x29c20
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xeb70
movq -0x90(%rbp), %rdx
leaq 0x54311(%rip), %rsi     # 0x7dc72
leaq -0x48(%rbp), %rdi
callq 0x18c80
jmp 0x2996c
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x12400
movb %al, -0x99(%rbp)
jmp 0x29981
leaq -0x48(%rbp), %rdi
callq 0xecd8
leaq -0x49(%rbp), %rdi
callq 0xe710
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x299a2
jmp 0x29a22
movq -0x98(%rbp), %rax
movb $0x1, 0x4(%rax)
leaq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
movq $-0x1, %rcx
callq 0xe6d0
jmp 0x299c8
leaq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xe800
leaq -0x80(%rbp), %rdi
callq 0xecd8
jmp 0x29a22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x29a03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xecd8
leaq -0x49(%rbp), %rdi
callq 0xe710
jmp 0x29b64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x29b64
leaq -0x28(%rbp), %rdi
callq 0xea90
testb $0x1, %al
jne 0x29b41
movl $0x40, %edi
callq 0xe680
movq %rax, -0xa8(%rbp)
jmp 0x29a46
movq -0xa8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2b490
jmp 0x29a58
movq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2ab40
jmp 0x29a6d
movq -0x98(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x29b0c
movl $0x18, %edi
callq 0xe680
movq %rax, -0xb0(%rbp)
jmp 0x29a91
movq -0xb0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2ab80
jmp 0x29aa6
movq -0xb0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2abe0
jmp 0x29abb
jmp 0x29b0c
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movl $0x40, %esi
callq 0xe6a0
jmp 0x29b64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x29b33
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movl $0x18, %esi
callq 0xe6a0
jmp 0x29b33
movq -0x98(%rbp), %rdi
addq $0x38, %rdi
leaq -0x88(%rbp), %rsi
callq 0x2ac50
jmp 0x29b25
leaq -0x88(%rbp), %rdi
callq 0x1cf50
jmp 0x29b41
leaq -0x88(%rbp), %rdi
callq 0x1cf50
jmp 0x29b64
movq -0x98(%rbp), %rax
movb $0x0, 0x4(%rax)
movl $0x0, (%rax)
leaq -0x28(%rbp), %rdi
callq 0xecd8
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x28(%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::TestCaseTracking::TrackerContext::startRun()
inline ITracker& TrackerContext::startRun() {
        m_rootTracker = new SectionTracker( "{root}", *this, CATCH_NULL );
        m_currentTracker = CATCH_NULL;
        m_runState = Executing;
        return *m_rootTracker;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x60, %edi
callq 0xe680
movq %rax, -0x50(%rbp)
movb $0x1, -0x3d(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xeb70
movq -0x48(%rbp), %rdx
leaq 0x5218d(%rip), %rsi     # 0x7dc7b
leaq -0x28(%rbp), %rdi
callq 0x18c80
jmp 0x2baf9
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x28(%rbp), %rsi
callq 0x25950
jmp 0x2bb10
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
callq 0x2c2b0
jmp 0x2bb23
leaq -0x28(%rbp), %rdi
callq 0xecd8
leaq -0x29(%rbp), %rdi
callq 0xe710
movq -0x58(%rbp), %rdi
movq $0x0, 0x8(%rdi)
movl $0x1, 0x10(%rdi)
callq 0x2c320
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2bb76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xecd8
leaq -0x29(%rbp), %rdi
callq 0xe710
testb $0x1, -0x3d(%rbp)
jne 0x2bb87
jmp 0x2bb95
movq -0x50(%rbp), %rdi
movl $0x60, %esi
callq 0xe6a0
jmp 0x2bb97
movq -0x38(%rbp), %rdi
callq 0xeb60
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Totals::delta(Catch::Totals const&) const
Totals delta( Totals const& prevTotals ) const {
            Totals diff = *this - prevTotals;
            if( diff.assertions.failed > 0 )
                ++diff.testCases.failed;
            else if( diff.assertions.failedButOk > 0 )
                ++diff.testCases.failedButOk;
            else
                ++diff.testCases.passed;
            return diff;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2c850
movq -0x18(%rbp), %rdi
cmpq $0x0, 0x8(%rdi)
jbe 0x2c235
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x2c264
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x2c252
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x2c262
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x2c264
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Counts::operator+=(Catch::Counts const&)
Counts& operator += ( Counts const& other ) {
            passed += other.passed;
            failed += other.failed;
            failedButOk += other.failedButOk;
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::FatalConditionHandler::reset()
void reset() {
            if( m_isSet ) {
                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
                    signal( signalDefs[i].id, SIG_DFL );
                m_isSet = false;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, (%rax)
je 0x2c66a
movq $0x0, -0x10(%rbp)
cmpq $0x6, -0x10(%rbp)
jae 0x2c663
movq -0x10(%rbp), %rcx
leaq 0x8903d(%rip), %rax     # 0xb5680
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xe7d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2c631
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::FatalConditionHandler::handleSignal(int)
static void handleSignal( int sig ) {
            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
                if( sig == signalDefs[i].id )
                    fatal( signalDefs[i].name, -sig );
            fatal( "<unknown signal>", -sig );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x6, -0x10(%rbp)
jae 0x2c76e
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rdx
leaq 0x88fc1(%rip), %rcx     # 0xb5680
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x2c75b
movq -0x10(%rbp), %rax
shlq $0x4, %rax
leaq 0x88fa3(%rip), %rcx     # 0xb5680
movq 0x8(%rax,%rcx), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xeb70
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x18c80
jmp 0x2c706
movl -0x4(%rbp), %esi
negl %esi
leaq -0x30(%rbp), %rdi
callq 0x2c800
jmp 0x2c716
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x2c75b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2c74d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x2c7ee
jmp 0x2c75d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2c6a6
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xeb70
movq -0x88(%rbp), %rdx
leaq 0x51500(%rip), %rsi     # 0x7dc8c
leaq -0x68(%rbp), %rdi
callq 0x18c80
jmp 0x2c797
movl -0x4(%rbp), %esi
negl %esi
leaq -0x68(%rbp), %rdi
callq 0x2c800
jmp 0x2c7a7
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x69(%rbp), %rdi
callq 0xe710
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2c7e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x69(%rbp), %rdi
callq 0xe710
movq -0x40(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::fatal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
inline void fatal( std::string const& message, int exitCode ) {
        IContext& context = Catch::getCurrentContext();
        IResultCapture* resultCapture = context.getResultCapture();
        resultCapture->handleFatalErrorCondition( message );

		if( Catch::alwaysTrue() ) // avoids "no return" warnings
            exit( exitCode );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0xf5b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
callq 0x1ba60
testb $0x1, %al
jne 0x2c83f
jmp 0x2c847
movl -0xc(%rbp), %edi
callq 0xe7f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Totals::operator-(Catch::Totals const&) const
Totals operator - ( Totals const& other ) const {
            Totals diff;
            diff.assertions = assertions - other.assertions;
            diff.testCases = testCases - other.testCases;
            return diff;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x19590
movq -0x58(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x264c0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
leaq -0x40(%rbp), %rdi
callq 0x264c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rdi)
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rdi)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rdi)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestSpec::Filter::matches(Catch::TestCaseInfo const&) const
bool matches( TestCaseInfo const& testCase ) const {
                // All patterns in a filter must match for the filter to be a match
                for( std::vector<Ptr<Pattern> >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it )
                    if( !(*it)->matches( testCase ) )
                        return false;
                    return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x28d60
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x28d90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x29140
testb $0x1, %al
jne 0x2d5f1
jmp 0x2d626
leaq -0x20(%rbp), %rdi
callq 0x291b0
movq %rax, %rdi
callq 0x2d640
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x2d619
movb $0x0, -0x1(%rbp)
jmp 0x2d62a
jmp 0x2d61b
leaq -0x20(%rbp), %rdi
callq 0x291d0
jmp 0x2d5de
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IConfig const> const&) const
virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
            FactoryMap::const_iterator it =  m_factories.find( name );
            if( it == m_factories.end() )
                return CATCH_NULL;
            return it->second->create( ReporterConfig( config ) );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x2e480
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x2e4e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e4b0
testb $0x1, %al
jne 0x2de81
jmp 0x2de8b
movq $0x0, -0x8(%rbp)
jmp 0x2def6
leaq -0x28(%rbp), %rdi
callq 0x2e510
movq %rax, %rdi
addq $0x20, %rdi
callq 0x19130
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x19150
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, -0x60(%rbp)
jmp 0x2decc
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x191a0
jmp 0x2def6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x191a0
jmp 0x2df00
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: void Catch::deleteAll<std::vector<Catch::IExceptionTranslator const*, std::allocator<Catch::IExceptionTranslator const*>>>(std::vector<Catch::IExceptionTranslator const*, std::allocator<Catch::IExceptionTranslator const*>>&)
inline void deleteAll( ContainerT& container ) {
        typename ContainerT::const_iterator it = container.begin();
        typename ContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
            delete *it;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ecf0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2ed20
movq -0x8(%rbp), %rdi
callq 0x2ed60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2ed20
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2ed90
testb $0x1, %al
jne 0x2ec53
jmp 0x2ec80
leaq -0x10(%rbp), %rdi
callq 0x2edd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2ec73
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2ec75
leaq -0x10(%rbp), %rdi
callq 0x2edf0
jmp 0x2ec40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ExceptionTranslatorRegistry::tryTranslators[abi:cxx11]() const
std::string tryTranslators() const {
            if( m_translators.empty() )
                throw;
            else
                return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x2f0b0
testb $0x1, %al
jne 0x2f032
jmp 0x2f037
callq 0xe930
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2f0f0
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x2f110
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x2f140
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x2f180
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Context::getGeneratorsForCurrentTest()
IGeneratorsForTest& getGeneratorsForCurrentTest() {
            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
            if( !generators ) {
                std::string testName = getResultCapture()->getCurrentTestName();
                generators = createGeneratorsForTest();
                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
            }
            return *generators;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x31360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x31348
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq (%rsi), %rax
movq 0x40(%rax), %rax
leaq -0x30(%rbp), %rdi
callq *%rax
callq 0x11e40
movq %rax, -0x88(%rbp)
jmp 0x312a6
movq -0x80(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, -0x10(%rbp)
addq $0x20, %rax
movq %rax, -0x90(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x31490
jmp 0x312d3
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x31450
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x312f2
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movb %al, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x314d0
leaq -0x30(%rbp), %rdi
callq 0xecd8
jmp 0x31348
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3133d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x314d0
leaq -0x30(%rbp), %rdi
callq 0xecd8
jmp 0x31355
movq -0x10(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xeb60
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Context::findGeneratorsForCurrentTest()
IGeneratorsForTest* findGeneratorsForCurrentTest() {
            std::string testName = getResultCapture()->getCurrentTestName();

            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
                m_generatorsByTestName.find( testName );
            return it != m_generatorsByTestName.end()
                ? it->second
                : CATCH_NULL;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq (%rsi), %rax
movq 0x40(%rax), %rax
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq *%rax
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x20, %rdi
callq 0x314f0
movq %rax, -0x60(%rbp)
jmp 0x313ab
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x31520
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x31570
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x31520
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x31540
testb $0x1, %al
jne 0x313f1
jmp 0x31404
leaq -0x30(%rbp), %rdi
callq 0x315a0
movq 0x20(%rax), %rax
movq %rax, -0x78(%rbp)
jmp 0x3140c
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x3140c
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xecd8
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xecd8
movq -0x40(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::GeneratorsForTest::getGeneratorInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
            if( it == m_generatorsByName.end() ) {
                IGeneratorInfo* info = new GeneratorInfo( size );
                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
                m_generatorsInOrder.push_back( info );
                return *info;
            }
            return *it->second;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x32c60
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32c90
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x32ce0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x32c90
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x32cb0
testb $0x1, %al
jne 0x321d7
jmp 0x322c7
movl $0x18, %edi
callq 0xe680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rsi
callq 0x32d10
jmp 0x321f9
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, -0x48(%rbp)
addq $0x8, %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x48(%rbp), %rdx
callq 0x32da0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x32d60
movb %dl, -0xa9(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x32250
movb -0xa9(%rbp), %al
movq -0xa8(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movb %al, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x32de0
movq -0x98(%rbp), %rdi
addq $0x38, %rdi
leaq -0x48(%rbp), %rsi
callq 0x32e00
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x322d8
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x18, %esi
callq 0xe6a0
jmp 0x322e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x32de0
jmp 0x322e5
leaq -0x28(%rbp), %rdi
callq 0x32e70
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xeb60
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::GeneratorsForTest::moveNext()
bool moveNext() {
            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
            for(; it != itEnd; ++it ) {
                if( (*it)->moveNext() )
                    return true;
            }
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x38, %rdi
callq 0x325e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x32610
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x32650
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32610
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32680
testb $0x1, %al
jne 0x3234f
jmp 0x3237a
leaq -0x18(%rbp), %rdi
callq 0x326c0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x32367
jmp 0x3236d
movb $0x1, -0x1(%rbp)
jmp 0x3237e
jmp 0x3236f
leaq -0x18(%rbp), %rdi
callq 0x326e0
jmp 0x3233c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::GeneratorInfo::moveNext()
bool moveNext() {
            if( ++m_currentIndex == m_size ) {
                m_currentIndex = 0;
                return false;
            }
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x10(%rcx)
cmpq 0x8(%rcx), %rax
jne 0x331d4
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x331d8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: 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>>>::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
virtual bool match( ExpressionT const& expr ) const
            {
                for( std::size_t i = 0; i < m_matchers.size(); ++i )
                    if( !m_matchers[i]->match( expr ) )
                        return false;
                return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x34ec0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x34851
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0x35490
movq %rax, %rdi
callq 0x354b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x34841
movb $0x0, -0x1(%rbp)
jmp 0x34855
jmp 0x34843
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x347f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xe8d0
movq -0x1c8(%rbp), %rdi
leaq 0x4927a(%rip), %rsi     # 0x7db2a
callq 0xe670
jmp 0x348b7
movq $0x0, -0x1a0(%rbp)
movq -0x1d0(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
addq $0x10, %rdi
callq 0x34ec0
movq %rax, %rcx
movq -0x1e8(%rbp), %rax
cmpq %rcx, %rax
jae 0x349b7
cmpq $0x0, -0x1a0(%rbp)
je 0x3492b
leaq 0x49488(%rip), %rsi     # 0x7dd8c
leaq -0x188(%rbp), %rdi
callq 0xe670
jmp 0x34912
jmp 0x3492b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x349fd
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
movq -0x1a0(%rbp), %rsi
callq 0x35490
movq %rax, %rdi
callq 0x354b0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x1c0(%rbp), %rdi
callq *%rax
jmp 0x3495f
leaq -0x188(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xe5a0
jmp 0x34974
leaq -0x1c0(%rbp), %rdi
callq 0xecd8
movq -0x1a0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1a0(%rbp)
jmp 0x348c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xecd8
jmp 0x349fd
leaq 0x4900c(%rip), %rsi     # 0x7d9ca
leaq -0x188(%rbp), %rdi
callq 0xe670
jmp 0x349cc
movq -0x1e0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xe6b0
jmp 0x349e1
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x190(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->noMatchingTestCases( spec );
    }

// 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 0x35c43
jmp 0x35c6c
leaq -0x18(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
leaq -0x18(%rbp), %rdi
callq 0x367b0
jmp 0x35c30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testRunStarting(Catch::TestRunInfo const&)
virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testRunStarting( testRunInfo );
    }

// 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 0x35ce3
jmp 0x35d0c
leaq -0x18(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
leaq -0x18(%rbp), %rdi
callq 0x367b0
jmp 0x35cd0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::testGroupStarting(Catch::GroupInfo const&)
virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->testGroupStarting( groupInfo );
    }

// 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 0x35d83
jmp 0x35dac
leaq -0x18(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
leaq -0x18(%rbp), %rdi
callq 0x367b0
jmp 0x35d70
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::MultipleReporters::assertionStarting(Catch::AssertionInfo const&)
virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE {
        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
                it != itEnd;
                ++it )
            (*it)->assertionStarting( assertionInfo );
    }

// 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 0x35f63
jmp 0x35f8c
leaq -0x18(%rbp), %rdi
callq 0x36790
movq %rax, %rdi
callq 0x19db0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
leaq -0x18(%rbp), %rdi
callq 0x367b0
jmp 0x35f50
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)