LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq 0x10(%rdi), %r15
movl $0x20, %edi
callq 0x7450
movl $0x32, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1, %ebp
movl %ebp, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd7aa
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x20, %edi
callq 0x7450
movl $0x14, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd7aa
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x20, %edi
callq 0x7450
movl $0xa, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd7aa
movq %rax, 0x10(%r14)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x3df34(%rip), %rdi     # 0x49578
leaq 0x8(%rsp), %rsi
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb665
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq (%rbx), %rsi
leaq 0x645(%rip), %rdx       # 0xbcb4
movq %rbx, %rdi
callq 0xdc52
leaq 0x3def2(%rip), %rax     # 0x49570
movq 0x3deeb(%rip), %rcx     # 0x49570
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xb714
leaq 0x3dedd(%rip), %rsi     # 0x49578
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7880
leaq 0x28d90(%rip), %rsi     # 0x3443f
movq %rbx, %rdi
callq 0x7140
testl %eax, %eax
jne 0xb714
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb6d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
leaq 0x3de8b(%rip), %rdi     # 0x49578
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb709
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28d3a(%rip), %rdi     # 0x34455
leaq 0x2890f(%rip), %rsi     # 0x34031
leaq 0x28d64(%rip), %rcx     # 0x3448d
movl $0xb9, %edx
callq 0x72e0
jmp 0xb735
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb74f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7960
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq 0x10(%rdi), %r15
movl $0x20, %edi
callq 0x7450
movl $0x42, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1, %ebp
movl %ebp, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd7aa
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x20, %edi
callq 0x7450
movl $0x4c, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd7aa
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x20, %edi
callq 0x7450
movl $0x56, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd7aa
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x20, %edi
callq 0x7450
movl $0x60, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd7aa
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x20, %edi
callq 0x7450
movl $0x5a, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd7aa
movq %rax, 0x10(%r14)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x3daa2(%rip), %rdi     # 0x49578
leaq 0x8(%rsp), %rsi
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xbaf7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq (%rbx), %rsi
leaq 0x1b3(%rip), %rdx       # 0xbcb4
movq %rbx, %rdi
callq 0xdc52
leaq 0x3da60(%rip), %rax     # 0x49570
movq 0x3da59(%rip), %rcx     # 0x49570
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xbba6
leaq 0x3da4b(%rip), %rsi     # 0x49578
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7880
leaq 0x28a6a(%rip), %rsi     # 0x345ab
movq %rbx, %rdi
callq 0x7140
testl %eax, %eax
jne 0xbba6
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xbb64
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
leaq 0x3d9f9(%rip), %rdi     # 0x49578
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xbb9b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28a22(%rip), %rdi     # 0x345cf
leaq 0x2847d(%rip), %rsi     # 0x34031
leaq 0x28a5a(%rip), %rcx     # 0x34615
movl $0xd4, %edx
callq 0x72e0
jmp 0xbbc7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xbbe1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0xc480
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0xc448
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xc448
movl $0x20, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7480
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %r9, (%rsp)
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq 0x11369
leaq 0x27941(%rip), %rsi     # 0x34680
movq %r12, %rdi
callq 0xcea0
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xcf36
leaq 0x27931(%rip), %rsi     # 0x3468c
movq %rax, %rdi
callq 0xcfdc
movq %rsp, %rsi
movq %rax, %rdi
callq 0xcf36
leaq 0x27914(%rip), %rsi     # 0x34689
movq %rax, %rdi
callq 0xcfdc
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xcf36
leaq 0x278fe(%rip), %rsi     # 0x3468f
movq %rax, %rdi
callq 0xcea0
movq %rax, %r12
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0xcb02
leaq 0x38(%rsp), %rsi
movq %r12, %rdi
callq 0xd072
leaq 0x278de(%rip), %rsi     # 0x3469b
movq %rax, %rdi
callq 0xd0fe
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xcb02
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0xd072
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11294
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xce08
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xce23
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0xc1aa
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0xbfbb
jmp 0xce6a
jmp 0xce8a
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xce6d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0xce6d
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xce8d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0xce8d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xbc1e
movq %rbx, %rdi
callq 0x7960
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rsi, %rcx
testq %rdi, %rdi
je 0xd3d0
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x7380
leaq 0x272d0(%rip), %rsi     # 0x346a7
movl $0x4, %edx
movq %rcx, %rdi
jmp 0x7560
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0xd856
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
movl $0x8, %r15d
cmpl %eax, (%rsi)
jg 0xd7db
movl $0x10, %r15d
jge 0xd7eb
movq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0xd7aa
movq %rax, (%rbx,%r15)
movq 0x8(%rbx), %rax
xorl %edx, %edx
movl $0x0, %ecx
testq %rax, %rax
je 0xd7fe
movl 0x18(%rax), %ecx
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0xd80a
movl 0x18(%rsi), %edx
subl %edx, %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
cmpl $0x2, %edx
jb 0xd82f
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd866
movq (%rbx), %rbx
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movl $0x0, %edx
testq %rax, %rax
je 0xd83e
movl 0x18(%rax), %edx
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xd84a
movl 0x18(%rax), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, 0x18(%rbx)
jmp 0xd859
movq %rdx, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::doRotation(node<int>*&)
void AVLTree< itemType >::doRotation( node< itemType > *&root ) {
	int direction[ 2 ] = { 0 };
	node< itemType > *up = root , *middle , *down;
	// check for nullptr
	if ( up->getLeftChildHeight() > up->getRightChildHeight() ) {
		middle = up->getLeftChild();
		direction[ 0 ] = -1;
	}
	else {
		middle = up->getRightChild();
		direction[ 0 ] = 1;
	}

	if ( middle->getLeftChildHeight() > middle->getRightChildHeight() ) {
		down = middle->getLeftChild();
		direction[ 1 ] = -1;
	}
	else {
		down = middle->getRightChild();
		direction[ 1 ] = 1;
	}
	if ( direction[ 1 ] == 1 && direction[ 0 ] == 1 ) { // LL rotation
		root = this->leftRotation( up , middle );
	}
	else if ( direction[ 1 ] == -1 && direction[ 0 ] == -1 ) { // RR rotation
		root = this->rightRotation( up , middle );
	}
	else if ( direction[ 1 ] == 1 && direction[ 0 ] == -1 ) { // RL rotation
		middle = this->leftRotation( middle , down );
		up->setLeftChild( middle );

		root = this->rightRotation( up , middle );
	}
	else { // LR rotation
		middle = this->rightRotation( middle , down );
		up->setRightChild( middle );

		root = this->leftRotation( up , middle );
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r14
movq 0x8(%r14), %rdx
xorl %esi, %esi
movl $0x0, %edi
testq %rdx, %rdx
je 0xd887
movl 0x18(%rdx), %edi
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd893
movl 0x18(%rax), %esi
cmpl %esi, %edi
movq %rax, %r8
cmovgq %rdx, %r8
movq 0x8(%r8), %rcx
xorl %r9d, %r9d
movl $0x0, %r10d
testq %rcx, %rcx
je 0xd8b2
movl 0x18(%rcx), %r10d
movq 0x10(%r8), %r8
testq %r8, %r8
je 0xd8bf
movl 0x18(%r8), %r9d
cmpl %r9d, %r10d
jle 0xd8d0
cmpl %esi, %edi
jle 0xd8f6
movq %r15, %rdi
movq %r14, %rsi
jmp 0xd8ef
cmpl %esi, %edi
jle 0xd908
movq %r15, %rdi
movq %rdx, %rsi
movq %r8, %rdx
callq 0xd920
movq %rax, 0x8(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd970
jmp 0xd916
movq %r15, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0xd970
movq %rax, 0x10(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd920
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdx, %rax
movq 0x8(%rdx), %rdx
movq %rdx, 0x10(%rsi)
movq %rsi, 0x8(%rax)
movq 0x8(%rsi), %r8
xorl %ecx, %ecx
movl $0x0, %edi
testq %r8, %r8
je 0xd943
movl 0x18(%r8), %edi
testq %rdx, %rdx
je 0xd94b
movl 0x18(%rdx), %ecx
cmpl %ecx, %edi
cmovgl %edi, %ecx
incl %ecx
movl %ecx, 0x18(%rsi)
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0xd963
movl 0x18(%rdx), %edx
jmp 0xd965
xorl %edx, %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
incl %edx
movl %edx, 0x18(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdx, %rax
movq 0x10(%rdx), %rdi
movq %rdi, 0x8(%rsi)
movq %rsi, 0x10(%rdx)
xorl %ecx, %ecx
movl $0x0, %edx
testq %rdi, %rdi
je 0xd98e
movl 0x18(%rdi), %edx
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0xd99a
movl 0x18(%rdi), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, 0x18(%rsi)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xd9b2
movl 0x18(%rdx), %edx
jmp 0xd9b4
xorl %edx, %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, 0x18(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0xdda6
testq %r14, %r14
je 0xdcbe
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0xdcaf
movq %r14, (%rax)
addq $0x8, 0x40(%rsp)
jmp 0xdcbe
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xdf1c
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
je 0xdd73
leaq 0x3b89b(%rip), %r14     # 0x49570
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movq (%rax), %r13
movq 0x30(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0xdcf4
addq $0x8, %rax
jmp 0xdd26
movq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x7480
movq 0x38(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq *%rbx
movq 0x8(%r13), %rax
testq %rax, %rax
je 0xdd4b
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe130
movq 0x10(%r13), %rax
testq %rax, %rax
je 0xdd63
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe130
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
jne 0xdcdd
leaq 0x10(%rsp), %rdi
callq 0xe246
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xdd91
jmp 0xdd91
jmp 0xdd91
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe246
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2827c
movq (%r14), %r14
movq %r14, %rdi
callq 0x7620
testq %rax, %rax
je 0xe2d7
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0xe2d7
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0xe2f1
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x7480
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x2827c
movq (%r14), %r15
movq %r15, %rdi
callq 0x7620
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0xe33d
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x7480
testq %r14, %r14
cmovneq %r14, %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x280ca(%rip), %rdx     # 0x36437
movq %rdx, %rsi
callq 0x30548
leaq 0x28cb2(%rip), %rdi     # 0x3702e
callq 0x7620
testq %rax, %rax
je 0xe43d
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28ca0(%rip), %rsi     # 0x3703e
leaq 0x28c9d(%rip), %rdx     # 0x37042
leaq 0x8(%rsp), %rdi
callq 0x30548
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7a30
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xe3e3
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0xe3ea
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7630
movq (%r14), %rdi
cmpq %r15, %rdi
je 0xe426
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7480
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe43d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe46b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0xe46b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xe47e
movq (%r15), %rsi
incq %rsi
callq 0x7480
movq %r14, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::Random::Generate(unsigned int)
UInt32 Random::Generate(UInt32 range) {
  // These constants are the same as are used in glibc's rand(3).
  // Use wider types than necessary to prevent unsigned overflow diagnostics.
  state_ = static_cast<UInt32>(1103515245ULL*state_ + 12345U) % kMaxRange;

  GTEST_CHECK_(range > 0)
      << "Cannot generate a number in the range [0, 0).";
  GTEST_CHECK_(range <= kMaxRange)
      << "Generation of a number in [0, " << range << ") was requested, "
      << "but this can only generate numbers in [0, " << kMaxRange << ").";

  // Converting via modulus introduces a bit of downward bias, but
  // it's simple, and a linear congruential generator isn't too good
  // to begin with.
  return state_ % range;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax           # imm = 0x3039
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0xe6e2
cmpl $0x80000001, %ebx       # imm = 0x80000001
jb 0xe737
leaq 0x2760f(%rip), %rdx     # 0x35c4c
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x168, %ecx            # imm = 0x168
callq 0x27dfe
movq 0x3a990(%rip), %rdi     # 0x48fe8
leaq 0x2765d(%rip), %rsi     # 0x35cbc
movl $0x25, %edx
callq 0x7560
movq 0x3a978(%rip), %rdi     # 0x48fe8
leaq 0x2766b(%rip), %rsi     # 0x35ce2
movl $0x1e, %edx
callq 0x7560
movl %ebx, %esi
movq 0x3a95e(%rip), %rdi     # 0x48fe8
callq 0x72f0
movq %rax, %r15
leaq 0x27668(%rip), %rsi     # 0x35d01
movl $0x11, %edx
movq %rax, %rdi
callq 0x7560
leaq 0x27666(%rip), %rsi     # 0x35d13
movl $0x2a, %edx
movq %r15, %rdi
callq 0x7560
movl $0x80000000, %esi       # imm = 0x80000000
movq %r15, %rdi
callq 0x72f0
leaq 0x275eb(%rip), %rsi     # 0x35cb9
movl $0x2, %edx
movq %rax, %rdi
callq 0x7560
leaq 0x8(%rsp), %rdi
jmp 0xe732
leaq 0x27563(%rip), %rdx     # 0x35c4c
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x166, %ecx            # imm = 0x166
callq 0x27dfe
movq 0x3a8e4(%rip), %rdi     # 0x48fe8
leaq 0x27566(%rip), %rsi     # 0x35c71
movl $0x1c, %edx
callq 0x7560
movq 0x3a8cc(%rip), %rdi     # 0x48fe8
leaq 0x2756b(%rip), %rsi     # 0x35c8e
movl $0x2d, %edx
callq 0x7560
leaq 0xc(%rsp), %rdi
callq 0x27f40
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0xe75c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27f40
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3a712(%rip), %r14     # 0x497a0
movq %r14, %rdi
movl $0x3a, %esi
callq 0x71c0
testq %rax, %rax
je 0xf0b7
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x30548
jmp 0xf0c7
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a3b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x110(%rdi), %rax
testq %rax, %rax
je 0x10805
addq $0x90, %rax
retq
movq 0x108(%rdi), %rax
testq %rax, %rax
je 0x10816
subq $-0x80, %rax
retq
addq $0x118, %rdi            # imm = 0x118
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::ColoredPrintf(testing::internal::GTestColor, char const*, ...)
static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
    GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
  const bool use_color = AlwaysFalse();
#else
  static const bool in_color_mode =
      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
  const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.

  if (!use_color) {
    vprintf(fmt, args);
    va_end(args);
    return;
  }

#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);

  // Gets the current text color.
  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
  const WORD old_color_attrs = buffer_info.wAttributes;
  const WORD new_color = GetNewColor(color, old_color_attrs);

  // We need to flush the stream buffers into the console before each
  // SetConsoleTextAttribute call lest it affect the text that is already
  // printed but has not yet reached the console.
  fflush(stdout);
  SetConsoleTextAttribute(stdout_handle, new_color);

  vprintf(fmt, args);

  fflush(stdout);
  // Restores the text color.
  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
#else
  printf("\033[0;3%sm", GetAnsiColorCode(color));
  vprintf(fmt, args);
  printf("\033[m");  // Resets the terminal to default.
#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  va_end(args);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x16df8
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movb 0x32b32(%rip), %al      # 0x49950
testb %al, %al
je 0x16e7f
testl %ebp, %ebp
je 0x16e6a
cmpb $0x0, 0x32b1b(%rip)     # 0x49948
je 0x16e6a
movslq %ebp, %rax
leaq 0x1ed73(%rip), %rcx     # 0x35bac
movslq -0x4(%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x2055c(%rip), %rdi     # 0x373a4
xorl %eax, %eax
callq 0x7080
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7490
leaq 0x2054c(%rip), %rdi     # 0x373ad
xorl %eax, %eax
callq 0x7080
jmp 0x16e75
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7490
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
callq 0x7ac0
jmp 0x16e22
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x183fc
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7320
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x18548
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x111a9
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x7530
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x183a0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7440
movq 0x30be9(%rip), %rsi     # 0x48f98
leaq 0x20(%rsp), %rdi
callq 0x7360
leaq 0xa0(%rsp), %rdi
callq 0x7170
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x183d3
movq %rax, %rbx
movq 0x30bbb(%rip), %rsi     # 0x48f98
leaq 0x20(%rsp), %rdi
callq 0x7360
leaq 0xa0(%rsp), %rdi
callq 0x7170
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a4d6
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x27794
leaq 0x8(%rsp), %rdi
callq 0x2798e
testb %al, %al
je 0x18448
movq (%rbx), %rdi
leaq 0x1e5a3(%rip), %rsi     # 0x369de
callq 0x75c0
movq %rax, %r14
testq %rax, %rax
jne 0x184af
leaq 0x1d7fd(%rip), %rdx     # 0x35c4c
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xcf, %ecx
callq 0x27dfe
movq 0x30b7e(%rip), %rdi     # 0x48fe8
leaq 0x1ef66(%rip), %rsi     # 0x373d7
movl $0x15, %edx
callq 0x7560
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x30b5f(%rip), %rdi     # 0x48fe8
callq 0x7560
leaq 0x1e2ab(%rip), %rsi     # 0x36740
movl $0x1, %edx
movq %rax, %rdi
callq 0x7560
leaq 0x4(%rsp), %rdi
callq 0x27f40
xorl %r14d, %r14d
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x184ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x184e5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7480
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x184f2
movq %rax, %rbx
jmp 0x18509
movq %rax, %rbx
jmp 0x18524
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x27f40
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18524
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1853f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7960
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x183fc
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7320
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x18c2c
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x111a9
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x7530
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x18bd0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7440
movq 0x303b9(%rip), %rsi     # 0x48f98
leaq 0x20(%rsp), %rdi
callq 0x7360
leaq 0xa0(%rsp), %rdi
callq 0x7170
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x18c03
movq %rax, %rbx
movq 0x3038b(%rip), %rsi     # 0x48f98
leaq 0x20(%rsp), %rdi
callq 0x7360
leaq 0xa0(%rsp), %rdi
callq 0x7170
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                  int /*iteration*/) {
  FILE* jsonout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintJsonUnitTest(&stream, unit_test);
  fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
  fclose(jsonout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x183fc
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7320
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1b83a
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x111a9
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x7530
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x1b7de
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7440
movq 0x2d7ab(%rip), %rsi     # 0x48f98
leaq 0x20(%rsp), %rdi
callq 0x7360
leaq 0xa0(%rsp), %rdi
callq 0x7170
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x1b811
movq %rax, %rbx
movq 0x2d77d(%rip), %rsi     # 0x48f98
leaq 0x20(%rsp), %rdi
callq 0x7360
leaq 0xa0(%rsp), %rdi
callq 0x7170
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
    const TestResult& result, const std::string& indent) {
  Message attributes;
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    attributes << ",\n" << indent << "\"" << property.key() << "\": "
               << "\"" << EscapeJson(property.value()) << "\"";
  }
  return attributes.GetString();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x38(%rsp)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x10f40
movq 0x58(%r12), %rax
subq 0x50(%r12), %rax
shrq $0x6, %rax
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
testl %eax, %eax
jle 0x1de74
movq 0x10(%rsp), %rax
leaq 0x10(%rax), %r13
xorl %ebp, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x146fa
movq %rax, %r14
movl $0x2, %edx
movq %r13, %rdi
leaq 0x189e4(%rip), %rsi     # 0x36743
callq 0x7560
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r13, %rdi
callq 0x7560
movl $0x1, %edx
movq %r13, %rdi
leaq 0x189be(%rip), %rsi     # 0x36740
callq 0x7560
movq (%r14), %rbx
testq %rbx, %rbx
je 0x1dd9c
movq %rbx, %rdi
callq 0x71e0
movq %rax, %rdx
jmp 0x1dda8
movl $0x6, %edx
leaq 0x168f8(%rip), %rbx     # 0x346a0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7560
movl $0x3, %edx
movq %r13, %rdi
leaq 0x18959(%rip), %rsi     # 0x3671b
callq 0x7560
movl $0x1, %edx
movq %r13, %rdi
leaq 0x1896a(%rip), %rsi     # 0x36740
callq 0x7560
movq 0x20(%r14), %rsi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
leaq 0xf(%rsp), %rdx
callq 0x2a3b0
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x1cb1e
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r13, %rdi
callq 0x7560
movl $0x1, %edx
movq %r13, %rdi
leaq 0x18921(%rip), %rsi     # 0x36740
callq 0x7560
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1de40
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7480
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1de5c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7480
incl %ebp
movq 0x58(%r12), %rax
subq 0x50(%r12), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x1dd43
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x111a9
testq %r14, %r14
je 0x1de97
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1defc
jmp 0x1def4
movq %rax, %rbx
jmp 0x1ded4
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1ded4
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7480
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1def7
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0x1def7
jmp 0x1def4
movq %rax, %rbx
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x1df0a
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x71e0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x7860
leaq 0x18(%rsp), %r13
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x28(%rsp), %r15
leaq 0x17eac(%rip), %r12     # 0x36760
movzbl (%r14), %eax
cmpq $0x3d, %rax
ja 0x1e97b
btq %rax, %rbp
jae 0x1e976
movzbl %al, %esi
movq %r15, %rdi
callq 0x1455c
movl $0x1, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x7540
movq %r13, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1e90f
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1e917
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x7150
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1e958
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1e986
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0x1e986
testq %rax, %rax
je 0x1e98e
movsbl %al, %esi
movq %rbx, %rdi
callq 0x73e0
incq %r14
jmp 0x1e8b4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e9c0
jmp 0x1e9c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1e9c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0x1e9c8
movq %rax, %r14
jmp 0x1e9e4
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1e9e4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7480
movq (%rsp), %rax
movq (%rbx), %rdi
cmpq %rax, %rdi
je 0x1e9fb
movq (%rax), %rsi
incq %rsi
callq 0x7480
movq %r14, %rdi
callq 0x7960
nop
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ConfigureXmlOutput()
void UnitTestImpl::ConfigureXmlOutput() {
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
  if (output_format == "xml") {
    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format == "json") {
    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format != "") {
    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
                        << output_format << "\" ignored.";
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xf080
leaq 0x15303(%rip), %rsi     # 0x34dfc
movq %r14, %rdi
callq 0x7140
testl %eax, %eax
je 0x1fba3
leaq 0x16d84(%rip), %rsi     # 0x36894
leaq 0x20(%rsp), %rdi
callq 0x7140
testl %eax, %eax
je 0x1fbdd
leaq 0x1690e(%rip), %rsi     # 0x36437
leaq 0x20(%rsp), %rdi
callq 0x7140
testl %eax, %eax
je 0x1fc30
leaq 0x1610a(%rip), %rdx     # 0x35c4c
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1346, %ecx           # imm = 0x1346
callq 0x27dfe
movq 0x2948d(%rip), %rdi     # 0x48fe8
leaq 0x16d37(%rip), %rsi     # 0x36899
movl $0x25, %edx
callq 0x7560
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x2946b(%rip), %rdi     # 0x48fe8
callq 0x7560
leaq 0x16d36(%rip), %rsi     # 0x368bf
movl $0xa, %edx
movq %rax, %rdi
callq 0x7560
movq %rsp, %rdi
callq 0x27f40
jmp 0x1fc30
movl $0x28, %edi
callq 0x7450
movq %rax, %r14
movq %rsp, %rdi
callq 0xf0d2
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x1829e
addq $0x190, %rbx            # imm = 0x190
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ed38
jmp 0x1fc15
movl $0x28, %edi
callq 0x7450
movq %rax, %r14
movq %rsp, %rdi
callq 0xf0d2
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x1b6dc
addq $0x190, %rbx            # imm = 0x190
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ed38
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fc30
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fc4b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7480
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1fc58
jmp 0x1fc5f
movq %rax, %rbx
jmp 0x1fc94
jmp 0x1fc71
movq %rax, %rbx
jmp 0x1fca1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27f40
jmp 0x1fca1
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fc8f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7480
testb %bpl, %bpl
je 0x1fca1
movl $0x28, %esi
movq %r14, %rdi
callq 0x7480
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fcbc
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::InDeathTestChild()
bool InDeathTestChild() {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA

  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
  // of the death_test_style flag.
  return !GTEST_FLAG(internal_run_death_test).empty();

# else

  if (GTEST_FLAG(death_test_style) == "threadsafe")
    return !GTEST_FLAG(internal_run_death_test).empty();
  else
    return g_in_fast_death_test_child;
#endif
}

// Assembly:
pushq %rax
leaq 0x287b6(%rip), %rdi     # 0x498e8
leaq 0x159dd(%rip), %rsi     # 0x36b16
callq 0x7140
xorl %ecx, %ecx
cmpq $0x0, 0x28788(%rip)     # 0x498d0
setne %cl
testl %eax, %eax
movzbl 0x287b5(%rip), %eax     # 0x49909
cmovel %ecx, %eax
andb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**)
static void CaptureStream(int fd, const char* stream_name,
                          CapturedStream** stream) {
  if (*stream != NULL) {
    GTEST_LOG_(FATAL) << "Only one " << stream_name
                      << " capturer can exist at a time.";
  }
  *stream = new CapturedStream(fd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x28055
movq %rsi, %r14
leaq 0xef57(%rip), %rdx      # 0x36f22
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x437, %ecx            # imm = 0x437
callq 0x27dfe
movq 0x21002(%rip), %r15     # 0x48fe8
leaq 0xfa3b(%rip), %rsi      # 0x37a28
movl $0x9, %edx
movq %r15, %rdi
callq 0x7560
testq %r14, %r14
je 0x2801b
movq %r14, %rdi
callq 0x71e0
movq 0x20fda(%rip), %rdi     # 0x48fe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x7560
jmp 0x28033
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x78f0
movq 0x20fae(%rip), %rdi     # 0x48fe8
leaq 0xf9f1(%rip), %rsi      # 0x37a32
movl $0x1e, %edx
callq 0x7560
leaq 0x4(%rsp), %rdi
callq 0x27f40
movl $0x28, %edi
callq 0x7450
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x30384
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x7480
jmp 0x28099
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x27f40
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O3/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*)
static CharFormat PrintCharsAsStringTo(
    const CharType* begin, size_t len, ostream* os) {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  CharFormat print_format = kAsIs;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << kQuoteBegin;
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
    // Remember if any characters required hex escaping.
    if (is_previous_hex) {
      print_format = kHexEscape;
    }
  }
  *os << "\"";
  return print_format;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xe1d0(%rip), %rsi      # 0x36740
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7560
testq %r14, %r14
je 0x285e5
xorl %ecx, %ecx
xorl %r13d, %r13d
xorl %ebp, %ebp
movzbl (%r15,%r13), %r12d
testb $0x1, %cl
je 0x285c7
movl %r12d, %edi
callq 0x70f0
testl %eax, %eax
je 0x285c7
movl $0x2, %edx
movq %rbx, %rdi
leaq 0xf6e8(%rip), %rsi      # 0x37c96
callq 0x7560
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xe17e(%rip), %rsi      # 0x36740
callq 0x7560
movl %r12d, %edi
movq %rbx, %rsi
callq 0x2a365
cmpl $0x1, %eax
sete %cl
cmovel %eax, %ebp
incq %r13
cmpq %r13, %r14
jne 0x28589
jmp 0x285e7
xorl %ebp, %ebp
leaq 0xe152(%rip), %rsi      # 0x36740
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7560
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq