LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: void pugi::impl::(anonymous namespace)::partition3<pugi::xpath_node, pugi::impl::(anonymous namespace)::document_order_comparator>(pugi::xpath_node*, pugi::xpath_node*, pugi::xpath_node, pugi::impl::(anonymous namespace)::document_order_comparator const&, pugi::xpath_node**, pugi::xpath_node**)
void partition3(T* begin, T* end, T pivot, const Pred& pred, T** out_eqbeg, T** out_eqend)
	{
		// invariant: array is split into 4 groups: = < ? > (each variable denotes the boundary between the groups)
		T* eq = begin;
		T* lt = begin;
		T* gt = end;

		while (lt < gt)
		{
			if (pred(*lt, pivot))
				lt++;
			else if (*lt == pivot)
				swap(*eq++, *lt++);
			else
				swap(*lt, *--gt);
		}

		// we now have just 4 groups: = < >; move equal elements to the middle
		T* eqbeg = gt;

		for (T* it = begin; it != eq; ++it)
			swap(*it, *--eqbeg);

		*out_eqbeg = eqbeg;
		*out_eqend = gt;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x59f5c
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x596f0
testb $0x1, %al
jne 0x59efd
jmp 0x59f0b
movq -0x40(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
jmp 0x59f5a
movq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x49800
testb $0x1, %al
jne 0x59f1e
jmp 0x59f43
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq %rsi, %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
callq 0x5a0e0
jmp 0x59f58
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $-0x10, %rsi
movq %rsi, -0x48(%rbp)
callq 0x5a0e0
jmp 0x59f5a
jmp 0x59edc
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x59f99
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $-0x10, %rsi
movq %rsi, -0x50(%rbp)
callq 0x5a0e0
movq -0x58(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
jmp 0x59f6c
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: void pugi::impl::(anonymous namespace)::insertion_sort<pugi::xpath_node, pugi::impl::(anonymous namespace)::document_order_comparator>(pugi::xpath_node*, pugi::xpath_node*, pugi::impl::(anonymous namespace)::document_order_comparator const&)
void insertion_sort(T* begin, T* end, const Pred& pred)
	{
		if (begin == end)
			return;

		for (T* it = begin + 1; it != end; ++it)
		{
			T val = *it;
			T* hole = it;

			// move hole backwards
			while (hole > begin && pred(val, *(hole - 1)))
			{
				*hole = *(hole - 1);
				hole--;
			}

			// fill hole with element
			*hole = val;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x59fe3
jmp 0x5a091
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x5a091
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x39(%rbp)
jbe 0x5a03f
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rdx
addq $-0x10, %rdx
leaq -0x30(%rbp), %rsi
callq 0x596f0
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5a048
jmp 0x5a06d
movq -0x38(%rbp), %rcx
movq -0x38(%rbp), %rax
movq -0x10(%rcx), %rdx
movq %rdx, (%rax)
movq -0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x38(%rbp)
jmp 0x5a018
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x59fef
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_node const* pugi::impl::(anonymous namespace)::min_element<pugi::xpath_node const*, pugi::impl::(anonymous namespace)::document_order_comparator>(pugi::xpath_node const*, pugi::xpath_node const*, pugi::impl::(anonymous namespace)::document_order_comparator const&)
I min_element(I begin, I end, const Pred& pred)
	{
		I result = begin;

		for (I it = begin + 1; it != end; ++it)
			if (pred(*it, *result))
				result = it;

		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x5a191
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x596f0
testb $0x1, %al
jne 0x5a179
jmp 0x5a181
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5a183
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x5a158
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_variable_node_set* pugi::impl::(anonymous namespace)::new_xpath_variable<pugi::impl::(anonymous namespace)::xpath_variable_node_set>(char const*)
PUGI__FN T* new_xpath_variable(const char_t* name)
	{
		size_t length = strlength(name);
		if (length == 0) return 0; // empty variable names are invalid

		// $$ we can't use offsetof(T, name) because T is non-POD, so we just allocate additional length characters
		void* memory = xml_memory::allocate(sizeof(T) + length * sizeof(char_t));
		if (!memory) return 0;

		T* result = new (memory) T();

		memcpy(result->name, name, (length + 1) * sizeof(char_t));

		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x418f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5a1ca
movq $0x0, -0x8(%rbp)
jmp 0x5a22e
movq 0x3b817(%rip), %rax     # 0x959e8
movq -0x18(%rbp), %rdi
shlq $0x0, %rdi
addq $0x40, %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5a1f4
movq $0x0, -0x8(%rbp)
jmp 0x5a22e
movq -0x20(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x5a420
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
callq 0x70b0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_allocator::release()
void release()
		{
			xpath_memory_block* cur = _root;
			assert(cur);

			while (cur->next)
			{
				xpath_memory_block* next = cur->next;

				xml_memory::deallocate(cur);

				cur = next;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5a6a0
jmp 0x5a6bf
leaq 0x12cbf(%rip), %rdi     # 0x6d366
leaq 0x10ca7(%rip), %rsi     # 0x6b355
movl $0x1db8, %edx           # imm = 0x1DB8
leaq 0x12cb0(%rip), %rcx     # 0x6d36a
callq 0x7180
jmp 0x5a6c1
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5a6ed
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x3b303(%rip), %rax     # 0x959e0
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5a6c1
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_parser::parse()
xpath_ast_node* parse()
		{
			xpath_ast_node* n = parse_expression();
			if (!n) return 0;

			// check if there are unparsed tokens left
			if (_lexer.current() != lex_eof)
				return error("Incorrect query");

			return n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
callq 0x5af10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5a790
movq $0x0, -0x8(%rbp)
jmp 0x5a7c0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x5af60
cmpl $0x1a, %eax
je 0x5a7b8
movq -0x20(%rbp), %rdi
leaq 0x12c00(%rip), %rsi     # 0x6d3ad
callq 0x5af80
movq %rax, -0x8(%rbp)
jmp 0x5a7c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_parser::parse_location_path()
xpath_ast_node* parse_location_path()
		{
			if (_lexer.current() == lex_slash)
			{
				_lexer.next();

				xpath_ast_node* n = alloc_node(ast_step_root, xpath_type_node_set);
				if (!n) return 0;

				// relative location path can start from axis_attribute, dot, double_dot, multiply and string lexemes; any other lexeme means standalone root path
				lexeme_t l = _lexer.current();

				if (l == lex_string || l == lex_axis_attribute || l == lex_dot || l == lex_double_dot || l == lex_multiply)
					return parse_relative_location_path(n);
				else
					return n;
			}
			else if (_lexer.current() == lex_double_slash)
			{
				_lexer.next();

				xpath_ast_node* n = alloc_node(ast_step_root, xpath_type_node_set);
				if (!n) return 0;

				n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
				if (!n) return 0;

				return parse_relative_location_path(n);
			}

			// else clause moved outside of if because of bogus warning 'control may reach end of non-void function being inlined' in gcc 4.0.1
			return parse_relative_location_path(0);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x5af60
cmpl $0x10, %eax
jne 0x5b557
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5a830
movq -0x30(%rbp), %rdi
movl $0x39, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x5ba30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5b506
movq $0x0, -0x8(%rbp)
jmp 0x5b607
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5af60
movl %eax, -0x1c(%rbp)
cmpl $0x14, -0x1c(%rbp)
je 0x5b534
cmpl $0x16, -0x1c(%rbp)
je 0x5b534
cmpl $0x17, -0x1c(%rbp)
je 0x5b534
cmpl $0x18, -0x1c(%rbp)
je 0x5b534
cmpl $0x9, -0x1c(%rbp)
jne 0x5b54a
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b920
movq %rax, -0x8(%rbp)
jmp 0x5b607
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5b607
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5af60
cmpl $0x11, %eax
jne 0x5b5f4
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5a830
movq -0x30(%rbp), %rdi
movl $0x39, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x5ba30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5b5aa
movq $0x0, -0x8(%rbp)
jmp 0x5b607
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x38, %esi
movl $0x5, %ecx
movl $0x2, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x5b8b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5b5e1
movq $0x0, -0x8(%rbp)
jmp 0x5b607
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5b920
movq %rax, -0x8(%rbp)
jmp 0x5b607
jmp 0x5b5f6
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5b920
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_parser::parse_node_test_type(pugi::impl::(anonymous namespace)::xpath_lexer_string const&)
nodetest_t parse_node_test_type(const xpath_lexer_string& name)
		{
			switch (name.begin[0])
			{
			case 'c':
				if (name == PUGIXML_TEXT("comment"))
					return nodetest_type_comment;

				break;

			case 'n':
				if (name == PUGIXML_TEXT("node"))
					return nodetest_type_node;

				break;

			case 'p':
				if (name == PUGIXML_TEXT("processing-instruction"))
					return nodetest_type_pi;

				break;

			case 't':
				if (name == PUGIXML_TEXT("text"))
					return nodetest_type_text;

				break;

			default:
				break;
			}

			return nodetest_none;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
addl $-0x63, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x11, %eax
ja 0x5b6e4
movq -0x20(%rbp), %rax
leaq 0xf7c5(%rip), %rcx      # 0x6ae1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
leaq 0x101cd(%rip), %rsi     # 0x6b838
callq 0x5baa0
testb $0x1, %al
jne 0x5b676
jmp 0x5b67f
movl $0x3, -0x4(%rbp)
jmp 0x5b6ed
jmp 0x5b6e6
movq -0x18(%rbp), %rdi
leaq 0x1151a(%rip), %rsi     # 0x6cba6
callq 0x5baa0
testb $0x1, %al
jne 0x5b697
jmp 0x5b6a0
movl $0x2, -0x4(%rbp)
jmp 0x5b6ed
jmp 0x5b6e6
movq -0x18(%rbp), %rdi
leaq 0x11d33(%rip), %rsi     # 0x6d3e0
callq 0x5baa0
testb $0x1, %al
jne 0x5b6b8
jmp 0x5b6c1
movl $0x4, -0x4(%rbp)
jmp 0x5b6ed
jmp 0x5b6e6
movq -0x18(%rbp), %rdi
leaq 0x11d29(%rip), %rsi     # 0x6d3f7
callq 0x5baa0
testb $0x1, %al
jne 0x5b6d9
jmp 0x5b6e2
movl $0x5, -0x4(%rbp)
jmp 0x5b6ed
jmp 0x5b6e6
jmp 0x5b6e6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_parser::parse_filter_expression()
xpath_ast_node* parse_filter_expression()
		{
			xpath_ast_node* n = parse_primary_expression();
			if (!n) return 0;

			while (_lexer.current() == lex_open_square_brace)
			{
				_lexer.next();

				if (n->rettype() != xpath_type_node_set)
					return error("Predicate has to be applied to node set");

				xpath_ast_node* expr = parse_expression();
				if (!expr) return 0;

				n = alloc_node(ast_filter, n, expr, predicate_default);
				if (!n) return 0;

				if (_lexer.current() != lex_close_square_brace)
					return error("Expected ']' to match an opening '['");

				_lexer.next();
			}

			return n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x5bae0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5b7c1
movq $0x0, -0x8(%rbp)
jmp 0x5b89d
jmp 0x5b7c3
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5af60
cmpl $0x12, %eax
jne 0x5b895
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5a830
movq -0x18(%rbp), %rdi
callq 0x4b490
cmpl $0x1, %eax
je 0x5b80d
movq -0x28(%rbp), %rdi
leaq 0x11cd1(%rip), %rsi     # 0x6d4d0
callq 0x5af80
movq %rax, -0x8(%rbp)
jmp 0x5b89d
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x5af10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5b82d
movq $0x0, -0x8(%rbp)
jmp 0x5b89d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x11, %esi
xorl %r8d, %r8d
callq 0x5bf50
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5b85b
movq $0x0, -0x8(%rbp)
jmp 0x5b89d
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5af60
cmpl $0x13, %eax
je 0x5b883
movq -0x28(%rbp), %rdi
leaq 0x11c80(%rip), %rsi     # 0x6d4f8
callq 0x5af80
movq %rax, -0x8(%rbp)
jmp 0x5b89d
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5a830
jmp 0x5b7c3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_parser::parse_relative_location_path(pugi::impl::(anonymous namespace)::xpath_ast_node*)
xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
		{
			xpath_ast_node* n = parse_step(set);
			if (!n) return 0;

			while (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
			{
				lexeme_t l = _lexer.current();
				_lexer.next();

				if (l == lex_double_slash)
				{
					n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
					if (!n) return 0;
				}

				n = parse_step(n);
				if (!n) return 0;
			}

			return n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x5d300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5b959
movq $0x0, -0x8(%rbp)
jmp 0x5ba21
jmp 0x5b95b
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5af60
movl %eax, %ecx
movb $0x1, %al
cmpl $0x10, %ecx
movb %al, -0x31(%rbp)
je 0x5b98a
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5af60
cmpl $0x11, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5b996
jmp 0x5ba19
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5af60
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
addq $0x8, %rdi
callq 0x5a830
cmpl $0x11, -0x24(%rbp)
jne 0x5b9f2
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x38, %esi
movl $0x5, %ecx
movl $0x2, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x5b8b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5b9f0
movq $0x0, -0x8(%rbp)
jmp 0x5ba21
jmp 0x5b9f2
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5d300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5ba14
movq $0x0, -0x8(%rbp)
jmp 0x5ba21
jmp 0x5b95b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::get_variable_scratch(char (&) [32], pugi::xpath_variable_set*, char const*, char const*, pugi::xpath_variable**)
PUGI__FN bool get_variable_scratch(char_t (&buffer)[32], xpath_variable_set* set, const char_t* begin, const char_t* end, xpath_variable** out_result)
	{
		size_t length = static_cast<size_t>(end - begin);
		char_t* scratch = buffer;

		if (length >= sizeof(buffer) / sizeof(buffer[0]))
		{
			// need to make dummy on-heap copy
			scratch = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
			if (!scratch) return false;
		}

		// copy string to zero-terminated buffer and perform lookup
		memcpy(scratch, begin, length * sizeof(char_t));
		scratch[length] = 0;

		*out_result = set->get(scratch);

		// free dummy buffer
		if (scratch != buffer) xml_memory::deallocate(scratch);

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x20, -0x38(%rbp)
jb 0x5c022
movq 0x399e7(%rip), %rax     # 0x959e8
movq -0x38(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x5c020
movb $0x0, -0x1(%rbp)
jmp 0x5c078
jmp 0x5c022
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
shlq $0x0, %rdx
callq 0x70b0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x4aec0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0x5c074
movq 0x39972(%rip), %rax     # 0x959e0
movq -0x40(%rbp), %rdi
callq *%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)::xpath_parser::alloc_string(pugi::impl::(anonymous namespace)::xpath_lexer_string const&)
const char_t* alloc_string(const xpath_lexer_string& value)
		{
			if (!value.begin)
				return PUGIXML_TEXT("");

			size_t length = static_cast<size_t>(value.end - value.begin);

			char_t* c = static_cast<char_t*>(_alloc->allocate((length + 1) * sizeof(char_t)));
			if (!c) return 0;

			memcpy(c, value.begin, length * sizeof(char_t));
			c[length] = 0;

			return c;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5c17f
leaq 0xcf90(%rip), %rax      # 0x69109
movq %rax, -0x8(%rbp)
jmp 0x5c1ee
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
shlq $0x0, %rsi
callq 0x5cde0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5c1c2
movq $0x0, -0x8(%rbp)
jmp 0x5c1ee
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
shlq $0x0, %rdx
callq 0x70b0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::convert_string_to_number_scratch(char (&) [32], char const*, char const*, double*)
PUGI__FN bool convert_string_to_number_scratch(char_t (&buffer)[32], const char_t* begin, const char_t* end, double* out_result)
	{
		size_t length = static_cast<size_t>(end - begin);
		char_t* scratch = buffer;

		if (length >= sizeof(buffer) / sizeof(buffer[0]))
		{
			// need to make dummy on-heap copy
			scratch = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
			if (!scratch) return false;
		}

		// copy string to zero-terminated buffer and perform conversion
		memcpy(scratch, begin, length * sizeof(char_t));
		scratch[length] = 0;

		*out_result = convert_string_to_number(scratch);

		// free dummy buffer
		if (scratch != buffer) xml_memory::deallocate(scratch);

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x20, -0x30(%rbp)
jb 0x5c2be
movq 0x3974b(%rip), %rax     # 0x959e8
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x5c2bc
movb $0x0, -0x1(%rbp)
jmp 0x5c30e
jmp 0x5c2be
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
shlq $0x0, %rdx
callq 0x70b0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rdi
callq 0x5cfa0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0x5c30a
movq 0x396dc(%rip), %rax     # 0x959e0
movq -0x38(%rbp), %rdi
callq *%rax
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_allocator::allocate(unsigned long)
void* allocate(size_t size)
		{
			// round size up to block alignment boundary
			size = (size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);

			if (_root_size + size <= _root->capacity)
			{
				void* buf = &_root->data[0] + _root_size;
				_root_size += size;
				return buf;
			}
			else
			{
				// make sure we have at least 1/4th of the page free after allocation to satisfy subsequent allocation requests
				size_t block_capacity_base = sizeof(_root->data);
				size_t block_capacity_req = size + block_capacity_base / 4;
				size_t block_capacity = (block_capacity_base > block_capacity_req) ? block_capacity_base : block_capacity_req;

				size_t block_size = block_capacity + offsetof(xpath_memory_block, data);

				xpath_memory_block* block = static_cast<xpath_memory_block*>(xml_memory::allocate(block_size));
				if (!block)
				{
					if (_error) *_error = true;
					return 0;
				}

				block->next = _root;
				block->capacity = block_capacity;

				_root = block;
				_root_size = size;

				return block->data;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rcx), %rax
addq -0x18(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x8(%rcx), %rax
ja 0x5ce49
movq -0x50(%rbp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
addq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5cf01
movq $0x1000, -0x28(%rbp)    # imm = 0x1000
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
shrq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x5ce78
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x5ce80
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq 0x38b4d(%rip), %rax     # 0x959e8
movq -0x40(%rbp), %rdi
callq *%rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x5cecc
movq -0x50(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5cec2
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x5cf01
movq -0x50(%rbp), %rax
movq (%rax), %rdx
movq -0x48(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::check_string_to_number_format(char const*)
PUGI__FN bool check_string_to_number_format(const char_t* string)
	{
		// parse leading whitespace
		while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;

		// parse sign
		if (*string == '-') ++string;

		if (!*string) return false;

		// if there is no integer part, there should be a decimal part with at least one digit
		if (!PUGI__IS_CHARTYPEX(string[0], ctx_digit) && (string[0] != '.' || !PUGI__IS_CHARTYPEX(string[1], ctx_digit))) return false;

		// parse integer part
		while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;

		// parse decimal part
		if (*string == '.')
		{
			++string;

			while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
		}

		// parse trailing whitespace
		while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;

		return *string == 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xe0c8(%rip), %rax      # 0x6b0d0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5d022
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5cff8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x5d03a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x5d04c
movb $0x0, -0x1(%rbp)
jmp 0x5d148
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xe184(%rip), %rax      # 0x6b1e0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x5d09a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x5d091
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, %ecx
leaq 0xe15b(%rip), %rax      # 0x6b1e0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x5d09a
movb $0x0, -0x1(%rbp)
jmp 0x5d148
jmp 0x5d09c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xe134(%rip), %rax      # 0x6b1e0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5d0c6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5d09c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x5d10a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xe0f2(%rip), %rax      # 0x6b1e0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5d108
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5d0de
jmp 0x5d10a
jmp 0x5d10c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xdfb4(%rip), %rax      # 0x6b0d0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5d136
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5d10c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::is_posinv_expr() const
bool is_posinv_expr() const
		{
			switch (_type)
			{
			case ast_func_position:
			case ast_func_last:
				return false;

			case ast_string_constant:
			case ast_number_constant:
			case ast_variable:
				return true;

			case ast_step:
			case ast_step_root:
				return true;

			case ast_predicate:
			case ast_filter:
				return true;

			default:
				if (_left && !_left->is_posinv_expr()) return false;

				for (xpath_ast_node* n = _right; n; n = n->_next)
					if (!n->is_posinv_expr()) return false;

				return true;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl (%rax), %eax
addl $-0x10, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x29, %eax
ja 0x5e311
movq -0x20(%rbp), %rax
leaq 0xcc84(%rip), %rcx      # 0x6af74
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x5e36d
movb $0x1, -0x1(%rbp)
jmp 0x5e36d
movb $0x1, -0x1(%rbp)
jmp 0x5e36d
movb $0x1, -0x1(%rbp)
jmp 0x5e36d
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5e333
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5e2c0
testb $0x1, %al
jne 0x5e333
movb $0x0, -0x1(%rbp)
jmp 0x5e36d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5e369
movq -0x18(%rbp), %rdi
callq 0x5e2c0
testb $0x1, %al
jne 0x5e359
movb $0x0, -0x1(%rbp)
jmp 0x5e36d
jmp 0x5e35b
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5e33f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::is_posinv_step() const
bool is_posinv_step() const
		{
			assert(_type == ast_step);

			for (xpath_ast_node* n = _right; n; n = n->_next)
			{
				assert(n->_type == ast_predicate);

				if (n->_test != predicate_posinv)
					return false;
			}

			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl (%rax), %eax
cmpl $0x38, %eax
jne 0x5e39e
jmp 0x5e3bd
leaq 0xf8e5(%rip), %rdi      # 0x6dc8a
leaq 0xcfa9(%rip), %rsi      # 0x6b355
movl $0x2ad1, %edx           # imm = 0x2AD1
leaq 0xf8e4(%rip), %rcx      # 0x6dc9c
callq 0x7180
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5e420
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x10, %eax
jne 0x5e3de
jmp 0x5e3fd
leaq 0xf906(%rip), %rdi      # 0x6dceb
leaq 0xcf69(%rip), %rsi      # 0x6b355
movl $0x2ad5, %edx           # imm = 0x2AD5
leaq 0xf8a4(%rip), %rcx      # 0x6dc9c
callq 0x7180
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x1, %eax
je 0x5e410
movb $0x0, -0x1(%rbp)
jmp 0x5e424
jmp 0x5e412
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5e3c9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::translate_table_generate(pugi::impl::(anonymous namespace)::xpath_allocator*, char const*, char const*)
PUGI__FN unsigned char* translate_table_generate(xpath_allocator* alloc, const char_t* from, const char_t* to)
	{
		unsigned char table[128] = {0};

		while (*from)
		{
			unsigned int fc = static_cast<unsigned int>(*from);
			unsigned int tc = static_cast<unsigned int>(*to);

			if (fc >= 128 || tc >= 128)
				return 0;

			// code=128 means "skip character"
			if (!table[fc])
				table[fc] = static_cast<unsigned char>(tc ? tc : 128);

			from++;
			if (tc) to++;
		}

		for (int i = 0; i < 128; ++i)
			if (!table[i])
				table[i] = static_cast<unsigned char>(i);

		void* result = alloc->allocate(sizeof(table));
		if (!result) return 0;

		memcpy(result, table, sizeof(table));

		return static_cast<unsigned char*>(result);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x72b0
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5e515
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xa4(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xa8(%rbp)
cmpl $0x80, -0xa4(%rbp)
jae 0x5e499
cmpl $0x80, -0xa8(%rbp)
jb 0x5e4a6
movq $0x0, -0x8(%rbp)
jmp 0x5e5b1
movl -0xa4(%rbp), %eax
cmpb $0x0, -0xa0(%rbp,%rax)
jne 0x5e4ef
cmpl $0x0, -0xa8(%rbp)
je 0x5e4cd
movl -0xa8(%rbp), %eax
movl %eax, -0xbc(%rbp)
jmp 0x5e4da
movl $0x80, %eax
movl %eax, -0xbc(%rbp)
jmp 0x5e4da
movl -0xbc(%rbp), %eax
movb %al, %cl
movl -0xa4(%rbp), %eax
movb %cl, -0xa0(%rbp,%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xa8(%rbp)
je 0x5e510
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5e45a
movl $0x0, -0xac(%rbp)
cmpl $0x80, -0xac(%rbp)
jge 0x5e565
movslq -0xac(%rbp), %rax
cmpb $0x0, -0xa0(%rbp,%rax)
jne 0x5e552
movl -0xac(%rbp), %eax
movb %al, %cl
movslq -0xac(%rbp), %rax
movb %cl, -0xa0(%rbp,%rax)
jmp 0x5e554
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x5e51f
movq -0x10(%rbp), %rdi
movl $0x80, %esi
callq 0x5cde0
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
jne 0x5e58e
movq $0x0, -0x8(%rbp)
jmp 0x5e5b1
movq -0xb8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x80, %edx
callq 0x70b0
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_string::append(pugi::impl::(anonymous namespace)::xpath_string const&, pugi::impl::(anonymous namespace)::xpath_allocator*)
void append(const xpath_string& o, xpath_allocator* alloc)
		{
			// skip empty sources
			if (!*o._buffer) return;

			// fast append for constant empty target and constant source
			if (!*_buffer && !_uses_heap && !o._uses_heap)
			{
				_buffer = o._buffer;
			}
			else
			{
				// need to make heap copy
				size_t target_length = length();
				size_t source_length = o.length();
				size_t result_length = target_length + source_length;

				// allocate new buffer
				char_t* result = static_cast<char_t*>(alloc->reallocate(_uses_heap ? const_cast<char_t*>(_buffer) : 0, (target_length + 1) * sizeof(char_t), (result_length + 1) * sizeof(char_t)));
				if (!result) return;

				// append first string to the new buffer in case there was no reallocation
				if (!_uses_heap) memcpy(result, _buffer, target_length * sizeof(char_t));

				// append second string to the new buffer
				memcpy(result + target_length, o._buffer, source_length * sizeof(char_t));
				result[result_length] = 0;

				// finalize
				_buffer = result;
				_uses_heap = true;
				_length_heap = result_length;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x60e4d
jmp 0x60f63
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x60e80
movq -0x40(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x60e80
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x60e80
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x60f63
movq -0x40(%rbp), %rdi
callq 0x4e200
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e200
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x48(%rbp)
testb $0x1, 0x8(%rax)
je 0x60ec8
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x60ed0
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x60ed0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
shlq $0x0, %rcx
callq 0x60fb0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x60f02
jmp 0x60f63
movq -0x40(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x60f24
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
shlq $0x0, %rdx
callq 0x70b0
movq -0x38(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
shlq $0x0, %rdx
callq 0x70b0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdx
movb $0x0, (%rcx,%rdx)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_allocator::revert(pugi::impl::(anonymous namespace)::xpath_allocator const&)
void revert(const xpath_allocator& state)
		{
			// free all new pages
			xpath_memory_block* cur = _root;

			while (cur != state._root)
			{
				xpath_memory_block* next = cur->next;

				xml_memory::deallocate(cur);

				cur = next;
			}

			// restore state
			_root = state._root;
			_root_size = state._root_size;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x6132e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x346c2(%rip), %rax     # 0x959e0
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x612ff
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_string::from_heap(char const*, char const*, pugi::impl::(anonymous namespace)::xpath_allocator*)
static xpath_string from_heap(const char_t* begin, const char_t* end, xpath_allocator* alloc)
		{
			assert(begin <= end);

			if (begin == end)
				return xpath_string();

			size_t length = static_cast<size_t>(end - begin);
			const char_t* data = duplicate_string(begin, length, alloc);

			return data ? xpath_string(data, true, length) : xpath_string();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x61968
jmp 0x61987
leaq 0xcb22(%rip), %rdi      # 0x6e491
leaq 0x99df(%rip), %rsi      # 0x6b355
movl $0x1e19, %edx           # imm = 0x1E19
leaq 0xcb1c(%rip), %rcx      # 0x6e49e
callq 0x7180
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x6199c
movq -0x38(%rbp), %rdi
callq 0x4e460
jmp 0x619ea
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x62400
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x619df
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x60f70
jmp 0x619e8
movq -0x38(%rbp), %rdi
callq 0x4e460
jmp 0x619ea
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_string::data(pugi::impl::(anonymous namespace)::xpath_allocator*)
char_t* data(xpath_allocator* alloc)
		{
			// make private heap copy
			if (!_uses_heap)
			{
				size_t length_ = strlength(_buffer);
				const char_t* data_ = duplicate_string(_buffer, length_, alloc);

				if (!data_) return 0;

				_buffer = data_;
				_uses_heap = true;
				_length_heap = length_;
			}

			return const_cast<char_t*>(_buffer);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x8(%rax)
jne 0x61ac1
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x418f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x62400
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x61aaa
movq $0x0, -0x8(%rbp)
jmp 0x61acc
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::normalize_space(char*)
PUGI__FN char_t* normalize_space(char_t* buffer)
	{
		char_t* write = buffer;

		for (char_t* it = buffer; *it; )
		{
			char_t ch = *it++;

			if (PUGI__IS_CHARTYPE(ch, ct_space))
			{
				// replace whitespace sequence with single space
				while (PUGI__IS_CHARTYPE(*it, ct_space)) it++;

				// avoid leading spaces
				if (write != buffer) *write++ = ' ';
			}
			else *write++ = ch;
		}

		// remove trailing space
		if (write != buffer && PUGI__IS_CHARTYPE(write[-1], ct_space)) write--;

		// zero-terminate
		*write = 0;

		return write;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x61b95
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, %ecx
leaq 0x95aa(%rip), %rax      # 0x6b0d0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x61b7c
jmp 0x61b34
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x958c(%rip), %rax      # 0x6b0d0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x61b5e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x61b34
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x61b7a
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
jmp 0x61b90
movb -0x19(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x61af8
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x61bc8
movq -0x10(%rbp), %rax
movzbl -0x1(%rax), %eax
movl %eax, %ecx
leaq 0x9520(%rip), %rax      # 0x6b0d0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x61bc8
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::translate(char*, char const*, char const*, unsigned long)
PUGI__FN char_t* translate(char_t* buffer, const char_t* from, const char_t* to, size_t to_length)
	{
		char_t* write = buffer;

		while (*buffer)
		{
			PUGI__DMC_VOLATILE char_t ch = *buffer++;

			const char_t* pos = find_char(from, ch);

			if (!pos)
				*write++ = ch; // do not process
			else if (static_cast<size_t>(pos - from) < to_length)
				*write++ = to[pos - from]; // replace
		}

		// zero-terminate
		*write = 0;

		return write;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x61d16
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x29(%rbp), %esi
callq 0x62090
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x61cdb
movb -0x29(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x61d11
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq -0x20(%rbp), %rax
jae 0x61d0f
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq %rdx, %rcx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x61d11
jmp 0x61c90
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::translate_table(char*, unsigned char const*)
PUGI__FN char_t* translate_table(char_t* buffer, const unsigned char* table)
	{
		char_t* write = buffer;

		while (*buffer)
		{
			char_t ch = *buffer++;
			unsigned int index = static_cast<unsigned int>(ch);

			if (index < 128)
			{
				unsigned char code = table[index];

				// code=128 means "skip character" (table size is 128 so 128 can be a special value)
				// this code skips these characters without extra branches
				*write = static_cast<char_t>(code);
				write += 1 - (code >> 7);
			}
			else
			{
				*write++ = ch;
			}
		}

		// zero-terminate
		*write = 0;

		return write;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x61dbb
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x80, -0x20(%rbp)
jae 0x61da5
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movzbl -0x21(%rbp), %eax
sarl $0x7, %eax
movl $0x1, %ecx
subl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x61db9
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x61d44
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::namespace_uri(pugi::xml_attribute, pugi::xml_node)
PUGI__FN const char_t* namespace_uri(xml_attribute attr, xml_node parent)
	{
		namespace_uri_predicate pred = attr.name();

		// Default namespace does not apply to attributes
		if (!pred.prefix) return PUGIXML_TEXT("");

		xml_node p = parent;

		while (p)
		{
			xml_attribute a = p.find_attribute(pred);

			if (a) return a.value();

			p = p.parent();
		}

		return PUGIXML_TEXT("");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x41020
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x62230
cmpq $0x0, -0x28(%rbp)
jne 0x620f9
leaq 0x7016(%rip), %rax      # 0x69109
movq %rax, -0x8(%rbp)
jmp 0x62175
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41c30
cmpq $0x0, %rax
je 0x6216a
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x622b0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x40990
cmpq $0x0, %rax
je 0x62153
leaq -0x38(%rbp), %rdi
callq 0x41070
movq %rax, -0x8(%rbp)
jmp 0x62175
leaq -0x30(%rbp), %rdi
callq 0x426e0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x62101
leaq 0x6f98(%rip), %rax      # 0x69109
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop