LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::insert_node_after(pugi::xml_node_struct*, pugi::xml_node_struct*)
inline void insert_node_after(xml_node_struct* child, xml_node_struct* node)
	{
		xml_node_struct* parent = node->parent;

		child->parent = parent;

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

		child->next_sibling = node->next_sibling;
		child->prev_sibling_c = node;

		node->next_sibling = child;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x43d31
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x43d41
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42160
movq -0x38(%rbp), %rdi
movl %eax, -0x1c(%rbp)
callq 0x42160
movl %eax, %edi
movl -0x1c(%rbp), %esi
callq 0x437f0
testb $0x1, %al
jne 0x43ed9
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43f5b
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x43f01
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43f5b
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x43850
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x41c10
leaq -0x30(%rbp), %rdi
callq 0x41c70
testb $0x1, %al
jne 0x43f28
jmp 0x43f33
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43f5b
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x438b0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43f70
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42d20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42d20
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0x43fb4
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x43fbc
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x43fbc
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4fa40
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x49(%rbp)
je 0x44003
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x4400f
jmp 0x440b9
movq -0x30(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x44077
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rax
andq $0xf, %rax
movl %eax, %edx
callq 0x4fb50
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x44075
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4fa40
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x44073
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x43fe9
jmp 0x44075
jmp 0x44077
jmp 0x44079
movq -0x30(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x44092
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x440b4
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x44079
jmp 0x43fe9
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42160
movq -0x38(%rbp), %rdi
movl %eax, -0x1c(%rbp)
callq 0x42160
movl %eax, %edi
movl -0x1c(%rbp), %esi
callq 0x437f0
testb $0x1, %al
jne 0x44109
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4418b
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x44131
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4418b
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x43850
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x41c10
leaq -0x30(%rbp), %rdi
callq 0x41c70
testb $0x1, %al
jne 0x44158
jmp 0x44163
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4418b
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x43a00
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43f70
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42160
movq -0x40(%rbp), %rdi
movl %eax, -0x24(%rbp)
callq 0x42160
movl %eax, %edi
movl -0x24(%rbp), %esi
callq 0x437f0
testb $0x1, %al
jne 0x441ed
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4429b
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4420b
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq (%rcx), %rax
je 0x44219
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4429b
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x44241
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4429b
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x43850
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x41c10
leaq -0x38(%rbp), %rdi
callq 0x41c70
testb $0x1, %al
jne 0x44268
jmp 0x44273
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4429b
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x43cf0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43f70
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42160
movq -0x40(%rbp), %rdi
movl %eax, -0x24(%rbp)
callq 0x42160
movl %eax, %edi
movl -0x24(%rbp), %esi
callq 0x437f0
testb $0x1, %al
jne 0x442fd
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x443ab
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4431b
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq (%rcx), %rax
je 0x44329
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x443ab
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x44351
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x443ab
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x43850
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x41c10
leaq -0x38(%rbp), %rdi
callq 0x41c70
testb $0x1, %al
jne 0x44378
jmp 0x44383
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x443ab
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x43b70
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43f70
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x44480
testb $0x1, %al
jne 0x44406
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4446e
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x4442e
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4446e
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42780
movq (%rax), %rcx
orq $0x40, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x44550
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x438b0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x42160
movl %eax, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x42160
movl -0x3c(%rbp), %edi
movl %eax, %esi
callq 0x437f0
testb $0x1, %al
jne 0x444b9
movb $0x0, -0x1(%rbp)
jmp 0x44537
leaq -0x10(%rbp), %rdi
callq 0x42730
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x42730
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x42000
testb $0x1, %al
jne 0x444e6
jmp 0x444ec
movb $0x0, -0x1(%rbp)
jmp 0x44537
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41c30
cmpq $0x0, %rax
je 0x44533
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x41fd0
testb $0x1, %al
jne 0x44516
jmp 0x4451c
movb $0x0, -0x1(%rbp)
jmp 0x44537
leaq -0x30(%rbp), %rdi
callq 0x426e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x444f4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x44585
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x44599
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x445be
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
jmp 0x445ce
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x44480
testb $0x1, %al
jne 0x44646
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x446ae
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x4466e
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x446ae
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42780
movq (%rax), %rcx
orq $0x40, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x44550
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x43a00
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x44480
testb $0x1, %al
jne 0x4470d
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x447bc
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4472b
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq (%rcx), %rax
je 0x44739
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x447bc
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x44754
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x447bc
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x4477c
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x447bc
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x42780
movq (%rax), %rcx
orq $0x40, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x44550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x43cf0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x44480
testb $0x1, %al
jne 0x4481d
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x448cc
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4483b
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq (%rcx), %rax
je 0x44849
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x448cc
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x44864
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x448cc
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x4488c
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x448cc
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x42780
movq (%rax), %rcx
orq $0x40, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x44550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x43b70
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x44948
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4494e
movb $0x0, -0x1(%rbp)
jmp 0x449b5
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x42630
testb $0x1, %al
jne 0x4496b
movb $0x0, -0x1(%rbp)
jmp 0x449b5
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x4498e
movb $0x0, -0x1(%rbp)
jmp 0x449b5
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x449c0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x44a50
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::remove_attribute(pugi::xml_attribute_struct*, pugi::xml_node_struct*)
inline void remove_attribute(xml_attribute_struct* attr, xml_node_struct* node)
	{
		if (attr->next_attribute)
			attr->next_attribute->prev_attribute_c = attr->prev_attribute_c;
		else
			node->first_attribute->prev_attribute_c = attr->prev_attribute_c;

		if (attr->prev_attribute_c->next_attribute)
			attr->prev_attribute_c->next_attribute = attr->next_attribute;
		else
			node->first_attribute = attr->next_attribute;

		attr->prev_attribute_c = 0;
		attr->next_attribute = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x449ed
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x44a01
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x44a26
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x44a36
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0x44a82
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4fc30
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x44aa4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4fc30
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdx
shrq $0x8, %rdx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movl $0x28, %edx
callq 0x4fcf0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x44b5c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x44b5c
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq (%rcx), %rax
je 0x44b62
movb $0x0, -0x1(%rbp)
jmp 0x44ba5
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x44b85
movb $0x0, -0x1(%rbp)
jmp 0x44ba5
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x44550
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x44bb0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0x44be2
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4fc30
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x44c04
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4fc30
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x44c3a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x44a50
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x44c10
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x44c70
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x44bb0
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x44c46
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdx
shrq $0x8, %rdx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movl $0x40, %edx
callq 0x4fcf0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::make_parse_result(pugi::xml_parse_status, long)
inline xml_parse_result make_parse_result(xml_parse_status status, ptrdiff_t offset = 0)
	{
		xml_parse_result result;
		result.status = status;
		result.offset = offset;

		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x47520
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_allocator::allocate_memory(unsigned long, pugi::impl::(anonymous namespace)::xml_memory_page*&)
void* allocate_memory(size_t size, xml_memory_page*& out_page)
		{
			if (PUGI__UNLIKELY(_busy_size + size > xml_memory_page_size))
				return allocate_memory_oob(size, out_page);

			void* buf = reinterpret_cast<char*>(_root) + sizeof(xml_memory_page) + _busy_size;

			_busy_size += size;

			out_page = _root;

			return buf;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
cmpq $0x7fd8, %rax           # imm = 0x7FD8
jbe 0x44e93
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4fee0
movq %rax, -0x8(%rbp)
jmp 0x44ec4
movq -0x30(%rbp), %rax
movq (%rax), %rcx
addq $0x28, %rcx
addq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x450b4
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x451b1
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x451a8
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x45195
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x450f7
jmp 0x45195
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x45193
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x45180
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x45130
jmp 0x45180
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x45151
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x4515e
leaq 0x23fb1(%rip), %rax     # 0x69109
movq %rax, -0x50(%rbp)
jmp 0x4515e
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x45171
jmp 0x45180
movq -0x30(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x41c10
jmp 0x451b1
jmp 0x45182
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x45103
jmp 0x45195
jmp 0x45197
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x450c3
leaq -0x8(%rbp), %rdi
callq 0x41bf0
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x451f0
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x452c2
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x452b9
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x452a6
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x45293
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x45243
jmp 0x45293
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x45264
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x45271
leaq 0x23e9e(%rip), %rax     # 0x69109
movq %rax, -0x48(%rbp)
jmp 0x45271
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x45284
jmp 0x45293
movq -0x28(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x41c10
jmp 0x452c2
jmp 0x45295
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x45216
jmp 0x452a8
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x451ff
leaq -0x8(%rbp), %rdi
callq 0x41bf0
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x45764
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x45754
movb $0x0, -0x1(%rbp)
jmp 0x4577b
jmp 0x45756
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x45728
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x2850, %rsp           # imm = 0x2850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2848(%rbp)
cmpq $0x0, (%rax)
jne 0x459f5
jmp 0x45a35
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
leaq -0x2840(%rbp), %rdi
callq 0x45a40
movq -0x2848(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x24(%rbp), %r8d
leaq -0x2840(%rbp), %rdi
callq 0x45a90
leaq -0x2840(%rbp), %rdi
callq 0x45d50
addq $0x2850, %rsp           # imm = 0x2850
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
jne 0x45ed7
movq $-0x1, -0x8(%rbp)
jmp 0x46026
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x42780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x45efd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x45f0a
movq $-0x1, -0x8(%rbp)
jmp 0x46026
movq -0x20(%rbp), %rdi
callq 0x42160
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $0x1, %eax
je 0x45f50
jmp 0x45f1f
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x45f5d
jmp 0x45f29
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x45fb2
jmp 0x45f36
movl -0x24(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x45f5d
jmp 0x45f43
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0x45fb2
jmp 0x46007
movq $0x0, -0x8(%rbp)
jmp 0x46026
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x45f9b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0x60, %rax
cmpq $0x0, %rax
jne 0x45f9b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x45fa8
movq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x45fa8
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x46026
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x45ff0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0x50, %rax
cmpq $0x0, %rax
jne 0x45ff0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x45ffd
movq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x45ffd
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x46026
leaq 0x254c0(%rip), %rdi     # 0x6b4ce
leaq 0x25340(%rip), %rsi     # 0x6b355
movl $0x18b1, %edx           # imm = 0x18B1
leaq 0x254ca(%rip), %rcx     # 0x6b4eb
callq 0x7180
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x4607c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x428f0
testb $0x1, %al
jne 0x4607c
jmp 0x46089
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x460fe
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0xf, %rax
cmpl $0x2, %eax
jne 0x460b7
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x460b7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x460fe
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x460f6
movq -0x18(%rbp), %rdi
callq 0x428f0
testb $0x1, %al
jne 0x460dc
jmp 0x460e6
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x460fe
jmp 0x460e8
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x460c6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_named_node_iterator::operator--()
PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator--()
	{
		if (_wrap._root)
			_wrap = _wrap.previous_sibling(_name);
		else
		{
			_wrap = _parent.last_child();

			if (!impl::strequal(_wrap.name(), _name))
				_wrap = _wrap.previous_sibling(_name);
		}

		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x4746b
movq -0x28(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x423f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x474c1
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x42a60
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
callq 0x42110
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x474bf
movq -0x28(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x423f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x474c1
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_parse_result::description() const
PUGI__FN const char* xml_parse_result::description() const
	{
		switch (status)
		{
		case status_ok: return "No error";

		case status_file_not_found: return "File was not found";
		case status_io_error: return "Error reading from file/stream";
		case status_out_of_memory: return "Could not allocate memory";
		case status_internal_error: return "Internal error occurred";

		case status_unrecognized_tag: return "Could not determine tag type";

		case status_bad_pi: return "Error parsing document declaration/processing instruction";
		case status_bad_comment: return "Error parsing comment";
		case status_bad_cdata: return "Error parsing CDATA section";
		case status_bad_doctype: return "Error parsing document type declaration";
		case status_bad_pcdata: return "Error parsing PCDATA section";
		case status_bad_start_element: return "Error parsing start element tag";
		case status_bad_attribute: return "Error parsing element attribute";
		case status_bad_end_element: return "Error parsing end element tag";
		case status_end_element_mismatch: return "Start-end tags mismatch";

		case status_append_invalid_root: return "Unable to append nodes: root is not an element or document";

		case status_no_document_element: return "No document element found";

		default: return "Unknown error";
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x10, %rax
ja 0x47695
movq -0x18(%rbp), %rax
leaq 0x23259(%rip), %rcx     # 0x6a7f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x241bf(%rip), %rax     # 0x6b766
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x241b8(%rip), %rax     # 0x6b76f
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x241bb(%rip), %rax     # 0x6b782
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x241ca(%rip), %rax     # 0x6b7a1
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x241d4(%rip), %rax     # 0x6b7bb
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x241dc(%rip), %rax     # 0x6b7d3
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x241e9(%rip), %rax     # 0x6b7f0
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x24213(%rip), %rax     # 0x6b82a
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x24219(%rip), %rax     # 0x6b840
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x24228(%rip), %rax     # 0x6b85c
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x24243(%rip), %rax     # 0x6b884
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x24253(%rip), %rax     # 0x6b8a1
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x24266(%rip), %rax     # 0x6b8c1
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x24279(%rip), %rax     # 0x6b8e1
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x2428a(%rip), %rax     # 0x6b8ff
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x24295(%rip), %rax     # 0x6b917
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x242c3(%rip), %rax     # 0x6b952
movq %rax, -0x8(%rbp)
jmp 0x476a0
leaq 0x242d0(%rip), %rax     # 0x6b96c
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_memory_page::construct(void*)
static xml_memory_page* construct(void* memory)
		{
			xml_memory_page* result = static_cast<xml_memory_page*>(memory);

			result->allocator = 0;
			result->prev = 0;
			result->next = 0;
			result->busy_size = 0;
			result->freed_size = 0;

		#ifdef PUGIXML_COMPACT
			result->compact_string_base = 0;
			result->compact_shared_parent = 0;
			result->compact_page_marker = 0;
		#endif

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)