LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/memFN-bind.cc
// Function: main
int main()
{
    vector<string> svec = {"hi", "bye"};
    // bind each string in the range to the implicit first argument to empty
    auto it = find_if(svec.begin(), svec.end(), 
	                  bind(&string::empty, _1));
    if (it == svec.end()) 
		cout << "worked" << endl; 
	else 
		cout << "failed"  << endl;
	auto f =  bind(&string::empty, _1);
	f(*svec.begin()); // ok: argument is a string f will use .* to call empty
	f(&svec[0]); // ok: argument is a pointer to string f will use .-> to call empty
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
movw $0x6968, (%rax)         # imm = 0x6968
movq $0x2, -0x8(%rax)
movb $0x0, 0x2(%rax)
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movl $0x657962, (%rbx)       # imm = 0x657962
movq $0x3, -0x8(%rbx)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x11(%rbp), %rcx
movl $0x2, %edx
callq 0x1406
movq $-0x40, %r14
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0x1347
movq (%rbx), %rsi
incq %rsi
callq 0x10f0
addq $-0x20, %rbx
addq $0x20, %r14
jne 0x1333
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq 0x2c78(%rip), %rax      # 0x3fd8
leaq -0x70(%rbp), %rdx
movq %rax, (%rdx)
movq $0x0, 0x8(%rdx)
callq 0x16b3
cmpq -0x28(%rbp), %rax
leaq 0xc89(%rip), %rax       # 0x2008
leaq 0xc89(%rip), %rsi       # 0x200f
cmoveq %rax, %rsi
movq 0x2c3f(%rip), %rbx      # 0x3fd0
movl $0x6, %edx
movq %rbx, %rdi
callq 0x1100
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq 0x2c14(%rip), %rdi      # 0x3fd0
callq 0x1030
movq %rax, %rdi
callq 0x1080
leaq -0x30(%rbp), %rdi
callq 0x144e
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x13f1
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1170
jmp 0x13fd
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x144e
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/MaxCounters.cpp
// Function: solution(int, std::vector<int, std::allocator<int>>&)
vector<int> solution(int N, vector<int> &A) {
	vector<int> counters(N, 0);
	int max = 0;
	int lastMax = 0;
	for (int i = 0; i < A.size(); i++) {
		int op = A[i];
		if (op >= 1 && op <= N) {
			int count = counters[op - 1];
			if (count < lastMax) {
				count = lastMax;
			}
			count++;
			if (count > max) {
				max = count;
			}
			counters[op - 1] = count;
		} else if (op == N + 1) {
			lastMax = max;
		}
	}
	for (int i = 0; i < N; i++) {
		if (counters[i] < lastMax) {
			counters[i] = lastMax;
		}
	}
	return counters;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movslq %esi, %rsi
leaq -0x20(%rbp), %rdx
movl $0x0, (%rdx)
leaq -0x19(%rbp), %rcx
callq 0x1428
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
je 0x12b2
sarq $0x2, %rdx
movq (%rbx), %rsi
cmpq $0x1, %rdx
adcq $0x0, %rdx
leal 0x1(%r14), %edi
xorl %r8d, %r8d
xorl %eax, %eax
xorl %r9d, %r9d
movl (%rcx,%r8,4), %r10d
testl %r10d, %r10d
setle %r11b
cmpl %r14d, %r10d
setg %r15b
orb %r11b, %r15b
je 0x128c
cmpl %edi, %r10d
cmovel %r9d, %eax
jmp 0x12a8
movl -0x4(%rsi,%r10,4), %r11d
cmpl %eax, %r11d
cmovlel %eax, %r11d
leal 0x1(%r11), %r15d
cmpl %r9d, %r11d
cmovgel %r15d, %r9d
movl %r15d, -0x4(%rsi,%r10,4)
incq %r8
cmpq %r8, %rdx
jne 0x126c
jmp 0x12b4
xorl %eax, %eax
testl %r14d, %r14d
jle 0x12d1
movq (%rbx), %rcx
movl %r14d, %edx
xorl %esi, %esi
cmpl %eax, (%rcx,%rsi,4)
jge 0x12c9
movl %eax, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x12c1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/MaxCounters.cpp
// Function: main
int main() {
	vector<int> A(7);
	A[0] = 3;
	A[1] = 4;
	A[2] = 4;
	A[3] = 6;
	A[4] = 1;
	A[5] = 4;
	A[6] = 4;
	vector<int> counters = solution(5, A);
	for (int i = 0; i < counters.size(); i++) {
		cout << counters[i] << ',';
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0x1c, %edi
callq 0x1070
movq %rax, %rbx
movq %rax, (%r14)
movq %rax, 0x8(%r14)
addq $0x1c, %rax
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0xc(%rbx)
movq %rax, 0x8(%r14)
movaps 0xcde(%rip), %xmm0      # 0x2010
movups %xmm0, (%rbx)
movabsq $0x400000001, %rax      # imm = 0x400000001
movq %rax, 0x10(%rbx)
movl $0x4, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
movl $0x5, %esi
movq %r14, %rdx
callq 0x121c
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x13aa
xorl %r12d, %r12d
movq 0x2c69(%rip), %r14      # 0x3fd8
leaq -0x21(%rbp), %r15
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x10b0
movb $0x2c, -0x21(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
incq %r12
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x1373
leaq -0x21(%rbp), %rsi
movb $0xa, (%rsi)
movq 0x2c20(%rip), %rdi      # 0x3fd8
movl $0x1, %edx
callq 0x1090
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x13d7
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x1080
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x1080
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13fa
movq %rax, %r14
jmp 0x1412
movq %rax, %r14
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1412
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x1080
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x1080
movq %r14, %rdi
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH04_Expressions/examples/prec.cc
// Function: main
int main() 
{
	cout << 6 + 3 * 4 / 2 + 2 << endl;

	// parentheses in this expression match default precedence and associativity
	cout << ((6 + ((3 * 4) / 2)) + 2) << endl; // prints 14

	int temp = 3 * 4;         // 12
	int temp2 = temp / 2;     // 6
	int temp3 = temp2 + 6;    // 12
	int result = temp3 + 2;   // 14
	cout << result << endl;

	// parentheses result in alternative groupings
	cout << (6 + 3) * (4 / 2 + 2) << endl;     // prints 36
	cout << ((6 + 3) * 4) / 2 + 2 << endl;     // prints 20
	cout << 6 + 3 * 4 / (2 + 2) << endl;       // prints 9

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2dfe(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
movl $0xe, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0xe, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0xe, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0x24, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0x14, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0x9, %esi
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::AutoReg::registerTestCase(Catch::ITestCase*, char const*, Catch::NameAndDesc const&, Catch::SourceLineInfo const&)
void AutoReg::registerTestCase( ITestCase* testCase,
                                    char const* classOrQualifiedMethodName,
                                    NameAndDesc const& nameAndDesc,
                                    SourceLineInfo const& lineInfo ) {

        getMutableRegistryHub().registerTest
            ( makeTestCase( testCase,
                            extractClassName( classOrQualifiedMethodName ),
                            nameAndDesc.name,
                            nameAndDesc.description,
                            lineInfo ) );
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
callq 0xb36b
movq %rax, %rbx
leaq 0x70(%rsp), %rbp
leaq 0xf(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x10f70
leaq 0x50(%rsp), %rdi
movq %rbp, %rsi
callq 0x10e31
movq (%r12), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x10f70
movq 0x8(%r12), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x10f70
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %r15, %rsi
movq %r14, %r9
callq 0xb436
movq (%rbx), %rax
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0xb232
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x90(%rsp), %rdi
callq 0x11296
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb25a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb275
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb290
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb2b1
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xa330
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x1105d
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x10fae
jmp 0xb2e0
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb300
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0xb300
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb320
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0xb320
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb340
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0xb340
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb361
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::getMutableRegistryHub()
inline RegistryHub*& getTheRegistryHub() {
            static RegistryHub* theRegistryHub = NULL;
            if( !theRegistryHub )
                theRegistryHub = new RegistryHub();
            return theRegistryHub;
        }

// Assembly:
cmpq $0x0, 0x4c095(%rip)     # 0x57408
jne 0xb42a
pushq %rax
movl $0xd8, %edi
callq 0xa310
leaq 0x4abdd(%rip), %rcx     # 0x55f68
movq %rcx, (%rax)
leaq 0x4ac23(%rip), %rcx     # 0x55fb8
movq %rcx, 0x8(%rax)
leaq 0x49e20(%rip), %rcx     # 0x551c0
movq %rcx, 0x10(%rax)
leaq 0x20(%rax), %rcx
xorl %edx, %edx
movl %edx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rcx, 0x38(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x70(%rax)
leaq 0x4ae0d(%rip), %rcx     # 0x561e0
movq %rcx, 0x80(%rax)
leaq 0x90(%rax), %rcx
movl %edx, 0x90(%rax)
movq %rdx, 0x98(%rax)
movq %rcx, 0xa0(%rax)
movq %rcx, 0xa8(%rax)
movq %rdx, 0xb0(%rax)
leaq 0x4ae1e(%rip), %rcx     # 0x56228
movq %rcx, 0xb8(%rax)
movq %rdx, 0xd0(%rax)
movups %xmm0, 0xc0(%rax)
movq %rax, 0x4bfe2(%rip)     # 0x57408
addq $0x8, %rsp
movq 0x4bfd7(%rip), %rax     # 0x57408
addq $0x8, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Stream::release()
void Stream::release() {
        if( isOwned ) {
            delete streamBuf;
            streamBuf = NULL;
            isOwned = false;
        }
    }

// Assembly:
cmpb $0x1, 0x8(%rdi)
jne 0xbc8c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xbc80
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::createStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Stream createStream( std::string const& streamName ) {
        if( streamName == "stdout" ) return Stream( std::cout.rdbuf(), false );
        if( streamName == "stderr" ) return Stream( std::cerr.rdbuf(), false );
        if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );

        throw std::domain_error( "Unknown stream: " + streamName );
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x329e2(%rip), %rsi     # 0x3e6db
callq 0xa0d0
testl %eax, %eax
je 0xbd88
leaq 0x329d5(%rip), %rsi     # 0x3e6e2
movq %r14, %rdi
callq 0xa0d0
testl %eax, %eax
je 0xbd91
leaq 0x329c9(%rip), %rsi     # 0x3e6e9
movq %r14, %rdi
callq 0xa0d0
testl %eax, %eax
jne 0xbdb5
movl $0x148, %edi            # imm = 0x148
callq 0xa310
movq %rax, %rbx
movq 0x4b244(%rip), %rax     # 0x56f88
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x38(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
callq 0xa660
leaq 0x4aaee(%rip), %rax     # 0x56858
movq %rax, (%rbx)
leaq 0x40(%rbx), %rax
leaq 0x140(%rbx), %rcx
movq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x30(%rbx)
movb $0x1, %dl
jmp 0xbda9
movq 0x4b231(%rip), %rax     # 0x56fc0
jmp 0xbd98
movq 0x4b250(%rip), %rax     # 0x56fe8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rbx
xorl %edx, %edx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0xa160
movq %rax, %rbx
leaq 0x32926(%rip), %rsi     # 0x3e6ef
movq %rsp, %rdi
movq %r14, %rdx
callq 0x10fd5
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa3c0
xorl %ebp, %ebp
movq 0x4b195(%rip), %rsi     # 0x56f80
movq 0x4b1ae(%rip), %rdx     # 0x56fa0
movq %rbx, %rdi
callq 0xa580
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbe20
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0xbe20
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xbe2d
movq %rbx, %rdi
callq 0xa270
movq %r14, %rdi
callq 0xa5c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/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 toString( s );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
callq 0xa4c0
cmpq $0x0, 0x8(%r14)
je 0xe580
xorl %r13d, %r13d
movl $0x3f, %ebp
leaq 0x8(%rsp), %r15
movq (%r14), %rax
movl (%rax,%r13,4), %eax
cmpl $0x100, %eax            # imm = 0x100
cmovgel %ebp, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0xa2d0
incq %r13
cmpq 0x8(%r14), %r13
jb 0xe55d
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe0a1
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe5a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe5b8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe5d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::toString[abi:cxx11](unsigned long)
std::string toString( unsigned long value ) {
    std::ostringstream oss;
    if( value > 8192 )
        oss << "0x" << std::hex << value;
    else
        oss << value;
    return oss.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xa400
cmpq $0x2001, %r14           # imm = 0x2001
jb 0xe85f
leaq 0x2feef(%rip), %rsi     # 0x3e72b
movq %rsp, %rdi
movl $0x2, %edx
callq 0xa390
movq (%rsp), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsp,%rax)
movq %rsp, %rdi
movq %r14, %rsi
callq 0xa200
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xa4d0
movq 0x48732(%rip), %rsi     # 0x56fb0
movq %rsp, %rdi
callq 0xa180
leaq 0x70(%rsp), %rdi
callq 0xa0f0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x48708(%rip), %rsi     # 0x56fb0
movq %rsp, %rdi
callq 0xa180
leaq 0x70(%rsp), %rdi
callq 0xa0f0
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ResultBuilder::captureExpression()
void ResultBuilder::captureExpression() {
        AssertionResult result = build();
        getResultCapture().assertionEnded( result );

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

// Assembly:
pushq %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xd48a
callq 0xb0cc
movq (%rax), %rcx
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq *0x10(%rcx)
testb $0x10, 0xc0(%rsp)
je 0xed0c
movl 0x78(%rsp), %eax
andl $0x4, %eax
jne 0xed0c
callq 0xbc8d
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xecd5
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0xece1
movb $0x1, 0x298(%rbx)
callq 0xbc8d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
cmpl $0x0, 0x68(%rbx)
sete %cl
orb %cl, %al
cmpb $0x1, %al
jne 0xed0c
movb $0x1, 0x299(%rbx)
leaq 0x10(%rsp), %rdi
callq 0xc1bc
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
jmp 0xed37
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xed44
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xed44
movq %rax, %rdi
callq 0x1105d
jmp 0xed41
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc1bc
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/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 );
            std::cerr << ex.what() << std::endl;
            exit(1);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1026a
leaq 0x47110(%rip), %rdi     # 0x573c8
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xfba6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x1033c
movq %rbx, %rdi
callq 0xa130
movq %rax, %rbx
movb $0x0, 0xf(%rsp)
callq 0xbe90
movq (%rax), %rcx
movq %rax, %rdi
movl $0x2, %esi
callq *0x10(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x46cdd(%rip), %rdi     # 0x56fe8
movq %rax, %rsi
callq 0xa300
movq %rax, %rdi
callq 0xa150
movl $0x1, %edi
callq 0xa3d0
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xbe70
jmp 0x10337
movq %rax, %rbx
callq 0xa540
movq %rbx, %rdi
callq 0xa5c0
movq %rax, %rdi
callq 0x1105d
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/main.cpp
// Function: ensureGraphTestLink()
void ensureGraphTestLink()
{
  ensureGraphConstructionTestLink();
  ensureGraphVisitorTestLink();
  ensureGraphCopyTopologyTestLink();
  ensureGraphAddTestLink();
  ensureGraphVisitorIgnoreKeyTestLink();
}

// Assembly:
pushq %rax
callq 0x32b8c
callq 0x3d2ba
callq 0x377b8
callq 0x2e616
popq %rax
jmp 0x3a228
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/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 );
                std::cerr
                    << "Tag name [" << tag << "] not allowed.\n"
                    << "Tag names starting with non alpha-numeric characters are reserved\n";
            }
            {
                Colour colourGuard( Colour::FileName );
                std::cerr << _lineInfo << std::endl;
            }
            exit(1);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1652b
testb %al, %al
jne 0x111b7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0x7(%rsp)
callq 0xbe90
movq (%rax), %rcx
movq %rax, %rdi
movl $0x2, %esi
callq *0x10(%rcx)
movq 0x45e12(%rip), %rdi     # 0x56fe8
leaq 0x2d74e(%rip), %rsi     # 0x3e92b
movl $0xa, %edx
callq 0xa390
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x45df3(%rip), %rdi     # 0x56fe8
callq 0xa390
movq %rax, %r14
leaq 0x2d732(%rip), %rsi     # 0x3e936
movl $0xf, %edx
movq %rax, %rdi
callq 0xa390
leaq 0x2d72e(%rip), %rsi     # 0x3e946
movl $0x42, %edx
movq %r14, %rdi
callq 0xa390
leaq 0x7(%rsp), %rdi
callq 0xbe70
movb $0x0, 0x6(%rsp)
callq 0xbe90
movq (%rax), %rcx
movq %rax, %rdi
movl $0x17, %esi
callq *0x10(%rcx)
movq 0x45d9a(%rip), %rdi     # 0x56fe8
movq %rbx, %rsi
callq 0xbc0a
movq 0x45d8b(%rip), %rdi     # 0x56fe8
callq 0xa150
leaq 0x6(%rsp), %rdi
callq 0xbe70
movl $0x1, %edi
callq 0xa3d0
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
jmp 0x11288
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0xbe70
movq %rbx, %rdi
callq 0xa5c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/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";
                std::cerr << msg << std::endl;
                throw std::logic_error( msg );
            }
            alreadyInstantiated = true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x16b7d
xorl %eax, %eax
movb %al, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movsd 0x2c3de(%rip), %xmm1    # 0x3e030
movups %xmm1, 0x84(%rbx)
leaq 0xa8(%rbx), %rcx
movq %rcx, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movb %al, 0xa8(%rbx)
leaq 0xc8(%rbx), %rcx
movq %rcx, 0xb8(%rbx)
movq %rax, 0xc0(%rbx)
movb %al, 0xc8(%rbx)
leaq 0xe8(%rbx), %rcx
movq %rcx, 0xd8(%rbx)
movq %rax, 0xe0(%rbx)
movb %al, 0xe8(%rbx)
leaq 0x108(%rbx), %rcx
movq %rcx, 0xf8(%rbx)
movq %rax, 0x100(%rbx)
movb %al, 0x108(%rbx)
movups %xmm0, 0x118(%rbx)
movups %xmm0, 0x128(%rbx)
cmpb $0x1, 0x456c0(%rip)     # 0x5739a
je 0x11cef
movb $0x1, 0x456b7(%rip)     # 0x5739a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2ccb3(%rip), %rsi     # 0x3e9b3
leaq 0x2cce0(%rip), %rdx     # 0x3e9e7
leaq 0x8(%rsp), %rdi
callq 0x2bf74
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x452c6(%rip), %rdi     # 0x56fe8
callq 0xa390
movq %rax, %rdi
callq 0xa150
movl $0x10, %edi
callq 0xa160
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xa460
movq 0x45280(%rip), %rsi     # 0x56fd0
movq 0x45261(%rip), %rdx     # 0x56fb8
movq %r15, %rdi
callq 0xa580
movq %rax, %r14
movq %r15, %rdi
callq 0xa270
jmp 0x11d6f
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11d8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x11d8b
movq %rax, %r14
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0x11d9d
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x60(%rbx), %r15
leaq 0x78(%rbx), %rdi
callq 0x17e3c
movq %r15, %rdi
callq 0x17eb6
movq %rbx, %rdi
callq 0x17f12
movq %r14, %rdi
callq 0xa5c0
movq %rax, %rdi
callq 0x1105d
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Session::run(int, char* const*)
int run( int argc, char* const argv[] ) {

            int returnCode = applyCommandLine( argc, argv );
            if( returnCode == 0 )
                returnCode = run();
            return returnCode;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ecx
callq 0x1a618
testl %eax, %eax
je 0x11dde
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x1a84e
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::TestSpec::NamePattern::matches(Catch::TestCaseInfo const&) const
virtual bool matches( TestCaseInfo const& testCase ) const {
                switch( m_wildcard ) {
                    case NoWildcard:
                        return m_name == toLower( testCase.name );
                    case WildcardAtStart:
                        return endsWith( toLower( testCase.name ), m_name );
                    case WildcardAtEnd:
                        return startsWith( toLower( testCase.name ), m_name );
                    case WildcardAtBothEnds:
                        return contains( toLower( testCase.name ), m_name );
                }

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x30(%rdi), %eax
cmpq $0x3, %rax
ja 0x123cd
movq %rdi, %rbx
leaq 0x2bd96(%rip), %rcx     # 0x3e088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xca77
movq 0x18(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0x123a2
testq %rdx, %rdx
je 0x123a6
movq 0x8(%rsp), %rsi
movq 0x10(%rbx), %rdi
callq 0xa350
testl %eax, %eax
sete %bl
jmp 0x123a8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xca77
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc5c4
jmp 0x1239e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xca77
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0xa5a0
cmpq $-0x1, %rax
setne %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
jmp 0x123b1
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xca77
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd904
movl %eax, %ebx
jmp 0x123a8
xorl %ebx, %ebx
jmp 0x123a8
movb $0x1, %bl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x123c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa160
movq %rax, %r14
leaq 0x2cdcc(%rip), %rsi     # 0x3f1ad
movq %rax, %rdi
callq 0xa430
movq 0x44be0(%rip), %rsi     # 0x56fd0
movq 0x44bc1(%rip), %rdx     # 0x56fb8
movq %r14, %rdi
callq 0xa580
movq %rax, %rbx
movq %r14, %rdi
callq 0xa270
jmp 0x1242c
jmp 0x1240e
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1242c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::CumulativeReporterBase::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& testRunStats ) {
            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
            node->children.swap( m_testGroups );
            m_testRuns.push_back( node );
            testRunEndedCumulative();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x88, %edi
callq 0xa310
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x436f0(%rip), %rax     # 0x56810
movq %rax, (%r14)
leaq 0x41dee(%rip), %rax     # 0x54f18
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
callq 0x2bee4
movb 0x58(%r15), %al
movb %al, 0x68(%r14)
movups 0x28(%r15), %xmm0
movups 0x38(%r15), %xmm1
movups 0x48(%r15), %xmm2
movups %xmm2, 0x58(%r14)
movups %xmm1, 0x48(%r14)
movups %xmm0, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
movq $0x0, 0x80(%r14)
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movups 0x70(%rax), %xmm0
movq 0x80(%rax), %rcx
movq 0x68(%rbx), %rdx
movq %rdx, 0x70(%rax)
movq 0x70(%rbx), %rdx
movq %rdx, 0x78(%rax)
movq 0x78(%rbx), %rdx
movq %rdx, 0x80(%rax)
movups %xmm0, 0x68(%rbx)
movq %rcx, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0x2653e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x131f0
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13229
movq %rax, %rbx
movl $0x88, %esi
movq %r14, %rdi
callq 0xa330
jmp 0x13221
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13221
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xa5c0
movq %rax, %rdi
callq 0x1105d
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::StartTesting()
virtual void StartTesting() {
            m_xml.setStream( m_config.stream() );
            m_xml.startElement( "Catch" );
            if( !m_config.fullConfig()->name().empty() )
                m_xml.writeAttribute( "name", m_config.fullConfig()->name() );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, 0x68(%rdi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2c111(%rip), %rsi     # 0x3f380
leaq 0x2c10f(%rip), %rdx     # 0x3f385
movq %rsp, %rdi
callq 0x2bf74
leaq 0x28(%r14), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x26816
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x132a3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x132b5
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
callq *0x30(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %r13
cmpq %r12, %rdi
je 0x132dc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
testq %r13, %r13
je 0x13371
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x2b871(%rip), %rsi     # 0x3eb6c
leaq 0x2b86e(%rip), %rdx     # 0x3eb70
callq 0x2bf74
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x13319
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r14), %rax
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x268c8
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13352
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa330
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13371
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x133cd
jmp 0x133c5
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x133a6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x133a6
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x133d0
jmp 0x133c5
jmp 0x133e8
jmp 0x133c5
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
jmp 0x133eb
movq %rax, %rdi
callq 0x1105d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x133eb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x133eb
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa5c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::EndTesting(Catch::Totals const&)
virtual void EndTesting( const Totals& totals ) {
            m_xml.scopedElement( "OverallResults" )
                .writeAttribute( "successes", totals.assertions.passed )
                .writeAttribute( "failures", totals.assertions.failed )
                .writeAttribute( "expectedFailures", totals.assertions.failedButOk );
            m_xml.endElement();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2bf7f(%rip), %rsi     # 0x3f39f
leaq 0x2bf86(%rip), %rdx     # 0x3f3ad
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x2bf74
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26816
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2bf5b(%rip), %rsi     # 0x3f3ae
leaq 0x2bf5d(%rip), %rdx     # 0x3f3b7
leaq 0x48(%rsp), %rdi
callq 0x2bf74
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x26b4e
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2b735(%rip), %rsi     # 0x3ebba
leaq 0x2b736(%rip), %rdx     # 0x3ebc2
leaq 0x28(%rsp), %rdi
callq 0x2bf74
leaq 0x8(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x26b4e
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2bf00(%rip), %rsi     # 0x3f3b8
leaq 0x2bf09(%rip), %rdx     # 0x3f3c8
leaq 0x8(%rsp), %rdi
callq 0x2bf74
addq $0x10, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x26b4e
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x134f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1350c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x13523
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rsp, %rdi
callq 0x26b36
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x13542
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0x16958
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1357d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x1357d
jmp 0x1357a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1359b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x1359b
jmp 0x13598
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x135b9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x135b9
jmp 0x135b6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x26b36
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x135d8
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::EndGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Totals const&)
virtual void EndGroup( const std::string&, const Totals& totals ) {
            m_xml.scopedElement( "OverallResults" )
                .writeAttribute( "successes", totals.assertions.passed )
                .writeAttribute( "failures", totals.assertions.failed )
                .writeAttribute( "expectedFailures", totals.assertions.failedButOk );
            m_xml.endElement();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2bc9f(%rip), %rsi     # 0x3f39f
leaq 0x2bca6(%rip), %rdx     # 0x3f3ad
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x2bf74
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26816
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2bc7b(%rip), %rsi     # 0x3f3ae
leaq 0x2bc7d(%rip), %rdx     # 0x3f3b7
leaq 0x48(%rsp), %rdi
callq 0x2bf74
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x26b4e
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2b455(%rip), %rsi     # 0x3ebba
leaq 0x2b456(%rip), %rdx     # 0x3ebc2
leaq 0x28(%rsp), %rdi
callq 0x2bf74
leaq 0x8(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x26b4e
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2bc20(%rip), %rsi     # 0x3f3b8
leaq 0x2bc29(%rip), %rdx     # 0x3f3c8
leaq 0x8(%rsp), %rdi
callq 0x2bf74
addq $0x10, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x26b4e
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x137d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x137ec
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x13803
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rsp, %rdi
callq 0x26b36
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x13822
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0x16958
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1385d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x1385d
jmp 0x1385a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1387b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x1387b
jmp 0x13878
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x13899
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x13899
jmp 0x13896
movq %rax, %rbx
movq %rsp, %rdi
callq 0x26b36
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x138b8
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::StartSection(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&)
virtual void StartSection( const std::string& sectionName, const std::string& description ) {
            if( m_sectionDepth++ > 0 ) {
                m_xml.startElement( "Section" )
                    .writeAttribute( "name", trim( sectionName ) )
                    .writeAttribute( "description", description );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl 0x70(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rdi)
testl %eax, %eax
jle 0x13c38
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x70(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2b836(%rip), %rsi     # 0x3f378
leaq 0x2b836(%rip), %rdx     # 0x3f37f
leaq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0x2bf74
addq $0x28, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x26816
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2aff3(%rip), %rsi     # 0x3eb6c
leaq 0x2aff0(%rip), %rdx     # 0x3eb70
leaq 0x20(%rsp), %rdi
callq 0x2bf74
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xd9d8
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
callq 0x268c8
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b82a(%rip), %rsi     # 0x3f3e6
leaq 0x2b82e(%rip), %rdx     # 0x3f3f1
movq %rsp, %rdi
callq 0x2bf74
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x268c8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x13bef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13c0a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x13c21
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x13c38
movq 0x70(%rsp), %rsi
incq %rsi
callq 0xa330
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x13c69
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x13c69
jmp 0x13c66
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13c89
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x13c89
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x13ca7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x13ca7
jmp 0x13ca4
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x13cbe
movq 0x70(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::EndSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Counts const&)
virtual void EndSection( const std::string& /*sectionName*/, const Counts& assertions ) {
            if( --m_sectionDepth > 0 ) {
                m_xml.scopedElement( "OverallResults" )
                    .writeAttribute( "successes", assertions.passed )
                    .writeAttribute( "failures", assertions.failed )
                    .writeAttribute( "expectedFailures", assertions.failedButOk );
                m_xml.endElement();
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl 0x70(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x70(%rdi)
cmpl $0x2, %eax
jl 0x13e2e
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2b69b(%rip), %rsi     # 0x3f39f
leaq 0x2b6a2(%rip), %rdx     # 0x3f3ad
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x2bf74
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26816
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b677(%rip), %rsi     # 0x3f3ae
leaq 0x2b679(%rip), %rdx     # 0x3f3b7
leaq 0x48(%rsp), %rdi
callq 0x2bf74
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x26b4e
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2ae51(%rip), %rsi     # 0x3ebba
leaq 0x2ae52(%rip), %rdx     # 0x3ebc2
leaq 0x28(%rsp), %rdi
callq 0x2bf74
leaq 0x8(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x26b4e
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2b61c(%rip), %rsi     # 0x3f3b8
leaq 0x2b625(%rip), %rdx     # 0x3f3c8
leaq 0x8(%rsp), %rdi
callq 0x2bf74
addq $0x10, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x26b4e
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13dd9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x13df0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa330
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x13e07
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rsp, %rdi
callq 0x26b36
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x13e26
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0x16958
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13e61
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x13e61
jmp 0x13e5e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x13e7f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x13e7f
jmp 0x13e7c
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x13e9d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x13e9d
jmp 0x13e9a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x26b36
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x13ebc
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa330
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::JunitReporter::testGroupStarting(Catch::GroupInfo const&)
virtual void testGroupStarting( GroupInfo const& groupInfo ) {
            suiteTimer.start();
            stdOutForSuite.str("");
            stdErrForSuite.str("");
            unexpectedExceptions = 0;
            CumulativeReporterBase::testGroupStarting( groupInfo );
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xa4f0
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
movq %rax, 0x108(%rbx)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2ac16(%rip), %rdx     # 0x3f56b
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x2bf74
leaq 0x118(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa480
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1498a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x2abd2(%rip), %rdx     # 0x3f56b
movq %rdx, %rsi
callq 0x2bf74
leaq 0x290(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa480
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x149c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
movl $0x0, 0x400(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x149df
jmp 0x149fb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x149fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa330
jmp 0x149fe
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa5c0
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ConsoleReporter::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& _testRunStats ) {
            printTotalsDivider( _testRunStats.totals );
            printTotals( _testRunStats.totals );
            stream << std::endl;
            StreamingReporterBase::testRunEnded( _testRunStats );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %r15
movq %r15, %rsi
callq 0x2a342
movq %r14, %rdi
movq %r15, %rsi
callq 0x29378
movq 0x18(%r14), %r15
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xa2f0
movsbl %al, %esi
movq %r15, %rdi
callq 0xa030
movq %rax, %rdi
callq 0xa210
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12ad8
nop
// File: /workspace/github_cpp_makefile_star2_O1/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IConfig> const&) const
virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const {
            FactoryMap::const_iterator it =  m_factories.find( name );
            if( it == m_factories.end() )
                return NULL;
            return it->second->create( ReporterConfig( config ) );
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x15350
addq $0x10, %rbx
cmpq %rbx, %rax
je 0x1529f
movq 0x40(%rax), %rbx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x8(%rsp)
movq (%r14), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x1527c
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x152a1
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x152a1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x152c9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x152c1
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xa5c0
movq %rax, %rdi
callq 0x1105d
nop