LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: operator<<(std::ostream&, Polygon&)
std::ostream & operator<<(std::ostream & out, Polygon & p)
{
  //gnuplotstyle
  for(int i=0;i<p.size();++i)
  {
    Point f=p[i].first;
    Point s=p[i].second;
    out << f << std::endl << s << std::endl << std::endl;
  }
  
  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
testl %ecx, %ecx
jle 0x2128
movq %rsi, %r14
movl $0xc, %r15d
xorl %r12d, %r12d
movq -0xc(%rax,%r15), %rcx
movq %rcx, -0x38(%rbp)
movq -0x4(%rax,%r15), %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
leaq -0x38(%rbp), %rsi
callq 0x13dc
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %r13, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x13dc
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %r13, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %r13, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
movslq %ecx, %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jl 0x205f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/demo.new.cpp
// Function: main
int main()
{
	std::cout << std::unitbuf; // set no buffer for stdout
	test_constructors();
	test_json_node_values();
	test_assignments();
	test_append();
	test_parser();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb7e8(%rip), %rax      # 0x13fd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
orl $0x2000, 0x18(%rax,%rcx) # imm = 0x2000
callq 0x26cc
callq 0x4273
callq 0x47d7
callq 0x5f69
callq 0x7f75
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/./json.hpp
// Function: int yll::json::as_number<int>() const
T as_number() const {
			assert(type_ == type::number);
			std::istringstream ss(text_);
			T v;
			ss >> v;
			return v;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
cmpl $0x2, (%rdi)
jne 0x9088
movq %rdi, %rsi
addq $0x8, %rsi
leaq -0x190(%rbp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x2350
leaq -0xc(%rbp), %rsi
movq %rbx, %rdi
callq 0x2100
movl -0xc(%rbp), %ebx
movq 0xaf6c(%rip), %rsi      # 0x13fd0
leaq -0x190(%rbp), %rdi
callq 0x22c0
leaq -0x118(%rbp), %rdi
callq 0x20a0
movl %ebx, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
leaq 0x6bb1(%rip), %rdi      # 0xfc40
leaq 0x69a6(%rip), %rsi      # 0xfa3c
leaq 0x6bb9(%rip), %rcx      # 0xfc56
movl $0x45, %edx
callq 0x2130
movq %rax, %rbx
movq 0xaf1f(%rip), %rsi      # 0x13fd0
leaq -0x190(%rbp), %rdi
callq 0x22c0
leaq -0x118(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long*, bool)
bool parse(const std::string& text, size_t* pos = nullptr, bool strict = true) {
			const char* p = text.c_str();
			if (!parse_value(p, *this, strict)) {
				if (pos) *pos = p - text.c_str();
				return false;
			}
			skip_spaces(p);
			if (pos) *pos = p - text.c_str();
			return (!*p);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq (%r14), %rax
leaq -0x18(%rbp), %rdi
movq %rax, (%rdi)
movl %ecx, %edx
callq 0xd216
testb %al, %al
je 0x9df5
leaq -0x18(%rbp), %rdi
callq 0xd550
testq %rbx, %rbx
je 0x9de9
movq -0x18(%rbp), %rax
subq (%r14), %rax
movq %rax, (%rbx)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
sete %al
jmp 0x9e06
testq %rbx, %rbx
je 0x9e04
movq -0x18(%rbp), %rax
subq (%r14), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::trim0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::string trim0(std::string s) {
			if (s.find('.') != std::string::npos) {
				s.erase(s.find_last_not_of('0') + 1, std::string::npos);
				s.erase(s.find_last_not_of('.') + 1, std::string::npos);
			}
			return s;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0x22b0
cmpq $-0x1, %rax
je 0xb37c
movq %r14, %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x2160
incq %rax
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
jb 0xb3c1
movq %rax, 0x8(%r14)
movq (%r14), %rcx
movb $0x0, (%rcx,%rax)
movq %r14, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x2160
incq %rax
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
jb 0xb3c1
movq %rax, 0x8(%r14)
movq (%r14), %rcx
movb $0x0, (%rcx,%rax)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0xb39b
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xb3a1
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x46e5(%rip), %rdi      # 0xfaad
leaq 0x475c(%rip), %rsi      # 0xfb2b
movq %rax, %rdx
xorl %eax, %eax
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::swap(yll::json&)
void swap(json& j) {
			using std::swap;
			swap(type_, j.type_);
			swap(text_, j.text_);
			swap(array_, j.array_);
			swap(object_, j.object_);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movl (%rsi), %ecx
movl %ecx, (%rdi)
movl %eax, (%rsi)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x21a0
movups 0x28(%r14), %xmm0
movq 0x38(%r14), %rax
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%r14)
movq 0x30(%rbx), %rcx
movq %rcx, 0x30(%r14)
movq 0x38(%rbx), %rcx
movq %rcx, 0x38(%r14)
movups %xmm0, 0x28(%rbx)
movq %rax, 0x38(%rbx)
addq $0x40, %r14
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xbc08
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::clear(yll::json::type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void clear(type t = type::null, const std::string s = "") {
			type_ = t;
			text_ = s;
			array_.clear();
			object_.clear();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
callq 0x20f0
leaq 0x28(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0xcb80
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xcbe2
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::skip_spaces(char const*&)
static void skip_spaces(const char*& s) {
			while (*s) {
				if (isspace(*s)) {
					++s;
				} else if (*s == '/' && *(s + 1) == '*') { // Skip comments
					s += 2;
					while (*s) {
						if (*s == '*' && *(s + 1) == '/') {
							s += 2;
							break;
						}
						++s;
					}
				} else {
					break;
				}
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movb (%r14), %r15b
testb %r15b, %r15b
je 0xd5b8
movq %rdi, %rbx
movsbl %r15b, %edi
callq 0x2050
testl %eax, %eax
je 0xd57a
incq %r14
jmp 0xd5ad
cmpb $0x2f, %r15b
jne 0xd5b8
cmpb $0x2a, 0x1(%r14)
jne 0xd5b8
addq $0x2, %r14
movq %r14, (%rbx)
movzbl (%r14), %eax
cmpl $0x2a, %eax
je 0xd59d
testl %eax, %eax
jne 0xd5a4
jmp 0xd5b0
cmpb $0x2f, 0x1(%r14)
je 0xd5a9
incq %r14
jmp 0xd58b
addq $0x2, %r14
movq %r14, (%rbx)
movb (%r14), %r15b
testb %r15b, %r15b
jne 0xd568
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::parse_number(char const*&, yll::json&)
static bool parse_number(const char*& s, json& v) {
			const char* s0 = s;
			skip_spaces(s);
			if (*s == '-' || *s == '+') ++s;
			if (!isdigit(*s) && *s != '.') return false; else ++s;
			while (isdigit(*s)) ++s;
			if (*s == '.') {
				++s;
				while (isdigit(*s)) ++s;
			}
			if (*s == 'e' || *s == 'E') {
				++s;
				if (*s == '+' || *s == '-') ++s;
				if (!isdigit(*s)) return false; else ++s;
				while (isdigit(*s)) ++s;
			}
			v.clear(type::number, std::string(s0, s));
			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
callq 0xd550
movq (%r15), %rax
movzbl (%rax), %ecx
cmpl $0x2d, %ecx
je 0xd913
cmpl $0x2b, %ecx
jne 0xd919
incq %rax
movq %rax, (%r15)
movq (%r15), %rax
movsbl (%rax), %ecx
cmpl $0x2e, %ecx
setne %dl
addl $-0x30, %ecx
cmpl $0xa, %ecx
setae %cl
testb %cl, %dl
jne 0xd9f0
incq %rax
movq %rax, (%r15)
movsbl (%rax), %ecx
leal -0x30(%rcx), %edx
incq %rax
cmpl $0xa, %edx
jb 0xd939
cmpb $0x2e, %cl
jne 0xd960
movq %rax, (%r15)
movsbl (%rax), %ecx
addl $-0x30, %ecx
incq %rax
cmpl $0xa, %ecx
jb 0xd94f
movq (%r15), %rax
movzbl (%rax), %ecx
orl $0x20, %ecx
cmpl $0x65, %ecx
jne 0xd9ac
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
movzbl 0x1(%rax), %ecx
cmpl $0x2d, %ecx
je 0xd983
cmpl $0x2b, %ecx
jne 0xd98a
addq $0x2, %rax
movq %rax, (%r15)
movq (%r15), %rax
movsbl (%rax), %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0xd9f0
incq %rax
movq %rax, (%r15)
movsbl (%rax), %ecx
addl $-0x30, %ecx
incq %rax
cmpl $0xa, %ecx
jb 0xd99b
movq (%r15), %rdx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xe00e
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0xcaca
movq -0x40(%rbp), %rdi
movb $0x1, %bl
cmpq %r12, %rdi
je 0xd9f2
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0xd9f2
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xda19
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::parse_array(char const*&, yll::json&, bool)
static bool parse_array(const char*& s, json& v, bool strict) {
			skip_spaces(s);
			if (*s != '[') return false; else ++s;
			skip_spaces(s);
			v.clear(type::array);
			if (*s != ']') {
				for (;;) {
					if (!strict) {
						skip_spaces(s);
						if (*s == ',') {
							++s;
							continue;
						} else if (*s == ']') {
							break;
						}
					}
					json o;
					if (!parse_value(s, o, strict)) return false;
					skip_spaces(s);
					v.append(o);
					if (*s == ']') break;
					if (*s == '}') return false;
					if (*s == ',') {
						++s;
					} else {
						if (strict) return false;
					}
				}
			}
			++s;
			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %r14d
movq %rsi, %r13
movq %rdi, %rbx
callq 0xd550
movq (%rbx), %rax
cmpb $0x5b, (%rax)
jne 0xdfc1
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0xd550
leaq -0x48(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1df1(%rip), %rdx      # 0xfc3f
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xe00e
movq %r13, %rdi
movl $0x4, %esi
movq %r15, %rdx
callq 0xcaca
movq %r13, -0x38(%rbp)
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0xde86
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2220
movq (%rbx), %rax
cmpb $0x5d, (%rax)
je 0xdfc5
leaq -0xa0(%rbp), %r12
xorl %r15d, %r15d
movzbl %r14b, %eax
movl %eax, -0x2c(%rbp)
testb %r14b, %r14b
jne 0xdec8
movq %rbx, %rdi
callq 0xd550
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
je 0xdf60
cmpl $0x5d, %ecx
je 0xdfc5
movl %r15d, -0xc8(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq %r15, -0xb8(%rbp)
movb $0x0, -0xb0(%rbp)
movq %r15, 0x10(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movl %r15d, -0x80(%rbp)
movq %r15, -0x78(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq %r15, -0x60(%rbp)
movq %rbx, %rdi
leaq -0xc8(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0xd216
movl $0x1, %r13d
testb %al, %al
je 0xdf7c
movq %rbx, %rdi
callq 0xd550
movq -0x38(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x91de
movq (%rbx), %rcx
movzbl (%rcx), %eax
cmpl $0x2c, %eax
je 0xdf73
cmpl $0x5d, %eax
je 0xdf6b
cmpl $0x7d, %eax
je 0xdf7c
testb %r14b, %r14b
je 0xdf79
jmp 0xdf7c
incq %rax
movq %rax, (%rbx)
jmp 0xdea3
movl $0x2, %r13d
jmp 0xdf7c
incq %rcx
movq %rcx, (%rbx)
xorl %r13d, %r13d
leaq -0x88(%rbp), %rdi
callq 0xb90e
movq %r12, %rdi
callq 0xabf8
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0xdfb2
movq -0xb0(%rbp), %rsi
incq %rsi
callq 0x2220
testl %r13d, %r13d
je 0xdea3
cmpl $0x1, %r13d
jne 0xdfc5
xorl %eax, %eax
jmp 0xdfca
incq (%rbx)
movb $0x1, %al
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0xe005
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0xe005
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x8fe2
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
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 0xd968
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 0xd968
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 0xd968
movq %rax, 0x10(%r14)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x3df72(%rip), %rdi     # 0x49578
leaq 0x8(%rsp), %rsi
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb627
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq (%rbx), %rsi
leaq 0x819(%rip), %rdx       # 0xbe4a
movq %rbx, %rdi
callq 0xdece
leaq 0x3df30(%rip), %rax     # 0x49570
movq 0x3df29(%rip), %rcx     # 0x49570
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xb6d6
leaq 0x3df1b(%rip), %rsi     # 0x49578
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7880
leaq 0x28d3d(%rip), %rsi     # 0x343ae
movq %rbx, %rdi
callq 0x7140
testl %eax, %eax
jne 0xb6d6
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb694
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
leaq 0x3dec9(%rip), %rdi     # 0x49578
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb6cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28ce7(%rip), %rdi     # 0x343c4
leaq 0x2894d(%rip), %rsi     # 0x34031
leaq 0x28d11(%rip), %rcx     # 0x343fc
movl $0xae, %edx
callq 0x72e0
jmp 0xb6f7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb711
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd968
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 0xd968
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 0xd968
movq %rax, 0x10(%r14)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x3dd9e(%rip), %rdi     # 0x49578
leaq 0x8(%rsp), %rsi
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb7fb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq (%rbx), %rsi
leaq 0x645(%rip), %rdx       # 0xbe4a
movq %rbx, %rdi
callq 0xdece
leaq 0x3dd5c(%rip), %rax     # 0x49570
movq 0x3dd55(%rip), %rcx     # 0x49570
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xb8aa
leaq 0x3dd47(%rip), %rsi     # 0x49578
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7880
leaq 0x28bfa(%rip), %rsi     # 0x3443f
movq %rbx, %rdi
callq 0x7140
testl %eax, %eax
jne 0xb8aa
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb868
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
leaq 0x3dcf5(%rip), %rdi     # 0x49578
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb89f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28ba4(%rip), %rdi     # 0x34455
leaq 0x28779(%rip), %rsi     # 0x34031
leaq 0x28bce(%rip), %rcx     # 0x3448d
movl $0xb9, %edx
callq 0x72e0
jmp 0xb8cb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb8e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd968
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 0xd968
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 0xd968
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 0xd968
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 0xd968
movq %rax, 0x10(%r14)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x3d90c(%rip), %rdi     # 0x49578
leaq 0x8(%rsp), %rsi
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xbc8d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq (%rbx), %rsi
leaq 0x1b3(%rip), %rdx       # 0xbe4a
movq %rbx, %rdi
callq 0xdece
leaq 0x3d8ca(%rip), %rax     # 0x49570
movq 0x3d8c3(%rip), %rcx     # 0x49570
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xbd3c
leaq 0x3d8b5(%rip), %rsi     # 0x49578
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7880
leaq 0x288d4(%rip), %rsi     # 0x345ab
movq %rbx, %rdi
callq 0x7140
testl %eax, %eax
jne 0xbd3c
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xbcfa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
leaq 0x3d863(%rip), %rdi     # 0x49578
callq 0x77f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xbd31
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2888c(%rip), %rdi     # 0x345cf
leaq 0x282e7(%rip), %rsi     # 0x34031
leaq 0x288c4(%rip), %rcx     # 0x34615
movl $0xd4, %edx
callq 0x72e0
jmp 0xbd5d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xbd77
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc612
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0xc5da
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xc5da
movl $0x20, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7480
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11689
leaq 0x277af(%rip), %rsi     # 0x34680
movq %r12, %rdi
callq 0xd032
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xd0d2
leaq 0x2779f(%rip), %rsi     # 0x3468c
movq %rax, %rdi
callq 0xd180
movq %rsp, %rsi
movq %rax, %rdi
callq 0xd0d2
leaq 0x27782(%rip), %rsi     # 0x34689
movq %rax, %rdi
callq 0xd180
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xd0d2
leaq 0x2776c(%rip), %rsi     # 0x3468f
movq %rax, %rdi
callq 0xd032
movq %rax, %r12
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0xcc94
leaq 0x38(%rsp), %rsi
movq %r12, %rdi
callq 0xd220
leaq 0x2774c(%rip), %rsi     # 0x3469b
movq %rax, %rdi
callq 0xd2b6
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xcc94
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0xd220
movq %rbx, %rdi
movq %rax, %rsi
callq 0x115b4
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcf9a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcfb5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x7480
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0xc33c
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0xc14c
jmp 0xcffc
jmp 0xd01c
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcfff
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0xcfff
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd01f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0xd01f
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xbdb4
movq %rbx, %rdi
callq 0x7960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd58d
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x7380
leaq 0x27113(%rip), %rsi     # 0x346a7
movl $0x4, %edx
movq %rcx, %rdi
jmp 0x7560
// File: /workspace/github_cpp_makefile_star2_O1/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 0xda16
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %eax
movl $0x8, %r15d
cmpl %eax, (%rsi)
jg 0xd999
movl $0x10, %r15d
jge 0xd9a9
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0xd968
movq %rax, (%r14,%r15)
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rsi
xorl %ecx, %ecx
movl $0x0, %eax
testq %rsi, %rsi
je 0xd9c1
movl 0x18(%rsi), %eax
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0xd9cd
movl 0x18(%rdx), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x2, %ecx
jb 0xd9e8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xda24
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rsi
xorl %eax, %eax
movl $0x0, %ecx
testq %rsi, %rsi
je 0xda00
movl 0x18(%rsi), %ecx
movq 0x10(%rdx), %rsi
testq %rsi, %rsi
je 0xda0c
movl 0x18(%rsi), %eax
cmpl %eax, %ecx
cmovgl %ecx, %eax
incl %eax
movl %eax, 0x18(%rdx)
movq %rdx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %ecx, %ecx
movl $0x0, %esi
testq %rdx, %rdx
je 0xda45
movl 0x18(%rdx), %esi
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xda51
movl 0x18(%rax), %ecx
cmpl %ecx, %esi
setg %dil
cmovleq %rax, %rdx
movq 0x8(%rdx), %rax
xorl %r8d, %r8d
movl $0x0, %r9d
testq %rax, %rax
je 0xda71
movl 0x18(%rax), %r9d
movq 0x10(%rdx), %r10
testq %r10, %r10
je 0xda7e
movl 0x18(%r10), %r8d
cmpl %r8d, %r9d
cmovleq %r10, %rax
cmpl %ecx, %esi
jg 0xda9b
cmpl %r8d, %r9d
jg 0xda9b
movq %r15, %rdi
movq %r14, %rsi
callq 0xdb02
jmp 0xdadb
cmpl %ecx, %esi
jle 0xdaac
cmpl %r8d, %r9d
jle 0xdaac
movq %r15, %rdi
movq %r14, %rsi
jmp 0xdad6
cmpl %r8d, %r9d
setg %cl
xorb $0x1, %dil
orb %cl, %dil
jne 0xdae4
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xdb02
movq %rax, 0x8(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xdb5c
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xdb5c
movq %rax, 0x10(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
jmp 0xda94
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdb25
movl 0x18(%r8), %edi
testq %rdx, %rdx
je 0xdb2d
movl 0x18(%rdx), %ecx
cmpl %ecx, %edi
cmovgl %edi, %ecx
incl %ecx
movl %ecx, 0x18(%rsi)
movq 0x10(%rax), %r8
xorl %edx, %edx
movl $0x0, %edi
testq %r8, %r8
je 0xdb4b
movl 0x18(%r8), %edi
testq %rsi, %rsi
cmovel %edx, %ecx
cmpl %edi, %ecx
cmovlel %edi, %ecx
incl %ecx
movl %ecx, 0x18(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdb7a
movl 0x18(%rdi), %edx
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0xdb86
movl 0x18(%rdi), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, 0x18(%rsi)
movq 0x8(%rax), %r8
xorl %edx, %edx
movl $0x0, %edi
testq %r8, %r8
je 0xdba4
movl 0x18(%r8), %edi
testq %rsi, %rsi
cmovel %edx, %ecx
cmpl %ecx, %edi
cmovgl %edi, %ecx
incl %ecx
movl %ecx, 0x18(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rsi, %rsi
je 0xde2f
movl (%rsi), %eax
cmpl %edx, %eax
je 0xde32
movl $0x8, %eax
jg 0xde29
movl $0x10, %eax
jge 0xde2f
movq (%rsi,%rax), %rsi
jmp 0xde10
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 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 0xe024
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xdf3c
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0xdf2d
movq %rax, (%rcx)
addq $0x8, 0x40(%rsp)
jmp 0xdf3c
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe19a
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
je 0xdff1
leaq 0x3b61d(%rip), %r14     # 0x49570
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movq (%rax), %r13
movq 0x30(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0xdf72
addq $0x8, %rax
jmp 0xdfa4
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 0xdfc9
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3ae
movq 0x10(%r13), %rax
testq %rax, %rax
je 0xdfe1
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3ae
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
jne 0xdf5b
leaq 0x10(%rsp), %rdi
callq 0xe4be
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xe00f
jmp 0xe00f
jmp 0xe00f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe4be
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28847
movq (%r14), %r14
movq %r14, %rdi
callq 0x7620
testq %rax, %rax
je 0xe54d
leaq 0x29429(%rip), %rsi     # 0x37969
movq %rax, %rdi
callq 0x7740
testl %eax, %eax
setne %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0xe567
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_O1/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 0x28847
movq (%r14), %r15
movq %r15, %rdi
callq 0x7620
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0xe5b3
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_O1/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 0x27e24(%rip), %rdx     # 0x36407
movq %rdx, %rsi
callq 0x30c22
leaq 0x28a0c(%rip), %rdi     # 0x36ffe
callq 0x7620
testq %rax, %rax
je 0xe6b3
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x289fa(%rip), %rsi     # 0x3700e
leaq 0x289f7(%rip), %rdx     # 0x37012
leaq 0x8(%rsp), %rdi
callq 0x30c22
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 0xe659
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0xe660
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 0xe69c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7480
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe6b3
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 0xe6e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7480
jmp 0xe6e1
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xe6f4
movq (%r15), %rsi
incq %rsi
callq 0x7480
movq %r14, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O1/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
jne 0xe91f
leaq 0x2734b(%rip), %rdx     # 0x35c1c
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x166, %ecx            # imm = 0x166
callq 0x283be
movq 0x3a6fc(%rip), %rdi     # 0x48fe8
leaq 0x2734e(%rip), %rsi     # 0x35c41
movl $0x1c, %edx
callq 0x7560
movq 0x3a6e4(%rip), %rdi     # 0x48fe8
leaq 0x27353(%rip), %rsi     # 0x35c5e
movl $0x2d, %edx
callq 0x7560
leaq 0xc(%rsp), %rdi
callq 0x28500
cmpl $0x80000001, %ebx       # imm = 0x80000001
jb 0xe9da
leaq 0x272ea(%rip), %rdx     # 0x35c1c
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x168, %ecx            # imm = 0x168
callq 0x283be
movq 0x3a69b(%rip), %rdi     # 0x48fe8
leaq 0x27338(%rip), %rsi     # 0x35c8c
movl $0x25, %edx
callq 0x7560
movq 0x3a683(%rip), %rdi     # 0x48fe8
leaq 0x27346(%rip), %rsi     # 0x35cb2
movl $0x1e, %edx
callq 0x7560
movl %ebx, %esi
movq 0x3a669(%rip), %rdi     # 0x48fe8
callq 0x72f0
movq %rax, %r15
leaq 0x27343(%rip), %rsi     # 0x35cd1
movl $0x11, %edx
movq %rax, %rdi
callq 0x7560
leaq 0x27341(%rip), %rsi     # 0x35ce3
movl $0x2a, %edx
movq %r15, %rdi
callq 0x7560
movl $0x80000000, %esi       # imm = 0x80000000
movq %r15, %rdi
callq 0x72f0
leaq 0x272c6(%rip), %rsi     # 0x35c89
movl $0x2, %edx
movq %rax, %rdi
callq 0x7560
leaq 0x8(%rsp), %rdi
callq 0x28500
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 0xe9ff
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x28500
movq %rbx, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x3a437(%rip), %r15     # 0x497a0
movq %r15, %rdi
movl $0x3a, %esi
callq 0x71c0
movq %rax, %rbx
testq %rax, %rax
je 0xf395
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x30c22
jmp 0xf3a5
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a9f6
testq %rbx, %rbx
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf3b7
testq %rbx, %rbx
movq %rax, %rdi
callq 0x7960
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10b3d
addq $0x90, %rax
retq
movq 0x108(%rdi), %rax
testq %rax, %rax
je 0x10b4e
subq $-0x80, %rax
retq
addq $0x118, %rdi            # imm = 0x118
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17237
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 0x326f3(%rip), %al      # 0x49950
testb %al, %al
je 0x172be
testl %ebp, %ebp
je 0x172a9
cmpb $0x0, 0x326dc(%rip)     # 0x49948
je 0x172a9
movslq %ebp, %rax
leaq 0x1e904(%rip), %rcx     # 0x35b7c
movslq -0x4(%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x200ed(%rip), %rdi     # 0x37374
xorl %eax, %eax
callq 0x7080
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7490
leaq 0x200dd(%rip), %rdi     # 0x3737d
xorl %eax, %eax
callq 0x7080
jmp 0x172b4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7490
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
callq 0x7ac0
jmp 0x17261
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1890c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7320
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x18a58
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x114c9
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x7530
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x188b0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7480
movq %rbx, %rdi
callq 0x7440
movq 0x306d9(%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 0x188e3
movq %rax, %rbx
movq 0x306ab(%rip), %rsi     # 0x48f98
leaq 0x20(%rsp), %rdi
callq 0x7360
leaq 0xa0(%rsp), %rdi
callq 0x7170
movq %rbx, %rdi
callq 0x7960