LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/clap/include/cmdarg.hh
// Function: CmdArgTypeList<int>::validate()
bool         validate     (){
    if (_list.size() < _min) {
      cout << "too few argument to the switch -" << getKeyword() << endl;
      return false;
    }
    if (_list.size() > _max) {
      cout << "too many argument to the switch -" << getKeyword() << endl;
      return false;
    }
    reset();
    setParseOK();
    return true;    
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x40(%rdi), %rax
movslq 0x64(%rdi), %rcx
cmpq %rcx, %rax
jae 0x1ba37
movq 0x2a557(%rip), %rbx     # 0x45f80
leaq 0x15b49(%rip), %rsi     # 0x31579
movl $0x20, %edx
jmp 0x1ba57
movslq 0x60(%r14), %rcx
cmpq %rcx, %rax
jbe 0x1bac6
movq 0x2a535(%rip), %rbx     # 0x45f80
leaq 0x15b48(%rip), %rsi     # 0x3159a
movl $0x21, %edx
movq %rbx, %rdi
callq 0x6690
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1ba84
movq %r14, %rdi
callq 0x6270
movq 0x2a509(%rip), %rdi     # 0x45f80
movq %r14, %rsi
movq %rax, %rdx
callq 0x6690
jmp 0x1ba9b
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x67b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6730
movsbl %al, %esi
movq %rbx, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6340
xorl %eax, %eax
jmp 0x1bad6
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
orb $0x4, 0x2c(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/clap/src/cmdline.cc
// Function: CmdLine::CmdLine(char*, CmdArg*, ...)
CmdLine::CmdLine(char *progName, CmdArg *cmds ...) :
  _progName(progName), _maxLength(0)
{
  va_list args;
  va_start(args, cmds);
  for (CmdArg* arg = cmds; arg; arg = va_arg(args, CmdArg*))
    {
      _cmdList.push_front(arg);
      _maxLength = std::max((long)_maxLength, (long)strlen(arg->getValueName()));
    }
  va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x1c37f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
movq %rdx, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rsp)
testq %r14, %r14
je 0x1c42f
movq %rdi, %rbx
movq (%rbx), %r15
movl $0x18, %edi
callq 0x60f0
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x6150
incq 0x10(%rbx)
movslq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x1ace0
movq %rax, %rdi
callq 0x6270
cmpq %r15, %rax
cmovgq %rax, %r15
movl %r15d, 0x20(%rbx)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x1c419
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x1c427
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
jne 0x1c3c1
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1c43e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x1c459
movq (%rdi), %r15
callq 0x63b0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x1c449
movq %r14, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_writer_stream::write(void const*, unsigned long)
PUGI__FN void xml_writer_stream::write(const void* data, size_t size)
	{
		if (narrow_stream)
		{
			assert(!wide_stream);
			narrow_stream->write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
		}
		else
		{
			assert(wide_stream);
			assert(size % sizeof(wchar_t) == 0);

			wide_stream->write(reinterpret_cast<const wchar_t*>(data), static_cast<std::streamsize>(size / sizeof(wchar_t)));
		}
	}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
testq %rax, %rax
je 0x1cbc8
testq %rdi, %rdi
jne 0x1cbdc
movq %rax, %rdi
popq %rax
jmp 0x6330
testq %rdi, %rdi
je 0x1cbfb
testb $0x3, %dl
jne 0x1cc1a
shrq $0x2, %rdx
popq %rax
jmp 0x6160
leaq 0x15335(%rip), %rdi     # 0x31f18
leaq 0x1533b(%rip), %rsi     # 0x31f25
leaq 0x15348(%rip), %rcx     # 0x31f39
movl $0x13c2, %edx           # imm = 0x13C2
callq 0x6120
leaq 0x15317(%rip), %rdi     # 0x31f19
leaq 0x1531c(%rip), %rsi     # 0x31f25
leaq 0x15329(%rip), %rcx     # 0x31f39
movl $0x13c7, %edx           # imm = 0x13C7
callq 0x6120
leaq 0x1535a(%rip), %rdi     # 0x31f7b
leaq 0x152fd(%rip), %rsi     # 0x31f25
leaq 0x1530a(%rip), %rcx     # 0x31f39
movl $0x13c8, %edx           # imm = 0x13C8
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: bool pugi::impl::(anonymous namespace)::set_value_integer<unsigned int, char*, unsigned long>(char*&, unsigned long&, unsigned long, unsigned int, bool)
PUGI__FN bool set_value_integer(String& dest, Header& header, uintptr_t header_mask, U value, bool negative)
	{
		char_t buf[64];
		char_t* end = buf + sizeof(buf) / sizeof(buf[0]);
		char_t* begin = integer_to_string(buf, end, value, negative);

		return strcpy_insitu(dest, header, header_mask, begin, end - begin);
	}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x3f(%rsp), %rax
movl %edx, %r9d
negl %r9d
testl %ecx, %ecx
cmovel %edx, %r9d
leal 0x1(%rcx), %edx
movzbl %dl, %r8d
andl $0x1, %r8d
decq %r8
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %r9d, %r10d
imulq %rdx, %r10
shrq $0x23, %r10
leal (%r10,%r10), %r11d
leal (%r11,%r11,4), %r11d
movl %r9d, %ebx
subl %r11d, %ebx
orb $0x30, %bl
movb %bl, (%rax)
decq %rax
decq %r8
cmpl $0x9, %r9d
movl %r10d, %r9d
ja 0x1d3cb
movq %rsp, %rdx
cmpq %rdx, %rax
jb 0x1d41f
movb $0x2d, (%rax)
xorb $0x1, %cl
movzbl %cl, %ecx
addq %rax, %rcx
negq %r8
movl $0x10, %edx
callq 0x1d136
addq $0x40, %rsp
popq %rbx
retq
leaq 0x17e73(%rip), %rdi     # 0x35299
leaq 0x14af8(%rip), %rsi     # 0x31f25
leaq 0x17e75(%rip), %rcx     # 0x352a9
movl $0x120b, %edx           # imm = 0x120B
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::child(char const*) const
PUGI__FN xml_node xml_node::child(const char_t* name_) 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)) return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1d71e
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x1d71e
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d715
movq %r14, %rdi
callq 0x1d7f1
testb %al, %al
jne 0x1d720
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d700
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::attribute(char const*) const
PUGI__FN xml_attribute xml_node::attribute(const char_t* name_) const
	{
		if (!_root) return xml_attribute();

		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
			if (i->name && impl::strequal(name_, i->name))
				return xml_attribute(i);

		return xml_attribute();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1d85e
movq 0x38(%rax), %rbx
testq %rbx, %rbx
je 0x1d85e
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d855
movq %r14, %rdi
callq 0x1d7f1
testb %al, %al
jne 0x1d860
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d840
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::next_sibling(char const*) const
PUGI__FN xml_node xml_node::next_sibling(const char_t* name_) const
	{
		if (!_root) return xml_node();

		for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1d8a2
movq 0x30(%rax), %rbx
testq %rbx, %rbx
je 0x1d8a2
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d899
movq %r14, %rdi
callq 0x1d7f1
testb %al, %al
jne 0x1d8a4
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d884
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::previous_sibling(char const*) const
PUGI__FN xml_node xml_node::previous_sibling(const char_t* name_) const
	{
		if (!_root) return xml_node();

		for (xml_node_struct* i = _root->prev_sibling_c; i->next_sibling; i = i->prev_sibling_c)
			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1d8fa
movq 0x28(%rax), %rbx
cmpq $0x0, 0x30(%rbx)
je 0x1d8fa
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d8ef
movq %r14, %rdi
callq 0x1d7f1
testb %al, %al
jne 0x1d8fc
movq 0x28(%rbx), %rbx
cmpq $0x0, 0x30(%rbx)
jne 0x1d8da
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::attribute(char const*, pugi::xml_attribute&) const
PUGI__FN xml_attribute xml_node::attribute(const char_t* name_, xml_attribute& hint_) const
	{
		xml_attribute_struct* hint = hint_._attr;

		// if hint is not an attribute of node, behavior is not defined
		assert(!hint || (_root && impl::is_attribute_of(hint, _root)));

		if (!_root) return xml_attribute();

		// optimistically search from hint up until the end
		for (xml_attribute_struct* i = hint; i; i = i->next_attribute)
			if (i->name && impl::strequal(name_, i->name))
			{
				// update hint to maximize efficiency of searching for consecutive attributes
				hint_._attr = i->next_attribute;

				return xml_attribute(i);
			}

		// wrap around and search from the first attribute until the hint
		// 'j' null pointer check is technically redundant, but it prevents a crash in case the assertion above fails
		for (xml_attribute_struct* j = _root->first_attribute; j && j != hint; j = j->next_attribute)
			if (j->name && impl::strequal(name_, j->name))
			{
				// update hint to maximize efficiency of searching for consecutive attributes
				hint_._attr = j->next_attribute;

				return xml_attribute(j);
			}

		return xml_attribute();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %r12
movq (%rdi), %rax
testq %r12, %r12
je 0x1d977
testq %rax, %rax
je 0x1d9d4
movq %rdi, %r15
leaq 0x38(%rax), %rdx
movq (%rdx), %rcx
cmpq %r12, %rcx
je 0x1d943
leaq 0x20(%rcx), %rdx
testq %rcx, %rcx
jne 0x1d932
testq %rcx, %rcx
je 0x1d9d4
testq %r12, %r12
je 0x1d97c
movq %r12, %r13
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x1d969
movq %r14, %rdi
callq 0x1d7f1
testb %al, %al
jne 0x1d9bd
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0x1d954
movq (%r15), %rax
jmp 0x1d97c
testq %rax, %rax
je 0x1d990
movq 0x38(%rax), %r13
testq %r13, %r13
sete %al
cmpq %r12, %r13
sete %cl
orb %al, %cl
je 0x1d995
xorl %r15d, %r15d
jmp 0x1d9c7
xorl %r15d, %r15d
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x1d9ad
movq %r14, %rdi
callq 0x1d7f1
testb %al, %al
jne 0x1d9bd
movq 0x20(%r13), %r13
testq %r13, %r13
je 0x1d9c7
cmpq %r12, %r13
jne 0x1d998
jmp 0x1d9c7
movq 0x20(%r13), %rax
movq %rax, (%rbx)
movq %r13, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x145bc(%rip), %rdi     # 0x31f97
leaq 0x14543(%rip), %rsi     # 0x31f25
leaq 0x145e5(%rip), %rcx     # 0x31fce
movl $0x159e, %edx           # imm = 0x159E
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::child_value() const
PUGI__FN const char_t* xml_node::child_value() const
	{
		if (!_root) return PUGIXML_TEXT("");

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

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

		return PUGIXML_TEXT("");
	}

// Assembly:
movq (%rdi), %rdx
leaq 0x126bd(%rip), %rcx     # 0x30109
testq %rdx, %rdx
je 0x1da8a
movl (%rdx), %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x1da65
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x1da65
retq
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0x1da8a
movl (%rdx), %eax
andl $0xf, %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x1da84
movq 0x10(%rdx), %rax
testq %rax, %rax
jne 0x1da64
movq 0x30(%rdx), %rdx
jmp 0x1da69
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::set_value(char const*)
PUGI__FN bool xml_node::set_value(const char_t* rhs)
	{
		xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;

		if (type_ != node_pcdata && type_ != node_cdata && type_ != node_comment && type_ != node_pi && type_ != node_doctype)
			return false;

		return impl::strcpy_insitu(_root->value, _root->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs));
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x1db9e
movq %rsi, %rbx
movl (%r14), %eax
andl $0xf, %eax
leal -0x3(%rax), %ecx
cmpl $0x4, %ecx
jb 0x1db77
cmpl $0x8, %eax
jne 0x1db9e
leaq 0x10(%r14), %r15
movq %rbx, %rdi
callq 0x1d379
movl $0x10, %edx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %rax, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x1d136
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rax, %rax
je 0x1ea2d
movl (%rax), %r12d
andl $0xf, %r12d
jmp 0x1ea30
xorl %r12d, %r12d
movq (%r14), %rax
testq %rax, %rax
je 0x1eb27
xorl %r15d, %r15d
cmpl $0x2, %r12d
jb 0x1eb2a
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1eb2a
cmpl $0x1, %edx
setne %dl
leal -0x9(%r12), %esi
cmpl $-0x2, %esi
setae %sil
testb %dl, %sil
jne 0x1eb27
shrq $0x8, %rcx
subq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rdi), %rcx
leaq 0x40(%rcx), %rdx
cmpq $0x7fd8, %rdx           # imm = 0x7FD8
ja 0x1eb09
movq (%rdi), %rax
leaq (%rax,%rcx), %r15
addq $0x28, %r15
movq %rdx, 0x8(%rdi)
movq %r15, %rcx
subq %rax, %rcx
shlq $0x8, %rcx
movl %r12d, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq $0x0, 0x38(%r15)
movq %rax, (%r15)
movq (%r14), %rcx
movq %rcx, 0x18(%r15)
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0x1eaf1
movq 0x28(%rax), %rcx
addq $0x28, %rax
movq %r15, 0x30(%rcx)
movq %rcx, 0x28(%r15)
jmp 0x1eaf9
movq %r15, 0x20(%rcx)
leaq 0x28(%r15), %rax
movq %r15, (%rax)
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x1eb39
jmp 0x1eb2a
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28796
testq %rax, %rax
je 0x1eb27
movq %rax, %r15
movq (%rsp), %rax
jmp 0x1eaa2
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rax, %rax
je 0x1ec57
movl (%rax), %r12d
andl $0xf, %r12d
jmp 0x1ec5a
xorl %r12d, %r12d
movq (%r14), %rax
testq %rax, %rax
je 0x1ed51
xorl %r15d, %r15d
cmpl $0x2, %r12d
jb 0x1ed54
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1ed54
cmpl $0x1, %edx
setne %dl
leal -0x9(%r12), %esi
cmpl $-0x2, %esi
setae %sil
testb %dl, %sil
jne 0x1ed51
shrq $0x8, %rcx
subq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rdi), %rcx
leaq 0x40(%rcx), %rdx
cmpq $0x7fd8, %rdx           # imm = 0x7FD8
ja 0x1ed33
movq (%rdi), %rax
leaq (%rax,%rcx), %r15
addq $0x28, %r15
movq %rdx, 0x8(%rdi)
movq %r15, %rcx
subq %rax, %rcx
shlq $0x8, %rcx
movl %r12d, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq $0x0, 0x38(%r15)
movq %rax, (%r15)
movq (%r14), %rax
movq %rax, 0x18(%r15)
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x1ed17
leaq 0x28(%rcx), %rdx
movq 0x28(%rcx), %rsi
movq %rsi, 0x28(%r15)
jmp 0x1ed1b
leaq 0x28(%r15), %rdx
movq %r15, (%rdx)
movq %rcx, 0x30(%r15)
movq %r15, 0x20(%rax)
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x1eb39
jmp 0x1ed54
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28796
testq %rax, %rax
je 0x1ed51
movq %rax, %r15
movq (%rsp), %rax
jmp 0x1eccc
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rax, %rax
je 0x1ed83
movl (%rax), %r12d
andl $0xf, %r12d
jmp 0x1ed86
xorl %r12d, %r12d
movq (%rdi), %rax
testq %rax, %rax
je 0x1edcc
xorl %r15d, %r15d
cmpl $0x2, %r12d
jb 0x1edcf
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1edcf
cmpl $0x1, %edx
setne %dl
leal -0x9(%r12), %esi
cmpl $-0x2, %esi
setae %sil
testb %dl, %sil
jne 0x1edcc
movq (%r14), %rdx
testq %rdx, %rdx
je 0x1edcc
cmpq %rax, 0x18(%rdx)
je 0x1edde
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
shrq $0x8, %rcx
subq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rdi), %rcx
leaq 0x40(%rcx), %rdx
cmpq $0x7fd8, %rdx           # imm = 0x7FD8
ja 0x1ee70
movq (%rdi), %rax
leaq (%rax,%rcx), %r15
addq $0x28, %r15
movq %rdx, 0x8(%rdi)
movq %r15, %rcx
subq %rax, %rcx
shlq $0x8, %rcx
movl %r12d, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq $0x0, 0x38(%r15)
movq %rax, (%r15)
movq (%r14), %rax
movq 0x18(%rax), %rdx
movq %rdx, 0x18(%r15)
movq 0x30(%rax), %rcx
movq %rcx, %rsi
testq %rcx, %rcx
jne 0x1ee50
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 0x1eb39
jmp 0x1edcf
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28796
testq %rax, %rax
je 0x1edcc
movq %rax, %r15
movq (%rsp), %rax
jmp 0x1ee08
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rax, %rax
je 0x1eeb1
movl (%rax), %r12d
andl $0xf, %r12d
jmp 0x1eeb4
xorl %r12d, %r12d
movq (%rdi), %rax
testq %rax, %rax
je 0x1eefa
xorl %r15d, %r15d
cmpl $0x2, %r12d
jb 0x1eefd
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1eefd
cmpl $0x1, %edx
setne %dl
leal -0x9(%r12), %esi
cmpl $-0x2, %esi
setae %sil
testb %dl, %sil
jne 0x1eefa
movq (%r14), %rdx
testq %rdx, %rdx
je 0x1eefa
cmpq %rax, 0x18(%rdx)
je 0x1ef0c
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
shrq $0x8, %rcx
subq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rdi), %rcx
leaq 0x40(%rcx), %rdx
cmpq $0x7fd8, %rdx           # imm = 0x7FD8
ja 0x1efa2
movq (%rdi), %rax
leaq (%rax,%rcx), %r15
addq $0x28, %r15
movq %rdx, 0x8(%rdi)
movq %r15, %rcx
subq %rax, %rcx
shlq $0x8, %rcx
movl %r12d, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq $0x0, 0x38(%r15)
movq %rax, (%r15)
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 0x1eb39
jmp 0x1eefd
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28796
testq %rax, %rax
je 0x1eefa
movq %rax, %r15
movq (%rsp), %rax
jmp 0x1ef36
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f0ac
testb %al, %al
je 0x1f06f
testq %r12, %r12
je 0x1f08d
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rcx
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
leaq 0x28(%r15), %rax
movq %rdx, %rdi
testq %rdx, %rdx
jne 0x1f024
movq 0x20(%rcx), %rdi
movq %rsi, 0x28(%rdi)
addq $0x20, %rcx
cmpq $0x0, 0x30(%rsi)
leaq 0x30(%rsi), %rsi
cmovneq %rsi, %rcx
movq %rdx, (%rcx)
movq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%rbx), %rax
movq (%r14), %rdx
movq %rdx, 0x18(%rax)
movq 0x20(%rdx), %rcx
testq %rcx, %rcx
je 0x1f073
movq 0x28(%rcx), %rdx
addq $0x28, %rcx
movq %rax, 0x30(%rdx)
movq %rdx, 0x28(%rax)
jmp 0x1f07b
xorl %eax, %eax
jmp 0x1f081
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 0x13992(%rip), %rdi     # 0x32a26
leaq 0x12e8a(%rip), %rsi     # 0x31f25
leaq 0x16067(%rip), %rcx     # 0x35109
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f0ac
testb %al, %al
je 0x1f1d5
testq %r12, %r12
je 0x1f1f7
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rcx
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
leaq 0x28(%r15), %rax
movq %rdx, %rdi
testq %rdx, %rdx
jne 0x1f18e
movq 0x20(%rcx), %rdi
movq %rsi, 0x28(%rdi)
addq $0x20, %rcx
cmpq $0x0, 0x30(%rsi)
leaq 0x30(%rsi), %rsi
cmovneq %rsi, %rcx
movq %rdx, (%rcx)
movq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%rbx), %rax
movq (%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
je 0x1f1d9
leaq 0x28(%rdx), %rsi
movq 0x28(%rdx), %rdi
movq %rdi, 0x28(%rax)
jmp 0x1f1dd
xorl %eax, %eax
jmp 0x1f1eb
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 0x13828(%rip), %rdi     # 0x32a26
leaq 0x12d20(%rip), %rsi     # 0x31f25
leaq 0x15efd(%rip), %rcx     # 0x35109
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f0ac
testb %al, %al
je 0x1f252
movq (%r14), %rax
testq %rax, %rax
je 0x1f252
cmpq %r12, 0x18(%rax)
setne %cl
cmpq %rax, %r15
sete %al
orb %cl, %al
je 0x1f260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %r12, %r12
je 0x1f2f5
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rcx
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
leaq 0x28(%r15), %rax
movq %rdx, %rdi
testq %rdx, %rdx
jne 0x1f299
movq 0x20(%rcx), %rdi
movq %rsi, 0x28(%rdi)
leaq 0x30(%rsi), %rdi
addq $0x20, %rcx
cmpq $0x0, 0x30(%rsi)
cmovneq %rdi, %rcx
movq %rdx, (%rcx)
movq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
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 0x1f2dd
movq 0x20(%rsi), %rdi
movq %rax, 0x28(%rdi)
movq %rdx, 0x30(%rax)
movq %rcx, 0x28(%rax)
movq %rax, 0x30(%rcx)
movq (%rbx), %rax
jmp 0x1f254
leaq 0x1372a(%rip), %rdi     # 0x32a26
leaq 0x12c22(%rip), %rsi     # 0x31f25
leaq 0x15dff(%rip), %rcx     # 0x35109
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f0ac
testb %al, %al
je 0x1f350
movq (%r14), %rax
testq %rax, %rax
je 0x1f350
cmpq %r12, 0x18(%rax)
setne %cl
cmpq %rax, %r15
sete %al
orb %cl, %al
je 0x1f35e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %r12, %r12
je 0x1f3f7
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rcx
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
leaq 0x28(%r15), %rax
movq %rdx, %rdi
testq %rdx, %rdx
jne 0x1f397
movq 0x20(%rcx), %rdi
movq %rsi, 0x28(%rdi)
leaq 0x30(%rsi), %rdi
addq $0x20, %rcx
cmpq $0x0, 0x30(%rsi)
cmovneq %rdi, %rcx
movq %rdx, (%rcx)
movq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
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 0x1f352
leaq 0x13628(%rip), %rdi     # 0x32a26
leaq 0x12b20(%rip), %rsi     # 0x31f25
leaq 0x15cfd(%rip), %rcx     # 0x35109
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f500
movq (%rsi), %rax
testq %rax, %rax
je 0x1f500
pushq %r14
pushq %rbx
pushq %rax
leaq 0x38(%rcx), %rdx
movq %rdx, %r8
movq (%r8), %rdi
cmpq %rax, %rdi
je 0x1f46e
leaq 0x20(%rdi), %r8
testq %rdi, %rdi
jne 0x1f45d
testq %rdi, %rdi
je 0x1f503
movq (%rcx), %r8
shrq $0x8, %r8
negq %r8
movq 0x18(%rax), %r9
movq 0x20(%rax), %rdi
addq $0x18, %rax
movq %rdi, %r10
testq %rdi, %rdi
jne 0x1f498
movq (%rdx), %r10
movq (%rcx,%r8), %rbx
movq %r9, 0x18(%r10)
leaq 0x20(%r9), %rcx
cmpq $0x0, 0x20(%r9)
cmoveq %rdx, %rcx
movq %rdi, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%rsi), %r14
movq (%r14), %rax
testb $0x20, %al
je 0x1f4cf
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x2864c
movq (%r14), %rax
testb $0x10, %al
je 0x1f4e2
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x2864c
movq (%r14), %rax
shrq $0x8, %rax
movq %r14, %rcx
subq %rax, %rcx
movl $0x28, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28678
movb $0x1, %al
jmp 0x1f505
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f54b
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x1f54b
movq 0x18(%rcx), %rdx
cmpq %rax, %rdx
je 0x1f54e
xorl %eax, %eax
retq
movq (%rax), %rdi
shrq $0x8, %rdi
negq %rdi
movq (%rax,%rdi), %rax
movq 0x28(%rcx), %r9
movq 0x30(%rcx), %r8
leaq 0x28(%rcx), %rdi
movq %r8, %r10
testq %r8, %r8
jne 0x1f574
movq 0x20(%rdx), %r10
pushq %rax
movq %r9, 0x28(%r10)
addq $0x20, %rdx
cmpq $0x0, 0x30(%r9)
leaq 0x30(%r9), %r9
cmovneq %r9, %rdx
movq %r8, (%rdx)
movq $0x0, 0x18(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x1f5ad
movb $0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rdi), %rax
testb $0x20, %al
je 0x1f5d1
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x2864c
movq (%rbx), %rax
testb $0x10, %al
je 0x1f5e1
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x2864c
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x1f639
movq (%r15), %rax
movq 0x20(%r15), %r12
testb $0x20, %al
je 0x1f604
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x2864c
movq (%r15), %rax
testb $0x10, %al
je 0x1f617
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x2864c
movq (%r15), %rax
shrq $0x8, %rax
movq %r15, %rcx
subq %rax, %rcx
movl $0x28, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x28678
movq %r12, %r15
testq %r12, %r12
jne 0x1f5ea
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1f656
movq 0x30(%rdi), %r15
movq %r14, %rsi
callq 0x1f5ad
movq %r15, %rdi
testq %r15, %r15
jne 0x1f642
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 0x28678
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21091
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x21091
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xf0d1(%rip), %r13      # 0x30109
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x21088
movq %r12, %rdi
callq 0x1d7f1
testb %al, %al
je 0x21088
movq 0x38(%rbx), %rbp
testq %rbp, %rbp
je 0x21088
movq 0x8(%rbp), %rsi
testq %rsi, %rsi
je 0x21082
movq %r15, %rdi
callq 0x1d7f1
testb %al, %al
je 0x21082
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
cmoveq %r13, %rsi
movq %r14, %rdi
callq 0x1d7f1
testb %al, %al
jne 0x21093
movq 0x20(%rbp), %rbp
jmp 0x21051
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x21038
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::find_child_by_attribute(char const*, char const*) const
PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const
	{
		if (!_root) return xml_node();

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

		return xml_node();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x21111
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x21111
movq %rdx, %r14
movq %rsi, %r15
leaq 0xf03c(%rip), %r12      # 0x30109
movq 0x38(%rbx), %r13
testq %r13, %r13
je 0x21108
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x21102
movq %r15, %rdi
callq 0x1d7f1
testb %al, %al
je 0x21102
movq 0x10(%r13), %rsi
testq %rsi, %rsi
cmoveq %r12, %rsi
movq %r14, %rdi
callq 0x1d7f1
testb %al, %al
jne 0x21113
movq 0x20(%r13), %r13
jmp 0x210d1
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x210cd
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2120c
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 0x21165
callq 0x6270
jmp 0x21167
xorl %eax, %eax
movb %r14b, %bpl
addq %rbp, %r15
addq %rax, %r15
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x2114c
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 0x211e8
movl 0xc(%rsp), %ebp
cmpq (%r14), %r13
je 0x211ba
movq (%rbx), %rax
movb %bpl, -0x1(%rax,%r15)
decq %r15
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x211df
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 0x211aa
testq %r15, %r15
je 0x2121f
leaq 0x10e2d(%rip), %rdi     # 0x32021
leaq 0x10d2a(%rip), %rsi     # 0x31f25
leaq 0x10e2b(%rip), %rcx     # 0x3202d
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 0x21241
callq 0x63b0
movq %r14, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::first_element_by_path(char const*, char) const
PUGI__FN xml_node xml_node::first_element_by_path(const char_t* path_, char_t delimiter) const
	{
		xml_node found = *this; // Current search context.

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

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

		const char_t* path_segment = path_;

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

		const char_t* path_segment_end = path_segment;

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

		if (path_segment == path_segment_end) return found;

		const char_t* next_segment = path_segment_end;

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

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

					if (subsearch) return subsearch;
				}
			}

			return xml_node();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x21371
