LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::offset_debug() const
PUGI__FN ptrdiff_t xml_node::offset_debug() const
	{
		if (!_root) return -1;

		impl::xml_document_struct& doc = impl::get_document(_root);

		// we can determine the offset reliably only if there is exactly once parse buffer
		if (!doc.buffer || doc.extra_buffers) return -1;

		switch (type())
		{
		case node_document:
			return 0;

		case node_element:
		case node_declaration:
		case node_pi:
			return _root->name && (_root->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0 ? _root->name - doc.buffer : -1;

		case node_pcdata:
		case node_cdata:
		case node_comment:
		case node_doctype:
			return _root->value && (_root->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0 ? _root->value - doc.buffer : -1;

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

// Assembly:
movq (%rdi), %rsi
movq $-0x1, %rax
testq %rsi, %rsi
je 0x21a20
movq (%rsi), %rdx
movq %rdx, %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rsi,%rcx), %rdi
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x21a20
cmpq $0x0, 0x18(%rdi)
jne 0x21a20
movl %edx, %edi
andl $0xf, %edi
cmpl $0x8, %edi
ja 0x21a29
movl $0x138, %r8d            # imm = 0x138
btl %edi, %r8d
jb 0x21a04
movl $0xc4, %r8d
btl %edi, %r8d
jae 0x21a21
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x60, %dl
jmp 0x21a12
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x50, %dl
setne %dl
orb %dil, %dl
jne 0x21a20
subq %rcx, %rsi
movq %rsi, %rax
retq
cmpl $0x1, %edi
jne 0x21a29
xorl %eax, %eax
retq
pushq %rax
leaq 0x1066d(%rip), %rdi     # 0x3209e
leaq 0x104ed(%rip), %rsi     # 0x31f25
leaq 0x1067c(%rip), %rcx     # 0x320bb
movl $0x18b1, %edx           # imm = 0x18B1
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_text::_data() const
PUGI__FN xml_node_struct* xml_text::_data() const
	{
		if (!_root || impl::is_text_node(_root)) return _root;

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

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

		return 0;
	}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x21a92
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
addl $-0x3, %edx
cmpl $0x2, %edx
jb 0x21a75
andl $0xf, %ecx
cmpl $0x2, %ecx
jne 0x21a76
cmpq $0x0, 0x10(%rax)
je 0x21a76
retq
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x21a92
movl (%rax), %ecx
andl $0xf, %ecx
addl $-0x3, %ecx
cmpl $0x2, %ecx
jb 0x21a75
movq 0x30(%rax), %rax
jmp 0x21a7a
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22395
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2237a
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2237a
movq 0x28(%rax), %rax
movq %rax, (%rbx)
testq %rax, %rax
je 0x22381
movq 0x8(%rax), %rax
testq %rax, %rax
leaq 0xdd95(%rip), %rdi      # 0x30109
cmovneq %rax, %rdi
jmp 0x22388
movq $0x0, (%rbx)
leaq 0xdd81(%rip), %rdi      # 0x30109
movq 0x10(%rbx), %rsi
callq 0x1d7f1
testb %al, %al
jne 0x223a4
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x1d8c0
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
testq %rax, %rax
je 0x2254b
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x224d1
callq *0x2438a(%rip)          # 0x46850
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movq 0x58(%rax), %r14
testq %r14, %r14
je 0x224f4
movq (%r14), %rdi
testq %rdi, %rdi
je 0x224e8
callq *0x24368(%rip)          # 0x46850
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x224da
movq (%rbx), %rax
movq (%rax), %rcx
shrq $0x8, %rcx
movq %rcx, %rdx
negq %rdx
cmpq $0x0, 0x8(%rax,%rdx)
jne 0x2256a
subq %rcx, %rax
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jb 0x22589
leaq 0xd0(%rbx), %rcx
cmpq %rcx, %rax
jae 0x22589
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x2253c
movq 0x10(%rdi), %r14
callq *0x2431c(%rip)          # 0x46850
movq %r14, %rdi
testq %r14, %r14
jne 0x2252a
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xfff9(%rip), %rdi      # 0x3254b
leaq 0xf9cc(%rip), %rsi      # 0x31f25
leaq 0x10014(%rip), %rcx     # 0x32574
movl $0x1b0c, %edx           # imm = 0x1B0C
callq 0x6120
leaq 0x10027(%rip), %rdi     # 0x32598
leaq 0xf9ad(%rip), %rsi      # 0x31f25
leaq 0xfff5(%rip), %rcx      # 0x32574
movl $0x1b1d, %edx           # imm = 0x1B1D
callq 0x6120
leaq 0x10026(%rip), %rdi     # 0x325b6
leaq 0xf98e(%rip), %rsi      # 0x31f25
leaq 0xffd6(%rip), %rcx      # 0x32574
movl $0x1b1e, %edx           # imm = 0x1B1E
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::load_file(char const*, unsigned int, pugi::xml_encoding)
PUGI__FN xml_parse_result xml_document::load_file(const char* path_, unsigned int options, xml_encoding encoding)
	{
		reset();

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x224a4
movq %r12, %rdi
callq 0x22414
leaq 0xf5c6(%rip), %rsi      # 0x326fe
movq %r14, %rdi
callq 0x6830
movq %rax, %r14
movq (%r12), %rsi
addq $0x8, %r12
movq %rbx, %rdi
movq %rax, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
movq %r12, %r9
callq 0x23190
testq %r14, %r14
je 0x2316c
movq %r14, %rdi
callq 0x62a0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x23188
movq %r14, %rdi
callq 0x62a0
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23237
movq %r9, %r14
movl %r8d, %r12d
movl %ecx, %r15d
movq %rdx, %rbp
movq %rsi, 0x8(%rsp)
movq %rdx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x6810
movq %rbp, %rdi
callq 0x6170
movq %rax, %r13
movq %rbp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6810
testq %r13, %r13
js 0x2325e
movl %r15d, 0x4(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x1(%r13), %r14
movq %r14, %rdi
callq *0x2365b(%rip)          # 0x46858
testq %rax, %rax
je 0x23246
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x63a0
cmpq %r13, %rax
jne 0x23255
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x28861
cmpl $0x1, %eax
jne 0x23282
movb $0x0, (%r15,%r13)
jmp 0x23285
movl $0x0, 0x10(%rbx)
movl $0x1, (%rbx)
jmp 0x2326b
movl $0x0, 0x10(%rbx)
movl $0x3, (%rbx)
jmp 0x2326b
movq %r15, %rdi
callq *0x235f2(%rip)          # 0x46850
movl $0x0, 0x10(%rbx)
movl $0x2, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r14
movq 0x8(%rsp), %rdx
movl $0x1, %r10d
movq %rbx, %rdi
movq %rdx, %rsi
movq %r15, %rcx
movq %r14, %r8
movl 0x4(%rsp), %r9d
pushq 0x10(%rsp)
pushq %r10
pushq %r10
pushq %rax
callq 0x1f7a0
addq $0x38, %rsp
jmp 0x23277
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_document::load_file(wchar_t const*, unsigned int, pugi::xml_encoding)
PUGI__FN xml_parse_result xml_document::load_file(const wchar_t* path_, unsigned int options, xml_encoding encoding)
	{
		reset();

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x224a4
movq %r12, %rdi
callq 0x22414
leaq 0x12388(%rip), %rsi     # 0x3566c
movq %r14, %rdi
callq 0x2333c
movq %rax, %r14
movq (%r12), %rsi
addq $0x8, %r12
movq %rbx, %rdi
movq %rax, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
movq %r12, %r9
callq 0x23190
testq %r14, %r14
je 0x23318
movq %r14, %rdi
callq 0x62a0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x23334
movq %r14, %rdi
callq 0x62a0
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23433
movq %rsi, %rbx
movq %rdi, %r14
movq $-0x4, %rax
cmpl $0x0, 0x4(%r14,%rax)
leaq 0x4(%rax), %rax
jne 0x2335f
movq %rax, %r15
sarq $0x2, %r15
testq %rax, %rax
je 0x233b9
xorl %eax, %eax
movl $0x1, %ecx
xorl %r12d, %r12d
movl (%r14,%rax,4), %edx
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x233ab
cmpl $0x800, %edx            # imm = 0x800
movl $0x3, %esi
sbbq $0x0, %rsi
cmpl $0x80, %edx
cmovbq %rcx, %rsi
addq %rsi, %r12
jmp 0x233af
addq $0x4, %r12
incq %rax
cmpq %rax, %r15
jne 0x23381
jmp 0x233bc
xorl %r12d, %r12d
leaq 0x1(%r12), %rdi
callq *0x23491(%rip)          # 0x46858
testq %rax, %rax
je 0x23420
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2a26d
movb $0x0, (%r13,%r12)
movl $0x0, 0xc(%rsp)
movl (%rbx), %eax
testl %eax, %eax
je 0x23405
xorl %ecx, %ecx
movb %al, 0xc(%rsp,%rcx)
movl 0x4(%rbx,%rcx,4), %eax
incq %rcx
testl %eax, %eax
jne 0x233f6
leaq 0xc(%rsp), %rsi
movq %r13, %rdi
callq 0x6830
movq %rax, %rbx
movq %r13, %rdi
callq *0x23432(%rip)          # 0x46850
jmp 0x23422
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xf32b(%rip), %rdi      # 0x32765
leaq 0xeae4(%rip), %rsi      # 0x31f25
leaq 0x1042e(%rip), %rcx     # 0x33876
movl $0x1367, %edx           # imm = 0x1367
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, 0x2800(%rsp)
movq $0x0, 0x2808(%rsp)
movl %r8d, %eax
cmpl $0x8, %r8d
ja 0x2356f
movl $0x191, %eax            # imm = 0x191
btl %ebp, %eax
movl %ebp, %eax
jae 0x2356f
movl %ebp, %eax
leaq 0xe988(%rip), %rcx      # 0x31ef4
movl (%rcx,%rax,4), %eax
movl %eax, 0x2810(%rsp)
testb $0x2, %bl
sete %al
cmpl $0x9, %ebp
sete %cl
orb %al, %cl
jne 0x2359d
movw $0xbbef, (%rsp)         # imm = 0xBBEF
movb $-0x41, 0x2(%rsp)
movq $0x3, 0x2808(%rsp)
testb $0x8, %bl
jne 0x23649
movq (%r15), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x235cb
movl (%rax), %ecx
andl $0xf, %ecx
cmpl $0x2, %ecx
je 0x235cb
cmpl $0x7, %ecx
je 0x23649
movq 0x30(%rax), %rax
jmp 0x235ad
leaq 0xf12f(%rip), %rsi      # 0x32701
movq %rsp, %rdi
callq 0x23680
cmpl $0x9, %ebp
jne 0x235ee
leaq 0xf12f(%rip), %rsi      # 0x32715
movq %rsp, %rdi
callq 0x23680
movq 0x2808(%rsp), %rax
cmpq $0x7ff, %rax            # imm = 0x7FF
jb 0x2360e
movq %rsp, %rdi
movq %rdi, %rsi
movq %rax, %rdx
callq 0x29c16
xorl %eax, %eax
movw $0x3e3f, (%rsp,%rax)    # imm = 0x3E3F
leaq 0x2(%rax), %rdx
movq %rdx, 0x2808(%rsp)
testb $0x4, %bl
jne 0x23649
cmpq $0x7fe, %rax            # imm = 0x7FE
jb 0x2363a
movq %rsp, %rdi
movq %rdi, %rsi
callq 0x29c16
xorl %edx, %edx
movb $0xa, (%rsp,%rdx)
incq %rdx
movq %rdx, 0x2808(%rsp)
movq (%r15), %rsi
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x21520
movq 0x2808(%r15), %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x29c16
addq $0x2818, %rsp           # imm = 0x2818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_buffered_writer::write_string(char const*)
void write_string(const char_t* data)
		{
			// write the part of the string that fits in the buffer
			size_t offset = bufsize;

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

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

				bufsize = offset - extra;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2808(%rdi), %rcx
movb (%rsi), %dl
testb %dl, %dl
setne %al
cmpq $0x800, %rcx            # imm = 0x800
setb %dil
andb %dil, %al
cmpb $0x1, %al
jne 0x236d2
leaq 0x1(%rcx), %rax
movb %dl, (%rbx,%rcx)
movb 0x1(%rsi), %dl
incq %rsi
cmpq $0x7ff, %rcx            # imm = 0x7FF
setb %dil
testb %dl, %dl
je 0x236d5
cmpq $0x7ff, %rcx            # imm = 0x7FF
movq %rax, %rcx
jb 0x236a8
jmp 0x236d5
movq %rcx, %rax
testb %dil, %dil
je 0x236e7
movq %rax, 0x2808(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
subq 0x2808(%rbx), %r14
cmpq $0x5, %r14
jae 0x236fb
xorl %ecx, %ecx
jmp 0x2371d
movq $-0x1, %rcx
movb (%rsi,%rcx), %dl
andb $-0x40, %dl
negb %dl
jno 0x2371a
decq %rcx
cmpq $-0x5, %rcx
jne 0x23702
movq %r14, %rcx
jmp 0x2371d
addq %r14, %rcx
subq %rcx, %r14
subq %r14, %rax
movq %rax, 0x2808(%rbx)
movq %rsi, %r15
subq %r14, %r15
movq %rsi, %rdi
callq 0x6270
addq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x29b26
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2385c
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x2232e(%rip), %rax     # 0x45b68
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, 0x8(%rsi)
callq 0x23522
movq %rbx, %rdi
callq 0x6520
testl %eax, %eax
sete %al
addq $0x10, %rsp
popq %rbx
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23904
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x23900
movl (%rax), %ecx
andl $0xf, %ecx
cmpl $0x2, %ecx
je 0x23902
movq 0x30(%rax), %rax
jmp 0x238eb
xorl %eax, %eax
popq %rcx
retq
leaq 0xec40(%rip), %rdi      # 0x3254b
leaq 0xe613(%rip), %rsi      # 0x31f25
leaq 0xee16(%rip), %rcx      # 0x3272f
movl $0x1c24, %edx           # imm = 0x1C24
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::as_utf8_impl[abi:cxx11](wchar_t const*, unsigned long)
PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
	{
		// first pass: get length in utf8 characters
		size_t size = as_utf8_begin(str, length);

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

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

		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x239c7
xorl %eax, %eax
movl $0x1, %ecx
xorl %r12d, %r12d
movl (%r15,%rax,4), %edx
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x239b9
cmpl $0x800, %edx            # imm = 0x800
movl $0x3, %esi
sbbq $0x0, %rsi
cmpl $0x80, %edx
cmovbq %rcx, %rsi
addq %rsi, %r12
jmp 0x239bd
addq $0x4, %r12
incq %rax
cmpq %rax, %rbx
jne 0x2398f
jmp 0x239ca
xorl %r12d, %r12d
leaq 0x10(%r14), %r13
movq %r13, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x6480
testq %r12, %r12
je 0x23a0a
movq (%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a26d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x23a24
callq 0x63b0
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x23bb1
movq %r15, %rax
movq %rbx, %rcx
movzbl (%rax), %edx
testb %dl, %dl
js 0x23aff
incq %r12
incq %rax
decq %rcx
cmpq $0x4, %rcx
jb 0x23ba8
movl %eax, %edx
andl $0x3, %edx
jne 0x23ba8
testl $0x80808080, (%rax)     # imm = 0x80808080
jne 0x23ba8
addq $0x4, %r12
addq $0x4, %rax
addq $-0x4, %rcx
cmpq $0x3, %rcx
ja 0x23adc
jmp 0x23ba8
cmpq $0x1, %rcx
je 0x23b2c
movl %edx, %esi
andl $-0x20, %esi
cmpl $0xc0, %esi
jne 0x23b2c
movb 0x1(%rax), %sil
andb $-0x40, %sil
negb %sil
jno 0x23b2c
incq %r12
addq $0x2, %rax
addq $-0x2, %rcx
jmp 0x23ba8
cmpq $0x3, %rcx
jb 0x23b66
movl %edx, %esi
andl $-0x10, %esi
cmpl $0xe0, %esi
jne 0x23b66
movb 0x1(%rax), %sil
andb $-0x40, %sil
negb %sil
jno 0x23b66
movb 0x2(%rax), %sil
andb $-0x40, %sil
negb %sil
jno 0x23b66
incq %r12
addq $0x3, %rax
addq $-0x3, %rcx
jmp 0x23ba8
cmpq $0x4, %rcx
jb 0x23ba2
andl $-0x8, %edx
cmpl $0xf0, %edx
jne 0x23ba2
movb 0x1(%rax), %dl
andb $-0x40, %dl
negb %dl
jno 0x23ba2
movb 0x2(%rax), %dl
andb $-0x40, %dl
negb %dl
jno 0x23ba2
movb 0x3(%rax), %dl
andb $-0x40, %dl
negb %dl
jno 0x23ba2
incq %r12
addq $0x4, %rax
addq $-0x4, %rcx
jmp 0x23ba8
incq %rax
decq %rcx
testq %rcx, %rcx
jne 0x23ab7
leaq 0x10(%r14), %r13
movq %r13, (%r14)
movq $0x0, 0x8(%r14)
movl $0x0, 0x10(%r14)
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x65b0
testq %r12, %r12
je 0x23bf4
movq (%r14), %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2a0ce
leaq (%r14,%r12,4), %rcx
cmpq %rax, %rcx
jne 0x23bfe
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xfd2e(%rip), %rdi      # 0x33933
leaq 0xe319(%rip), %rsi      # 0x31f25
leaq 0xfd36(%rip), %rcx      # 0x33949
movl $0x91a, %edx            # imm = 0x91A
callq 0x6120
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x23c2d
callq 0x63b0
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23e0c
movl %ecx, %ebx
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r14
movq %rdx, %r15
subq %rsi, %r15
cmpq $0x10, %r15
ja 0x23dbd
movq 0x18(%r14), %rdi
leaq 0x8(%r14), %r12
cmpq %r12, %rdi
je 0x23dac
callq *0x22aa4(%rip)          # 0x46850
cmpq %rbp, %r13
je 0x23def
movups (%r13), %xmm0
movups %xmm0, (%r12)
jmp 0x23def
movq %r15, %rdi
callq *0x22a92(%rip)          # 0x46858
testq %rax, %rax
je 0x23e2b
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6090
movq 0x18(%r14), %rdi
leaq 0x8(%r14), %rax
cmpq %rax, %rdi
je 0x23def
callq *0x22a61(%rip)          # 0x46850
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 0xea09(%rip), %rdi      # 0x3281c
leaq 0xe10b(%rip), %rsi      # 0x31f25
leaq 0xea0a(%rip), %rcx      # 0x3282b
movl $0x2eeb, %edx           # imm = 0x2EEB
callq 0x6120
movl $0x8, %edi
callq 0x6260
movq 0x2213c(%rip), %rcx     # 0x45f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x2213e(%rip), %rsi     # 0x45f88
movq 0x22107(%rip), %rdx     # 0x45f58
movq %rax, %rdi
callq 0x6420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %ecx, %eax
movq %rsi, %r14
movq %rdi, %r15
incl %eax
movq %rsi, %rbx
subq %rdi, %rbx
testl %edx, %edx
jne 0x24108
cmpq $0x11, %rbx
jl 0x24148
movl %eax, 0xc(%rsp)
leaq 0x10(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a52e
movl %eax, %ebp
leaq 0x10(%r12), %r13
cmpq %r14, %r13
jae 0x240f9
movq %r12, %rdi
movq %r13, %rsi
callq 0x2a52e
movq %r13, %r12
cmpb %al, %bpl
je 0x240ca
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a315
movl $0x1, %edx
jmp 0x24104
movzbl %bpl, %eax
movl $0x2, %edx
subl %eax, %edx
movl 0xc(%rsp), %eax
cmpl %eax, %edx
sete %dl
cmpq $0x11, %rbx
setl %cl
orb %dl, %cl
jne 0x24148
addq $-0x10, %r14
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, %rbx
addq $-0x10, %r14
cmpq $0x10, %rbx
jg 0x2411c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::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 0x2418b
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x2419b
cmpl $0x2, %edx
je 0x24191
cmpl $0x1, %edx
jne 0x241dd
leaq 0x8(%r14), %rbx
jmp 0x241d1
xorl %edx, %edx
xorl %eax, %eax
jmp 0x241d7
leaq -0x10(%rbx), %r14
addq $-0x8, %rbx
jmp 0x241d1
leaq 0x10(%r14), %r15
cmpq %rbx, %r15
je 0x241c7
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a52e
movq %r15, %rcx
testb %al, %al
jne 0x241b9
movq %r14, %rcx
addq $0x10, %r15
movq %rcx, %r14
cmpq %rbx, %r15
jne 0x241a4
jmp 0x241ca
movq %r14, %rcx
leaq 0x8(%rcx), %rbx
movq %rcx, %r14
movq (%r14), %rax
movq (%rbx), %rdx
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf844(%rip), %rdi      # 0x33a28
leaq 0xdd3a(%rip), %rsi      # 0x31f25
leaq 0xf857(%rip), %rcx      # 0x33a49
movl $0x223a, %edx           # imm = 0x223A
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24341
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1d379
movq %rax, %r12
incq %r12
movq %r12, %rdi
callq *0x22544(%rip)          # 0x46858
testq %rax, %rax
je 0x24344
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6090
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x24339
callq *0x22517(%rip)          # 0x46850
movq %r15, 0x10(%rbx)
movb $0x1, %al
jmp 0x24346
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_O3/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 0x2481e
movq %rsi, %rbx
leaq 0xd0d0(%rip), %rax      # 0x317d0
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x1d379
testq %rax, %rax
je 0x2481e
movq %rax, %r15
leaq 0x40(%rax), %rdi
callq *0x22131(%rip)          # 0x46858
testq %rax, %rax
je 0x2481e
movq %rax, %r14
movl $0x1, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
addq $0x18, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %rax, 0x28(%r14)
movq %rax, 0x30(%r14)
movq %r14, %rdi
addq $0x38, %rdi
jmp 0x2480e
movq %rbx, %rdi
callq 0x1d379
testq %rax, %rax
je 0x2481e
movq %rax, %r15
leaq 0x20(%rax), %rdi
callq *0x220d2(%rip)          # 0x46858
testq %rax, %rax
je 0x2481e
movq %rax, %r14
movl $0x3, (%rax)
jmp 0x247ff
movq %rbx, %rdi
callq 0x1d379
testq %rax, %rax
je 0x2481e
movq %rax, %r15
leaq 0x18(%rax), %rdi
callq *0x220a4(%rip)          # 0x46858
testq %rax, %rax
je 0x2481e
movq %rax, %r14
movl $0x4, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rax, %rdi
addq $0x11, %rdi
jmp 0x2480e
movq %rbx, %rdi
callq 0x1d379
testq %rax, %rax
je 0x2481e
movq %rax, %r15
leaq 0x20(%rax), %rdi
callq *0x22067(%rip)          # 0x46858
testq %rax, %rax
je 0x2481e
movq %rax, %r14
movl $0x2, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %r14, %rdi
addq $0x18, %rdi
incq %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6090
jmp 0x24821
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_variable_set::add(char const*, pugi::xpath_value_type)
PUGI__FN xpath_variable* xpath_variable_set::add(const char_t* name, xpath_value_type type)
	{
		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
		size_t hash = impl::hash_string(name) % hash_size;

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

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

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

			_data[hash] = result;
		}

		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %dl
testb %dl, %dl
je 0x24867
leaq 0x1(%r14), %rax
xorl %ecx, %ecx
movsbl %dl, %edx
addl %ecx, %edx
movl %edx, %esi
shll $0xa, %esi
addl %edx, %esi
movl %esi, %ecx
shrl $0x6, %ecx
xorl %esi, %ecx
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0x24846
leal (%rcx,%rcx,8), %eax
jmp 0x24869
xorl %eax, %eax
movl %eax, %r12d
shrl $0xb, %r12d
xorl %eax, %r12d
andl $0x3f, %r12d
movq (%rbx,%r12,8), %r15
testq %r15, %r15
je 0x2489d
movq %r15, %rdi
callq 0x24236
movq %rax, %rdi
movq %r14, %rsi
callq 0x1d7f1
testb %al, %al
jne 0x248ba
movq 0x8(%r15), %r15
jmp 0x2487b
movl %ebp, %edi
movq %r14, %rsi
callq 0x246e6
testq %rax, %rax
je 0x248c5
movq (%rbx,%r12,8), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx,%r12,8)
jmp 0x248c7
xorl %eax, %eax
cmpl %ebp, (%r15)
cmoveq %r15, %rax
jmp 0x248c7
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25074
movups (%rsi), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x1, %ecx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
leaq 0x2048(%rsp), %rcx
leaq 0x2088(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rdi, -0x40(%rdx)
xorl %r8d, %r8d
movq %r8, -0x38(%rdx)
movq %rdx, -0x30(%rdx)
leaq 0x2060(%rsp), %r9
leaq 0x1038(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rdx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %edx           # imm = 0x1000
movq %rdx, 0x8(%r10)
movq %rdx, 0x8(%rdi)
leaq 0x2078(%rsp), %rdx
movq %rcx, (%rdx)
movq %r9, 0x8(%rdx)
movq (%rax), %rdi
callq 0x250c4
cmpb $0x1, 0x2088(%rsp)
je 0x25081
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x25e86
jmp 0x25076
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x2090, %rsp           # imm = 0x2090
popq %rbx
retq
movl $0x8, %edi
callq 0x6260
movq 0x20ee6(%rip), %rcx     # 0x45f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20ee8(%rip), %rsi     # 0x45f88
movq 0x20eb1(%rip), %rdx     # 0x45f58
movq %rax, %rdi
callq 0x6420
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x25e86
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25f68
movups (%rsi), %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x1, %ecx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
leaq 0x2058(%rsp), %rcx
leaq 0x2098(%rsp), %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, -0x40(%rdx)
xorl %r8d, %r8d
movq %r8, -0x38(%rdx)
movq %rdx, -0x30(%rdx)
leaq 0x2070(%rsp), %r9
leaq 0x1048(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rdx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %edx           # imm = 0x1000
movq %rdx, 0x8(%r10)
movq %rdx, 0x8(%rdi)
leaq 0x2088(%rsp), %rdx
movq %rcx, (%rdx)
movq %r9, 0x8(%rdx)
movq (%rax), %rdi
callq 0x25fbc
movsd %xmm0, 0x8(%rsp)
cmpb $0x1, 0x2098(%rsp)
je 0x25f79
leaq 0x38(%rsp), %rdi
callq 0x25e86
movsd 0x8(%rsp), %xmm0
jmp 0x25f70
movsd 0xb810(%rip), %xmm0     # 0x31780
addq $0x20a0, %rsp           # imm = 0x20A0
popq %rbx
retq
movl $0x8, %edi
callq 0x6260
movq 0x1ffee(%rip), %rcx     # 0x45f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1fff0(%rip), %rsi     # 0x45f88
movq 0x1ffb9(%rip), %rdx     # 0x45f58
movq %rax, %rdi
callq 0x6420
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x25e86
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2661d
movups (%rdx), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movl $0x1, %ecx
movq %rcx, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
leaq 0x2060(%rsp), %rsi
leaq 0x20a0(%rsp), %rcx
leaq 0x40(%rsp), %rdi
movq %rdi, -0x40(%rcx)
xorl %r8d, %r8d
movq %r8, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
leaq 0x2078(%rsp), %r9
leaq 0x1050(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rcx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r10)
movq %rcx, 0x8(%rdi)
leaq 0x2090(%rsp), %rcx
movq %rsi, (%rcx)
movq %r9, 0x8(%rcx)
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x266b0
cmpb $0x1, 0x20a0(%rsp)
je 0x2666a
movq 0x8(%rsp), %r14
cmpb $0x1, 0x10(%rsp)
jne 0x26632
movq 0x18(%rsp), %rdx
jmp 0x2663d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x2665c
movq %r14, %rdi
callq 0x1d379
movq %rax, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa246
leaq 0x40(%rsp), %rdi
callq 0x25e86
movq %rbx, %rax
addq $0x20a8, %rsp           # imm = 0x20A8
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x6260
movq 0x1f8fd(%rip), %rcx     # 0x45f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1f8ff(%rip), %rsi     # 0x45f88
movq 0x1f8c8(%rip), %rdx     # 0x45f58
movq %rax, %rdi
callq 0x6420
jmp 0x2669a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x25e86
movq %rbx, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_query::evaluate_string(char*, unsigned long, pugi::xpath_node const&) const
PUGI__FN size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const
	{
		impl::xpath_context c(n, 1, 1);
		impl::xpath_stack_data sd;

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

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

		size_t full_size = r.length() + 1;

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

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

		return full_size;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20b0, %rsp           # imm = 0x20B0
movq %rdx, %rbx
movq %rsi, %r14
movups (%rcx), %xmm0
movaps %xmm0, 0x20(%rsp)
movl $0x1, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
leaq 0x2068(%rsp), %rax
leaq 0x20a8(%rsp), %rcx
leaq 0x48(%rsp), %rdx
movq %rdx, -0x40(%rcx)
xorl %esi, %esi
movq %rsi, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
leaq 0x2080(%rsp), %r8
leaq 0x1058(%rsp), %r9
movq %r9, (%r8)
movq %rsi, 0x8(%r8)
movq %rcx, 0x10(%r8)
movb $0x0, 0x28(%r8)
movq %rsi, (%r9)
movq %rsi, (%rdx)
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r9)
movq %rcx, 0x8(%rdx)
movq %rax, 0x18(%r8)
movq %r8, 0x20(%r8)
movq (%rdi), %rax
testq %rax, %rax
je 0x2776d
leaq 0x2098(%rsp), %rcx
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x266b0
testb $0x1, 0x20a8(%rsp)
je 0x27787
movl $0x8, %edi
callq 0x6260
movq 0x1e828(%rip), %rcx     # 0x45f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1e82a(%rip), %rsi     # 0x45f88
movq 0x1e7f3(%rip), %rdx     # 0x45f58
movq %rax, %rdi
callq 0x6420
leaq 0x8995(%rip), %rax      # 0x30109
movq %rax, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
cmpb $0x1, 0x10(%rsp)
jne 0x27795
movq 0x18(%rsp), %r15
jmp 0x277a2
movq 0x8(%rsp), %rdi
callq 0x1d379
movq %rax, %r15
incq %r15
testq %rbx, %rbx
je 0x277cd
testq %r15, %r15
je 0x277e7
cmpq %rbx, %r15
cmovbq %r15, %rbx
movq 0x8(%rsp), %rsi
leaq -0x1(%rbx), %rdx
movq %r14, %rdi
callq 0x6090
movb $0x0, -0x1(%r14,%rbx)
leaq 0x48(%rsp), %rdi
callq 0x25e86
movq %r15, %rax
addq $0x20b0, %rsp           # imm = 0x20B0
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb139(%rip), %rdi      # 0x32927
leaq 0xa730(%rip), %rsi      # 0x31f25
leaq 0xb134(%rip), %rcx      # 0x32930
movl $0x3149, %edx           # imm = 0x3149
callq 0x6120
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x25e86
movq %rbx, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27978
testq %rax, %rax
je 0x2790e
movups (%r14), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movl $0x1, %ecx
movq %rcx, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
leaq 0x2060(%rsp), %rsi
leaq 0x20a0(%rsp), %rcx
leaq 0x40(%rsp), %rdi
movq %rdi, -0x40(%rcx)
xorl %r8d, %r8d
movq %r8, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
leaq 0x2078(%rsp), %r9
leaq 0x1050(%rsp), %r10
movq %r10, (%r9)
movq %r8, 0x8(%r9)
movq %rcx, 0x10(%r9)
movb $0x0, 0x28(%r9)
movq %r8, (%r10)
movq %r8, (%rdi)
movl $0x1000, %ecx           # imm = 0x1000
movq %rcx, 0x8(%r10)
movq %rcx, 0x8(%rdi)
leaq 0x2090(%rsp), %rcx
movq %rsi, (%rcx)
movq %r9, 0x8(%rcx)
movq %rsp, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x279d6
cmpb $0x1, 0x20a0(%rsp)
je 0x27935
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl (%rsp), %ecx
movl $0x0, (%rbx)
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x23d6e
leaq 0x40(%rsp), %rdi
callq 0x25e86
jmp 0x27927
movl $0x0, (%rbx)
leaq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x20a8, %rsp           # imm = 0x20A8
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x6260
movq 0x1e632(%rip), %rcx     # 0x45f78
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1e634(%rip), %rsi     # 0x45f88
movq 0x1e5fd(%rip), %rdx     # 0x45f58
movq %rax, %rdi
callq 0x6420
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x25e86
movq %rbx, %rdi
callq 0x6430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27987
movq (%rdi), %rax
cmpb $0x1, 0x1(%rax)
jne 0x2798a
retq
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, 0x8(%rbx)
leaq 0xd207(%rip), %rax      # 0x34bac
movq %rax, (%rbx)
movl $0x18, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x23c6c
leaq 0x1e241(%rip), %rsi     # 0x45c08
movq 0x1e582(%rip), %rdx     # 0x45f50
movq %r14, %rdi
callq 0x6420