LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_named_node_iterator::operator--()
PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator--()
	{
		if (_wrap._root)
			_wrap = _wrap.previous_sibling(_name);
		else
		{
			_wrap = _parent.last_child();

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

		return *this;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x1c6e8
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c6d0
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1c6d0
movq 0x28(%rax), %rax
movq %rax, (%rbx)
testq %rax, %rax
je 0x1c6d4
movq 0x8(%rax), %rax
testq %rax, %rax
leaq 0xda3f(%rip), %rdi      # 0x2a109
cmovneq %rax, %rdi
jmp 0x1c6db
andq $0x0, (%rbx)
leaq 0xda2e(%rip), %rdi      # 0x2a109
movq 0x10(%rbx), %rsi
callq 0x1888f
testb %al, %al
jne 0x1c6f7
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x18956
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::_destroy()
PUGI__FN void xml_document::_destroy()
	{
		assert(_root);

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

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

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

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

			impl::xml_allocator::deallocate_page(page);

			page = next;
		}

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

		_root = 0;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x1c88c
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1c818
callq *0x27050(%rip)          # 0x43860
andq $0x0, 0x8(%rbx)
movq (%rbx), %r14
addq $0x58, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x1c838
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c832
callq *0x2702e(%rip)          # 0x43860
addq $0x8, %r14
jmp 0x1c81c
movq (%rbx), %rax
movq (%rax), %rcx
shrq $0x8, %rcx
movq %rcx, %rdx
negq %rdx
cmpq $0x0, 0x8(%rax,%rdx)
jne 0x1c8ab
subq %rcx, %rax
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jb 0x1c8ca
leaq 0xd0(%rbx), %rcx
cmpq %rcx, %rax
jae 0x1c8ca
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x1c880
movq 0x10(%rdi), %r14
callq *0x26fe5(%rip)          # 0x43860
movq %r14, %rdi
jmp 0x1c86c
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xfcc8(%rip), %rdi      # 0x2c55b
leaq 0xf69b(%rip), %rsi      # 0x2bf35
leaq 0xfce3(%rip), %rcx      # 0x2c584
movl $0x1b0c, %edx           # imm = 0x1B0C
callq 0x6100
leaq 0xfcf6(%rip), %rdi      # 0x2c5a8
leaq 0xf67c(%rip), %rsi      # 0x2bf35
leaq 0xfcc4(%rip), %rcx      # 0x2c584
movl $0x1b1d, %edx           # imm = 0x1B1D
callq 0x6100
leaq 0xfcf5(%rip), %rdi      # 0x2c5c6
leaq 0xf65d(%rip), %rsi      # 0x2bf35
leaq 0xfca5(%rip), %rcx      # 0x2c584
movl $0x1b1e, %edx           # imm = 0x1B1E
callq 0x6100
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::load_file(char const*, unsigned int, pugi::xml_encoding)
PUGI__FN xml_parse_result xml_document::load_file(const char* path_, unsigned int options, xml_encoding encoding)
	{
		reset();

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1cb20
leaq 0xf36c(%rip), %rsi      # 0x2c70e
movq %r15, %rdi
callq 0x6860
movq %rax, (%rsp)
leaq 0x4c(%rip), %rcx        # 0x1d401
movq %rcx, 0x8(%rsp)
movq (%r12), %rsi
addq $0x8, %r12
movq %rbx, %rdi
movq %rax, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movq %r12, %r9
callq 0x1d406
movq %rsp, %rdi
callq 0x1d51a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1d51a
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::load_file_impl(pugi::impl::(anonymous namespace)::xml_document_struct*, _IO_FILE*, unsigned int, pugi::xml_encoding, char**)
PUGI__FN xml_parse_result load_file_impl(xml_document_struct* doc, FILE* file, unsigned int options, xml_encoding encoding, char_t** out_buffer)
	{
		if (!file) return make_parse_result(status_file_not_found);

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

		size_t max_suffix_size = sizeof(char_t);

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1d4a7
movq %r9, %r15
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, 0x8(%rsp)
pushq $0x2
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x6830
movq %r13, %rdi
callq 0x6150
movq %rax, %r14
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6830
testq %r14, %r14
js 0x1d4c8
movl %ebp, 0x4(%rsp)
movq %r15, 0x10(%rsp)
leaq 0x1(%r14), %rbp
movq %rbp, %rdi
callq *0x263f9(%rip)          # 0x43868
testq %rax, %rax
je 0x1d4b3
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
movq %r13, %rcx
callq 0x63b0
cmpq %r14, %rax
jne 0x1d4bf
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x22e29
cmpl $0x1, %eax
jne 0x1d4e9
movb $0x0, (%r15,%r14)
jmp 0x1d4ec
andl $0x0, 0x10(%rbx)
movl $0x1, (%rbx)
jmp 0x1d4d2
andl $0x0, 0x10(%rbx)
movl $0x3, (%rbx)
jmp 0x1d4d2
movq %r15, %rdi
callq *0x26398(%rip)          # 0x43860
andl $0x0, 0x10(%rbx)
movl $0x2, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rbp
movq 0x8(%rsp), %rdx
pushq $0x1
popq %r10
movq %rbx, %rdi
movq %rdx, %rsi
movq %r15, %rcx
movq %rbp, %r8
movl 0x4(%rsp), %r9d
pushq 0x10(%rsp)
pushq %r10
pushq %r10
pushq %rax
callq 0x19ddb
addq $0x20, %rsp
jmp 0x1d4d7
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::open_file_wide(wchar_t const*, wchar_t const*)
PUGI__FN char* convert_path_heap(const wchar_t* str)
	{
		assert(str);

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

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

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

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

		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1d65c
movq %rsi, %rbx
movq %rdi, %r15
callq 0x1dc2d
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x25567
movq %rax, %r13
leaq 0x1(%rax), %rdi
callq *0x2626f(%rip)          # 0x43868
testq %rax, %rax
je 0x1d649
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2556c
movb $0x0, (%r14,%r13)
andl $0x0, 0xc(%rsp)
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
testl %ecx, %ecx
je 0x1d62e
movb %cl, 0xc(%rsp,%rax)
incq %rax
jmp 0x1d61e
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x6860
movq %rax, %rbx
movq %r14, %rdi
callq *0x26219(%rip)          # 0x43860
jmp 0x1d64b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xf112(%rip), %rdi      # 0x2c775
leaq 0xe8cb(%rip), %rsi      # 0x2bf35
leaq 0x1029b(%rip), %rcx     # 0x2d90c
movl $0x1367, %edx           # imm = 0x1367
callq 0x6100
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::save(pugi::xml_writer&, char const*, unsigned int, pugi::xml_encoding) const
PUGI__FN void xml_document::save(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding) const
	{
		impl::xml_buffered_writer buffered_writer(writer, encoding);

		if ((flags & format_write_bom) && encoding != encoding_latin1)
		{
			// BOM always represents the codepoint U+FEFF, so just write it in native encoding
		#ifdef PUGIXML_WCHAR_MODE
			unsigned int bom = 0xfeff;
			buffered_writer.write(static_cast<wchar_t>(bom));
		#else
			buffered_writer.write('\xef', '\xbb', '\xbf');
		#endif
		}

		if (!(flags & format_no_declaration) && !impl::has_declaration(_root))
		{
			buffered_writer.write_string(PUGIXML_TEXT("<?xml version=\"1.0\""));
			if (encoding == encoding_latin1) buffered_writer.write_string(PUGIXML_TEXT(" encoding=\"ISO-8859-1\""));
			buffered_writer.write('?', '>');
			if (!(flags & format_raw)) buffered_writer.write('\n');
		}

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

		buffered_writer.flush();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2818, %rsp           # imm = 0x2818
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movq %rsp, %rdi
movl %r8d, %edx
callq 0x1ba4c
testb $0x2, %bl
sete %al
cmpl $0x9, %ebp
sete %cl
orb %al, %cl
jne 0x1d77e
movq %rsp, %rdi
pushq $-0x11
popq %rsi
pushq $-0x45
popq %rdx
pushq $-0x41
popq %rcx
callq 0x1d814
testb $0x8, %bl
jne 0x1d7e8
movq (%r15), %rax
addq $0x20, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1d7a7
movl (%rax), %ecx
andl $0xf, %ecx
cmpl $0x2, %ecx
je 0x1d7a7
cmpl $0x7, %ecx
je 0x1d7e8
addq $0x30, %rax
jmp 0x1d78a
leaq 0xef63(%rip), %rsi      # 0x2c711
movq %rsp, %rdi
callq 0x1d864
cmpl $0x9, %ebp
jne 0x1d7ca
leaq 0xef63(%rip), %rsi      # 0x2c725
movq %rsp, %rdi
callq 0x1d864
movq %rsp, %rdi
pushq $0x3f
popq %rsi
pushq $0x3e
popq %rdx
callq 0x1d914
testb $0x4, %bl
jne 0x1d7e8
movq %rsp, %rdi
pushq $0xa
popq %rsi
callq 0x1d952
movq (%r15), %rsi
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x1ba7d
movq %r15, %rdi
callq 0x1bd66
addq $0x2818, %rsp           # imm = 0x2818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_buffered_writer::write(char, char, char)
void write(char_t d0, char_t d1, char_t d2)
		{
			size_t offset = bufsize;
			if (offset > bufcapacity - 3) offset = flush();

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movq 0x2808(%rdi), %rax
cmpq $0x7fe, %rax            # imm = 0x7FE
jb 0x1d83f
movq %rbx, %rdi
callq 0x1bd66
xorl %eax, %eax
movb %r15b, (%rbx,%rax)
movb %r14b, 0x1(%rbx,%rax)
movb %bpl, 0x2(%rbx,%rax)
addq $0x3, %rax
movq %rax, 0x2808(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x2808(%rdi), %rbx
movb (%r15), %al
testb %al, %al
je 0x1d898
cmpq $0x7ff, %rbx            # imm = 0x7FF
ja 0x1d898
incq %r15
movb %al, (%r14,%rbx)
incq %rbx
jmp 0x1d87c
cmpq $0x7ff, %rbx            # imm = 0x7FF
ja 0x1d8b7
movq %rbx, 0x2808(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2808(%r14), %rbp
movq %rbx, %rsi
subq %rbp, %rsi
movq %rbp, %rdi
subq %rbx, %rdi
addq %r15, %rdi
callq 0x24ded
movq %rax, %r12
leaq (%rax,%rbp), %r13
movq %r13, 0x2808(%r14)
subq %rbx, %r13
addq %r15, %r13
movq %r15, %rdi
callq 0x6260
subq %r12, %rax
subq %rbp, %rax
addq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24d1c
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_buffered_writer::write(char, char)
void write(char_t d0, char_t d1)
		{
			size_t offset = bufsize;
			if (offset > bufcapacity - 2) offset = flush();

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x2808(%rdi), %rax
cmpq $0x7ff, %rax            # imm = 0x7FF
jb 0x1d939
movq %rbx, %rdi
callq 0x1bd66
xorl %eax, %eax
movb %r14b, (%rbx,%rax)
movb %bpl, 0x1(%rbx,%rax)
addq $0x2, %rax
movq %rax, 0x2808(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_buffered_writer::write(char)
void write(char_t d0)
		{
			size_t offset = bufsize;
			if (offset > bufcapacity - 1) offset = flush();

			buffer[offset + 0] = d0;
			bufsize = offset + 1;
		}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x2808(%rdi), %rax
cmpq $0x800, %rax            # imm = 0x800
jb 0x1d973
movq %rbx, %rdi
callq 0x1bd66
xorl %eax, %eax
movb %bpl, (%rbx,%rax)
incq %rax
movq %rax, 0x2808(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1da9a
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x25100(%rip), %rax     # 0x42b78
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, 0x8(%rsi)
callq 0x1d73a
movq %rbx, %rdi
callq 0x6540
testl %eax, %eax
sete %al
addq $0x10, %rsp
popq %rbx
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1db4d
addq $0x20, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1db4b
movl (%rax), %ecx
andl $0xf, %ecx
cmpl $0x2, %ecx
je 0x1db4b
addq $0x30, %rax
jmp 0x1db33
popq %rcx
retq
leaq 0xea07(%rip), %rdi      # 0x2c55b
leaq 0xe3da(%rip), %rsi      # 0x2bf35
leaq 0xebdd(%rip), %rcx      # 0x2c73f
movl $0x1c24, %edx           # imm = 0x1C24
callq 0x6100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x25567
movq %rax, %r12
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6280
testq %r12, %r12
je 0x1dc0b
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2556c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6890
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x3
popq %rax
movq %rdx, %rcx
movq %rsi, %rdi
movq %rdi, %rdx
movq %rax, %rdi
xorl %esi, %esi
leaq (%rcx,%rsi), %r8
movq %r8, %r10
subq $0x1, %r10
jb 0x1de2c
movzbl -0x3(%rdx,%rdi), %r9d
testb %r9b, %r9b
jns 0x1dd95
testq %r10, %r10
je 0x1dd14
movl %r9d, %r10d
andl $-0x20, %r10d
cmpl $0xc0, %r10d
jne 0x1dd14
movb -0x2(%rdx,%rdi), %r10b
andb $-0x40, %r10b
negb %r10b
jo 0x1dde1
cmpq $0x3, %r8
jb 0x1dd4a
movl %r9d, %r10d
andl $-0x10, %r10d
cmpl $0xe0, %r10d
jne 0x1dd4a
movb -0x2(%rdx,%rdi), %r10b
andb $-0x40, %r10b
negb %r10b
jno 0x1dd4a
movb -0x1(%rdx,%rdi), %r10b
andb $-0x40, %r10b
negb %r10b
jo 0x1ddfa
cmpq $0x4, %r8
jb 0x1dd8a
andl $-0x8, %r9d
cmpl $0xf0, %r9d
jne 0x1dd8a
movb -0x2(%rdx,%rdi), %r8b
andb $-0x40, %r8b
negb %r8b
jno 0x1dd8a
movb -0x1(%rdx,%rdi), %r8b
andb $-0x40, %r8b
negb %r8b
jno 0x1dd8a
movb (%rdx,%rdi), %r8b
andb $-0x40, %r8b
negb %r8b
jo 0x1de13
decq %rsi
incq %rdi
jmp 0x1dccd
incq %r14
movq %rdx, %rdi
subq %rsi, %rdi
incq %rdi
addq %rsi, %rcx
decq %rcx
cmpq $0x4, %rcx
jb 0x1dcc5
subl %esi, %edx
incl %edx
andl $0x3, %edx
jne 0x1dcc5
testl $0x80808080, (%rdi)     # imm = 0x80808080
jne 0x1dcc5
addq $0x4, %r14
addq $0x4, %rdi
addq $-0x4, %rcx
cmpq $0x3, %rcx
ja 0x1ddbe
jmp 0x1dcc5
incq %r14
subq %rsi, %rdx
addq $0x2, %rdx
addq %rsi, %rcx
addq $-0x2, %rcx
movq %rdx, %rdi
jmp 0x1dcc5
incq %r14
subq %rsi, %rdx
addq $0x3, %rdx
addq %rsi, %rcx
addq $-0x3, %rcx
movq %rdx, %rdi
jmp 0x1dcc5
incq %r14
subq %rsi, %rdx
addq $0x4, %rdx
addq %rsi, %rcx
addq $-0x4, %rcx
movq %rdx, %rdi
jmp 0x1dcc5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
andl $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67f0
testq %r14, %r14
je 0x1de6d
movq (%rbx), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x25356
leaq (,%r14,4), %rcx
addq %r13, %rcx
cmpq %rax, %rcx
jne 0x1de7a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xfb48(%rip), %rdi      # 0x2d9c9
leaq 0xe0ad(%rip), %rsi      # 0x2bf35
leaq 0xfb50(%rip), %rcx      # 0x2d9df
movl $0x91a, %edx            # imm = 0x91A
callq 0x6100
movq %rax, %r14
movq %rbx, %rdi
callq 0x6160
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1e080
movl %ecx, %ebx
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r14
movq %rdx, %r15
subq %rsi, %r15
cmpq $0x10, %r15
ja 0x1e031
movq 0x18(%r14), %rdi
leaq 0x8(%r14), %r12
cmpq %r12, %rdi
je 0x1e020
callq *0x25840(%rip)          # 0x43860
cmpq %rbp, %r13
je 0x1e063
movups (%r13), %xmm0
movups %xmm0, (%r12)
jmp 0x1e063
movq %r15, %rdi
callq *0x2582e(%rip)          # 0x43868
testq %rax, %rax
je 0x1e09f
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6080
movq 0x18(%r14), %rdi
leaq 0x8(%r14), %rax
cmpq %rax, %rdi
je 0x1e063
callq *0x257fd(%rip)          # 0x43860
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 0xe7a5(%rip), %rdi      # 0x2c82c
leaq 0xdea7(%rip), %rsi      # 0x2bf35
leaq 0xe7a6(%rip), %rcx      # 0x2c83b
movl $0x2eeb, %edx           # imm = 0x2EEB
callq 0x6100
pushq $0x8
popq %rdi
callq 0x6250
movq 0x24eda(%rip), %rcx     # 0x42f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x24edc(%rip), %rsi     # 0x42f98
movq 0x24ea5(%rip), %rdx     # 0x42f68
movq %rax, %rdi
callq 0x6440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andl $0x0, (%rsi)
movq %rax, 0x18(%rsi)
movq %rax, 0x20(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
incl %ecx
testl %edx, %edx
jne 0x1e2fe
movq %r14, %rax
subq %r15, %rax
pushq $0x1
popq %rbp
cmpq $0x11, %rax
jl 0x1e2fe
movl %ecx, 0xc(%rsp)
leaq 0x10(%r15), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x257d0
movl %eax, %r12d
leaq 0x10(%rbx), %r13
cmpq %r14, %r13
jae 0x1e2f1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x257d0
movq %r13, %rbx
cmpb %al, %r12b
je 0x1e2c8
movq %r15, %rdi
movq %r14, %rsi
callq 0x255b3
jmp 0x1e2fa
movzbl %r12b, %eax
pushq $0x2
popq %rbp
subl %eax, %ebp
movl 0xc(%rsp), %ecx
cmpl %ecx, %ebp
jne 0x1e313
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rax
subq %r15, %rax
addq $-0x10, %r14
cmpq $0x11, %rax
jl 0x1e302
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r15
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r14)
addq $-0x20, %rax
jmp 0x1e319
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1e3a2
movq %rsi, %rbx
cmpl $0x2, %edx
je 0x1e3a8
movq %rdi, %r14
cmpl $0x1, %edx
je 0x1e39c
testl %edx, %edx
jne 0x1e3bc
leaq 0x10(%r14), %r15
cmpq %rbx, %r15
je 0x1e39c
movq %r15, %rdi
movq %r14, %rsi
callq 0x257d0
movq %r15, %rcx
testb %al, %al
jne 0x1e393
movq %r14, %rcx
addq $0x10, %r15
movq %rcx, %r14
jmp 0x1e379
leaq 0x8(%r14), %rbx
jmp 0x1e3b0
xorl %eax, %eax
xorl %edx, %edx
jmp 0x1e3b6
leaq -0x10(%rbx), %r14
addq $-0x8, %rbx
movq (%r14), %rax
movq (%rbx), %rdx
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf6fb(%rip), %rdi      # 0x2dabe
leaq 0xdb6b(%rip), %rsi      # 0x2bf35
leaq 0xf70e(%rip), %rcx      # 0x2dadf
movl $0x223a, %edx           # imm = 0x223A
callq 0x6100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1e519
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x18462
movq %rax, %r12
incq %r12
movq %r12, %rdi
callq *0x2537c(%rip)          # 0x43868
testq %rax, %rax
je 0x1e51c
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6080
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1e511
callq *0x2534f(%rip)          # 0x43860
movq %r15, 0x10(%rbx)
movb $0x1, %al
jmp 0x1e51e
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::hash_string(char const*)
PUGI__FN PUGI__UNSIGNED_OVERFLOW unsigned int hash_string(const char_t* str)
	{
		// Jenkins one-at-a-time hash (http://en.wikipedia.org/wiki/Jenkins_hash_function#one-at-a-time)
		unsigned int result = 0;

		while (*str)
		{
			result += static_cast<unsigned int>(*str++);
			result += result << 10;
			result ^= result >> 6;
		}

		result += result << 3;
		result ^= result >> 11;
		result += result << 15;

		return result;
	}

// Assembly:
xorl %eax, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x1e868
incq %rdi
addl %ecx, %eax
imull $0x401, %eax, %ecx      # imm = 0x401
movl %ecx, %eax
shrl $0x6, %eax
xorl %ecx, %eax
jmp 0x1e84d
leal (%rax,%rax,8), %eax
movl %eax, %ecx
shrl $0xb, %ecx
xorl %eax, %ecx
imull $0x8001, %ecx, %eax     # imm = 0x8001
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1e9a8
movq %rsi, %rbx
leaq 0xcf4d(%rip), %rax      # 0x2b7e0
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x18462
testq %rax, %rax
je 0x1e9a8
movq %rax, %r15
leaq 0x40(%rax), %rdi
callq *0x24fae(%rip)          # 0x43868
testq %rax, %rax
je 0x1e9a8
movq %rax, %r14
movl $0x1, (%rax)
andq $0x0, 0x8(%rax)
andl $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 0x1e998
movq %rbx, %rdi
callq 0x18462
testq %rax, %rax
je 0x1e9a8
movq %rax, %r15
leaq 0x20(%rax), %rdi
callq *0x24f55(%rip)          # 0x43868
testq %rax, %rax
je 0x1e9a8
movq %rax, %r14
movl $0x3, (%rax)
jmp 0x1e989
movq %rbx, %rdi
callq 0x18462
testq %rax, %rax
je 0x1e9a8
movq %rax, %r15
leaq 0x18(%rax), %rdi
callq *0x24f27(%rip)          # 0x43868
testq %rax, %rax
je 0x1e9a8
movq %rax, %r14
movl $0x4, (%rax)
andq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rax, %rdi
addq $0x11, %rdi
jmp 0x1e998
movq %rbx, %rdi
callq 0x18462
testq %rax, %rax
je 0x1e9a8
movq %rax, %r15
leaq 0x20(%rax), %rdi
callq *0x24eed(%rip)          # 0x43868
testq %rax, %rax
je 0x1e9a8
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 0x6080
jmp 0x1e9ab
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1e84b
andl $0x3f, %eax
leaq (%r15,%rax,8), %r12
movq %r12, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x1e9fb
movq %r15, %rdi
callq 0x1e40e
movq %rax, %rdi
movq %r14, %rsi
callq 0x1888f
testb %al, %al
jne 0x1ea18
addq $0x8, %r15
jmp 0x1e9d6
movl %ebx, %edi
movq %r14, %rsi
callq 0x1e879
testq %rax, %rax
je 0x1ea23
movq (%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r12)
jmp 0x1ea25
xorl %eax, %eax
cmpl %ebx, (%r15)
cmoveq %r15, %rax
jmp 0x1ea25
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f127
movups (%rsi), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
pushq $0x1
popq %rcx
movq %rcx, 0x10(%rsi)
leaq 0x2088(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rdi, -0x40(%rdx)
andq $0x0, -0x38(%rdx)
movq %rdx, -0x30(%rdx)
leaq 0x2060(%rsp), %r8
leaq 0x1038(%rsp), %r9
movq %r9, (%r8)
andq $0x0, 0x8(%r8)
movq %rdx, 0x10(%r8)
movb $0x0, 0x28(%r8)
andq $0x0, (%r9)
movq %rcx, 0x18(%rsi)
andq $0x0, (%rdi)
leaq 0x2048(%rsp), %rcx
movl $0x1000, %edx           # imm = 0x1000
movq %rdx, 0x8(%r9)
movq %rdx, 0x8(%rdi)
leaq 0x2078(%rsp), %rdx
movq %rcx, (%rdx)
movq %r8, 0x8(%rdx)
movq (%rax), %rdi
callq 0x1f176
cmpb $0x1, 0x2088(%rsp)
je 0x1f134
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x1fe80
jmp 0x1f129
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x2090, %rsp           # imm = 0x2090
popq %rbx
retq
pushq $0x8
popq %rdi
callq 0x6250
movq 0x23e45(%rip), %rcx     # 0x42f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x23e47(%rip), %rsi     # 0x42f98
movq 0x23e10(%rip), %rdx     # 0x42f68
movq %rax, %rdi
callq 0x6440
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1fe80
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ff65
movups (%rsi), %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
pushq $0x1
popq %rcx
movq %rcx, 0x10(%rsi)
leaq 0x2098(%rsp), %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, -0x40(%rdx)
andq $0x0, -0x38(%rdx)
movq %rdx, -0x30(%rdx)
leaq 0x2070(%rsp), %r8
leaq 0x1048(%rsp), %r9
movq %r9, (%r8)
andq $0x0, 0x8(%r8)
movq %rdx, 0x10(%r8)
movb $0x0, 0x28(%r8)
andq $0x0, (%r9)
movq %rcx, 0x18(%rsi)
andq $0x0, (%rdi)
leaq 0x2058(%rsp), %rcx
movl $0x1000, %edx           # imm = 0x1000
movq %rdx, 0x8(%r9)
movq %rdx, 0x8(%rdi)
leaq 0x2088(%rsp), %rdx
movq %rcx, (%rdx)
movq %r8, 0x8(%rdx)
movq (%rax), %rdi
callq 0x1ffb8
movsd %xmm0, 0x8(%rsp)
cmpb $0x1, 0x2098(%rsp)
je 0x1ff76
leaq 0x38(%rsp), %rdi
callq 0x1fe80
movsd 0x8(%rsp), %xmm0
jmp 0x1ff6d
movsd 0xb823(%rip), %xmm0     # 0x2b790
addq $0x20a0, %rsp           # imm = 0x20A0
popq %rbx
retq
pushq $0x8
popq %rdi
callq 0x6250
movq 0x23003(%rip), %rcx     # 0x42f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x23005(%rip), %rsi     # 0x42f98
movq 0x22fce(%rip), %rdx     # 0x42f68
movq %rax, %rdi
callq 0x6440
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1fe80
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x205fe
movups (%rdx), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
pushq $0x1
popq %rcx
movq %rcx, 0x10(%rdx)
leaq 0x20a0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, -0x40(%rsi)
andq $0x0, -0x38(%rsi)
movq %rsi, -0x30(%rsi)
leaq 0x2078(%rsp), %r8
leaq 0x1050(%rsp), %r9
movq %r9, (%r8)
andq $0x0, 0x8(%r8)
movq %rsi, 0x10(%r8)
movb $0x0, 0x28(%r8)
andq $0x0, (%r9)
movq %rcx, 0x18(%rdx)
andq $0x0, (%rdi)
leaq 0x2060(%rsp), %rsi
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r9)
movq %rcx, 0x8(%rdi)
leaq 0x2090(%rsp), %rcx
movq %rsi, (%rcx)
movq %r8, 0x8(%rcx)
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x20660
cmpb $0x1, 0x20a0(%rsp)
je 0x2061c
leaq 0x8(%rsp), %rdi
movq (%rdi), %r14
callq 0x214ba
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2938a
leaq 0x40(%rsp), %rdi
callq 0x1fe80
jmp 0x2060e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x20a8, %rsp           # imm = 0x20A8
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x6250
movq 0x2295d(%rip), %rcx     # 0x42f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x2295f(%rip), %rsi     # 0x42f98
movq 0x22928(%rip), %rdx     # 0x42f68
movq %rax, %rdi
callq 0x6440
jmp 0x2064a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1fe80
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x1
popq %rax
movq %rax, 0x30(%rsp)
leaq 0x20a8(%rsp), %rcx
leaq 0x48(%rsp), %rdx
movq %rdx, -0x40(%rcx)
andq $0x0, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
leaq 0x2080(%rsp), %rsi
leaq 0x1058(%rsp), %r8
movq %r8, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movb $0x0, 0x28(%rsi)
andq $0x0, (%r8)
movq %rax, 0x38(%rsp)
andq $0x0, (%rdx)
leaq 0x2068(%rsp), %rax
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r8)
movq %rcx, 0x8(%rdx)
movq %rax, 0x18(%rsi)
movq %rsi, 0x20(%rsi)
movq (%rdi), %rax
testq %rax, %rax
je 0x215ac
leaq 0x2098(%rsp), %rcx
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x20660
testb $0x1, 0x20a8(%rsp)
je 0x215c3
pushq $0x8
popq %rdi
callq 0x6250
movq 0x219f9(%rip), %rcx     # 0x42f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x219fb(%rip), %rsi     # 0x42f98
movq 0x219c4(%rip), %rdx     # 0x42f68
movq %rax, %rdi
callq 0x6440
leaq 0x8b56(%rip), %rax      # 0x2a109
movq %rax, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x214ba
movq %rax, %r15
incq %r15
testq %rbx, %rbx
je 0x215fb
testq %r15, %r15
je 0x21615
cmpq %rbx, %r15
cmovbq %r15, %rbx
movq 0x8(%rsp), %rsi
leaq -0x1(%rbx), %rdx
movq %r14, %rdi
callq 0x6080
movb $0x0, -0x1(%r14,%rbx)
leaq 0x48(%rsp), %rdi
callq 0x1fe80
movq %r15, %rax
addq $0x20b0, %rsp           # imm = 0x20B0
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb31b(%rip), %rdi      # 0x2c937
leaq 0xa912(%rip), %rsi      # 0x2bf35
leaq 0xb316(%rip), %rcx      # 0x2c940
movl $0x3149, %edx           # imm = 0x3149
callq 0x6100
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1fe80
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21787
testq %rax, %rax
je 0x21722
movups (%r14), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
pushq $0x1
popq %rcx
leaq 0x20a0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, -0x40(%rsi)
andq $0x0, -0x38(%rsi)
movq %rsi, -0x30(%rsi)
leaq 0x2078(%rsp), %r8
leaq 0x1050(%rsp), %r9
movq %r9, (%r8)
andq $0x0, 0x8(%r8)
movq %rsi, 0x10(%r8)
movb $0x0, 0x28(%r8)
andq $0x0, (%r9)
movq %rcx, 0x10(%rdx)
andq $0x0, (%rdi)
movq %rcx, 0x18(%rdx)
leaq 0x2060(%rsp), %rsi
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r9)
movq %rcx, 0x8(%rdi)
leaq 0x2090(%rsp), %rcx
movq %rsi, (%rcx)
movq %r8, 0x8(%rcx)
movq %rsp, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x217e0
cmpb $0x1, 0x20a0(%rsp)
je 0x21746
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl (%rsp), %ecx
movq %rbx, %rdi
callq 0x1e122
leaq 0x40(%rsp), %rdi
callq 0x1fe80
jmp 0x21738
andl $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
pushq $0x8
popq %rdi
callq 0x6250
movq 0x21833(%rip), %rcx     # 0x42f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x21835(%rip), %rsi     # 0x42f98
movq 0x217fe(%rip), %rdx     # 0x42f68
movq %rax, %rdi
callq 0x6440
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1fe80
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21796
movq (%rdi), %rax
cmpb $0x1, 0x1(%rax)
jne 0x21799
retq
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, 0x8(%rbx)
leaq 0xd5fe(%rip), %rax      # 0x2edaf
movq %rax, (%rbx)
pushq $0x18
popq %rdi
callq 0x6250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1dee4
leaq 0x21447(%rip), %rsi     # 0x42c18
movq 0x21788(%rip), %rdx     # 0x42f60
movq %r14, %rdi
callq 0x6440
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21787
testq %rax, %rax
je 0x225d0
movups (%rbx), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
pushq $0x1
popq %rcx
leaq 0x20a0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, -0x40(%rsi)
andq $0x0, -0x38(%rsi)
movq %rsi, -0x30(%rsi)
leaq 0x2078(%rsp), %r8
leaq 0x1050(%rsp), %r9
movq %r9, (%r8)
andq $0x0, 0x8(%r8)
movq %rsi, 0x10(%r8)
movb $0x0, 0x28(%r8)
andq $0x0, (%r9)
movq %rcx, 0x10(%rdx)
andq $0x0, (%rdi)
movq %rcx, 0x18(%rdx)
leaq 0x2060(%rsp), %rsi
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r9)
movq %rcx, 0x8(%rdi)
leaq 0x2090(%rsp), %rcx
movq %rsi, (%rcx)
movq %r8, 0x8(%rcx)
movq %rsp, %rdi
pushq $0x2
popq %r8
movq %rax, %rsi
callq 0x217e0
cmpb $0x1, 0x20a0(%rsp)
je 0x225e6
movq %rsp, %rdi
callq 0x22628
movq %rax, %rbx
movq %rdx, %r14
leaq 0x40(%rsp), %rdi
callq 0x1fe80
jmp 0x225d5
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rbx, %rax
movq %r14, %rdx
addq $0x20a8, %rsp           # imm = 0x20A8
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x6250
movq 0x20993(%rip), %rcx     # 0x42f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20995(%rip), %rsi     # 0x42f98
movq 0x2095e(%rip), %rdx     # 0x42f68
movq %rax, %rdi
callq 0x6440
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1fe80
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22ad0
movq %rdx, %r15
movq %rsi, %r14
movq (%rsi), %rax
testq %rdx, %rax
jne 0x22ad0
movq %rcx, %rbx
testq %rcx, %rcx
je 0x22ac4
movq %rdi, %r12
testq %r9, %r9
je 0x22a8e
testq %r15, (%r8)
je 0x22ab5
movq %rbx, %rdi
callq 0x6260
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 0x1824c
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 0x9fdc(%rip), %rdi      # 0x2cab3
leaq 0x9457(%rip), %rsi      # 0x2bf35
leaq 0x9ff3(%rip), %rcx      # 0x2cad8
movl $0x111c, %edx           # imm = 0x111C
callq 0x6100