movq %rsi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x21371
cmpb %dl, %cl
jne 0x21294
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rax
addq $-0x40, %rax
movq %rax, 0x10(%rsp)
incq %rbx
addq $-0x3, %rbx
movb 0x3(%rbx), %cl
incq %rbx
cmpb %dl, %cl
je 0x21298
xorl %r12d, %r12d
movb 0x2(%rbx,%r12), %sil
incq %r12
testb %sil, %sil
je 0x212b7
cmpb %dl, %sil
jne 0x212a5
cmpq $0x1, %r12
je 0x21371
leaq (%rbx,%r12), %r14
leaq -0x1(%r12), %r13
movq %r14, %rsi
incq %r14
cmpb %dl, 0x1(%rsi)
je 0x212ca
cmpb $0x2e, %cl
setne %sil
cmpq $0x2, %r12
setne %dil
orb %sil, %dil
jne 0x212fb
movsbl %dl, %edx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2124a
jmp 0x21371
cmpb $0x2e, %cl
jne 0x2131d
cmpq $0x3, %r12
jne 0x2131d
cmpb $0x2e, 0x3(%rbx)
jne 0x2131d
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movsbl %dl, %edx
jmp 0x212f1
movq 0x20(%rax), %r15
testq %r15, %r15
je 0x2136f
movsbl %dl, %ebp
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x21366
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
cmpb 0x2(%rbx,%rcx), %dl
jne 0x21366
incq %rcx
cmpq %rcx, %r13
jne 0x21334
cmpb $0x0, -0x1(%rax,%r12)
jne 0x21366
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2124a
testq %rax, %rax
jne 0x21371
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0x21329
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21453
movq (%r14), %rax
testq %rax, %rax
je 0x21457
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x21459
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 0x21453
movq 0x20(%r12), %rcx
testq %rcx, %rcx
je 0x213f9
incl 0x8(%rbx)
jmp 0x21403
movq 0x30(%r12), %rcx
testq %rcx, %rcx
je 0x21415
movq (%r14), %rax
movq %rcx, %r12
testq %r12, %r12
je 0x21459
cmpq %rax, %r12
jne 0x213d5
jmp 0x21459
movq (%r14), %rax
cmpq %rax, %r12
je 0x21409
movq 0x18(%r12), %rcx
testq %rcx, %rcx
je 0x21446
decl 0x8(%rbx)
movq 0x30(%rcx), %r12
movq (%r14), %rax
cmpq %rax, %rcx
sete %dl
testq %r12, %r12
jne 0x2144b
testb %dl, %dl
jne 0x2144b
movq 0x18(%rcx), %rcx
jmp 0x21422
xorl %r12d, %r12d
jmp 0x21409
testb %dl, %dl
cmovneq %rcx, %r12
jmp 0x21409
xorl %eax, %eax
jmp 0x21470
xorl %eax, %eax
cmpl $-0x1, 0x8(%rbx)
jne 0x2147c
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 0x10bd6(%rip), %rdi     # 0x32059
leaq 0x10a9b(%rip), %rsi     # 0x31f25
leaq 0x10bdc(%rip), %rcx     # 0x3206d
movl $0x186c, %edx           # imm = 0x186C
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2151f
pushq %rbx
subq $0x2820, %rsp           # imm = 0x2820
movq %rax, 0x2808(%rsp)
movq $0x0, 0x2810(%rsp)
cmpl $0x8, %r8d
ja 0x214ee
movl $0x191, %eax            # imm = 0x191
btl %r8d, %eax
jae 0x214ee
movl %r8d, %eax
leaq 0x10a0a(%rip), %rdi     # 0x31ef4
movl (%rdi,%rax,4), %r8d
leaq 0x8(%rsp), %rbx
movl %r8d, 0x2810(%rbx)
movq %rbx, %rdi
movl %r9d, %r8d
callq 0x21520
movq 0x2808(%rbx), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x29c16
addq $0x2820, %rsp           # imm = 0x2820
popq %rbx
retq