LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_parse_result pugi::impl::(anonymous namespace)::load_stream_impl<char>(pugi::impl::(anonymous namespace)::xml_document_struct*, std::basic_istream<char, std::char_traits<char>>&, unsigned int, pugi::xml_encoding, char**)
PUGI__FN xml_parse_result load_stream_impl(xml_document_struct* doc, std::basic_istream<T>& stream, unsigned int options, xml_encoding encoding, char_t** out_buffer)
	{
		void* buffer = 0;
		size_t size = 0;
		xml_parse_status status = status_ok;

		// if stream has an error bit set, bail out (otherwise tellg() can fail and we'll clear error bits)
		if (stream.fail()) return make_parse_result(status_io_error);

		// load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
		if (stream.tellg() < 0)
		{
			stream.clear(); // clear error flags that could be set by a failing tellg
			status = load_stream_data_noseek(stream, &buffer, &size);
		}
		else
			status = load_stream_data_seek(stream, &buffer, &size);

		if (status != status_ok) return make_parse_result(status);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x79a0
testb $0x1, %al
jne 0x48023
jmp 0x4803a
movq -0x60(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x44e10
jmp 0x48126
movq -0x10(%rbp), %rdi
callq 0x7130
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x68770
cmpq $0x0, %rax
jge 0x48082
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x7a70
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x676f0
movl %eax, -0x34(%rbp)
jmp 0x48096
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x67a10
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x480ae
movq -0x60(%rbp), %rdi
movl -0x34(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x44e10
jmp 0x48126
movl -0x18(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x500c0
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x4c(%rbp), %edx
callq 0x58f60
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq %rax, %r8
movl -0x14(%rbp), %r9d
movl -0x4c(%rbp), %r10d
movq -0x20(%rbp), %rax
movl %r10d, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x44f00
movq -0x58(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x48584
movq -0x60(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x44e10
jmp 0x486af
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x58ed0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x485b7
movq -0x60(%rbp), %rdi
movl -0x2c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x44e10
jmp 0x486af
movq $0x1, -0x38(%rbp)
movq 0x4d422(%rip), %rax     # 0x959e8
movq -0x28(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x485f2
movq -0x60(%rbp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x44e10
jmp 0x486af
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x7530
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x48637
movq 0x4d3c3(%rip), %rax     # 0x959e0
movq -0x40(%rbp), %rdi
callq *%rax
movq -0x60(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x44e10
jmp 0x486af
movl -0x18(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x500c0
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x4c(%rbp), %edx
callq 0x58f60
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq %rax, %r8
movl -0x14(%rbp), %r9d
movl -0x4c(%rbp), %r10d
movq -0x20(%rbp), %rax
movl %r10d, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x44f00
movq -0x58(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::open_file_wide(wchar_t const*, wchar_t const*)
PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
	{
		// there is no standard function to open wide paths, so our best bet is to try utf8 path
		char* path_utf8 = convert_path_heap(path);
		if (!path_utf8) return 0;

		// convert mode to ASCII (we mirror _wfopen interface)
		char mode_ascii[4] = {0};
		for (size_t i = 0; mode[i]; ++i) mode_ascii[i] = static_cast<char>(mode[i]);

		// try to open the utf8 path
		FILE* result = fopen(path_utf8, mode_ascii);

		// free dummy buffer
		xml_memory::deallocate(path_utf8);

		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58fa0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x487de
movq $0x0, -0x8(%rbp)
jmp 0x4884d
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x72b0
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x48827
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, -0x24(%rbp,%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x487f6
movq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x7b50
movq %rax, -0x38(%rbp)
movq 0x4d1a1(%rip), %rax     # 0x959e0
movq -0x20(%rbp), %rdi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x2840, %rsp           # imm = 0x2840
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2840(%rbp)
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
leaq -0x2838(%rbp), %rdi
callq 0x45a40
movl -0x1c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x489c8
cmpl $0x9, -0x20(%rbp)
je 0x489c8
leaq -0x2838(%rbp), %rdi
movl $0xffffffef, %esi       # imm = 0xFFFFFFEF
movl $0xffffffbb, %edx       # imm = 0xFFFFFFBB
movl $0xffffffbf, %ecx       # imm = 0xFFFFFFBF
callq 0x48a80
movl -0x1c(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x48a46
movq -0x2840(%rbp), %rax
movq (%rax), %rdi
callq 0x48b00
testb $0x1, %al
jne 0x48a46
leaq -0x2838(%rbp), %rdi
leaq 0x2319d(%rip), %rsi     # 0x6bb91
callq 0x48b60
cmpl $0x9, -0x20(%rbp)
jne 0x48a12
leaq -0x2838(%rbp), %rdi
leaq 0x23198(%rip), %rsi     # 0x6bba5
callq 0x48b60
leaq -0x2838(%rbp), %rdi
movl $0x3f, %esi
movl $0x3e, %edx
callq 0x48c80
movl -0x1c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x48a44
leaq -0x2838(%rbp), %rdi
movl $0xa, %esi
callq 0x48cf0
jmp 0x48a46
movq -0x2840(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x2838(%rbp), %rdi
xorl %r8d, %r8d
callq 0x45a90
leaq -0x2838(%rbp), %rdi
callq 0x45d50
addq $0x2840, %rsp           # imm = 0x2840
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x2808(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x7fd, -0x18(%rbp)     # imm = 0x7FD
jbe 0x48ac6
movq -0x20(%rbp), %rdi
callq 0x45d50
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movb -0x9(%rbp), %dl
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0xa(%rbp), %dl
movq -0x18(%rbp), %rcx
movb %dl, 0x1(%rax,%rcx)
movb -0xb(%rbp), %dl
movq -0x18(%rbp), %rcx
movb %dl, 0x2(%rax,%rcx)
movq -0x18(%rbp), %rcx
addq $0x3, %rcx
movq %rcx, 0x2808(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::has_declaration(pugi::xml_node_struct*)
PUGI__FN bool has_declaration(xml_node_struct* node)
	{
		for (xml_node_struct* child = node->first_child; child; child = child->next_sibling)
		{
			xml_node_type type = PUGI__NODETYPE(child);

			if (type == node_declaration) return true;
			if (type == node_element) return false;
		}

		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x48b51
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0xf, %rax
movl %eax, -0x1c(%rbp)
cmpl $0x7, -0x1c(%rbp)
jne 0x48b35
movb $0x1, -0x1(%rbp)
jmp 0x48b55
cmpl $0x2, -0x1c(%rbp)
jne 0x48b41
movb $0x0, -0x1(%rbp)
jmp 0x48b55
jmp 0x48b43
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x48b14
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x2808(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x48b9f
cmpq $0x800, -0x18(%rbp)     # imm = 0x800
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x48ba8
jmp 0x48bd1
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb (%rcx), %dl
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x48b83
cmpq $0x800, -0x18(%rbp)     # imm = 0x800
jae 0x48bef
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x2808(%rax)
jmp 0x48c6f
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq 0x2808(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
subq -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x58050
movq -0x48(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
subq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
subq -0x28(%rbp), %rcx
movq %rcx, 0x2808(%rax)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
subq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x418f0
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
addq -0x28(%rbp), %rdx
callq 0x57f10
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x2808(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x7fe, -0x18(%rbp)     # imm = 0x7FE
jbe 0x48cc1
movq -0x20(%rbp), %rdi
callq 0x45d50
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movb -0x9(%rbp), %dl
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0xa(%rbp), %dl
movq -0x18(%rbp), %rcx
movb %dl, 0x1(%rax,%rcx)
movq -0x18(%rbp), %rcx
addq $0x2, %rcx
movq %rcx, 0x2808(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x2808(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x7ff, -0x18(%rbp)     # imm = 0x7FF
jbe 0x48d2c
movq -0x20(%rbp), %rdi
callq 0x45d50
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movb -0x9(%rbp), %dl
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, 0x2808(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x48f28
movb $0x0, -0x1(%rbp)
jmp 0x48f89
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x40690
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
callq 0x48960
jmp 0x48f53
movq -0x18(%rbp), %rdi
callq 0x7700
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x686a0
jmp 0x48f89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x686a0
jmp 0x48f94
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7600
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x4906c
jmp 0x4908b
leaq 0x22908(%rip), %rdi     # 0x6b97b
leaq 0x222db(%rip), %rsi     # 0x6b355
movl $0x1c24, %edx           # imm = 0x1C24
leaq 0x22b39(%rip), %rcx     # 0x6bbbf
callq 0x7180
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x490d0
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0xf, %rax
cmpl $0x2, %eax
jne 0x490c0
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x41c10
jmp 0x490d9
jmp 0x490c2
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4909a
leaq -0x8(%rbp), %rdi
callq 0x41bf0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59050
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x7320
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x73c0
jmp 0x491ac
cmpq $0x0, -0x20(%rbp)
jbe 0x491f6
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7ab0
movq %rax, -0x50(%rbp)
jmp 0x491c6
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x59080
jmp 0x491dd
jmp 0x491f6
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x7b88
jmp 0x49213
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x49209
movq -0x40(%rbp), %rdi
callq 0x7b88
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x7600
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::strlength_wide(wchar_t const*)
PUGI__FN size_t strlength_wide(const wchar_t* s)
	{
		assert(s);

	#ifdef PUGIXML_WCHAR_MODE
		return wcslen(s);
	#else
		const wchar_t* end = s;
		while (*end) end++;
		return static_cast<size_t>(end - s);
	#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x49235
jmp 0x49254
leaq 0x2367a(%rip), %rdi     # 0x6c8b6
leaq 0x22112(%rip), %rsi     # 0x6b355
movl $0xf8, %edx
leaq 0x23dfa(%rip), %rcx     # 0x6d049
callq 0x7180
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x49273
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x4925c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x59150
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
movb $0x0, -0x2a(%rbp)
callq 0x7650
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7a90
jmp 0x493ab
cmpq $0x0, -0x28(%rbp)
jbe 0x4943d
movq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7960
movq %rax, -0x70(%rbp)
jmp 0x493c9
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x587e0
movq %rax, -0x78(%rbp)
jmp 0x493e8
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
cmpq -0x50(%rbp), %rax
jne 0x49407
jmp 0x4943d
leaq 0x23c85(%rip), %rdi     # 0x6d093
leaq 0x21f40(%rip), %rsi     # 0x6b355
movl $0x91a, %edx            # imm = 0x91A
leaq 0x23c88(%rip), %rcx     # 0x6d0a9
callq 0x7180
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x7810
jmp 0x4945d
movb $0x1, -0x2a(%rbp)
testb $0x1, -0x2a(%rbp)
jne 0x49450
movq -0x60(%rbp), %rdi
callq 0x7810
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7600
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x498db
jmp 0x498fa
leaq 0x223ca(%rip), %rdi     # 0x6bcac
leaq 0x21a6c(%rip), %rsi     # 0x6b355
movl $0x2eeb, %edx           # imm = 0x2EEB
leaq 0x223c6(%rip), %rcx     # 0x6bcbb
callq 0x7180
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
ja 0x49986
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rax
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x49936
movq -0x38(%rbp), %rcx
movq 0x4c0b0(%rip), %rax     # 0x959e0
movq 0x18(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x49957
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x18(%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x49a2a
movq 0x4c05b(%rip), %rax     # 0x959e8
movq -0x28(%rbp), %rdi
shlq $0x4, %rdi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x499cf
movl $0x8, %edi
callq 0x7380
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x68640
movq -0x40(%rbp), %rdi
movq 0x4b5cd(%rip), %rsi     # 0x94f90
movq 0x4b58e(%rip), %rdx     # 0x94f58
callq 0x75e0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
callq 0x70b0
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rax
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x49a06
movq -0x38(%rbp), %rcx
movq 0x4bfe0(%rip), %rax     # 0x959e0
movq 0x18(%rcx), %rdi
callq *%rax
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x49a83
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x49a8f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
movq -0x10(%rbp), %rsi
movq 0x18(%rsi), %rsi
subq %rsi, %rdx
sarq $0x4, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %dl
movl $0x1, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x49f5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x594a0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x49f56
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x21(%rbp), %rdx
callq 0x59570
movl $0x1, -0x14(%rbp)
jmp 0x49f5c
movl -0x20(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x49f5e
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x49f73
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x596a0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x49feb
leaq -0x10(%rbp), %rdi
callq 0x495c0
jmp 0x4a077
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x4a036
jmp 0x49ff7
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x4a00b
jmp 0x4a001
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x4a020
jmp 0x4a058
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a077
movq -0x20(%rbp), %rax
movq -0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq -0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a077
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x25(%rbp), %rdx
callq 0x5a130
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a077
leaq 0x231a4(%rip), %rdi     # 0x6d203
leaq 0x212ef(%rip), %rsi     # 0x6b355
movl $0x223a, %edx           # imm = 0x223A
leaq 0x231b2(%rip), %rcx     # 0x6d224
callq 0x7180
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_variable::name() const
PUGI__FN const char_t* xpath_variable::name() const
	{
		switch (_type)
		{
		case xpath_type_node_set:
			return static_cast<const impl::xpath_variable_node_set*>(this)->name;

		case xpath_type_number:
			return static_cast<const impl::xpath_variable_number*>(this)->name;

		case xpath_type_string:
			return static_cast<const impl::xpath_variable_string*>(this)->name;

		case xpath_type_boolean:
			return static_cast<const impl::xpath_variable_boolean*>(this)->name;

		default:
			assert(false && "Invalid variable type"); // unreachable
			return 0;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x4a19f
movq -0x18(%rbp), %rax
leaq 0x206d6(%rip), %rcx     # 0x6a834
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
jmp 0x4a1be
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x4a1be
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x4a1be
movq -0x20(%rbp), %rax
addq $0x11, %rax
movq %rax, -0x8(%rbp)
jmp 0x4a1be
leaq 0x21bbf(%rip), %rdi     # 0x6bd65
leaq 0x211a8(%rip), %rsi     # 0x6b355
movl $0x2f9f, %edx           # imm = 0x2F9F
leaq 0x21bcd(%rip), %rcx     # 0x6bd86
callq 0x7180
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x3, (%rax)
je 0x4a3b3
movb $0x0, -0x1(%rbp)
jmp 0x4a42b
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x418f0
addq $0x1, %rax
shlq $0x0, %rax
movq %rax, -0x28(%rbp)
movq 0x4b611(%rip), %rax     # 0x959e8
movq -0x28(%rbp), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4a3ee
movb $0x0, -0x1(%rbp)
jmp 0x4a42b
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x70b0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4a41b
movq 0x4b5cf(%rip), %rax     # 0x959e0
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4aa2a
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0xa, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x4a9ef
movl -0xc(%rbp), %eax
shll $0x3, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0xb, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0xf, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x4aacf
movq -0x20(%rbp), %rax
leaq 0x1fdba(%rip), %rcx     # 0x6a844
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x5a1a0
movq %rax, -0x8(%rbp)
jmp 0x4aad7
movq -0x18(%rbp), %rdi
callq 0x5a240
movq %rax, -0x8(%rbp)
jmp 0x4aad7
movq -0x18(%rbp), %rdi
callq 0x5a2e0
movq %rax, -0x8(%rbp)
jmp 0x4aad7
movq -0x18(%rbp), %rdi
callq 0x5a380
movq %rax, -0x8(%rbp)
jmp 0x4aad7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::copy_xpath_variable(pugi::xpath_variable*, pugi::xpath_variable const*)
PUGI__FN bool copy_xpath_variable(xpath_variable* lhs, const xpath_variable* rhs)
	{
		switch (rhs->type())
		{
		case xpath_type_node_set:
			return lhs->set(static_cast<const xpath_variable_node_set*>(rhs)->value);

		case xpath_type_number:
			return lhs->set(static_cast<const xpath_variable_number*>(rhs)->value);

		case xpath_type_string:
			return lhs->set(static_cast<const xpath_variable_string*>(rhs)->value);

		case xpath_type_boolean:
			return lhs->set(static_cast<const xpath_variable_boolean*>(rhs)->value);

		default:
			assert(false && "Invalid variable type"); // unreachable
			return false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a1d0
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x4ab8f
movq -0x20(%rbp), %rax
leaq 0x1fd33(%rip), %rcx     # 0x6a854
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x4a440
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4abae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x4a350
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4abae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4a390
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4abae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4a310
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4abae
leaq 0x211cf(%rip), %rdi     # 0x6bd65
leaq 0x207b8(%rip), %rsi     # 0x6b355
movl $0x21e3, %edx           # imm = 0x21E3
leaq 0x226f5(%rip), %rcx     # 0x6d29e
callq 0x7180
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::delete_xpath_variable(pugi::xpath_value_type, pugi::xpath_variable*)
PUGI__FN void delete_xpath_variable(xpath_value_type type, xpath_variable* var)
	{
		switch (type)
		{
		case xpath_type_node_set:
			delete_xpath_variable(static_cast<xpath_variable_node_set*>(var));
			break;

		case xpath_type_number:
			delete_xpath_variable(static_cast<xpath_variable_number*>(var));
			break;

		case xpath_type_string:
			delete_xpath_variable(static_cast<xpath_variable_string*>(var));
			break;

		case xpath_type_boolean:
			delete_xpath_variable(static_cast<xpath_variable_boolean*>(var));
			break;

		default:
			assert(false && "Invalid variable type"); // unreachable
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x4ac1f
movq -0x18(%rbp), %rax
leaq 0x1fc7a(%rip), %rcx     # 0x6a864
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x5a4f0
jmp 0x4ac3e
movq -0x10(%rbp), %rdi
callq 0x5a520
jmp 0x4ac3e
movq -0x10(%rbp), %rdi
callq 0x5a540
jmp 0x4ac3e
movq -0x10(%rbp), %rdi
callq 0x5a570
jmp 0x4ac3e
leaq 0x2113f(%rip), %rdi     # 0x6bd65
leaq 0x20728(%rip), %rsi     # 0x6b355
movl $0x21ce, %edx           # imm = 0x21CE
leaq 0x226cb(%rip), %rcx     # 0x6d304
callq 0x7180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x40, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a9e0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, %ecx
andq $0x3f, %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4acf4
movq -0x38(%rbp), %rdi
callq 0x4a130
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x4acba
jmp 0x4ace4
movq -0x38(%rbp), %rdi
callq 0x4a1d0
cmpl -0x1c(%rbp), %eax
jne 0x4acd2
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x4acda
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x4acda
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4ad33
jmp 0x4ace6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4ac98
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4aa60
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x4ad2b
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x40(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::optimize(pugi::impl::(anonymous namespace)::xpath_allocator*)
void optimize(xpath_allocator* alloc)
		{
			if (_left)
				_left->optimize(alloc);

			if (_right)
				_right->optimize(alloc);

			if (_next)
				_next->optimize(alloc);

			optimize_self(alloc);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x4b210
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4b1e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4b22c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4b1e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4b248
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4b1e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5df50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_query::xpath_query(pugi::xpath_query&&)
PUGI__FN xpath_query::xpath_query(xpath_query&& rhs) PUGIXML_NOEXCEPT
	{
		_impl = rhs._impl;
		_result = rhs._result;
		rhs._impl = 0;
		rhs._result = xpath_parse_result();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0x4a090
jmp 0x4b353
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movups 0x8(%rcx), %xmm0
movups %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x4a090
jmp 0x4b383
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb810
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20e0, %rsp           # imm = 0x20E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20c0(%rbp)
cmpq $0x0, (%rax)
jne 0x4b4dd
movb $0x0, -0x1(%rbp)
jmp 0x4b5aa
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x20d0(%rbp)
movl $0x1, %ecx
movq %rcx, %rdx
callq 0x4b5d0
leaq -0x20a0(%rbp), %rdi
callq 0x4b610
movq -0x20c0(%rbp), %rax
movq -0x20d0(%rbp), %rsi
movq (%rax), %rax
movq (%rax), %rdi
leaq -0x50(%rbp), %rdx
callq 0x4b6c0
movb %al, -0x20c1(%rbp)
jmp 0x4b52a
movb -0x20c1(%rbp), %al
andb $0x1, %al
movb %al, -0x20a1(%rbp)
testb $0x1, -0x40(%rbp)
je 0x4b593
movl $0x8, %edi
callq 0x7380
movq %rax, %rdi
movq %rdi, -0x20d8(%rbp)
callq 0x68640
movq -0x20d8(%rbp), %rdi
movq 0x49a2b(%rip), %rsi     # 0x94f90
movq 0x499ec(%rip), %rdx     # 0x94f58
callq 0x75e0
jmp 0x4b5c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20b0(%rbp)
movl %eax, -0x20b4(%rbp)
leaq -0x20a0(%rbp), %rdi
callq 0x4c030
jmp 0x4b5b8
movb -0x20a1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x20a0(%rbp), %rdi
callq 0x4c030
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20e0, %rsp           # imm = 0x20E0
popq %rbp
retq
movq -0x20b0(%rbp), %rdi
callq 0x7600
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_stack_data::xpath_stack_data()
xpath_stack_data(): result(blocks + 0, &oom), temp(blocks + 1, &oom), oom(false)
		{
			blocks[0].next = blocks[1].next = 0;
			blocks[0].capacity = blocks[1].capacity = sizeof(blocks[0].data);

			stack.result = &result;
			stack.temp = &temp;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
movq %rsi, %rdi
addq $0x2020, %rdi           # imm = 0x2020
movq %rsi, %rdx
addq $0x2060, %rdx           # imm = 0x2060
callq 0x5a650
movq -0x10(%rbp), %rdx
movq %rdx, %rdi
addq $0x2038, %rdi           # imm = 0x2038
movq %rdx, %rsi
addq $0x1010, %rsi           # imm = 0x1010
addq $0x2060, %rdx           # imm = 0x2060
callq 0x5a650
movq -0x10(%rbp), %rax
movb $0x0, 0x2060(%rax)
movq $0x0, 0x1010(%rax)
movq $0x0, (%rax)
movq $0x1000, 0x1018(%rax) # imm = 0x1000
movq $0x1000, 0x8(%rax)      # imm = 0x1000
movq %rax, %rcx
addq $0x2020, %rcx           # imm = 0x2020
movq %rcx, 0x2050(%rax)
movq %rax, %rcx
addq $0x2038, %rcx           # imm = 0x2038
movq %rcx, 0x2058(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)