LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::append_attribute(char const*)
PUGI__FN xml_attribute xml_node::append_attribute(const char_t* name_)
	{
		if (!impl::allow_insert_attribute(type())) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::append_attribute(a._attr, _root);

		a.set_name(name_);

		return a;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x18cc0
movq %rsi, %rbx
movl (%rdi), %eax
andl $0xf, %eax
cmpl $0x7, %eax
je 0x18c88
cmpl $0x2, %eax
jne 0x18cc0
callq 0x18ced
movq %rax, %rdi
callq 0x18d21
movq %rax, %r14
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x18ce0
movq (%r15), %rcx
movq 0x38(%rcx), %rax
testq %rax, %rax
je 0x18cc5
movq 0x18(%rax), %rcx
addq $0x18, %rax
movq %r14, 0x20(%rcx)
movq %rcx, 0x18(%r14)
jmp 0x18cd0
xorl %r14d, %r14d
jmp 0x18ce0
movq %r14, 0x38(%rcx)
movq %r14, %rax
addq $0x18, %rax
movq %r14, (%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x18212
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::prepend_attribute(char const*)
PUGI__FN xml_attribute xml_node::prepend_attribute(const char_t* name_)
	{
		if (!impl::allow_insert_attribute(type())) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::prepend_attribute(a._attr, _root);

		a.set_name(name_);

		return a;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x18da8
movq %rsi, %rbx
movl (%rdi), %eax
andl $0xf, %eax
cmpl $0x7, %eax
je 0x18d74
cmpl $0x2, %eax
jne 0x18da8
callq 0x18ced
movq %rax, %rdi
callq 0x18d21
movq %rax, %r14
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x18dcc
movq (%r15), %rax
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x18dad
leaq 0x18(%rcx), %rdx
movq 0x18(%rcx), %rsi
movq %rsi, 0x18(%r14)
jmp 0x18db4
xorl %r14d, %r14d
jmp 0x18dcc
movq %r14, %rdx
addq $0x18, %rdx
movq %r14, (%rdx)
movq %rcx, 0x20(%r14)
movq %r14, 0x38(%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x18212
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::node_copy_attribute(pugi::xml_attribute_struct*, pugi::xml_attribute_struct*)
PUGI__FN void node_copy_attribute(xml_attribute_struct* da, xml_attribute_struct* sa)
	{
		xml_allocator& alloc = get_allocator(da);
		xml_allocator* shared_alloc = (&alloc == &get_allocator(sa)) ? &alloc : 0;

		node_copy_string(da->name, da->header, xml_memory_page_name_allocated_mask, sa->name, sa->header, shared_alloc);
		node_copy_string(da->value, da->header, xml_memory_page_value_allocated_mask, sa->value, sa->header, shared_alloc);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x22a29
movq %rax, %r15
movq %rbx, %rdi
callq 0x22a29
xorl %r12d, %r12d
cmpq %rax, %r15
cmoveq %r15, %r12
leaq 0x8(%r14), %rdi
movq 0x8(%rbx), %rcx
pushq $0x20
popq %rdx
movq %r14, %rsi
movq %rbx, %r8
movq %r12, %r9
callq 0x22a5d
leaq 0x10(%r14), %rdi
movq 0x10(%rbx), %rcx
pushq $0x10
popq %rdx
movq %r14, %rsi
movq %rbx, %r8
movq %r12, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22a5d
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::append_child(pugi::xml_node_type)
PUGI__FN xml_node xml_node::append_child(xml_node_type type_)
	{
		if (!impl::allow_insert_child(type(), type_)) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::append_node(n._root, _root);

		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));

		return n;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %r15
testq %r15, %r15
je 0x191fa
movl (%r15), %edi
andl $0xf, %edi
jmp 0x191fc
xorl %edi, %edi
movl %ebx, %esi
callq 0x19259
testb %al, %al
je 0x19249
movq %r15, %rdi
callq 0x18ced
movq %rax, %rdi
movl %ebx, %esi
callq 0x19281
movq %rax, %r15
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1924c
movq (%r14), %rsi
movq %r15, %rdi
callq 0x192c8
cmpl $0x7, %ebx
jne 0x1924c
leaq 0x12df0(%rip), %rsi     # 0x2c02d
leaq 0x8(%rsp), %rdi
callq 0x18bb4
jmp 0x1924c
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::allocate_node(pugi::impl::(anonymous namespace)::xml_allocator&, pugi::xml_node_type)
inline xml_node_struct* allocate_node(xml_allocator& alloc, xml_node_type type)
	{
		xml_memory_page* page;
		void* memory = alloc.allocate_object(sizeof(xml_node_struct), page);
		if (!memory) return 0;

		return new (memory) xml_node_struct(page, type);
	}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
pushq $0x40
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x19db4
testq %rax, %rax
je 0x192c2
movq %rax, %rcx
subq 0x8(%rsp), %rcx
shlq $0x8, %rcx
movl %ebx, %edx
orq %rcx, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
andq $0x0, 0x38(%rax)
movq %rdx, (%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::prepend_child(pugi::xml_node_type)
PUGI__FN xml_node xml_node::prepend_child(xml_node_type type_)
	{
		if (!impl::allow_insert_child(type(), type_)) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::prepend_node(n._root, _root);

		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));

		return n;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %r15
testq %r15, %r15
je 0x19312
movl (%r15), %edi
andl $0xf, %edi
jmp 0x19314
xorl %edi, %edi
movl %ebx, %esi
callq 0x19259
testb %al, %al
je 0x19361
movq %r15, %rdi
callq 0x18ced
movq %rax, %rdi
movl %ebx, %esi
callq 0x19281
movq %rax, %r15
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x19364
movq (%r14), %rsi
movq %r15, %rdi
callq 0x19371
cmpl $0x7, %ebx
jne 0x19364
leaq 0x12cd8(%rip), %rsi     # 0x2c02d
leaq 0x8(%rsp), %rdi
callq 0x18bb4
jmp 0x19364
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_child_before(pugi::xml_node_type, pugi::xml_node const&)
PUGI__FN xml_node xml_node::insert_child_before(xml_node_type type_, const xml_node& node)
	{
		if (!impl::allow_insert_child(type(), type_)) return xml_node();
		if (!node._root || node._root->parent != _root) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::insert_node_before(n._root, node._root);

		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));

		return n;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq (%rdi), %r15
testq %r15, %r15
je 0x193ba
movl (%r15), %edi
andl $0xf, %edi
jmp 0x193bc
xorl %edi, %edi
movl %ebx, %esi
callq 0x19259
testb %al, %al
je 0x193d5
movq (%r14), %rax
testq %rax, %rax
je 0x193d5
cmpq %r15, 0x18(%rax)
je 0x193e5
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x18ced
movq %rax, %rdi
movl %ebx, %esi
callq 0x19281
movq %rax, %r15
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x193d8
movq (%r14), %rsi
movq %r15, %rdi
callq 0x19427
cmpl $0x7, %ebx
jne 0x193d8
leaq 0x12c12(%rip), %rsi     # 0x2c02d
leaq 0x8(%rsp), %rdi
callq 0x18bb4
jmp 0x193d8
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_child_after(pugi::xml_node_type, pugi::xml_node const&)
PUGI__FN xml_node xml_node::insert_child_after(xml_node_type type_, const xml_node& node)
	{
		if (!impl::allow_insert_child(type(), type_)) return xml_node();
		if (!node._root || node._root->parent != _root) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::insert_node_after(n._root, node._root);

		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));

		return n;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq (%rdi), %r15
testq %r15, %r15
je 0x19472
movl (%r15), %edi
andl $0xf, %edi
jmp 0x19474
xorl %edi, %edi
movl %ebx, %esi
callq 0x19259
testb %al, %al
je 0x1948d
movq (%r14), %rax
testq %rax, %rax
je 0x1948d
cmpq %r15, 0x18(%rax)
je 0x1949d
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x18ced
movq %rax, %rdi
movl %ebx, %esi
callq 0x19281
movq %rax, %r15
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x19490
movq (%r14), %rsi
movq %r15, %rdi
callq 0x194df
cmpl $0x7, %ebx
jne 0x19490
leaq 0x12b5a(%rip), %rsi     # 0x2c02d
leaq 0x8(%rsp), %rdi
callq 0x18bb4
jmp 0x19490
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::append_copy(pugi::xml_node const&)
PUGI__FN xml_node xml_node::append_copy(const xml_node& proto)
	{
		xml_node_type type_ = proto.type();
		if (!impl::allow_insert_child(type(), type_)) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::append_node(n._root, _root);
		impl::node_copy_tree(n._root, proto._root);

		return n;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
xorl %edi, %edi
movl $0x0, %ebp
testq %rax, %rax
je 0x195d9
movl (%rax), %ebp
andl $0xf, %ebp
movq (%r14), %r15
testq %r15, %r15
je 0x195e7
movl (%r15), %edi
andl $0xf, %edi
movl %ebp, %esi
callq 0x19259
testb %al, %al
je 0x19624
movq %r15, %rdi
callq 0x18ced
movq %rax, %rdi
movl %ebp, %esi
callq 0x19281
testq %rax, %rax
je 0x19624
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
callq 0x192c8
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x19635
jmp 0x19627
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::node_copy_tree(pugi::xml_node_struct*, pugi::xml_node_struct*)
PUGI__FN void node_copy_tree(xml_node_struct* dn, xml_node_struct* sn)
	{
		xml_allocator& alloc = get_allocator(dn);
		xml_allocator* shared_alloc = (&alloc == &get_allocator(sn)) ? &alloc : 0;

		node_copy_contents(dn, sn, shared_alloc);

		xml_node_struct* dit = dn;
		xml_node_struct* sit = sn->first_child;

		while (sit && sit != sn)
		{
			if (sit != dn)
			{
				xml_node_struct* copy = append_new_node(dit, alloc, PUGI__NODETYPE(sit));

				if (copy)
				{
					node_copy_contents(copy, sit, shared_alloc);

					if (sit->first_child)
					{
						dit = copy;
						sit = sit->first_child;
						continue;
					}
				}
			}

			// continue to the next node
			do
			{
				if (sit->next_sibling)
				{
					sit = sit->next_sibling;
					break;
				}

				sit = sit->parent;
				dit = dit->parent;
			}
			while (sit != sn);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x18ced
movq %rax, %r15
movq %rbx, %rdi
callq 0x18ced
xorl %edx, %edx
cmpq %rax, %r15
cmoveq %r15, %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %rdx, (%rsp)
callq 0x22aef
movq 0x20(%rbx), %rax
movq %r14, %r13
testq %rax, %rax
je 0x196de
movq %rax, %rbp
cmpq %rbx, %rax
je 0x196de
movq %r13, %r12
cmpq %r14, %rbp
je 0x196bb
movl (%rbp), %edx
andl $0xf, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x22bb1
testq %rax, %rax
je 0x196bb
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
callq 0x22aef
movq 0x20(%rbp), %rax
testq %rax, %rax
jne 0x19675
movq %rbp, %rax
movq %r12, %r13
movq 0x30(%rax), %rcx
testq %rcx, %rcx
jne 0x196d9
movq 0x18(%rax), %rax
movq 0x18(%r13), %r13
cmpq %rbx, %rax
jne 0x196c1
jmp 0x19675
movq %rcx, %rax
jmp 0x19675
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::prepend_copy(pugi::xml_node const&)
PUGI__FN xml_node xml_node::prepend_copy(const xml_node& proto)
	{
		xml_node_type type_ = proto.type();
		if (!impl::allow_insert_child(type(), type_)) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::prepend_node(n._root, _root);
		impl::node_copy_tree(n._root, proto._root);

		return n;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
xorl %edi, %edi
movl $0x0, %ebp
testq %rax, %rax
je 0x1970f
movl (%rax), %ebp
andl $0xf, %ebp
movq (%r14), %r15
testq %r15, %r15
je 0x1971d
movl (%r15), %edi
andl $0xf, %edi
movl %ebp, %esi
callq 0x19259
testb %al, %al
je 0x1975a
movq %r15, %rdi
callq 0x18ced
movq %rax, %rdi
movl %ebp, %esi
callq 0x19281
testq %rax, %rax
je 0x1975a
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
callq 0x19371
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x19635
jmp 0x1975d
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_copy_after(pugi::xml_node const&, pugi::xml_node const&)
PUGI__FN xml_node xml_node::insert_copy_after(const xml_node& proto, const xml_node& node)
	{
		xml_node_type type_ = proto.type();
		if (!impl::allow_insert_child(type(), type_)) return xml_node();
		if (!node._root || node._root->parent != _root) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::insert_node_after(n._root, node._root);
		impl::node_copy_tree(n._root, proto._root);

		return n;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rax
movq (%rsi), %rcx
xorl %edi, %edi
movl $0x0, %ebp
testq %rcx, %rcx
je 0x19790
movl (%rcx), %ebp
andl $0xf, %ebp
movq (%rax), %r15
testq %r15, %r15
je 0x1979e
movl (%r15), %edi
andl $0xf, %edi
movl %ebp, %esi
callq 0x19259
testb %al, %al
je 0x197b7
movq (%r14), %rax
testq %rax, %rax
je 0x197b7
cmpq %r15, 0x18(%rax)
je 0x197c8
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x18ced
movq %rax, %rdi
movl %ebp, %esi
callq 0x19281
testq %rax, %rax
je 0x197b7
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
callq 0x194df
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x19635
jmp 0x197ba
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_copy_before(pugi::xml_node const&, pugi::xml_node const&)
PUGI__FN xml_node xml_node::insert_copy_before(const xml_node& proto, const xml_node& node)
	{
		xml_node_type type_ = proto.type();
		if (!impl::allow_insert_child(type(), type_)) return xml_node();
		if (!node._root || node._root->parent != _root) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::insert_node_before(n._root, node._root);
		impl::node_copy_tree(n._root, proto._root);

		return n;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rax
movq (%rsi), %rcx
xorl %edi, %edi
movl $0x0, %ebp
testq %rcx, %rcx
je 0x1981e
movl (%rcx), %ebp
andl $0xf, %ebp
movq (%rax), %r15
testq %r15, %r15
je 0x1982c
movl (%r15), %edi
andl $0xf, %edi
movl %ebp, %esi
callq 0x19259
testb %al, %al
je 0x19845
movq (%r14), %rax
testq %rax, %rax
je 0x19845
cmpq %r15, 0x18(%rax)
je 0x19856
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x18ced
movq %rax, %rdi
movl %ebp, %esi
callq 0x19281
testq %rax, %rax
je 0x19845
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
callq 0x19427
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x19635
jmp 0x19848
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::append_move(pugi::xml_node const&)
PUGI__FN xml_node xml_node::append_move(const xml_node& moved)
	{
		if (!impl::allow_move(*this, moved)) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		// disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
		impl::get_document(_root).header |= impl::xml_memory_page_contents_shared_mask;

		impl::remove_node(moved._root);
		impl::append_node(moved._root, _root);

		return moved;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq (%rsi), %rsi
movq %r15, %rdi
callq 0x198d8
testb %al, %al
je 0x198d0
movq %r15, %rdi
callq 0x18ced
movq (%r14), %rdi
callq 0x18ac0
orb $0x40, (%rax)
movq (%rbx), %rdi
callq 0x1995f
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x192c8
movq (%rbx), %rax
jmp 0x198d2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::allow_move(pugi::xml_node, pugi::xml_node)
PUGI__FN bool allow_move(xml_node parent, xml_node child)
	{
		// check that child can be a child of parent
		if (!allow_insert_child(parent.type(), child.type()))
			return false;

		// check that node is not moved between documents
		if (parent.root() != child.root())
			return false;

		// check that new parent is not in the child subtree
		xml_node cur = parent;

		while (cur)
		{
			if (cur == child)
				return false;

			cur = cur.parent();
		}

		return true;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
movl $0x0, %edi
testq %r14, %r14
je 0x198f4
movl (%r14), %edi
andl $0xf, %edi
testq %rbx, %rbx
je 0x198fe
movl (%rbx), %esi
andl $0xf, %esi
callq 0x19259
testb %al, %al
je 0x19942
testq %r14, %r14
je 0x19920
movq (%r14), %rax
shrq $0x8, %rax
negq %rax
movq (%r14,%rax), %rax
addq $-0x40, %rax
jmp 0x19922
xorl %eax, %eax
testq %rbx, %rbx
je 0x1993b
movq (%rbx), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rbx,%rcx), %rcx
addq $-0x40, %rcx
jmp 0x1993d
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x19955
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq %rbx, %r14
je 0x19944
movq 0x18(%r14), %r14
testq %r14, %r14
sete %al
jne 0x1994c
jmp 0x19944
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::remove_node(pugi::xml_node_struct*)
inline void remove_node(xml_node_struct* node)
	{
		xml_node_struct* parent = node->parent;

		if (node->next_sibling)
			node->next_sibling->prev_sibling_c = node->prev_sibling_c;
		else
			parent->first_child->prev_sibling_c = node->prev_sibling_c;

		if (node->prev_sibling_c->next_sibling)
			node->prev_sibling_c->next_sibling = node->next_sibling;
		else
			parent->first_child = node->next_sibling;

		node->parent = 0;
		node->prev_sibling_c = 0;
		node->next_sibling = 0;
	}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rdx
movq 0x30(%rdi), %rcx
movq %rcx, %rsi
testq %rcx, %rcx
jne 0x19977
movq 0x20(%rax), %rsi
movq %rdx, 0x28(%rsi)
leaq 0x30(%rdx), %rsi
addq $0x20, %rax
cmpq $0x0, 0x30(%rdx)
cmovneq %rsi, %rax
movq %rcx, (%rax)
andq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::prepend_move(pugi::xml_node const&)
PUGI__FN xml_node xml_node::prepend_move(const xml_node& moved)
	{
		if (!impl::allow_move(*this, moved)) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		// disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
		impl::get_document(_root).header |= impl::xml_memory_page_contents_shared_mask;

		impl::remove_node(moved._root);
		impl::prepend_node(moved._root, _root);

		return moved;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq (%rsi), %rsi
movq %r15, %rdi
callq 0x198d8
testb %al, %al
je 0x199e4
movq %r15, %rdi
callq 0x18ced
movq (%r14), %rdi
callq 0x18ac0
orb $0x40, (%rax)
movq (%rbx), %rdi
callq 0x1995f
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x19371
movq (%rbx), %rax
jmp 0x199e6
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_move_after(pugi::xml_node const&, pugi::xml_node const&)
PUGI__FN xml_node xml_node::insert_move_after(const xml_node& moved, const xml_node& node)
	{
		if (!impl::allow_move(*this, moved)) return xml_node();
		if (!node._root || node._root->parent != _root) return xml_node();
		if (moved._root == node._root) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		// disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
		impl::get_document(_root).header |= impl::xml_memory_page_contents_shared_mask;

		impl::remove_node(moved._root);
		impl::insert_node_after(moved._root, node._root);

		return moved;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r12
movq (%rsi), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x198d8
testb %al, %al
je 0x19a2c
movq (%r14), %rax
testq %rax, %rax
je 0x19a2c
cmpq %r12, 0x18(%rax)
setne %cl
cmpq %rax, %r13
sete %al
orb %cl, %al
je 0x19a38
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x18ced
movq (%r15), %rdi
callq 0x18ac0
orb $0x40, (%rax)
movq (%rbx), %rdi
callq 0x1995f
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x194df
movq (%rbx), %rax
jmp 0x19a2e
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_move_before(pugi::xml_node const&, pugi::xml_node const&)
PUGI__FN xml_node xml_node::insert_move_before(const xml_node& moved, const xml_node& node)
	{
		if (!impl::allow_move(*this, moved)) return xml_node();
		if (!node._root || node._root->parent != _root) return xml_node();
		if (moved._root == node._root) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		// disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
		impl::get_document(_root).header |= impl::xml_memory_page_contents_shared_mask;

		impl::remove_node(moved._root);
		impl::insert_node_before(moved._root, node._root);

		return moved;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r12
movq (%rsi), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x198d8
testb %al, %al
je 0x19aa4
movq (%r14), %rax
testq %rax, %rax
je 0x19aa4
cmpq %r12, 0x18(%rax)
setne %cl
cmpq %rax, %r13
sete %al
orb %cl, %al
je 0x19ab0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x18ced
movq (%r15), %rdi
callq 0x18ac0
orb $0x40, (%rax)
movq (%rbx), %rdi
callq 0x1995f
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x19427
movq (%rbx), %rax
jmp 0x19aa6
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::remove_attribute(pugi::xml_attribute const&)
PUGI__FN bool xml_node::remove_attribute(const xml_attribute& a)
	{
		if (!_root || !a._attr) return false;
		if (!impl::is_attribute_of(a._attr, _root)) return false;

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return false;

		impl::remove_attribute(a._attr, _root);
		impl::destroy_attribute(a._attr, alloc);

		return true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x19b7a
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x19b7a
movq %r15, %rsi
callq 0x18a59
testb %al, %al
je 0x19b7a
movq %r15, %rdi
callq 0x18ced
movq (%rbx), %rcx
movq (%r14), %rdx
movq 0x18(%rcx), %rdi
movq 0x20(%rcx), %rsi
addq $0x18, %rcx
movq %rsi, %r8
testq %rsi, %rsi
jne 0x19b4d
movq 0x38(%rdx), %r8
movq %rdi, 0x18(%r8)
leaq 0x20(%rdi), %r8
addq $0x38, %rdx
cmpq $0x0, 0x20(%rdi)
cmovneq %r8, %rdx
movq %rsi, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x19b82
movb $0x1, %al
jmp 0x19b7c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::destroy_attribute(pugi::xml_attribute_struct*, pugi::impl::(anonymous namespace)::xml_allocator&)
inline void destroy_attribute(xml_attribute_struct* a, xml_allocator& alloc)
	{
		if (a->header & impl::xml_memory_page_name_allocated_mask)
			alloc.deallocate_string(a->name);

		if (a->header & impl::xml_memory_page_value_allocated_mask)
			alloc.deallocate_string(a->value);

		alloc.deallocate_memory(a, sizeof(xml_attribute_struct), PUGI__GETPAGE(a));
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testb $0x20, %al
je 0x19ba2
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x22c1c
movq (%rbx), %rax
testb $0x10, %al
je 0x19bb5
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x22c1c
movq (%rbx), %rax
shrq $0x8, %rax
movq %rbx, %rcx
subq %rax, %rcx
pushq $0x28
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22c48
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::remove_child(pugi::xml_node const&)
PUGI__FN bool xml_node::remove_child(const xml_node& n)
	{
		if (!_root || !n._root || n._root->parent != _root) return false;

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return false;

		impl::remove_node(n._root);
		impl::destroy_node(n._root, alloc);

		return true;
	}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x19c19
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x19c15
cmpq %rax, 0x18(%rdi)
je 0x19c1c
xorl %eax, %eax
jmp 0x19c3c
xorl %eax, %eax
retq
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %r14
callq 0x1995f
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x19c44
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::destroy_node(pugi::xml_node_struct*, pugi::impl::(anonymous namespace)::xml_allocator&)
inline void destroy_node(xml_node_struct* n, xml_allocator& alloc)
	{
		if (n->header & impl::xml_memory_page_name_allocated_mask)
			alloc.deallocate_string(n->name);

		if (n->header & impl::xml_memory_page_value_allocated_mask)
			alloc.deallocate_string(n->value);

		for (xml_attribute_struct* attr = n->first_attribute; attr; )
		{
			xml_attribute_struct* next = attr->next_attribute;

			destroy_attribute(attr, alloc);

			attr = next;
		}

		for (xml_node_struct* child = n->first_child; child; )
		{
			xml_node_struct* next = child->next_sibling;

			destroy_node(child, alloc);

			child = next;
		}

		alloc.deallocate_memory(n, sizeof(xml_node_struct), PUGI__GETPAGE(n));
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testb $0x20, %al
je 0x19c65
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x22c1c
movq (%rbx), %rax
testb $0x10, %al
je 0x19c75
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x22c1c
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x19c8f
movq 0x20(%rdi), %r15
movq %r14, %rsi
callq 0x19b82
movq %r15, %rdi
jmp 0x19c79
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x19ca9
movq 0x30(%rdi), %r15
movq %r14, %rsi
callq 0x19c44
movq %r15, %rdi
jmp 0x19c93
movq (%rbx), %rax
shrq $0x8, %rax
movq %rbx, %rcx
subq %rax, %rcx
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x22c48
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::append_buffer(void const*, unsigned long, unsigned int, pugi::xml_encoding)
PUGI__FN xml_parse_result xml_node::append_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding)
	{
		// append_buffer is only valid for elements/documents
		if (!impl::allow_insert_child(type(), node_element)) return impl::make_parse_result(status_append_invalid_root);

		// get document node
		impl::xml_document_struct* doc = &impl::get_document(_root);

		// disable document_buffer_order optimization since in a document with multiple buffers comparing buffer pointers does not make sense
		doc->header |= impl::xml_memory_page_contents_shared_mask;

		// get extra buffer element (we'll store the document fragment buffer there so that we can deallocate it later)
		impl::xml_memory_page* page = 0;
		impl::xml_extra_buffer* extra = static_cast<impl::xml_extra_buffer*>(doc->allocate_memory(sizeof(impl::xml_extra_buffer) + sizeof(void*), page));
		(void)page;

		if (!extra) return impl::make_parse_result(status_out_of_memory);

	#ifdef PUGIXML_COMPACT
		// align the memory block to a pointer boundary; this is required for compact mode where memory allocations are only 4b aligned
		// note that this requires up to sizeof(void*)-1 additional memory, which the allocation above takes into account
		extra = reinterpret_cast<impl::xml_extra_buffer*>((reinterpret_cast<uintptr_t>(extra) + (sizeof(void*) - 1)) & ~(sizeof(void*) - 1));
	#endif

		// add extra buffer to the list
		extra->buffer = 0;
		extra->next = doc->extra_buffers;
		doc->extra_buffers = extra;

		// name of the root has to be NULL before parsing - otherwise closing node mismatches will not be detected at the top level
		impl::name_null_sentry sentry(_root);

		return impl::load_buffer_impl(doc, _root, const_cast<void*>(contents), size, options, encoding, false, false, &extra->buffer);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x19cf0
movl (%rdi), %eax
andl $0xf, %eax
addl $-0x3, %eax
cmpl $-0x3, %eax
ja 0x19d11
andl $0x0, 0x10(%rbx)
movl $0xf, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %r9, 0x8(%rsp)
callq 0x18ac0
movq %rax, %r14
orb $0x40, (%rax)
leaq 0x40(%rax), %rdi
pushq $0x18
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x19db4
testq %rax, %rax
je 0x19d95
andq $0x0, (%rax)
movq 0x58(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x58(%r14)
movq (%r13), %r13
movq 0x8(%r13), %rcx
movq %rcx, (%rsp)
andq $0x0, 0x8(%r13)
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movl %ebp, %r9d
pushq %rax
pushq $0x0
pushq $0x0
pushq 0x20(%rsp)
callq 0x19ddb
addq $0x20, %rsp
movq (%rsp), %rax
movq %rax, 0x8(%r13)
jmp 0x19cff
andl $0x0, 0x10(%rbx)
movl $0x3, (%rbx)
jmp 0x19cfa
movq (%rsp), %rcx
movq %rcx, 0x8(%r13)
movq %rax, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::find_child_by_attribute(char const*, char const*, char const*) const
PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* name_, const char_t* attr_name, const char_t* attr_value) const
	{
		if (!_root) return xml_node();

		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
			if (i->name && impl::strequal(name_, i->name))
			{
				for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
					if (a->name && impl::strequal(attr_name, a->name) && impl::strequal(attr_value, a->value ? a->value + 0 : PUGIXML_TEXT("")))
						return xml_node(i);
			}

		return xml_node();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x1b5cd
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
addq $0x20, %rbx
leaq 0xeb9e(%rip), %r13      # 0x2a109
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1b5cd
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1b5c7
movq %r12, %rdi
callq 0x1888f
testb %al, %al
je 0x1b5c7
leaq 0x38(%rbx), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x1b5c7
movq 0x8(%rbp), %rsi
testq %rsi, %rsi
je 0x1b5c1
movq %r15, %rdi
callq 0x1888f
testb %al, %al
je 0x1b5c1
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
cmoveq %r13, %rsi
movq %r14, %rdi
callq 0x1888f
testb %al, %al
jne 0x1b5cf
addq $0x20, %rbp
jmp 0x1b58c
addq $0x30, %rbx
jmp 0x1b56b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::find_child_by_attribute(char const*, char const*) const
PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const
	{
		if (!_root) return xml_node();

		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
			for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
				if (a->name && impl::strequal(attr_name, a->name) && impl::strequal(attr_value, a->value ? a->value + 0 : PUGIXML_TEXT("")))
					return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x1b651
movq %rdx, %r14
movq %rsi, %r15
addq $0x20, %rbx
leaq 0xeb05(%rip), %r12      # 0x2a109
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1b651
leaq 0x38(%rbx), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x1b64b
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x1b645
movq %r15, %rdi
callq 0x1888f
testb %al, %al
je 0x1b645
movq 0x10(%r13), %rsi
testq %rsi, %rsi
cmoveq %r12, %rsi
movq %r14, %rdi
callq 0x1888f
testb %al, %al
jne 0x1b653
addq $0x20, %r13
jmp 0x1b610
addq $0x30, %rbx
jmp 0x1b604
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::path[abi:cxx11](char) const
PUGI__FN string_t xml_node::path(char_t delimiter) const
	{
		if (!_root) return string_t();

		size_t offset = 0;

		for (xml_node_struct* i = _root; i; i = i->parent)
		{
			offset += (i != _root);
			offset += i->name ? impl::strlength(i->name) : 0;
		}

		string_t result;
		result.resize(offset);

		for (xml_node_struct* j = _root; j; j = j->parent)
		{
			if (j != _root)
				result[--offset] = delimiter;

			if (j->name)
			{
				size_t length = impl::strlength(j->name);

				offset -= length;
				memcpy(&result[offset], j->name, length * sizeof(char_t));
			}
		}

		assert(offset == 0);

		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq (%rsi), %r12
testq %r12, %r12
je 0x1b74c
xorl %r15d, %r15d
movq %r12, %r13
testq %r13, %r13
je 0x1b6bb
xorl %ebp, %ebp
cmpq %r12, %r13
setne %r14b
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0x1b6aa
callq 0x6260
jmp 0x1b6ac
xorl %eax, %eax
movb %r14b, %bpl
addq %rbp, %r15
addq %rax, %r15
movq 0x18(%r13), %r13
jmp 0x1b68c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6280
movq 0x10(%rsp), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x1b728
movq 0x10(%rsp), %rax
cmpq (%rax), %r13
je 0x1b6fd
movq (%rbx), %rax
movl 0xc(%rsp), %ecx
movb %cl, -0x1(%rax,%r15)
decq %r15
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x1b722
movq %r12, %rdi
callq 0x6260
subq %rax, %r15
movq (%rbx), %rdi
addq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x6080
addq $0x18, %r13
jmp 0x1b6db
testq %r15, %r15
je 0x1b75c
leaq 0x108fd(%rip), %rdi     # 0x2c031
leaq 0x107fa(%rip), %rsi     # 0x2bf35
leaq 0x108fb(%rip), %rcx     # 0x2c03d
movl $0x180e, %edx           # imm = 0x180E
callq 0x6100
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6890
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::first_element_by_path(char const*, char) const
PUGI__FN xml_node xml_node::first_element_by_path(const char_t* path_, char_t delimiter) const
	{
		xml_node found = *this; // Current search context.

		if (!_root || !path_[0]) return found;

		if (path_[0] == delimiter)
		{
			// Absolute path; e.g. '/foo/bar'
			found = found.root();
			++path_;
		}

		const char_t* path_segment = path_;

		while (*path_segment == delimiter) ++path_segment;

		const char_t* path_segment_end = path_segment;

		while (*path_segment_end && *path_segment_end != delimiter) ++path_segment_end;

		if (path_segment == path_segment_end) return found;

		const char_t* next_segment = path_segment_end;

		while (*next_segment == delimiter) ++next_segment;

		if (*path_segment == '.' && path_segment + 1 == path_segment_end)
			return found.first_element_by_path(next_segment, delimiter);
		else if (*path_segment == '.' && *(path_segment+1) == '.' && path_segment + 2 == path_segment_end)
			return found.parent().first_element_by_path(next_segment, delimiter);
		else
		{
			for (xml_node_struct* j = found._root->first_child; j; j = j->next_sibling)
			{
				if (j->name && impl::strequalrange(j->name, path_segment, static_cast<size_t>(path_segment_end - path_segment)))
				{
					xml_node subsearch = xml_node(j).first_element_by_path(next_segment, delimiter);

					if (subsearch) return subsearch;
				}
			}

			return xml_node();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rbx
movq %rbx, 0x10(%rsp)
testq %rbx, %rbx
je 0x1b8a3
movq %rsi, %r14
movb (%rsi), %al
testb %al, %al
je 0x1b8a3
cmpb %dl, %al
jne 0x1b7cc
movq (%rbx), %rax
shrq $0x8, %rax
negq %rax
movq (%rbx,%rax), %rbx
addq $-0x40, %rbx
movq %rbx, 0x10(%rsp)
incq %r14
decq %r14
movb 0x1(%r14), %al
incq %r14
cmpb %dl, %al
je 0x1b7cf
xorl %ecx, %ecx
movb (%r14,%rcx), %sil
incq %rcx
testb %sil, %sil
je 0x1b7ed
cmpb %dl, %sil
jne 0x1b7dc
cmpq $0x1, %rcx
je 0x1b8a3
leaq -0x1(%rcx), %r12
leaq (%r14,%rcx), %r15
addq $-0x2, %r15
movq %r15, %rsi
incq %r15
cmpb %dl, 0x1(%rsi)
je 0x1b803
cmpb $0x2e, %al
setne %sil
cmpq $0x2, %rcx
setne %dil
orb %sil, %dil
jne 0x1b836
movsbl %dl, %edx
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1b782
movq %rax, %rbx
jmp 0x1b8a3
cmpb $0x2e, %al
jne 0x1b858
cmpq $0x3, %rcx
jne 0x1b858
cmpb $0x2e, 0x1(%r14)
jne 0x1b858
movq 0x18(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movsbl %dl, %edx
jmp 0x1b829
addq $0x20, %rbx
movsbl %dl, %ebp
leaq 0x8(%rsp), %r13
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1b8a1
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1b89b
movq %r14, %rsi
movq %r12, %rdx
callq 0x1b8b5
testb %al, %al
je 0x1b89b
movq %rbx, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1b782
testq %rax, %rax
jne 0x1b831
addq $0x30, %rbx
jmp 0x1b864
xorl %ebx, %ebx
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_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::strequalrange(char const*, char const*, unsigned long)
PUGI__FN bool strequalrange(const char_t* lhs, const char_t* rhs, size_t count)
	{
		for (size_t i = 0; i < count; ++i)
			if (lhs[i] != rhs[i])
				return false;

		return lhs[count] == 0;
	}

// Assembly:
xorl %eax, %eax
cmpq %rax, %rdx
je 0x1b8ce
movb (%rdi,%rax), %cl
leaq 0x1(%rax), %r8
cmpb (%rsi,%rax), %cl
movq %r8, %rax
je 0x1b8b7
xorl %eax, %eax
retq
cmpb $0x0, (%rdi,%rdx)
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::traverse(pugi::xml_tree_walker&)
PUGI__FN bool xml_node::traverse(xml_tree_walker& walker)
	{
		walker._depth = -1;

		xml_node arg_begin(_root);
		if (!walker.begin(arg_begin)) return false;

		xml_node_struct* cur = _root ? _root->first_child + 0 : 0;

		if (cur)
		{
			++walker._depth;

			do
			{
				xml_node arg_for_each(cur);
				if (!walker.for_each(arg_for_each))
					return false;

				if (cur->first_child)
				{
					++walker._depth;
					cur = cur->first_child;
				}
				else if (cur->next_sibling)
					cur = cur->next_sibling;
				else
				{
					while (!cur->next_sibling && cur != _root && cur->parent)
					{
						--walker._depth;
						cur = cur->parent;
					}

					if (cur != _root)
						cur = cur->next_sibling;
				}
			}
			while (cur && cur != _root);
		}

		assert(walker._depth == -1);

		xml_node arg_end(_root);
		return walker.end(arg_end);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
orl $-0x1, 0x8(%rsi)
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x1b99c
movq (%r14), %rax
testq %rax, %rax
je 0x1b9a0
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x1b9a2
incl 0x8(%rbx)
leaq 0x8(%rsp), %r15
movq %r12, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%rax)
testb %al, %al
je 0x1b99c
movq 0x20(%r12), %rcx
testq %rcx, %rcx
je 0x1b94c
incl 0x8(%rbx)
jmp 0x1b956
movq 0x30(%r12), %rcx
testq %rcx, %rcx
je 0x1b968
movq (%r14), %rax
movq %rcx, %r12
testq %rcx, %rcx
je 0x1b9a2
cmpq %rax, %r12
jne 0x1b928
jmp 0x1b9a2
xorl %ecx, %ecx
movq (%r14), %rax
cmpq %rax, %r12
sete %dl
testq %rcx, %rcx
jne 0x1b990
testb %dl, %dl
jne 0x1b990
movq 0x18(%r12), %r12
testq %r12, %r12
je 0x1b998
decl 0x8(%rbx)
movq 0x30(%r12), %rcx
jmp 0x1b96a
testb %dl, %dl
cmovneq %r12, %rcx
jmp 0x1b959
xorl %ecx, %ecx
jmp 0x1b959
xorl %eax, %eax
jmp 0x1b9b9
xorl %eax, %eax
cmpl $-0x1, 0x8(%rbx)
jne 0x1b9c5
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1069d(%rip), %rdi     # 0x2c069
leaq 0x10562(%rip), %rsi     # 0x2bf35
leaq 0x106a3(%rip), %rcx     # 0x2c07d
movl $0x186c, %edx           # imm = 0x186C
callq 0x6100
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::print(pugi::xml_writer&, char const*, unsigned int, pugi::xml_encoding, unsigned int) const
PUGI__FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
	{
		if (!_root) return;

		impl::xml_buffered_writer buffered_writer(writer, encoding);

		impl::node_output(buffered_writer, _root, indent, flags, depth);

		buffered_writer.flush();
	}

// Assembly:
cmpq $0x0, (%rdi)
je 0x1ba4a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2820, %rsp           # imm = 0x2820
movl %r9d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl %r8d, %edx
callq 0x1ba4c
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x1ba7d
movq %r12, %rdi
callq 0x1bd66
addq $0x2820, %rsp           # imm = 0x2820
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::offset_debug() const
PUGI__FN ptrdiff_t xml_node::offset_debug() const
	{
		if (!_root) return -1;

		impl::xml_document_struct& doc = impl::get_document(_root);

		// we can determine the offset reliably only if there is exactly once parse buffer
		if (!doc.buffer || doc.extra_buffers) return -1;

		switch (type())
		{
		case node_document:
			return 0;

		case node_element:
		case node_declaration:
		case node_pi:
			return _root->name && (_root->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0 ? _root->name - doc.buffer : -1;

		case node_pcdata:
		case node_cdata:
		case node_comment:
		case node_doctype:
			return _root->value && (_root->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0 ? _root->value - doc.buffer : -1;

		default:
			assert(false && "Invalid node type"); // unreachable
			return -1;
		}
	}

// Assembly:
movq (%rdi), %rsi
pushq $-0x1
popq %rax
testq %rsi, %rsi
je 0x1be54
movq (%rsi), %rdx
movq %rdx, %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rsi,%rcx), %rdi
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x1be54
cmpq $0x0, 0x18(%rdi)
jne 0x1be54
movl %edx, %edi
andl $0xf, %edi
cmpl $0x8, %edi
ja 0x1be5d
movl $0x138, %r8d            # imm = 0x138
btl %edi, %r8d
jb 0x1be38
movl $0xc4, %r8d
btl %edi, %r8d
jae 0x1be55
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x60, %dl
jmp 0x1be46
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x50, %dl
setne %dl
orb %dil, %dl
jne 0x1be54
subq %rcx, %rsi
movq %rsi, %rax
retq
cmpl $0x1, %edi
jne 0x1be5d
xorl %eax, %eax
retq
pushq %rax
leaq 0x10249(%rip), %rdi     # 0x2c0ae
leaq 0x100c9(%rip), %rsi     # 0x2bf35
leaq 0x10258(%rip), %rcx     # 0x2c0cb
movl $0x18b1, %edx           # imm = 0x18B1
callq 0x6100
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_text::_data() const
PUGI__FN xml_node_struct* xml_text::_data() const
	{
		if (!_root || impl::is_text_node(_root)) return _root;

		// element nodes can have value if parse_embed_pcdata was used
		if (PUGI__NODETYPE(_root) == node_element && _root->value)
			return _root;

		for (xml_node_struct* node = _root->first_child; node; node = node->next_sibling)
			if (impl::is_text_node(node))
				return node;

		return 0;
	}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1bec9
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
addl $-0x3, %edx
cmpl $0x2, %edx
jb 0x1bea9
andl $0xf, %ecx
cmpl $0x2, %ecx
jne 0x1beaa
cmpq $0x0, 0x10(%rax)
je 0x1beaa
retq
addq $0x20, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1bec9
movl (%rax), %ecx
andl $0xf, %ecx
addl $-0x3, %ecx
cmpl $0x2, %ecx
jb 0x1bea9
addq $0x30, %rax
jmp 0x1beae
xorl %eax, %eax
retq