LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestSpecParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TestSpecParser& parse( std::string const& arg ) {
            m_mode = None;
            m_exclusion = false;
            m_start = std::string::npos;
            m_arg = m_tagAliases->expandAliases( arg );
            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
                visitChar( m_arg[m_pos] );
            if( m_mode == Name )
                addPattern<TestSpec::NamePattern>();
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq $-0x1, 0x8(%rax)
movq 0x68(%rax), %rsi
movq -0x10(%rbp), %rdx
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x18(%rax)
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
callq 0xe800
leaq -0x30(%rbp), %rdi
callq 0xecd8
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0xe480
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x197a5
movq -0x38(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x10(%rax), %rsi
callq 0xec90
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x29760
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x19752
movq -0x38(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x197b7
movq -0x38(%rbp), %rdi
callq 0x29920
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestSpec::matches(Catch::TestCaseInfo const&) const
bool matches( TestCaseInfo const& testCase ) const {
            // A TestSpec matches if any filter matches
            for( std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
                if( it->matches( testCase ) )
                    return true;
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x28640
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x28670
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x28a30
testb $0x1, %al
jne 0x1a2e1
jmp 0x1a30f
leaq -0x20(%rbp), %rdi
callq 0x2d590
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2d5b0
testb $0x1, %al
jne 0x1a2fc
jmp 0x1a302
movb $0x1, -0x1(%rbp)
jmp 0x1a313
jmp 0x1a304
leaq -0x20(%rbp), %rdi
callq 0x28ac0
jmp 0x1a2ce
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::extractClassName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
        std::string className = classOrQualifiedMethodName;
        if( startsWith( className, "&" ) )
        {
            std::size_t lastColons = className.rfind( "::" );
            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
            if( penultimateColons == std::string::npos )
                penultimateColons = 1;
            className = className.substr( penultimateColons, lastColons-penultimateColons );
        }
        return className;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0xe280
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xeb70
movq -0x88(%rbp), %rdx
leaq 0x6361e(%rip), %rsi     # 0x7dc9d
leaq -0x38(%rbp), %rdi
callq 0x18c80
jmp 0x1a68a
movq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12400
movb %al, -0x99(%rbp)
jmp 0x1a6a2
leaq -0x38(%rbp), %rdi
callq 0xecd8
leaq -0x39(%rbp), %rdi
callq 0xe710
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x1a6c3
jmp 0x1a7a2
movq -0x98(%rbp), %rdi
leaq 0x635ce(%rip), %rsi     # 0x7dc9f
movq $-0x1, %rdx
callq 0xeae0
movq %rax, -0xa8(%rbp)
jmp 0x1a6e6
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdx
decq %rdx
leaq 0x63599(%rip), %rsi     # 0x7dc9f
callq 0xeae0
movq %rax, -0xb0(%rbp)
jmp 0x1a714
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $-0x1, -0x60(%rbp)
jne 0x1a76c
movq $0x1, -0x60(%rbp)
jmp 0x1a76c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1a753
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xecd8
leaq -0x39(%rbp), %rdi
callq 0xe710
jmp 0x1a7c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1a7c8
movq -0x98(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
subq %rdx, %rcx
leaq -0x80(%rbp), %rdi
callq 0xe6d0
jmp 0x1a789
movq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xe800
leaq -0x80(%rbp), %rdi
callq 0xecd8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1a7b8
movq -0x98(%rbp), %rdi
callq 0xecd8
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0xecd8
movq -0x48(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
        if( startsWith( tag, "." ) ||
            tag == "hide" ||
            tag == "!hide" )
            return TestCaseInfo::IsHidden;
        else if( tag == "!throws" )
            return TestCaseInfo::Throws;
        else if( tag == "!shouldfail" )
            return TestCaseInfo::ShouldFail;
        else if( tag == "!mayfail" )
            return TestCaseInfo::MayFail;
        else
            return TestCaseInfo::None;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xeb70
movq -0x50(%rbp), %rdx
leaq 0x63e64(%rip), %rsi     # 0x7ed20
leaq -0x30(%rbp), %rdi
callq 0x18c80
jmp 0x1aec7
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12400
movb %al, -0x59(%rbp)
jmp 0x1aed9
movb -0x59(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x5a(%rbp)
jne 0x1af29
jmp 0x1aee8
movq -0x10(%rbp), %rdi
leaq 0x62e19(%rip), %rsi     # 0x7dd0c
callq 0x1c1d0
movb %al, -0x5b(%rbp)
jmp 0x1aefd
movb -0x5b(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x5a(%rbp)
jne 0x1af29
jmp 0x1af0c
movq -0x10(%rbp), %rdi
leaq 0x62df4(%rip), %rsi     # 0x7dd0b
callq 0x1c1d0
movb %al, -0x5c(%rbp)
jmp 0x1af21
movb -0x5c(%rbp), %al
movb %al, -0x5a(%rbp)
jmp 0x1af29
movb -0x5a(%rbp), %al
movb %al, -0x5d(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0x1af4a
jmp 0x1af84
movl $0x2, -0x4(%rbp)
jmp 0x1afe8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1af79
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 0x1aff1
movq -0x10(%rbp), %rdi
leaq 0x62d82(%rip), %rsi     # 0x7dd11
callq 0x1c1d0
testb $0x1, %al
jne 0x1af9a
jmp 0x1afa3
movl $0x10, -0x4(%rbp)
jmp 0x1afe8
movq -0x10(%rbp), %rdi
leaq 0x62d6b(%rip), %rsi     # 0x7dd19
callq 0x1c1d0
testb $0x1, %al
jne 0x1afb9
jmp 0x1afc2
movl $0x4, -0x4(%rbp)
jmp 0x1afe8
movq -0x10(%rbp), %rdi
leaq 0x62d58(%rip), %rsi     # 0x7dd25
callq 0x1c1d0
testb $0x1, %al
jne 0x1afd8
jmp 0x1afe1
movl $0x8, -0x4(%rbp)
jmp 0x1afe8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::enforceNotReservedTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
        if( isReservedTag( tag ) ) {
            {
                Colour colourGuard( Colour::Red );
                Catch::cerr()
                    << "Tag name [" << tag << "] not allowed.\n"
                    << "Tag names starting with non alpha-numeric characters are reserved\n";
            }
            {
                Colour colourGuard( Colour::FileName );
                Catch::cerr() << _lineInfo << std::endl;
            }
            exit(1);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33f70
testb $0x1, %al
jne 0x1b022
jmp 0x1b106
leaq -0x11(%rbp), %rdi
movl $0x2, %esi
callq 0x11bf0
callq 0x10b70
movq %rax, %rdi
leaq 0x62cef(%rip), %rsi     # 0x7dd2e
callq 0xe670
movq %rax, -0x30(%rbp)
jmp 0x1b04a
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xe5a0
movq %rax, -0x38(%rbp)
jmp 0x1b05d
movq -0x38(%rbp), %rdi
leaq 0x62cd1(%rip), %rsi     # 0x7dd39
callq 0xe670
movq %rax, -0x40(%rbp)
jmp 0x1b073
movq -0x40(%rbp), %rdi
leaq 0x62ccb(%rip), %rsi     # 0x7dd49
callq 0xe670
jmp 0x1b085
leaq -0x11(%rbp), %rdi
callq 0x11cf0
leaq -0x25(%rbp), %rdi
movl $0x17, %esi
callq 0x11bf0
callq 0x10b70
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x10b20
movq %rax, -0x48(%rbp)
jmp 0x1b0b3
movq -0x48(%rbp), %rdi
movq 0x99e7a(%rip), %rsi     # 0xb4f38
callq 0xe6f0
jmp 0x1b0c5
leaq -0x25(%rbp), %rdi
callq 0x11cf0
movl $0x1, %edi
callq 0xe7f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x11cf0
jmp 0x1b10c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x11cf0
jmp 0x1b10c
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::fpToString<double>(double, int)
std::string fpToString( T value, int precision ) {
    std::ostringstream oss;
    oss << std::setprecision( precision )
        << std::fixed
        << value;
    std::string d = oss.str();
    std::size_t i = d.find_last_not_of( '0' );
    if( i != std::string::npos && i != d.size()-1 ) {
        if( d[i] == '.' )
            i++;
        d = d.substr( 0, i+1 );
    }
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xe8d0
movl -0x14(%rbp), %edi
callq 0x5cf70
movl %eax, -0x1d4(%rbp)
jmp 0x1bda4
movl -0x1d4(%rbp), %eax
movl %eax, -0x194(%rbp)
movl -0x194(%rbp), %esi
leaq -0x190(%rbp), %rdi
callq 0xe9e0
movq %rax, -0x1f0(%rbp)
jmp 0x1bdcb
movq -0x1f0(%rbp), %rdi
leaq 0x411b7(%rip), %rsi     # 0x5cf90
callq 0xe1d0
movq %rax, -0x1f8(%rbp)
jmp 0x1bde7
movq -0x1f8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0xec10
jmp 0x1bdfa
movq -0x1e8(%rbp), %rdi
movb $0x0, -0x1a5(%rbp)
leaq -0x190(%rbp), %rsi
callq 0xe6b0
jmp 0x1be16
movq -0x1e8(%rbp), %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0xe460
movq %rax, -0x1b0(%rbp)
cmpq $-0x1, -0x1b0(%rbp)
je 0x1bf2c
movq -0x1e8(%rbp), %rdi
movq -0x1b0(%rbp), %rax
movq %rax, -0x200(%rbp)
callq 0xe480
movq %rax, %rcx
movq -0x200(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x1bf2c
movq -0x1e8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
callq 0xec90
movq %rax, -0x208(%rbp)
jmp 0x1be90
movq -0x208(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x1beea
movq -0x1b0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1b0(%rbp)
jmp 0x1beea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x1bf64
movq -0x1e8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
callq 0xecd8
jmp 0x1bf64
movq -0x1e8(%rbp), %rsi
movq -0x1b0(%rbp), %rcx
incq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x1d0(%rbp), %rdi
callq 0xe6d0
jmp 0x1bf0d
movq -0x1e8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xe800
leaq -0x1d0(%rbp), %rdi
callq 0xecd8
movb $0x1, -0x1a5(%rbp)
testb $0x1, -0x1a5(%rbp)
jne 0x1bf48
movq -0x1e8(%rbp), %rdi
callq 0xecd8
leaq -0x190(%rbp), %rdi
callq 0xe130
movq -0x1e0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0xe130
movq -0x1a0(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Session::Session()
Session()
        : m_cli( makeCommandLineParser() ) {
            if( alreadyInstantiated ) {
                std::string msg = "Only one instance of Catch::Session can ever be used";
                Catch::cerr() << msg << std::endl;
                throw std::logic_error( msg );
            }
            alreadyInstantiated = true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1ba70
movq -0x50(%rbp), %rdi
leaq 0x97129(%rip), %rax     # 0xb4160
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x37460
jmp 0x1d049
movq -0x50(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x60(%rbp)
callq 0x39fc0
movq -0x50(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x58(%rbp)
callq 0x39fe0
jmp 0x1d06d
movq -0x50(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq %rdi, -0x68(%rbp)
callq 0x3a0a0
jmp 0x1d083
testb $0x1, 0x986c0(%rip)     # 0xb574a
je 0x1d192
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xeb70
movq -0x70(%rbp), %rdx
leaq 0x60cf1(%rip), %rsi     # 0x7dd99
leaq -0x38(%rbp), %rdi
callq 0x18c80
jmp 0x1d0b3
leaq -0x39(%rbp), %rdi
callq 0xe710
callq 0x10b70
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0xe5a0
movq %rax, -0x78(%rbp)
jmp 0x1d0d3
movq -0x78(%rbp), %rdi
movq 0x97e5a(%rip), %rsi     # 0xb4f38
callq 0xe6f0
jmp 0x1d0e5
movl $0x10, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xe950
jmp 0x1d104
movq -0x80(%rbp), %rdi
movq 0x97eb9(%rip), %rsi     # 0xb4fc8
movq 0x97e7a(%rip), %rdx     # 0xb4f90
callq 0xeb10
jmp 0x1d1d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1d1c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1d1b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1d1ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xe710
jmp 0x1d1a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1d187
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xe4c0
leaq -0x38(%rbp), %rdi
callq 0xecd8
jmp 0x1d1a2
movb $0x1, 0x985b1(%rip)     # 0xb574a
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3a0c0
movq -0x58(%rbp), %rdi
callq 0x3a100
movq -0x60(%rbp), %rdi
callq 0x3a160
movq -0x48(%rbp), %rdi
callq 0x3a1c0
movq -0x50(%rbp), %rdi
callq 0x14320
movq -0x10(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::close()
virtual void close() CATCH_OVERRIDE {

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

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

                case NeedsAnotherRun:
                    break;;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25930
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
je 0x1e132
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25930
movq %rax, %rdi
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x1e104
movq -0x20(%rbp), %rax
movl 0x58(%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0x1e205
movq -0x28(%rbp), %rax
leaq 0x5eece(%rip), %rcx     # 0x7d020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x10, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x60503(%rip), %rsi     # 0x7e679
callq 0xe920
jmp 0x1e17d
movq -0x30(%rbp), %rdi
movq 0x96e40(%rip), %rsi     # 0xb4fc8
movq 0x96e01(%rip), %rdx     # 0xb4f90
callq 0xeb10
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xe4c0
jmp 0x1e271
jmp 0x1e255
movq -0x20(%rbp), %rax
movl $0x4, 0x58(%rax)
jmp 0x1e255
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x485e0
testb $0x1, %al
jne 0x1e1f8
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x486f0
movq %rax, %rdi
callq 0x48730
movq %rax, %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x1e1f8
jmp 0x1e203
movq -0x20(%rbp), %rax
movl $0x4, 0x58(%rax)
jmp 0x1e255
movl $0x10, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x60469(%rip), %rsi     # 0x7e689
callq 0xe920
jmp 0x1e227
movq -0x38(%rbp), %rdi
movq 0x96d96(%rip), %rsi     # 0xb4fc8
movq 0x96d57(%rip), %rdx     # 0xb4f90
callq 0xeb10
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xe4c0
jmp 0x1e271
movq -0x20(%rbp), %rdi
callq 0x48750
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x487b0
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::fail()
virtual void fail() CATCH_OVERRIDE {
            m_runState = Failed;
            if( m_parent )
                m_parent->markAsNeedingAnotherRun();
            moveToParent();
            m_ctx.completeCycle();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x5, 0x58(%rax)
cmpq $0x0, 0x38(%rax)
je 0x1e2b0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x10(%rbp), %rdi
callq 0x48750
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x487b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::findChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual ITracker* findChild( std::string const& name ) CATCH_OVERRIDE {
            Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( name ) );
            return( it != m_children.end() )
                ? it->get()
                : CATCH_NULL;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x40, %rdi
movq %rdi, -0x80(%rbp)
callq 0x48d50
movq -0x80(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x487d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x493b0
movq -0x78(%rbp), %rdx
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x492d0
movq %rax, -0x70(%rbp)
jmp 0x1e384
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x493e0
leaq -0x50(%rbp), %rdi
callq 0x49420
movq -0x88(%rbp), %rdi
addq $0x40, %rdi
callq 0x487d0
movq %rax, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x49440
testb $0x1, %al
jne 0x1e3c9
jmp 0x1e3e3
leaq -0x18(%rbp), %rdi
callq 0x49480
movq %rax, %rdi
callq 0x2c3b0
movq %rax, -0x90(%rbp)
jmp 0x1e3ee
xorl %eax, %eax
movq %rax, -0x90(%rbp)
jmp 0x1e3ee
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x49420
movq -0x58(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::openChild()
virtual void openChild() CATCH_OVERRIDE {
            if( m_runState != ExecutingChildren ) {
                m_runState = ExecutingChildren;
                if( m_parent )
                    m_parent->openChild();
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x2, 0x58(%rax)
je 0x1e45c
movq -0x10(%rbp), %rax
movl $0x2, 0x58(%rax)
cmpq $0x0, 0x38(%rax)
je 0x1e45a
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
jmp 0x1e45c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestRegistry::getAllTestsSorted(Catch::IConfig const&) const
virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const {
            if( m_sortedFunctions.empty() )
                enforceNoDuplicateTestCases( m_functions );

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
callq 0x49940
testb $0x1, %al
jne 0x1e507
jmp 0x1e514
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x108a0
movq -0x30(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jne 0x1e544
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x49940
testb $0x1, %al
jne 0x1e544
jmp 0x1e586
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rsi
addq $0x8, %rdx
leaq -0x28(%rbp), %rdi
callq 0x49980
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
leaq -0x28(%rbp), %rsi
callq 0x49a90
leaq -0x28(%rbp), %rdi
callq 0x1a5d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x28, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::TestRegistry::registerTest(Catch::TestCase const&)
virtual void registerTest( TestCase const& testCase ) {
            std::string name = testCase.getTestCaseInfo().name;
            if( name == "" ) {
                std::ostringstream oss;
                oss << "Anonymous test case " << ++m_unnamedCount;
                return registerTest( testCase.withName( oss.str() ) );
            }
            m_functions.push_back( testCase );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x308(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10b80
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x300(%rbp)
callq 0xe280
movq -0x300(%rbp), %rdi
leaq 0x60442(%rip), %rsi     # 0x7ea2a
callq 0x1c1d0
movb %al, -0x2f5(%rbp)
jmp 0x1e5f5
movb -0x2f5(%rbp), %al
testb $0x1, %al
jne 0x1e604
jmp 0x1e732
leaq -0x1b8(%rbp), %rdi
callq 0xe8d0
jmp 0x1e612
leaq 0x600bb(%rip), %rsi     # 0x7e6d4
leaq -0x1b8(%rbp), %rdi
callq 0xe670
movq %rax, -0x310(%rbp)
jmp 0x1e62e
movq -0x310(%rbp), %rdi
movq -0x308(%rbp), %rax
movq 0x40(%rax), %rsi
incq %rsi
movq %rsi, 0x40(%rax)
callq 0xe120
jmp 0x1e64e
movq -0x10(%rbp), %rax
movq %rax, -0x318(%rbp)
leaq -0x2f0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xe6b0
jmp 0x1e66e
movq -0x318(%rbp), %rsi
leaq -0x2d0(%rbp), %rdi
leaq -0x2f0(%rbp), %rdx
callq 0x12940
jmp 0x1e68a
movq -0x308(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x2d0(%rbp), %rsi
callq *%rax
jmp 0x1e6a3
leaq -0x2d0(%rbp), %rdi
callq 0x1a7e0
leaq -0x2f0(%rbp), %rdi
callq 0xecd8
movl $0x1, -0x2f4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xe130
jmp 0x1e752
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1e764
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1e724
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1e718
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2d0(%rbp), %rdi
callq 0x1a7e0
leaq -0x2f0(%rbp), %rdi
callq 0xecd8
leaq -0x1b8(%rbp), %rdi
callq 0xe130
jmp 0x1e764
movq -0x308(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x1a560
jmp 0x1e748
movl $0x0, -0x2f4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xecd8
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xecd8
movq -0x38(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CumulativeReporterBase::assertionEnded(Catch::AssertionStats const&)
virtual bool assertionEnded( AssertionStats const& assertionStats ) {
            assert( !m_sectionStack.empty() );
            SectionNode& sectionNode = *m_sectionStack.back();
            sectionNode.assertions.push_back( assertionStats );
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xa8, %rdi
callq 0x4cb90
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ee4c
jmp 0x1ee4e
jmp 0x1ee6d
leaq 0x5f894(%rip), %rdi     # 0x7e6e9
leaq 0x5ebda(%rip), %rsi     # 0x7da36
movl $0x2193, %edx           # imm = 0x2193
leaq 0x5f899(%rip), %rcx     # 0x7e701
callq 0xe440
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
callq 0x4cd50
movq %rax, %rdi
callq 0x4cd90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
movq -0x10(%rbp), %rsi
callq 0x4e140
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CumulativeReporterBase::sectionEnded(Catch::SectionStats const&)
virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
            assert( !m_sectionStack.empty() );
            SectionNode& node = *m_sectionStack.back();
            node.stats = sectionStats;
            m_sectionStack.pop_back();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xa8, %rdi
callq 0x4cb90
xorb $-0x1, %al
testb $0x1, %al
jne 0x1eedc
jmp 0x1eede
jmp 0x1eefd
leaq 0x5f804(%rip), %rdi     # 0x7e6e9
leaq 0x5eb4a(%rip), %rsi     # 0x7da36
movl $0x2199, %edx           # imm = 0x2199
leaq 0x5f85c(%rip), %rcx     # 0x7e754
callq 0xe440
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
callq 0x4cd50
movq %rax, %rdi
callq 0x4cd90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x4eef0
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
callq 0x4ef40
addq $0x20, %rsp
popq %rbp
retq
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CumulativeReporterBase::testCaseEnded(Catch::TestCaseStats const&)
virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
            Ptr<TestCaseNode> node = new TestCaseNode( testCaseStats );
            assert( m_sectionStack.size() == 0 );
            node->children.push_back( m_rootSection );
            m_testCases.push_back( node );
            m_rootSection.reset();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1b8, %edi            # imm = 0x1B8
callq 0xe680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4efd0
jmp 0x1ef77
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x4f040
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
callq 0x4dd80
cmpq $0x0, %rax
jne 0x1ef9c
jmp 0x1efda
leaq 0x5f800(%rip), %rdi     # 0x7e7a3
leaq 0x5ea8c(%rip), %rsi     # 0x7da36
movl $0x21a0, %edx           # imm = 0x21A0
leaq 0x5f808(%rip), %rcx     # 0x7e7be
callq 0xe440
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x1b8, %esi            # imm = 0x1B8
callq 0xe6a0
jmp 0x1f0f8
leaq -0x18(%rbp), %rdi
callq 0x4f080
movq %rax, -0x40(%rbp)
jmp 0x1efe9
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
addq $0x98, %rsi
callq 0x4cf20
jmp 0x1f006
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
leaq -0x18(%rbp), %rsi
callq 0x4f0a0
jmp 0x1f019
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
callq 0x4f110
jmp 0x1f02b
movq -0x38(%rbp), %rdi
addq $0xa0, %rdi
callq 0x4f150
movq %rax, -0x48(%rbp)
jmp 0x1f041
movq -0x48(%rbp), %rax
cmpq $0x0, %rax
je 0x1f04d
jmp 0x1f083
leaq 0x5f7bb(%rip), %rdi     # 0x7e80f
leaq 0x5e9db(%rip), %rsi     # 0x7da36
movl $0x21a5, %edx           # imm = 0x21A5
leaq 0x5f757(%rip), %rcx     # 0x7e7be
callq 0xe440
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4f180
jmp 0x1f0f8
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x148, %rax            # imm = 0x148
movq %rax, -0x50(%rbp)
addq $0xa0, %rdi
callq 0x4d7e0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
addq $0xd8, %rdi
callq 0xe060
jmp 0x1f0b6
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x58(%rbp)
addq $0xa0, %rdi
callq 0x4d7e0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
addq $0xf8, %rdi
callq 0xe060
jmp 0x1f0e9
leaq -0x18(%rbp), %rdi
callq 0x4f180
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::CumulativeReporterBase::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
            node->children.swap( m_testGroups );
            m_testRuns.push_back( node );
            testRunEndedCumulative();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x88, %edi
callq 0xe680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x50c00
jmp 0x1f217
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x50c70
movq -0x48(%rbp), %rdi
callq 0x50cb0
movq %rax, -0x40(%rbp)
jmp 0x1f237
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x70, %rdi
addq $0x68, %rsi
callq 0x50cd0
movq -0x38(%rbp), %rdi
subq $-0x80, %rdi
leaq -0x18(%rbp), %rsi
callq 0x50d30
jmp 0x1f25f
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
callq *%rax
jmp 0x1f271
leaq -0x18(%rbp), %rdi
callq 0x50da0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x88, %esi
callq 0xe6a0
jmp 0x1f2b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x50da0
movq -0x20(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::testRunStarting(Catch::TestRunInfo const&)
virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_OVERRIDE {
            StreamingReporterBase::testRunStarting( testInfo );
            m_xml.setStream( stream );
            m_xml.startElement( "Catch" );
            if( !m_config->name().empty() )
                m_xml.writeAttribute( "name", m_config->name() );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e890
movq -0xc8(%rbp), %rax
movq %rax, %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movq %rdi, -0xc0(%rbp)
movq 0x18(%rax), %rsi
callq 0x51a90
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xeb70
movq -0xb8(%rbp), %rdx
leaq 0x5f4ba(%rip), %rsi     # 0x7e820
leaq -0x30(%rbp), %rdi
callq 0x18c80
jmp 0x1f371
movq -0xc0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x51ab0
jmp 0x1f383
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
movq -0xc8(%rbp), %rdi
addq $0x10, %rdi
callq 0x19f20
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x68(%rbp), %rdi
callq *0x30(%rax)
leaq -0x68(%rbp), %rdi
callq 0xea90
xorb $-0x1, %al
movb %al, -0xc9(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xecd8
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x1f3db
jmp 0x1f50e
movq -0xc8(%rbp), %rax
addq $0x1d8, %rax            # imm = 0x1D8
movq %rax, -0xe0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xeb70
movq -0xd8(%rbp), %rdx
leaq 0x5eb42(%rip), %rsi     # 0x7df52
leaq -0x88(%rbp), %rdi
callq 0x18c80
jmp 0x1f41e
movq -0xc8(%rbp), %rdi
addq $0x10, %rdi
callq 0x19f20
movq %rax, -0xe8(%rbp)
jmp 0x1f437
movq -0xe8(%rbp), %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0xb0(%rbp), %rdi
callq *%rax
jmp 0x1f450
movq -0xe0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x51b40
jmp 0x1f46c
leaq -0xb0(%rbp), %rdi
callq 0xecd8
leaq -0x88(%rbp), %rdi
callq 0xecd8
leaq -0x89(%rbp), %rdi
callq 0xe710
jmp 0x1f50e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f4b5
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 0x1f517
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f4f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xecd8
leaq -0x88(%rbp), %rdi
callq 0xecd8
leaq -0x89(%rbp), %rdi
callq 0xe710
jmp 0x1f517
addq $0xf0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::testCaseStarting(Catch::TestCaseInfo const&)
virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
            StreamingReporterBase::testCaseStarting(testInfo);
            m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) );

            if ( m_config->showDurations() == ShowDurations::Always )
                m_testCaseTimer.start();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e8f0
movq -0xa8(%rbp), %rax
addq $0x1d8, %rax            # imm = 0x1D8
movq %rax, -0xa0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xeb70
movq -0x98(%rbp), %rdx
leaq 0x5f191(%rip), %rsi     # 0x7e84a
leaq -0x30(%rbp), %rdi
callq 0x18c80
jmp 0x1f6c4
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x51ab0
movq %rax, -0xb0(%rbp)
jmp 0x1f6dd
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xeb70
movq -0xb8(%rbp), %rdx
leaq 0x5e857(%rip), %rsi     # 0x7df52
leaq -0x68(%rbp), %rdi
callq 0x18c80
jmp 0x1f706
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x13970
jmp 0x1f718
movq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x51b40
jmp 0x1f731
leaq -0x90(%rbp), %rdi
callq 0xecd8
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x69(%rbp), %rdi
callq 0xe710
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
callq 0x19f20
movq %rax, %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x1f80e
movq -0xa8(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x13730
jmp 0x1f80e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f803
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f7fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f7f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f7e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xecd8
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x69(%rbp), %rdi
callq 0xe710
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x1f817
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::XmlReporter::sectionStarting(Catch::SectionInfo const&)
virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
            StreamingReporterBase::sectionStarting( sectionInfo );
            if( m_sectionDepth++ > 0 ) {
                m_xml.startElement( "Section" )
                    .writeAttribute( "name", trim( sectionInfo.name ) )
                    .writeAttribute( "description", sectionInfo.description );
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e920
movq -0xc0(%rbp), %rcx
movl 0x220(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x220(%rcx)
cmpl $0x0, %eax
jle 0x1fa5f
movq -0xc0(%rbp), %rax
addq $0x1d8, %rax            # imm = 0x1D8
movq %rax, -0xd0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xeb70
movq -0xc8(%rbp), %rdx
leaq 0x5ef7e(%rip), %rsi     # 0x7e818
leaq -0x30(%rbp), %rdi
callq 0x18c80
jmp 0x1f8a5
movq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x51ab0
movq %rax, -0xd8(%rbp)
jmp 0x1f8be
leaq -0x69(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xeb70
movq -0xe0(%rbp), %rdx
leaq 0x5e676(%rip), %rsi     # 0x7df52
leaq -0x68(%rbp), %rdi
callq 0x18c80
jmp 0x1f8e7
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x13970
jmp 0x1f8f9
movq -0xd8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x51b40
movq %rax, -0xe8(%rbp)
jmp 0x1f919
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xeb70
movq -0xf0(%rbp), %rdx
leaq 0x5ef19(%rip), %rsi     # 0x7e853
leaq -0xb0(%rbp), %rdi
callq 0x18c80
jmp 0x1f948
movq -0xe8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
leaq -0xb0(%rbp), %rsi
callq 0x51b40
jmp 0x1f965
leaq -0xb0(%rbp), %rdi
callq 0xecd8
leaq -0xb1(%rbp), %rdi
callq 0xe710
leaq -0x90(%rbp), %rdi
callq 0xecd8
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x69(%rbp), %rdi
callq 0xe710
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x1fa5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1fa54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1fa4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1fa42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1fa39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1fa2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1fa21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xecd8
leaq -0xb1(%rbp), %rdi
callq 0xe710
leaq -0x90(%rbp), %rdi
callq 0xecd8
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x69(%rbp), %rdi
callq 0xe710
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
jmp 0x1fa68
addq $0xf0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::JunitReporter::testGroupStarting(Catch::GroupInfo const&)
virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
            suiteTimer.start();
            stdOutForSuite.str("");
            stdErrForSuite.str("");
            unexpectedExceptions = 0;
            CumulativeReporterBase::testGroupStarting( groupInfo );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x110, %rdi            # imm = 0x110
callq 0x13730
movq -0x88(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xeb70
movq -0x78(%rbp), %rdx
leaq 0x5d0d7(%rip), %rsi     # 0x7ea2a
leaq -0x30(%rbp), %rdi
callq 0x18c80
jmp 0x2195e
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe2c0
jmp 0x2196d
leaq -0x30(%rbp), %rdi
callq 0xecd8
leaq -0x31(%rbp), %rdi
callq 0xe710
movq -0x88(%rbp), %rax
addq $0x290, %rax            # imm = 0x290
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xeb70
movq -0x90(%rbp), %rdx
leaq 0x5d079(%rip), %rsi     # 0x7ea2a
leaq -0x68(%rbp), %rdi
callq 0x18c80
jmp 0x219bc
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xe2c0
jmp 0x219ce
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x69(%rbp), %rdi
callq 0xe710
movq -0x88(%rbp), %rdi
movl $0x0, 0x408(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1ea70
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x21a26
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 0x21a5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x21a54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xecd8
leaq -0x69(%rbp), %rdi
callq 0xe710
movq -0x40(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::assertionEnded(Catch::AssertionStats const&)
virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE {
            AssertionResult const& result = _assertionStats.assertionResult;

            bool printInfoMessages = true;

            // Drop out if result was successful and we're not printing those
            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
                if( result.getResultType() != ResultWas::Warning )
                    return false;
                printInfoMessages = false;
            }

            lazyPrint();

            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
            printer.print();
            stream << std::endl;
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
addq $0x10, %rdi
callq 0x19f20
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x21cde
movq -0x20(%rbp), %rdi
callq 0x12040
testb $0x1, %al
jne 0x21cc3
jmp 0x21cde
movq -0x20(%rbp), %rdi
callq 0x12090
cmpl $0x2, %eax
je 0x21cda
movb $0x0, -0x1(%rbp)
jmp 0x21d6c
movb $0x0, -0x21(%rbp)
movq -0xe0(%rbp), %rdi
callq 0x54940
movq -0xe0(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x21(%rbp), %ecx
andl $0x1, %ecx
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x549a0
movq -0xe8(%rbp), %rdi
callq 0x54e20
jmp 0x21d21
movq -0xe0(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x93205(%rip), %rsi     # 0xb4f38
callq 0xe6f0
jmp 0x21d3a
movb $0x1, -0x1(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x54ec0
jmp 0x21d6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x54ec0
jmp 0x21d7a
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::testGroupEnded(Catch::TestGroupStats const&)
virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE {
            if( currentGroupInfo.used ) {
                printSummaryDivider();
                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
                printTotals( _testGroupStats.totals );
                stream << "\n" << std::endl;
            }
            StreamingReporterBase::testGroupEnded( _testGroupStats );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x88(%rax)
je 0x22071
movq -0x18(%rbp), %rdi
callq 0x55f00
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x5cbc9(%rip), %rsi     # 0x7ebe2
callq 0xe670
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x5cbbe(%rip), %rsi     # 0x7ebf6
callq 0xe670
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x55f40
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x5c9cc(%rip), %rsi     # 0x7ea29
callq 0xe670
movq %rax, %rdi
movq 0x92ecc(%rip), %rsi     # 0xb4f38
callq 0xe6f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e9b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ConsoleReporter::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE {
            printTotalsDivider( _testRunStats.totals );
            printTotals( _testRunStats.totals );
            stream << std::endl;
            StreamingReporterBase::testRunEnded( _testRunStats );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x57db0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x55f40
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x92e63(%rip), %rsi     # 0xb4f38
callq 0xe6f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e9e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)