LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Hybryd[P]HyRoadGenerator/Polygon.cpp
// Function: Polygon::randPoint()
std::pair<int,Point> Polygon::randPoint()
{
  Point res(0,0);
  
  int rEdge = rand()%size();
  double t=((double)rand()/(double)RAND_MAX);
  
  res.x(poly[rEdge].first.x() + t*(poly[rEdge].second.x() - poly[rEdge].first.x()));
  res.y(poly[rEdge].first.y() + t*(poly[rEdge].second.y() - poly[rEdge].first.y()));

  return std::pair<int,Point>(rEdge,res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1030
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x4, %rcx
cltd
idivl %ecx
movl %edx, %r15d
callq 0x1030
cvtsi2sd %eax, %xmm0
divsd 0x2919(%rip), %xmm0     # 0x4050
movslq %r15d, %rax
movq (%r14), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movss (%rcx,%rdx), %xmm1
movss 0x4(%rcx,%rdx), %xmm2
cvtss2sd %xmm1, %xmm3
movss 0x8(%rcx,%rdx), %xmm4
subss %xmm1, %xmm4
cvtss2sd %xmm4, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
cvtss2sd %xmm2, %xmm3
movss 0xc(%rcx,%rdx), %xmm4
subss %xmm2, %xmm4
cvtss2sd %xmm4, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
cvtsd2ss %xmm2, %xmm0
movl %eax, (%rbx)
movss %xmm1, 0x4(%rbx)
movss %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
pushq $0xc
popq %r13
xorl %r15d, %r15d
leaq -0x30(%rbp), %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0x1d09
movq -0xc(%rax,%r13), %rcx
movq %rcx, -0x38(%rbp)
movq -0x4(%rax,%r13), %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
leaq -0x38(%rbp), %rsi
callq 0x130c
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
movq %r12, %rsi
callq 0x130c
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1070
incq %r15
addq $0x10, %r13
jmp 0x1ca9
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9f8a(%rip), %rax      # 0xefd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
orl $0x2000, 0x18(%rax,%rcx) # imm = 0x2000
callq 0x268c
callq 0x3133
callq 0x33a9
callq 0x3dd2
callq 0x4bdb
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanlinlin82[P]jsonxx/./json.hpp
// Function: float yll::json::as_number<float>() 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 0x5799
movq %rdi, %rsi
addq $0x8, %rsi
leaq -0x190(%rbp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x2350
leaq -0x10(%rbp), %rsi
movq %rbx, %rdi
callq 0x23d0
movss -0x10(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x20d0
movss -0xc(%rbp), %xmm0
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
leaq 0x5455(%rip), %rdi      # 0xabf5
leaq 0x5295(%rip), %rsi      # 0xaa3c
leaq 0x5486(%rip), %rcx      # 0xac34
pushq $0x45
popq %rdx
callq 0x2140
movq %rax, %rbx
leaq -0x190(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::append(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, yll::json const&)
json& append(const std::string& name, const json& x) {
			if (this == &x) {
				json copy(x);
				return append(name, copy);
			}
			if (type_ != type::object) { clear(type::object); }
			if (object_.find(name) == object_.end()) { array_.push_back(json(name)); }
			object_[name] = x;
			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdx, %rdi
je 0x5b49
cmpl $0x5, (%rbx)
je 0x5ad2
leaq 0x514a(%rip), %rsi      # 0xabf4
leaq -0x48(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x507a
pushq $0x5
popq %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x7eec
leaq -0x48(%rbp), %rdi
callq 0x23e8
leaq 0x40(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7b8a
leaq 0x48(%rbx), %rcx
cmpq %rcx, %rax
jne 0x5b18
leaq 0x28(%rbx), %r13
leaq -0xb8(%rbp), %rdi
movq %r14, %rsi
callq 0x5380
movq %r13, %rdi
leaq -0xb8(%rbp), %rsi
callq 0x7c14
leaq -0xb8(%rbp), %rdi
callq 0x565a
leaq -0x128(%rbp), %rdi
movq %r15, %rsi
callq 0x6538
movq %r12, %rdi
movq %r14, %rsi
callq 0x7f1e
leaq -0x128(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x7500
movq %r14, %rdi
jmp 0x5b73
leaq -0xb8(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6538
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5a78
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x565a
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ba2
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x23e8
jmp 0x5bbd
movq %rax, %rbx
jmp 0x5bbd
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
jmp 0x5bb8
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
callq 0x565a
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
json& operator [] (const std::string& name) {
			if (type_ != type::object) { clear(type::object); }
			auto it = object_.find(name);
			if (it == object_.end()) {
				array_.push_back(name);
				object_.insert(std::make_pair(name, json()));
				it = object_.find(name);
			}
			return it->second;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x5, (%rdi)
je 0x5c12
leaq 0x500a(%rip), %rsi      # 0xabf4
leaq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x507a
pushq $0x5
popq %rsi
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x7eec
leaq -0x40(%rbp), %rdi
callq 0x23e8
leaq 0x40(%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7b8a
leaq 0x48(%r15), %rcx
cmpq %rcx, %rax
jne 0x5cea
addq $0x28, %r15
leaq -0xd0(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5380
movq %r15, %rdi
movq %r12, %rsi
callq 0x7c14
leaq -0xd0(%rbp), %rdi
callq 0x565a
leaq -0x128(%rbp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rax)
movaps %xmm0, -0x8(%rax)
movaps %xmm0, 0x18(%rax)
movaps %xmm0, 0x8(%rax)
movaps %xmm0, 0x28(%rax)
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
leaq -0xf8(%rbp), %rax
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0xd0(%rbp), %rdi
leaq -0x140(%rbp), %rdx
movq %rbx, %rsi
callq 0x82ae
leaq -0xd0(%rbp), %rsi
movq %r14, %rdi
callq 0x81a0
leaq -0xd0(%rbp), %rdi
callq 0x710a
leaq -0x140(%rbp), %rdi
callq 0x565a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7b8a
addq $0x40, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x710a
jmp 0x5d12
movq %rax, %rbx
leaq -0x140(%rbp), %rdi
jmp 0x5d25
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x565a
jmp 0x5d3d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x23e8
jmp 0x5d3d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq (%r14), %rax
leaq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movl %ecx, %edx
callq 0x84a6
testb %al, %al
je 0x5e2b
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x8662
movq (%r15), %rax
testq %rbx, %rbx
je 0x5e23
movq %rax, %rcx
subq (%r14), %rcx
movq %rcx, (%rbx)
cmpb $0x0, (%rax)
sete %al
jmp 0x5e3c
testq %rbx, %rbx
je 0x5e3a
movq -0x20(%rbp), %rax
subq (%r14), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::encode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::string encode(std::string s) {
			std::stringstream ss;
			for (auto c : s) {
				switch (c) {
				case '/': ss << "\\/"; break;
				case '"': ss << "\\\""; break;
				case '\\': ss << "\\\\"; break;
				case '\b': ss << "\\b"; break;
				case '\f': ss << "\\f"; break;
				case '\n': ss << "\\n"; break;
				case '\r': ss << "\\r"; break;
				case '\t': ss << "\\t"; break;
				default:
					unsigned int u = static_cast<unsigned char>(c);
					if (u >= 0x7F) {
						ss << "\\u00"
							<< std::hex << std::uppercase
							<< static_cast<unsigned int>(u >> 4)
							<< static_cast<unsigned int>(u & 0x0F)
							<< std::dec << std::nouppercase;
					} else {
						ss << c;
					}
					break;
				}
			}
			return ss.str();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x2180
movq (%r14), %r13
movq 0x8(%r14), %r15
xorl %ebx, %ebx
leaq 0x3c99(%rip), %r14      # 0xa058
cmpq %rbx, %r15
je 0x64e9
movzbl (%r13,%rbx), %r12d
leal -0x8(%r12), %eax
cmpl $0x5, %eax
ja 0x63ed
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
leaq 0x46ce(%rip), %rsi      # 0xaab6
jmp 0x64c3
leaq 0x46bc(%rip), %rsi      # 0xaab0
cmpl $0x22, %r12d
je 0x64c3
cmpl $0x5c, %r12d
je 0x64bc
cmpl $0x2f, %r12d
jne 0x641a
leaq 0x4698(%rip), %rsi      # 0xaaad
jmp 0x64c3
cmpb $0x7f, %r12b
jb 0x64d7
leaq -0x1a8(%rbp), %rdi
leaq 0x4693(%rip), %rsi      # 0xaac5
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl $-0x4b, %esi
orl $0x8, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
orl $0x4000, 0x18(%rax,%rcx) # imm = 0x4000
movl %r12d, %esi
shrl $0x4, %esi
movq %rax, %rdi
callq 0x2150
andl $0xf, %r12d
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl $-0x4b, %esi
orl $0x2, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
andl $0xffffbfff, 0x18(%rax,%rcx) # imm = 0xFFFFBFFF
jmp 0x64cf
leaq 0x461a(%rip), %rsi      # 0xaab9
jmp 0x64c3
leaq 0x461a(%rip), %rsi      # 0xaac2
jmp 0x64c3
leaq 0x460e(%rip), %rsi      # 0xaabf
jmp 0x64c3
leaq 0x4602(%rip), %rsi      # 0xaabc
jmp 0x64c3
leaq 0x45f0(%rip), %rsi      # 0xaab3
leaq -0x1a8(%rbp), %rdi
callq 0x2220
incq %rbx
jmp 0x63bf
movsbl %r12b, %esi
leaq -0x1a8(%rbp), %rdi
callq 0x22a0
jmp 0x64cf
leaq -0x1a0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2310
leaq -0x1b8(%rbp), %rdi
callq 0x21c0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6521
jmp 0x6521
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2e
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x22d0
cmpq $-0x1, %rax
je 0x6f23
pushq $0x30
popq %rsi
pushq $-0x1
popq %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x2160
leaq 0x1(%rax), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2060
pushq $0x2e
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2160
leaq 0x1(%rax), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x28(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x7546
addq $0x40, %r14
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7570
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2100
leaq 0x28(%rbx), %rdi
callq 0x7f88
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7fc6
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq (%rdi), %r15
movsbl (%r15), %r14d
testl %r14d, %r14d
je 0x86c4
movl %r14d, %edi
callq 0x2040
testl %eax, %eax
je 0x868c
incq %r15
jmp 0x86bf
cmpb $0x2f, %r14b
jne 0x86c4
cmpb $0x2a, 0x1(%r15)
jne 0x86c4
addq $0x2, %r15
movq %r15, (%rbx)
movzbl (%r15), %eax
cmpl $0x2a, %eax
je 0x86af
testl %eax, %eax
jne 0x86b6
jmp 0x8672
cmpb $0x2f, 0x1(%r15)
je 0x86bb
incq %r15
jmp 0x869d
addq $0x2, %r15
movq %r15, (%rbx)
jmp 0x8672
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
callq 0x8662
movq (%r15), %rdx
movzbl (%rdx), %eax
cmpl $0x2d, %eax
je 0x8963
cmpl $0x2b, %eax
jne 0x8970
leaq 0x1(%rdx), %rcx
movq %rcx, (%r15)
movb 0x1(%rdx), %al
movq %rcx, %rdx
cmpb $0x2e, %al
je 0x8983
movsbl %al, %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x8a30
incq %rdx
movq %rdx, (%r15)
movsbl (%rdx), %eax
leal -0x30(%rax), %ecx
incq %rdx
cmpl $0xa, %ecx
jb 0x8986
cmpb $0x2e, %al
jne 0x89ac
movq %rdx, (%r15)
movsbl (%rdx), %eax
leal -0x30(%rax), %ecx
incq %rdx
cmpl $0xa, %ecx
jb 0x899b
decq %rdx
movzbl %al, %eax
orl $0x20, %eax
cmpl $0x65, %eax
jne 0x89fe
leaq 0x1(%rdx), %rax
movq %rax, (%r15)
movzbl 0x1(%rdx), %ecx
cmpl $0x2d, %ecx
je 0x89cf
cmpl $0x2b, %ecx
jne 0x89d9
leaq 0x2(%rdx), %rax
movq %rax, (%r15)
movb 0x2(%rdx), %cl
movsbl %cl, %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0x8a30
incq %rax
movq %rax, (%r15)
movsbl (%rax), %ecx
addl $-0x30, %ecx
incq %rax
cmpl $0xa, %ecx
jb 0x89e7
decq %rax
movq %rax, %rdx
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8f58
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7eec
leaq -0x38(%rbp), %rdi
callq 0x23e8
movb $0x1, %al
jmp 0x8a32
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x23e8
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x98, %rsp
movl %edx, %r14d
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
callq 0x8662
movq (%rbx), %rax
cmpb $0x5b, (%rax)
jne 0x8e8a
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x8662
leaq 0x1e94(%rip), %rsi      # 0xabf4
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
callq 0x507a
pushq $0x4
popq %rsi
leaq -0xc0(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x7eec
leaq -0xc0(%rbp), %rdi
callq 0x23e8
movq (%rbx), %rax
cmpb $0x5d, (%rax)
jne 0x8da7
incq %rax
movq %rax, (%rbx)
movb $0x1, %al
jmp 0x8e8c
leaq -0x88(%rbp), %r15
movzbl %r14b, %r12d
leaq -0xa0(%rbp), %r13
testb %r14b, %r14b
jne 0x8dda
movq %rbx, %rdi
callq 0x8662
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
je 0x8e73
cmpl $0x5d, %ecx
je 0x8d9a
andl $0x0, -0xa0(%rbp)
movq %r15, -0x98(%rbp)
andq $0x0, -0x90(%rbp)
movb $0x0, -0x88(%rbp)
andq $0x0, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
andl $0x0, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x40(%rbp)
andq $0x0, -0x38(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x84a6
testb %al, %al
je 0x8e7e
movq %rbx, %rdi
callq 0x8662
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x580c
movq (%rbx), %rcx
movzbl (%rcx), %eax
cmpl $0x2c, %eax
je 0x8e60
cmpl $0x7d, %eax
je 0x8e7e
cmpl $0x5d, %eax
je 0x8e9e
testb %r14b, %r14b
je 0x8e66
jmp 0x8e7e
incq %rcx
movq %rcx, (%rbx)
movq %r13, %rdi
callq 0x565a
jmp 0x8db9
incq %rax
movq %rax, (%rbx)
jmp 0x8db9
leaq -0xa0(%rbp), %rdi
callq 0x565a
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0xa0(%rbp), %rdi
callq 0x565a
movq (%rbx), %rax
jmp 0x8d9a
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x23e8
jmp 0x8ed7
movq %rax, %rbx
jmp 0x8ed7
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x565a
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::match_symbol(char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline bool match_symbol(const char*& s, const std::string& t) {
			if (memcmp(s, t.c_str(), t.size()) == 0 && is_valid_separator(s[t.size()])) {
				s += t.size();
				return true;
			}
			return false;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq (%rsi), %rsi
movq 0x8(%r14), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x2250
testl %eax, %eax
jne 0x8f23
movsbl (%r15,%r12), %edi
callq 0x8a52
testb %al, %al
je 0x8f23
movq 0x8(%r14), %rax
addq %rax, (%rbx)
movb $0x1, %al
jmp 0x8f25
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanlinlin82[P]jsonxx/./json.hpp
// Function: yll::json::hex_value(int)
static unsigned int hex_value(int c) {
			if (c >= '0' && c <= '9') {
				return (c - '0');
			} else if (c >= 'A' && c <= 'F') {
				return (c - 'A') + 10;
			} else if (c >= 'a' && c <= 'f') {
				return (c - 'a') + 10;
			} else {
				return c;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x30(%rdi), %eax
cmpl $0xa, %eax
jb 0x8f55
leal -0x41(%rdi), %eax
cmpl $0x5, %eax
ja 0x8f49
addl $-0x37, %edi
movl %edi, %eax
jmp 0x8f55
leal -0x61(%rdi), %ecx
leal -0x57(%rdi), %eax
cmpl $0x6, %ecx
cmovael %edi, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./src/unit_test.cpp
// Function: avlTest_search_Test::TestBody()
TEST_F( avlTest , search ) {
	avl_tree_int.insertHelper( 66 );
	avl_tree_double.insertHelper( 66.6 );
	avl_tree_int.insertHelper( 76 );
	avl_tree_double.insertHelper( 76.6 );
	avl_tree_int.insertHelper( 86 );
	avl_tree_double.insertHelper( 86.6 );

	EXPECT_TRUE( avl_tree_int.searchHelper( 86 ) );
	EXPECT_TRUE( avl_tree_double.searchHelper( 86.6 ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
pushq $0x42
popq %rsi
movq %r14, %rdi
callq 0xb8de
addq $0x18, %rbx
movsd 0x1d142(%rip), %xmm0    # 0x28008
movq %rbx, %rdi
callq 0xb91c
pushq $0x4c
popq %rsi
movq %r14, %rdi
callq 0xb8de
movsd 0x1d12f(%rip), %xmm0    # 0x28010
movq %rbx, %rdi
callq 0xb91c
pushq $0x56
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0xb8de
movsd 0x1d11a(%rip), %xmm0    # 0x28018
movq %rbx, %rdi
callq 0xb91c
movq %r14, %rdi
movl %ebp, %esi
callq 0xb98a
leaq 0x40(%rsp), %r14
movb %al, -0x8(%r14)
andq $0x0, (%r14)
testb %al, %al
jne 0xaf9a
leaq 0x10(%rsp), %rdi
callq 0xf4a8
leaq 0x1d3cf(%rip), %rdx     # 0x28301
leaq 0x1d20d(%rip), %rcx     # 0x28146
leaq 0x1d20c(%rip), %r8      # 0x2814c
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1059a
movq 0x18(%rsp), %r8
leaq 0x1d0de(%rip), %rdx     # 0x28039
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0x97, %ecx
callq 0xdb34
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdbb2
leaq 0x8(%rsp), %rdi
callq 0xdb94
leaq 0x18(%rsp), %rdi
callq 0x8aa8
leaq 0x10(%rsp), %rdi
callq 0xbcf2
movq %r14, %rdi
callq 0xbd38
movsd 0x1d06e(%rip), %xmm0    # 0x28018
movq %rbx, %rdi
callq 0xb994
leaq 0x40(%rsp), %rbx
movb %al, -0x8(%rbx)
andq $0x0, (%rbx)
testb %al, %al
jne 0xb03b
leaq 0x10(%rsp), %rdi
callq 0xf4a8
leaq 0x1d34e(%rip), %rdx     # 0x28321
leaq 0x1d16c(%rip), %rcx     # 0x28146
leaq 0x1d16b(%rip), %r8      # 0x2814c
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1059a
movq 0x18(%rsp), %r8
leaq 0x1d03d(%rip), %rdx     # 0x28039
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0x98, %ecx
callq 0xdb34
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdbb2
leaq 0x8(%rsp), %rdi
callq 0xdb94
leaq 0x18(%rsp), %rdi
callq 0x8aa8
leaq 0x10(%rsp), %rdi
callq 0xbcf2
movq %rbx, %rdi
callq 0xbd38
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xdb94
jmp 0xb060
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x8aa8
jmp 0xb06f
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0xbcf2
jmp 0xb08d
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xdb94
jmp 0xb095
movq %rax, %r15
movq %rbx, %rdi
jmp 0xb0b6
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x8aa8
jmp 0xb0a4
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0xbcf2
jmp 0xb0b3
movq %rax, %r15
movq %r14, %rdi
callq 0xbd38
movq %r15, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./src/unit_test.cpp
// Function: avlTest_getNumberOfNodes_Test::TestBody()
TEST_F( avlTest , getNumberOfNodes ) {
	avl_tree_int.insertHelper( 66 );
	avl_tree_double.insertHelper( 66.6 );
	avl_tree_int.insertHelper( 76 );
	avl_tree_double.insertHelper( 76.6 );
	avl_tree_int.insertHelper( 86 );
	avl_tree_double.insertHelper( 86.6 );

	EXPECT_EQ( avl_tree_int.getNumberOfNodesHelper() , 3 );
	EXPECT_GT( avl_tree_double.getNumberOfNodesHelper() , 2 );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
pushq $0x42
popq %rsi
movq %r14, %rdi
callq 0xb8de
addq $0x18, %rbx
movsd 0x1cf1f(%rip), %xmm0    # 0x28008
movq %rbx, %rdi
callq 0xb91c
pushq $0x4c
popq %rsi
movq %r14, %rdi
callq 0xb8de
movsd 0x1cf0c(%rip), %xmm0    # 0x28010
movq %rbx, %rdi
callq 0xb91c
pushq $0x56
popq %rsi
movq %r14, %rdi
callq 0xb8de
movsd 0x1cef9(%rip), %xmm0    # 0x28018
movq %rbx, %rdi
callq 0xb91c
movq %r14, %rdi
callq 0xb99c
leaq 0x10(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x8(%rsp), %r8
movl $0x3, (%r8)
leaq 0x1d20e(%rip), %rsi     # 0x28357
leaq 0x1d22d(%rip), %rdx     # 0x2837d
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xc2f5
cmpb $0x0, (%r14)
jne 0xb1bf
leaq 0x10(%rsp), %rdi
callq 0xf4a8
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xb17c
movq (%rax), %r8
jmp 0xb183
leaq 0x1f294(%rip), %r8      # 0x2a417
leaq 0x1ceaf(%rip), %rdx     # 0x28039
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0xa3, %ecx
callq 0xdb34
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdbb2
leaq 0x8(%rsp), %rdi
callq 0xdb94
leaq 0x10(%rsp), %rdi
callq 0xbcf2
leaq 0x20(%rsp), %rdi
callq 0xbd38
movq %rbx, %rdi
callq 0xb9a4
leaq 0x10(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x8(%rsp), %r8
movl $0x2, (%r8)
leaq 0x1d194(%rip), %rsi     # 0x2837f
leaq 0x1ceaf(%rip), %rdx     # 0x280a1
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0xb7d8
cmpb $0x0, (%rbx)
jne 0xb260
leaq 0x10(%rsp), %rdi
callq 0xf4a8
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xb21d
movq (%rax), %r8
jmp 0xb224
leaq 0x1f1f3(%rip), %r8      # 0x2a417
leaq 0x1ce0e(%rip), %rdx     # 0x28039
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0xa4, %ecx
callq 0xdb34
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdbb2
leaq 0x8(%rsp), %rdi
callq 0xdb94
leaq 0x10(%rsp), %rdi
callq 0xbcf2
leaq 0x20(%rsp), %rdi
callq 0xbd38
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xb276
jmp 0xb287
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdb94
jmp 0xb28a
jmp 0xb296
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbcf2
jmp 0xb299
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbd38
movq %rbx, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x10, %rbx
pushq $0x42
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x4c
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x56
popq %rsi
movq %rbx, %rdi
callq 0xb8de
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
andq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x342a4(%rip), %rdi     # 0x3f598
leaq 0x8(%rsp), %rsi
callq 0x8830
leaq 0x8(%rsp), %rdi
callq 0x8aa8
leaq 0x6a9(%rip), %rsi       # 0xb9b8
movq %rbx, %rdi
callq 0xb9ac
leaq 0x34272(%rip), %rax     # 0x3f590
movq 0x3426b(%rip), %rcx     # 0x3f590
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xb393
leaq 0x34261(%rip), %rsi     # 0x3f598
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x88c0
leaq 0x1d06b(%rip), %rsi     # 0x283b6
movq %rbx, %rdi
callq 0xb9ef
testb %al, %al
je 0xb393
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x8aa8
movq %r14, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x34221(%rip), %rdi     # 0x3f598
leaq 0x8(%rsp), %rsi
callq 0x8830
leaq 0x8(%rsp), %rdi
callq 0x8aa8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d032(%rip), %rdi     # 0x283cc
leaq 0x1cc98(%rip), %rsi     # 0x28039
leaq 0x1d05c(%rip), %rcx     # 0x28404
movl $0xae, %edx
callq 0x82f0
jmp 0xb3b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x10, %rbx
pushq $0x32
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x14
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0xb8de
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
andq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x34186(%rip), %rdi     # 0x3f598
leaq 0x8(%rsp), %rsi
callq 0x8830
leaq 0x8(%rsp), %rdi
callq 0x8aa8
leaq 0x58b(%rip), %rsi       # 0xb9b8
movq %rbx, %rdi
callq 0xb9ac
leaq 0x34154(%rip), %rax     # 0x3f590
movq 0x3414d(%rip), %rcx     # 0x3f590
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xb4b1
leaq 0x34143(%rip), %rsi     # 0x3f598
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x88c0
leaq 0x1cfde(%rip), %rsi     # 0x28447
movq %rbx, %rdi
callq 0xb9ef
testb %al, %al
je 0xb4b1
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x8aa8
movq %r14, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x34103(%rip), %rdi     # 0x3f598
leaq 0x8(%rsp), %rsi
callq 0x8830
leaq 0x8(%rsp), %rdi
callq 0x8aa8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1cfa5(%rip), %rdi     # 0x2845d
leaq 0x1cb7a(%rip), %rsi     # 0x28039
leaq 0x1cfcf(%rip), %rcx     # 0x28495
movl $0xb9, %edx
callq 0x82f0
jmp 0xb4d2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./src/unit_test.cpp
// Function: avlTest_right_left_double_rotation_Test::TestBody()
TEST_F( avlTest , right_left_double_rotation ) {
	avl_tree_int.insertHelper( 20 );
	avl_tree_int.insertHelper( 4 );
	avl_tree_int.insertHelper( 26 );
	avl_tree_int.insertHelper( 3 );
	avl_tree_int.insertHelper( 9 );
	avl_tree_int.insertHelper( 15 );

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x10, %rbx
pushq $0x14
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x1a
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0xb8de
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
andq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x34047(%rip), %rdi     # 0x3f598
leaq 0x8(%rsp), %rsi
callq 0x8830
leaq 0x8(%rsp), %rdi
callq 0x8aa8
leaq 0x44c(%rip), %rsi       # 0xb9b8
movq %rbx, %rdi
callq 0xb9ac
leaq 0x34015(%rip), %rax     # 0x3f590
movq 0x3400e(%rip), %rcx     # 0x3f590
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xb5f0
leaq 0x34004(%rip), %rsi     # 0x3f598
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x88c0
leaq 0x1cf3d(%rip), %rsi     # 0x284e5
movq %rbx, %rdi
callq 0xb9ef
testb %al, %al
je 0xb5f0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x8aa8
movq %r14, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x33fc4(%rip), %rdi     # 0x3f598
leaq 0x8(%rsp), %rsi
callq 0x8830
leaq 0x8(%rsp), %rdi
callq 0x8aa8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1cf16(%rip), %rdi     # 0x2850d
leaq 0x1ca3b(%rip), %rsi     # 0x28039
leaq 0x1cf52(%rip), %rcx     # 0x28557
movl $0xc7, %edx
callq 0x82f0
jmp 0xb611
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x10, %rbx
pushq $0x42
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x4c
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x56
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0xb8de
pushq $0x5a
popq %rsi
movq %rbx, %rdi
callq 0xb8de
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
andq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x33f14(%rip), %rdi     # 0x3f598
leaq 0x8(%rsp), %rsi
callq 0x8830
leaq 0x8(%rsp), %rdi
callq 0x8aa8
leaq 0x319(%rip), %rsi       # 0xb9b8
movq %rbx, %rdi
callq 0xb9ac
leaq 0x33ee2(%rip), %rax     # 0x3f590
movq 0x33edb(%rip), %rcx     # 0x3f590
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0xb723
leaq 0x33ed1(%rip), %rsi     # 0x3f598
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x88c0
leaq 0x1ced8(%rip), %rsi     # 0x285b3
movq %rbx, %rdi
callq 0xb9ef
testb %al, %al
je 0xb723
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x8aa8
movq %r14, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x33e91(%rip), %rdi     # 0x3f598
leaq 0x8(%rsp), %rsi
callq 0x8830
leaq 0x8(%rsp), %rdi
callq 0x8aa8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1cead(%rip), %rdi     # 0x285d7
leaq 0x1c908(%rip), %rsi     # 0x28039
leaq 0x1cee5(%rip), %rcx     # 0x2861d
movl $0xd4, %edx
callq 0x82f0
jmp 0xb744
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./src/node.h
// Function: node<int>::unbalanced()
int node< itemType >::getLeftChildHeight() {
	int temp;

	if ( this->left == nullptr ) temp = 0;
	else temp = this->getLeftChild()->getHeight();

	return temp;
}

// Assembly:
movq 0x8(%rdi), %rdx
xorl %ecx, %ecx
movl $0x0, %eax
testq %rdx, %rdx
je 0xb891
movl 0x18(%rdx), %eax
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0xb89d
movl 0x18(%rdx), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x2, %ecx
setae %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc020
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0xbfea
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0xbfea
pushq $0x20
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x84b0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xf7e5
leaq 0x1c11e(%rip), %rsi     # 0x28688
movq %r12, %rdi
callq 0xc67c
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xc6e0
leaq 0x1c10e(%rip), %rsi     # 0x28694
movq %rax, %rdi
callq 0xc73e
movq %rsp, %rsi
movq %rax, %rdi
callq 0xc6e0
leaq 0x1c0f1(%rip), %rsi     # 0x28691
movq %rax, %rdi
callq 0xc73e
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xc6e0
leaq 0x1c0db(%rip), %rsi     # 0x28697
movq %rax, %rdi
callq 0xc67c
movq %rax, %r12
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0xc3aa
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0xc7a2
leaq 0x1c0bb(%rip), %rsi     # 0x286a3
movq %rax, %rdi
callq 0xc806
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xc3aa
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0xc7a2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf72a
leaq 0x28(%rsp), %rdi
callq 0x8aa8
leaq 0x48(%rsp), %rdi
callq 0x8aa8
leaq 0x20(%rsp), %rdi
callq 0xbd38
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xc658
jmp 0xc667
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8aa8
jmp 0xc65b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8aa8
jmp 0xc66a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbd38
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/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 0xca3d
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x8390
leaq 0x1bc6b(%rip), %rsi     # 0x286af
movq %rcx, %rdi
jmp 0x8460
// File: /workspace/github_cpp_makefile_star2_O2/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 0xcd96
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
cmpl %eax, (%rsi)
jle 0xcd51
pushq $0x8
jmp 0xcd55
jge 0xcd67
pushq $0x10
popq %r15
movq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0xcd2e
movq %rax, (%rbx,%r15)
movq %rbx, %rdi
callq 0xb87e
testb %al, %al
je 0xcd86
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcda4
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0xb82e
movl %eax, 0x18(%rbx)
movq 0x8(%rsp), %rdx
movq %rdx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xcdc5
movl 0x18(%rdx), %edi
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xcdd1
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 0xcdf0
movl 0x18(%rcx), %r10d
movq 0x10(%r8), %r8
testq %r8, %r8
je 0xcdfd
movl 0x18(%r8), %r9d
cmpl %r9d, %r10d
jle 0xce0e
cmpl %esi, %edi
jle 0xce34
movq %r15, %rdi
movq %r14, %rsi
jmp 0xce2d
cmpl %esi, %edi
jle 0xce46
movq %r15, %rdi
movq %rdx, %rsi
movq %r8, %rdx
callq 0xce5e
movq %rax, 0x8(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xce96
jmp 0xce54
movq %r15, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0xce96
movq %rax, 0x10(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xce5e
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::leftRotation(node<int>*, node<int>*)
node< itemType >* AVLTree< itemType >::leftRotation( node< itemType > *up , node< itemType > *middle ) {
	node< itemType > *temp = middle->getLeftChild();

	up->setRightChild( temp );
	middle->setLeftChild( up );

	up->setHeight( up->getMaxHeight() );
	middle->setHeight( middle->getMaxHeight() );

	return middle;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdx)
movq %rsi, %rdi
callq 0xb82e
movl %eax, 0x18(%r14)
movq %rbx, %rdi
callq 0xb82e
movl %eax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::rightRotation(node<int>*, node<int>*)
node< itemType >* AVLTree< itemType >::rightRotation( node< itemType > *up , node< itemType > *middle ) {
	node< itemType > *temp = middle->getRightChild();

	up->setLeftChild( temp );
	middle->setRightChild( up );

	up->setHeight( up->getMaxHeight() );
	middle->setHeight( middle->getMaxHeight() );

	return middle;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdx), %rax
movq %rax, 0x8(%rsi)
movq %rsi, 0x10(%rdx)
movq %rsi, %rdi
callq 0xb82e
movl %eax, 0x18(%r14)
movq %rbx, %rdi
callq 0xb82e
movl %eax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./src/avl.h
// Function: AVLTree<int>::search(node<int>*, int)
bool AVLTree< itemType >::search( node< itemType > *root , itemType target ) {
	if ( root == nullptr ) return false;
	if ( root->getData() == target ) return true;

	if ( root->getData() > target ) return this->search( root->getLeftChild() , target );
	if ( root->getData() < target ) return this->search( root->getRightChild() , target );

	return false;
}

// Assembly:
pushq $0x8
popq %rax
pushq $0x10
popq %rcx
testq %rsi, %rsi
je 0xd09b
movl (%rsi), %edi
cmpl %edx, %edi
je 0xd09e
movq %rax, %rdi
jg 0xd095
movq %rcx, %rdi
jge 0xd09b
movq (%rsi,%rdi), %rsi
jmp 0xd080
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq 0x10(%rsp), %rdi
callq 0xd206
testq %r14, %r14
je 0xd172
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd42a
leaq 0x10(%rsp), %r14
leaq 0x32412(%rip), %r15     # 0x3f590
movq %rsp, %r12
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
je 0xd1d2
movq (%rax), %r13
movq %r14, %rdi
callq 0xd65e
movq %r13, %rdi
movq %r15, %rsi
callq *%rbx
movq 0x8(%r13), %rax
testq %rax, %rax
je 0xd1b8
movq %rax, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd6b4
movq 0x10(%r13), %rax
testq %rax, %rax
je 0xd181
movq %rax, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd6b4
jmp 0xd181
leaq 0x10(%rsp), %rdi
callq 0xd77c
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xd1f0
jmp 0xd1f0
jmp 0xd1f0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd77c
movq %rbx, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1dc95
movq (%r14), %rdi
callq 0x8630
testq %rax, %rax
je 0xd7e0
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0xd7e0
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1dc95
movq (%r14), %rdi
callq 0x8630
movq %rax, %r15
testq %rax, %rax
cmoveq %rbx, %r15
movq %r14, %rdi
callq 0x8aa8
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq