LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::NotImplementedException::NotImplementedException(Catch::SourceLineInfo const&)
NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
    :   m_lineInfo( lineInfo ) {
        std::ostringstream oss;
        oss << lineInfo << ": function ";
        oss << "not implemented";
        m_what = oss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x1a850
movq -0x1c8(%rbp), %rdi
leaq 0xa0d97(%rip), %rax     # 0xb23c8
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xe900
movq -0x1c8(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x1c0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x13de0
jmp 0x11661
leaq -0x198(%rbp), %rdi
callq 0xe8d0
jmp 0x1166f
movq -0x10(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x10b20
movq %rax, -0x1d8(%rbp)
jmp 0x11688
movq -0x1d8(%rbp), %rdi
leaq 0x6c301(%rip), %rsi     # 0x7d997
callq 0xe670
jmp 0x1169d
leaq 0x6c2ff(%rip), %rsi     # 0x7d9a3
leaq -0x198(%rbp), %rdi
callq 0xe670
jmp 0x116b2
leaq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xe6b0
jmp 0x116c7
movq -0x1c8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xe800
leaq -0x1b8(%rbp), %rdi
callq 0xecd8
leaq -0x198(%rbp), %rdi
callq 0xe130
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1173f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x11733
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xe130
movq -0x1c0(%rbp), %rdi
callq 0x1a870
movq -0x1d0(%rbp), %rdi
callq 0xecd8
movq -0x1c8(%rbp), %rdi
callq 0xebe0
movq -0x18(%rbp), %rdi
callq 0xeb60
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::FileStream::FileStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
FileStream::FileStream( std::string const& filename ) {
        m_ofs.open( filename.c_str() );
        if( m_ofs.fail() ) {
            std::ostringstream oss;
            oss << "Unable to open file: '" << filename << "'";
            throw std::domain_error( oss.str() );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x1a890
movq -0x1d0(%rbp), %rdi
leaq 0xa0c3f(%rip), %rax     # 0xb23f0
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xeb00
jmp 0x117c6
movq -0x1d0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x1d8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe260
movq -0x1d8(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0xe090
jmp 0x117f7
movq -0x1d0(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rcx), %rcx
leaq 0x8(%rax,%rcx), %rdi
callq 0xe030
movb %al, -0x1d9(%rbp)
jmp 0x11818
movb -0x1d9(%rbp), %al
testb $0x1, %al
jne 0x11827
jmp 0x1195e
leaq -0x198(%rbp), %rdi
callq 0xe8d0
jmp 0x11835
leaq 0x6c177(%rip), %rsi     # 0x7d9b3
leaq -0x198(%rbp), %rdi
callq 0xe670
movq %rax, -0x1e8(%rbp)
jmp 0x11851
movq -0x1e8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe5a0
movq %rax, -0x1f0(%rbp)
jmp 0x1186a
movq -0x1f0(%rbp), %rdi
leaq 0x6c9f2(%rip), %rsi     # 0x7e26a
callq 0xe670
jmp 0x1187f
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0xe310
movq %rax, -0x1f8(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xe6b0
jmp 0x118ac
movq -0x1f8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xe7e0
jmp 0x118c1
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0xa366a(%rip), %rsi     # 0xb4f40
movq 0xa3693(%rip), %rdx     # 0xb4f70
callq 0xeb10
jmp 0x11988
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x11973
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x11967
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x11950
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x11937
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xecd8
testb $0x1, -0x1b9(%rbp)
jne 0x11942
jmp 0x1194e
movq -0x1f8(%rbp), %rdi
callq 0xe4c0
jmp 0x11950
leaq -0x198(%rbp), %rdi
callq 0xe130
jmp 0x11967
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0xe960
movq -0x1d0(%rbp), %rdi
callq 0x11990
movq -0x18(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Colour::use(Catch::Colour::Code)
void Colour::use( Code _colourCode ) {
        static IColourImpl* impl = isDebuggerActive()
            ? NoColourImpl::instance()
            : platformColourInstance();
        impl->use( _colourCode );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
cmpb $0x0, 0xa3b2e(%rip)     # 0xb5760
jne 0x11c99
leaq 0xa3b25(%rip), %rdi     # 0xb5760
callq 0xebc0
cmpl $0x0, %eax
je 0x11c99
callq 0x1aa20
movb %al, -0x15(%rbp)
jmp 0x11c4f
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x11c58
jmp 0x11c6d
callq 0x11d20
movq %rax, -0x20(%rbp)
jmp 0x11c63
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x11c82
callq 0x11d70
movq %rax, -0x30(%rbp)
jmp 0x11c78
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x11c82
movq -0x28(%rbp), %rax
movq %rax, 0xa3acb(%rip)     # 0xb5758
leaq 0xa3acc(%rip), %rdi     # 0xb5760
callq 0xe420
movq 0xa3ab8(%rip), %rdi     # 0xb5758
movl -0x4(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0xa3a9e(%rip), %rdi     # 0xb5760
callq 0xe400
movq -0x10(%rbp), %rdi
callq 0xeb60
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::(anonymous namespace)::platformColourInstance()
IColourImpl* platformColourInstance() {
        Ptr<IConfig const> config = getCurrentContext().getConfig();
        return (config && config->forceColour()) || isatty(STDOUT_FILENO)
            ? PosixColourImpl::instance()
            : NoColourImpl::instance();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0xf5b0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq *%rax
movq -0x28(%rbp), %rdi
callq 0x32000
movq %rax, -0x20(%rbp)
jmp 0x11da0
movq -0x20(%rbp), %rax
cmpq $0x0, %rax
je 0x11dd7
leaq -0x8(%rbp), %rdi
callq 0x19f20
movq %rax, -0x30(%rbp)
jmp 0x11db9
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x80(%rax), %rax
callq *%rax
movb %al, -0x31(%rbp)
jmp 0x11dce
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11de6
jmp 0x11dd7
movl $0x1, %edi
callq 0xeb50
cmpl $0x0, %eax
je 0x11dfb
callq 0x18810
movq %rax, -0x40(%rbp)
jmp 0x11df1
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x11e04
callq 0x11d20
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x18b10
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x18b10
movq -0x10(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x68(%rax), %edi
callq 0x1ad00
testb $0x1, %al
jne 0x12141
jmp 0x1215b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x48, %rdx
leaq 0x6e541(%rip), %rsi     # 0x80695
callq 0x1a170
jmp 0x1216c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
callq 0xe280
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xea90
testb $0x1, %al
jne 0x121b1
jmp 0x121c7
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x48, %rsi
callq 0xe280
jmp 0x1224e
movq -0x68(%rbp), %rsi
leaq 0x6b958(%rip), %rdx     # 0x7db2a
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1adc0
movq -0x68(%rbp), %rdx
movq -0x80(%rbp), %rsi
addq $0x48, %rdx
leaq -0x30(%rbp), %rdi
callq 0x1ad70
jmp 0x121f6
movq -0x78(%rbp), %rdi
leaq 0x6b7c9(%rip), %rdx     # 0x7d9ca
leaq -0x30(%rbp), %rsi
callq 0x1ad20
jmp 0x1220c
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x50(%rbp), %rdi
callq 0xecd8
jmp 0x1224e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x12243
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x50(%rbp), %rdi
callq 0xecd8
jmp 0x1225b
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x110, %rdi            # imm = 0x110
movq -0x10(%rbp), %rsi
addq $0x110, %rsi            # imm = 0x110
callq 0x1b3a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe4b0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0xe4b0
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0xe4b0
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x1b3d0
movq -0x18(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
callq 0x1b3d0
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
movq -0x10(%rbp), %rsi
addq $0xc0, %rsi
callq 0xe4b0
movq -0x18(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq -0x10(%rbp), %rsi
addq $0x108, %rsi            # imm = 0x108
callq 0x1b400
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
movq -0x10(%rbp), %rsi
addq $0xe0, %rsi
callq 0x1b430
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0xe8c0
movq %rax, %rdi
leaq 0x6c067(%rip), %rsi     # 0x7ed20
callq 0xe670
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xe8c0
movq %rax, %rdi
leaq 0x6c049(%rip), %rsi     # 0x7ed20
callq 0xe670
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xe8c0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xea90
testb $0x1, %al
jne 0x12d3a
movq -0x8(%rbp), %rdi
leaq 0x6bf48(%rip), %rsi     # 0x7ec4f
callq 0xe670
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x6bffa(%rip), %rsi     # 0x7ed20
callq 0xe670
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
callq 0xe8c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x3b0, %rsp            # imm = 0x3B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x390(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x12090
cmpl $0x0, %eax
je 0x132db
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0x1b7a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0x1b7d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1b800
testb $0x1, %al
jne 0x13182
jmp 0x132d9
leaq -0x18(%rbp), %rdi
callq 0x1b840
cmpl $0x1, 0x48(%rax)
jne 0x132c9
leaq -0x18(%rbp), %rdi
movq %rdi, -0x3a0(%rbp)
callq 0x1b840
movq %rax, %rdi
callq 0xe260
movq -0x3a0(%rbp), %rdi
movq %rax, -0x3a8(%rbp)
callq 0x1b840
movq -0x3a8(%rbp), %rsi
movq %rax, %rdx
addq $0x20, %rdx
leaq 0x6b855(%rip), %r9      # 0x7ea2a
leaq -0x2c0(%rbp), %rdi
movq %rdi, -0x398(%rbp)
movl $0x1, %r8d
movq %r9, %rcx
callq 0x155f0
movq -0x3a0(%rbp), %rdi
callq 0x1b840
movq -0x398(%rbp), %rdi
movq %rax, %rsi
addq $0x50, %rsi
callq 0x1b860
jmp 0x13212
leaq -0x2c0(%rbp), %rdi
movl $0x1, %esi
callq 0x13320
jmp 0x13225
leaq -0x388(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
callq 0x13340
jmp 0x1323a
movq -0x390(%rbp), %rdi
addq $0x10, %rdi
callq 0x1b780
movq %rax, -0x3b0(%rbp)
jmp 0x13253
movq -0x3b0(%rbp), %rdi
movq (%rdi), %rax
movq 0x80(%rax), %rax
leaq -0x388(%rbp), %rsi
callq *%rax
jmp 0x1326f
leaq -0x388(%rbp), %rdi
callq 0x11fe0
leaq -0x2c0(%rbp), %rdi
callq 0x1b8a0
jmp 0x132c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2c8(%rbp)
movl %eax, -0x2cc(%rbp)
jmp 0x132bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2c8(%rbp)
movl %eax, -0x2cc(%rbp)
leaq -0x388(%rbp), %rdi
callq 0x11fe0
leaq -0x2c0(%rbp), %rdi
callq 0x1b8a0
jmp 0x1330c
jmp 0x132cb
leaq -0x18(%rbp), %rdi
callq 0x1b8f0
jmp 0x1316c
jmp 0x132db
movq -0x390(%rbp), %rdi
addq $0x10, %rdi
callq 0x1b780
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq (%rdi), %rax
callq *0x80(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x3b0, %rsp            # imm = 0x3B0
popq %rbp
retq
movq -0x2c8(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::LegacyReporterAdapter::testCaseEnded(Catch::TestCaseStats const&)
void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
        m_legacyReporter->EndTestCase
            (   testCaseStats.testInfo,
                testCaseStats.totals,
                testCaseStats.stdOut,
                testCaseStats.stdErr );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x1b780
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
addq $0x118, %rdx            # imm = 0x118
movq -0x10(%rbp), %rcx
addq $0x148, %rcx            # imm = 0x148
movq -0x10(%rbp), %r8
addq $0x168, %r8             # imm = 0x168
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0xa1d4a(%rip), %rsi     # 0xb56e0
xorl %eax, %eax
movl %eax, %edx
callq 0xe390
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0xa1d32(%rip), %rsi     # 0xb56e0
movq $-0x1, %rdx
callq 0xebb0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, -0x22(%rbp)
cmpq $-0x1, %rax
je 0x139eb
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
subq -0x18(%rbp), %rcx
callq 0xe6d0
jmp 0x13a14
leaq -0x21(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xeb70
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
movb $0x1, -0x22(%rbp)
leaq 0x6b01f(%rip), %rsi     # 0x7ea2a
callq 0x18c80
jmp 0x13a12
jmp 0x13a14
testb $0x1, -0x22(%rbp)
jne 0x13a1c
jmp 0x13a25
leaq -0x21(%rbp), %rdi
callq 0xe710
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x22(%rbp)
jne 0x13a43
jmp 0x13a4c
leaq -0x21(%rbp), %rdi
callq 0xe710
jmp 0x13a4e
movq -0x30(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::replaceInPlace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
        bool replaced = false;
        std::size_t i = str.find( replaceThis );
        while( i != std::string::npos ) {
            replaced = true;
            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
            if( i < str.size()-withThis.size() )
                i = str.find( replaceThis, i+withThis.size() );
            else
                i = std::string::npos;
        }
        return replaced;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xeca0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x13c5e
movb $0x1, -0x19(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xe6d0
movq -0xc0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x1ad70
jmp 0x13ad4
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe480
movq -0xd0(%rbp), %rdx
movq -0xc8(%rbp), %rsi
addq %rax, %rdx
leaq -0xb8(%rbp), %rdi
movq $-0x1, %rcx
callq 0xe6d0
jmp 0x13b19
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x1b990
jmp 0x13b2f
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe800
leaq -0x48(%rbp), %rdi
callq 0xecd8
leaq -0xb8(%rbp), %rdi
callq 0xecd8
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x88(%rbp), %rdi
callq 0xecd8
movq -0x28(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe480
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe480
movq -0xe0(%rbp), %rcx
movq %rax, %rdx
movq -0xd8(%rbp), %rax
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x13c51
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe480
movq -0xf8(%rbp), %rdx
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
addq %rax, %rdx
callq 0xeca0
movq %rax, -0x28(%rbp)
jmp 0x13c59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x13c43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x13c3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xecd8
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x88(%rbp), %rdi
callq 0xecd8
jmp 0x13c6c
movq $-0x1, -0x28(%rbp)
jmp 0x13a90
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xe120
movq %rax, %rdi
leaq 0x69ce9(%rip), %rsi     # 0x7d9d3
callq 0xe670
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xe5a0
movq -0x10(%rbp), %rax
cmpq $0x1, (%rax)
je 0x13d19
movq -0x8(%rbp), %rdi
leaq 0x6a135(%rip), %rsi     # 0x7de49
callq 0xe670
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xe8d0
movq -0x1d0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10b20
movq %rax, -0x1c8(%rbp)
jmp 0x13fff
movq -0x1c8(%rbp), %rdi
leaq 0x699c8(%rip), %rsi     # 0x7d9d5
callq 0xe670
movq %rax, -0x1d8(%rbp)
jmp 0x1401b
movq -0x1d8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xe5a0
movq %rax, -0x1e0(%rbp)
jmp 0x14034
movq -0x1e0(%rbp), %rdi
leaq 0x6a228(%rip), %rsi     # 0x7e26a
callq 0xe670
jmp 0x14049
callq 0x1ba60
movb %al, -0x1e1(%rbp)
jmp 0x14056
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0x14065
jmp 0x1412c
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0xe310
movq %rax, -0x1f0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xe6b0
jmp 0x14092
movq -0x1f0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xe950
jmp 0x140a7
movq -0x1f0(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0xa0f0c(%rip), %rsi     # 0xb4fc8
movq 0xa0ecd(%rip), %rdx     # 0xb4f90
callq 0xeb10
jmp 0x14159
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x14141
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x14113
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xecd8
testb $0x1, -0x1b9(%rbp)
jne 0x1411e
jmp 0x1412a
movq -0x1f0(%rbp), %rdi
callq 0xe4c0
jmp 0x14141
leaq -0x188(%rbp), %rdi
callq 0xe130
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x190(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0x9e19f(%rip), %rcx     # 0xb24f0
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0xa8(%rax)
je 0x1442d
movq -0x98(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, %rax
addq $0x90, %rax
movq %rax, -0xa8(%rbp)
addq $0xb0, %rdi
callq 0x137f0
movsd %xmm0, -0xa0(%rbp)
jmp 0x143a0
movsd -0xa0(%rbp), %xmm0
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1bbc0
jmp 0x143c4
callq 0xe080
testb $0x1, %al
jne 0x143cf
jmp 0x143f8
callq 0xf520
movq %rax, -0xb8(%rbp)
jmp 0x143dd
movq -0xb8(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x90(%rbp), %rsi
callq *%rax
jmp 0x143f6
jmp 0x14421
callq 0xf520
movq %rax, -0xc0(%rbp)
jmp 0x14406
movq -0xc0(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x90(%rbp), %rsi
callq *%rax
jmp 0x1441f
jmp 0x14421
leaq -0x90(%rbp), %rdi
callq 0x1bc20
movq -0x98(%rbp), %rdi
addq $0x70, %rdi
callq 0xecd8
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x1bb80
movq -0x98(%rbp), %rdi
callq 0x14320
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1aa10
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
callq 0x146a0
cmpl $0x1, %eax
jne 0x1454e
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x1a8(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0xe8d0
movq -0x1e0(%rbp), %rdi
leaq 0x69492(%rip), %rsi     # 0x7da09
callq 0xe670
movq %rax, -0x1d8(%rbp)
jmp 0x14585
movl $0x30, %edi
callq 0x1bc40
movb %al, -0x1e1(%rbp)
jmp 0x14597
movq -0x1d8(%rbp), %rdi
movb -0x1e1(%rbp), %al
movb %al, -0x1b5(%rbp)
movzbl -0x1b5(%rbp), %esi
callq 0xe9b0
movq %rax, -0x1f0(%rbp)
jmp 0x145bf
movq -0x1f0(%rbp), %rdi
leaq 0x7693(%rip), %rsi      # 0x1bc60
callq 0xe1d0
jmp 0x145d4
jmp 0x145d6
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x14662
movl $0x2, %edi
callq 0x1bc90
movl %eax, -0x1f4(%rbp)
jmp 0x145f4
movl -0x1f4(%rbp), %eax
movl %eax, -0x1bc(%rbp)
movl -0x1bc(%rbp), %esi
leaq -0x1a8(%rbp), %rdi
callq 0xe790
movq %rax, -0x200(%rbp)
jmp 0x1461b
movq -0x200(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0xe8c0
jmp 0x14635
jmp 0x14637
movl -0x24(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x145d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0xe130
jmp 0x14693
movq -0x1d0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xe6b0
jmp 0x14677
leaq -0x1a8(%rbp), %rdi
callq 0xe130
movq -0x1c8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0xeb60
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xe900
movq -0x10(%rbp), %rdi
callq 0xe4e0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xe9a0
jmp 0x14a3f
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe4e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x14acc
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xe9d0
cmpl $0xff, (%rax)
jg 0x14a8d
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xe9d0
movl (%rax), %eax
movb %al, -0x69(%rbp)
jmp 0x14a94
movb $0x3f, %al
movb %al, -0x69(%rbp)
jmp 0x14a94
movb -0x69(%rbp), %al
movsbl %al, %esi
leaq -0x30(%rbp), %rdi
callq 0xe3e0
jmp 0x14aa5
jmp 0x14aa7
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x14a47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xecd8
jmp 0x14aee
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x146c0
jmp 0x14adb
leaq -0x30(%rbp), %rdi
callq 0xecd8
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0xe8d0
movq -0x1a0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xeb40
jmp 0x14e47
cmpl $0xff, -0xc(%rbp)
jle 0x14edb
leaq 0x68bac(%rip), %rsi     # 0x7da07
leaq -0x188(%rbp), %rdi
callq 0xe670
movq %rax, -0x1b8(%rbp)
jmp 0x14e70
movq -0x1b8(%rbp), %rdi
leaq 0x6de2(%rip), %rsi      # 0x1bc60
callq 0xe1d0
movq %rax, -0x1c0(%rbp)
jmp 0x14e8c
movq -0x1c0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xeb40
movq %rax, -0x1c8(%rbp)
jmp 0x14ea4
movq -0x1c8(%rbp), %rdi
leaq 0x68b19(%rip), %rsi     # 0x7d9cb
callq 0xe670
jmp 0x14eb9
jmp 0x14edb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xe130
jmp 0x14f0c
movq -0x1b0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xe6b0
jmp 0x14ef0
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x1a8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0xe8d0
movq -0x1a0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe120
jmp 0x14f69
cmpq $0xff, -0x10(%rbp)
jbe 0x14fff
leaq 0x68a89(%rip), %rsi     # 0x7da07
leaq -0x188(%rbp), %rdi
callq 0xe670
movq %rax, -0x1b8(%rbp)
jmp 0x14f93
movq -0x1b8(%rbp), %rdi
leaq 0x6cbf(%rip), %rsi      # 0x1bc60
callq 0xe1d0
movq %rax, -0x1c0(%rbp)
jmp 0x14faf
movq -0x1c0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe120
movq %rax, -0x1c8(%rbp)
jmp 0x14fc8
movq -0x1c8(%rbp), %rdi
leaq 0x689f5(%rip), %rsi     # 0x7d9cb
callq 0xe670
jmp 0x14fdd
jmp 0x14fff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xe130
jmp 0x15030
movq -0x1b0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xe6b0
jmp 0x15014
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x1a8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0xe8d0
movq -0x1a0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe340
jmp 0x152b9
cmpq $0xff, -0x10(%rbp)
jle 0x1534f
leaq 0x68739(%rip), %rsi     # 0x7da07
leaq -0x188(%rbp), %rdi
callq 0xe670
movq %rax, -0x1b8(%rbp)
jmp 0x152e3
movq -0x1b8(%rbp), %rdi
leaq 0x696f(%rip), %rsi      # 0x1bc60
callq 0xe1d0
movq %rax, -0x1c0(%rbp)
jmp 0x152ff
movq -0x1c0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe340
movq %rax, -0x1c8(%rbp)
jmp 0x15318
movq -0x1c8(%rbp), %rdi
leaq 0x686a5(%rip), %rsi     # 0x7d9cb
callq 0xe670
jmp 0x1532d
jmp 0x1534f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xe130
jmp 0x15380
movq -0x1b0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xe6b0
jmp 0x15364
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x1a8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0xe8d0
movq -0x1a0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe600
jmp 0x153d9
cmpq $0xff, -0x10(%rbp)
jbe 0x1546f
leaq 0x68619(%rip), %rsi     # 0x7da07
leaq -0x188(%rbp), %rdi
callq 0xe670
movq %rax, -0x1b8(%rbp)
jmp 0x15403
movq -0x1b8(%rbp), %rdi
leaq 0x684f(%rip), %rsi      # 0x1bc60
callq 0xe1d0
movq %rax, -0x1c0(%rbp)
jmp 0x1541f
movq -0x1c0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe600
movq %rax, -0x1c8(%rbp)
jmp 0x15438
movq -0x1c8(%rbp), %rdi
leaq 0x68585(%rip), %rsi     # 0x7d9cb
callq 0xe670
jmp 0x1544d
jmp 0x1546f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xe130
jmp 0x154a0
movq -0x1b0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xe6b0
jmp 0x15484
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x1a8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0xea90
testb $0x1, %al
jne 0x15b5d
jmp 0x15ba4
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1c2a0
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x15c10
jmp 0x15b82
leaq -0x38(%rbp), %rdi
callq 0x1c2e0
jmp 0x15bf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c2e0
jmp 0x15bfa
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
xorl %edx, %edx
callq 0x1c320
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x15c10
jmp 0x15bcf
leaq -0x80(%rbp), %rdi
callq 0x180a0
jmp 0x15bf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x180a0
jmp 0x15bfa
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movb 0xb8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x15c40
jmp 0x15c5f
leaq 0x67dcb(%rip), %rdi     # 0x7da12
leaq 0x67de8(%rip), %rsi     # 0x7da36
movl $0x1fc2, %edx           # imm = 0x1FC2
leaq 0x67dec(%rip), %rcx     # 0x7da46
callq 0xe440
movq -0x148(%rbp), %rsi
addq $0x70, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x1ac10
movq -0x148(%rbp), %rsi
movq -0x150(%rbp), %rdi
movl $0x0, -0x18(%rbp)
addq $0x48, %rsi
callq 0xe060
jmp 0x15c9a
leaq -0x88(%rbp), %rdi
callq 0x115c0
jmp 0x15ca8
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x88(%rbp), %rsi
callq *%rax
movb %al, -0x151(%rbp)
jmp 0x15cc4
movb -0x151(%rbp), %al
testb $0x1, %al
jne 0x15d0a
jmp 0x15cd0
movl $0x11, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xe060
jmp 0x15ce9
jmp 0x15d0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x15d86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x15d7a
movq -0x148(%rbp), %rsi
leaq -0x140(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x11f80
jmp 0x15d23
movq -0x148(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x15da0
jmp 0x15d38
leaq -0x140(%rbp), %rdi
callq 0x11fe0
leaq -0x88(%rbp), %rdi
callq 0xecd8
leaq -0x58(%rbp), %rdi
callq 0x1ac90
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x11fe0
leaq -0x88(%rbp), %rdi
callq 0xecd8
leaq -0x58(%rbp), %rdi
callq 0x1ac90
movq -0x60(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xf520
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x12040
testb $0x1, %al
jne 0x15e82
callq 0xf5b0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq *%rax
movq -0x40(%rbp), %rdi
callq 0x19f20
movq %rax, -0x38(%rbp)
jmp 0x15e03
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movb %al, -0x41(%rbp)
jmp 0x15e15
leaq -0x18(%rbp), %rdi
callq 0x18b10
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x15e27
jmp 0x15e4b
movq -0x30(%rbp), %rax
movb $0x1, 0x298(%rax)
jmp 0x15e4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x18b10
jmp 0x15e88
callq 0xf5b0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x15e75
movq -0x30(%rbp), %rax
movl 0x68(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15e80
movq -0x30(%rbp), %rax
movb $0x1, 0x299(%rax)
jmp 0x15e82
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x1c420
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x1c480
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c450
testb $0x1, %al
jne 0x166cc
jmp 0x166e7
leaq -0x20(%rbp), %rdi
callq 0x1c4b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x1c4d0
jmp 0x166f0
movq -0x40(%rbp), %rdi
callq 0x1c510
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x17200
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x16940
jmp 0x172a3
jmp 0x17351
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x17357
movq -0x28(%rbp), %rdi
callq 0xe240
movq %rax, -0x38(%rbp)
leaq -0x39(%rbp), %rdi
movl $0x2, %esi
callq 0x11bf0
jmp 0x172e1
callq 0x10b70
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xe670
movq %rax, -0x48(%rbp)
jmp 0x17309
movq -0x48(%rbp), %rdi
movq 0x9dc24(%rip), %rsi     # 0xb4f38
callq 0xe6f0
jmp 0x1731b
movl $0x1, %edi
callq 0xe7f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x17348
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x11cf0
callq 0xea70
jmp 0x1734f
jmp 0x17357
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xeb60
movq %rax, %rdi
callq 0x1aa10
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x17, %rax
ja 0x18a1a
movq -0x28(%rbp), %rax
leaq 0x64765(%rip), %rcx     # 0x7d048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rdi
leaq 0x653bd(%rip), %rsi     # 0x7dcb4
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x653ac(%rip), %rsi     # 0x7dcb8
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x6539e(%rip), %rsi     # 0x7dcbf
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x65390(%rip), %rsi     # 0x7dcc6
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x65382(%rip), %rsi     # 0x7dccd
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x65374(%rip), %rsi     # 0x7dcd4
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x65366(%rip), %rsi     # 0x7dcdb
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x65358(%rip), %rsi     # 0x7dce2
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x6534a(%rip), %rsi     # 0x7dce9
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x6533f(%rip), %rsi     # 0x7dcf0
callq 0x18a30
jmp 0x18a1a
movq -0x30(%rbp), %rdi
leaq 0x65334(%rip), %rsi     # 0x7dcf7
callq 0x18a30
jmp 0x18a1a
movl $0x10, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x65319(%rip), %rsi     # 0x7dcfe
callq 0xe920
jmp 0x189ec
movq -0x38(%rbp), %rdi
movq 0x9c5d1(%rip), %rsi     # 0xb4fc8
movq 0x9c592(%rip), %rdx     # 0xb4f90
callq 0xeb10
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xe4c0
jmp 0x18a20
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xeb60
nopl (%rax)