LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a81e
movb $0x0, 0x1a8(%rbx)
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2d93a(%rip), %rsi     # 0x45801
leaq 0x2d93b(%rip), %rdx     # 0x45809
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x31a82
leaq 0x1d8(%rbx), %rdi
movq %r15, %rsi
callq 0x2c086
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2d011(%rip), %rsi     # 0x44f0e
leaq 0x2d00e(%rip), %rdx     # 0x44f12
movq %rsp, %rdi
callq 0x31a82
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xfc3a
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
callq 0x2c138
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17f44
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x17f5a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x17f71
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x17fa1
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xb710
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 0x17fd2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x17fd2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x17fef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x17fef
jmp 0x17fec
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x18006
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a858
movl 0x220(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x220(%r14)
testl %eax, %eax
jle 0x18156
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2d775(%rip), %rsi     # 0x457cf
leaq 0x2d775(%rip), %rdx     # 0x457d6
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x31a82
addq $0x1d8, %r14            # imm = 0x1D8
movq %r14, %rdi
movq %r15, %rsi
callq 0x2c086
movq %rax, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2ce7b(%rip), %rsi     # 0x44f0e
leaq 0x2ce78(%rip), %rdx     # 0x44f12
leaq 0x20(%rsp), %rdi
callq 0x31a82
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0xfc3a
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0x2c138
movq %rax, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2d734(%rip), %rsi     # 0x4580a
leaq 0x2d738(%rip), %rdx     # 0x45815
movq %rsp, %rdi
callq 0x31a82
addq $0x20, %rbx
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2c138
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1810d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18128
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1813f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x18156
movq 0x70(%rsp), %rsi
incq %rsi
callq 0xb4a0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x18187
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x18187
jmp 0x18184
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x181a7
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x181a7
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x181c5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x181c5
jmp 0x181c2
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x181dc
movq 0x70(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0x191a8
callq 0x15090
movq $0x0, 0x90(%r14)
movb $0x0, 0x1a8(%r14)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2c6dd(%rip), %rsi     # 0x458a9
leaq 0x2c6e3(%rip), %rdx     # 0x458b6
leaq 0x10(%rsp), %rdi
callq 0x31a82
leaq 0x1d8(%r14), %rbx
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2c086
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1920d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x10(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x2bbed(%rip), %rsi     # 0x44e09
leaq 0x2bbed(%rip), %rdx     # 0x44e10
callq 0x31a82
xorl %edx, %edx
cmpq $0x0, 0x120(%r15)
sete %dl
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2c3b4
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1925b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x192e2
leaq 0x10(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x2c61e(%rip), %rsi     # 0x45897
leaq 0x2c628(%rip), %rdx     # 0x458a8
callq 0x31a82
leaq 0x38(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xb710
imull $0xf4240, (%r15), %eax  # imm = 0xF4240
addl 0x8(%r15), %eax
subl 0x1d0(%r14), %eax
cvtsi2sd %rax, %xmm0
divsd 0x2ad55(%rip), %xmm0    # 0x44008
leaq 0x30(%rsp), %rdx
movsd %xmm0, (%rdx)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2c602
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x192e2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0x20366
leaq 0x8(%rsp), %rdi
callq 0x2c39c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x19304
jmp 0x1934d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x19350
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x19350
jmp 0x1934d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2c39c
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1935a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x1935a
movq %rax, %rbx
jmp 0x1935a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2c39c
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2030e
movb $0x0, 0x88(%rbx)
addq $0x1d8, %rbx            # imm = 0x1D8
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2c4cc(%rip), %rsi     # 0x4586d
leaq 0x2c4d3(%rip), %rdx     # 0x4587b
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x31a82
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2c086
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c4a8(%rip), %rsi     # 0x4587c
leaq 0x2c4aa(%rip), %rdx     # 0x45885
leaq 0x48(%rsp), %rdi
callq 0x31a82
leaq 0x38(%r14), %rdx
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2c446
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2bb55(%rip), %rsi     # 0x44f5c
leaq 0x2bb56(%rip), %rdx     # 0x44f64
leaq 0x28(%rsp), %rdi
callq 0x31a82
leaq 0x40(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2c446
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2c44c(%rip), %rsi     # 0x45886
leaq 0x2c455(%rip), %rdx     # 0x45896
leaq 0x8(%rsp), %rdi
callq 0x31a82
addq $0x48, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x2c446
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x19477
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1948e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x194a5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rsp, %rdi
callq 0x2c39c
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x194c4
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0x20366
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 0x194ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x194ff
jmp 0x194fc
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1951d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x1951d
jmp 0x1951a
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1953b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x1953b
jmp 0x19538
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2c39c
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x1955a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17480
addq $0x1d8, %rbx            # imm = 0x1D8
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2c2d7(%rip), %rsi     # 0x4586d
leaq 0x2c2de(%rip), %rdx     # 0x4587b
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x31a82
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2c086
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c2b3(%rip), %rsi     # 0x4587c
leaq 0x2c2b5(%rip), %rdx     # 0x45885
leaq 0x48(%rsp), %rdi
callq 0x31a82
leaq 0x28(%r14), %rdx
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2c446
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2b960(%rip), %rsi     # 0x44f5c
leaq 0x2b961(%rip), %rdx     # 0x44f64
leaq 0x28(%rsp), %rdi
callq 0x31a82
leaq 0x30(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2c446
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2c257(%rip), %rsi     # 0x45886
leaq 0x2c260(%rip), %rdx     # 0x45896
leaq 0x8(%rsp), %rdi
callq 0x31a82
addq $0x38, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x2c446
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1966c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x19683
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1969a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rsp, %rdi
callq 0x2c39c
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x196b9
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0x20366
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 0x196f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x196f4
jmp 0x196f1
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x19712
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x19712
jmp 0x1970f
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x19730
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x19730
jmp 0x1972d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2c39c
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x1974f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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 0xb710
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
movq %rax, 0x110(%rbx)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2c1ca(%rip), %rdx     # 0x459e1
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x31a82
leaq 0x120(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb6a0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1984c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x2c186(%rip), %rdx     # 0x459e1
movq %rdx, %rsi
callq 0x31a82
leaq 0x298(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb6a0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1988b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movl $0x0, 0x408(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x198a1
jmp 0x198bd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x198c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x198c0
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19a7b
movl 0xb8(%r14), %eax
testb $0x10, %al
je 0x19a70
movl 0x70(%r14), %ecx
andl $0x8, %ecx
je 0x19a7b
xorl %ebp, %ebp
cmpl $0x2, %eax
jne 0x19b32
movq %rbx, %rdi
callq 0x2dbd8
movq 0x18(%rbx), %rsi
movzbl %bpl, %ecx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2dc16
movq %r15, %rdi
callq 0x2e066
movq 0x18(%rbx), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb460
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb310
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0x15b00
movq -0x20(%rbx), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x19af9
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19b14
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19b2f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
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 0x2e0ea
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19e6a
movq %rsi, %r14
movq %rbx, %rdi
callq 0x2ed5c
movq 0x18(%rbx), %r15
leaq 0x2bdae(%rip), %rsi     # 0x45b99
movl $0x13, %edx
movq %r15, %rdi
callq 0xb530
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0xb530
leaq 0x2bd9e(%rip), %rsi     # 0x45bad
movl $0x3, %edx
movq %rax, %rdi
callq 0xb530
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2edd6
movq 0x18(%rbx), %r14
leaq 0x2bbaa(%rip), %rsi     # 0x459e0
movl $0x1, %edx
movq %r14, %rdi
callq 0xb530
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb460
movsbl %al, %esi
movq %r14, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb310
leaq 0x50(%rbx), %rdi
callq 0x2030e
movb $0x0, 0x88(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fd78
movq %r14, %rdi
movq %r15, %rsi
callq 0x2edd6
movq 0x18(%r14), %r15
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb460
movsbl %al, %esi
movq %r15, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb310
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb5f0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0xb530
movq %rax, %r13
leaq 0x2a62a(%rip), %rsi     # 0x44b14
movl $0x1, %edx
movq %rax, %rdi
callq 0xb530
leaq 0x40(%r15), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xd423
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xb6f0
leaq 0x200(%r14), %rdi
movq %rsp, %rsi
callq 0x1b810
movq %rax, %r13
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a540
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq (%r13), %rax
movq %r13, %rdi
callq *0x38(%rax)
movl %eax, %ebp
testb %al, %al
je 0x1a5a2
leaq 0x1e8(%r14), %rdi
movq %rsp, %rsi
movq %r13, (%rsi)
callq 0x1b964
leaq 0x180(%r14), %rdi
movq %r12, %rsi
callq 0xb230
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 0x459df(%rip), %rsi     # 0x5ff88
leaq 0x20(%rsp), %rdi
callq 0xb220
leaq 0x90(%rsp), %rdi
callq 0xb120
movl %ebp, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a5fa
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a5fd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x1a5fd
jmp 0x1a5fa
jmp 0x1a5fa
movq %rax, %rbx
movq 0x45984(%rip), %rsi     # 0x5ff88
leaq 0x20(%rsp), %rdi
callq 0xb220
leaq 0x90(%rsp), %rdi
callq 0xb120
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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 0x1bad8
movl %eax, %ebp
movq 0x1f0(%rbx), %rax
cmpq %rax, 0x1e8(%rbx)
je 0x1a689
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 0x1bb2e
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x60(%rax)
leaq 0x18(%rsp), %rdi
callq 0x1321e
movq 0x148(%rbx), %rsi
addq $0x148, %rbx            # imm = 0x148
movq %rbx, %rdi
callq 0x1b7e0
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1321e
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b873
leaq 0x42ad1(%rip), %rsi     # 0x5e308
leaq 0x42b8a(%rip), %rdx     # 0x5e3c8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xb520
movq %rax, %rbx
testq %rax, %rax
jne 0x1b8ec
leaq 0x2a2fa(%rip), %rdi     # 0x45b55
leaq 0x29190(%rip), %rsi     # 0x449f2
leaq 0x29356(%rip), %rcx     # 0x44bbf
movl $0x15ea, %edx           # imm = 0x15EA
callq 0xb2d0
movl $0x60, %edi
callq 0xb480
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x426e2(%rip), %rax     # 0x5df70
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 0x319ec
movq %r14, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4c(%rbx)
leaq 0x42a80(%rip), %rax     # 0x5e348
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 0x1b8ec
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, 0x10(%r14)
je 0x1b91e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x1b91e
movl $0x1, 0x58(%rbx)
movq 0x30(%rbx), %rax
movq %rbx, 0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1b91e
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1b943
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1b95b
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1b95b
movq %rax, %rdi
callq 0x14d37
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0xb4a0
movq %r14, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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), %r14
movq 0x1d8(%rdi), %r12
cmpq %r14, %r12
je 0x1c2b2
movq %rdi, %r15
addq $-0x88, %r12
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x20(%rax)
cmpq %r14, %r12
jne 0x1c297
movq (%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1c3b2
// File: /workspace/github_cpp_makefile_star2_O3/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), %eax
cmpl $0x1, %eax
je 0x1c760
testl %eax, %eax
jne 0x1c6f5
movsbl %sil, %eax
cmpl $0x5a, %eax
jg 0x1c716
cmpl $0x20, %eax
je 0x1c7f6
cmpl $0x22, %eax
jne 0x1c752
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl $0x2, (%rbx)
jmp 0x1c7f2
cmpl $0x2, %eax
setne %cl
cmpb $0x22, %sil
setne %dl
orb %cl, %dl
jne 0x1c72d
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1c800
cmpl $0x5b, %eax
je 0x1c7e1
cmpl $0x7e, %eax
jne 0x1c752
movb $0x1, 0x4(%rbx)
jmp 0x1c7f6
cmpl $0x3, %eax
setne %al
cmpb $0x5d, %sil
setne %cl
orb %al, %cl
jne 0x1c7f6
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1ca62
movq 0x10(%rbx), %rax
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movsbl %sil, %eax
cmpl $0x5b, %eax
je 0x1c78a
cmpl $0x2c, %eax
jne 0x1c7f6
movq %rbx, %rdi
callq 0x1c800
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1c9fe
leaq 0x18(%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
subq %rdx, %rcx
movq %rsp, %r14
movq %r14, %rdi
callq 0xb4d0
leaq 0x28483(%rip), %rsi     # 0x44c2e
movq %r14, %rdi
callq 0xb100
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1c7cf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
testl %ebp, %ebp
je 0x1c7dd
movq %rbx, %rdi
callq 0x1c800
jmp 0x1c7e1
movb $0x1, 0x4(%rbx)
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: void Catch::TestSpecParser::addPattern<Catch::TestSpec::TagPattern>()
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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0xb4d0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x28196(%rip), %rsi     # 0x44c2e
leaq 0x28197(%rip), %rdx     # 0x44c36
leaq 0x8(%rsp), %rdi
callq 0x31a82
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe998
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cad1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
testb %bpl, %bpl
je 0x1cb1c
movb $0x1, 0x4(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
movq $-0x1, %rcx
callq 0xb4d0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0xb590
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1cb1c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
cmpq $0x0, 0x30(%rsp)
je 0x1cbc1
movl $0x30, %edi
callq 0xb480
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x4129d(%rip), %rax     # 0x5dde0
movq %rax, (%r14)
movq %r14, %rdi
addq $0x10, %rdi
leaq 0x28(%rsp), %rsi
callq 0xea17
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpb $0x1, 0x4(%rbx)
jne 0x1cba3
movl $0x18, %edi
callq 0xb480
movq %rax, %r15
movl $0x0, 0x8(%rax)
leaq 0x41292(%rip), %rax     # 0x5de18
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1ce7c
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1ceb8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cbc1
movq (%rdi), %rax
callq *0x18(%rax)
movb $0x0, 0x4(%rbx)
movl $0x0, (%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cbe6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0xb4a0
jmp 0x1cc35
jmp 0x1cc47
jmp 0x1cc4f
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
jmp 0x1cc29
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cc52
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x1cc52
jmp 0x1cc4f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cc52
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1cc52
movq %rax, %rdi
callq 0x14d37
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cc6d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x40bf5(%rip), %rcx     # 0x5dd80
movq %rcx, (%rdi)
movl %edx, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1d302
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28975(%rip), %rsi     # 0x45b30
leaq 0x2896f(%rip), %rdx     # 0x45b31
movq %rsp, %rdi
callq 0x31a82
movq %rsp, %rsi
movq %r14, %rdi
callq 0xe998
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d1ed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
testb %bpl, %bpl
je 0x1d233
movq %rsp, %rdi
movl $0x1, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0xb4d0
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xb590
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1d22c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
movl $0x1, 0xc(%rbx)
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x288f0(%rip), %rsi     # 0x45b30
leaq 0x288ea(%rip), %rdx     # 0x45b31
callq 0x31a82
movq %rsp, %rsi
movq %r14, %rdi
callq 0xfb6f
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d26f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
testb %bpl, %bpl
je 0x1d2af
movq 0x18(%rbx), %rcx
decq %rcx
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb4d0
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xb590
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1d2ab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
orb $0x2, 0xc(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d2df
jmp 0x1d2df
jmp 0x1d2c4
jmp 0x1d2df
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d2e2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x1d2e2
movq %rax, %r14
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x1d2fa
movq (%rbx), %rsi
incq %rsi
callq 0xb4a0
movq %r14, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0xb480
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2788d(%rip), %rsi     # 0x44c37
leaq 0x2788c(%rip), %rdx     # 0x44c3d
leaq 0x8(%rsp), %rdi
callq 0x31a82
movl $0x0, 0x8(%rbx)
leaq 0x40ba7(%rip), %rax     # 0x5df70
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq %rbx, %rax
addq $0x20, %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
callq 0x319ec
movq %r14, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movl $0x0, 0x58(%rbx)
leaq 0x40f3b(%rip), %rax     # 0x5e348
movq %rax, (%rbx)
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d9aa
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d434
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq $0x0, 0x8(%r14)
movl $0x1, 0x10(%r14)
movq (%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1d476
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d471
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
testb %bpl, %bpl
je 0x1d483
movl $0x60, %esi
movq %rbx, %rdi
callq 0xb4a0
movq %r14, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::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 %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movl $0x8, %eax
leaq 0x4293d(%rip), %rcx     # 0x604b0
cmpl %ebx, -0x8(%rax,%rcx)
je 0x1dbc2
addq $0x10, %rax
cmpq $0x68, %rax
jne 0x1db73
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x270b5(%rip), %rsi     # 0x44c48
leaq 0x270be(%rip), %rdx     # 0x44c58
leaq 0x8(%rsp), %rdi
callq 0x31a82
callq 0xe13b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *0x50(%rcx)
jmp 0x1dbf1
movq (%rax,%rcx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x13d78
callq 0xe13b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *0x50(%rcx)
negl %ebx
movl %ebx, %edi
callq 0xb580
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x1dc1a
jmp 0x1dc2e
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dc2e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x1dc2e
jmp 0x1dc2b
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IConfig const> const&) const
virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
            FactoryMap::const_iterator it =  m_factories.find( name );
            if( it == m_factories.end() )
                return CATCH_NULL;
            return it->second->create( ReporterConfig( config ) );
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x1e128
addq $0x10, %rbx
cmpq %rbx, %rax
je 0x1e057
movq 0x40(%rax), %rbx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x8(%rsp)
movq (%r14), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x1e034
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1e059
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1e059
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x1e081
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1e079
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xb820
movq %rax, %rdi
callq 0x14d37
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ExceptionTranslatorRegistry::translateActiveException[abi:cxx11]() const
virtual std::string translateActiveException() const {
            try {
#ifdef __OBJC__
                // In Objective-C try objective-c exceptions first
                @try {
                    return tryTranslators();
                }
                @catch (NSException *exception) {
                    return Catch::toString( [exception description] );
                }
#else
                return tryTranslators();
#endif
            }
            catch( TestFailureException& ) {
                throw;
            }
            catch( std::exception& ex ) {
                return ex.what();
            }
            catch( std::string& msg ) {
                return msg;
            }
            catch( const char* msg ) {
                return msg;
            }
            catch(...) {
                return "Unknown exception";
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1e350
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x5, %r14d
je 0x1e2db
cmpl $0x4, %r14d
jne 0x1e271
callq 0xb190
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13d78
jmp 0x1e2d1
cmpl $0x3, %r14d
jne 0x1e297
callq 0xb190
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x319ec
jmp 0x1e2d1
callq 0xb190
cmpl $0x2, %r14d
jne 0x1e2b4
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13d78
jmp 0x1e2d1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2699c(%rip), %rsi     # 0x44c5e
leaq 0x269a6(%rip), %rdx     # 0x44c6f
movq %rbx, %rdi
callq 0x31a82
callq 0xb750
jmp 0x1e230
callq 0xb190
callq 0xb660
movq %rax, %rbx
callq 0xb750
jmp 0x1e315
movq %rax, %rbx
callq 0xb750
jmp 0x1e315
movq %rax, %rbx
callq 0xb750
jmp 0x1e315
movq %rax, %rbx
callq 0xb750
jmp 0x1e315
movq %rax, %rbx
callq 0xb750
movq %rbx, %rdi
callq 0xb820
movq %rax, %rdi
callq 0x14d37
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Context::getGeneratorsForCurrentTest()
IGeneratorsForTest& getGeneratorsForCurrentTest() {
            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
            if( !generators ) {
                std::string testName = getResultCapture()->getCurrentTestName();
                generators = createGeneratorsForTest();
                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
            }
            return *generators;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
callq 0x1ed3c
movq %rax, %rbx
testq %rax, %rax
jne 0x1ecea
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x40(%rcx)
movl $0x50, %edi
callq 0xb480
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
addq $0x10, %rax
leaq 0x406c8(%rip), %rcx     # 0x5f338
movq %rcx, (%rbx)
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x319ec
leaq 0x28(%rsp), %rsi
movq %rbx, 0x20(%rsi)
addq $0x20, %r14
movq %r14, %rdi
callq 0x1ee50
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1eccf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ecea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ed18
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb4a0
jmp 0x1ed18
jmp 0x1ed15
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ed33
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Context::findGeneratorsForCurrentTest()
IGeneratorsForTest* findGeneratorsForCurrentTest() {
            std::string testName = getResultCapture()->getCurrentTestName();

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *0x40(%rcx)
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x1edc6
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x1ed78
movq 0x40(%rax), %rbx
jmp 0x1ed7a
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ed95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1edbe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::GeneratorsForTest::getGeneratorInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
            if( it == m_generatorsByName.end() ) {
                IGeneratorInfo* info = new GeneratorInfo( size );
                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
                m_generatorsInOrder.push_back( info );
                return *info;
            }
            return *it->second;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x1f284
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x1f104
movq 0x40(%rax), %r14
jmp 0x1f19d
movl $0x18, %edi
callq 0xb480
movq %rax, %r14
leaq 0x40268(%rip), %rax     # 0x5f380
movq %rax, (%r14)
movq %r13, 0x8(%r14)
movq $0x0, 0x10(%r14)
movq %r14, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x319ec
movq %r14, 0x20(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1f338
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f174
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x1f188
movq %r14, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x1f19d
addq $0x38, %rbx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1f504
movq (%r14), %r14
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f1c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb4a0
movq %rbx, %rdi
callq 0xb820