LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: void pugi::impl::(anonymous namespace)::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 sort(I begin, I end, const Pred& pred)
	{
		// sort large chunks
		while (end - begin > 32)
		{
			// find median element
			I middle = begin + (end - begin) / 2;
			median(begin, middle, end - 1, pred);

			// partition in three chunks (< = >)
			I eqbeg, eqend;
			partition(begin, middle, end, pred, &eqbeg, &eqend);

			// loop on larger half
			if (eqbeg - begin > end - eqend)
			{
				sort(eqend, end, pred);
				end = eqbeg;
			}
			else
			{
				sort(begin, eqbeg, pred);
				begin = eqend;
			}
		}

		// insertion sort small chunk
		if (begin != end) insertion_sort(begin, end, pred, &*begin);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq $0x20, %rax
jle 0x1d342
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $-0x10, %rdx
movq -0x18(%rbp), %rcx
callq 0x1dae0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
callq 0x1dc10
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rax
jle 0x1d324
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d250
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1d33d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d250
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d264
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x1d361
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
callq 0x1de90
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: void pugi::impl::(anonymous namespace)::median<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&)
void median(I first, I middle, I last, const Pred& pred)
	{
		if (last - first <= 40)
		{
			// median of three for small chunks
			median3(first, middle, last, pred);
		}
		else
		{
			// median of nine
			size_t step = (last - first + 1) / 8;

			median3(first, first + step, first + 2 * step, pred);
			median3(middle - step, middle, middle + step, pred);
			median3(last - 2 * step, last - step, last, pred);
			median3(first + step, middle, last - step, pred);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq $0x28, %rax
jg 0x1db27
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1dfc0
jmp 0x1dc05
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
addq $0x1, %rax
movl $0x8, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq %rax
shlq $0x4, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1dfc0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
subq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1dfc0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rcx
shlq %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
subq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1dfc0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
subq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1dfc0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/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::xpath_node*, pugi::impl::(anonymous namespace)::document_order_comparator const&, pugi::xpath_node*)
void insertion_sort(I begin, I end, const Pred& pred, T*)
	{
		assert(begin != end);

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

			if (pred(val, *begin))
			{
				// move to front
				copy_backwards(begin, it, it + 1);
				*begin = val;
			}
			else
			{
				I hole = it;

				// move hole backwards
				while (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 %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x1deb4
jmp 0x1ded3
leaq 0x42a5d(%rip), %rdi     # 0x60918
leaq 0x40cb3(%rip), %rsi     # 0x5eb75
movl $0x1c3f, %edx           # imm = 0x1C3F
leaq 0x42a57(%rip), %rcx     # 0x60925
callq 0x5310
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x1dfaf
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x1d3c0
testb $0x1, %al
jne 0x1df17
jmp 0x1df41
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x10, %rdx
callq 0x1e0a0
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1df9c
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rdx
addq $-0x10, %rdx
leaq -0x38(%rbp), %rsi
callq 0x1d3c0
testb $0x1, %al
jne 0x1df64
jmp 0x1df89
movq -0x40(%rbp), %rcx
movq -0x40(%rbp), %rax
movq -0x10(%rcx), %rdx
movq %rdx, (%rax)
movq -0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x40(%rbp)
jmp 0x1df49
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1df9e
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x1dedf
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_parser::parse()
xpath_ast_node* parse()
		{
			xpath_ast_node* result = parse_expression();

			if (_lexer.current() != lex_eof)
			{
				// there are still unparsed tokens left, error
				throw_error("Incorrect query");
			}

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1eea0
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x8, %rdi
callq 0x1eed0
cmpl $0x1a, %eax
je 0x1e74f
movq -0x18(%rbp), %rdi
leaq 0x42449(%rip), %rsi     # 0x60b93
callq 0x1eef0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_parser::throw_error(char const*)
void throw_error(const char* message)
		{
			_result->error = message;
			_result->offset = _lexer.current_pos() - _query;

		#ifdef PUGIXML_NO_EXCEPTIONS
			longjmp(_error_handler, 1);
		#else
			throw xpath_exception(*_result);
		#endif
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq 0x40(%rdi), %rax
movq %rcx, (%rax)
addq $0x8, %rdi
callq 0x21c70
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdx
movq 0x40(%rax), %rax
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl $0x18, %edi
callq 0x5240
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq 0x40(%rax), %rsi
callq 0xe8e0
jmp 0x1ef55
movq -0x28(%rbp), %rdi
leaq 0x62dc8(%rip), %rsi     # 0x81d28
leaq 0xf029(%rip), %rdx      # 0x2df90
callq 0x58d0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5380
movq -0x18(%rbp), %rdi
callq 0x5920
nopw (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_allocator::allocate_nothrow(unsigned long)
void* allocate_nothrow(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) 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 0x1f879
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 0x1f91b
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 0x1f8a8
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x1f8b0
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 0x62c8d(%rip), %rax     # 0x82558
movq -0x40(%rbp), %rdi
callq *%rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x1f8e6
movq $0x0, -0x8(%rbp)
jmp 0x1f91b
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
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/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 = new (alloc_node()) xpath_ast_node(ast_step_root, xpath_type_node_set);

				// 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 = new (alloc_node()) xpath_ast_node(ast_step_root, xpath_type_node_set);
				n = new (alloc_node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 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 $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x1eed0
cmpl $0x10, %eax
jne 0x1fa43
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x1e7c0
movq -0x30(%rbp), %rdi
callq 0x1f650
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movl $0x39, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x1f690
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x1eed0
movl %eax, -0x1c(%rbp)
cmpl $0x14, -0x1c(%rbp)
je 0x1fa20
cmpl $0x16, -0x1c(%rbp)
je 0x1fa20
cmpl $0x17, -0x1c(%rbp)
je 0x1fa20
cmpl $0x18, -0x1c(%rbp)
je 0x1fa20
cmpl $0x9, -0x1c(%rbp)
jne 0x1fa36
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1fd50
movq %rax, -0x8(%rbp)
jmp 0x1faf1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1faf1
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x1eed0
cmpl $0x11, %eax
jne 0x1fade
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x1e7c0
movq -0x30(%rbp), %rdi
callq 0x1f650
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
movl $0x39, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x1f690
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x1f650
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
movq -0x28(%rbp), %rdx
movl $0x38, %esi
movl $0x5, %ecx
movl $0x2, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x1fcc0
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x1fd50
movq %rax, -0x8(%rbp)
jmp 0x1faf1
jmp 0x1fae0
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1fd50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/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();

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

				xpath_ast_node* expr = parse_expression();

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

				n = new (alloc_node()) xpath_ast_node(ast_filter, n, expr, predicate_default);

				if (_lexer.current() != lex_close_square_brace)
					throw_error("Unmatched square brace");

				_lexer.next();
			}

			return n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1fe30
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1eed0
cmpl $0x12, %eax
jne 0x1fcac
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1e7c0
movq -0x20(%rbp), %rdi
callq 0x1eea0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10790
cmpl $0x1, %eax
je 0x1fc4b
movq -0x20(%rbp), %rdi
leaq 0x410aa(%rip), %rsi     # 0x60cf0
callq 0x1eef0
movq -0x20(%rbp), %rdi
callq 0x1f650
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x11, %esi
xorl %r8d, %r8d
callq 0x202c0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x8, %rdi
callq 0x1eed0
cmpl $0x13, %eax
je 0x1fc9a
movq -0x20(%rbp), %rdi
leaq 0x41083(%rip), %rsi     # 0x60d18
callq 0x1eef0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1e7c0
jmp 0x1fbfd
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/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);

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

				if (l == lex_double_slash)
					n = new (alloc_node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);

				n = parse_step(n);
			}

			return n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x21470
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x1eed0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x10, %ecx
movb %al, -0x29(%rbp)
je 0x1fda4
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x1eed0
cmpl $0x11, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1fdad
jmp 0x1fe1c
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x1eed0
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
addq $0x8, %rdi
callq 0x1e7c0
cmpl $0x11, -0x1c(%rbp)
jne 0x1fe06
movq -0x28(%rbp), %rdi
callq 0x1f650
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rdx
movl $0x38, %esi
movl $0x5, %ecx
movl $0x2, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x1fcc0
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21470
movq %rax, -0x18(%rbp)
jmp 0x1fd75
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/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)
			{
				size_t length = static_cast<size_t>(value.end - value.begin);

				char_t* c = static_cast<char_t*>(_alloc->allocate_nothrow((length + 1) * sizeof(char_t)));
				if (!c) throw_error_oom();
				assert(c); // workaround for clang static analysis

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

				return c;
			}
			else return 0;
		}

// 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)
je 0x2056e
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 0x1f810
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x20518
movq -0x30(%rbp), %rdi
callq 0x1f930
cmpq $0x0, -0x28(%rbp)
je 0x20521
jmp 0x20540
leaq 0x4096e(%rip), %rdi     # 0x60e96
leaq 0x3e646(%rip), %rsi     # 0x5eb75
movl $0x2acd, %edx           # imm = 0x2ACD
leaq 0x4095d(%rip), %rcx     # 0x60e98
callq 0x5310
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5400
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x20576
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: adamiaonr[P]rid-analytics/src/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_nothrow(sizeof(table));

		if (result)
		{
			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 0x5290
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x22255
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 0x221d9
cmpl $0x80, -0xa8(%rbp)
jb 0x221e6
movq $0x0, -0x8(%rbp)
jmp 0x222e7
movl -0xa4(%rbp), %eax
cmpb $0x0, -0xa0(%rbp,%rax)
jne 0x2222f
cmpl $0x0, -0xa8(%rbp)
je 0x2220d
movl -0xa8(%rbp), %eax
movl %eax, -0xbc(%rbp)
jmp 0x2221a
movl $0x80, %eax
movl %eax, -0xbc(%rbp)
jmp 0x2221a
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 0x22250
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2219a
movl $0x0, -0xac(%rbp)
cmpl $0x80, -0xac(%rbp)
jge 0x222a5
movslq -0xac(%rbp), %rax
cmpb $0x0, -0xa0(%rbp,%rax)
jne 0x22292
movl -0xac(%rbp), %eax
movb %al, %cl
movslq -0xac(%rbp), %rax
movb %cl, -0xa0(%rbp,%rax)
jmp 0x22294
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x2225f
movq -0x10(%rbp), %rdi
movl $0x80, %esi
callq 0x1f810
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
je 0x222dc
movq -0xb8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x80, %edx
callq 0x5400
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_allocator::allocate(unsigned long)
void* allocate(size_t size)
		{
			void* result = allocate_nothrow(size);

			if (!result)
			{
			#ifdef PUGIXML_NO_EXCEPTIONS
				assert(error_handler);
				longjmp(*error_handler, 1);
			#else
				throw std::bad_alloc();
			#endif
			}

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f810
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x263f5
movl $0x8, %edi
callq 0x5240
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
callq 0x2ded0
movq -0x20(%rbp), %rdi
movq 0x5bbd7(%rip), %rsi     # 0x81fc0
movq 0x5bba8(%rip), %rdx     # 0x81f98
callq 0x58d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamiaonr[P]rid-analytics/src/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);

				_buffer = duplicate_string(_buffer, length_, alloc);
				_uses_heap = true;
				_length_heap = length_;
			}

			return const_cast<char_t*>(_buffer);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x8(%rax)
jne 0x26c7b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x6f70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x275c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_string::duplicate_string(char const*, unsigned long, pugi::impl::(anonymous namespace)::xpath_allocator*)
static char_t* duplicate_string(const char_t* string, size_t length, xpath_allocator* alloc)
		{
			char_t* result = static_cast<char_t*>(alloc->allocate((length + 1) * sizeof(char_t)));
			assert(result);

			memcpy(result, string, length * sizeof(char_t));
			result[length] = 0;

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
shlq $0x0, %rsi
callq 0x263a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x275f6
jmp 0x27615
leaq 0x3a23e(%rip), %rdi     # 0x6183b
leaq 0x37571(%rip), %rsi     # 0x5eb75
movl $0x1db6, %edx           # imm = 0x1DB6
leaq 0x3a713(%rip), %rcx     # 0x61d23
callq 0x5310
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5400
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::convert_number_to_mantissa_exponent(double, char*, unsigned long, char**, int*)
PUGI__FN void convert_number_to_mantissa_exponent(double value, char* buffer, size_t buffer_size, char** out_mantissa, int* out_exponent)
	{
		// get a scientific notation value with IEEE DBL_DIG decimals
		sprintf(buffer, "%.*e", DBL_DIG, value);
		assert(strlen(buffer) < buffer_size);
		(void)!buffer_size;

		// get the exponent (possibly negative)
		char* exponent_string = strchr(buffer, 'e');
		assert(exponent_string);

		int exponent = atoi(exponent_string + 1);

		// extract mantissa string: skip sign
		char* mantissa = buffer[0] == '-' ? buffer + 1 : buffer;
		assert(mantissa[0] != '0' && mantissa[1] == '.');

		// divide mantissa by 10 to eliminate integer part
		mantissa[1] = mantissa[0];
		mantissa++;
		exponent++;

		// remove extra mantissa digits and zero-terminate mantissa
		truncate_zeros(mantissa, exponent_string);

		// fill results
		*out_mantissa = mantissa;
		*out_exponent = exponent;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
leaq 0x3a830(%rip), %rsi     # 0x61f4d
movl $0xf, %edx
movb $0x1, %al
callq 0x5110
movq -0x10(%rbp), %rdi
callq 0x5200
cmpq -0x18(%rbp), %rax
jae 0x2773a
jmp 0x27759
leaq 0x3a811(%rip), %rdi     # 0x61f52
leaq 0x3742d(%rip), %rsi     # 0x5eb75
movl $0x1f8d, %edx           # imm = 0x1F8D
leaq 0x3a81b(%rip), %rcx     # 0x61f6f
callq 0x5310
movq -0x10(%rbp), %rdi
movl $0x65, %esi
callq 0x51a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x27774
jmp 0x27793
leaq 0x3a868(%rip), %rdi     # 0x61fe3
leaq 0x373f3(%rip), %rsi     # 0x5eb75
movl $0x1f92, %edx           # imm = 0x1F92
leaq 0x3a7e1(%rip), %rcx     # 0x61f6f
callq 0x5310
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0x5800
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x277bd
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x277c5
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x49(%rbp)
je 0x277ef
movq -0x40(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2e, %eax
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x277f8
jmp 0x277fa
jmp 0x27819
leaq 0x3a7f2(%rip), %rdi     # 0x61ff3
leaq 0x3736d(%rip), %rsi     # 0x5eb75
movl $0x1f98, %edx           # imm = 0x1F98
leaq 0x3a75b(%rip), %rcx     # 0x61f6f
callq 0x5310
movq -0x40(%rbp), %rax
movb (%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x27870
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: char* pugi::impl::(anonymous namespace)::integer_to_string<int>(char*, char*, int)
PUGI__FN char_t* integer_to_string(char_t* begin, char_t* end, T value)
	{
		typedef typename make_unsigned<T>::type U;

		bool negative = value < 0;

		char_t* result = end - 1;
		U rest = negative ? 0 - U(value) : U(value);

		do
		{
			*result-- = static_cast<char_t>('0' + (rest % 10));
			rest /= 10;
		}
		while (rest);

		assert(result >= begin);
		(void)begin;

		*result = '-';

		return result + !negative;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
setl %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x15(%rbp)
je 0x2ca1b
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x2ca21
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
addl $0x30, %edx
movb %dl, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2ca27
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x2ca6a
jmp 0x2ca89
leaq 0x35f42(%rip), %rdi     # 0x629b3
leaq 0x320fd(%rip), %rsi     # 0x5eb75
movl $0x11fa, %edx           # imm = 0x11FA
leaq 0x35f3f(%rip), %rcx     # 0x629c3
callq 0x5310
movq -0x20(%rbp), %rax
movb $0x2d, (%rax)
movq -0x20(%rbp), %rax
movb -0x15(%rbp), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamiaonr[P]rid-analytics/src/graph.cpp
// Function: Graph::Graph(char const*)
Graph::Graph(const char * filename)
{
    // add .dot extension
    this->graph_filename = filename + std::string(GRAPHVIZ_DOT_FILE_EXT);

    // create the .dot output file.
    this->graph_filestream.open(this->graph_filename.c_str());

    // initial syntax to set the graph
    this->graph_filestream << "digraph {\n";
    this->graph_filestream << "\trankdir=LR\n\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x5730
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x70(%rbp)
callq 0x58c0
jmp 0x3087a
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5930
movq -0x88(%rbp), %rdx
leaq 0x32c04(%rip), %rsi     # 0x634a7
leaq -0x60(%rbp), %rdi
callq 0x30320
jmp 0x308ae
movq -0x90(%rbp), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x31a70
jmp 0x308c4
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x5600
movq -0xa0(%rbp), %rdi
callq 0x52f0
leaq -0x60(%rbp), %rdi
callq 0x52f0
leaq -0x61(%rbp), %rdi
callq 0x5510
movq -0x80(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x98(%rbp)
callq 0x51d0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x50a0
jmp 0x30923
movq -0x80(%rbp), %rdi
addq $0x20, %rdi
leaq 0x32b7a(%rip), %rsi     # 0x634ac
callq 0x5480
jmp 0x30939
movq -0x80(%rbp), %rdi
addq $0x20, %rdi
leaq 0x32b6f(%rip), %rsi     # 0x634b7
callq 0x5480
jmp 0x3094f
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x309a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x30989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x52f0
leaq -0x61(%rbp), %rdi
callq 0x5510
jmp 0x309a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x70(%rbp), %rdi
callq 0x57c0
movq -0x78(%rbp), %rdi
callq 0x52f0
movq -0x18(%rbp), %rdi
callq 0x5920
nopl (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/graph.cpp
// Function: Graph::align_nodes(Node**, int)
void Graph::align_nodes(
    Node ** nodes,
    int nodes_size) {

    this->graph_filestream << std::string("\t{rank = same; ");

    for (int i = 0; i < nodes_size; i++) {

        this->graph_filestream << nodes[i]->get_uid();

        if (i + 1 < nodes_size) {
            this->graph_filestream << ", ";
        }
    }    

    this->graph_filestream << " };\n"; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x20, %rax
movq %rax, -0x80(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5930
movq -0x78(%rbp), %rdx
leaq 0x31c08(%rip), %rsi     # 0x63509
leaq -0x38(%rbp), %rdi
callq 0x30320
jmp 0x3190c
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5430
jmp 0x3191b
leaq -0x38(%rbp), %rdi
callq 0x52f0
leaq -0x39(%rbp), %rdi
callq 0x5510
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x31a05
movq -0x88(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x31d80
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x5430
jmp 0x31983
leaq -0x70(%rbp), %rdi
callq 0x52f0
movl -0x50(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jge 0x319f5
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
leaq 0x31b70(%rip), %rsi     # 0x63519
callq 0x5480
jmp 0x319f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x319d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52f0
leaq -0x39(%rbp), %rdi
callq 0x5510
jmp 0x31a25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x52f0
jmp 0x31a25
jmp 0x319f7
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x31934
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
leaq 0x31b05(%rip), %rsi     # 0x6351c
callq 0x5480
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5920
nop
// File: adamiaonr[P]rid-analytics/src/rid-router.cpp
// Function: RID_Router::is_iface_on_fptree(int, std::map<int, std::vector<unsigned char, std::allocator<unsigned char>>, std::less<int>, std::allocator<std::pair<int const, std::vector<unsigned char, std::allocator<unsigned char>>>>>*)
void RID_Router::is_iface_on_fptree(
    int i, 
    std::map<int, std::vector<uint8_t> > * tree_bitmasks) {

    // std::cout << "RID_Router::is_iface_on_fptree() : [INFO] is " << i << " on prefix tree?";

    std::map<int, std::vector<uint8_t> >::iterator itr;
    for (itr = (*tree_bitmasks).begin(); itr != (*tree_bitmasks).end(); itr++) {

        int t = itr->first;
        if (t == 0) continue;
    
        for (uint8_t k = 0; k < this->fwd_table[i].tree_bitmasks[t].size(); k++) {

            uint8_t iface_tree_bitmask = this->fwd_table[i].tree_bitmasks[t][k];
            // std::cout << "\n\t tree_bitmask vs. iface_tree_bitmask : " 
            //     << (int) (*tree_bitmasks)[t][k] << " <-> " << (int) iface_tree_bitmask
            //     << std::endl;

            if ((*tree_bitmasks)[t][k] & iface_tree_bitmask) {
                // std::cout << "\n\t IT IS!" << std::endl;
                this->iface_on_fptree[i][t] = true;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x351b0
movq -0x18(%rbp), %rdi
callq 0x351d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x35230
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x35200
testb $0x1, %al
jne 0x33f4c
jmp 0x34062
leaq -0x20(%rbp), %rdi
callq 0x352a0
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x33f65
jmp 0x3404e
movb $0x0, -0x35(%rbp)
movq -0x58(%rbp), %rdi
movzbl -0x35(%rbp), %eax
movq %rax, -0x60(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0x34a20
movq %rax, %rdi
addq $0x60, %rdi
leaq -0x34(%rbp), %rsi
callq 0x354a0
movq %rax, %rdi
callq 0x35580
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x3404c
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0x34a20
movq %rax, %rdi
addq $0x60, %rdi
leaq -0x34(%rbp), %rsi
callq 0x354a0
movq %rax, %rdi
movzbl -0x35(%rbp), %eax
movl %eax, %esi
callq 0x34d30
movb (%rax), %al
movb %al, -0x36(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x354a0
movq %rax, %rdi
movzbl -0x35(%rbp), %eax
movl %eax, %esi
callq 0x34d30
movzbl (%rax), %eax
movzbl -0x36(%rbp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x3403d
movq -0x58(%rbp), %rdi
addq $0x88, %rdi
movslq -0xc(%rbp), %rsi
callq 0x34fa0
movq %rax, %rdi
movslq -0x34(%rbp), %rsi
callq 0x35120
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x355a0
jmp 0x3403f
movb -0x35(%rbp), %al
addb $0x1, %al
movb %al, -0x35(%rbp)
jmp 0x33f69
jmp 0x3404e
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x35320
movq %rax, -0x50(%rbp)
jmp 0x33f29
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamiaonr[P]rid-analytics/include/prob.h
// Function: Prob::fp_data::fp_data()
fp_data() {

            tp_size = 0;
            num_entries = 0.0;
            entry_prop = 0.0;
            is_blocked = false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x30, %rdi
callq 0x38e40
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x38e40
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x38e60
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x34920
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
fldz
fld %st(0)
fstpt 0x10(%rax)
fstpt 0x20(%rax)
movb $0x0, 0xb8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: adamiaonr[P]rid-analytics/src/path-state.cpp
// Function: Path_State::Path_State(RID_Router*, int)
Path_State::Path_State(RID_Router * router, int req_size) {

    this->router = router;
    // path info
    this->path_length = 0;
    this->path_status = (int) OUTCOME_UNDEF;
    this->path_prob = 0.0;
    // event & event prob
    this->event = (int) 0x07;
    this->event_prob = 0.0;

    this->in_fptree_prob = std::vector<__float080>(req_size + 1, 0.0);

    this->eop = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x50, %rdi
movq %rdi, -0x78(%rbp)
callq 0x38e40
movq -0x70(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, 0xc(%rax)
movl $0x6, 0x10(%rax)
fldz
fld %st(0)
fstpt 0x20(%rax)
movl $0x7, 0x30(%rax)
fld %st(0)
fstpt 0x40(%rax)
movl -0x14(%rbp), %eax
incl %eax
cltq
movq %rax, -0x68(%rbp)
fstpt -0x40(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x34a40
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x34a60
jmp 0x3f539
movq -0x70(%rbp), %rdi
addq $0x50, %rdi
leaq -0x30(%rbp), %rsi
callq 0x34ae0
leaq -0x30(%rbp), %rdi
callq 0x34b10
leaq -0x41(%rbp), %rdi
callq 0x34b70
movq -0x70(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x34b70
movq -0x78(%rbp), %rdi
callq 0x34b10
movq -0x50(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::reset()
void ArgvParser::reset()
{
    max_key = 1;
    option2key.clear();
    option2attribute.clear();
    option2descr.clear();
    option2value.clear();
    errorcode2descr.clear();
    argument_container.clear();
    intro_description.clear();
    error_option.clear();
    help_option = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, (%rdi)
addq $0x8, %rdi
callq 0x42ec0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x42ee0
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x42f00
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0x42f00
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x42f20
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x42f40
movq -0x10(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x5680
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x5680
movq -0x10(%rbp), %rax
movl $0x0, 0x130(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::optionKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int ArgvParser::optionKey( const string& _name ) const
{
    String2KeyMap::const_iterator it = option2key.find(_name);

    // if not found
    if (it == option2key.end())
        return(-1);

    return(it->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x42f60
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x42fc0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x42f90
testb $0x1, %al
jne 0x3fd5d
jmp 0x3fd66
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3fd75
leaq -0x20(%rbp), %rdi
callq 0x42ff0
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::foundOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool ArgvParser::foundOption( const string & _name ) const
{
    int key = optionKey(_name);

    // not defined -> cannot by found
    if (key == -1)
        return(false);

    // return whether the key of the given option name is in the hash of the
    // parsed options.
    return(option2value.find(key) != option2value.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3fd10
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x3fe00
movb $0x0, -0x1(%rbp)
jmp 0x3fe44
movq -0x40(%rbp), %rdi
addq $0x98, %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x43070
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x98, %rdi
callq 0x430a0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x43040
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::optionValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string ArgvParser::optionValue(const string& _option) const
{
    int key = optionKey(_option);

    // not defined -> cannot by found
    if (key == -1)
    {
        cerr << "ArgvParser::optionValue(): Requested value of an option the parser did not find or does not know." << endl;
        return("");
    }

    return(option2value.find(key)->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3fd10
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x3fef0
movq 0x42160(%rip), %rdi     # 0x81ff0
leaq 0x23b99(%rip), %rsi     # 0x63a30
callq 0x5480
movq %rax, %rdi
movq 0x420ea(%rip), %rsi     # 0x81f90
callq 0x54f0
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5930
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x23641(%rip), %rsi     # 0x63508
callq 0x30320
jmp 0x3fece
leaq -0x1d(%rbp), %rdi
callq 0x5510
jmp 0x3ff27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x5510
jmp 0x3ff31
movq -0x48(%rbp), %rdi
addq $0x98, %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x43070
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x430d0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x51f0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5920
nopw (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::isValidOptionString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool CommandLineProcessing::isValidOptionString(const string& _string)
{
    // minimal short option length is 2
    if (_string.length() < 2)
        return(false);

    // is it an option (check for '-' as first character)
    if (_string.compare(0, 1, "-"))
        return(false);

    // not an option if just '--'
    if (_string.length() == 2 && _string == "--")
        return(false);

    // it might still be a negative number
    // (but not if there is no digit afterwards)
    if (isDigit(_string[1]))
        return(false);

    // let's consider this an option
    return(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57e0
cmpq $0x2, %rax
jae 0x40db1
movb $0x0, -0x1(%rbp)
jmp 0x40e26
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
leaq 0x22d6f(%rip), %rcx     # 0x63b34
callq 0x56b0
cmpl $0x0, %eax
je 0x40dd5
movb $0x0, -0x1(%rbp)
jmp 0x40e26
movq -0x10(%rbp), %rdi
callq 0x57e0
cmpq $0x2, %rax
jne 0x40e00
movq -0x10(%rbp), %rdi
leaq 0x22d44(%rip), %rsi     # 0x63b33
callq 0x43cf0
testb $0x1, %al
jne 0x40dfa
jmp 0x40e00
movb $0x0, -0x1(%rbp)
jmp 0x40e26
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5530
movq %rax, %rdi
callq 0x42670
testb $0x1, %al
jne 0x40e1c
jmp 0x40e22
movb $0x0, -0x1(%rbp)
jmp 0x40e26
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::isValidLongOptionString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool CommandLineProcessing::isValidLongOptionString(const string& _string)
{
    if (_string.length() < 4) // must be at least '--??'
        return(false);

    // is it an option (check for '--')
    if (_string.compare(0, 2, "--"))
        return(false);
    else
        return(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57e0
cmpq $0x4, %rax
jae 0x40e61
movb $0x0, -0x1(%rbp)
jmp 0x40e89
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
leaq 0x22cbe(%rip), %rcx     # 0x63b33
callq 0x56b0
cmpl $0x0, %eax
je 0x40e85
movb $0x0, -0x1(%rbp)
jmp 0x40e89
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)