LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::AssertionResult::getExpression[abi:cxx11]() const
std::string AssertionResult::getExpression() const {
        if( isFalseTest( m_info.resultDisposition ) )
            return "!" + m_info.capturedExpression;
        else
            return m_info.capturedExpression;
    }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
testb $0x4, 0x68(%rsi)
jne 0xf657
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x48(%rdx), %rsi
movq 0x50(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x32cee
jmp 0xf66a
addq $0x48, %rdx
leaq 0x39a2f(%rip), %rsi     # 0x49091
movq %rbx, %rdi
callq 0x15995
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::AssertionResult::getExpressionInMacro[abi:cxx11]() const
std::string AssertionResult::getExpressionInMacro() const {
        if( m_info.macroName.empty() )
            return m_info.capturedExpression;
        else
            return m_info.macroName + "( " + m_info.capturedExpression + " )";
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0xf6ef
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x32cee
leaq 0x37438(%rip), %rsi     # 0x46ae6
movq %r15, %rdi
callq 0xc8b0
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0xc110
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xf70e
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0xf715
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x32cee
jmp 0xf7aa
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x3724e(%rip), %rsi     # 0x46986
callq 0xc8b0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xf75f
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xf765
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xf793
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf7aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xf7da
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0xf7da
jmp 0xf7d7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf7f1
movq 0x18(%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::TestCase::swap(Catch::TestCase&)
void TestCase::swap( TestCase& other ) {
        test.swap( other.test );
        name.swap( other.name );
        className.swap( other.className );
        description.swap( other.description );
        tags.swap( other.tags );
        lcaseTags.swap( other.lcaseTags );
        tagsAsString.swap( other.tagsAsString );
        std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
        std::swap( lineInfo, other.lineInfo );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x110(%rdi), %rax
movq 0x110(%rsi), %rcx
movq %rcx, 0x110(%rdi)
movq %rax, 0x110(%rsi)
callq 0xc350
leaq 0x20(%r14), %rdi
leaq 0x20(%rbx), %rsi
callq 0xc350
leaq 0x40(%r14), %rdi
leaq 0x40(%rbx), %rsi
callq 0xc350
leaq 0x60(%r14), %rdi
leaq 0x60(%rbx), %rsi
callq 0x338fc
movl $0x90, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x338fc
movl $0xc0, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0xc350
movl 0x108(%r14), %eax
movl 0x108(%rbx), %ecx
movl %ecx, 0x108(%r14)
movl %eax, 0x108(%rbx)
movl $0xe0, %r15d
leaq (%r14,%r15), %rdi
addq %rbx, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0xe0(%r14), %rcx
leaq 0xf0(%r14), %rax
cmpq %rax, %rcx
je 0xffd1
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
jmp 0xffd9
movups (%rax), %xmm0
movups %xmm0, (%r13)
movq 0xe8(%r14), %rcx
leaq 0x8(%rsp), %r12
movq %rcx, 0x8(%r12)
movq %rax, 0xe0(%r14)
movq $0x0, 0xe8(%r14)
movb $0x0, 0xf0(%r14)
movq 0x100(%r14), %rax
movq %rax, 0x20(%r12)
movq %r15, %rsi
callq 0xc590
movq 0x100(%rbx), %rax
movq %rax, 0x100(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0xc590
movq 0x20(%r12), %rax
movq %rax, 0x100(%rbx)
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x10053
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::operator<<(std::ostream&, Catch::Version const&)
std::ostream& operator << ( std::ostream& os, Version const& version ) {
        os  << version.majorVersion << "."
            << version.minorVersion << "."
            << version.patchNumber;

        if( !version.branchName.empty() ) {
            os  << "-" << version.branchName
                << "." << version.buildNumber;
        }
        return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0xc300
movq %rax, %r15
leaq 0x37b3b(%rip), %r12     # 0x47cd7
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xc530
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0xc300
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xc530
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0xc300
cmpq $0x0, 0x18(%r14)
je 0x10225
leaq 0x37a21(%rip), %rsi     # 0x47c06
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc530
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0xc530
movq %rax, %r15
leaq 0x37acb(%rip), %rsi     # 0x47cd7
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
movl 0x30(%r14), %esi
movq %r15, %rdi
callq 0xc300
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::LegacyReporterAdapter::assertionEnded(Catch::AssertionStats const&)
bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
                    it != itEnd;
                    ++it ) {
                if( it->type == ResultWas::Info ) {
                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
                    rb << it->message;
                    rb.setResultType( ResultWas::Info );
                    AssertionResult result = rb.build();
                    m_legacyReporter->Result( result );
                }
            }
        }
        m_legacyReporter->Result( assertionStats.assertionResult );
        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0xb8(%rsi)
je 0x106a6
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %r15
movq 0xc8(%rax), %rbx
cmpq %rbx, %r15
je 0x106a6
leaq 0x373be(%rip), %r12     # 0x479e1
leaq 0xc8(%rsp), %r13
leaq 0x10(%rsp), %rbp
cmpl $0x1, 0x48(%r15)
jne 0x1069d
movq (%r15), %rsi
leaq 0x20(%r15), %rdx
movq %r13, %rdi
movq %r12, %rcx
movl $0x1, %r8d
movq %r12, %r9
callq 0x123f2
movq 0x50(%r15), %rsi
movq 0x58(%r15), %rdx
leaq 0x1e8(%rsp), %rdi
callq 0xc530
movl $0x1, 0x178(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x10704
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
callq *0x80(%rax)
movq %rbp, %rdi
callq 0xf566
movq %r13, %rdi
callq 0x1617e
addq $0x78, %r15
cmpq %rbx, %r15
jne 0x10630
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movb $0x1, %al
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x106d2
movq %rax, %rbx
jmp 0x106e4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf566
leaq 0xc8(%rsp), %rdi
callq 0x1617e
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string trim( std::string const& str ) {
        static char const* whitespaceChars = "\n\r\t ";
        std::string::size_type start = str.find_first_not_of( whitespaceChars );
        std::string::size_type end = str.find_last_not_of( whitespaceChars );

        return start != std::string::npos ? str.substr( start, 1+end-start ) : "";
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x35d4e(%rip), %r12     # 0x4698c
movl $0x4, %ecx
movq %rsi, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xc7a0
movq %rax, %r15
movl $0x4, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0xc730
cmpq $-0x1, %r15
je 0x10c89
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xc4d0
jmp 0x10ca2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x36d4a(%rip), %rdx     # 0x479e1
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x32d7e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::operator<<(std::ostream&, Catch::pluralise const&)
std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
        os << pluraliser.m_count << " " << pluraliser.m_label;
        if( pluraliser.m_count != 1 )
            os << "s";
        return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0xc300
movq %rax, %r15
leaq 0x359e3(%rip), %rsi     # 0x4698f
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0xc530
cmpq $0x1, (%r14)
je 0x10fe3
leaq 0x35e2f(%rip), %rsi     # 0x46e05
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc530
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::throwLogicError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
        std::ostringstream oss;
        oss << locationInfo << ": Internal Catch error: '" << message << "'";
        if( alwaysTrue() )
            throw std::logic_error( oss.str() );
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xc5f0
movq %r15, %rdi
movq %r14, %rsi
callq 0xe3bb
leaq 0x35821(%rip), %rsi     # 0x46991
leaq 0x20(%rsp), %rdi
movl $0x19, %edx
callq 0xc530
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x20(%rsp), %rdi
callq 0xc530
leaq 0x3608f(%rip), %rsi     # 0x47226
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
movl $0x10, %edi
callq 0xc1f0
movq %rax, %rbx
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xc6f0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc680
xorl %ebp, %ebp
movq 0x50df3(%rip), %rsi     # 0x61fc8
movq 0x50dbc(%rip), %rdx     # 0x61f98
movq %rbx, %rdi
callq 0xc7d0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1120a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x1120a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1121c
movq %rbx, %rdi
callq 0xc360
jmp 0x1121c
movq %rax, %r14
movq 0x50d65(%rip), %rsi     # 0x61f88
leaq 0x20(%rsp), %rdi
callq 0xc220
leaq 0x90(%rsp), %rdi
callq 0xc120
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Section::~Section()
Section::~Section() {
        if( m_sectionIncluded ) {
            SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
            if( std::uncaught_exception() )
                getResultCapture().sectionEndedEarly( endInfo );
            else
                getResultCapture().sectionEnded( endInfo );
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x4e2a6(%rip), %rax     # 0x5f710
movq %rax, (%rdi)
cmpb $0x1, 0xa8(%rdi)
jne 0x11534
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc710
imull $0xf4240, (%r14), %eax  # imm = 0xF4240
addl 0x8(%r14), %eax
subl 0xb0(%rbx), %eax
cvtsi2sd %rax, %xmm0
divsd 0x34b63(%rip), %xmm0    # 0x46008
leaq 0x90(%rbx), %rdx
leaq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x16374
callq 0xc060
testb %al, %al
je 0x114cd
callq 0xd1cc
movl $0x28, %ecx
jmp 0x114d7
callq 0xd1cc
movl $0x20, %ecx
movq (%rax), %rdx
movq %rsp, %rsi
movq %rax, %rdi
callq *(%rdx,%rcx)
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x114fe
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11519
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11534
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x1154f
movq (%rax), %rsi
incq %rsi
callq 0xc4a0
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x11567
movq (%rax), %rsi
incq %rsi
callq 0xc4a0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x1157f
movq (%rax), %rsi
incq %rsi
callq 0xc4a0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x11597
movq (%rbx), %rsi
incq %rsi
callq 0xc4a0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x15d1b
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Detail::rawMemoryToString[abi:cxx11](void const*, unsigned long)
std::string rawMemoryToString( const void *object, std::size_t size )
    {
        // Reverse order for little endian architectures
        int i = 0, end = static_cast<int>( size ), inc = 1;
        if( Endianness::which() == Endianness::Little ) {
            i = end-1;
            end = inc = -1;
        }

        unsigned char const *bytes = static_cast<unsigned char const *>(object);
        std::ostringstream os;
        os << "0x" << std::setfill('0') << std::hex;
        for( ; i != end; i += inc )
             os << std::setw(2) << static_cast<unsigned>(bytes[i]);
       return os.str();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0xc5f0
leaq 0x353c0(%rip), %rsi     # 0x469c5
movl $0x2, %edx
movq %r12, %rdi
callq 0xc530
movq (%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r12
cmpb $0x0, 0xe1(%r12)
jne 0x11647
movq %r12, %rdi
movl $0x20, %esi
callq 0xc460
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movq %rsp, %r12
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsp,%rax)
movslq %r15d, %rax
movq %rax, %r15
subq $0x1, %r15
jb 0x11699
movq (%rsp), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rsp,%rcx)
movzbl -0x1(%r14,%rax), %esi
movq %r12, %rdi
callq 0xc300
movq %r15, %rax
jmp 0x1166f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc6f0
movq 0x508db(%rip), %rsi     # 0x61f88
movq %rsp, %rdi
callq 0xc220
leaq 0x70(%rsp), %rdi
callq 0xc120
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x116d3
movq %rax, %rbx
movq 0x508ab(%rip), %rsi     # 0x61f88
movq %rsp, %rdi
callq 0xc220
leaq 0x70(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::toString(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string toString( std::wstring const& value ) {

    std::string s;
    s.reserve( value.size() );
    for(size_t i = 0; i < value.size(); ++i )
        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
    return Catch::toString( s );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc6e0
cmpq $0x0, 0x8(%r14)
je 0x11bd6
xorl %r13d, %r13d
movl $0x3f, %ebp
leaq 0x8(%rsp), %r15
movq (%r14), %rax
movl (%rax,%r13,4), %eax
cmpl $0x100, %eax            # imm = 0x100
cmovgel %ebp, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0xc3e0
incq %r13
cmpq 0x8(%r14), %r13
jb 0x11bb3
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x116f7
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11bfa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11c0e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11c28
movq 0x18(%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::toString[abi:cxx11](int)
std::string toString( int value ) {
    std::ostringstream oss;
    oss << value;
    if( value > Detail::hexThreshold )
        oss << " (0x" << std::hex << value << ")";
    return oss.str();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc5f0
movq %r14, %rdi
movl %ebp, %esi
callq 0xc7e0
cmpl $0x100, %ebp            # imm = 0x100
jl 0x11e60
leaq 0x34ba7(%rip), %rsi     # 0x469c3
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0xc530
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rsp,%rax)
movl %ebp, %esi
callq 0xc7e0
leaq 0x34b34(%rip), %rsi     # 0x46987
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xc6f0
movq 0x50114(%rip), %rsi     # 0x61f88
leaq 0x8(%rsp), %rdi
callq 0xc220
leaq 0x78(%rsp), %rdi
callq 0xc120
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x500e7(%rip), %rsi     # 0x61f88
leaq 0x8(%rsp), %rdi
callq 0xc220
leaq 0x78(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::toString[abi:cxx11](unsigned long)
std::string toString( unsigned long value ) {
    std::ostringstream oss;
    oss << value;
    if( value > Detail::hexThreshold )
        oss << " (0x" << std::hex << value << ")";
    return oss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc5f0
movq %r15, %rdi
movq %r14, %rsi
callq 0xc300
cmpq $0x100, %r14            # imm = 0x100
jb 0x11f3c
leaq 0x34acc(%rip), %rsi     # 0x469c3
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0xc530
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rsp,%rax)
movq %r14, %rsi
callq 0xc300
leaq 0x34a58(%rip), %rsi     # 0x46987
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xc6f0
movq 0x50038(%rip), %rsi     # 0x61f88
leaq 0x8(%rsp), %rdi
callq 0xc220
leaq 0x78(%rsp), %rdi
callq 0xc120
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x5000a(%rip), %rsi     # 0x61f88
leaq 0x8(%rsp), %rdi
callq 0xc220
leaq 0x78(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::toString[abi:cxx11](long long)
std::string toString( long long value ) {
    std::ostringstream oss;
    oss << value;
    if( value > Detail::hexThreshold )
        oss << " (0x" << std::hex << value << ")";
    return oss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc5f0
movq %r15, %rdi
movq %r14, %rsi
callq 0xc150
cmpq $0x100, %r14            # imm = 0x100
jl 0x12180
leaq 0x34888(%rip), %rsi     # 0x469c3
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0xc530
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rsp,%rax)
movq %r14, %rsi
callq 0xc150
leaq 0x34814(%rip), %rsi     # 0x46987
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xc6f0
movq 0x4fdf4(%rip), %rsi     # 0x61f88
leaq 0x8(%rsp), %rdi
callq 0xc220
leaq 0x78(%rsp), %rdi
callq 0xc120
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x4fdc6(%rip), %rsi     # 0x61f88
leaq 0x8(%rsp), %rdi
callq 0xc220
leaq 0x78(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::toString[abi:cxx11](unsigned long long)
std::string toString( unsigned long long value ) {
    std::ostringstream oss;
    oss << value;
    if( value > Detail::hexThreshold )
        oss << " (0x" << std::hex << value << ")";
    return oss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc5f0
movq %r15, %rdi
movq %r14, %rsi
callq 0xc2f0
cmpq $0x100, %r14            # imm = 0x100
jb 0x1225d
leaq 0x347ab(%rip), %rsi     # 0x469c3
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0xc530
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rsp,%rax)
movq %r14, %rsi
callq 0xc2f0
leaq 0x34737(%rip), %rsi     # 0x46987
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xc6f0
movq 0x4fd17(%rip), %rsi     # 0x61f88
leaq 0x8(%rsp), %rdi
callq 0xc220
leaq 0x78(%rsp), %rdi
callq 0xc120
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x4fce9(%rip), %rsi     # 0x61f88
leaq 0x8(%rsp), %rdi
callq 0xc220
leaq 0x78(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ResultBuilder::captureExpectedException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) {
        if( expectedMessage.empty() )
            captureExpectedException( Matchers::Impl::Generic::AllOf<std::string>() );
        else
            captureExpectedException( Matchers::Equals( expectedMessage ) );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x1281f
movq %rsi, %rdx
xorl %eax, %eax
leaq 0x18(%rsp), %rsi
movl %eax, -0x8(%rsi)
leaq 0x4d3c7(%rip), %r14     # 0x5fba8
movq %r14, -0x10(%rsi)
movl %eax, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x20e0a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x128a6
leaq 0x30(%rsp), %rax
movq %r14, -0x28(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12860
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x12860
leaq 0x18(%rsp), %r14
movl $0x0, -0x8(%r14)
leaq 0x4e955(%rip), %r15     # 0x61188
movq %r15, -0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x128a6
movq %r15, 0x8(%rsp)
movq %r14, %rdi
callq 0x20a2a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, 0x8(%rsp)
movq %r14, %rdi
callq 0x20a2a
jmp 0x1289e
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq %r14, -0x28(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1289e
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::ResultBuilder::captureExpectedException(Catch::Matchers::Impl::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void ResultBuilder::captureExpectedException( Matchers::Impl::Matcher<std::string> const& matcher ) {

        assert( m_exprComponents.testFalse == false );
        AssertionResultData data = m_data;
        data.resultType = ResultWas::Ok;
        data.reconstructedExpression = m_assertionInfo.capturedExpression;

        std::string actualMessage = Catch::translateActiveException();
        if( !matcher.match( actualMessage ) ) {
            data.resultType = ResultWas::ExpressionFailed;
            data.reconstructedExpression = actualMessage;
        }
        AssertionResult result( m_assertionInfo, data );
        handleResult( result );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
cmpb $0x0, 0xb8(%rdi)
jne 0x129e4
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x70(%rdi), %rsi
movq 0x78(%rdi), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x32cee
leaq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x90(%rbx), %rsi
movq 0x98(%rbx), %rdx
addq %rsi, %rdx
callq 0x32cee
leaq 0x28(%rsp), %rdi
movl $0x0, 0x40(%rdi)
leaq 0x48(%rbx), %rsi
callq 0xc230
callq 0xd3ca
movq (%rax), %rcx
movq %rax, %rdi
callq *0x20(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x12963
leaq 0x28(%rsp), %rdi
movl $0x11, 0x40(%rdi)
leaq 0x8(%rsp), %rsi
callq 0xc230
leaq 0x70(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0xf434
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x12a68
leaq 0x70(%rsp), %rdi
callq 0xf566
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x129a7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x129be
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x129d5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x33fe3(%rip), %rdi     # 0x469ce
leaq 0x34000(%rip), %rsi     # 0x469f2
leaq 0x34009(%rip), %rcx     # 0x46a02
movl $0x1fc2, %edx           # imm = 0x1FC2
callq 0xc2d0
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf566
jmp 0x12a35
jmp 0x12a32
jmp 0x12a52
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x12a5f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x12a5f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12a55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x12a55
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x15d74
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ResultBuilder::handleResult(Catch::AssertionResult const&)
void ResultBuilder::handleResult( AssertionResult const& result )
    {
        getResultCapture().assertionEnded( result );

        if( !result.isOk() ) {
            if( getCurrentContext().getConfig()->shouldDebugBreak() )
                m_shouldDebugBreak = true;
            if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) )
                m_shouldThrow = true;
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd1cc
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x10(%rcx)
testb $0x10, 0xb0(%r14)
je 0x12aff
movl 0x68(%r14), %eax
andl $0x8, %eax
jne 0x12aff
callq 0xf103
movq (%rax), %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12acb
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0x12ad7
movb $0x1, 0x298(%rbx)
callq 0xf103
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
testb %al, %al
jne 0x12af8
testb $0x1, 0x68(%rbx)
je 0x12aff
movb $0x1, 0x299(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x12b25
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12b1d
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::TagAliasRegistry::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Option<TagAlias> TagAliasRegistry::find( std::string const& alias ) const {
        std::map<std::string, TagAlias>::const_iterator it = m_registry.find( alias );
        if( it != m_registry.end() )
            return it->second;
        else
            return Option<TagAlias>();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x33b1c
addq $0x10, %r14
cmpq %r14, %rax
je 0x13614
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16794
jmp 0x1361b
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::RegistrarForTagAliases::RegistrarForTagAliases(char const*, char const*, Catch::SourceLineInfo const&)
RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
        try {
            TagAliasRegistry::get().add( alias, tag, lineInfo );
        }
        catch( std::exception& ex ) {
            Colour colourGuard( Colour::Red );
            Catch::cerr() << ex.what() << std::endl;
            exit(1);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x13f96
leaq 0x4e624(%rip), %rdi     # 0x625f8
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x138d2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x1404f
movq %rbx, %rdi
callq 0xc190
movq %rax, %rbx
movb $0x0, 0xf(%rsp)
movl $0x2, %edi
callq 0xf168
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x4dfca(%rip), %rdi     # 0x61fe8
movq %rax, %rsi
callq 0xc470
movq %rax, %rdi
callq 0xc1e0
movl $0x1, %edi
callq 0xc580
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xf1d2
jmp 0x1404a
movq %rax, %rbx
callq 0xc750
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::(anonymous namespace)::PosixColourImpl::use(Catch::Colour::Code)
virtual void use( Colour::Code _colourCode ) {
            switch( _colourCode ) {
                case Colour::None:
                case Colour::White:     return setColour( "[0m" );
                case Colour::Red:       return setColour( "[0;31m" );
                case Colour::Green:     return setColour( "[0;32m" );
                case Colour::Blue:      return setColour( "[0:34m" );
                case Colour::Cyan:      return setColour( "[0;36m" );
                case Colour::Yellow:    return setColour( "[0;33m" );
                case Colour::Grey:      return setColour( "[1;30m" );

                case Colour::LightGrey:     return setColour( "[0;37m" );
                case Colour::BrightRed:     return setColour( "[1;31m" );
                case Colour::BrightGreen:   return setColour( "[1;32m" );
                case Colour::BrightWhite:   return setColour( "[1;37m" );

                case Colour::Bright: throw std::logic_error( "not a colour" );
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x17, %esi
ja 0x14cff
movl %esi, %eax
leaq 0x313fc(%rip), %rcx     # 0x46088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x31fd4(%rip), %rdi     # 0x46c70
jmp 0x14cf6
leaq 0x32000(%rip), %rdi     # 0x46ca5
jmp 0x14cf6
leaq 0x31ff0(%rip), %rdi     # 0x46c9e
jmp 0x14cf6
leaq 0x31ffc(%rip), %rdi     # 0x46cb3
jmp 0x14cf6
leaq 0x31fb4(%rip), %rdi     # 0x46c74
jmp 0x14cf6
leaq 0x31fb9(%rip), %rdi     # 0x46c82
jmp 0x14cf6
leaq 0x31fb7(%rip), %rdi     # 0x46c89
jmp 0x14cf6
leaq 0x31fa0(%rip), %rdi     # 0x46c7b
jmp 0x14cf6
leaq 0x31fc8(%rip), %rdi     # 0x46cac
jmp 0x14cf6
leaq 0x31fa3(%rip), %rdi     # 0x46c90
jmp 0x14cf6
leaq 0x31fa1(%rip), %rdi     # 0x46c97
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14d4c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xc1f0
movq %rax, %rbx
leaq 0x31f9f(%rip), %rsi     # 0x46cba
movq %rax, %rdi
callq 0xc640
movq 0x4d29e(%rip), %rsi     # 0x61fc8
movq 0x4d267(%rip), %rdx     # 0x61f98
movq %rbx, %rdi
callq 0xc7d0
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::TestSpecParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TestSpecParser& parse( std::string const& arg ) {
            m_mode = None;
            m_exclusion = false;
            m_start = std::string::npos;
            m_arg = m_tagAliases->expandAliases( arg );
            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
                visitChar( m_arg[m_pos] );
            if( m_mode == Name )
                addPattern<TestSpec::NamePattern>();
            return *this;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x0, (%rdi)
movb $0x0, 0x4(%rdi)
movq $-0x1, 0x8(%rdi)
movq 0x68(%rdi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x18(%rax)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xc590
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15363
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq $0x0, 0x10(%rbx)
cmpq $0x0, 0x20(%rbx)
je 0x15395
xorl %eax, %eax
movq 0x18(%rbx), %rcx
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x1d6b8
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq 0x20(%rbx), %rax
jb 0x15374
cmpl $0x1, (%rbx)
jne 0x153a2
movq %rbx, %rdi
callq 0x1d818
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::extractClassName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
        std::string className = classOrQualifiedMethodName;
        if( startsWith( className, "&" ) )
        {
            std::size_t lastColons = className.rfind( "::" );
            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
            if( penultimateColons == std::string::npos )
                penultimateColons = 1;
            className = className.substr( penultimateColons, lastColons-penultimateColons );
        }
        return className;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x32cee
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3106a(%rip), %rsi     # 0x46c59
leaq 0x31064(%rip), %rdx     # 0x46c5a
leaq 0x8(%rsp), %rdi
callq 0x32d7e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf96e
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x15c26
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
testb %bpl, %bpl
je 0x15ca5
leaq 0x31029(%rip), %r14     # 0x46c5b
movl $0x2, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
callq 0xc610
movq %rax, %r15
leaq -0x1(%rax), %rdx
movl $0x2, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc610
cmpq $-0x1, %rax
movl $0x1, %edx
cmovneq %rax, %rdx
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0xc4d0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc590
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x15ca5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15cd5
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x15cd8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x15cd8
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x15cec
movq (%r12), %rsi
incq %rsi
callq 0xc4a0
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
        if( startsWith( tag, "." ) ||
            tag == "hide" ||
            tag == "!hide" )
            return TestCaseInfo::IsHidden;
        else if( tag == "!throws" )
            return TestCaseInfo::Throws;
        else if( tag == "!shouldfail" )
            return TestCaseInfo::ShouldFail;
        else if( tag == "!mayfail" )
            return TestCaseInfo::MayFail;
        else
            return TestCaseInfo::None;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x31e60(%rip), %rsi     # 0x47cd7
leaq 0x31e5a(%rip), %rdx     # 0x47cd8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x32d7e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf96e
testb %al, %al
jne 0x15f20
leaq 0x30e23(%rip), %rsi     # 0x46cc8
movq %rbx, %rdi
callq 0xc100
testl %eax, %eax
je 0x15f20
leaq 0x30e0f(%rip), %rsi     # 0x46cc7
movq %rbx, %rdi
callq 0xc100
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15ed9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
testl %ebp, %ebp
je 0x15f37
leaq 0x30de9(%rip), %rsi     # 0x46ccd
movq %rbx, %rdi
callq 0xc100
testl %eax, %eax
je 0x15f47
leaq 0x30dde(%rip), %rsi     # 0x46cd5
movq %rbx, %rdi
callq 0xc100
testl %eax, %eax
je 0x15f4e
leaq 0x30dd7(%rip), %rsi     # 0x46ce1
movq %rbx, %rdi
callq 0xc100
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
shll $0x3, %eax
jmp 0x15f3c
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15f37
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movl $0x2, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %eax
jmp 0x15f3c
movl $0x4, %eax
jmp 0x15f3c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15f6f
movq 0x18(%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::enforceNotReservedTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
        if( isReservedTag( tag ) ) {
            {
                Colour colourGuard( Colour::Red );
                Catch::cerr()
                    << "Tag name [" << tag << "] not allowed.\n"
                    << "Tag names starting with non alpha-numeric characters are reserved\n";
            }
            {
                Colour colourGuard( Colour::FileName );
                Catch::cerr() << _lineInfo << std::endl;
            }
            exit(1);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15e5a
testl %eax, %eax
jne 0x15fa0
cmpq $0x0, 0x8(%r14)
je 0x15fa0
movq (%r14), %rax
movsbl (%rax), %edi
callq 0xc4b0
testl %eax, %eax
je 0x15fa8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0x7(%rsp)
movl $0x2, %edi
callq 0xf168
movq 0x4c02a(%rip), %rdi     # 0x61fe8
leaq 0x30d25(%rip), %rsi     # 0x46cea
movl $0xa, %edx
callq 0xc530
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x4c00b(%rip), %rdi     # 0x61fe8
callq 0xc530
movq %rax, %r14
leaq 0x30d09(%rip), %rsi     # 0x46cf5
movl $0xf, %edx
movq %rax, %rdi
callq 0xc530
leaq 0x30d05(%rip), %rsi     # 0x46d05
movl $0x42, %edx
movq %r14, %rdi
callq 0xc530
leaq 0x7(%rsp), %rdi
callq 0xf1d2
movb $0x0, 0x6(%rsp)
movl $0x17, %edi
callq 0xf168
movq 0x4bfbb(%rip), %rdi     # 0x61fe8
movq %rbx, %rsi
callq 0xe3bb
movq 0x4bfac(%rip), %rdi     # 0x61fe8
callq 0xc1e0
leaq 0x6(%rsp), %rdi
callq 0xf1d2
movl $0x1, %edi
callq 0xc580
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
jmp 0x16067
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0xf1d2
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::fpToString<double>(double, int)
std::string fpToString( T value, int precision ) {
    std::ostringstream oss;
    oss << std::setprecision( precision )
        << std::fixed
        << value;
    std::string d = oss.str();
    std::size_t i = d.find_last_not_of( '0' );
    if( i != std::string::npos && i != d.size()-1 ) {
        if( d[i] == '.' )
            i++;
        d = d.substr( 0, i+1 );
    }
    return d;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %esi, %ebp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xc5f0
movq (%r14), %rax
movq -0x18(%rax), %rcx
movslq %ebp, %rdx
movq %rdx, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x40(%rsp,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x40(%rsp,%rax)
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0xc700
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xc6f0
movq %rbx, %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0xc320
cmpq $-0x1, %rax
je 0x1651c
movq 0x8(%rbx), %rcx
decq %rcx
cmpq %rcx, %rax
je 0x1651c
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x2e, (%rcx,%rax)
sete %dl
leaq (%rax,%rdx), %rcx
incq %rcx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc4d0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc590
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1651c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x4ba65(%rip), %rsi     # 0x61f88
leaq 0x28(%rsp), %rdi
callq 0xc220
leaq 0x98(%rsp), %rdi
callq 0xc120
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x16568
movq (%rbx), %rsi
incq %rsi
callq 0xc4a0
jmp 0x16568
movq %rax, %r14
movq 0x4ba19(%rip), %rsi     # 0x61f88
leaq 0x28(%rsp), %rdi
callq 0xc220
leaq 0x98(%rsp), %rdi
callq 0xc120
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Session::Session()
Session()
        : m_cli( makeCommandLineParser() ) {
            if( alreadyInstantiated ) {
                std::string msg = "Only one instance of Catch::Session can ever be used";
                Catch::cerr() << msg << std::endl;
                throw std::logic_error( msg );
            }
            alreadyInstantiated = true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x4a569(%rip), %rax     # 0x61298
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2159c
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r14)
movups %xmm0, 0x68(%r14)
movl $0x0, 0x87(%r14)
movaps 0x2f2b3(%rip), %xmm1    # 0x46010
movups %xmm1, 0x8c(%r14)
xorl %eax, %eax
movq %rax, 0x9c(%r14)
leaq 0xb8(%r14), %rcx
movq %rcx, 0xa8(%r14)
movq %rax, 0xb0(%r14)
movb %al, 0xb8(%r14)
leaq 0xd8(%r14), %rcx
movq %rcx, 0xc8(%r14)
movq %rax, 0xd0(%r14)
movb %al, 0xd8(%r14)
leaq 0xf8(%r14), %rcx
movq %rcx, 0xe8(%r14)
movq %rax, 0xf0(%r14)
movb %al, 0xf8(%r14)
movups %xmm0, 0x108(%r14)
movups %xmm0, 0x118(%r14)
movups %xmm0, 0x128(%r14)
movq %rax, 0x138(%r14)
cmpb $0x1, 0x4b792(%rip)     # 0x6257a
je 0x16dff
movb $0x1, 0x4b789(%rip)     # 0x6257a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2ff46(%rip), %rsi     # 0x46d55
leaq 0x2ff73(%rip), %rdx     # 0x46d89
movq %rsp, %rdi
callq 0x32d7e
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x4b1ba(%rip), %rdi     # 0x61fe8
callq 0xc530
movq %rax, %rdi
callq 0xc1e0
movl $0x10, %edi
callq 0xc1f0
movq %rax, %r12
movq %rsp, %rsi
movq %rax, %rdi
callq 0xc680
movq 0x4b16e(%rip), %rsi     # 0x61fc8
movq 0x4b137(%rip), %rdx     # 0x61f98
movq %r12, %rdi
callq 0xc7d0
movq %rax, %r15
movq %r12, %rdi
callq 0xc360
jmp 0x16e79
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x16e94
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0x16e94
movq %rax, %r15
movq 0x138(%r14), %rdi
testq %rdi, %rdi
je 0x16ea6
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x68(%r14), %r12
subq $-0x80, %r14
movq %r14, %rdi
callq 0x22b9a
movq %r12, %rdi
callq 0x22c02
movq %rbx, %rdi
callq 0x22c5e
movq %r15, %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::WildcardPattern::matches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
virtual bool matches( std::string const& str ) const {
            switch( m_wildcard ) {
                case NoWildcard:
                    return m_pattern == adjustCase( str );
                case WildcardAtStart:
                    return endsWith( adjustCase( str ), m_pattern );
                case WildcardAtEnd:
                    return startsWith( adjustCase( str ), m_pattern );
                case WildcardAtBothEnds:
                    return contains( adjustCase( str ), m_pattern );
            }

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#endif
            throw std::logic_error( "Unknown enum" );
#ifdef __clang__
#pragma clang diagnostic pop
#endif
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0xc(%rdi), %eax
cmpq $0x3, %rax
ja 0x17aec
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2e65b(%rip), %rcx     # 0x46060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e362
movq 0x18(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0x17ac1
testq %rdx, %rdx
je 0x17ac5
movq 0x8(%rsp), %rsi
movq 0x10(%rbx), %rdi
callq 0xc4c0
testl %eax, %eax
sete %bl
jmp 0x17ac7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e362
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf96e
jmp 0x17abd
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e362
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0xc7f0
cmpq $-0x1, %rax
setne %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
jmp 0x17ad0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e362
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10b55
movl %eax, %ebx
jmp 0x17ac7
xorl %ebx, %ebx
jmp 0x17ac7
movb $0x1, %bl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17ae2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xc1f0
movq %rax, %r14
leaq 0x2fad9(%rip), %rsi     # 0x475d9
movq %rax, %rdi
callq 0xc640
movq 0x4a4b9(%rip), %rsi     # 0x61fc8
movq 0x4a482(%rip), %rdx     # 0x61f98
movq %r14, %rdi
callq 0xc7d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xc360
jmp 0x17b4b
jmp 0x17b2d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17b4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
nop