LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::testCaseStarting(Catch::TestCaseInfo const&)
virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
            StreamingReporterBase::testCaseStarting(testInfo);
            m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) );

            if ( m_config->showDurations() == ShowDurations::Always )
                m_testCaseTimer.start();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x22c86
leaq 0x2229e(%rip), %rsi     # 0x36812
leaq 0x50(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x11b1a
leaq 0x1d8(%rbx), %rdi
movq %r15, %rsi
callq 0x243dc
movq %rax, %r15
leaq 0x2197b(%rip), %rsi     # 0x35f1a
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x11b1a
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf453
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x24446
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x30(%rsp), %rdi
callq 0xc978
leaq 0x50(%rsp), %rdi
callq 0xc978
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x14606
callq 0xf370
movq %rax, 0x1d0(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x14622
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc978
jmp 0x14633
jmp 0x14630
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::sectionStarting(Catch::SectionInfo const&)
virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
            StreamingReporterBase::sectionStarting( sectionInfo );
            if( m_sectionDepth++ > 0 ) {
                m_xml.startElement( "Section" )
                    .writeAttribute( "name", trim( sectionInfo.name ) )
                    .writeAttribute( "description", sectionInfo.description );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x22cc8
movl 0x220(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x220(%r14)
testl %eax, %eax
jle 0x14735
leaq 0x2215c(%rip), %rsi     # 0x367e0
leaq 0x70(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x11b1a
addq $0x1d8, %r14            # imm = 0x1D8
movq %r14, %rdi
movq %r15, %rsi
callq 0x243dc
movq %rax, %r14
leaq 0x21868(%rip), %rsi     # 0x35f1a
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x11b1a
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xf453
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x24446
movq %rax, %r14
leaq 0x22131(%rip), %rsi     # 0x3681b
leaq 0x10(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x11b1a
addq $0x20, %rbx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x24446
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x30(%rsp), %rdi
callq 0xc978
leaq 0x50(%rsp), %rdi
callq 0xc978
leaq 0x70(%rsp), %rdi
callq 0xc978
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x14756
jmp 0x14753
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc978
jmp 0x14765
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xc978
jmp 0x14776
jmp 0x14773
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::sectionEnded(Catch::SectionStats const&)
virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
            StreamingReporterBase::sectionEnded( sectionStats );
            if( --m_sectionDepth > 0 ) {
                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
                e.writeAttribute( "successes", sectionStats.assertions.passed );
                e.writeAttribute( "failures", sectionStats.assertions.failed );
                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );

                if ( m_config->showDurations() == ShowDurations::Always )
                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );

                m_xml.endElement();
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x22f2c
movl 0x220(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x220(%r15)
cmpl $0x2, %eax
jl 0x15124
leaq 0x21882(%rip), %rsi     # 0x3687e
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
leaq 0x1d8(%r15), %r14
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0x24630
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x21858(%rip), %rsi     # 0x3688d
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
leaq 0x70(%rbx), %rdx
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x246e6
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x20f00(%rip), %rsi     # 0x35f68
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
leaq 0x78(%rbx), %rdx
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x246e6
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x217fc(%rip), %rsi     # 0x36897
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
leaq 0x80(%rbx), %rdx
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x246e6
leaq 0x10(%rsp), %rdi
callq 0xc978
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x15112
leaq 0x217c8(%rip), %rsi     # 0x368a8
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
addq $0x88, %rbx
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x2480e
leaq 0x10(%rsp), %rdi
callq 0xc978
movq %r14, %rdi
callq 0x1b20a
leaq 0x8(%rsp), %rdi
callq 0x24664
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1513a
jmp 0x1515f
jmp 0x1513a
jmp 0x1515f
jmp 0x1513a
jmp 0x1515f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x15162
jmp 0x1515f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x1516c
movq %rax, %rbx
jmp 0x1516c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x24664
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::testCaseEnded(Catch::TestCaseStats const&)
virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
            StreamingReporterBase::testCaseEnded( testCaseStats );
            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );

            if ( m_config->showDurations() == ShowDurations::Always )
                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );

            m_xml.endElement();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x90, %rdi
callq 0x22f40
leaq 0x21724(%rip), %rsi     # 0x368ba
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x11b1a
leaq 0x1d8(%r14), %rbx
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0x24630
leaq 0x20(%rsp), %rdi
callq 0xc978
leaq 0x20c46(%rip), %rsi     # 0x35e15
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x11b1a
xorl %edx, %edx
cmpq $0x0, 0x120(%r15)
sete %dl
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2467c
leaq 0x20(%rsp), %rdi
callq 0xc978
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x1525a
leaq 0x2168e(%rip), %rsi     # 0x368a8
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x11b1a
addq $0x1d0, %r14            # imm = 0x1D0
movq %r14, %rdi
callq 0xf3b4
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2480e
leaq 0x20(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0x1b20a
leaq 0x10(%rsp), %rdi
callq 0x24664
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1527a
jmp 0x1529f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc978
jmp 0x152a2
jmp 0x1529f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc978
jmp 0x152ac
movq %rax, %rbx
jmp 0x152ac
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x24664
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::testGroupEnded(Catch::TestGroupStats const&)
virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
            StreamingReporterBase::testGroupEnded( testGroupStats );
            // TODO: Check testGroupStats.aborting and act accordingly.
            m_xml.scopedElement( "OverallResults" )
                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
            m_xml.endElement();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x50, %rdi
callq 0x22f52
addq $0x1d8, %rbx            # imm = 0x1D8
leaq 0x215a1(%rip), %rsi     # 0x3687e
leaq 0x70(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x11b1a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x24630
leaq 0x21587(%rip), %rsi     # 0x3688d
leaq 0x50(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x11b1a
leaq 0x38(%r14), %rdx
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x246e6
leaq 0x20c39(%rip), %rsi     # 0x35f68
leaq 0x30(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x11b1a
leaq 0x40(%r14), %rdx
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x246e6
leaq 0x2153f(%rip), %rsi     # 0x36897
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x11b1a
addq $0x48, %r14
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x246e6
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x30(%rsp), %rdi
callq 0xc978
leaq 0x50(%rsp), %rdi
callq 0xc978
leaq 0x8(%rsp), %rdi
callq 0x24664
leaq 0x70(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0x1b20a
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x153d8
jmp 0x153d5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc978
jmp 0x153e9
jmp 0x153e6
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xc978
leaq 0x8(%rsp), %rdi
callq 0x24664
leaq 0x70(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
movq %rax, %rbx
jmp 0x153f3
movq %rax, %rbx
jmp 0x153fd
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
            StreamingReporterBase::testRunEnded( testRunStats );
            m_xml.scopedElement( "OverallResults" )
                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
            m_xml.endElement();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x13f18
addq $0x1d8, %rbx            # imm = 0x1D8
leaq 0x2143f(%rip), %rsi     # 0x3687e
leaq 0x70(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x11b1a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x24630
leaq 0x21425(%rip), %rsi     # 0x3688d
leaq 0x50(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x11b1a
leaq 0x28(%r14), %rdx
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x246e6
leaq 0x20ad7(%rip), %rsi     # 0x35f68
leaq 0x30(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x11b1a
leaq 0x30(%r14), %rdx
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x246e6
leaq 0x213dd(%rip), %rsi     # 0x36897
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x11b1a
addq $0x38, %r14
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x246e6
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x30(%rsp), %rdi
callq 0xc978
leaq 0x50(%rsp), %rdi
callq 0xc978
leaq 0x8(%rsp), %rdi
callq 0x24664
leaq 0x70(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0x1b20a
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x1553a
jmp 0x15537
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc978
jmp 0x1554b
jmp 0x15548
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xc978
leaq 0x8(%rsp), %rdi
callq 0x24664
leaq 0x70(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
movq %rax, %rbx
jmp 0x15555
movq %rax, %rbx
jmp 0x1555f
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::JunitReporter::testGroupStarting(Catch::GroupInfo const&)
virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
            suiteTimer.start();
            stdOutForSuite.str("");
            stdErrForSuite.str("");
            unexpectedExceptions = 0;
            CumulativeReporterBase::testGroupStarting( groupInfo );
        }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xf370
movq %rax, 0x110(%rbx)
leaq 0x213fd(%rip), %rsi     # 0x369f2
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x11b1a
leaq 0x120(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc6e0
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x213cc(%rip), %rsi     # 0x369f2
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x11b1a
leaq 0x298(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc6e0
leaq 0x10(%rsp), %rdi
callq 0xc978
andl $0x0, 0x408(%rbx)
addq $0x30, %rsp
popq %rbx
retq
jmp 0x15661
jmp 0x15670
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x15673
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::assertionEnded(Catch::AssertionStats const&)
virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE {
            AssertionResult const& result = _assertionStats.assertionResult;

            bool printInfoMessages = true;

            // Drop out if result was successful and we're not printing those
            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
                if( result.getResultType() != ResultWas::Warning )
                    return false;
                printInfoMessages = false;
            }

            lazyPrint();

            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
            printer.print();
            stream << std::endl;
            return true;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x157b5
movl 0xb8(%r14), %eax
testb $0x10, %al
je 0x157ae
movl 0x70(%r14), %ecx
andl $0x8, %ecx
je 0x157b5
xorl %ebp, %ebp
cmpl $0x2, %eax
jne 0x157f3
movq %rbx, %rdi
callq 0x2572c
movq 0x18(%rbx), %rsi
movzbl %bpl, %ecx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2576a
movq %r15, %rdi
callq 0x25a4a
movq 0x18(%rbx), %rdi
callq 0xc220
leaq 0x8(%rsp), %rdi
callq 0x25ac4
movb $0x1, %bpl
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25ac4
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::sectionEnded(Catch::SectionStats const&)
virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE {
            if( _sectionStats.missingAssertions ) {
                lazyPrint();
                Colour colour( Colour::ResultError );
                if( m_sectionStack.size() > 1 )
                    stream << "\nNo assertions in section";
                else
                    stream << "\nNo assertions in test case";
                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
            }
            if( m_headerPrinted ) {
                if( m_config->showDurations() == ShowDurations::Always )
                    stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
                m_headerPrinted = false;
            }
            else {
                if( m_config->showDurations() == ShowDurations::Always )
                    stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
            }
            StreamingReporterBase::sectionEnded( _sectionStats );
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x90(%rsi)
jne 0x158ba
movq %rbx, %rdi
callq 0x2572c
movb $0x0, 0xf(%rsp)
pushq $0x12
popq %rdi
callq 0xe4b0
movq 0x18(%rbx), %rdi
movq 0x1b8(%rbx), %rax
subq 0x1b0(%rbx), %rax
pushq $0x68
popq %rcx
cqto
idivq %rcx
cmpq $0x2, %rax
leaq 0x212e7(%rip), %rax     # 0x36b54
leaq 0x212fa(%rip), %rsi     # 0x36b6e
cmovaeq %rax, %rsi
callq 0xc4d0
movq 0x18(%rbx), %rdi
leaq 0x209a9(%rip), %rsi     # 0x36231
callq 0xc4d0
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0xc430
leaq 0x212ea(%rip), %rsi     # 0x36b8a
movq %rax, %rdi
callq 0xc4d0
movq %rax, %rdi
callq 0xc220
leaq 0xf(%rsp), %rdi
callq 0xe5a2
movb 0x1c9(%rbx), %bpl
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpb $0x1, %bpl
jne 0x15917
cmpl $0x1, %eax
jne 0x1590e
movq 0x18(%rbx), %rdi
leaq 0x212ac(%rip), %rsi     # 0x36b8d
callq 0xc4d0
movsd 0x88(%r14), %xmm0
movq %rax, %rdi
callq 0xc750
leaq 0x20513(%rip), %rsi     # 0x35e11
movq %rax, %rdi
callq 0xc4d0
movq %rax, %rdi
callq 0xc220
movb $0x0, 0x1c9(%rbx)
jmp 0x15960
cmpl $0x1, %eax
jne 0x15960
movq 0x18(%rbx), %rdi
leaq 0x8(%r14), %rsi
callq 0xc430
leaq 0x2126b(%rip), %rsi     # 0x36b9b
movq %rax, %rdi
callq 0xc4d0
movsd 0x88(%r14), %xmm0
movq %rax, %rdi
callq 0xc750
leaq 0x204c1(%rip), %rsi     # 0x35e11
movq %rax, %rdi
callq 0xc4d0
movq %rax, %rdi
callq 0xc220
addq $0x1b0, %rbx            # imm = 0x1B0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x22f2c
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xe5a2
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::testGroupEnded(Catch::TestGroupStats const&)
virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE {
            if( currentGroupInfo.used ) {
                printSummaryDivider();
                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
                printTotals( _testGroupStats.totals );
                stream << "\n" << std::endl;
            }
            StreamingReporterBase::testGroupEnded( _testGroupStats );
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x88(%rdi)
jne 0x15a13
movq %rsi, %r14
movq %rbx, %rdi
callq 0x263be
movq 0x18(%rbx), %rdi
leaq 0x211de(%rip), %rsi     # 0x36baa
callq 0xc4d0
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0xc430
leaq 0x211da(%rip), %rsi     # 0x36bbe
movq %rax, %rdi
callq 0xc4d0
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2641a
movq 0x18(%rbx), %rdi
leaq 0x20feb(%rip), %rsi     # 0x369f1
callq 0xc4d0
movq %rax, %rdi
callq 0xc220
addq $0x50, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22f52
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE {
            printTotalsDivider( _testRunStats.totals );
            printTotals( _testRunStats.totals );
            stream << std::endl;
            StreamingReporterBase::testRunEnded( _testRunStats );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %r15
movq %r15, %rsi
callq 0x26f52
movq %r14, %rdi
movq %r15, %rsi
callq 0x2641a
movq 0x18(%r14), %rdi
callq 0xc220
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13f18
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::RunContext::assertionEnded(Catch::AssertionResult const&)
virtual void assertionEnded( AssertionResult const& result ) {
            if( result.getResultType() == ResultWas::Ok ) {
                m_totals.assertions.passed++;
            }
            else if( !result.isOk() ) {
                m_totals.assertions.failed++;
            }

            if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) )
                m_messages.clear();

            // Reset working state
            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
            m_lastResult = result;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %rbx
movq %rdi, %r14
movl 0xb0(%rsi), %eax
testl %eax, %eax
je 0x15d5c
testb $0x10, %al
je 0x15d65
movl 0x68(%rbx), %ecx
movl $0x118, %eax            # imm = 0x118
andl $0x8, %ecx
je 0x15d61
jmp 0x15d65
movl $0x110, %eax            # imm = 0x110
incq (%r14,%rax)
movq 0x140(%r14), %r12
leaq 0x148(%r14), %r15
leaq 0x110(%r14), %rcx
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x16504
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x58(%rax)
movl %eax, %ebp
leaq 0x50(%rsp), %rdi
callq 0x113b6
testb %bpl, %bpl
je 0x15db3
movq %r15, %rdi
callq 0x166ae
leaq 0x20c38(%rip), %rsi     # 0x369f2
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x11b1a
leaq 0x1fdb4(%rip), %rsi     # 0x35b84
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x11b1a
leaq 0x180(%r14), %rdx
movl 0x1c8(%r14), %r8d
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
callq 0xe620
leaq 0x160(%r14), %rdi
leaq 0x50(%rsp), %r15
movq %r15, %rsi
callq 0x166b6
movq %r15, %rdi
callq 0x126a4
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x30(%rsp), %rdi
callq 0xc978
addq $0x50, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x166f2
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x15e64
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc978
jmp 0x15e82
movq %rax, %rbx
jmp 0x15e82
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x113b6
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xc640
movq %r12, %rdi
movq %r15, %rsi
callq 0xc430
leaq 0x1fc5d(%rip), %rsi     # 0x35b20
movq %rax, %rdi
callq 0xc4d0
leaq 0x40(%r15), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xdb57
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xc720
leaq 0x200(%r14), %rdi
movq %rsp, %rsi
callq 0x16c56
movq %rax, %r13
movq %rsp, %rdi
callq 0xc978
movq (%r13), %rax
movq %r13, %rdi
callq *0x38(%rax)
movl %eax, %ebp
testb %al, %al
je 0x15f58
leaq 0x1e8(%r14), %rdi
movq %rsp, %rsi
movq %r13, (%rsi)
callq 0x16db8
leaq 0x180(%r14), %rdi
movq %r12, %rsi
callq 0x16c34
movq 0x140(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x48(%rax)
movq 0x120(%r14), %rax
movq %rax, 0x10(%rbx)
movups 0x110(%r14), %xmm0
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
callq 0xc0e0
movl %ebp, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15f89
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc978
jmp 0x15f8c
jmp 0x15f89
jmp 0x15f89
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc0e0
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movdqu 0x110(%rdi), %xmm0
movdqu 0x68(%rsi), %xmm1
psubq %xmm1, %xmm0
movq %rsp, %rsi
movdqa %xmm0, (%rsi)
movq 0x120(%rdi), %rax
subq 0x78(%r14), %rax
movq %rax, 0x10(%rsi)
callq 0x16f34
movl %eax, %ebp
movq 0x1f0(%rbx), %rax
cmpq %rax, 0x1e8(%rbx)
je 0x16003
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
addq $-0x8, 0x1f0(%rbx)
movq 0x140(%rbx), %r15
movsd 0x80(%r14), %xmm0
movzbl %bpl, %ecx
leaq 0x18(%rsp), %r12
movq %rsp, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x16f8a
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x60(%rax)
leaq 0x18(%rsp), %rdi
callq 0x113f6
addq $0x148, %rbx            # imm = 0x148
movq %rbx, %rdi
callq 0x166ae
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x113f6
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::AssertionStats::AssertionStats(Catch::AssertionResult const&, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> const&, Catch::Totals const&)
AssertionStats( AssertionResult const& _assertionResult,
                        std::vector<MessageInfo> const& _infoMessages,
                        Totals const& _totals )
        :   assertionResult( _assertionResult ),
            infoMessages( _infoMessages ),
            totals( _totals )
        {
            if( assertionResult.hasMessage() ) {
                // Copy message into messages list.
                // !TBD This should have been done earlier, somewhere
                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
                builder << assertionResult.getMessage();
                builder.m_info.message = builder.m_stream.str();

                infoMessages.push_back( builder.m_info );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
leaq 0x3b45c(%rip), %rax     # 0x51980
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x1671c
leaq 0xc0(%r15), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x16756
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0xf8(%r15)
movups %xmm1, 0xe8(%r15)
movups %xmm0, 0xd8(%r15)
cmpq $0x0, 0xa0(%r15)
je 0x1663c
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xc650
leaq 0x28(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0xf68e
movl 0xb8(%r15), %ecx
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x167b0
leaq 0x8(%rsp), %rdi
callq 0xc978
leaq 0x30(%rsp), %rdi
callq 0xc978
addq $0x98, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xc650
leaq 0xc8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc430
leaq 0x8(%rsp), %rdi
callq 0xc978
leaq 0xd0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc720
leaq 0xa0(%rsp), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0xc5d0
movq %r15, %rdi
callq 0xc978
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x167e0
leaq 0x50(%rsp), %rdi
callq 0x1680c
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x16660
jmp 0x16660
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xc978
jmp 0x16663
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x1680c
jmp 0x16690
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xc978
jmp 0x16681
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0xc978
jmp 0x16690
movq %rax, %r15
movq %r14, %rdi
callq 0x130ec
movq %rbx, %rdi
callq 0xe6fc
movq %r15, %rdi
callq 0xc840
movq %rax, %r15
jmp 0x16698
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x16cb5
leaq 0x3b603(%rip), %rsi     # 0x52280
leaq 0x3b6bc(%rip), %rdx     # 0x52340
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xc560
movq %rax, %r14
testq %rax, %rax
jne 0x16cf5
leaq 0x1fec9(%rip), %rdi     # 0x36b66
leaq 0x1ed5a(%rip), %rsi     # 0x359fe
leaq 0x1ef20(%rip), %rcx     # 0x35bcb
movl $0x15ea, %edx           # imm = 0x15EA
callq 0xc310
pushq $0x60
popq %rdi
callq 0xc4e0
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x16d42
movq %rsp, %r12
movq %r14, (%r12)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x68(%rax)
movq %rsp, %rdi
callq 0x1644e
cmpl $0x2, 0x10(%rbx)
je 0x16d10
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x16d10
movq %r14, %rdi
callq 0x16d58
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1644e
jmp 0x16d3a
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r14, %rdi
callq 0xc500
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl $0x1, 0x58(%rdi)
movq 0x30(%rdi), %rax
movq %rdi, 0x8(%rax)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x16d76
movq (%rdi), %rax
jmpq *0x78(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
leaq 0x180(%rsi), %rdx
movq 0x160(%rsi), %rax
movq 0x1a8(%rsi), %rcx
movl 0x1c8(%rsi), %r8d
leaq 0x1f52f(%rip), %r9      # 0x369f2
movq %rax, %rsi
callq 0x102b4
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1d0(%rdi), %rbx
movq 0x1d0(%rdi), %r12
movq 0x1d8(%rdi), %r15
cmpq %r12, %r15
je 0x1750a
addq $-0x88, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rax)
jmp 0x174f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17616
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestSpecParser::visitChar(char)
void visitChar( char c ) {
            if( m_mode == None ) {
                switch( c ) {
                case ' ': return;
                case '~': m_exclusion = true; return;
                case '[': return startNewMode( Tag, ++m_pos );
                case '"': return startNewMode( QuotedName, ++m_pos );
                default: startNewMode( Name, m_pos ); break;
                }
            }
            if( m_mode == Name ) {
                if( c == ',' ) {
                    addPattern<TestSpec::NamePattern>();
                    addFilter();
                }
                else if( c == '[' ) {
                    if( subString() == "exclude:" )
                        m_exclusion = true;
                    else
                        addPattern<TestSpec::NamePattern>();
                    startNewMode( Tag, ++m_pos );
                }
            }
            else if( m_mode == QuotedName && c == '"' )
                addPattern<TestSpec::NamePattern>();
            else if( m_mode == Tag && c == ']' )
                addPattern<TestSpec::TagPattern>();
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl (%rdi), %ecx
movsbl %sil, %eax
cmpl $0x1, %ecx
je 0x17a3a
testl %ecx, %ecx
jne 0x179d3
cmpl $0x20, %eax
je 0x17aab
cmpl $0x22, %eax
je 0x17a19
cmpl $0x5b, %eax
je 0x17a96
cmpl $0x7e, %eax
jne 0x17a2c
movb $0x1, 0x4(%rbx)
jmp 0x17aab
cmpl $0x2, %ecx
setne %al
cmpb $0x22, %sil
setne %dl
orb %al, %dl
jne 0x179f4
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x17ab4
cmpl $0x3, %ecx
setne %al
cmpb $0x5d, %sil
setne %cl
orb %al, %cl
jne 0x17aab
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x17c84
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl $0x2, (%rbx)
jmp 0x17aa7
movq 0x10(%rbx), %rcx
movl $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
cmpl $0x5b, %eax
je 0x17a5c
cmpl $0x2c, %eax
jne 0x17aab
movq %rbx, %rdi
callq 0x17ab4
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x17c18
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17c64
leaq 0x1e1c9(%rip), %rsi     # 0x35c3a
movq %r14, %rdi
callq 0x12e35
movl %eax, %ebp
movq %r14, %rdi
callq 0xc978
testb %bpl, %bpl
je 0x17a8e
movb $0x1, 0x4(%rbx)
jmp 0x17a96
movq %rbx, %rdi
callq 0x17ab4
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x17c64
leaq 0x1e167(%rip), %rsi     # 0x35c3a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x11b1a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe8e2
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0xc978
testb %bpl, %bpl
je 0x17b35
movb $0x1, 0x4(%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
pushq $0x8
popq %rdx
pushq $-0x1
popq %rcx
callq 0xc520
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0xc5d0
movq %r14, %rdi
callq 0xc978
cmpq $0x0, 0x38(%rsp)
je 0x17ba6
pushq $0x40
popq %rdi
callq 0xc4e0
movq %rax, %r14
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x182b4
movq %r14, 0x10(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpb $0x1, 0x4(%rbx)
jne 0x17b8e
pushq $0x18
popq %rdi
callq 0xc4e0
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x18042
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x18066
leaq 0x38(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1809a
leaq 0x10(%rsp), %rdi
callq 0x13258
movb $0x0, 0x4(%rbx)
andl $0x0, (%rbx)
leaq 0x30(%rsp), %rdi
callq 0xc978
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0xc500
jmp 0x17bf6
jmp 0x17c02
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0xc500
jmp 0x17c05
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x17c05
jmp 0x17c02
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13258
jmp 0x17c05
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::WildcardPattern::WildcardPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice)
WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity )
        :   m_caseSensitivity( caseSensitivity ),
            m_wildcard( NoWildcard ),
            m_pattern( adjustCase( pattern ) )
        {
            if( startsWith( m_pattern, "*" ) ) {
                m_pattern = m_pattern.substr( 1 );
                m_wildcard = WildcardAtStart;
            }
            if( endsWith( m_pattern, "*" ) ) {
                m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
                m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %r14
leaq 0x399cf(%rip), %rcx     # 0x51cf8
movq %rcx, (%rdi)
movl %edx, 0x8(%rdi)
andl $0x0, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x18448
leaq 0x1e7f5(%rip), %rsi     # 0x36b41
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe8e2
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xc978
testb %bpl, %bpl
je 0x183ac
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rsi
callq 0xc520
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc5d0
movq %r15, %rdi
callq 0xc978
movl $0x1, 0xc(%r14)
leaq 0x1e78e(%rip), %rsi     # 0x36b41
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf3cb
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xc978
testb %bpl, %bpl
je 0x18413
movq 0x18(%r14), %rcx
decq %rcx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc520
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc5d0
movq %r15, %rdi
callq 0xc978
orb $0x2, 0xc(%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18435
jmp 0x18435
jmp 0x18426
jmp 0x18435
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc978
jmp 0x18438
movq %rax, %r14
movq %rbx, %rdi
callq 0xc978
movq %r14, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0xc4e0
movq %rax, %rbx
leaq 0x1d742(%rip), %rsi     # 0x35c43
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x11b1a
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x16d42
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1894a
leaq 0x10(%rsp), %rdi
callq 0xc978
andq $0x0, 0x8(%r14)
movl $0x1, 0x10(%r14)
movq (%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x1856c
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xc978
testb %bpl, %bpl
je 0x18577
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0xc500
movq %r14, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x18bea
xorl %eax, %eax
cmpq $0x0, 0x10(%rbx)
setne %al
shll $0x4, %eax
addq $0x18, %rax
cmpq $0x0, 0x8(%rbx)
pushq $0x20
popq %rcx
cmoveq %rax, %rcx
incq (%rbx,%rcx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movdqu (%rsi), %xmm0
movdqu (%rdi), %xmm1
paddq %xmm0, %xmm1
movdqu %xmm1, (%rdi)
movq 0x10(%rsi), %rcx
addq %rcx, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x1, (%rdi)
jne 0x18b08
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x3b9e7(%rip), %r15     # 0x544d0
cmpq $0x60, %r14
je 0x18b00
movl (%r14,%r15), %edi
xorl %esi, %esi
callq 0xc5a0
addq $0x10, %r14
jmp 0x18ae9
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebp
movl %edi, %ebx
negl %ebx
pushq $0x8
popq %r12
leaq 0x3b9a7(%rip), %r13     # 0x544d0
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
cmpq $0x68, %r12
je 0x18b67
cmpl %ebp, -0x8(%r12,%r13)
jne 0x18b61
movq (%r12,%r13), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x11b1a
movq %r14, %rdi
movl %ebx, %esi
callq 0x18bc0
movq %r14, %rdi
callq 0xc978
addq $0x10, %r12
jmp 0x18b33
leaq 0x1d0e6(%rip), %rsi     # 0x35c54
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x11b1a
leaq 0x8(%rsp), %rdi
movl %ebx, %esi
callq 0x18bc0
leaq 0x8(%rsp), %rdi
callq 0xc978
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18bab
jmp 0x18ba6
movq %rax, %rbx
jmp 0x18bb8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0xe453
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x50(%rcx)
movl %ebx, %edi
callq 0xc5c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movdqu (%rsi), %xmm0
movdqu (%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, (%rdi)
movdqu 0x10(%rsi), %xmm0
movdqu 0x10(%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x10(%rdi)
movdqu 0x20(%rsi), %xmm0
movdqu 0x20(%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %r14
movq %rcx, %r15
cmpq %r14, %rcx
je 0x18f5f
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
leaq 0x8(%r15), %rcx
testb %al, %al
jne 0x18f43
cmpq %r14, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop