LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
xorl %ecx, %ecx
movl $0x0, %r12d
testq %rax, %rax
je 0x1eacb
movl (%rax), %r12d
andl $0xf, %r12d
movq (%r14), %rax
testq %rax, %rax
je 0x1ead8
movl (%rax), %ecx
andl $0xf, %ecx
xorl %r15d, %r15d
cmpl $0x2, %r12d
jb 0x1ebbd
leal -0x3(%rcx), %edx
cmpl $-0x2, %edx
jb 0x1ebbd
leal -0x9(%r12), %edx
cmpl $-0x2, %edx
jb 0x1eb04
cmpl $0x1, %ecx
jne 0x1eba2
testq %rax, %rax
je 0x1ebe1
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1ebcc
movq (%rdi), %rdx
leaq (%rdx,%rax), %r15
addq $0x28, %r15
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %r15, %r15
je 0x1eb78
movq %r15, %rax
subq (%rsp), %rax
shlq $0x8, %rax
movl %r12d, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq $0x0, 0x38(%r15)
movq %rcx, (%r15)
jmp 0x1eb7b
xorl %r15d, %r15d
testq %r15, %r15
je 0x1eba2
movq (%r14), %rcx
movq %rcx, 0x18(%r15)
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0x1eba7
movq 0x28(%rax), %rcx
addq $0x28, %rax
movq %r15, 0x30(%rcx)
movq %rcx, 0x28(%r15)
jmp 0x1ebaf
xorl %r15d, %r15d
jmp 0x1ebbd
movq %r15, 0x20(%rcx)
leaq 0x28(%r15), %rax
movq %r15, (%rax)
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x1ec00
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28a84
movq %rax, %r15
jmp 0x1eb43
leaq 0x14e0e(%rip), %rdi     # 0x339f6
leaq 0x14306(%rip), %rsi     # 0x32ef5
leaq 0x176bd(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
xorl %ecx, %ecx
movl $0x0, %r12d
testq %rax, %rax
je 0x1ed27
movl (%rax), %r12d
andl $0xf, %r12d
movq (%r14), %rax
testq %rax, %rax
je 0x1ed34
movl (%rax), %ecx
andl $0xf, %ecx
xorl %r15d, %r15d
cmpl $0x2, %r12d
jb 0x1ee19
leal -0x3(%rcx), %edx
cmpl $-0x2, %edx
jb 0x1ee19
leal -0x9(%r12), %edx
cmpl $-0x2, %edx
jb 0x1ed60
cmpl $0x1, %ecx
jne 0x1edfa
testq %rax, %rax
je 0x1ee3d
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1ee28
movq (%rdi), %rdx
leaq (%rdx,%rax), %r15
addq $0x28, %r15
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %r15, %r15
je 0x1edd4
movq %r15, %rax
subq (%rsp), %rax
shlq $0x8, %rax
movl %r12d, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq $0x0, 0x38(%r15)
movq %rcx, (%r15)
jmp 0x1edd7
xorl %r15d, %r15d
testq %r15, %r15
je 0x1edfa
movq (%r14), %rax
movq %rax, 0x18(%r15)
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x1edff
leaq 0x28(%rcx), %rdx
movq 0x28(%rcx), %rsi
movq %rsi, 0x28(%r15)
jmp 0x1ee03
xorl %r15d, %r15d
jmp 0x1ee19
leaq 0x28(%r15), %rdx
movq %r15, (%rdx)
movq %rcx, 0x30(%r15)
movq %r15, 0x20(%rax)
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x1ec00
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28a84
movq %rax, %r15
jmp 0x1ed9f
leaq 0x14bb2(%rip), %rdi     # 0x339f6
leaq 0x140aa(%rip), %rsi     # 0x32ef5
leaq 0x17461(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rsi), %rax
xorl %ecx, %ecx
movl $0x0, %r12d
testq %rax, %rax
je 0x1ee81
movl (%rax), %r12d
andl $0xf, %r12d
movq (%rdi), %rax
testq %rax, %rax
je 0x1ee8e
movl (%rax), %ecx
andl $0xf, %ecx
xorl %r15d, %r15d
cmpl $0x2, %r12d
jb 0x1eebf
leal -0x3(%rcx), %edx
cmpl $-0x2, %edx
jb 0x1eebf
leal -0x9(%r12), %edx
cmpl $-0x2, %edx
jb 0x1eeae
cmpl $0x1, %ecx
jne 0x1eebc
movq (%r14), %rcx
testq %rcx, %rcx
je 0x1eebc
cmpq %rax, 0x18(%rcx)
je 0x1eece
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rax, %rax
je 0x1ef9e
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1ef89
movq (%rdi), %rdx
leaq (%rdx,%rax), %r15
addq $0x28, %r15
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %r15, %r15
je 0x1ef42
movq %r15, %rax
subq (%rsp), %rax
shlq $0x8, %rax
movl %r12d, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq $0x0, 0x38(%r15)
movq %rcx, (%r15)
jmp 0x1ef45
xorl %r15d, %r15d
testq %r15, %r15
je 0x1eebc
movq (%r14), %rax
movq 0x18(%rax), %rdx
movq %rdx, 0x18(%r15)
movq 0x30(%rax), %rcx
movq %rcx, %rsi
testq %rcx, %rcx
jne 0x1ef69
movq 0x20(%rdx), %rsi
movq %r15, 0x28(%rsi)
movq %rcx, 0x30(%r15)
movq %rax, 0x28(%r15)
movq %r15, 0x30(%rax)
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x1ec00
jmp 0x1eebf
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28a84
movq %rax, %r15
jmp 0x1ef0d
leaq 0x14a51(%rip), %rdi     # 0x339f6
leaq 0x13f49(%rip), %rsi     # 0x32ef5
leaq 0x17300(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rsi), %rax
xorl %ecx, %ecx
movl $0x0, %r12d
testq %rax, %rax
je 0x1efe3
movl (%rax), %r12d
andl $0xf, %r12d
movq (%rdi), %rax
testq %rax, %rax
je 0x1eff0
movl (%rax), %ecx
andl $0xf, %ecx
xorl %r15d, %r15d
cmpl $0x2, %r12d
jb 0x1f021
leal -0x3(%rcx), %edx
cmpl $-0x2, %edx
jb 0x1f021
leal -0x9(%r12), %edx
cmpl $-0x2, %edx
jb 0x1f010
cmpl $0x1, %ecx
jne 0x1f01e
movq (%r14), %rcx
testq %rcx, %rcx
je 0x1f01e
cmpq %rax, 0x18(%rcx)
je 0x1f030
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rax, %rax
je 0x1f104
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1f0ef
movq (%rdi), %rdx
leaq (%rdx,%rax), %r15
addq $0x28, %r15
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %r15, %r15
je 0x1f0a4
movq %r15, %rax
subq (%rsp), %rax
shlq $0x8, %rax
movl %r12d, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq $0x0, 0x38(%r15)
movq %rcx, (%r15)
jmp 0x1f0a7
xorl %r15d, %r15d
testq %r15, %r15
je 0x1f01e
movq (%r14), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x18(%r15)
movq 0x28(%rax), %rdx
addq $0x20, %rcx
cmpq $0x0, 0x30(%rdx)
leaq 0x30(%rdx), %rsi
cmovneq %rsi, %rcx
movq %r15, (%rcx)
movq %rdx, 0x28(%r15)
movq %rax, 0x30(%r15)
movq %r15, 0x28(%rax)
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x1ec00
jmp 0x1f021
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28a84
movq %rax, %r15
jmp 0x1f06f
leaq 0x148eb(%rip), %rdi     # 0x339f6
leaq 0x13de3(%rip), %rsi     # 0x32ef5
leaq 0x1719a(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
movq (%rsi), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f20e
testb %al, %al
je 0x1f1d1
testq %r12, %r12
je 0x1f1ef
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rax
movq 0x28(%r15), %rdx
movq 0x30(%r15), %rcx
movq %rcx, %rsi
testq %rcx, %rcx
jne 0x1f180
movq 0x20(%rax), %rsi
movq %rdx, 0x28(%rsi)
movq 0x28(%r15), %rdx
addq $0x20, %rax
cmpq $0x0, 0x30(%rdx)
leaq 0x30(%rdx), %rdx
cmovneq %rdx, %rax
movq %rcx, (%rax)
movq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movq (%rbx), %rax
movq (%r14), %rdx
movq %rdx, 0x18(%rax)
movq 0x20(%rdx), %rcx
testq %rcx, %rcx
je 0x1f1d5
movq 0x28(%rcx), %rdx
addq $0x28, %rcx
movq %rax, 0x30(%rdx)
movq %rdx, 0x28(%rax)
jmp 0x1f1dd
xorl %eax, %eax
jmp 0x1f1e3
movq %rax, 0x20(%rdx)
leaq 0x28(%rax), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x14800(%rip), %rdi     # 0x339f6
leaq 0x13cf8(%rip), %rsi     # 0x32ef5
leaq 0x170af(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movl $0x0, %ecx
testq %rdi, %rdi
je 0x1f21f
movl (%rdi), %ecx
andl $0xf, %ecx
testq %rsi, %rsi
je 0x1f229
movl (%rsi), %eax
andl $0xf, %eax
leal -0x3(%rcx), %edx
cmpl $-0x2, %edx
setb %dl
cmpl $0x2, %eax
setb %r8b
orb %dl, %r8b
jne 0x1f286
cmpl $0x1, %ecx
je 0x1f24b
addl $-0x9, %eax
cmpl $-0x3, %eax
ja 0x1f286
testq %rdi, %rdi
je 0x1f264
movq (%rdi), %rax
shrq $0x8, %rax
negq %rax
movq (%rdi,%rax), %rax
addq $-0x40, %rax
jmp 0x1f266
xorl %eax, %eax
testq %rsi, %rsi
je 0x1f27f
movq (%rsi), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rsi,%rcx), %rcx
addq $-0x40, %rcx
jmp 0x1f281
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1f289
xorl %eax, %eax
retq
testq %rdi, %rdi
sete %al
cmpq %rsi, %rdi
sete %cl
orb %al, %cl
jne 0x1f288
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
sete %al
je 0x1f288
cmpq %rsi, %rdi
jne 0x1f299
jmp 0x1f288
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
movq (%rsi), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f20e
testb %al, %al
je 0x1f355
testq %r12, %r12
je 0x1f377
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rax
movq 0x28(%r15), %rdx
movq 0x30(%r15), %rcx
movq %rcx, %rsi
testq %rcx, %rcx
jne 0x1f308
movq 0x20(%rax), %rsi
movq %rdx, 0x28(%rsi)
movq 0x28(%r15), %rdx
addq $0x20, %rax
cmpq $0x0, 0x30(%rdx)
leaq 0x30(%rdx), %rdx
cmovneq %rdx, %rax
movq %rcx, (%rax)
movq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movq (%rbx), %rax
movq (%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
je 0x1f359
leaq 0x28(%rdx), %rsi
movq 0x28(%rdx), %rdi
movq %rdi, 0x28(%rax)
jmp 0x1f35d
xorl %eax, %eax
jmp 0x1f36b
leaq 0x28(%rax), %rsi
movq %rax, (%rsi)
movq %rdx, 0x30(%rax)
movq %rax, 0x20(%rcx)
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x14678(%rip), %rdi     # 0x339f6
leaq 0x13b70(%rip), %rsi     # 0x32ef5
leaq 0x16f27(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdi), %r12
movq (%rsi), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f20e
testb %al, %al
je 0x1f3d2
movq (%r14), %rax
testq %rax, %rax
je 0x1f3d2
cmpq %r12, 0x18(%rax)
setne %cl
cmpq %rax, %r15
sete %al
orb %cl, %al
je 0x1f3e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %r12, %r12
je 0x1f477
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rax
movq 0x28(%r15), %rdx
movq 0x30(%r15), %rcx
movq %rcx, %rsi
testq %rcx, %rcx
jne 0x1f415
movq 0x20(%rax), %rsi
movq %rdx, 0x28(%rsi)
movq 0x28(%r15), %rdx
leaq 0x30(%rdx), %rsi
addq $0x20, %rax
cmpq $0x0, 0x30(%rdx)
cmovneq %rsi, %rax
movq %rcx, (%rax)
movq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movq (%rbx), %rax
movq (%r14), %rcx
movq 0x18(%rcx), %rsi
movq %rsi, 0x18(%rax)
movq 0x30(%rcx), %rdx
movq %rdx, %rdi
testq %rdx, %rdx
jne 0x1f45f
movq 0x20(%rsi), %rdi
movq %rax, 0x28(%rdi)
movq %rdx, 0x30(%rax)
movq %rcx, 0x28(%rax)
movq %rax, 0x30(%rcx)
movq (%rbx), %rax
jmp 0x1f3d4
leaq 0x14578(%rip), %rdi     # 0x339f6
leaq 0x13a70(%rip), %rsi     # 0x32ef5
leaq 0x16e27(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdi), %r12
movq (%rsi), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f20e
testb %al, %al
je 0x1f4d2
movq (%r14), %rax
testq %rax, %rax
je 0x1f4d2
cmpq %r12, 0x18(%rax)
setne %cl
cmpq %rax, %r15
sete %al
orb %cl, %al
je 0x1f4e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %r12, %r12
je 0x1f57b
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rax
movq 0x28(%r15), %rdx
movq 0x30(%r15), %rcx
movq %rcx, %rsi
testq %rcx, %rcx
jne 0x1f515
movq 0x20(%rax), %rsi
movq %rdx, 0x28(%rsi)
movq 0x28(%r15), %rdx
leaq 0x30(%rdx), %rsi
addq $0x20, %rax
cmpq $0x0, 0x30(%rdx)
cmovneq %rsi, %rax
movq %rcx, (%rax)
movq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movq (%rbx), %rax
movq (%r14), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x28(%rcx), %rsi
addq $0x20, %rdx
cmpq $0x0, 0x30(%rsi)
leaq 0x30(%rsi), %rdi
cmovneq %rdi, %rdx
movq %rax, (%rdx)
movq %rsi, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rax, 0x28(%rcx)
movq (%rbx), %rax
jmp 0x1f4d4
leaq 0x14474(%rip), %rdi     # 0x339f6
leaq 0x1396c(%rip), %rsi     # 0x32ef5
leaq 0x16d23(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1f683
movq (%rsi), %rax
testq %rax, %rax
je 0x1f683
pushq %r14
pushq %rbx
pushq %rax
leaq 0x38(%rcx), %rdx
movq %rdx, %r8
movq (%r8), %rdi
cmpq %rax, %rdi
je 0x1f5f2
leaq 0x20(%rdi), %r8
testq %rdi, %rdi
jne 0x1f5e1
testq %rdi, %rdi
je 0x1f686
movq (%rcx), %r8
shrq $0x8, %r8
negq %r8
movq 0x18(%rax), %r9
movq 0x20(%rax), %rdi
movq %rdi, %r10
testq %rdi, %rdi
jne 0x1f618
movq (%rdx), %r10
movq (%rcx,%r8), %rbx
movq %r9, 0x18(%r10)
movq 0x18(%rax), %rcx
leaq 0x20(%rcx), %r8
cmpq $0x0, 0x20(%rcx)
cmoveq %rdx, %r8
movq %rdi, (%r8)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq (%rsi), %r14
testb $0x20, (%r14)
je 0x1f650
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x2893a
testb $0x10, (%r14)
je 0x1f662
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x2893a
movq (%r14), %rax
shrq $0x8, %rax
movq %r14, %rcx
subq %rax, %rcx
movl $0x28, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28966
movb $0x1, %al
jmp 0x1f688
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f6cd
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x1f6cd
movq 0x18(%rcx), %rdx
cmpq %rax, %rdx
je 0x1f6d0
xorl %eax, %eax
retq
movq (%rax), %rdi
shrq $0x8, %rdi
negq %rdi
movq (%rax,%rdi), %rax
movq 0x28(%rcx), %r8
movq 0x30(%rcx), %rdi
movq %rdi, %r9
testq %rdi, %rdi
jne 0x1f6f2
movq 0x20(%rdx), %r9
pushq %rax
movq %r8, 0x28(%r9)
movq 0x28(%rcx), %r8
addq $0x20, %rdx
cmpq $0x0, 0x30(%r8)
leaq 0x30(%r8), %r8
cmovneq %r8, %rdx
movq %rdi, (%rdx)
movq $0x0, 0x18(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rcx)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x1f730
movb $0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testb $0x20, (%rdi)
je 0x1f74f
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x2893a
testb $0x10, (%rbx)
je 0x1f760
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x2893a
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x1f7b6
movq 0x20(%r15), %r12
testb $0x20, (%r15)
je 0x1f77f
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x2893a
testb $0x10, (%r15)
je 0x1f791
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x2893a
movq (%r15), %rax
shrq $0x8, %rax
movq %r15, %rcx
subq %rax, %rcx
movl $0x28, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x28966
movq %r12, %r15
testq %r12, %r12
jne 0x1f769
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1f7d3
movq 0x30(%rdi), %r15
movq %r14, %rsi
callq 0x1f730
movq %r15, %rdi
testq %r15, %r15
jne 0x1f7bf
movq (%rbx), %rax
shrq $0x8, %rax
movq %rbx, %rcx
subq %rax, %rcx
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x28966
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
testq %rax, %rax
je 0x21299
movq 0x20(%rax), %r13
testq %r13, %r13
je 0x21299
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rbp
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x21290
movq %rbp, %rdi
callq 0x1d71d
testb %al, %al
je 0x21290
movq 0x38(%r13), %r15
testq %r15, %r15
sete %r12b
je 0x2128a
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x21280
movq %r14, %rdi
callq 0x1d71d
testb %al, %al
je 0x21280
movq 0x10(%r15), %rsi
testq %rsi, %rsi
leaq 0xfe99(%rip), %rax      # 0x31109
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x1d71d
testb %al, %al
jne 0x21286
movq 0x20(%r15), %r15
jmp 0x21244
movq %r13, (%rsp)
testb $0x1, %r12b
je 0x212a1
movq 0x30(%r13), %r13
testq %r13, %r13
jne 0x2122b
movq $0x0, (%rsp)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rax
testq %rax, %rax
je 0x21335
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x21331
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xfe2c(%rip), %r13      # 0x31109
movq 0x38(%r12), %r15
testq %r15, %r15
sete %bpl
je 0x21321
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x21317
movq %r14, %rdi
callq 0x1d71d
testb %al, %al
je 0x21317
movq 0x10(%r15), %rsi
testq %rsi, %rsi
cmoveq %r13, %rsi
movq %rbx, %rdi
callq 0x1d71d
testb %al, %al
jne 0x2131d
movq 0x20(%r15), %r15
jmp 0x212e2
movq %r12, (%rsp)
testb $0x1, %bpl
je 0x21338
movq 0x30(%r12), %r12
testq %r12, %r12
jne 0x212dd
xorl %eax, %eax
jmp 0x2133c
xorl %eax, %eax
retq
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x21438
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
xorl %r15d, %r15d
movq %r12, %r13
xorl %ebp, %ebp
cmpq %r12, %r13
setne %r14b
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0x21391
callq 0x6270
jmp 0x21393
xorl %eax, %eax
movb %r14b, %bpl
addq %rbp, %r15
addq %rax, %r15
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x21378
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6480
movq 0x10(%rsp), %r14
movq (%r14), %r13
testq %r13, %r13
je 0x21414
movl 0xc(%rsp), %ebp
cmpq (%r14), %r13
je 0x213e6
movq (%rbx), %rax
movb %bpl, -0x1(%rax,%r15)
decq %r15
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x2140b
movq %r12, %rdi
callq 0x6270
subq %rax, %r15
movq (%rbx), %rdi
addq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x6090
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x213d6
testq %r15, %r15
je 0x2144b
leaq 0x11bd1(%rip), %rdi     # 0x32ff1
leaq 0x11ace(%rip), %rsi     # 0x32ef5
leaq 0x11bcf(%rip), %rcx     # 0x32ffd
movl $0x180e, %edx           # imm = 0x180E
callq 0x6120
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $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
cmpq %r12, %rdi
je 0x2146d
callq 0x63b0
movq %r14, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xffffffff, 0x8(%rsi)  # imm = 0xFFFFFFFF
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x216d6
movq (%r14), %rax
testq %rax, %rax
je 0x21634
movq 0x20(%rax), %r12
jmp 0x21637
xorl %r12d, %r12d
testq %r12, %r12
je 0x216da
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 0x21697
movq 0x20(%r12), %rcx
testq %rcx, %rcx
je 0x2166c
incl 0x8(%rbx)
jmp 0x2169a
movq 0x30(%r12), %rcx
testq %rcx, %rcx
jne 0x2169a
movq 0x30(%r12), %rcx
testq %rcx, %rcx
setne %sil
cmpq (%r14), %r12
sete %dl
orb %dl, %sil
testb $0x1, %sil
je 0x216ad
testb %dl, %dl
cmoveq %rcx, %r12
movq %r12, %rcx
testb %al, %al
je 0x216d6
testq %rcx, %rcx
je 0x216da
movq %rcx, %r12
cmpq (%r14), %rcx
jne 0x21648
jmp 0x216da
movq 0x18(%r12), %rsi
testq %rsi, %rsi
je 0x21691
movq %rsi, %r12
decl 0x8(%rbx)
movq 0x30(%rsi), %rcx
movq (%r14), %rsi
cmpq %rsi, %r12
sete %dl
testq %rcx, %rcx
jne 0x21691
cmpq %rsi, %r12
jne 0x216ad
jmp 0x21691
xorl %eax, %eax
jmp 0x216f4
cmpl $-0x1, 0x8(%rbx)
jne 0x21700
movq (%r14), %rax
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 0x11922(%rip), %rdi     # 0x33029
leaq 0x117e7(%rip), %rsi     # 0x32ef5
leaq 0x11928(%rip), %rcx     # 0x3303d
movl $0x186c, %edx           # imm = 0x186C
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rsi, %rax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x217a3
pushq %rbx
subq $0x2820, %rsp           # imm = 0x2820
movq %rax, 0x2808(%rsp)
movq $0x0, 0x2810(%rsp)
cmpl $0x8, %r8d
ja 0x21772
movl $0x191, %eax            # imm = 0x191
btl %r8d, %eax
jae 0x21772
movl %r8d, %eax
leaq 0x11756(%rip), %rdi     # 0x32ec4
movl (%rdi,%rax,4), %r8d
leaq 0x8(%rsp), %rbx
movl %r8d, 0x2810(%rbx)
movq %rbx, %rdi
movl %r9d, %r8d
callq 0x217a4
movq 0x2808(%rbx), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x2a3c8
addq $0x2820, %rsp           # imm = 0x2820
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $-0x1, %rax
testq %rsi, %rsi
je 0x21d14
movq (%rsi), %rdx
movq %rdx, %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rsi,%rcx), %rdi
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x21d14
cmpq $0x0, 0x18(%rdi)
jne 0x21d14
movl %edx, %edi
andl $0xf, %edi
cmpl $0x8, %edi
ja 0x21d1d
movl $0x138, %r8d            # imm = 0x138
btl %edi, %r8d
jb 0x21cf8
movl $0xc4, %r8d
btl %edi, %r8d
jae 0x21d15
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x60, %dl
jmp 0x21d06
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x50, %dl
setne %dl
orb %dil, %dl
jne 0x21d14
subq %rcx, %rsi
movq %rsi, %rax
retq
cmpl $0x1, %edi
jne 0x21d1d
xorl %eax, %eax
retq
pushq %rax
leaq 0x11349(%rip), %rdi     # 0x3306e
leaq 0x111c9(%rip), %rsi     # 0x32ef5
leaq 0x11358(%rip), %rcx     # 0x3308b
movl $0x18b1, %edx           # imm = 0x18B1
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21d69
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
addl $-0x3, %edx
cmpl $0x2, %edx
jb 0x21d69
andl $0xf, %ecx
cmpl $0x2, %ecx
jne 0x21d6a
cmpq $0x0, 0x10(%rax)
je 0x21d6a
retq
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x21d69
movl (%rax), %ecx
andl $0xf, %ecx
addl $-0x3, %ecx
cmpl $0x2, %ecx
jb 0x21d69
movq 0x30(%rax), %rax
jmp 0x21d6e
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x2264e
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2261c
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2261c
movq 0x28(%rax), %rax
jmp 0x2261e
xorl %eax, %eax
movq %rax, (%rbx)
testq %rax, %rax
je 0x2263a
movq 0x8(%rax), %rax
testq %rax, %rax
leaq 0xead5(%rip), %rdi      # 0x31109
cmovneq %rax, %rdi
jmp 0x22641
leaq 0xeac8(%rip), %rdi      # 0x31109
movq 0x10(%rbx), %rsi
callq 0x1d71d
testb %al, %al
jne 0x2265d
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1d7f0
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::_destroy()
PUGI__FN void xml_document::_destroy()
	{
		assert(_root);

		// destroy static storage
		if (_buffer)
		{
			impl::xml_memory::deallocate(_buffer);
			_buffer = 0;
		}

		// destroy extra buffers (note: no need to destroy linked list nodes, they're allocated using document allocator)
		for (impl::xml_extra_buffer* extra = static_cast<impl::xml_document_struct*>(_root)->extra_buffers; extra; extra = extra->next)
		{
			if (extra->buffer) impl::xml_memory::deallocate(extra->buffer);
		}

		// destroy dynamic storage, leave sentinel page (it's in static memory)
		impl::xml_memory_page* root_page = PUGI__GETPAGE(_root);
		assert(root_page && !root_page->prev);
		assert(reinterpret_cast<char*>(root_page) >= _memory && reinterpret_cast<char*>(root_page) < _memory + sizeof(_memory));

		for (impl::xml_memory_page* page = root_page->next; page; )
		{
			impl::xml_memory_page* next = page->next;

			impl::xml_allocator::deallocate_page(page);

			page = next;
		}

	#ifdef PUGIXML_COMPACT
		// destroy hash table
		static_cast<impl::xml_document_struct*>(_root)->hash.clear();
	#endif

		_root = 0;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
je 0x22800
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x22786
callq *0x250d2(%rip)          # 0x47850
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movq 0x58(%rax), %r14
testq %r14, %r14
je 0x227a6
movq (%r14), %rdi
testq %rdi, %rdi
je 0x227a0
callq *0x250b0(%rip)          # 0x47850
movq 0x8(%r14), %r14
jmp 0x2278d
movq (%rbx), %rax
movq (%rax), %rcx
shrq $0x8, %rcx
movq %rcx, %rdx
negq %rdx
cmpq $0x0, 0x8(%rax,%rdx)
jne 0x2281f
subq %rcx, %rax
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jb 0x2283e
leaq 0xd0(%rbx), %rcx
cmpq %rcx, %rax
jae 0x2283e
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x227f1
movq 0x10(%rdi), %r14
callq *0x25067(%rip)          # 0x47850
movq %r14, %rdi
testq %r14, %r14
jne 0x227df
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10d14(%rip), %rdi     # 0x3351b
leaq 0x106e7(%rip), %rsi     # 0x32ef5
leaq 0x10d2f(%rip), %rcx     # 0x33544
movl $0x1b0c, %edx           # imm = 0x1B0C
callq 0x6120
leaq 0x10d42(%rip), %rdi     # 0x33568
leaq 0x106c8(%rip), %rsi     # 0x32ef5
leaq 0x10d10(%rip), %rcx     # 0x33544
movl $0x1b1d, %edx           # imm = 0x1B1D
callq 0x6120
leaq 0x10d41(%rip), %rdi     # 0x33586
leaq 0x106a9(%rip), %rsi     # 0x32ef5
leaq 0x10cf1(%rip), %rcx     # 0x33544
movl $0x1b1e, %edx           # imm = 0x1B1E
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::load_file(char const*, unsigned int, pugi::xml_encoding)
PUGI__FN xml_parse_result xml_document::load_file(const char* path_, unsigned int options, xml_encoding encoding)
	{
		reset();

		using impl::auto_deleter; // MSVC7 workaround
		auto_deleter<FILE> file(fopen(path_, "rb"), impl::close_file);

		return impl::load_file_impl(static_cast<impl::xml_document_struct*>(_root), file.data, options, encoding, &_buffer);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2275e
movq %r12, %rdi
callq 0x226cc
leaq 0x10224(%rip), %rsi     # 0x336ce
movq %r14, %rdi
callq 0x6830
movq %rax, %r14
movq (%r12), %rsi
addq $0x8, %r12
movq %rbx, %rdi
movq %rax, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
movq %r12, %r9
callq 0x23502
testq %r14, %r14
je 0x234de
movq %r14, %rdi
callq 0x62a0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x234fa
movq %r14, %rdi
callq 0x62a0
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::load_file_impl(pugi::impl::(anonymous namespace)::xml_document_struct*, _IO_FILE*, unsigned int, pugi::xml_encoding, char**)
PUGI__FN xml_parse_result load_file_impl(xml_document_struct* doc, FILE* file, unsigned int options, xml_encoding encoding, char_t** out_buffer)
	{
		if (!file) return make_parse_result(status_file_not_found);

		// get file size (can result in I/O errors)
		size_t size = 0;
		xml_parse_status size_status = get_file_size(file, size);
		if (size_status != status_ok) return make_parse_result(size_status);

		size_t max_suffix_size = sizeof(char_t);

		// allocate buffer for the whole file
		char* contents = static_cast<char*>(xml_memory::allocate(size + max_suffix_size));
		if (!contents) return make_parse_result(status_out_of_memory);

		// read file in memory
		size_t read_size = fread(contents, 1, size, file);

		if (read_size != size)
		{
			xml_memory::deallocate(contents);
			return make_parse_result(status_io_error);
		}

		xml_encoding real_encoding = get_buffer_encoding(encoding, contents, size);

		return load_buffer_impl(doc, doc, contents, zero_terminate_buffer(contents, size, real_encoding), options, real_encoding, true, true, out_buffer);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x235b7
movl %r8d, %r13d
movq %rdx, %r14
movq %rsi, %r15
movl %ecx, 0x4(%rsp)
movq %r9, 0x10(%rsp)
xorl %r12d, %r12d
movq %rdx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x6810
movq %r14, %rdi
callq 0x6170
movq %rax, %rbp
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6810
testq %rbp, %rbp
cmovgq %rbp, %r12
shrq $0x3e, %rbp
andl $0x2, %ebp
jne 0x235ce
leaq 0x1(%r12), %rdi
movq %rdi, 0x8(%rsp)
callq *0x242e1(%rip)          # 0x47858
testq %rax, %rax
je 0x235e1
movq %rax, %rbp
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x63a0
cmpq %r12, %rax
jne 0x235f8
movl %r13d, %edi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x28b51
cmpl $0x1, %eax
jne 0x23618
movb $0x0, (%rbp,%r12)
movq 0x8(%rsp), %r8
jmp 0x2361b
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movl $0x1, (%rbx)
jmp 0x23644
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movl %ebp, (%rbx)
jmp 0x23644
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movl $0x3, (%rbx)
jmp 0x23644
movq %rbp, %rdi
callq *0x2424f(%rip)          # 0x47850
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movl $0x2, (%rbx)
jmp 0x23644
movq %r12, %r8
movl $0x1, %r10d
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movl 0x4(%rsp), %r9d
pushq 0x10(%rsp)
pushq %r10
pushq %r10
pushq %rax
callq 0x1f95b
addq $0x20, %rsp
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::load_file(wchar_t const*, unsigned int, pugi::xml_encoding)
PUGI__FN xml_parse_result xml_document::load_file(const wchar_t* path_, unsigned int options, xml_encoding encoding)
	{
		reset();

		using impl::auto_deleter; // MSVC7 workaround
		auto_deleter<FILE> file(impl::open_file_wide(path_, L"rb"), impl::close_file);

		return impl::load_file_impl(static_cast<impl::xml_document_struct*>(_root), file.data, options, encoding, &_buffer);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2275e
movq %r12, %rdi
callq 0x226cc
leaq 0x13208(%rip), %rsi     # 0x3688c
movq %r14, %rdi
callq 0x236dc
movq %rax, %r14
movq (%r12), %rsi
addq $0x8, %r12
movq %rbx, %rdi
movq %rax, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
movq %r12, %r9
callq 0x23502
testq %r14, %r14
je 0x236b8
movq %r14, %rdi
callq 0x62a0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x236d4
movq %r14, %rdi
callq 0x62a0
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::open_file_wide(wchar_t const*, wchar_t const*)
PUGI__FN char* convert_path_heap(const wchar_t* str)
	{
		assert(str);

		// first pass: get length in utf8 characters
		size_t length = strlength_wide(str);
		size_t size = as_utf8_begin(str, length);

		// allocate resulting string
		char* result = static_cast<char*>(xml_memory::allocate(size + 1));
		if (!result) return 0;

		// second pass: convert to utf8
		as_utf8_end(result, size, str, length);

		// zero-terminate
		result[size] = 0;

		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x237d8
movq %rsi, %rbx
movq %rdi, %r14
movq $-0x4, %rax
cmpl $0x0, 0x4(%r14,%rax)
leaq 0x4(%rax), %rax
jne 0x236ff
movq %rax, %r15
sarq $0x2, %r15
testq %rax, %rax
je 0x23756
xorl %eax, %eax
xorl %r13d, %r13d
movl (%r14,%rax,4), %edx
movl $0x4, %ecx
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x23749
movl $0x1, %ecx
cmpl $0x80, %edx
jb 0x23749
cmpl $0x800, %edx            # imm = 0x800
movl $0x3, %ecx
sbbq $0x0, %rcx
addq %rcx, %r13
incq %rax
cmpq %rax, %r15
jne 0x2371c
jmp 0x23759
xorl %r13d, %r13d
leaq 0x1(%r13), %rdi
callq *0x240f5(%rip)          # 0x47858
testq %rax, %rax
je 0x23783
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2aa1f
movb $0x0, (%r12,%r13)
jmp 0x23786
xorl %r12d, %r12d
testq %r12, %r12
je 0x237c5
movl $0x0, 0xc(%rsp)
movl (%rbx), %eax
testl %eax, %eax
je 0x237aa
xorl %ecx, %ecx
movb %al, 0xc(%rsp,%rcx)
movl 0x4(%rbx,%rcx,4), %eax
incq %rcx
testl %eax, %eax
jne 0x2379b
leaq 0xc(%rsp), %rsi
movq %r12, %rdi
callq 0x6830
movq %rax, %rbx
movq %r12, %rdi
callq *0x2408d(%rip)          # 0x47850
jmp 0x237c7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xff56(%rip), %rdi      # 0x33735
leaq 0xf70f(%rip), %rsi      # 0x32ef5
leaq 0x1115f(%rip), %rcx     # 0x3494c
movl $0x1367, %edx           # imm = 0x1367
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_buffered_writer::write(char, char, char)
void write(char_t d0, char_t d1, char_t d2)
		{
			size_t offset = bufsize;
			if (offset > bufcapacity - 3) offset = flush();

			buffer[offset + 0] = d0;
			buffer[offset + 1] = d1;
			buffer[offset + 2] = d2;
			bufsize = offset + 3;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movq 0x2808(%rdi), %rdx
cmpq $0x7fe, %rdx            # imm = 0x7FE
jb 0x23aac
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x2a3c8
movq $0x0, 0x2808(%rbx)
xorl %edx, %edx
movb %r15b, (%rbx,%rdx)
movb %r14b, 0x1(%rbx,%rdx)
movb %bpl, 0x2(%rbx,%rdx)
addq $0x3, %rdx
movq %rdx, 0x2808(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq