LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_buffered_writer::write_string(char const*)
void write_string(const char_t* data)
		{
			// write the part of the string that fits in the buffer
			size_t offset = bufsize;

			while (*data && offset < bufcapacity)
				buffer[offset++] = *data++;

			// write the rest
			if (offset < bufcapacity)
			{
				bufsize = offset;
			}
			else
			{
				// backtrack a bit if we have split the codepoint
				size_t length = offset - bufsize;
				size_t extra = length - get_valid_length(data - length, length);

				bufsize = offset - extra;

				write_direct(data - extra, strlength(data) + extra);
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2808(%rdi), %rcx
movb (%rsi), %dl
testb %dl, %dl
setne %al
cmpq $0x800, %rcx            # imm = 0x800
setb %dil
andb %dil, %al
cmpb $0x1, %al
jne 0x23b22
leaq 0x1(%rcx), %rax
movb %dl, (%rbx,%rcx)
movb 0x1(%rsi), %dl
incq %rsi
cmpq $0x7ff, %rcx            # imm = 0x7FF
setb %dil
testb %dl, %dl
je 0x23b25
cmpq $0x7ff, %rcx            # imm = 0x7FF
movq %rax, %rcx
jb 0x23af8
jmp 0x23b25
movq %rcx, %rax
testb %dil, %dil
je 0x23b37
movq %rax, 0x2808(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
subq 0x2808(%rbx), %r14
cmpq $0x5, %r14
jae 0x23b4b
xorl %ecx, %ecx
jmp 0x23b7a
movq $-0x1, %rdx
movq %rcx, %rdi
leaq (%r14,%rdx), %rcx
movb (%rsi,%rdx), %r8b
andb $-0x40, %r8b
cmpb $-0x80, %r8b
cmoveq %rdi, %rcx
negb %r8b
jno 0x23b7a
decq %rdx
cmpq $-0x5, %rdx
jne 0x23b52
movq %r14, %rcx
subq %rcx, %r14
subq %r14, %rax
movq %rax, 0x2808(%rbx)
movq %rsi, %r15
subq %r14, %r15
movq %rsi, %rdi
callq 0x6270
addq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2a2c8
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::save_file_impl(pugi::xml_document const&, _IO_FILE*, char const*, unsigned int, pugi::xml_encoding)
PUGI__FN bool save_file_impl(const xml_document& doc, FILE* file, const char_t* indent, unsigned int flags, xml_encoding encoding)
	{
		if (!file) return false;

		xml_writer_file writer(file);
		doc.save(writer, indent, flags, encoding);

		return ferror(file) == 0;
	}

// Assembly:
testq %rsi, %rsi
je 0x23cba
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x22ed0(%rip), %rax     # 0x46b68
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, 0x8(%rsi)
callq 0x238c8
movq %rbx, %rdi
callq 0x6520
testl %eax, %eax
sete %al
addq $0x10, %rsp
popq %rbx
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::document_element() const
PUGI__FN xml_node xml_document::document_element() const
	{
		assert(_root);

		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
			if (PUGI__NODETYPE(i) == node_element)
				return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x23d60
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x23d5e
movl (%rax), %ecx
andl $0xf, %ecx
cmpl $0x2, %ecx
je 0x23d5e
movq 0x30(%rax), %rax
jmp 0x23d49
popq %rcx
retq
leaq 0xf7b4(%rip), %rdi      # 0x3351b
leaq 0xf187(%rip), %rsi      # 0x32ef5
leaq 0xf98a(%rip), %rcx      # 0x336ff
movl $0x1c24, %edx           # imm = 0x1C24
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::as_utf8_impl[abi:cxx11](wchar_t const*, unsigned long)
PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
	{
		// first pass: get length in utf8 characters
		size_t size = as_utf8_begin(str, length);

		// allocate resulting string
		std::string result;
		result.resize(size);

		// second pass: convert to utf8
		if (size > 0) as_utf8_end(&result[0], size, str, length);

		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x23e20
xorl %eax, %eax
xorl %r12d, %r12d
movl (%r15,%rax,4), %edx
movl $0x4, %ecx
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x23e13
movl $0x1, %ecx
cmpl $0x80, %edx
jb 0x23e13
cmpl $0x800, %edx            # imm = 0x800
movl $0x3, %ecx
sbbq $0x0, %rcx
addq %rcx, %r12
incq %rax
cmpq %rax, %r14
jne 0x23de6
jmp 0x23e23
xorl %r12d, %r12d
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x6480
testq %r12, %r12
je 0x23e59
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2aa1f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x23e76
callq 0x63b0
movq %r14, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::as_wide_impl[abi:cxx11](char const*, unsigned long)
PUGI__FN std::basic_string<wchar_t> as_wide_impl(const char* str, size_t size)
	{
		const uint8_t* data = reinterpret_cast<const uint8_t*>(str);

		// first pass: get length in wchar_t units
		size_t length = utf8_decoder::process(data, size, 0, wchar_counter());

		// allocate resulting string
		std::basic_string<wchar_t> result;
		result.resize(length);

		// second pass: convert to wchar_t
		if (length > 0)
		{
			wchar_writer::value_type begin = reinterpret_cast<wchar_writer::value_type>(&result[0]);
			wchar_writer::value_type end = utf8_decoder::process(data, size, begin, wchar_writer());

			assert(begin + length == end);
			(void)!end;
		}

		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x24003
movq %r15, %rax
movq %r14, %rcx
movzbl (%rax), %edx
testb %dl, %dl
js 0x23f51
incq %r12
incq %rax
decq %rcx
cmpq $0x4, %rcx
jb 0x23ffa
movl %eax, %edx
andl $0x3, %edx
jne 0x23ffa
testl $0x80808080, (%rax)     # imm = 0x80808080
jne 0x23ffa
addq $0x4, %r12
addq $0x4, %rax
addq $-0x4, %rcx
cmpq $0x3, %rcx
ja 0x23f2e
jmp 0x23ffa
cmpq $0x1, %rcx
je 0x23f7e
movl %edx, %esi
andl $-0x20, %esi
cmpl $0xc0, %esi
jne 0x23f7e
movb 0x1(%rax), %sil
andb $-0x40, %sil
negb %sil
jno 0x23f7e
incq %r12
addq $0x2, %rax
addq $-0x2, %rcx
jmp 0x23ffa
cmpq $0x3, %rcx
jb 0x23fb8
movl %edx, %esi
andl $-0x10, %esi
cmpl $0xe0, %esi
jne 0x23fb8
movb 0x1(%rax), %sil
andb $-0x40, %sil
negb %sil
jno 0x23fb8
movb 0x2(%rax), %sil
andb $-0x40, %sil
negb %sil
jno 0x23fb8
incq %r12
addq $0x3, %rax
addq $-0x3, %rcx
jmp 0x23ffa
cmpq $0x4, %rcx
jb 0x23ff4
andl $-0x8, %edx
cmpl $0xf0, %edx
jne 0x23ff4
movb 0x1(%rax), %dl
andb $-0x40, %dl
negb %dl
jno 0x23ff4
movb 0x2(%rax), %dl
andb $-0x40, %dl
negb %dl
jno 0x23ff4
movb 0x3(%rax), %dl
andb $-0x40, %dl
negb %dl
jno 0x23ff4
incq %r12
addq $0x4, %rax
addq $-0x4, %rcx
jmp 0x23ffa
incq %rax
decq %rcx
testq %rcx, %rcx
jne 0x23f09
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x65b0
testq %r12, %r12
je 0x2404c
movq (%rbx), %r13
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2a882
leaq (,%r12,4), %rcx
addq %r13, %rcx
cmpq %rax, %rcx
jne 0x24059
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x109a9(%rip), %rdi     # 0x34a09
leaq 0xee8e(%rip), %rsi      # 0x32ef5
leaq 0x109b1(%rip), %rcx     # 0x34a1f
movl $0x91a, %edx            # imm = 0x91A
callq 0x6120
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x24088
callq 0x63b0
movq %r14, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_node_set::_assign(pugi::xpath_node const*, pugi::xpath_node const*, pugi::xpath_node_set::type_t)
PUGI__FN void xpath_node_set::_assign(const_iterator begin_, const_iterator end_, type_t type_)
	{
		assert(begin_ <= end_);

		size_t size_ = static_cast<size_t>(end_ - begin_);

		if (size_ <= 1)
		{
			// deallocate old buffer
			if (_begin != &_storage) impl::xml_memory::deallocate(_begin);

			// use internal buffer
			if (begin_ != end_) _storage = *begin_;

			_begin = &_storage;
			_end = &_storage + size_;
			_type = type_;
		}
		else
		{
			// make heap copy
			xpath_node* storage = static_cast<xpath_node*>(impl::xml_memory::allocate(size_ * sizeof(xpath_node)));

			if (!storage)
			{
			#ifdef PUGIXML_NO_EXCEPTIONS
				return;
			#else
				throw std::bad_alloc();
			#endif
			}

			memcpy(storage, begin_, size_ * sizeof(xpath_node));

			// deallocate old buffer
			if (_begin != &_storage) impl::xml_memory::deallocate(_begin);

			// finalize
			_begin = storage;
			_end = storage + size_;
			_type = type_;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdx, %rsi
ja 0x24254
movl %ecx, %ebx
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r14
movq %rdx, %r15
subq %rsi, %r15
cmpq $0x10, %r15
ja 0x24205
movq 0x18(%r14), %rdi
leaq 0x8(%r14), %r12
cmpq %r12, %rdi
je 0x241f4
callq *0x2365c(%rip)          # 0x47850
cmpq %rbp, %r13
je 0x24237
movups (%r13), %xmm0
movups %xmm0, (%r12)
jmp 0x24237
movq %r15, %rdi
callq *0x2364a(%rip)          # 0x47858
testq %rax, %rax
je 0x24273
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6090
movq 0x18(%r14), %rdi
leaq 0x8(%r14), %rax
cmpq %rax, %rdi
je 0x24237
callq *0x23619(%rip)          # 0x47850
movq %r12, 0x18(%r14)
addq %r15, %r12
movq %r12, 0x20(%r14)
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf591(%rip), %rdi      # 0x337ec
leaq 0xec93(%rip), %rsi      # 0x32ef5
leaq 0xf592(%rip), %rcx      # 0x337fb
movl $0x2eeb, %edx           # imm = 0x2EEB
callq 0x6120
movl $0x8, %edi
callq 0x6260
movq 0x22cf4(%rip), %rcx     # 0x46f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x22cf6(%rip), %rsi     # 0x46f88
movq 0x22cbf(%rip), %rdx     # 0x46f58
movq %rax, %rdi
callq 0x6420
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_node_set::_move(pugi::xpath_node_set&)
PUGI__FN void xpath_node_set::_move(xpath_node_set& rhs) PUGIXML_NOEXCEPT
	{
		_type = rhs._type;
		_storage = rhs._storage;
		_begin = (rhs._begin == &rhs._storage) ? &_storage : rhs._begin;
		_end = _begin + (rhs._end - rhs._begin);

		rhs._type = type_unsorted;
		rhs._begin = &rhs._storage;
		rhs._end = rhs._begin;
	}

// Assembly:
movl (%rsi), %eax
movl %eax, (%rdi)
leaq 0x8(%rsi), %rax
leaq 0x8(%rdi), %rcx
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
movq 0x18(%rsi), %rdx
cmpq %rax, %rdx
cmovneq %rdx, %rcx
movq %rcx, 0x18(%rdi)
movq 0x20(%rsi), %rdx
subq 0x18(%rsi), %rdx
addq %rcx, %rdx
movq %rdx, 0x20(%rdi)
movl $0x0, (%rsi)
movq %rax, 0x18(%rsi)
movq %rax, 0x20(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_sort(pugi::xpath_node*, pugi::xpath_node*, pugi::xpath_node_set::type_t, bool)
PUGI__FN xpath_node_set::type_t xpath_sort(xpath_node* begin, xpath_node* end, xpath_node_set::type_t type, bool rev)
	{
		xpath_node_set::type_t order = rev ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted;

		if (type == xpath_node_set::type_unsorted)
		{
			xpath_node_set::type_t sorted = xpath_get_order(begin, end);

			if (sorted == xpath_node_set::type_unsorted)
			{
				sort(begin, end, document_order_comparator());

				type = xpath_node_set::type_sorted;
			}
			else
				type = sorted;
		}

		if (type != order) reverse(begin, end);

		return order;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
jne 0x24550
movq %r14, %rax
subq %r15, %rax
movl $0x1, %edx
cmpq $0x11, %rax
jl 0x2453c
leaq 0x10(%r15), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2acd0
movl %eax, %ebp
leaq 0x10(%r13), %r12
cmpq %r14, %r12
jae 0x24529
movq %r13, %rdi
movq %r12, %rsi
callq 0x2acd0
movq %r12, %r13
cmpb %al, %bpl
je 0x2450d
movzbl %bpl, %eax
movl $0x2, %ecx
subl %eax, %ecx
xorl %edx, %edx
cmpq %r14, %r12
cmovael %ecx, %edx
testl %edx, %edx
jne 0x24550
movq %r15, %rdi
movq %r14, %rsi
callq 0x2aac7
movl $0x1, %edx
incl %ebx
movq %r14, %rax
subq %r15, %rax
cmpq $0x11, %rax
jl 0x24590
cmpl %ebx, %edx
je 0x24590
addq $-0x10, %r14
movups (%r15), %xmm0
movaps %xmm0, (%rsp)
movups (%r14), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r15
movaps (%rsp), %xmm0
movups %xmm0, (%r14)
addq $-0x20, %rax
addq $-0x10, %r14
cmpq $0x10, %rax
jg 0x24566
movl %ebx, %eax
addq $0x18, %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::impl::(anonymous namespace)::xpath_first(pugi::xpath_node const*, pugi::xpath_node const*, pugi::xpath_node_set::type_t)
PUGI__FN xpath_node xpath_first(const xpath_node* begin, const xpath_node* end, xpath_node_set::type_t type)
	{
		if (begin == end) return xpath_node();

		switch (type)
		{
		case xpath_node_set::type_sorted:
			return *begin;

		case xpath_node_set::type_sorted_reverse:
			return *(end - 1);

		case xpath_node_set::type_unsorted:
			return *min_element(begin, end, document_order_comparator());

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0x245d5
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x245e5
cmpl $0x2, %edx
je 0x245db
cmpl $0x1, %edx
jne 0x24627
leaq 0x8(%r14), %rbx
jmp 0x2461b
xorl %eax, %eax
xorl %edx, %edx
jmp 0x24621
leaq -0x10(%rbx), %r14
addq $-0x8, %rbx
jmp 0x2461b
leaq 0x10(%r14), %r15
cmpq %rbx, %r15
je 0x24611
movq %r15, %rdi
movq %r14, %rsi
callq 0x2acd0
movq %r15, %rcx
testb %al, %al
jne 0x24603
movq %r14, %rcx
addq $0x10, %r15
movq %rcx, %r14
cmpq %rbx, %r15
jne 0x245ee
jmp 0x24614
movq %r14, %rcx
leaq 0x8(%rcx), %rbx
movq %rcx, %r14
movq (%r14), %rax
movq (%rbx), %rdx
popq %rbx
popq %r14
popq %r15
retq
leaq 0x104d0(%rip), %rdi     # 0x34afe
leaq 0xe8c0(%rip), %rsi      # 0x32ef5
leaq 0x104e3(%rip), %rcx     # 0x34b1f
movl $0x223a, %edx           # imm = 0x223A
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_variable::set(char const*)
PUGI__FN bool xpath_variable::set(const char_t* value)
	{
		if (_type != xpath_type_string) return false;

		impl::xpath_variable_string* var = static_cast<impl::xpath_variable_string*>(this);

		// duplicate string
		size_t size = (impl::strlength(value) + 1) * sizeof(char_t);

		char_t* copy = static_cast<char_t*>(impl::xml_memory::allocate(size));
		if (!copy) return false;

		memcpy(copy, value, size);

		// replace old string
		if (var->value) impl::xml_memory::deallocate(var->value);
		var->value = copy;

		return true;
	}

// Assembly:
cmpl $0x3, (%rdi)
jne 0x24798
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1d2a2
movq %rax, %r12
incq %r12
movq %r12, %rdi
callq *0x230fa(%rip)          # 0x47858
movq %rax, %r15
testq %rax, %rax
setne %al
je 0x2478c
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6090
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x24786
callq *0x230ca(%rip)          # 0x47850
movq %r15, 0x10(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::new_xpath_variable(pugi::xpath_value_type, char const*)
PUGI__FN xpath_variable* new_xpath_variable(xpath_value_type type, const char_t* name)
	{
		switch (type)
		{
		case xpath_type_node_set:
			return new_xpath_variable<xpath_variable_node_set>(name);

		case xpath_type_number:
			return new_xpath_variable<xpath_variable_number>(name);

		case xpath_type_string:
			return new_xpath_variable<xpath_variable_string>(name);

		case xpath_type_boolean:
			return new_xpath_variable<xpath_variable_boolean>(name);

		default:
			return 0;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
decl %edi
cmpl $0x3, %edi
ja 0x24c7f
movq %rsi, %rbx
leaq 0xdc6f(%rip), %rax      # 0x327d0
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x1d2a2
testq %rax, %rax
je 0x24c7f
movq %rax, %r15
leaq 0x40(%rax), %rdi
callq *0x22cd0(%rip)          # 0x47858
testq %rax, %rax
je 0x24c7f
movq %rax, %r14
movl $0x1, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
addq $0x18, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %rax, 0x28(%r14)
movq %rax, 0x30(%r14)
movq %r14, %rdi
addq $0x38, %rdi
jmp 0x24c6f
movq %rbx, %rdi
callq 0x1d2a2
testq %rax, %rax
je 0x24c7f
movq %rax, %r15
leaq 0x20(%rax), %rdi
callq *0x22c71(%rip)          # 0x47858
testq %rax, %rax
je 0x24c7f
movq %rax, %r14
movl $0x3, (%rax)
jmp 0x24c60
movq %rbx, %rdi
callq 0x1d2a2
testq %rax, %rax
je 0x24c7f
movq %rax, %r15
leaq 0x18(%rax), %rdi
callq *0x22c43(%rip)          # 0x47858
testq %rax, %rax
je 0x24c7f
movq %rax, %r14
movl $0x4, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rax, %rdi
addq $0x11, %rdi
jmp 0x24c6f
movq %rbx, %rdi
callq 0x1d2a2
testq %rax, %rax
je 0x24c7f
movq %rax, %r15
leaq 0x20(%rax), %rdi
callq *0x22c06(%rip)          # 0x47858
testq %rax, %rax
je 0x24c7f
movq %rax, %r14
movl $0x2, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %r14, %rdi
addq $0x18, %rdi
incq %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6090
jmp 0x24c82
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_variable_set::add(char const*, pugi::xpath_value_type)
PUGI__FN xpath_variable* xpath_variable_set::add(const char_t* name, xpath_value_type type)
	{
		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
		size_t hash = impl::hash_string(name) % hash_size;

		// look for existing variable
		for (xpath_variable* var = _data[hash]; var; var = var->_next)
			if (impl::strequal(var->name(), name))
				return var->type() == type ? var : 0;

		// add new variable
		xpath_variable* result = impl::new_xpath_variable(type, name);

		if (result)
		{
			result->_next = _data[hash];

			_data[hash] = result;
		}

		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %dl
testb %dl, %dl
je 0x24ccc
leaq 0x1(%r14), %rax
xorl %ecx, %ecx
movsbl %dl, %edx
addl %ecx, %edx
movl %edx, %esi
shll $0xa, %esi
addl %edx, %esi
movl %esi, %ecx
shrl $0x6, %ecx
xorl %esi, %ecx
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0x24cab
leal (%rcx,%rcx,8), %eax
jmp 0x24cce
xorl %eax, %eax
movl %eax, %r12d
shrl $0xb, %r12d
xorl %eax, %r12d
andl $0x3f, %r12d
movq (%rbx,%r12,8), %r15
testq %r15, %r15
sete %r13b
je 0x24d06
movq %r15, %rdi
callq 0x24680
movq %rax, %rdi
movq %r14, %rsi
callq 0x1d71d
testb %al, %al
jne 0x24d08
movq 0x8(%r15), %r15
jmp 0x24ce0
jmp 0x24d11
xorl %eax, %eax
cmpl %ebp, (%r15)
cmoveq %r15, %rax
testb %r13b, %r13b
je 0x24d31
movl %ebp, %edi
movq %r14, %rsi
callq 0x24b47
testq %rax, %rax
je 0x24d31
movq (%rbx,%r12,8), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx,%r12,8)
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::xpath_query::evaluate_boolean(pugi::xpath_node const&) const
PUGI__FN bool xpath_query::evaluate_boolean(const xpath_node& n) const
	{
		if (!_impl) return false;

		impl::xpath_context c(n, 1, 1);
		impl::xpath_stack_data sd;

		bool r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_boolean(c, sd.stack);

		if (sd.oom)
		{
		#ifdef PUGIXML_NO_EXCEPTIONS
			return false;
		#else
			throw std::bad_alloc();
		#endif
		}

		return r;
	}

// Assembly:
pushq %rbx
subq $0x2090, %rsp           # imm = 0x2090
movq (%rdi), %rax
testq %rax, %rax
je 0x253fa
movups (%rsi), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x1, %ecx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
leaq 0x2048(%rsp), %rcx
leaq 0x2088(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rdi, -0x40(%rdx)
xorl %r8d, %r8d
movq %r8, -0x38(%rdx)
movq %rdx, -0x30(%rdx)
leaq 0x2060(%rsp), %r9
leaq 0x1038(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rdx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %edx           # imm = 0x1000
movq %rdx, 0x8(%r10)
movq %rdx, 0x8(%rdi)
leaq 0x2078(%rsp), %rdx
movq %rcx, (%rdx)
movq %r9, 0x8(%rdx)
movq (%rax), %rdi
callq 0x2544a
cmpb $0x1, 0x2088(%rsp)
je 0x25407
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x26232
jmp 0x253fc
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x2090, %rsp           # imm = 0x2090
popq %rbx
retq
movl $0x8, %edi
callq 0x6260
movq 0x21b60(%rip), %rcx     # 0x46f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x21b62(%rip), %rsi     # 0x46f88
movq 0x21b2b(%rip), %rdx     # 0x46f58
movq %rax, %rdi
callq 0x6420
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x26232
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_query::evaluate_number(pugi::xpath_node const&) const
PUGI__FN double xpath_query::evaluate_number(const xpath_node& n) const
	{
		if (!_impl) return impl::gen_nan();

		impl::xpath_context c(n, 1, 1);
		impl::xpath_stack_data sd;

		double r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_number(c, sd.stack);

		if (sd.oom)
		{
		#ifdef PUGIXML_NO_EXCEPTIONS
			return impl::gen_nan();
		#else
			throw std::bad_alloc();
		#endif
		}

		return r;
	}

// Assembly:
pushq %rbx
subq $0x20a0, %rsp           # imm = 0x20A0
movq (%rdi), %rax
testq %rax, %rax
je 0x26318
movups (%rsi), %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x1, %ecx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
leaq 0x2058(%rsp), %rcx
leaq 0x2098(%rsp), %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, -0x40(%rdx)
xorl %r8d, %r8d
movq %r8, -0x38(%rdx)
movq %rdx, -0x30(%rdx)
leaq 0x2070(%rsp), %r9
leaq 0x1048(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rdx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %edx           # imm = 0x1000
movq %rdx, 0x8(%r10)
movq %rdx, 0x8(%rdi)
leaq 0x2088(%rsp), %rdx
movq %rcx, (%rdx)
movq %r9, 0x8(%rdx)
movq (%rax), %rdi
callq 0x2636c
movsd %xmm0, 0x8(%rsp)
cmpb $0x1, 0x2098(%rsp)
je 0x26329
leaq 0x38(%rsp), %rdi
callq 0x26232
movsd 0x8(%rsp), %xmm0
jmp 0x26320
movsd 0xc460(%rip), %xmm0     # 0x32780
addq $0x20a0, %rsp           # imm = 0x20A0
popq %rbx
retq
movl $0x8, %edi
callq 0x6260
movq 0x20c3e(%rip), %rcx     # 0x46f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20c40(%rip), %rsi     # 0x46f88
movq 0x20c09(%rip), %rdx     # 0x46f58
movq %rax, %rdi
callq 0x6420
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x26232
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_query::evaluate_string[abi:cxx11](pugi::xpath_node const&) const
PUGI__FN string_t xpath_query::evaluate_string(const xpath_node& n) const
	{
		if (!_impl) return string_t();

		impl::xpath_context c(n, 1, 1);
		impl::xpath_stack_data sd;

		impl::xpath_string r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_string(c, sd.stack);

		if (sd.oom)
		{
		#ifdef PUGIXML_NO_EXCEPTIONS
			return string_t();
		#else
			throw std::bad_alloc();
		#endif
		}

		return string_t(r.c_str(), r.length());
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x20a8, %rsp           # imm = 0x20A8
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x269d3
movups (%rdx), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movl $0x1, %ecx
movq %rcx, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
leaq 0x2060(%rsp), %rsi
leaq 0x20a0(%rsp), %rcx
leaq 0x40(%rsp), %rdi
movq %rdi, -0x40(%rcx)
xorl %r8d, %r8d
movq %r8, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
leaq 0x2078(%rsp), %r9
leaq 0x1050(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rcx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r10)
movq %rcx, 0x8(%rdi)
leaq 0x2090(%rsp), %rcx
movq %rsi, (%rcx)
movq %r9, 0x8(%rcx)
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x26a66
cmpb $0x1, 0x20a0(%rsp)
je 0x26a20
movq 0x8(%rsp), %r14
cmpb $0x1, 0x10(%rsp)
jne 0x269e8
movq 0x18(%rsp), %rdx
jmp 0x269f3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x26a12
movq %r14, %rdi
callq 0x1d2a2
movq %rax, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa06a
leaq 0x40(%rsp), %rdi
callq 0x26232
movq %rbx, %rax
addq $0x20a8, %rsp           # imm = 0x20A8
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x6260
movq 0x20547(%rip), %rcx     # 0x46f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20549(%rip), %rsi     # 0x46f88
movq 0x20512(%rip), %rdx     # 0x46f58
movq %rax, %rdi
callq 0x6420
jmp 0x26a50
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x26232
movq %rbx, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_query::evaluate_string(char*, unsigned long, pugi::xpath_node const&) const
PUGI__FN size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const
	{
		impl::xpath_context c(n, 1, 1);
		impl::xpath_stack_data sd;

		impl::xpath_string r = _impl ? static_cast<impl::xpath_query_impl*>(_impl)->root->eval_string(c, sd.stack) : impl::xpath_string();

		if (sd.oom)
		{
		#ifdef PUGIXML_NO_EXCEPTIONS
			r = impl::xpath_string();
		#else
			throw std::bad_alloc();
		#endif
		}

		size_t full_size = r.length() + 1;

		if (capacity > 0)
		{
			size_t size = (full_size < capacity) ? full_size : capacity;
			assert(size > 0);

			memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
			buffer[size - 1] = 0;
		}

		return full_size;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20b0, %rsp           # imm = 0x20B0
movq %rdx, %rbx
movq %rsi, %r14
movups (%rcx), %xmm0
movaps %xmm0, 0x20(%rsp)
movl $0x1, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
leaq 0x2068(%rsp), %rax
leaq 0x20a8(%rsp), %rcx
leaq 0x48(%rsp), %rdx
movq %rdx, -0x40(%rcx)
xorl %esi, %esi
movq %rsi, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
leaq 0x2080(%rsp), %r8
leaq 0x1058(%rsp), %r9
movq %r9, (%r8)
movq %rsi, 0x8(%r8)
movq %rcx, 0x10(%r8)
movb $0x0, 0x28(%r8)
movq %rsi, (%r9)
movq %rsi, (%rdx)
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r9)
movq %rcx, 0x8(%rdx)
movq %rax, 0x18(%r8)
movq %r8, 0x20(%r8)
movq (%rdi), %rax
testq %rax, %rax
je 0x27a53
leaq 0x2098(%rsp), %rcx
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x26a66
jmp 0x27a6d
leaq 0x96af(%rip), %rax      # 0x31109
movq %rax, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
cmpb $0x1, 0x20a8(%rsp)
je 0x27ad7
cmpb $0x1, 0x10(%rsp)
jne 0x27a85
movq 0x18(%rsp), %r15
jmp 0x27a92
movq 0x8(%rsp), %rdi
callq 0x1d2a2
movq %rax, %r15
incq %r15
testq %rbx, %rbx
je 0x27abd
testq %r15, %r15
je 0x27b05
cmpq %rbx, %r15
cmovbq %r15, %rbx
movq 0x8(%rsp), %rsi
leaq -0x1(%rbx), %rdx
movq %r14, %rdi
callq 0x6090
movb $0x0, -0x1(%r14,%rbx)
leaq 0x48(%rsp), %rdi
callq 0x26232
movq %r15, %rax
addq $0x20b0, %rsp           # imm = 0x20B0
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x6260
movq 0x1f490(%rip), %rcx     # 0x46f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1f492(%rip), %rsi     # 0x46f88
movq 0x1f45b(%rip), %rdx     # 0x46f58
movq %rax, %rdi
callq 0x6420
leaq 0xbdeb(%rip), %rdi      # 0x338f7
leaq 0xb3e2(%rip), %rsi      # 0x32ef5
leaq 0xbde6(%rip), %rcx      # 0x33900
movl $0x3149, %edx           # imm = 0x3149
callq 0x6120
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x26232
movq %rbx, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_query::evaluate_node_set(pugi::xpath_node const&) const
PUGI__FN xpath_node_set xpath_query::evaluate_node_set(const xpath_node& n) const
	{
		impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast<impl::xpath_query_impl*>(_impl));
		if (!root) return xpath_node_set();

		impl::xpath_context c(n, 1, 1);
		impl::xpath_stack_data sd;

		impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack, impl::nodeset_eval_all);

		if (sd.oom)
		{
		#ifdef PUGIXML_NO_EXCEPTIONS
			return xpath_node_set();
		#else
			throw std::bad_alloc();
		#endif
		}

		return xpath_node_set(r.begin(), r.end(), r.type());
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x20a8, %rsp           # imm = 0x20A8
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x27c96
testq %rax, %rax
je 0x27c2c
movups (%r14), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movl $0x1, %ecx
movq %rcx, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
leaq 0x2060(%rsp), %rsi
leaq 0x20a0(%rsp), %rcx
leaq 0x40(%rsp), %rdi
movq %rdi, -0x40(%rcx)
xorl %r8d, %r8d
movq %r8, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
leaq 0x2078(%rsp), %r9
leaq 0x1050(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rcx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r10)
movq %rcx, 0x8(%rdi)
leaq 0x2090(%rsp), %rcx
movq %rsi, (%rcx)
movq %r9, 0x8(%rcx)
movq %rsp, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x27cf4
cmpb $0x1, 0x20a0(%rsp)
je 0x27c53
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl (%rsp), %ecx
movl $0x0, (%rbx)
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x241b6
leaq 0x40(%rsp), %rdi
callq 0x26232
jmp 0x27c45
movl $0x0, (%rbx)
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x20a8, %rsp           # imm = 0x20A8
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x6260
movq 0x1f314(%rip), %rcx     # 0x46f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1f316(%rip), %rsi     # 0x46f88
movq 0x1f2df(%rip), %rdx     # 0x46f58
movq %rax, %rdi
callq 0x6420
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x26232
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::evaluate_node_set_prepare(pugi::impl::(anonymous namespace)::xpath_query_impl*)
PUGI__FN impl::xpath_ast_node* evaluate_node_set_prepare(xpath_query_impl* impl)
	{
		if (!impl) return 0;

		if (impl->root->rettype() != xpath_type_node_set)
		{
		#ifdef PUGIXML_NO_EXCEPTIONS
			return 0;
		#else
			xpath_parse_result res;
			res.error = "Expression does not evaluate to node set";

			throw xpath_exception(res);
		#endif
		}

		return impl->root;
	}

// Assembly:
testq %rdi, %rdi
je 0x27ca5
movq (%rdi), %rax
cmpb $0x1, 0x1(%rax)
jne 0x27ca8
retq
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, 0x8(%rbx)
leaq 0xe093(%rip), %rax      # 0x35d56
movq %rax, (%rbx)
movl $0x18, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x240c8
leaq 0x1ef23(%rip), %rsi     # 0x46c08
movq 0x1f264(%rip), %rdx     # 0x46f50
movq %r14, %rdi
callq 0x6420
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_query::evaluate_node(pugi::xpath_node const&) const
PUGI__FN xpath_node xpath_query::evaluate_node(const xpath_node& n) const
	{
		impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast<impl::xpath_query_impl*>(_impl));
		if (!root) return xpath_node();

		impl::xpath_context c(n, 1, 1);
		impl::xpath_stack_data sd;

		impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack, impl::nodeset_eval_first);

		if (sd.oom)
		{
		#ifdef PUGIXML_NO_EXCEPTIONS
			return xpath_node();
		#else
			throw std::bad_alloc();
		#endif
		}

		return r.first();
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x20a8, %rsp           # imm = 0x20A8
movq %rsi, %rbx
movq (%rdi), %rdi
callq 0x27c96
testq %rax, %rax
je 0x28209
movups (%rbx), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movl $0x1, %ecx
movq %rcx, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
leaq 0x2060(%rsp), %rsi
leaq 0x20a0(%rsp), %rcx
leaq 0x40(%rsp), %rdi
movq %rdi, -0x40(%rcx)
xorl %r8d, %r8d
movq %r8, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
leaq 0x2078(%rsp), %r9
leaq 0x1050(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rcx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r10)
movq %rcx, 0x8(%rdi)
leaq 0x2090(%rsp), %rcx
movq %rsi, (%rcx)
movq %r9, 0x8(%rcx)
movq %rsp, %rdi
movq %rax, %rsi
movl $0x2, %r8d
callq 0x27cf4
cmpb $0x1, 0x20a0(%rsp)
je 0x2821f
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl (%rsp), %edx
callq 0x245b1
movq %rax, %rbx
movq %rdx, %r14
leaq 0x40(%rsp), %rdi
callq 0x26232
jmp 0x2820e
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rbx, %rax
movq %r14, %rdx
addq $0x20a8, %rsp           # imm = 0x20A8
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x6260
movq 0x1ed48(%rip), %rcx     # 0x46f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1ed4a(%rip), %rsi     # 0x46f88
movq 0x1ed13(%rip), %rdx     # 0x46f58
movq %rax, %rdi
callq 0x6420
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x26232
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: void pugi::impl::(anonymous namespace)::node_copy_string<char*, unsigned long>(char*&, unsigned long&, unsigned long, char*, unsigned long&, pugi::impl::(anonymous namespace)::xml_allocator*)
PUGI__FN void node_copy_string(String& dest, Header& header, uintptr_t header_mask, char_t* source, Header& source_header, xml_allocator* alloc)
	{
		assert(!dest && (header & header_mask) == 0);

		if (source)
		{
			if (alloc && (source_header & header_mask) == 0)
			{
				dest = source;

				// since strcpy_insitu can reuse document buffer memory we need to mark both source and dest as shared
				header |= xml_memory_page_contents_shared_mask;
				source_header |= xml_memory_page_contents_shared_mask;
			}
			else
				strcpy_insitu(dest, header, header_mask, source, strlength(source));
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
jne 0x2871a
movq %rdx, %r15
movq %rsi, %r14
movq (%rsi), %rax
testq %rdx, %rax
jne 0x2871a
movq %rcx, %rbx
testq %rcx, %rcx
je 0x2870e
movq %rdi, %r12
testq %r9, %r9
je 0x286d8
testq %r15, (%r8)
je 0x286ff
movq %rbx, %rdi
callq 0x6270
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d06a
movq %rbx, (%r12)
orq $0x40, %rax
movq %rax, (%r14)
orb $0x40, (%r8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xb352(%rip), %rdi      # 0x33a73
leaq 0xa7cd(%rip), %rsi      # 0x32ef5
leaq 0xb369(%rip), %rcx      # 0x33a98
movl $0x111c, %edx           # imm = 0x111C
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::node_copy_contents(pugi::xml_node_struct*, pugi::xml_node_struct*, pugi::impl::(anonymous namespace)::xml_allocator*)
PUGI__FN void node_copy_contents(xml_node_struct* dn, xml_node_struct* sn, xml_allocator* shared_alloc)
	{
		node_copy_string(dn->name, dn->header, xml_memory_page_name_allocated_mask, sn->name, sn->header, shared_alloc);
		node_copy_string(dn->value, dn->header, xml_memory_page_value_allocated_mask, sn->value, sn->header, shared_alloc);

		for (xml_attribute_struct* sa = sn->first_attribute; sa; sa = sa->next_attribute)
		{
			xml_attribute_struct* da = append_new_attribute(dn, get_allocator(dn));

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%rsi), %rcx
movl $0x20, %edx
movq %r14, %rsi
movq %r15, %r8
movq %rbx, %r9
callq 0x286a7
leaq 0x10(%r14), %rdi
movq 0x10(%r15), %rcx
movl $0x10, %edx
movq %r14, %rsi
movq %r15, %r8
movq %rbx, %r9
callq 0x286a7
movq 0x38(%r15), %r15
testq %r15, %r15
je 0x287e6
movq (%r14), %rax
shrq $0x8, %rax
negq %rax
movq (%r14,%rax), %rsi
movq %r14, %rdi
callq 0x2889f
testq %rax, %rax
je 0x287e0
movq %rax, %r12
leaq 0x8(%rax), %rdi
movq 0x8(%r15), %rcx
movl $0x20, %edx
movq %rax, %rsi
movq %r15, %r8
movq %rbx, %r9
callq 0x286a7
movq %r12, %rdi
addq $0x10, %rdi
movq 0x10(%r15), %rcx
movl $0x10, %edx
movq %r12, %rsi
movq %r15, %r8
movq %rbx, %r9
callq 0x286a7
movq 0x20(%r15), %r15
jmp 0x28784
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::append_new_node(pugi::xml_node_struct*, pugi::impl::(anonymous namespace)::xml_allocator&, pugi::xml_node_type)
PUGI__FN_NO_INLINE xml_node_struct* append_new_node(xml_node_struct* node, xml_allocator& alloc, xml_node_type type = node_element)
	{
		if (!alloc.reserve()) return 0;

		xml_node_struct* child = allocate_node(alloc, type);
		if (!child) return 0;

		append_node(child, node);

		return child;
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
leaq 0x40(%rax), %rdx
cmpq $0x7fd9, %rdx           # imm = 0x7FD9
jae 0x2888d
movq (%rcx), %rsi
addq %rsi, %rax
addq $0x28, %rax
movq %rdx, 0x8(%rcx)
movq %rsi, (%rsp)
testq %rax, %rax
je 0x28851
movq %rax, %rcx
subq (%rsp), %rcx
shlq $0x8, %rcx
movl %ebp, %edx
orq %rcx, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x38(%rax)
movq %rdx, (%rax)
jmp 0x28853
xorl %eax, %eax
testq %rax, %rax
je 0x28877
movq %rbx, 0x18(%rax)
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x2887b
movq 0x28(%rcx), %rdx
addq $0x28, %rcx
movq %rax, 0x30(%rdx)
movq %rdx, 0x28(%rax)
jmp 0x28883
xorl %eax, %eax
jmp 0x28886
movq %rax, 0x20(%rbx)
leaq 0x28(%rax), %rcx
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsp, %rdx
movl $0x40, %esi
movq %rcx, %rdi
callq 0x28a84
jmp 0x28820
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::append_new_attribute(pugi::xml_node_struct*, pugi::impl::(anonymous namespace)::xml_allocator&)
PUGI__FN_NO_INLINE xml_attribute_struct* append_new_attribute(xml_node_struct* node, xml_allocator& alloc)
	{
		if (!alloc.reserve()) return 0;

		xml_attribute_struct* attr = allocate_attribute(alloc);
		if (!attr) return 0;

		append_attribute(attr, node);

		return attr;
	}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
leaq 0x28(%rax), %rdx
cmpq $0x7fd9, %rdx           # imm = 0x7FD9
jae 0x28926
movq (%rcx), %rsi
addq %rsi, %rax
addq $0x28, %rax
movq %rdx, 0x8(%rcx)
movq %rsi, 0x8(%rsp)
testq %rax, %rax
je 0x288ef
movq %rax, %rcx
subq 0x8(%rsp), %rcx
shlq $0x8, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %rcx, (%rax)
jmp 0x288f1
xorl %eax, %eax
testq %rax, %rax
je 0x28911
movq 0x38(%rbx), %rcx
testq %rcx, %rcx
je 0x28915
movq 0x18(%rcx), %rdx
addq $0x18, %rcx
movq %rax, 0x20(%rdx)
movq %rdx, 0x18(%rax)
jmp 0x2891d
xorl %eax, %eax
jmp 0x28920
movq %rax, 0x38(%rbx)
leaq 0x18(%rax), %rcx
movq %rax, (%rcx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x8(%rsp), %rdx
movl $0x28, %esi
movq %rcx, %rdi
callq 0x28a84
jmp 0x288ce
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_allocator::deallocate_memory(void*, unsigned long, pugi::impl::(anonymous namespace)::xml_memory_page*)
void deallocate_memory(void* ptr, size_t size, xml_memory_page* page)
		{
			if (page == _root) page->busy_size = _busy_size;

			assert(ptr >= reinterpret_cast<char*>(page) + sizeof(xml_memory_page) && ptr < reinterpret_cast<char*>(page) + sizeof(xml_memory_page) + page->busy_size);
			(void)!ptr;

			page->freed_size += size;
			assert(page->freed_size <= page->busy_size);

			if (page->freed_size == page->busy_size)
			{
				if (page->next == 0)
				{
					assert(_root == page);

					// top page freed, just reset sizes
					page->busy_size = 0;
					page->freed_size = 0;

				#ifdef PUGIXML_COMPACT
					// reset compact state to maximize efficiency
					page->compact_string_base = 0;
					page->compact_shared_parent = 0;
					page->compact_page_marker = 0;
				#endif

					_busy_size = 0;
				}
				else
				{
					assert(_root != page);
					assert(page->prev);

					// remove from the list
					page->prev->next = page->next;
					page->next->prev = page->prev;

					// deallocate
					deallocate_page(page);
				}
			}
		}

// Assembly:
pushq %rax
movq (%rdi), %rax
cmpq %rcx, %rax
jne 0x28977
movq 0x8(%rdi), %r8
movq %r8, 0x18(%rcx)
leaq 0x28(%rcx), %r9
cmpq %rsi, %r9
ja 0x289e9
movq 0x18(%rcx), %r8
addq %r8, %r9
cmpq %rsi, %r9
jbe 0x289e9
leaq 0x18(%rcx), %rsi
addq 0x20(%rcx), %rdx
movq %rdx, 0x20(%rcx)
cmpq %r8, %rdx
ja 0x28a08
jne 0x289e7
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0x289d0
cmpq %rcx, %rax
je 0x28a27
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x28a46
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rdx
movq %rax, 0x8(%rdx)
movq %rcx, %rdi
popq %rax
jmpq *0x1ee80(%rip)          # 0x47850
cmpq %rcx, %rax
jne 0x28a65
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x8(%rdi)
popq %rax
retq
leaq 0xb14f(%rip), %rdi      # 0x33b3f
leaq 0xa4fe(%rip), %rsi      # 0x32ef5
leaq 0xb1d3(%rip), %rcx      # 0x33bd1
movl $0x255, %edx            # imm = 0x255
callq 0x6120
leaq 0xb22e(%rip), %rdi      # 0x33c3d
leaq 0xa4df(%rip), %rsi      # 0x32ef5
leaq 0xb1b4(%rip), %rcx      # 0x33bd1
movl $0x259, %edx            # imm = 0x259
callq 0x6120
leaq 0xb241(%rip), %rdi      # 0x33c6f
leaq 0xa4c0(%rip), %rsi      # 0x32ef5
leaq 0xb195(%rip), %rcx      # 0x33bd1
movl $0x270, %edx            # imm = 0x270
callq 0x6120
leaq 0xac1c(%rip), %rdi      # 0x33669
leaq 0xa4a1(%rip), %rsi      # 0x32ef5
leaq 0xb176(%rip), %rcx      # 0x33bd1
movl $0x271, %edx            # imm = 0x271
callq 0x6120
leaq 0xb1f5(%rip), %rdi      # 0x33c61
leaq 0xa482(%rip), %rsi      # 0x32ef5
leaq 0xb157(%rip), %rcx      # 0x33bd1
movl $0x25f, %edx            # imm = 0x25F
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_allocator::allocate_memory_oob(unsigned long, pugi::impl::(anonymous namespace)::xml_memory_page*&)
PUGI__FN_NO_INLINE void* xml_allocator::allocate_memory_oob(size_t size, xml_memory_page*& out_page)
	{
		const size_t large_allocation_threshold = xml_memory_page_size / 4;

		xml_memory_page* page = allocate_page(size <= large_allocation_threshold ? xml_memory_page_size : size);
		out_page = page;

		if (!page) return 0;

		if (size <= large_allocation_threshold)
		{
			_root->busy_size = _busy_size;

			// insert page at the end of linked list
			page->prev = _root;
			_root->next = page;
			_root = page;

			_busy_size = size;
		}
		else
		{
			// insert page before the end of linked list, so that it is deleted as soon as possible
			// the last page is not deleted even if it's empty (see deallocate_memory)
			assert(_root->prev);

			page->prev = _root->prev;
			page->next = _root;

			_root->prev->next = page;
			_root->prev = page;

			page->busy_size = size;
		}

		return reinterpret_cast<char*>(page) + sizeof(xml_memory_page);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %rax
cmpq $0x1ff7, %rsi           # imm = 0x1FF7
movl $0x8000, %edi           # imm = 0x8000
cmovaeq %rax, %rdi
callq *0x1edac(%rip)          # 0x47858
testq %rax, %rax
je 0x28ace
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq (%r14), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x28ad0
xorl %eax, %eax
movq %rax, (%r15)
testq %rax, %rax
je 0x28afd
cmpq $0x1ff6, %rbx           # imm = 0x1FF6
ja 0x28b01
leaq 0x8(%r14), %rcx
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %rsi, 0x18(%rdx)
movq %rdx, 0x8(%rax)
movq %rax, 0x10(%rdx)
movq %rax, (%r14)
jmp 0x28b25
xorl %eax, %eax
jmp 0x28b2c
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x28b32
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq 0x8(%rcx), %rdx
movq %rax, 0x10(%rdx)
movq %rax, 0x8(%rcx)
leaq 0x18(%rax), %rcx
movq %rbx, (%rcx)
addq $0x28, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb144(%rip), %rdi      # 0x33c7d
leaq 0xa3b5(%rip), %rsi      # 0x32ef5
leaq 0xb142(%rip), %rcx      # 0x33c89
movl $0x2db, %edx            # imm = 0x2DB
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::get_mutable_buffer(char*&, unsigned long&, void const*, unsigned long, bool)
PUGI__FN bool get_mutable_buffer(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
	{
		size_t length = size / sizeof(char_t);

		if (is_mutable)
		{
			out_buffer = static_cast<char_t*>(const_cast<void*>(contents));
			out_length = length;
		}
		else
		{
			char_t* buffer = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
			if (!buffer) return false;

			if (contents)
				memcpy(buffer, contents, length * sizeof(char_t));
			else
				assert(length == 0);

			buffer[length] = 0;

			out_buffer = buffer;
			out_length = length + 1;
		}

		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
testl %r8d, %r8d
je 0x29018
movq %rbp, %r13
movq %r15, %r12
jmp 0x29051
leaq 0x1(%r15), %r12
movq %r12, %rdi
callq *0x1e833(%rip)          # 0x47858
testq %rax, %rax
je 0x29042
movq %rax, %r13
testq %rbp, %rbp
je 0x29046
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x6090
jmp 0x2904b
xorl %eax, %eax
jmp 0x29059
testq %r15, %r15
jne 0x29068
movb $0x0, (%r13,%r15)
movq %r13, (%r14)
movq %r12, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xad14(%rip), %rdi      # 0x33d83
leaq 0x9e7f(%rip), %rsi      # 0x32ef5
leaq 0xad12(%rip), %rcx      # 0x33d8f
movl $0x809, %edx            # imm = 0x809
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::utf8_writer::low(unsigned char*, unsigned int)
static value_type low(value_type result, uint32_t ch)
		{
			// U+0000..U+007F
			if (ch < 0x80)
			{
				*result = static_cast<uint8_t>(ch);
				return result + 1;
			}
			// U+0080..U+07FF
			else if (ch < 0x800)
			{
				result[0] = static_cast<uint8_t>(0xC0 | (ch >> 6));
				result[1] = static_cast<uint8_t>(0x80 | (ch & 0x3F));
				return result + 2;
			}
			// U+0800..U+FFFF
			else
			{
				result[0] = static_cast<uint8_t>(0xE0 | (ch >> 12));
				result[1] = static_cast<uint8_t>(0x80 | ((ch >> 6) & 0x3F));
				result[2] = static_cast<uint8_t>(0x80 | (ch & 0x3F));
				return result + 3;
			}
		}

// Assembly:
movq %rdi, %rax
cmpl $0x7f, %esi
ja 0x2909a
movb %sil, (%rax)
movl $0x1, %ecx
jmp 0x290e6
movl %esi, %ecx
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0x290bf
shrl $0x6, %ecx
orb $-0x40, %cl
movb %cl, (%rax)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%rax)
movl $0x2, %ecx
jmp 0x290e6
shrl $0xc, %ecx
orb $-0x20, %cl
movb %cl, (%rax)
movl %esi, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rax)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x2(%rax)
movl $0x3, %ecx
addq %rcx, %rax
retq