LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::match_symbol(char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline bool match_symbol(const char*& s, const std::string& t) {
			if (memcmp(s, t.c_str(), t.size()) == 0 && is_valid_separator(s[t.size()])) {
				s += t.size();
				return true;
			}
			return false;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3130
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3240
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x3160
cmpl $0x0, %eax
jne 0x12a5c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3240
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsbl (%rax,%rcx), %edi
callq 0x122f0
testb $0x1, %al
jne 0x12a40
jmp 0x12a5c
movq -0x18(%rbp), %rdi
callq 0x3240
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x12a60
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::hex_value(int)
static unsigned int hex_value(int c) {
			if (c >= '0' && c <= '9') {
				return (c - '0');
			} else if (c >= 'A' && c <= 'F') {
				return (c - 'A') + 10;
			} else if (c >= 'a' && c <= 'f') {
				return (c - 'a') + 10;
			} else {
				return c;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x30, -0x8(%rbp)
jl 0x12a8e
cmpl $0x39, -0x8(%rbp)
jg 0x12a8e
movl -0x8(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x12ac8
cmpl $0x41, -0x8(%rbp)
jl 0x12aa8
cmpl $0x46, -0x8(%rbp)
jg 0x12aa8
movl -0x8(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x12ac8
cmpl $0x61, -0x8(%rbp)
jl 0x12ac2
cmpl $0x66, -0x8(%rbp)
jg 0x12ac2
movl -0x8(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x12ac8
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/./src/unit_test.cpp
// Function: avlTest_left_rotation_Test::TestBody()
TEST_F( avlTest , left_rotation ) {
	avl_tree_int.insertHelper( 66 );
	avl_tree_int.insertHelper( 76 );
	avl_tree_int.insertHelper( 86 );

	oss_level.str( string() );
	avl_tree_int.levelorderTraversalHelper( display );
	assert( oss_level && oss_level.str() == "   76,2   66,1   86,1" );
	oss_level.str( string() );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x10, %rdi
movq %rdi, -0x90(%rbp)
movl $0x42, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x4c, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x56, %esi
callq 0xfb30
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x99d0
movq -0x88(%rbp), %rsi
leaq 0x6dcb9(%rip), %rdi     # 0x7c718
callq 0x9280
jmp 0xea66
leaq -0x28(%rbp), %rdi
callq 0x9db8
movq -0x98(%rbp), %rdi
addq $0x10, %rdi
leaq 0x13bf(%rip), %rsi      # 0xfe40
callq 0xfe10
movq 0x6dc8b(%rip), %rax     # 0x7c718
leaq 0x6dc84(%rip), %rdi     # 0x7c718
addq -0x18(%rax), %rdi
callq 0x98e0
movb %al, %cl
movb $0x0, -0x59(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x99(%rbp)
jne 0xeab2
jmp 0xeaf6
leaq 0x6dc5f(%rip), %rsi     # 0x7c718
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x9640
movq -0xa8(%rbp), %rdi
movb $0x1, -0x59(%rbp)
leaq 0x478e3(%rip), %rsi     # 0x563be
callq 0xfeb0
movb %al, -0x9a(%rbp)
jmp 0xeae8
movb -0x9a(%rbp), %al
movb %al, -0x99(%rbp)
jmp 0xeaf6
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0xeb02
jmp 0xeb04
jmp 0xeb4e
leaq 0x478c9(%rip), %rdi     # 0x563d4
leaq 0x4752f(%rip), %rsi     # 0x56041
movl $0xae, %edx
leaq 0x478ee(%rip), %rcx     # 0x5640c
callq 0x93e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9db8
jmp 0xebb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x59(%rbp)
jne 0xeb96
jmp 0xeb9f
testb $0x1, -0x59(%rbp)
jne 0xeb56
jmp 0xeb5f
leaq -0x58(%rbp), %rdi
callq 0x9db8
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x99d0
movq -0xb0(%rbp), %rsi
leaq 0x6db9b(%rip), %rdi     # 0x7c718
callq 0x9280
jmp 0xeb84
leaq -0x80(%rbp), %rdi
callq 0x9db8
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x9db8
jmp 0xebb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9db8
movq -0x30(%rbp), %rdi
callq 0x9c40
nop
// File: ambersun1234[P]AVL_Tree/./src/unit_test.cpp
// Function: avlTest_right_rotation_Test::TestBody()
TEST_F( avlTest , right_rotation ) {
	avl_tree_int.insertHelper( 50 );
	avl_tree_int.insertHelper( 20 );
	avl_tree_int.insertHelper( 10 );

	oss_level.str( string() );
	avl_tree_int.levelorderTraversalHelper( display );
	assert( oss_level && oss_level.str() == "   20,2   10,1   50,1" );
	oss_level.str( string() );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x10, %rdi
movq %rdi, -0x90(%rbp)
movl $0x32, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x14, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0xa, %esi
callq 0xfb30
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x99d0
movq -0x88(%rbp), %rsi
leaq 0x6dae9(%rip), %rdi     # 0x7c718
callq 0x9280
jmp 0xec36
leaq -0x28(%rbp), %rdi
callq 0x9db8
movq -0x98(%rbp), %rdi
addq $0x10, %rdi
leaq 0x11ef(%rip), %rsi      # 0xfe40
callq 0xfe10
movq 0x6dabb(%rip), %rax     # 0x7c718
leaq 0x6dab4(%rip), %rdi     # 0x7c718
addq -0x18(%rax), %rdi
callq 0x98e0
movb %al, %cl
movb $0x0, -0x59(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x99(%rbp)
jne 0xec82
jmp 0xecc6
leaq 0x6da8f(%rip), %rsi     # 0x7c718
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x9640
movq -0xa8(%rbp), %rdi
movb $0x1, -0x59(%rbp)
leaq 0x477a4(%rip), %rsi     # 0x5644f
callq 0xfeb0
movb %al, -0x9a(%rbp)
jmp 0xecb8
movb -0x9a(%rbp), %al
movb %al, -0x99(%rbp)
jmp 0xecc6
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0xecd2
jmp 0xecd4
jmp 0xed1e
leaq 0x4778a(%rip), %rdi     # 0x56465
leaq 0x4735f(%rip), %rsi     # 0x56041
movl $0xb9, %edx
leaq 0x477af(%rip), %rcx     # 0x5649d
callq 0x93e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9db8
jmp 0xed86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x59(%rbp)
jne 0xed66
jmp 0xed6f
testb $0x1, -0x59(%rbp)
jne 0xed26
jmp 0xed2f
leaq -0x58(%rbp), %rdi
callq 0x9db8
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x99d0
movq -0xb0(%rbp), %rsi
leaq 0x6d9cb(%rip), %rdi     # 0x7c718
callq 0x9280
jmp 0xed54
leaq -0x80(%rbp), %rdi
callq 0x9db8
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x9db8
jmp 0xed86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9db8
movq -0x30(%rbp), %rdi
callq 0x9c40
nop
// File: ambersun1234[P]AVL_Tree/./src/unit_test.cpp
// Function: avlTest_right_left_double_rotation_Test::TestBody()
TEST_F( avlTest , right_left_double_rotation ) {
	avl_tree_int.insertHelper( 20 );
	avl_tree_int.insertHelper( 4 );
	avl_tree_int.insertHelper( 26 );
	avl_tree_int.insertHelper( 3 );
	avl_tree_int.insertHelper( 9 );
	avl_tree_int.insertHelper( 15 );

	oss_level.str( string() );
	avl_tree_int.levelorderTraversalHelper( display );
	assert( oss_level && oss_level.str() == "   9,3   4,2   20,2   3,1   15,1   26,1" );
	oss_level.str( string() );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x10, %rdi
movq %rdi, -0x90(%rbp)
movl $0x14, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x4, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x1a, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x3, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x9, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0xf, %esi
callq 0xfb30
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x99d0
movq -0x88(%rbp), %rsi
leaq 0x6d8e6(%rip), %rdi     # 0x7c718
callq 0x9280
jmp 0xee39
leaq -0x28(%rbp), %rdi
callq 0x9db8
movq -0x98(%rbp), %rdi
addq $0x10, %rdi
leaq 0xfec(%rip), %rsi       # 0xfe40
callq 0xfe10
movq 0x6d8b8(%rip), %rax     # 0x7c718
leaq 0x6d8b1(%rip), %rdi     # 0x7c718
addq -0x18(%rax), %rdi
callq 0x98e0
movb %al, %cl
movb $0x0, -0x59(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x99(%rbp)
jne 0xee85
jmp 0xeec9
leaq 0x6d88c(%rip), %rsi     # 0x7c718
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x9640
movq -0xa8(%rbp), %rdi
movb $0x1, -0x59(%rbp)
leaq 0x4763f(%rip), %rsi     # 0x564ed
callq 0xfeb0
movb %al, -0x9a(%rbp)
jmp 0xeebb
movb -0x9a(%rbp), %al
movb %al, -0x99(%rbp)
jmp 0xeec9
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0xeed5
jmp 0xeed7
jmp 0xef21
leaq 0x47637(%rip), %rdi     # 0x56515
leaq 0x4715c(%rip), %rsi     # 0x56041
movl $0xc7, %edx
leaq 0x4766e(%rip), %rcx     # 0x5655f
callq 0x93e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9db8
jmp 0xef89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x59(%rbp)
jne 0xef69
jmp 0xef72
testb $0x1, -0x59(%rbp)
jne 0xef29
jmp 0xef32
leaq -0x58(%rbp), %rdi
callq 0x9db8
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x99d0
movq -0xb0(%rbp), %rsi
leaq 0x6d7c8(%rip), %rdi     # 0x7c718
callq 0x9280
jmp 0xef57
leaq -0x80(%rbp), %rdi
callq 0x9db8
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x9db8
jmp 0xef89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9db8
movq -0x30(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./src/unit_test.cpp
// Function: avlTest_left_right_double_rotation_Test::TestBody()
TEST_F( avlTest , left_right_double_rotation ) {
	avl_tree_int.insertHelper( 66 );
	avl_tree_int.insertHelper( 76 );
	avl_tree_int.insertHelper( 86 );
	avl_tree_int.insertHelper( 96 );
	avl_tree_int.insertHelper( 90 );

	oss_level.str( string() );
	avl_tree_int.levelorderTraversalHelper( display );
	assert( oss_level && oss_level.str() == "   76,3   66,1   90,2   86,1   96,1" );
	oss_level.str( string() );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x10, %rdi
movq %rdi, -0x90(%rbp)
movl $0x42, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x4c, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x56, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x60, %esi
callq 0xfb30
movq -0x90(%rbp), %rdi
movl $0x5a, %esi
callq 0xfb30
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x99d0
movq -0x88(%rbp), %rsi
leaq 0x6d6e7(%rip), %rdi     # 0x7c718
callq 0x9280
jmp 0xf038
leaq -0x28(%rbp), %rdi
callq 0x9db8
movq -0x98(%rbp), %rdi
addq $0x10, %rdi
leaq 0xded(%rip), %rsi       # 0xfe40
callq 0xfe10
movq 0x6d6b9(%rip), %rax     # 0x7c718
leaq 0x6d6b2(%rip), %rdi     # 0x7c718
addq -0x18(%rax), %rdi
callq 0x98e0
movb %al, %cl
movb $0x0, -0x59(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x99(%rbp)
jne 0xf084
jmp 0xf0c8
leaq 0x6d68d(%rip), %rsi     # 0x7c718
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x9640
movq -0xa8(%rbp), %rdi
movb $0x1, -0x59(%rbp)
leaq 0x4750e(%rip), %rsi     # 0x565bb
callq 0xfeb0
movb %al, -0x9a(%rbp)
jmp 0xf0ba
movb -0x9a(%rbp), %al
movb %al, -0x99(%rbp)
jmp 0xf0c8
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0xf0d4
jmp 0xf0d6
jmp 0xf120
leaq 0x47502(%rip), %rdi     # 0x565df
leaq 0x46f5d(%rip), %rsi     # 0x56041
movl $0xd4, %edx
leaq 0x47535(%rip), %rcx     # 0x56625
callq 0x93e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9db8
jmp 0xf188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x59(%rbp)
jne 0xf168
jmp 0xf171
testb $0x1, -0x59(%rbp)
jne 0xf128
jmp 0xf131
leaq -0x58(%rbp), %rdi
callq 0x9db8
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x99d0
movq -0xb0(%rbp), %rsi
leaq 0x6d5c9(%rip), %rdi     # 0x7c718
callq 0x9280
jmp 0xf156
leaq -0x80(%rbp), %rdi
callq 0x9db8
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x9db8
jmp 0xf188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9db8
movq -0x30(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./src/node.h
// Function: node<int>::getMaxHeight()
int node< itemType >::getMaxHeight() {
	int leftHeight , rightHeight;

	leftHeight = this->getLeftChildHeight();
	rightHeight = this->getRightChildHeight();

	return ( leftHeight > rightHeight ? leftHeight : rightHeight ) + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x134a0
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
callq 0x134f0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0xf998
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xf99e
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./src/node.h
// Function: node<int>::node(int)
node< itemType >::node( itemType input ) {
	this->data = input;
	this->left = nullptr;
	this->right = nullptr;
	this->height = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl $0x1, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<double>::clearTree(node<double>*)
void AVLTree< itemType >::clearTree( node< itemType >* root ) {
	if ( root == nullptr ) return;

	this->clearTree( root->getLeftChild() );
	this->clearTree( root->getRightChild() );

	delete root;
	root = nullptr;
}

// 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)
cmpq $0x0, -0x10(%rbp)
jne 0x11181
jmp 0x111cf
movq -0x10(%rbp), %rdi
callq 0xf6d0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x11160
movq -0x10(%rbp), %rdi
callq 0xf7a0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x11160
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x111c7
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x9630
movq $0x0, -0x10(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperOpFailure<int, int>(char const*, char const*, int const&, int const&, char const*)
AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
                                   const T1& val1, const T2& val2,
                                   const char* op) {
  return AssertionFailure()
         << "Expected: (" << expr1 << ") " << op << " (" << expr2
         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
         << " vs " << FormatForComparisonFailureMessage(val2, val1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x197b0
movq -0xa0(%rbp), %rdi
leaq 0x4442e(%rip), %rsi     # 0x56690
callq 0x12420
movq %rax, -0x98(%rbp)
jmp 0x12270
movq -0x98(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x124a0
movq %rax, -0xb8(%rbp)
jmp 0x12289
movq -0xb8(%rbp), %rdi
leaq 0x44405(%rip), %rsi     # 0x5669c
callq 0x12520
movq %rax, -0xc0(%rbp)
jmp 0x122a5
movq -0xc0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x124a0
movq %rax, -0xc8(%rbp)
jmp 0x122be
movq -0xc8(%rbp), %rdi
leaq 0x443cd(%rip), %rsi     # 0x56699
callq 0x12520
movq %rax, -0xd0(%rbp)
jmp 0x122da
movq -0xd0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x124a0
movq %rax, -0xd8(%rbp)
jmp 0x122f3
movq -0xd8(%rbp), %rdi
leaq 0x4439e(%rip), %rsi     # 0x5669f
callq 0x12420
movq %rax, -0xe0(%rbp)
jmp 0x1230f
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x11bf0
jmp 0x12322
movq -0xe0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x125a0
movq %rax, -0xe8(%rbp)
jmp 0x1233b
movq -0xe8(%rbp), %rdi
leaq 0x44362(%rip), %rsi     # 0x566ab
callq 0x12620
movq %rax, -0xf0(%rbp)
jmp 0x12357
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x11bf0
jmp 0x1236d
movq -0xf0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x125a0
movq %rax, -0xf8(%rbp)
jmp 0x12389
movq -0xf8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x195b0
jmp 0x1239e
leaq -0x90(%rbp), %rdi
callq 0x9db8
leaq -0x70(%rbp), %rdi
callq 0x9db8
leaq -0x40(%rbp), %rdi
callq 0xf410
movq -0xa8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x12409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x12400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x9db8
leaq -0x70(%rbp), %rdi
callq 0x9db8
leaq -0x40(%rbp), %rdi
callq 0xf410
movq -0x48(%rbp), %rdi
callq 0x9c40
nopl (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/include/gtest/gtest-printers.h
// Function: void testing::internal::DefaultPrintTo<node<int>>(testing::internal::WrapPrinterType<(testing::internal::DefaultPrinterType)1>, node<int>*, std::ostream*)
void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */,
                    T* p, ::std::ostream* os) {
  if (p == NULL) {
    *os << "NULL";
  } else {
    // T is not a function type.  We just call << to print p,
    // relying on ADL to pick up user-defined << for their pointer
    // types, if any.
    *os << p;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12c99
movq -0x18(%rbp), %rdi
leaq 0x43a25(%rip), %rsi     # 0x566b7
callq 0x95e0
jmp 0x12ca6
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x94b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/./src/node.h
// Function: node<int>::getLeftChildHeight()
int node< itemType >::getLeftChildHeight() {
	int temp;

	if ( this->left == nullptr ) temp = 0;
	else temp = this->getLeftChild()->getHeight();

	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x134c4
movl $0x0, -0xc(%rbp)
jmp 0x134d8
movq -0x18(%rbp), %rdi
callq 0xf5e0
movq %rax, %rdi
callq 0xf430
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./src/node.h
// Function: node<int>::getRightChildHeight()
int node< itemType >::getRightChildHeight() {
	int temp;

	if ( this->right == nullptr ) temp = 0;
	else temp = this->getRightChild()->getHeight();

	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x13514
movl $0x0, -0xc(%rbp)
jmp 0x13528
movq -0x18(%rbp), %rdi
callq 0xf620
movq %rax, %rdi
callq 0xf430
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::insert(node<int>*, node<int>*)
node< itemType >* AVLTree< itemType >::insert( node< itemType > *root , node< itemType > *newEntry ) {
	if ( root == nullptr ) return newEntry;

	if ( root->getData() > newEntry->getData() ) root->setLeftChild( this->insert( root->getLeftChild() , newEntry ) );
	else if ( root->getData() < newEntry->getData() ) root->setRightChild( this->insert( root->getRightChild() , newEntry ) );

	if ( root->unbalanced() ) {
		this->doRotation( root );
	}
	root->setHeight( root->getMaxHeight() );

	return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13610
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x136ea
movq -0x18(%rbp), %rdi
callq 0xf3a0
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf3a0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jle 0x1365d
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x135e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xf600
jmp 0x136aa
movq -0x18(%rbp), %rdi
callq 0xf3a0
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf3a0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x136a8
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf620
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x135e0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xf640
jmp 0x136aa
movq -0x18(%rbp), %rdi
callq 0xfa40
testb $0x1, %al
jne 0x136b9
jmp 0x136c6
movq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13700
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf960
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x138b0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::leftRotation(node<int>*, node<int>*)
node< itemType >* AVLTree< itemType >::leftRotation( node< itemType > *up , node< itemType > *middle ) {
	node< itemType > *temp = middle->getLeftChild();

	up->setRightChild( temp );
	middle->setLeftChild( up );

	up->setHeight( up->getMaxHeight() );
	middle->setHeight( middle->getMaxHeight() );

	return middle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf640
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf600
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf960
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x138b0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf960
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x138b0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::rightRotation(node<int>*, node<int>*)
node< itemType >* AVLTree< itemType >::rightRotation( node< itemType > *up , node< itemType > *middle ) {
	node< itemType > *temp = middle->getRightChild();

	up->setLeftChild( temp );
	middle->setRightChild( up );

	up->setHeight( up->getMaxHeight() );
	middle->setHeight( middle->getMaxHeight() );

	return middle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf620
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf600
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf640
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf960
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x138b0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf960
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x138b0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::search(node<int>*, int)
bool AVLTree< itemType >::search( node< itemType > *root , itemType target ) {
	if ( root == nullptr ) return false;
	if ( root->getData() == target ) return true;

	if ( root->getData() > target ) return this->search( root->getLeftChild() , target );
	if ( root->getData() < target ) return this->search( root->getRightChild() , target );

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13de8
movb $0x0, -0x1(%rbp)
jmp 0x13e5a
movq -0x18(%rbp), %rdi
callq 0xf3a0
cmpl -0x1c(%rbp), %eax
jne 0x13dfc
movb $0x1, -0x1(%rbp)
jmp 0x13e5a
movq -0x18(%rbp), %rdi
callq 0xf3a0
cmpl -0x1c(%rbp), %eax
jle 0x13e29
movq -0x18(%rbp), %rdi
callq 0xf5e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0x13dc0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x13e5a
movq -0x18(%rbp), %rdi
callq 0xf3a0
cmpl -0x1c(%rbp), %eax
jge 0x13e56
movq -0x18(%rbp), %rdi
callq 0xf620
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0x13dc0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x13e5a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::levelorderTraversal(node<int>*, void (*)(node<int>&, std::ostream&))
void AVLTree< itemType >::levelorderTraversal( node< itemType > *root , void visit( node< itemType > &record , ostream& os ) ) {
	queue< node< itemType >* > myQueue;
	node< itemType > *temp;

	if ( root != nullptr ) myQueue.push( root );

	while ( !myQueue.empty() ) {
		temp = myQueue.front();
		myQueue.pop();

		visit( *temp , oss_level );

		if ( temp->getLeftChild() != nullptr ) myQueue.push( temp->getLeftChild() );
		if ( temp->getRightChild() != nullptr ) myQueue.push( temp->getRightChild() );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x14150
cmpq $0x0, -0x10(%rbp)
je 0x14062
leaq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x14180
jmp 0x14046
jmp 0x14062
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x14240
jmp 0x14141
jmp 0x14064
leaq -0x68(%rbp), %rdi
callq 0x141b0
movb %al, -0x91(%rbp)
jmp 0x14075
movb -0x91(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14086
jmp 0x1412f
leaq -0x68(%rbp), %rdi
callq 0x141d0
movq %rax, -0xa0(%rbp)
jmp 0x14098
movq -0xa0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x141f0
jmp 0x140b1
movq -0x18(%rbp), %rax
movq -0x70(%rbp), %rdi
leaq 0x68658(%rip), %rsi     # 0x7c718
callq *%rax
jmp 0x140c4
movq -0x70(%rbp), %rdi
callq 0xf5e0
cmpq $0x0, %rax
je 0x140f7
movq -0x70(%rbp), %rdi
callq 0xf5e0
movq %rax, -0x88(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x14210
jmp 0x140f5
jmp 0x140f7
movq -0x70(%rbp), %rdi
callq 0xf620
cmpq $0x0, %rax
je 0x1412a
movq -0x70(%rbp), %rdi
callq 0xf620
movq %rax, -0x90(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x14210
jmp 0x14128
jmp 0x1412a
jmp 0x14064
leaq -0x68(%rbp), %rdi
callq 0x14240
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x9c40
nopw (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-port.cc
// Function: testing::internal::BoolFromGTestEnv(char const*, bool)
bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  return string_value == NULL ?
      default_value : strcmp(string_value, "0") != 0;
#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34620
movq -0x58(%rbp), %rdi
callq 0x9230
movq %rax, %rdi
callq 0x3b970
movq %rax, -0x50(%rbp)
jmp 0x1599c
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x159b3
movb -0x9(%rbp), %al
movb %al, -0x59(%rbp)
jmp 0x159cc
movq -0x38(%rbp), %rdi
leaq 0x4457a(%rip), %rsi     # 0x59f38
callq 0x99f0
cmpl $0x0, %eax
setne %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
movb %al, -0x5a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9db8
movb -0x5a(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9db8
movq -0x40(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-port.cc
// Function: testing::internal::StringFromGTestEnv(char const*, char const*)
const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const value = posix::GetEnv(env_var.c_str());
  return value == NULL ? default_value : value;
#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34620
movq -0x58(%rbp), %rdi
callq 0x9230
movq %rax, %rdi
callq 0x3b970
movq %rax, -0x50(%rbp)
jmp 0x15a48
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x15a61
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x15a69
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9db8
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9db8
movq -0x40(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::GetDefaultFilter()
static const char* GetDefaultFilter() {
  const char* const testbridge_test_only =
      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
  if (testbridge_test_only != NULL) {
    return testbridge_test_only;
  }
  return kUniversalFilter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x43bf7(%rip), %rdi     # 0x596b6
callq 0x3b970
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x15ad9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15ae4
leaq 0x41663(%rip), %rax     # 0x57143
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-port.cc
// Function: testing::internal::OutputFlagAlsoCheckEnvVar[abi:cxx11]()
std::string OutputFlagAlsoCheckEnvVar(){
  std::string default_value_for_output_flag = "";
  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
  if (NULL != xml_output_file_env) {
    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
  }
  return default_value_for_output_flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x9c50
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x42e5f(%rip), %rsi     # 0x5898c
callq 0xf1d0
jmp 0x15b34
leaq -0xa(%rbp), %rdi
callq 0x96d0
leaq 0x43a86(%rip), %rdi     # 0x595ca
callq 0x3b970
movq %rax, -0x90(%rbp)
jmp 0x15b52
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x15c22
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x9c50
movq -0x98(%rbp), %rdx
leaq 0x43a53(%rip), %rsi     # 0x595da
leaq -0x68(%rbp), %rdi
callq 0xf1d0
jmp 0x15b92
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x37b80
jmp 0x15ba5
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9860
leaq -0x48(%rbp), %rdi
callq 0x9db8
leaq -0x68(%rbp), %rdi
callq 0x9db8
leaq -0x69(%rbp), %rdi
callq 0x96d0
jmp 0x15c22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x96d0
jmp 0x15c4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x15c45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x15c17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9db8
leaq -0x69(%rbp), %rdi
callq 0x96d0
jmp 0x15c45
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x15c35
movq -0x80(%rbp), %rdi
callq 0x9db8
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x9db8
movq -0x18(%rbp), %rdi
callq 0x9c40
nopw (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]()
std::string UnitTestOptions::GetOutputFormat() {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == NULL) ?
      std::string(gtest_output_flag) :
      std::string(gtest_output_flag, colon - gtest_output_flag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x65f0a(%rip), %rdi     # 0x7c948
callq 0x9230
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x9200
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, -0x1a(%rbp)
movb $0x0, -0x2e(%rbp)
cmpq $0x0, %rax
jne 0x16a99
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9c50
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movb $0x1, -0x1a(%rbp)
callq 0xf1d0
jmp 0x16a97
jmp 0x16ad6
movq -0x10(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x60(%rbp)
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x9c50
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
movb $0x1, -0x2e(%rbp)
callq 0x9760
jmp 0x16ad4
jmp 0x16ad6
testb $0x1, -0x2e(%rbp)
jne 0x16ade
jmp 0x16ae7
leaq -0x2d(%rbp), %rdi
callq 0x96d0
testb $0x1, -0x1a(%rbp)
jne 0x16aef
jmp 0x16af8
leaq -0x19(%rbp), %rdi
callq 0x96d0
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x16b2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
testb $0x1, -0x2e(%rbp)
jne 0x16b24
jmp 0x16b2d
leaq -0x2d(%rbp), %rdi
callq 0x96d0
jmp 0x16b2f
testb $0x1, -0x1a(%rbp)
jne 0x16b37
jmp 0x16b40
leaq -0x19(%rbp), %rdi
callq 0x96d0
jmp 0x16b42
movq -0x28(%rbp), %rdi
callq 0x9c40
nopl (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::current_test_result()
TestResult* UnitTestImpl::current_test_result() {
  if (current_test_info_ != NULL) {
    return &current_test_info_->result_;
  }
  if (current_test_case_ != NULL) {
    return &current_test_case_->ad_hoc_test_result_;
  }
  return &ad_hoc_test_result_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x110(%rax)
je 0x187c1
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rax
addq $0x90, %rax
movq %rax, -0x8(%rbp)
jmp 0x187f4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x108(%rax)
je 0x187e6
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rax
addq $0x80, %rax
movq %rax, -0x8(%rbp)
jmp 0x187f4
movq -0x18(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::TestInfo::Run()
void TestInfo::Run() {
  if (!should_run_) return;

  // Tells UnitTest where to store test result.
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_info(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  // Notifies the unit test event listeners that a test is about to start.
  repeater->OnTestStart(*this);

  const TimeInMillis start = internal::GetTimeInMillis();

  impl->os_stack_trace_getter()->UponLeavingGTest();

  // Creates the test object.
  Test* const test = internal::HandleExceptionsInMethodIfSupported(
      factory_, &internal::TestFactoryBase::CreateTest,
      "the test fixture's constructor");

  // Runs the test if the constructor didn't generate a fatal failure.
  // Note that the object will not be null
  if (!Test::HasFatalFailure()) {
    // This doesn't throw as all user code that can throw are wrapped into
    // exception handling code.
    test->Run();
  }

    // Deletes the test object.
    impl->os_stack_trace_getter()->UponLeavingGTest();
    internal::HandleExceptionsInMethodIfSupported(
        test, &Test::DeleteSelf_, "the test fixture's destructor");

  result_.set_elapsed_time(internal::GetTimeInMillis() - start);

  // Notifies the unit test event listener that a test has just finished.
  repeater->OnTestEnd(*this);

  // Tells UnitTest to stop associating assertion results to this
  // test.
  impl->set_current_test_info(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x80(%rax)
jne 0x20072
jmp 0x20193
callq 0x37ce0
movq -0x50(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ae90
callq 0x16240
movq %rax, %rdi
callq 0x201a0
movq %rax, %rdi
callq 0x18830
movq -0x50(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
callq 0x18e70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18df0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x50(%rbp), %rax
movq 0x88(%rax), %rdi
movq $0x0, -0x30(%rbp)
movq $0x11, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq 0x3864b(%rip), %rcx     # 0x58745
callq 0x3aeb0
movq %rax, -0x28(%rbp)
callq 0x1f560
testb $0x1, %al
jne 0x20115
movq -0x28(%rbp), %rdi
callq 0x1f460
movq -0x10(%rbp), %rdi
callq 0x18df0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x28(%rbp), %rdi
leaq 0x1b00b(%rip), %rax     # 0x3b140
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0x38614(%rip), %rcx     # 0x58764
callq 0x3a940
movq -0x50(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x58(%rbp)
callq 0x18e70
movq -0x58(%rbp), %rdi
movq %rax, %rsi
subq -0x20(%rbp), %rsi
callq 0x3b170
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3ae90
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                  int /*iteration*/) {
  FILE* xmlout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintXmlUnitTest(&stream, unit_test);
  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
  fclose(xmlout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq %rax, -0x20(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x9420
xorl %eax, %eax
leaq -0x1a8(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0x1e0(%rbp)
je 0x22c4b
leaq -0x1a8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x1e0(%rbp)
movq -0x1e0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22e80
jmp 0x22c5d
movq -0x20(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x1d8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x19470
jmp 0x22c7d
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x9230
movq -0x1e8(%rbp), %rdi
movq %rax, %rdx
leaq 0x363c9(%rip), %rsi     # 0x5906a
xorl %eax, %eax
callq 0x9a10
movq -0x1f0(%rbp), %rdi
callq 0x9db8
movq -0x20(%rbp), %rdi
callq 0x95f0
jmp 0x22cbf
leaq -0x1a8(%rbp), %rdi
callq 0x9480
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x9480
movq -0x1b0(%rbp), %rdi
callq 0x9c40
nop
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::OpenFileForWriting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static FILE* OpenFileForWriting(const std::string& output_file) {
  FILE* fileout = NULL;
  FilePath output_file_path(output_file);
  FilePath output_dir(output_file_path.RemoveFileName());

  if (output_dir.CreateDirectoriesRecursively()) {
    fileout = posix::FOpen(output_file.c_str(), "w");
  }
  if (fileout == NULL) {
    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
  }
  return fileout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x37ad0
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x33560
jmp 0x22d37
leaq -0x50(%rbp), %rdi
callq 0x33890
movb %al, -0x69(%rbp)
jmp 0x22d45
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x22d4e
jmp 0x22d98
movq -0x8(%rbp), %rdi
callq 0x9230
movq %rax, %rdi
leaq 0x361ef(%rip), %rsi     # 0x58f50
callq 0x3dfe0
movq %rax, -0x78(%rbp)
jmp 0x22d6c
movq -0x78(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x22d98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x22e60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x22e57
cmpq $0x0, -0x10(%rbp)
jne 0x22e2a
leaq 0x353c4(%rip), %rdx     # 0x5816e
leaq -0x60(%rbp), %rdi
movl $0x3, %esi
movl $0xcf, %ecx
callq 0x33f70
jmp 0x22dbf
leaq -0x60(%rbp), %rdi
callq 0x377b0
movq %rax, %rdi
leaq 0x36ba1(%rip), %rsi     # 0x59973
callq 0x95e0
movq %rax, -0x80(%rbp)
jmp 0x22ddd
movq -0x80(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x9550
movq %rax, -0x88(%rbp)
jmp 0x22df3
movq -0x88(%rbp), %rdi
leaq 0x35ead(%rip), %rsi     # 0x58cae
callq 0x95e0
jmp 0x22e08
leaq -0x60(%rbp), %rdi
callq 0x340b0
jmp 0x22e2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x340b0
jmp 0x22e57
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x37b20
leaq -0x30(%rbp), %rdi
callq 0x37b20
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x37b20
leaq -0x30(%rbp), %rdi
callq 0x37b20
movq -0x58(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&)
void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
    const std::vector<TestCase*>& test_cases) {
  FILE* xmlout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintXmlTestsList(&stream, test_cases);
  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
  fclose(xmlout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq %rax, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x9420
xorl %eax, %eax
leaq -0x1a0(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0x1d8(%rbp)
je 0x23958
leaq -0x1a0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x1d8(%rbp)
movq -0x1d8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23a10
jmp 0x2396a
movq -0x18(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x19470
jmp 0x2398a
leaq -0x1d0(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x9230
movq -0x1e0(%rbp), %rdi
movq %rax, %rdx
leaq 0x356bc(%rip), %rsi     # 0x5906a
xorl %eax, %eax
callq 0x9a10
movq -0x1e8(%rbp), %rdi
callq 0x9db8
movq -0x18(%rbp), %rdi
callq 0x95f0
jmp 0x239cc
leaq -0x1a0(%rbp), %rdi
callq 0x9480
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x9480
movq -0x1a8(%rbp), %rdi
callq 0x9c40
nopl (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*)
std::string StreamingListener::UrlEncode(const char* str) {
  std::string result;
  result.reserve(strlen(str) + 1);
  for (char ch = *str; ch != '\0'; ch = *++str) {
    switch (ch) {
      case '%':
      case '=':
      case '&':
      case '\n':
        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
        break;
      default:
        result.push_back(ch);
        break;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x99d0
movq -0x10(%rbp), %rdi
callq 0x9260
movq -0x70(%rbp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x9af0
jmp 0x2a561
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x0, %eax
je 0x2a653
movsbl -0x25(%rbp), %eax
movl %eax, -0x7c(%rbp)
subl $0xa, %eax
je 0x2a5b0
jmp 0x2a585
movl -0x7c(%rbp), %eax
addl $-0x25, %eax
subl $0x2, %eax
jb 0x2a5b0
jmp 0x2a592
movl -0x7c(%rbp), %eax
subl $0x3d, %eax
je 0x2a5b0
jmp 0x2a626
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2a673
movzbl -0x25(%rbp), %esi
leaq -0x68(%rbp), %rdi
callq 0x1de00
jmp 0x2a5bf
leaq 0x2e708(%rip), %rsi     # 0x58cce
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x39930
jmp 0x2a5d5
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9d70
jmp 0x2a5e4
leaq -0x48(%rbp), %rdi
callq 0x9db8
leaq -0x68(%rbp), %rdi
callq 0x9db8
jmp 0x2a637
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2a61b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9db8
leaq -0x68(%rbp), %rdi
callq 0x9db8
jmp 0x2a673
movq -0x70(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0x9510
jmp 0x2a635
jmp 0x2a637
jmp 0x2a639
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb 0x1(%rax), %al
movb %al, -0x25(%rbp)
jmp 0x2a56a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2a666
movq -0x70(%rbp), %rdi
callq 0x9db8
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x9db8
movq -0x20(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)