LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::close()
virtual void close() CATCH_OVERRIDE {

            // Close any still open children (e.g. generators)
            while( &m_ctx.currentTracker() != this )
                m_ctx.currentTracker().close();

            switch( m_runState ) {
                case NotStarted:
                case CompletedSuccessfully:
                case Failed:
                    throw std::logic_error( "Illogical state" );

                case NeedsAnotherRun:
                    break;;

                case Executing:
                    m_runState = CompletedSuccessfully;
                    break;
                case ExecutingChildren:
                    if( m_children.empty() || m_children.back()->isComplete() )
                        m_runState = CompletedSuccessfully;
                    break;

                default:
                    throw std::logic_error( "Unexpected state" );
            }
            moveToParent();
            m_ctx.completeCycle();
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rdi
cmpq %rbx, %rdi
je 0x17dd4
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x30(%rbx), %rax
jmp 0x17dbf
movl 0x58(%rbx), %eax
cmpq $0x5, %rax
ja 0x17e6d
leaq 0x2e288(%rip), %rcx     # 0x46070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x48(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x17e09
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x17e10
movl $0x4, 0x58(%rbx)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x17e4e
movq 0x30(%rbx), %rcx
movq %rax, 0x8(%rcx)
movl $0x2, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xc1f0
movq %rax, %rbx
leaq 0x2f7ec(%rip), %rsi     # 0x47630
movq %rax, %rdi
callq 0xc640
jmp 0x17e89
leaq 0x2f791(%rip), %rdi     # 0x475e6
leaq 0x2eb96(%rip), %rsi     # 0x469f2
leaq 0x2f7ee(%rip), %rcx     # 0x47651
movl $0x15d5, %edx           # imm = 0x15D5
callq 0xc2d0
movl $0x10, %edi
callq 0xc1f0
movq %rax, %rbx
leaq 0x2f7bf(%rip), %rsi     # 0x47640
movq %rax, %rdi
callq 0xc640
movq 0x4a138(%rip), %rsi     # 0x61fc8
movq 0x4a101(%rip), %rdx     # 0x61f98
movq %rbx, %rdi
callq 0xc7d0
jmp 0x17ea1
movq %rax, %r14
movq %rbx, %rdi
callq 0xc360
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::fail()
virtual void fail() CATCH_OVERRIDE {
            m_runState = Failed;
            if( m_parent )
                m_parent->markAsNeedingAnotherRun();
            moveToParent();
            m_ctx.completeCycle();
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x5, 0x58(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x17ece
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x17ee8
movq 0x30(%rbx), %rcx
movq %rax, 0x8(%rcx)
movl $0x2, 0x10(%rcx)
popq %rbx
retq
leaq 0x2f6f7(%rip), %rdi     # 0x475e6
leaq 0x2eafc(%rip), %rsi     # 0x469f2
leaq 0x2f754(%rip), %rcx     # 0x47651
movl $0x15d5, %edx           # imm = 0x15D5
callq 0xc2d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::findChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual ITracker* findChild( std::string const& name ) CATCH_OVERRIDE {
            Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( name ) );
            return( it != m_children.end() )
                ? it->get()
                : CATCH_NULL;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x32cee
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2a942
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x17f7a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
cmpq 0x48(%rbx), %r14
je 0x17f85
movq (%r14), %rax
jmp 0x17f87
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x17fae
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::openChild()
virtual void openChild() CATCH_OVERRIDE {
            if( m_runState != ExecutingChildren ) {
                m_runState = ExecutingChildren;
                if( m_parent )
                    m_parent->openChild();
            }
        }

// Assembly:
cmpl $0x2, 0x58(%rdi)
je 0x17fd2
movl $0x2, 0x58(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x17fd2
movq (%rdi), %rax
jmpq *0x78(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestRegistry::getAllTestsSorted(Catch::IConfig const&) const
virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const {
            if( m_sortedFunctions.empty() )
                enforceNoDuplicateTestCases( m_functions );

            if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
                m_sortedFunctions = sortTests( config, m_functions );
                m_currentSortOrder = config.runOrder();
            }
            return m_sortedFunctions;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x18021
leaq 0x8(%rbx), %rdi
callq 0xe25a
movl 0x20(%rbx), %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
cmpl %eax, %ebp
jne 0x1803f
movq 0x28(%rbx), %rax
cmpq 0x30(%rbx), %rax
jne 0x18135
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2ac10
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
cmpl $0x1, %eax
je 0x1807e
cmpl $0x2, %eax
jne 0x180c8
movq %r14, %rdi
callq 0x110ba
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x2acab
jmp 0x180c8
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r12
cmpq %r12, %r15
je 0x180c8
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
movabsq $-0x5075075075075075, %rcx # imm = 0xAF8AF8AF8AF8AF8B
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ae77
movq %r15, %rdi
movq %r12, %rsi
callq 0x2af67
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x28(%rbx), %rax
movups 0x30(%rbx), %xmm0
leaq 0x8(%rsp), %r15
movq (%r15), %rcx
movq %rcx, 0x28(%rbx)
movq 0x8(%r15), %rcx
movq %rcx, 0x30(%rbx)
movq 0x10(%r15), %rcx
movq %rcx, 0x38(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r15)
movq %rdx, 0x8(%r15)
movq %rsi, 0x10(%r15)
callq 0x15b86
movq %r15, %rdi
callq 0x15b86
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
movl %eax, 0x20(%rbx)
addq $0x28, %rbx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1814b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x15b86
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestRegistry::registerTest(Catch::TestCase const&)
virtual void registerTest( TestCase const& testCase ) {
            std::string name = testCase.getTestCaseInfo().name;
            if( name == "" ) {
                std::ostringstream oss;
                oss << "Anonymous test case " << ++m_unnamedCount;
                return registerTest( testCase.withName( oss.str() ) );
            }
            m_functions.push_back( testCase );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x32cee
leaq 0x2f845(%rip), %rsi     # 0x479e1
movq %r15, %rdi
callq 0xc100
testl %eax, %eax
je 0x181bc
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15b56
jmp 0x1827f
leaq 0x48(%rsp), %rdi
callq 0xc5f0
leaq 0x2f4be(%rip), %rsi     # 0x4768b
leaq 0x48(%rsp), %rdi
movl $0x14, %edx
callq 0xc530
movq 0x40(%rbx), %rsi
incq %rsi
movq %rsi, 0x40(%rbx)
leaq 0x48(%rsp), %rdi
callq 0xc300
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc6f0
leaq 0x1c0(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0xfeca
movq (%rbx), %rax
leaq 0x1c0(%rsp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x2d0(%rsp), %rdi
testq %rdi, %rdi
je 0x18239
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x1c0(%rsp), %rdi
callq 0x16074
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18261
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x49d20(%rip), %rsi     # 0x61f88
leaq 0x48(%rsp), %rdi
callq 0xc220
leaq 0xb8(%rsp), %rdi
callq 0xc120
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x18296
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x15d1b
movq %rax, %rbx
leaq 0x1c0(%rsp), %rdi
callq 0x15cf4
jmp 0x182c2
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x182eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x182eb
jmp 0x182e8
jmp 0x182e3
movq %rax, %rbx
jmp 0x18309
movq %rax, %rbx
movq 0x49c96(%rip), %rsi     # 0x61f88
leaq 0x48(%rsp), %rdi
callq 0xc220
leaq 0xb8(%rsp), %rdi
callq 0xc120
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x18320
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CumulativeReporterBase::assertionEnded(Catch::AssertionStats const&)
virtual bool assertionEnded( AssertionStats const& assertionStats ) {
            assert( !m_sectionStack.empty() );
            SectionNode& sectionNode = *m_sectionStack.back();
            sectionNode.assertions.push_back( assertionStats );
            return true;
        }

// Assembly:
pushq %rax
movq 0xb0(%rdi), %rax
cmpq %rax, 0xa8(%rdi)
je 0x18767
movl $0xc0, %edi
addq -0x8(%rax), %rdi
callq 0x2c4aa
movb $0x1, %al
popq %rcx
retq
leaq 0x2ef32(%rip), %rdi     # 0x476a0
leaq 0x2e27d(%rip), %rsi     # 0x469f2
leaq 0x2ef3c(%rip), %rcx     # 0x476b8
movl $0x2193, %edx           # imm = 0x2193
callq 0xc2d0
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CumulativeReporterBase::testCaseEnded(Catch::TestCaseStats const&)
virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
            Ptr<TestCaseNode> node = new TestCaseNode( testCaseStats );
            assert( m_sectionStack.size() == 0 );
            node->children.push_back( m_rootSection );
            m_testCases.push_back( node );
            m_rootSection.reset();

            assert( m_deepestSection );
            m_deepestSection->stdOut = testCaseStats.stdOut;
            m_deepestSection->stdErr = testCaseStats.stdErr;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1b8, %edi            # imm = 0x1B8
callq 0xc480
movq %rax, %r15
movl $0x0, 0x8(%rax)
leaq 0x48df0(%rip), %rax     # 0x615f0
movq %rax, (%r15)
leaq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x2ca12
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%r15)
movq $0x0, 0x1b0(%r15)
movq %r15, 0x8(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0xb0(%r14), %rax
cmpq 0xa8(%r14), %rax
jne 0x188db
movl $0x1a0, %edi            # imm = 0x1A0
addq 0x8(%rsp), %rdi
leaq 0x98(%r14), %r15
movq %r15, %rsi
callq 0x2bff8
leaq 0x50(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2c9e0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1887c
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x98(%r14)
movq 0xa0(%r14), %rdi
testq %rdi, %rdi
je 0x188fa
leaq 0x148(%rbx), %rsi
addq $0xd8, %rdi
callq 0xc230
addq $0x168, %rbx            # imm = 0x168
movl $0xf8, %edi
addq 0xa0(%r14), %rdi
movq %rbx, %rsi
callq 0xc230
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x188d1
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2ee78(%rip), %rdi     # 0x4775a
leaq 0x2e109(%rip), %rsi     # 0x469f2
leaq 0x2ee85(%rip), %rcx     # 0x47775
movl $0x21a0, %edx           # imm = 0x21A0
callq 0xc2d0
leaq 0x2eec5(%rip), %rdi     # 0x477c6
leaq 0x2e0ea(%rip), %rsi     # 0x469f2
leaq 0x2ee66(%rip), %rcx     # 0x47775
movl $0x21a5, %edx           # imm = 0x21A5
callq 0xc2d0
jmp 0x18948
movq %rax, %rbx
movl $0x1b8, %esi            # imm = 0x1B8
movq %r15, %rdi
callq 0xc4a0
jmp 0x18940
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18940
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xc820
movq %rax, %rdi
callq 0x15d1b
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CumulativeReporterBase::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
            node->children.swap( m_testGroups );
            m_testRuns.push_back( node );
            testRunEndedCumulative();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x88, %edi
callq 0xc480
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x48bc0(%rip), %rax     # 0x61680
movq %rax, (%r14)
leaq 0x46d16(%rip), %rax     # 0x5f7e0
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
callq 0x32cee
movb 0x58(%r15), %al
movb %al, 0x68(%r14)
movups 0x28(%r15), %xmm0
movups 0x38(%r15), %xmm1
movups 0x48(%r15), %xmm2
movups %xmm2, 0x58(%r14)
movups %xmm1, 0x48(%r14)
movups %xmm0, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
movq $0x0, 0x80(%r14)
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movups 0x70(%rax), %xmm0
movq 0x80(%rax), %rcx
movq 0x68(%rbx), %rdx
movq %rdx, 0x70(%rax)
movq 0x70(%rbx), %rdx
movq %rdx, 0x78(%rax)
movq 0x78(%rbx), %rdx
movq %rdx, 0x80(%rax)
movups %xmm0, 0x68(%rbx)
movq %rcx, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0x2d08e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x88(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18b90
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x18bc9
movq %rax, %rbx
movl $0x88, %esi
movq %r14, %rdi
callq 0xc4a0
jmp 0x18bc1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18bc1
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xc820
movq %rax, %rdi
callq 0x15d1b
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::testRunStarting(Catch::TestRunInfo const&)
virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_OVERRIDE {
            StreamingReporterBase::testRunStarting( testInfo );
            m_xml.setStream( stream );
            m_xml.startElement( "Catch" );
            if( !m_config->name().empty() )
                m_xml.writeAttribute( "name", m_config->name() );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x21468
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x32cee
movq %r15, 0x20(%rbx)
movb $0x0, 0x48(%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x218(%rbx)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2eba5(%rip), %rsi     # 0x477d7
leaq 0x2eba3(%rip), %rdx     # 0x477dc
leaq 0x8(%rsp), %rdi
callq 0x32d7e
leaq 0x1d8(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2d366
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x18c6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x10(%rbx), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x30(%rax)
movq (%r15), %rdi
movq 0x8(%r15), %r15
cmpq %r12, %rdi
je 0x18c99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
testq %r15, %r15
je 0x18d0c
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x2e261(%rip), %rsi     # 0x46f0e
leaq 0x2e25e(%rip), %rdx     # 0x46f12
callq 0x32d7e
movq 0x10(%rbx), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
callq *0x30(%rax)
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x2d418
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18cf5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x18d0c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18d3f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x18d3f
jmp 0x18d3c
jmp 0x18d58
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x18d5b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x18d5b
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x2bb06
movb $0x0, 0x1a8(%rbx)
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2e934(%rip), %rsi     # 0x47801
leaq 0x2e935(%rip), %rdx     # 0x47809
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x32d7e
leaq 0x1d8(%rbx), %rdi
movq %r15, %rsi
callq 0x2d366
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2e00b(%rip), %rsi     # 0x46f0e
leaq 0x2e008(%rip), %rdx     # 0x46f12
movq %rsp, %rdi
callq 0x32d7e
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x10c29
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
callq 0x2d418
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18f4a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x18f60
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x18f77
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x18fa7
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc710
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
movq %rax, 0x1d0(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18fd8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x18fd8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x18ff5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x18ff5
jmp 0x18ff2
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1900c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x2bb40
movl 0x220(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x220(%r14)
testl %eax, %eax
jle 0x1915c
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2e76f(%rip), %rsi     # 0x477cf
leaq 0x2e76f(%rip), %rdx     # 0x477d6
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x32d7e
addq $0x1d8, %r14            # imm = 0x1D8
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d366
movq %rax, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2de75(%rip), %rsi     # 0x46f0e
leaq 0x2de72(%rip), %rdx     # 0x46f12
leaq 0x20(%rsp), %rdi
callq 0x32d7e
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x10c29
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0x2d418
movq %rax, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2e72e(%rip), %rsi     # 0x4780a
leaq 0x2e732(%rip), %rdx     # 0x47815
movq %rsp, %rdi
callq 0x32d7e
addq $0x20, %rbx
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2d418
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x19113
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1912e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x19145
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x1915c
movq 0x70(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1918d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1918d
jmp 0x1918a
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x191ad
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x191ad
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x191cb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x191cb
jmp 0x191c8
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x191e2
movq 0x70(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rdi
testq %rdi, %rdi
je 0x1a1ae
callq 0x16074
movq $0x0, 0x90(%r14)
movb $0x0, 0x1a8(%r14)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2d6d7(%rip), %rsi     # 0x478a9
leaq 0x2d6dd(%rip), %rdx     # 0x478b6
leaq 0x10(%rsp), %rdi
callq 0x32d7e
leaq 0x1d8(%r14), %rbx
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d366
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a213
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x10(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x2cbe7(%rip), %rsi     # 0x46e09
leaq 0x2cbe7(%rip), %rdx     # 0x46e10
callq 0x32d7e
xorl %edx, %edx
cmpq $0x0, 0x120(%r15)
sete %dl
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2d692
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a261
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x1a2e8
leaq 0x10(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x2d618(%rip), %rsi     # 0x47897
leaq 0x2d622(%rip), %rdx     # 0x478a8
callq 0x32d7e
leaq 0x38(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xc710
imull $0xf4240, (%r15), %eax  # imm = 0xF4240
addl 0x8(%r15), %eax
subl 0x1d0(%r14), %eax
cvtsi2sd %rax, %xmm0
divsd 0x2bd4f(%rip), %xmm0    # 0x46008
leaq 0x30(%rsp), %rdx
movsd %xmm0, (%rdx)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2d8e8
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a2e8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0x21494
leaq 0x8(%rsp), %rdi
callq 0x2d67a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1a30a
jmp 0x1a353
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a356
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a356
jmp 0x1a353
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d67a
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a360
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a360
movq %rax, %rbx
jmp 0x1a360
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d67a
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x50, %rdi
callq 0x2143c
movb $0x0, 0x88(%rbx)
addq $0x1d8, %rbx            # imm = 0x1D8
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2d4c6(%rip), %rsi     # 0x4786d
leaq 0x2d4cd(%rip), %rdx     # 0x4787b
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x32d7e
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d366
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2d4a2(%rip), %rsi     # 0x4787c
leaq 0x2d4a4(%rip), %rdx     # 0x47885
leaq 0x48(%rsp), %rdi
callq 0x32d7e
leaq 0x38(%r14), %rdx
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d724
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2cb4f(%rip), %rsi     # 0x46f5c
leaq 0x2cb50(%rip), %rdx     # 0x46f64
leaq 0x28(%rsp), %rdi
callq 0x32d7e
leaq 0x40(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2d724
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2d446(%rip), %rsi     # 0x47886
leaq 0x2d44f(%rip), %rdx     # 0x47896
leaq 0x8(%rsp), %rdi
callq 0x32d7e
addq $0x48, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x2d724
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1a47d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a494
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a4ab
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rsp, %rdi
callq 0x2d67a
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a4ca
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0x21494
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1a505
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a505
jmp 0x1a502
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a523
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a523
jmp 0x1a520
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a541
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a541
jmp 0x1a53e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2d67a
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a560
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1846e
addq $0x1d8, %rbx            # imm = 0x1D8
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2d2d1(%rip), %rsi     # 0x4786d
leaq 0x2d2d8(%rip), %rdx     # 0x4787b
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x32d7e
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d366
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2d2ad(%rip), %rsi     # 0x4787c
leaq 0x2d2af(%rip), %rdx     # 0x47885
leaq 0x48(%rsp), %rdi
callq 0x32d7e
leaq 0x28(%r14), %rdx
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d724
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2c95a(%rip), %rsi     # 0x46f5c
leaq 0x2c95b(%rip), %rdx     # 0x46f64
leaq 0x28(%rsp), %rdi
callq 0x32d7e
leaq 0x30(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2d724
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2d251(%rip), %rsi     # 0x47886
leaq 0x2d25a(%rip), %rdx     # 0x47896
leaq 0x8(%rsp), %rdi
callq 0x32d7e
addq $0x38, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x2d724
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1a672
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a689
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a6a0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rsp, %rdi
callq 0x2d67a
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a6bf
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0x21494
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1a6fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a6fa
jmp 0x1a6f7
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a718
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a718
jmp 0x1a715
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a736
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a736
jmp 0x1a733
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2d67a
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a755
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc710
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
movq %rax, 0x110(%rbx)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2d1c4(%rip), %rdx     # 0x479e1
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x32d7e
leaq 0x120(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc6a0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a852
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x2d180(%rip), %rdx     # 0x479e1
movq %rdx, %rsi
callq 0x32d7e
leaq 0x298(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc6a0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a891
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movl $0x0, 0x408(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x1a8a7
jmp 0x1a8c3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a8c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1a8c6
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1aa81
movl 0xb8(%r14), %eax
testb $0x10, %al
je 0x1aa76
movl 0x70(%r14), %ecx
andl $0x8, %ecx
je 0x1aa81
xorl %ebp, %ebp
cmpl $0x2, %eax
jne 0x1ab38
movq %rbx, %rdi
callq 0x2eec8
movq 0x18(%rbx), %rsi
movzbl %bpl, %ecx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2ef06
movq %r15, %rdi
callq 0x2f362
movq 0x18(%rbx), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xc460
movsbl %al, %esi
movq %rbx, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc310
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0x16afc
movq -0x20(%rbx), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x1aaff
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ab1a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ab35
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
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 0x2f3e6
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x88(%rdi)
jne 0x1ae70
movq %rsi, %r14
movq %rbx, %rdi
callq 0x30056
movq 0x18(%rbx), %r15
leaq 0x2cda8(%rip), %rsi     # 0x47b99
movl $0x13, %edx
movq %r15, %rdi
callq 0xc530
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0xc530
leaq 0x2cd98(%rip), %rsi     # 0x47bad
movl $0x3, %edx
movq %rax, %rdi
callq 0xc530
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x300d0
movq 0x18(%rbx), %r14
leaq 0x2cba4(%rip), %rsi     # 0x479e0
movl $0x1, %edx
movq %r14, %rdi
callq 0xc530
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xc460
movsbl %al, %esi
movq %r14, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc310
leaq 0x50(%rbx), %rdi
callq 0x2143c
movb $0x0, 0x88(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31062
movq %r14, %rdi
movq %r15, %rsi
callq 0x300d0
movq 0x18(%r14), %r15
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xc460
movsbl %al, %esi
movq %r15, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc310
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1846e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc5f0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0xc530
movq %rax, %r13
leaq 0x2b624(%rip), %rsi     # 0x46b14
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x40(%r15), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xe3bb
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xc6f0
leaq 0x200(%r14), %rdi
movq %rsp, %rsi
callq 0x1c82c
movq %rax, %r13
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b546
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq (%r13), %rax
movq %r13, %rdi
callq *0x38(%rax)
movl %eax, %ebp
testb %al, %al
je 0x1b5a8
leaq 0x1e8(%r14), %rdi
movq %rsp, %rsi
movq %r13, (%rsi)
callq 0x1c98a
leaq 0x180(%r14), %rdi
movq %r12, %rsi
callq 0xc230
movq 0x60(%r15), %rax
movq %rax, 0x1a0(%r14)
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)
movq 0x469d9(%rip), %rsi     # 0x61f88
leaq 0x20(%rsp), %rdi
callq 0xc220
leaq 0x90(%rsp), %rdi
callq 0xc120
movl %ebp, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b600
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b603
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1b603
jmp 0x1b600
jmp 0x1b600
movq %rax, %rbx
movq 0x4697e(%rip), %rsi     # 0x61f88
leaq 0x20(%rsp), %rdi
callq 0xc220
leaq 0x90(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0x110(%rdi), %rax
subq 0x68(%r14), %rax
movq %rax, (%rsi)
movq 0x118(%rdi), %rax
subq 0x70(%r14), %rax
movq %rax, 0x8(%rsi)
movq 0x120(%rdi), %rax
subq 0x78(%r14), %rax
movq %rax, 0x10(%rsi)
callq 0x1caf6
movl %eax, %ebp
movq 0x1f0(%rbx), %rax
cmpq %rax, 0x1e8(%rbx)
je 0x1b6a5
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 0x1cb4c
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x60(%rax)
leaq 0x18(%rsp), %rdi
callq 0x14258
movq 0x148(%rbx), %rsi
addq $0x148, %rbx            # imm = 0x148
movq %rbx, %rdi
callq 0x1c7fc
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x14258
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1d0(%rdi), %r15
movq 0x1d0(%rdi), %rax
xorl %ecx, %ecx
cmpq 0x1d8(%rdi), %rax
movq 0x1f0(%rdi), %rax
sete %cl
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax,%rcx,8)
addq $-0x8, 0x1f0(%r14)
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1cc5c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq 0x8(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x1c88f
leaq 0x4380d(%rip), %rsi     # 0x60060
leaq 0x438c6(%rip), %rdx     # 0x60120
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xc520
movq %rax, %rbx
testq %rax, %rax
jne 0x1c908
leaq 0x2b2de(%rip), %rdi     # 0x47b55
leaq 0x2a174(%rip), %rsi     # 0x469f2
leaq 0x2a33a(%rip), %rcx     # 0x46bbf
movl $0x15ea, %edx           # imm = 0x15EA
callq 0xc2d0
movl $0x60, %edi
callq 0xc480
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x4341e(%rip), %rax     # 0x5fcc8
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x32cee
movq %r14, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4c(%rbx)
leaq 0x437bc(%rip), %rax     # 0x600a0
movq %rax, (%rbx)
movq %rsp, %rsi
movq %rbx, (%rsi)
incl 0x8(%rbx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x68(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c908
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, 0x10(%r14)
je 0x1c93a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x1c93a
movl $0x1, 0x58(%rbx)
movq 0x30(%rbx), %rax
movq %rbx, 0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1c93a
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1c95f
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c977
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1c977
movq %rax, %rdi
callq 0x15d1b
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0xc4a0
movq %r14, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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
leaq 0x1d0(%rdi), %rbx
movq 0x1d0(%rdi), %r12
movq 0x1d8(%rdi), %r15
cmpq %r12, %r15
je 0x1d2bb
movq %rdi, %r14
addq $-0x88, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rax)
cmpq %r12, %r15
jne 0x1d2a3
movq (%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d3bc
nop