LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Config::openStream()
IStream const* openStream() {
            if( m_data.outputFilename.empty() )
                return new CoutStream();
            else if( m_data.outputFilename[0] == '%' ) {
                if( m_data.outputFilename == "%debug" )
                    return new DebugOutStream();
                else
                    throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename );
            }
            else
                return new FileStream( m_data.outputFilename );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x10, %rdi
addq $0x28, %rdi
callq 0xea90
testb $0x1, %al
jne 0x450c7
jmp 0x4510e
movl $0x118, %edi            # imm = 0x118
callq 0xe680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x11ac0
jmp 0x450e2
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4526e
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x118, %esi            # imm = 0x118
callq 0xe6a0
jmp 0x45278
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xec90
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x45225
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
addq $0x28, %rdi
leaq 0x393eb(%rip), %rsi     # 0x7e52d
callq 0x1c1d0
testb $0x1, %al
jne 0x4514d
jmp 0x45194
movl $0x120, %edi            # imm = 0x120
callq 0xe680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x119c0
jmp 0x45168
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4526e
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x120, %esi            # imm = 0x120
callq 0xe6a0
jmp 0x45278
movb $0x1, -0x41(%rbp)
movl $0x10, %edi
callq 0xe310
movq -0x50(%rbp), %rdx
movq %rax, -0x68(%rbp)
addq $0x38, %rdx
leaq 0x3937f(%rip), %rsi     # 0x7e534
leaq -0x40(%rbp), %rdi
callq 0x1a170
jmp 0x451c0
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe7e0
jmp 0x451cf
movq -0x68(%rbp), %rdi
movb $0x0, -0x41(%rbp)
movq 0x6fd62(%rip), %rsi     # 0xb4f40
movq 0x6fd8b(%rip), %rdx     # 0xb4f70
callq 0xeb10
jmp 0x45281
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x45212
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xecd8
testb $0x1, -0x41(%rbp)
jne 0x4521a
jmp 0x45223
movq -0x68(%rbp), %rdi
callq 0xe4c0
jmp 0x45278
movl $0x208, %edi            # imm = 0x208
callq 0xe680
movq -0x50(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
addq $0x38, %rsi
callq 0x11780
jmp 0x45248
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4526e
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0xe6a0
jmp 0x45278
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TagInfo::all[abi:cxx11]() const
std::string all() const {
            std::string out;
            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
                        it != itEnd;
                        ++it )
                out += "[" + *it + "]";
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xe900
movq -0x80(%rbp), %rdi
callq 0x1b240
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x1b270
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1b2a0
testb $0x1, %al
jne 0x47035
jmp 0x470d4
leaq -0x20(%rbp), %rdi
callq 0x1b2d0
movq %rax, %rdx
leaq 0x36cef(%rip), %rsi     # 0x7dd37
leaq -0x68(%rbp), %rdi
callq 0x1a170
jmp 0x47053
leaq 0x374d1(%rip), %rdx     # 0x7e52b
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1ad20
jmp 0x47069
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe850
jmp 0x4707b
leaq -0x48(%rbp), %rdi
callq 0xecd8
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x20(%rbp), %rdi
callq 0x1b2f0
jmp 0x4701f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x470fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x470c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xecd8
leaq -0x68(%rbp), %rdi
callq 0xecd8
jmp 0x470fa
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x470ea
movq -0x90(%rbp), %rdi
callq 0xecd8
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xecd8
movq -0x70(%rbp), %rdi
callq 0xeb60
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::sortTests(Catch::IConfig const&, std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&)
inline std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {

        std::vector<TestCase> sorted = unsortedTestCases;

        switch( config.runOrder() ) {
            case RunTests::InLexicographicalOrder:
                std::sort( sorted.begin(), sorted.end(), LexSort() );
                break;
            case RunTests::InRandomOrder:
                {
                    seedRng( config );

                    RandomNumberGenerator rng;
                    std::random_shuffle( sorted.begin(), sorted.end(), rng );
                }
                break;
            case RunTests::InDeclarationOrder:
                // already in declaration order
                break;
        }
        return sorted;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
callq 0x49b10
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
movl %eax, -0x5c(%rbp)
jmp 0x499be
movl -0x5c(%rbp), %eax
testl %eax, %eax
je 0x49a61
jmp 0x499cb
movl -0x5c(%rbp), %eax
subl $0x1, %eax
je 0x499fc
jmp 0x499d5
movl -0x5c(%rbp), %eax
subl $0x2, %eax
je 0x49a27
jmp 0x49a63
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1a5d0
jmp 0x49a80
movq -0x70(%rbp), %rdi
callq 0x46bc0
movq -0x70(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x46c30
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x49c00
jmp 0x49a25
jmp 0x49a63
movq -0x10(%rbp), %rdi
callq 0x13f00
jmp 0x49a32
movq -0x70(%rbp), %rdi
callq 0x46bc0
movq -0x70(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x46c30
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x42(%rbp), %rdx
callq 0x49c40
jmp 0x49a5f
jmp 0x49a63
jmp 0x49a63
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x49a76
movq -0x70(%rbp), %rdi
callq 0x1a5d0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
XmlWriter& startElement( std::string const& name ) {
            ensureTagClosed();
            newlineIfNecessary();
            stream() << m_indent << "<" << name;
            m_tags.push_back( name );
            m_indent += "  ";
            m_tagIsOpen = true;
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x51c30
movq -0x18(%rbp), %rdi
callq 0x372c0
movq -0x18(%rbp), %rdi
callq 0x37300
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x2c94f(%rip), %rsi     # 0x7e448
callq 0xe670
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xe5a0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x3daa0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq 0x2c99a(%rip), %rsi     # 0x7e4c4
callq 0xe650
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
XmlWriter& writeText( std::string const& text, bool indent = true ) {
            if( !text.empty() ){
                bool tagWasOpen = m_tagIsOpen;
                ensureTagClosed();
                if( tagWasOpen && indent )
                    stream() << m_indent;
                stream() << XmlEncode( text );
                m_needsNewline = true;
            }
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0xea90
testb $0x1, %al
jne 0x5230e
movq -0x58(%rbp), %rdi
movb (%rdi), %al
andb $0x1, %al
movb %al, -0x12(%rbp)
callq 0x51c30
testb $0x1, -0x12(%rbp)
je 0x522b5
testb $0x1, -0x11(%rbp)
je 0x522b5
movq -0x58(%rbp), %rdi
callq 0x37300
movq -0x58(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0xe5a0
movq -0x58(%rbp), %rdi
callq 0x37300
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %edx, %edx
callq 0x51ca0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x51c70
jmp 0x522e4
leaq -0x40(%rbp), %rdi
callq 0x51ce0
movq -0x58(%rbp), %rax
movb $0x1, 0x1(%rax)
jmp 0x5230e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x51ce0
jmp 0x52318
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::JunitReporter::writeTestCase(Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode> const&)
void writeTestCase( TestCaseNode const& testCaseNode ) {
            TestCaseStats const& stats = testCaseNode.value;

            // All test cases have exactly one section - which represents the
            // test case itself. That section may have 0-n nested sections
            assert( testCaseNode.children.size() == 1 );
            SectionNode const& rootSection = *testCaseNode.children.front();

            std::string className = stats.testInfo.className;

            if( className.empty() ) {
                if( rootSection.childSections.empty() )
                    className = "global";
            }
            writeSection( className, "", rootSection );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x4dd80
cmpq $0x1, %rax
jne 0x5333f
jmp 0x5335e
leaq 0x2b603(%rip), %rdi     # 0x7e949
leaq 0x2a6e9(%rip), %rsi     # 0x7da36
movl $0x2432, %edx           # imm = 0x2432
leaq 0x2b612(%rip), %rcx     # 0x7e96b
callq 0xe440
movq -0x10(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x53510
movq %rax, %rdi
callq 0x4cd90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0x20, %rsi
leaq -0x40(%rbp), %rdi
callq 0xe280
leaq -0x40(%rbp), %rdi
callq 0xea90
testb $0x1, %al
jne 0x5339e
jmp 0x533db
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
callq 0x4cb90
testb $0x1, %al
jne 0x533b4
jmp 0x533d9
leaq 0x2b5ef(%rip), %rsi     # 0x7e9aa
leaq -0x40(%rbp), %rdi
callq 0xe8e0
jmp 0x533c6
jmp 0x533d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5346b
jmp 0x533db
leaq -0x71(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xeb70
movq -0x88(%rbp), %rdx
leaq 0x2b631(%rip), %rsi     # 0x7ea2a
leaq -0x70(%rbp), %rdi
callq 0x18c80
jmp 0x53404
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x53540
jmp 0x5341b
leaq -0x70(%rbp), %rdi
callq 0xecd8
leaq -0x71(%rbp), %rdi
callq 0xe710
leaq -0x40(%rbp), %rdi
callq 0xecd8
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x53462
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xecd8
leaq -0x71(%rbp), %rdi
callq 0xe710
leaq -0x40(%rbp), %rdi
callq 0xecd8
movq -0x48(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::JunitReporter::writeAssertions(Catch::CumulativeReporterBase::SectionNode const&)
void writeAssertions( SectionNode const& sectionNode ) {
            for( SectionNode::Assertions::const_iterator
                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
                    it != itEnd;
                    ++it )
                writeAssertion( *it );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0x54200
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0x54230
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x54290
testb $0x1, %al
jne 0x54133
jmp 0x54153
leaq -0x18(%rbp), %rdi
callq 0x548a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x542d0
leaq -0x18(%rbp), %rdi
callq 0x548c0
jmp 0x54120
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::lazyPrint()
void lazyPrint() {

            if( !currentTestRunInfo.used )
                lazyPrintRunInfo();
            if( !currentGroupInfo.used )
                lazyPrintGroupInfo();

            if( !m_headerPrinted ) {
                printTestCaseAndSectionHeader();
                m_headerPrinted = true;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x48(%rax)
jne 0x54963
movq -0x10(%rbp), %rdi
callq 0x54f10
movq -0x10(%rbp), %rax
testb $0x1, 0x88(%rax)
jne 0x54979
movq -0x10(%rbp), %rdi
callq 0x550d0
movq -0x10(%rbp), %rax
testb $0x1, 0x1c9(%rax)
jne 0x5499a
movq -0x10(%rbp), %rdi
callq 0x55180
movq -0x10(%rbp), %rax
movb $0x1, 0x1c9(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::AssertionPrinter::print() const
void print() const {
                printSourceInfo();
                if( stats.totals.assertions.total() > 0 ) {
                    if( result.isOk() )
                        stream << "\n";
                    printResultType();
                    printOriginalExpression();
                    printReconstructedExpression();
                }
                else {
                    stream << "\n";
                }
                printMessage();
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x559d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0xd8, %rdi
callq 0x266e0
cmpq $0x0, %rax
jbe 0x54e96
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12040
testb $0x1, %al
jne 0x54e66
jmp 0x54e79
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x29bb5(%rip), %rsi     # 0x7ea29
callq 0xe670
movq -0x10(%rbp), %rdi
callq 0x55a80
movq -0x10(%rbp), %rdi
callq 0x55b10
movq -0x10(%rbp), %rdi
callq 0x55bf0
jmp 0x54ea9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x29b85(%rip), %rsi     # 0x7ea29
callq 0xe670
movq -0x10(%rbp), %rdi
callq 0x55d60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::lazyPrintRunInfo()
void lazyPrintRunInfo() {
            stream  << "\n" << getLineOfChars<'~'>() << "\n";
            Colour colour( Colour::SecondaryText );
            stream  << currentTestRunInfo->name
                    << " is a Catch v"  << libraryVersion << " host application.\n"
                    << "Run with -? for options\n\n";

            if( m_config->rngSeed() != 0 )
                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";

            currentTestRunInfo.used = true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%rax), %rdi
leaq 0x29af7(%rip), %rsi     # 0x7ea29
movq %rsi, -0x40(%rbp)
callq 0xe670
movq %rax, -0x48(%rbp)
callq 0x55430
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xe670
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0xe670
leaq -0x9(%rbp), %rdi
movl $0x17, %esi
callq 0x11bf0
movq -0x38(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x20, %rdi
callq 0x55470
movq %rax, -0x28(%rbp)
jmp 0x54f85
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xe5a0
movq %rax, -0x50(%rbp)
jmp 0x54f98
movq -0x50(%rbp), %rdi
leaq 0x29a4c(%rip), %rsi     # 0x7e9ef
callq 0xe670
movq %rax, -0x58(%rbp)
jmp 0x54fae
movq -0x58(%rbp), %rdi
leaq 0x607af(%rip), %rsi     # 0xb5768
callq 0x12c90
movq %rax, -0x60(%rbp)
jmp 0x54fc4
movq -0x60(%rbp), %rdi
leaq 0x29a2e(%rip), %rsi     # 0x7e9fd
callq 0xe670
movq %rax, -0x68(%rbp)
jmp 0x54fda
movq -0x68(%rbp), %rdi
leaq 0x29a2c(%rip), %rsi     # 0x7ea11
callq 0xe670
jmp 0x54fec
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x19f20
movq %rax, -0x70(%rbp)
jmp 0x54fff
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq 0x78(%rax), %rax
callq *%rax
movl %eax, -0x74(%rbp)
jmp 0x55011
movl -0x74(%rbp), %eax
cmpl $0x0, %eax
je 0x550ab
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x299ff(%rip), %rsi     # 0x7ea2b
callq 0xe670
movq %rax, -0x80(%rbp)
jmp 0x55037
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x19f20
movq %rax, -0x88(%rbp)
jmp 0x5504d
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
movq 0x78(%rax), %rax
callq *%rax
movl %eax, -0x8c(%rbp)
jmp 0x55065
movl -0x8c(%rbp), %esi
movq -0x80(%rbp), %rdi
callq 0xe8c0
movq %rax, -0x98(%rbp)
jmp 0x5507d
movq -0x98(%rbp), %rdi
leaq 0x2999d(%rip), %rsi     # 0x7ea28
callq 0xe670
jmp 0x55092
jmp 0x550ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x11cf0
jmp 0x550c5
movq -0x38(%rbp), %rax
movb $0x1, 0x48(%rax)
leaq -0x9(%rbp), %rdi
callq 0x11cf0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xeb60
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: char const* Catch::getLineOfChars<(char)126>()
char const* getLineOfChars() {
        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
        if( !*line ) {
            memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
        }
        return line;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x603f5(%rip)     # 0xb5830
jne 0x5545a
leaq 0x603ec(%rip), %rdi     # 0xb5830
movl $0x7e, %esi
movl $0x4f, %edx
callq 0xe350
movb $0x0, 0x60425(%rip)     # 0xb587f
leaq 0x603cf(%rip), %rax     # 0xb5830
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
            std::size_t i = _string.find( ": " );
            if( i != std::string::npos )
                i+=2;
            else
                i = 0;
            stream << Text( _string, TextAttributes()
                                        .setIndent( indent+i)
                                        .setInitialIndent( indent ) ) << "\n";
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x28cea(%rip), %rsi     # 0x7e337
xorl %eax, %eax
movl %eax, %edx
callq 0xec80
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x5566f
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x55677
movq $0x0, -0x20(%rbp)
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3fcc0
movq -0xd8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
addq %rax, %rsi
callq 0x3fcf0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x46ba0
movq -0xd0(%rbp), %rsi
movq %rax, %rdx
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3fd10
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x3fc20
movq %rax, -0xb8(%rbp)
jmp 0x55700
movq -0xb8(%rbp), %rdi
leaq 0x2931b(%rip), %rsi     # 0x7ea29
callq 0xe670
jmp 0x55715
leaq -0x78(%rbp), %rdi
callq 0x40350
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x40350
movq -0xa0(%rbp), %rdi
callq 0xeb60
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::AssertionPrinter::printOriginalExpression() const
void printOriginalExpression() const {
                if( result.hasExpression() ) {
                    Colour colourGuard( Colour::OriginalExpression );
                    stream  << "  ";
                    stream << result.getExpressionInMacro();
                    stream << "\n";
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rax), %rdi
callq 0x120b0
testb $0x1, %al
jne 0x55b36
jmp 0x55bd9
leaq -0x9(%rbp), %rdi
movl $0x5, %esi
callq 0x11bf0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
leaq 0x28972(%rip), %rsi     # 0x7e4c4
callq 0xe670
jmp 0x55b59
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x12180
jmp 0x55b73
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe5a0
jmp 0x55b82
leaq -0x40(%rbp), %rdi
callq 0xecd8
movq -0x48(%rbp), %rax
movq (%rax), %rdi
leaq 0x28e90(%rip), %rsi     # 0x7ea29
callq 0xe670
jmp 0x55ba0
leaq -0x9(%rbp), %rdi
callq 0x11cf0
jmp 0x55bd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x55bce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xecd8
leaq -0x9(%rbp), %rdi
callq 0x11cf0
jmp 0x55bdf
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::AssertionPrinter::printReconstructedExpression() const
void printReconstructedExpression() const {
                if( result.hasExpandedExpression() ) {
                    stream << "with expansion:\n";
                    Colour colourGuard( Colour::ReconstructedExpression );
                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq 0x10(%rax), %rdi
callq 0x12270
testb $0x1, %al
jne 0x55c1c
jmp 0x55d3f
movq -0xc0(%rbp), %rax
movq (%rax), %rdi
leaq 0x28f4e(%rip), %rsi     # 0x7eb7b
callq 0xe670
leaq -0x9(%rbp), %rdi
movl $0x6, %esi
callq 0x11bf0
movq -0xc0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xc8(%rbp)
movq 0x10(%rax), %rsi
leaq -0x88(%rbp), %rdi
callq 0x12330
jmp 0x55c63
leaq -0xb8(%rbp), %rdi
callq 0x3fcc0
jmp 0x55c71
leaq -0xb8(%rbp), %rdi
movl $0x2, %esi
callq 0x3fcf0
movq %rax, %rdx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3fd10
jmp 0x55c97
movq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3fc20
movq %rax, -0xd0(%rbp)
jmp 0x55cb0
movq -0xd0(%rbp), %rdi
leaq 0x28d6b(%rip), %rsi     # 0x7ea29
callq 0xe670
jmp 0x55cc5
leaq -0x68(%rbp), %rdi
callq 0x40350
leaq -0x88(%rbp), %rdi
callq 0xecd8
leaq -0x9(%rbp), %rdi
callq 0x11cf0
jmp 0x55d3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x55d34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x55d28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x40350
leaq -0x88(%rbp), %rdi
callq 0xecd8
leaq -0x9(%rbp), %rdi
callq 0x11cf0
jmp 0x55d48
addq $0xd0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::AssertionPrinter::printMessage() const
void printMessage() const {
                if( !messageLabel.empty() )
                    stream << messageLabel << ":" << "\n";
                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
                        it != itEnd;
                        ++it ) {
                    // If this assertion is a warning ignore any INFO messages
                    if( printInfoMessages || it->type != ResultWas::Info )
                        stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
addq $0x40, %rdi
callq 0xea90
testb $0x1, %al
jne 0x55db8
movq -0xa8(%rbp), %rsi
movq (%rsi), %rdi
addq $0x40, %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x27efc(%rip), %rsi     # 0x7dca0
callq 0xe670
movq %rax, %rdi
leaq 0x28c76(%rip), %rsi     # 0x7ea29
callq 0xe670
movq -0xa8(%rbp), %rdi
addq $0x80, %rdi
callq 0x1b7a0
movq -0xa8(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x80, %rdi
callq 0x1b7d0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1b800
testb $0x1, %al
jne 0x55dfc
jmp 0x55eeb
movq -0xa8(%rbp), %rax
testb $0x1, 0x98(%rax)
jne 0x55e1f
leaq -0x10(%rbp), %rdi
callq 0x1b840
cmpl $0x1, 0x48(%rax)
je 0x55edb
movq -0xa8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1b840
addq $0x50, %rax
movq %rax, -0xc8(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3fcc0
movq -0xd0(%rbp), %rdi
movl $0x2, %esi
callq 0x3fcf0
movq -0xc8(%rbp), %rsi
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3fd10
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x3fc20
movq %rax, -0xb0(%rbp)
jmp 0x55e9e
movq -0xb0(%rbp), %rdi
leaq 0x28b7d(%rip), %rsi     # 0x7ea29
callq 0xe670
jmp 0x55eb3
leaq -0x70(%rbp), %rdi
callq 0x40350
jmp 0x55edb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x40350
jmp 0x55ef4
jmp 0x55edd
leaq -0x10(%rbp), %rdi
callq 0x1b8f0
jmp 0x55de6
addq $0xd0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0xeb60
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::SummaryColumn::addRow(unsigned long)
SummaryColumn addRow( std::size_t count ) {
                std::ostringstream oss;
                oss << count;
                std::string row = oss.str();
                for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
                    while( it->size() < row.size() )
                        *it = " " + *it;
                    while( it->size() > row.size() )
                        row = " " + row;
                }
                rows.push_back( row );
                return *this;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0xe8d0
movq -0x218(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe120
jmp 0x56aa8
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xe6b0
jmp 0x56abd
movq -0x220(%rbp), %rdi
addq $0x28, %rdi
callq 0x18d50
movq %rax, -0x1c8(%rbp)
movq -0x220(%rbp), %rdi
addq $0x28, %rdi
callq 0x18dc0
movq %rax, -0x1d0(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x57a60
testb $0x1, %al
jne 0x56b07
jmp 0x56c55
jmp 0x56b09
leaq -0x1c8(%rbp), %rdi
callq 0x57aa0
movq %rax, %rdi
callq 0xe480
movq %rax, -0x238(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xe480
movq %rax, %rcx
movq -0x238(%rbp), %rax
cmpq %rcx, %rax
jae 0x56bcd
leaq -0x1c8(%rbp), %rdi
callq 0x373d0
movq %rax, %rdx
leaq 0x26e7a(%rip), %rsi     # 0x7d9d3
leaq -0x1f0(%rbp), %rdi
callq 0x1a170
jmp 0x56b67
leaq -0x1c8(%rbp), %rdi
callq 0x373d0
movq %rax, %rdi
leaq -0x1f0(%rbp), %rsi
callq 0xe800
leaq -0x1f0(%rbp), %rdi
callq 0xecd8
jmp 0x56b09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x56cab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xecd8
jmp 0x56cab
jmp 0x56bcf
leaq -0x1c8(%rbp), %rdi
callq 0x57aa0
movq %rax, %rdi
callq 0xe480
movq %rax, -0x240(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xe480
movq %rax, %rcx
movq -0x240(%rbp), %rax
cmpq %rcx, %rax
jbe 0x56c42
leaq 0x26dc7(%rip), %rsi     # 0x7d9d3
leaq -0x210(%rbp), %rdi
leaq -0x1c0(%rbp), %rdx
callq 0x1a170
jmp 0x56c21
leaq -0x1c0(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xe800
leaq -0x210(%rbp), %rdi
callq 0xecd8
jmp 0x56bcf
jmp 0x56c44
leaq -0x1c8(%rbp), %rdi
callq 0x57ac0
jmp 0x56ad4
movq -0x220(%rbp), %rdi
addq $0x28, %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3daa0
jmp 0x56c6e
movq -0x220(%rbp), %rsi
movq -0x230(%rbp), %rdi
callq 0x57ae0
jmp 0x56c83
leaq -0x1c0(%rbp), %rdi
callq 0xecd8
leaq -0x190(%rbp), %rdi
callq 0xe130
movq -0x228(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0xe130
movq -0x198(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::findMax(unsigned long&, unsigned long&, unsigned long&)
static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
            if( i > j && i > k )
                return i;
            else if( j > k )
                return j;
            else
                return k;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x5848a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x5848a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x584ac
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x584a4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x584ac
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CompactReporter::AssertionPrinter::printResultType(Catch::Colour::Code, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
void printResultType( Colour::Code colour, std::string passOrFail ) const {
                if( !passOrFail.empty() ) {
                    {
                        Colour colourGuard( colour );
                        stream << " " << passOrFail;
                    }
                    stream << ":";
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rax, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xea90
testb $0x1, %al
jne 0x5920c
movl -0xc(%rbp), %esi
leaq -0x19(%rbp), %rdi
callq 0x11bf0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq 0x24816(%rip), %rsi     # 0x7d9d3
callq 0xe670
movq %rax, -0x50(%rbp)
jmp 0x591c8
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0xe5a0
jmp 0x591d7
leaq -0x19(%rbp), %rdi
callq 0x11cf0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq 0x24ab2(%rip), %rsi     # 0x7dca0
callq 0xe670
jmp 0x5920c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x11cf0
jmp 0x59212
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CompactReporter::AssertionPrinter::printReconstructedExpression() const
void printReconstructedExpression() const {
                if( result.hasExpandedExpression() ) {
                    {
                        Colour colour( dimColour() );
                        stream << " for: ";
                    }
                    stream << result.getExpandedExpression();
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rax), %rdi
callq 0x12270
testb $0x1, %al
jne 0x592f6
jmp 0x59388
callq 0x596a0
movl %eax, %esi
leaq -0x9(%rbp), %rdi
callq 0x11bf0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
leaq 0x259b0(%rip), %rsi     # 0x7ecc4
callq 0xe670
jmp 0x5931b
leaq -0x9(%rbp), %rdi
callq 0x11cf0
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x10(%rax), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x12330
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xe5a0
jmp 0x5934f
leaq -0x40(%rbp), %rdi
callq 0xecd8
jmp 0x59388
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x11cf0
jmp 0x5938e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xecd8
jmp 0x5938e
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CompactReporter::AssertionPrinter::printExpressionWas()
void printExpressionWas() {
                if( result.hasExpression() ) {
                    stream << ";";
                    {
                        Colour colour( dimColour() );
                        stream << " expression was:";
                    }
                    printOriginalExpression();
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x120b0
testb $0x1, %al
jne 0x597c3
jmp 0x59826
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0x25061(%rip), %rsi     # 0x7e832
callq 0xe670
callq 0x596a0
movl %eax, %esi
leaq -0x9(%rbp), %rdi
callq 0x11bf0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0x254e3(%rip), %rsi     # 0x7ecd7
callq 0xe670
jmp 0x597fb
leaq -0x9(%rbp), %rdi
callq 0x11cf0
movq -0x28(%rbp), %rdi
callq 0x59230
jmp 0x59826
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x11cf0
jmp 0x5982c
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::StreamBufImpl<Catch::OutputDebugWriter, 256ul>::sync()
int sync() {
            if( pbase() != pptr() ) {
                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
                setp( pbase(), epptr() );
            }
            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xe1b0
movq -0x50(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xe1a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x5c892
movq -0x50(%rbp), %rdi
movq %rdi, %rax
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x78(%rbp)
callq 0xe1b0
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0xe1a0
movq -0x50(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xe1b0
movq %rax, %rcx
movq -0x70(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xeb70
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x28(%rbp), %rdi
callq 0xe770
jmp 0x5c81b
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5c9b0
jmp 0x5c82a
leaq -0x28(%rbp), %rdi
callq 0xecd8
leaq -0x29(%rbp), %rdi
callq 0xe710
movq -0x50(%rbp), %rdi
callq 0xe1b0
movq -0x50(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0xe860
movq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0xe9c0
jmp 0x5c892
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5c887
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xecd8
leaq -0x29(%rbp), %rdi
callq 0xe710
jmp 0x5c89d
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::StreamBufImpl<Catch::OutputDebugWriter, 256ul>::overflow(int)
int overflow( int c ) {
            sync();

            if( c != EOF ) {
                if( pbase() == epptr() )
                    m_writer( std::string( 1, static_cast<char>( c ) ) );
                else
                    sputc( static_cast<char>( c ) );
            }
            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $-0x1, -0xc(%rbp)
je 0x5c998
movq -0x50(%rbp), %rdi
callq 0xe1b0
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0xe860
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0x5c987
movq -0x50(%rbp), %rax
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x70(%rbp)
movsbl -0xc(%rbp), %eax
movl %eax, -0x64(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xeb70
movl -0x64(%rbp), %edx
movq -0x60(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x437d0
jmp 0x5c936
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5c9b0
jmp 0x5c945
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x5c996
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5c97c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x5c9a0
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %eax
movsbl %al, %esi
callq 0xe250
jmp 0x5c998
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::delete_shared(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void delete_shared(const std::string& name)
		{
			int status = ::gdc_circular_queue_delete_shared(name.c_str());
			
			if (status != 0 && errno != ENOENT)
			{
				std::string what("Failed to delete shared memory queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe260
movq %rax, %rdi
callq 0x7c330
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x65f6b
callq 0xe070
cmpl $0x2, (%rax)
je 0x65f6b
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xeb70
movq -0x50(%rbp), %rdx
leaq 0x19e1c(%rip), %rsi     # 0x7fcdc
leaq -0x30(%rbp), %rdi
callq 0x18c80
jmp 0x65ecb
leaq -0x31(%rbp), %rdi
callq 0xe710
callq 0xe070
movl (%rax), %edi
callq 0xe1c0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0xec20
jmp 0x65eee
movl $0x18, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x66900
jmp 0x65f0d
movq -0x58(%rbp), %rdi
leaq 0x4ea68(%rip), %rsi     # 0xb4980
leaq 0x721(%rip), %rdx       # 0x66640
callq 0xeb10
jmp 0x65f7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x65f71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x65f60
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xe4c0
leaq -0x30(%rbp), %rdi
callq 0xecd8
jmp 0x65f71
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::circular_queue_factory(unsigned long, bool, std::function<int (gdc::circular_queue<char>&)>)
circular_queue_factory(
			size_type capacity,
			bool sync = true,
			mdinit_type metadata_initializer = [](Q&) -> int { return 0; }) :
			_capacity(capacity),
			_sync(sync),
			_metadata_initializer(metadata_initializer),
			_q(nullptr, null_queue_destroyer)
		{
			assert(capacity >= 0);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x40(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0xe900
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, 0x20(%rdi)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, 0x28(%rdi)
addq $0x30, %rdi
callq 0x66d40
jmp 0x66336
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
leaq 0xaab(%rip), %rax       # 0x66df0
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdx
callq 0x66e00
cmpq $0x0, -0x10(%rbp)
jb 0x6635f
jmp 0x66395
leaq 0x19a63(%rip), %rdi     # 0x7fdc9
leaq 0x199a4(%rip), %rsi     # 0x7fd11
movl $0x131, %edx            # imm = 0x131
leaq 0x19b72(%rip), %rcx     # 0x7feeb
callq 0xe440
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xecd8
jmp 0x6639b
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ExpressionLhs<bool>::endExpression()
void endExpression() {
        bool value = m_lhs ? true : false;
        m_rb
            .setLhs( Catch::toString( value ) )
            .setResultType( value )
            .endExpression();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x8(%rax), %cl
andb $0x1, %cl
movb %cl, -0x9(%rbp)
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movzbl -0x9(%rbp), %esi
andl $0x1, %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x15130
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x158f0
movq %rax, -0x48(%rbp)
jmp 0x66557
movq -0x48(%rbp), %rdi
movzbl -0x9(%rbp), %esi
andl $0x1, %esi
callq 0x158c0
movq %rax, -0x60(%rbp)
jmp 0x6656d
movq -0x60(%rbp), %rdi
callq 0x159b0
jmp 0x66578
leaq -0x30(%rbp), %rdi
callq 0xecd8
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xecd8
movq -0x38(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.h
// Function: gdc::circular_queue<char>::front() const
const_reference front() const
		{
			auto q = reinterpret_cast<const gdc_circular_queue*>(this);
			auto qq = const_cast<gdc_circular_queue*>(q);
			auto p = ::gdc_circular_queue_peek(qq);
			auto pp = reinterpret_cast<const_pointer>(p);
			return *pp;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7bcc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::create_shared(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, bool, std::function<int (gdc::circular_queue<char>&)>)
static void create_shared(
			const std::string& name,
			size_type capacity,
			bool sync,
			mdinit_type metadata_initializer)
		{
			void* mdinit_context = &metadata_initializer;
			int status = ::gdc_circular_queue_create_shared(
				name.c_str(),
				capacity,
				sync,
				default_metadata_init,
				mdinit_context);

			if (status != 0)
			{
				std::string what("Failed to create shared memory queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe260
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %r8
leaq 0x5ab(%rip), %rcx       # 0x678a0
callq 0x7c0d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x673ca
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xeb70
movq -0x70(%rbp), %rdx
leaq 0x18b16(%rip), %rsi     # 0x7fe35
leaq -0x50(%rbp), %rdi
callq 0x18c80
jmp 0x6732a
leaq -0x51(%rbp), %rdi
callq 0xe710
callq 0xe070
movl (%rax), %edi
callq 0xe1c0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0xec20
jmp 0x6734d
movl $0x18, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x66900
jmp 0x6736c
movq -0x78(%rbp), %rdi
leaq 0x4d609(%rip), %rsi     # 0xb4980
leaq -0xd3e(%rip), %rdx      # 0x66640
callq 0xeb10
jmp 0x673dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xe710
jmp 0x673d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x673bf
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0xe4c0
leaq -0x50(%rbp), %rdi
callq 0xecd8
jmp 0x673d3
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::map_shared(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static Q* map_shared(const std::string& name)
		{
			gdc_circular_queue* q = ::gdc_circular_queue_map_shared(name.c_str());
			
			if (q == NULL)
			{
				std::string what("Failed to map shared memory queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
			
			return reinterpret_cast<Q*>(q);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe260
movq %rax, %rdi
callq 0x7c400
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x674cf
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xeb70
movq -0x50(%rbp), %rdx
leaq 0x18a38(%rip), %rsi     # 0x7fe5c
leaq -0x30(%rbp), %rdi
callq 0x18c80
jmp 0x6742f
leaq -0x31(%rbp), %rdi
callq 0xe710
callq 0xe070
movl (%rax), %edi
callq 0xe1c0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0xec20
jmp 0x67452
movl $0x18, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x66900
jmp 0x67471
movq -0x58(%rbp), %rdi
leaq 0x4d504(%rip), %rsi     # 0xb4980
leaq -0xe43(%rip), %rdx      # 0x66640
callq 0xeb10
jmp 0x674e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x674d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x674c4
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xe4c0
leaq -0x30(%rbp), %rdi
callq 0xecd8
jmp 0x674d9
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax)