LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::convert_string_to_number(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:
leaq -0x2(%rdi), %rax
leaq 0x5c63(%rip), %rcx      # 0x31cb0
movzbl 0x2(%rax), %esi
incq %rax
testb $0x8, (%rsi,%rcx)
jne 0x2c04d
xorl %edx, %edx
cmpb $0x2d, %sil
sete %dl
movzbl 0x1(%rax,%rdx), %esi
testq %rsi, %rsi
je 0x2c0c8
leaq -0x3a(%rsi), %r8
cmpq $-0xb, %r8
ja 0x2c08b
cmpl $0x2e, %esi
jne 0x2c0c8
movzbl 0x2(%rax,%rdx), %esi
addq $-0x3a, %rsi
cmpq $-0xa, %rsi
jb 0x2c0c8
movzbl 0x1(%rax,%rdx), %esi
leaq -0x3a(%rsi), %r8
incq %rax
cmpq $-0xb, %r8
ja 0x2c08b
cmpb $0x2e, %sil
jne 0x2c0b5
movzbl 0x1(%rax,%rdx), %esi
addq $-0x3a, %rsi
incq %rax
cmpq $-0xb, %rsi
ja 0x2c0a3
addq %rdx, %rax
movzbl (%rax), %edx
incq %rax
testb $0x8, (%rdx,%rcx)
jne 0x2c0b8
testb %dl, %dl
je 0x2c0d1
movsd 0x56b0(%rip), %xmm0     # 0x31780
retq
xorl %esi, %esi
jmp 0x6840
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movb (%rdi), %cl
addb $-0x10, %cl
cmpb $0x2a, %cl
jae 0x2c9d6
movzbl %cl, %eax
movabsq $0x3000000007f, %rdx    # imm = 0x3000000007F
btq %rax, %rdx
jae 0x2c9d6
movabsq $0x3000000001f, %rax    # imm = 0x3000000001F
shrq %cl, %rax
jmp 0x2ca0e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2c9e8
callq 0x2c9a6
testb %al, %al
je 0x2ca08
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x2ca0c
movq %rbx, %rdi
callq 0x2c9a6
testb %al, %al
je 0x2ca0e
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x2c9f1
jmp 0x2ca0e
xorl %eax, %eax
jmp 0x2ca0e
movb $0x1, %al
andb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
cmpb $0x38, (%rdi)
jne 0x2ca5d
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x2ca3a
cmpb $0x10, (%rcx)
jne 0x2ca3e
cmpb $0x1, 0x3(%rcx)
sete %al
jne 0x2ca3c
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x2ca21
jmp 0x2ca3c
movb $0x1, %al
popq %rcx
retq
leaq 0x7738(%rip), %rdi      # 0x3417d
leaq 0x54d9(%rip), %rsi      # 0x31f25
leaq 0x76db(%rip), %rcx      # 0x3412e
movl $0x2ad5, %edx           # imm = 0x2AD5
callq 0x6120
leaq 0x76b8(%rip), %rdi      # 0x3411c
leaq 0x54ba(%rip), %rsi      # 0x31f25
leaq 0x76bc(%rip), %rcx      # 0x3412e
movl $0x2ad1, %edx           # imm = 0x2AD1
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::string_value(pugi::xpath_node const&, pugi::impl::(anonymous namespace)::xpath_allocator*)
PUGI__FN xpath_string string_value(const xpath_node& na, xpath_allocator* alloc)
	{
		if (na.attribute())
			return xpath_string::from_const(na.attribute().value());
		else
		{
			xml_node n = na.node();

			switch (n.type())
			{
			case node_pcdata:
			case node_cdata:
			case node_comment:
			case node_pi:
				return xpath_string::from_const(n.value());

			case node_document:
			case node_element:
			{
				xpath_string result;

				// element nodes can have value if parse_embed_pcdata was used
				if (n.value()[0])
					result.append(xpath_string::from_const(n.value()), alloc);

				xml_node cur = n.first_child();

				while (cur && cur != n)
				{
					if (cur.type() == node_pcdata || cur.type() == node_cdata)
						result.append(xpath_string::from_const(cur.value()), alloc);

					if (cur.first_child())
						cur = cur.first_child();
					else if (cur.next_sibling())
						cur = cur.next_sibling();
					else
					{
						while (!cur.next_sibling() && cur != n)
							cur = cur.parent();

						if (cur != n) cur = cur.next_sibling();
					}
				}

				return result;
			}

			default:
				return xpath_string();
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2e4b(%rip), %rax      # 0x30109
testq %rdx, %rdx
je 0x2d2ec
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rax, (%rbx)
movb $0x0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
testq %rsi, %rsi
je 0x2d2ce
movq %rcx, %r14
movl (%r15), %ecx
andl $0xf, %ecx
leal -0x3(%rcx), %esi
movq %r15, %rdx
cmpl $0x4, %esi
jb 0x2d2c3
decl %ecx
cmpl $0x1, %ecx
ja 0x2d2ce
leaq 0x2df3(%rip), %r13      # 0x30109
movq %r13, (%rbx)
movb $0x0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq 0x10(%r15), %rax
testq %rax, %rax
cmoveq %r13, %rax
cmpb $0x0, (%rax)
je 0x2d352
movq %rsp, %rsi
movq %rax, (%rsi)
movb $0x0, 0x8(%rsi)
movq $0x0, 0x10(%rsi)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2d3fe
movq 0x20(%r15), %rbp
testq %rbp, %rbp
sete %al
cmpq %r15, %rbp
sete %cl
orb %al, %cl
jne 0x2d2dd
movq %rsp, %r12
movq (%rbp), %rax
andl $0xf, %eax
addq $-0x3, %rax
cmpq $0x1, %rax
ja 0x2d3a9
movq 0x10(%rbp), %rax
testq %rax, %rax
cmoveq %r13, %rax
movq %rax, (%rsp)
movb $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2d3fe
movq 0x20(%rbp), %rax
testq %rax, %rax
jne 0x2d3e3
movq 0x30(%rbp), %rax
testq %rax, %rax
jne 0x2d3e3
jmp 0x2d3c1
movq 0x18(%rax), %rbp
movq %rbp, %rax
movl $0x0, %ebp
testq %rax, %rax
je 0x2d3c1
cmpq %r15, %rax
je 0x2d3da
cmpq $0x0, 0x30(%rax)
je 0x2d3bd
cmpq %r15, %rax
je 0x2d3e3
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x2d2dd
movq %rax, %rbp
cmpq %r15, %rax
jne 0x2d36d
jmp 0x2d2dd
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rax
cmpb $0x0, (%rax)
je 0x2d4c6
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x0, (%rdi)
movb 0x8(%rbx), %cl
jne 0x2d439
testb $0x1, %cl
jne 0x2d439
cmpb $0x0, 0x8(%r14)
je 0x2d4d5
testb $0x1, %cl
je 0x2d444
movq 0x10(%rbx), %r12
jmp 0x2d44c
callq 0x1d379
movq %rax, %r12
cmpb $0x1, 0x8(%r14)
jne 0x2d459
movq 0x10(%r14), %r13
jmp 0x2d464
movq (%r14), %rdi
callq 0x1d379
movq %rax, %r13
cmpb $0x0, 0x8(%rbx)
je 0x2d46f
movq (%rbx), %rsi
jmp 0x2d471
xorl %esi, %esi
leaq 0x1(%r12), %rdx
leaq (%r12,%r13), %rcx
incq %rcx
movq %r15, %rdi
callq 0x2d4da
testq %rax, %rax
je 0x2d4c6
movq %rax, %r15
leaq (%r12,%r13), %rbp
cmpb $0x0, 0x8(%rbx)
jne 0x2d4a5
movq (%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x6090
movq %r15, %rdi
addq %r12, %rdi
movq (%r14), %rsi
movq %r13, %rdx
callq 0x6090
movb $0x0, (%r15,%rbp)
movq %r15, (%rbx)
movb $0x1, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rbx)
jmp 0x2d4c6
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
ja 0x2d79c
movq %rdi, %rbx
leaq 0x29bf(%rip), %r13      # 0x30109
je 0x2d783
movq %rdx, %r14
movq %rsi, %r15
subq %rsi, %r14
leaq 0x1(%r14), %rsi
movq %rcx, %rdi
callq 0x2bfc0
testq %rax, %rax
je 0x2d783
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6090
movb $0x0, (%r12,%r14)
movb $0x1, %al
movq %r12, %r13
jmp 0x2d788
xorl %eax, %eax
xorl %r14d, %r14d
movq %r13, (%rbx)
movb %al, 0x8(%rbx)
movq %r14, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x7167(%rip), %rdi      # 0x3490a
leaq 0x477b(%rip), %rsi      # 0x31f25
leaq 0x7166(%rip), %rcx      # 0x34917
movl $0x1e19, %edx           # imm = 0x1E19
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r14
cmpb $0x0, 0x8(%rdi)
jne 0x2d819
movq %rsi, %r13
movq %rdi, %rbx
movq %r14, %rdi
callq 0x1d379
movq %rax, %r15
movq (%rbx), %r12
leaq 0x1(%rax), %rsi
movq %r13, %rdi
callq 0x2bfc0
testq %rax, %rax
je 0x2d816
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6090
movb $0x0, (%r14,%r15)
movq %r14, (%rbx)
movb $0x1, 0x8(%rbx)
movq %r15, 0x10(%rbx)
jmp 0x2d819
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdi, %rax
movb (%rdi), %dil
testb %dil, %dil
je 0x2d890
leaq 0x4478(%rip), %rcx      # 0x31cb0
movq %rax, %rsi
movq %rax, %rdx
movzbl %dil, %r8d
testb $0x8, (%r8,%rcx)
jne 0x2d84e
incq %rdx
jmp 0x2d866
movzbl 0x1(%rdx), %edi
incq %rdx
testb $0x8, (%rdi,%rcx)
jne 0x2d84e
movb $0x20, %dil
movq %rax, %r8
cmpq %rax, %rsi
je 0x2d86f
movb %dil, (%rsi)
incq %rsi
movq %rsi, %r8
movb (%rdx), %dil
movq %r8, %rsi
testb %dil, %dil
jne 0x2d83e
cmpq %rax, %r8
je 0x2d890
leaq -0x1(%r8), %rax
movzbl -0x1(%r8), %edx
testb $0x8, (%rdx,%rcx)
cmoveq %r8, %rax
movb $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.hpp
// Function: pugi::xml_attribute pugi::xml_node::find_attribute<pugi::impl::(anonymous namespace)::namespace_uri_predicate>(pugi::impl::(anonymous namespace)::namespace_uri_predicate) const
xml_attribute find_attribute(Predicate pred) const
		{
			if (!_root) return xml_attribute();

			for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
				if (pred(attrib))
					return attrib;

			return xml_attribute();
		}

// Assembly:
testq %rdi, %rdi
je 0x2d951
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x2d951
leaq 0x2826(%rip), %rcx      # 0x30109
leaq 0x6df0(%rip), %rdi      # 0x346da
movq 0x8(%rax), %r8
testq %r8, %r8
cmoveq %rcx, %r8
movb $0x78, %r10b
xorl %r9d, %r9d
cmpb %r10b, (%r8,%r9)
jne 0x2d948
movb 0x1(%r9,%rdi), %r10b
incq %r9
cmpq $0x5, %r9
jne 0x2d8fb
movb 0x5(%r8), %r9b
testq %rsi, %rsi
je 0x2d943
cmpb $0x3a, %r9b
jne 0x2d948
testq %rdx, %rdx
je 0x2d939
xorl %r9d, %r9d
movb 0x6(%r8,%r9), %r10b
cmpb (%rsi,%r9), %r10b
jne 0x2d948
incq %r9
cmpq %r9, %rdx
jne 0x2d926
cmpb $0x0, 0x6(%r8,%rdx)
jne 0x2d948
jmp 0x2d953
testb %r9b, %r9b
je 0x2d953
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x2d8ea
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_node_set_raw::append(pugi::xpath_node const*, pugi::xpath_node const*, pugi::impl::(anonymous namespace)::xpath_allocator*)
void append(const xpath_node* begin_, const xpath_node* end_, xpath_allocator* alloc)
		{
			if (begin_ == end_) return;

			size_t size_ = static_cast<size_t>(_end - _begin);
			size_t capacity = static_cast<size_t>(_eos - _begin);
			size_t count = static_cast<size_t>(end_ - begin_);

			if (size_ + count > capacity)
			{
				// reallocate the old array or allocate a new one
				xpath_node* data = static_cast<xpath_node*>(alloc->reallocate(_begin, capacity * sizeof(xpath_node), (size_ + count) * sizeof(xpath_node)));
				if (!data) return;

				// finalize
				_begin = data;
				_end = data + size_;
				_eos = data + size_ + count;
			}

			memcpy(_end, begin_, count * sizeof(xpath_node));
			_end += count;
		}

// Assembly:
cmpq %rdx, %rsi
je 0x2d9e7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
movq %rdi, %r12
subq %rsi, %r12
movq %r12, %r8
sarq $0x4, %r8
movq 0x18(%r14), %rdx
subq %rsi, %rdx
movq %rdx, %r9
sarq $0x4, %r9
subq %r15, %rbx
movq %rbx, %rax
sarq $0x4, %rax
addq %r8, %rax
cmpq %r9, %rax
jbe 0x2d9cd
shlq $0x4, %rax
movq %rcx, %rdi
movq %rax, %rcx
callq 0x2d4da
testq %rax, %rax
je 0x2d9dc
movq %rax, 0x8(%r14)
addq %rax, %r12
movq %r12, 0x10(%r14)
leaq (%r12,%rbx), %rax
movq %rax, 0x18(%r14)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6090
addq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: void pugi::impl::(anonymous namespace)::xpath_ast_node::step_fill<pugi::impl::(anonymous namespace)::axis_to_type<(pugi::impl::(anonymous namespace)::axis_t)6>>(pugi::impl::(anonymous namespace)::xpath_node_set_raw&, pugi::xpath_node const&, pugi::impl::(anonymous namespace)::xpath_allocator*, bool, pugi::impl::(anonymous namespace)::axis_to_type<(pugi::impl::(anonymous namespace)::axis_t)6>)
void step_fill(xpath_node_set_raw& ns, const xpath_node& xn, xpath_allocator* alloc, bool once, T v)
		{
			const axis_t axis = T::axis;
			const bool axis_has_attributes = (axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_descendant_or_self || axis == axis_following || axis == axis_parent || axis == axis_preceding || axis == axis_self);

			if (xn.node())
				step_fill(ns, xn.node().internal_object(), alloc, once, v);
			else if (axis_has_attributes && xn.attribute() && xn.parent())
				step_fill(ns, xn.attribute().internal_object(), xn.parent().internal_object(), alloc, once, v);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
testq %rax, %rax
setne %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
je 0x2f55a
testq %rax, %rax
setne %al
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x2f56c
movq 0x20(%rcx), %r13
testq %r13, %r13
jne 0x2f536
jmp 0x2f52d
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
je 0x2f56c
movq 0x30(%rcx), %r13
testq %r13, %r13
je 0x2f524
movq 0x20(%r12), %rsi
movzbl 0x3(%r12), %edi
movq %r15, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x2ef1a
andb %bl, %al
movq %r13, %rcx
cmpb $0x1, %al
jne 0x2f519
jmp 0x2f56c
movq 0x30(%rcx), %r13
testq %r13, %r13
jne 0x2f57b
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x2f55a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%r12), %rsi
movzbl 0x3(%r12), %edi
movq %r15, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x2ef1a
testb %bl, %al
jne 0x2f56c
movq 0x20(%r13), %rbp
testq %rbp, %rbp
jne 0x2f5b5
jmp 0x2f5ac
movq 0x18(%r13), %r13
testq %r13, %r13
je 0x2f56c
movq 0x30(%r13), %rbp
testq %rbp, %rbp
je 0x2f5a3
movq 0x20(%r12), %rsi
movzbl 0x3(%r12), %edi
movq %r15, %rdx
movq %rbp, %rcx
movq %r14, %r8
callq 0x2ef1a
movq %rbp, %r13
jmp 0x2f594
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::apply_predicates(pugi::impl::(anonymous namespace)::xpath_node_set_raw&, unsigned long, pugi::impl::(anonymous namespace)::xpath_stack const&, pugi::impl::(anonymous namespace)::nodeset_eval_t)
void apply_predicates(xpath_node_set_raw& ns, size_t first, const xpath_stack& stack, nodeset_eval_t eval)
		{
			if (ns.size() == first) return;

			bool last_once = eval_once(ns.type(), eval);

			for (xpath_ast_node* pred = _right; pred; pred = pred->_next)
				pred->apply_predicate(ns, first, stack, !pred->_next && last_once);
		}

// Assembly:
movq 0x10(%rsi), %rax
subq 0x8(%rsi), %rax
sarq $0x4, %rax
cmpq %rdx, %rax
je 0x2ef18
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
xorl %eax, %eax
testl %r8d, %r8d
setne %al
xorl %ebp, %ebp
cmpl $0x1, %r8d
sete %bpl
cmpl $0x1, (%rsi)
cmovel %eax, %ebp
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x2ef10
movq %rcx, %rbx
movq %rdx, %r14
cmpq $0x0, 0x18(%r12)
sete %al
andb %bpl, %al
movzbl %al, %r8d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2da8a
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x2eee5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::step_push(pugi::impl::(anonymous namespace)::xpath_node_set_raw&, pugi::xml_attribute_struct*, pugi::xml_node_struct*, pugi::impl::(anonymous namespace)::xpath_allocator*)
bool step_push(xpath_node_set_raw& ns, xml_attribute_struct* a, xml_node_struct* parent, xpath_allocator* alloc)
		{
			assert(a);

			const char_t* name = a->name ? a->name + 0 : PUGIXML_TEXT("");

			switch (_test)
			{
			case nodetest_name:
				if (strequal(name, _data.nodetest) && is_xpath_attribute(name))
				{
					ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
					return true;
				}
				break;

			case nodetest_type_node:
			case nodetest_all:
				if (is_xpath_attribute(name))
				{
					ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
					return true;
				}
				break;

			case nodetest_all_in_namespace:
				if (starts_with(name, _data.nodetest) && is_xpath_attribute(name))
				{
					ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
					return true;
				}
				break;

			default:
				;
			}

			return false;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rcx, %rcx
je 0x2f249
movq %rcx, %r15
movq 0x8(%rcx), %rax
testq %rax, %rax
leaq 0xfdc(%rip), %r13       # 0x30109
cmovneq %rax, %r13
movzbl %dil, %ecx
xorl %eax, %eax
decl %ecx
cmpl $0x7, %ecx
ja 0x2f23b
movq %r9, %rbx
movq %r8, %r12
movq %rdx, %r14
leaq 0x2ad6(%rip), %rdx      # 0x31c28
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb $0x78, %dl
xorl %eax, %eax
leaq 0x5574(%rip), %rcx      # 0x346da
cmpb %dl, (%r13,%rax)
jne 0x2f1fa
movb 0x1(%rax,%rcx), %dl
incq %rax
cmpq $0x5, %rax
jne 0x2f166
jmp 0x2f1ea
movq %r13, %rdi
callq 0x1d7f1
testb %al, %al
je 0x2f227
movb $0x78, %dl
xorl %eax, %eax
leaq 0x553f(%rip), %rcx      # 0x346da
cmpb %dl, (%r13,%rax)
jne 0x2f1fa
movb 0x1(%rax,%rcx), %dl
incq %rax
cmpq $0x5, %rax
jne 0x2f19b
jmp 0x2f1ea
movb (%rsi), %al
testb %al, %al
je 0x2f1cb
xorl %ecx, %ecx
cmpb %al, (%r13,%rcx)
jne 0x2f227
movb 0x1(%rsi,%rcx), %al
incq %rcx
testb %al, %al
jne 0x2f1b9
movb $0x78, %dl
xorl %eax, %eax
leaq 0x5504(%rip), %rcx      # 0x346da
cmpb %dl, (%r13,%rax)
jne 0x2f1fa
movb 0x1(%rax,%rcx), %dl
incq %rax
cmpq $0x5, %rax
jne 0x2f1d6
movzbl 0x5(%r13), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x2f23b
cmpl $0x3a, %ecx
je 0x2f23b
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x2f22b
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2f239
xorl %eax, %eax
jmp 0x2f23b
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2f806
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x17f2(%rip), %rdi      # 0x30a42
leaq 0x2cce(%rip), %rsi      # 0x31f25
leaq 0x5e15(%rip), %rcx      # 0x35073
movl $0x25ce, %edx           # imm = 0x25CE
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_node_set_raw::push_back_grow(pugi::xpath_node const&, pugi::impl::(anonymous namespace)::xpath_allocator*)
PUGI__FN_NO_INLINE void xpath_node_set_raw::push_back_grow(const xpath_node& node, xpath_allocator* alloc)
	{
		size_t capacity = static_cast<size_t>(_eos - _begin);

		// get new capacity (1.5x rule)
		size_t new_capacity = capacity + capacity / 2 + 1;

		// reallocate the old array or allocate a new one
		xpath_node* data = static_cast<xpath_node*>(alloc->reallocate(_begin, capacity * sizeof(xpath_node), new_capacity * sizeof(xpath_node)));
		if (!data) return;

		// finalize
		_begin = data;
		_end = data + capacity;
		_eos = data + new_capacity;

		// push
		*_end++ = node;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rsi
movq 0x18(%rdi), %r14
subq %rsi, %r14
movq %r14, %rax
sarq $0x4, %rax
movq %rax, %rcx
shrq %rcx
leaq (%rax,%rcx), %r12
incq %r12
shlq $0x4, %r12
movq %rdx, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2d4da
testq %rax, %rax
je 0x2f869
movq %rax, 0x8(%r15)
addq %rax, %r12
movq %r12, 0x18(%r15)
leaq (%rax,%r14), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%r15)
movups (%rbx), %xmm0
movups %xmm0, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/driver.cc
// Function: report_error(int, int)
void report_error( /* ARGUMENTS                            */
 int error_code,   /* the code number of the error message */
 int print_stack)  /* print stack if ON, otherwise not     */
{
  char interp_error_text_buf[LINELEN];
  int k;

  error_text(error_code, interp_error_text_buf, 5); /* for coverage of code */
  error_text(error_code, interp_error_text_buf, LINELEN);
  fprintf(stderr, "%s\n",
          ((interp_error_text_buf[0] == 0) ? "Unknown error, bad error code" : interp_error_text_buf));
  line_text(interp_error_text_buf, LINELEN);
  fprintf(stderr, "%s\n", interp_error_text_buf);
  if (print_stack == ON)
    {
      for (k = 0; ; k++)
        {
          stack_name(k, interp_error_text_buf, LINELEN);
          if (interp_error_text_buf[0] != 0)
            fprintf(stderr, "%s\n", interp_error_text_buf);
          else
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movl %edi, %r12d
leaq 0x8eb0(%rip), %r15      # 0xd1d0
leaq -0x130(%rbp), %r14
pushq $0x5
popq %rcx
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4110
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movl $0xff, %ecx
callq 0x4110
movq 0x8c8e(%rip), %r13      # 0xcfe0
cmpb $0x0, (%r14)
movq (%r13), %rdi
leaq 0x4ca7(%rip), %rdx      # 0x9008
cmovneq %r14, %rdx
leaq 0x4c98(%rip), %r12      # 0x9004
movq %r12, %rsi
xorl %eax, %eax
callq 0x4230
movq %r15, %rdi
movq %r14, %rsi
movl $0xff, %edx
callq 0x4250
movq (%r13), %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4230
cmpl $0x1, %ebx
jne 0x4404
leaq 0x8e2d(%rip), %rdi      # 0xd1d0
leaq -0x130(%rbp), %rbx
xorl %esi, %esi
movq %rbx, %rdx
movl $0xff, %ecx
callq 0x4190
cmpb $0x0, (%rbx)
je 0x4404
pushq $0x1
popq %rbx
leaq 0x4c3c(%rip), %r14      # 0x9004
leaq -0x130(%rbp), %r15
leaq 0x8dfa(%rip), %r12      # 0xd1d0
movq (%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4230
movq %r12, %rdi
movl %ebx, %esi
movq %r15, %rdx
movl $0xff, %ecx
callq 0x4190
incl %ebx
cmpb $0x0, -0x130(%rbp)
jne 0x43d6
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/driver.cc
// Function: fpga_spi_init()
int fpga_spi_init(void)
{
	int err = 0;
	static uint8_t mode = SPI_CPHA;

	spi_fd = open("/dev/spidev0.0",O_RDWR);
	if(spi_fd < 0)
		pabort("/dev/spidev0.0");
	err = ioctl(spi_fd, SPI_IOC_WR_MODE, &mode);
	if (err == -1)
		pabort("set spi mode");
	return spi_fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x46e0(%rip), %rdi      # 0x903c
movl $0x2, %esi
xorl %eax, %eax
callq 0x4120
movl %eax, 0x885a(%rip)      # 0xd1c8
testl %eax, %eax
js 0x4994
leaq 0x881b(%rip), %rdx      # 0xd194
movl $0x40016b01, %esi       # imm = 0x40016B01
movl %eax, %edi
xorl %eax, %eax
callq 0x4220
cmpl $-0x1, %eax
je 0x4999
movl 0x8836(%rip), %eax      # 0xd1c8
popq %rbp
retq
callq 0x44a5
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/driver.cc
// Function: main
int main (int argc, char ** argv)
{
	int status;
	int block_delete = OFF;
	int print_stack = OFF;
	char line[LINELEN];

	if (read_tool_file(TOOL_CONFIGURE_PATH) != 0)
		exit(1);

	if ((status = interp_init()) != INTERP_OK)
	{
		report_error(status, print_stack);
		exit(1);
	}
	spi_fd = fpga_spi_init();
	for(; ;)
	{
		char *result;
		printf("READ => ");
		memset(line, 0, sizeof(line));
		result = fgets(line, LINELEN, stdin);
		if (!result || strcmp (line, "quit\n") == 0)
			return 0;
		interpret_one_line(block_delete, print_stack, line);
	}
	close(spi_fd);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x46a7(%rip), %rdi      # 0x9058
callq 0x4681
testl %eax, %eax
jne 0x4a3e
leaq 0x880b(%rip), %rdi      # 0xd1d0
callq 0x42a0
testl %eax, %eax
jne 0x4a48
callq 0x4951
movl %eax, 0x87ef(%rip)      # 0xd1c8
leaq 0x4687(%rip), %rdi      # 0x9067
xorl %eax, %eax
callq 0x4030
leaq -0x110(%rbp), %rbx
movl $0xff, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40e0
movq 0x85cc(%rip), %rax      # 0xcfd0
movq (%rax), %rdx
movq %rbx, %rdi
movl $0xff, %esi
callq 0x4270
testq %rax, %rax
je 0x4a32
movl $0x74697571, %eax       # imm = 0x74697571
xorl -0x110(%rbp), %eax
movzwl -0x10c(%rbp), %ecx
xorl $0xa, %ecx
orl %eax, %ecx
jne 0x4a4f
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
movl $0x1, %edi
callq 0x41d0
movl %eax, %edi
callq 0x44ba
leaq -0x110(%rbp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x464c
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::IniFile(int, _IO_FILE*)
IniFile::IniFile(int _errMask, FILE *_fp)
{
    fp = _fp;
    errMask = _errMask;
    owned = false;

    if(fp != NULL)
        LockFile();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, (%rdi)
movl %esi, 0x50(%rdi)
movb $0x0, 0x28(%rdi)
testq %rdx, %rdx
je 0x4a79
popq %rbp
jmp 0x4a7c
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::LockFile()
bool
IniFile::LockFile(void)
{
    lock.l_type = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0;

    if(fcntl(fileno(fp), F_SETLK, &lock) == -1){
        if(owned)
            fclose(fp);

        fp = NULL;
        return(false);
    }

    return(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq (%rdi), %rdi
callq 0x4180
movl %eax, %edi
movl $0x6, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4100
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x4ace
cmpb $0x1, 0x28(%rbx)
jne 0x4ac7
movq (%rbx), %rdi
callq 0x4170
movq $0x0, (%rbx)
cmpl $-0x1, %r14d
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::Open(char const*)
bool
IniFile::Open(const char *file)
{
    char                        path[LINELEN] = "";

    if(IsOpen()) Close();

    TildeExpansion(file, path);

    if((fp = fopen(path, "r")) == NULL)
        return(false);

    owned = true;

    if(!LockFile())
        return(false);

    return(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x120(%rbp), %rdi
movl $0xff, %edx
xorl %esi, %esi
callq 0x40e0
cmpq $0x0, (%rbx)
je 0x4b11
movq %rbx, %rdi
callq 0x4b58
leaq -0x120(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x4bb0
leaq 0x458a(%rip), %rsi      # 0x90b4
movq %r15, %rdi
callq 0x41b0
movq %rax, (%rbx)
testq %rax, %rax
je 0x4b48
movb $0x1, 0x28(%rbx)
movq %rbx, %rdi
callq 0x4a7c
jmp 0x4b4a
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::Close()
bool
IniFile::Close()
{
    int                         rVal = 0;

    if(fp != NULL){
        lock.l_type = F_UNLCK;
        fcntl(fileno(fp), F_SETLKW, &lock);

        if(owned)
            rVal = fclose(fp);

        fp = NULL;
    }

    return(rVal == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4ba8
leaq 0x8(%rbx), %r14
movw $0x2, 0x8(%rbx)
callq 0x4180
movl %eax, %edi
movl $0x7, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4100
movb $0x1, %al
cmpb $0x1, 0x28(%rbx)
jne 0x4b9f
movq (%rbx), %rdi
callq 0x4170
testl %eax, %eax
sete %al
movq $0x0, (%rbx)
jmp 0x4baa
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::TildeExpansion(char const*, char*)
void
IniFile::TildeExpansion(const char *file, char *path)
{
    char                        *home;

    strncpy(path, file, LINELEN);
    if (strlen(file) < 2 || !(file[0] == '~' && file[1] == '/')) {
	/* no tilde expansion required, or unsupported
           tilde expansion type requested */
	return;
    }

    home = getenv("HOME");
    if (!home || strlen(home) + strlen(file) > LINELEN) {
	return;
    }

    /* Buffer overflow has already been checked. */

    strcpy(path, home);
    strcat(path, file + 1);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl $0xff, %edx
movq %r14, %rdi
callq 0x40d0
movq %rbx, %rdi
callq 0x40a0
cmpq $0x2, %rax
jb 0x4c11
cmpb $0x7e, (%rbx)
jne 0x4c11
cmpb $0x2f, 0x1(%rbx)
jne 0x4c11
movq %rax, %r15
leaq 0x44d1(%rip), %rdi      # 0x90c2
callq 0x41e0
testq %rax, %rax
je 0x4c11
movq %rax, %r12
movq %rax, %rdi
callq 0x40a0
addq %r15, %rax
cmpq $0xff, %rax
jbe 0x4c1a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
incq %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4150
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::Find(int*, int, int, char const*, char const*, int)
IniFile::ErrorCode                   
IniFile::Find(int *result, int min, int max,
              const char *tag, const char *section, int num)
{
    ErrorCode                   errCode;
    int                         tmp;

    if((errCode = Find(&tmp, tag, section, num)) != ERR_NONE)
        return(errCode);

    if((tmp > max) || (tmp < min))
        return(ERR_LIMITS);

    *result = tmp;

    return(ERR_NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rax
movl %ecx, %r15d
movl %edx, %r14d
movq %rsi, %rbx
movl 0x10(%rbp), %r8d
leaq -0x1c(%rbp), %rsi
movq %rax, %rdx
movq %r9, %rcx
callq 0x4c90
testl %eax, %eax
jne 0x4c85
movl -0x1c(%rbp), %ecx
cmpl %r15d, %ecx
setg %al
cmpl %r14d, %ecx
setl %dl
orb %al, %dl
movl $0x10, %eax
jne 0x4c85
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::Find(int*, char const*, char const*, int)
IniFile::ErrorCode                   
IniFile::Find(int *result, const char *tag, const char *section, int num)
{
    const char                  *pStr;
    int                         tmp;

    if((pStr = Find(tag, section, num)) == NULL){
        // We really need an ErrorCode return from Find() and should be passing
        // in a buffer. Just pick a suitable ErrorCode for now.
        return(ERR_TAG_NOT_FOUND);
    }

    if(sscanf(pStr, "%i", &tmp) != 1){
        ThrowException(ERR_CONVERSION);
        return(ERR_CONVERSION);
    }

    *result = tmp;

    return(ERR_NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0x4d02
testq %rax, %rax
je 0x4cd8
leaq 0x43fc(%rip), %rsi      # 0x90b6
xorl %r15d, %r15d
leaq -0x1c(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4160
cmpl $0x1, %eax
jne 0x4ce0
movl -0x1c(%rbp), %eax
movl %eax, (%r14)
jmp 0x4cf3
movl $0x4, %r15d
jmp 0x4cf3
movl $0x8, %r15d
movq %rbx, %rdi
movl $0x8, %esi
callq 0x5048
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::ThrowException(IniFile::ErrorCode)
void
IniFile::ThrowException(ErrorCode errCode)
{
    if(errCode & errMask){
        exception.errCode = errCode;
        exception.tag = tag;
        exception.section = section;
        exception.num = num;
        exception.lineNo = lineNo;
        throw(exception);
    }
}

// Assembly:
testl %esi, 0x50(%rdi)
jne 0x504e
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x30(%rdi)
movups 0x58(%rdi), %xmm0
movups %xmm0, 0x38(%rdi)
movl 0x68(%rdi), %eax
movl %eax, 0x48(%rdi)
movl 0x54(%rdi), %eax
movl %eax, 0x4c(%rdi)
movl $0x20, %edi
callq 0x40c0
movups 0x30(%rbx), %xmm0
movups 0x40(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
leaq 0x7cc2(%rip), %rsi      # 0xcd50
movq %rax, %rdi
xorl %edx, %edx
callq 0x4290
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::Find(double*, char const*, char const*, int)
IniFile::ErrorCode                   
IniFile::Find(double *result, const char *tag, const char *section, int num)
{
    const char                  *pStr;
    double                      tmp;

    if((pStr = Find(tag, section, num)) == NULL){
        // We really need an ErrorCode return from Find() and should be passing
        // in a buffer. Just pick a suitable ErrorCode for now.
        return(ERR_TAG_NOT_FOUND);
    }

    if(sscanf(pStr, "%lf", &tmp) != 1){
        ThrowException(ERR_CONVERSION);
        return(ERR_CONVERSION);
    }

    *result = tmp;

    return(ERR_NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0x4d02
testq %rax, %rax
je 0x5130
leaq 0x3fab(%rip), %rsi      # 0x90b9
xorl %r15d, %r15d
leaq -0x20(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4160
cmpl $0x1, %eax
jne 0x5138
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%r14)
jmp 0x514b
movl $0x4, %r15d
jmp 0x514b
movl $0x8, %r15d
movq %rbx, %rdi
movl $0x8, %esi
callq 0x5048
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::Find(int*, IniFile::StrIntPair*, char const*, char const*, int)
IniFile::ErrorCode
IniFile::Find(int *result, StrIntPair *pPair,
     const char *tag, const char *section, int num)
{
    const char                  *pStr;
    int                         tmp;

    if((pStr = Find(tag, section, num)) == NULL){
        // We really need an ErrorCode return from Find() and should be passing
        // in a buffer. Just pick a suitable ErrorCode for now.
        return(ERR_TAG_NOT_FOUND);
    }

    if(sscanf(pStr, "%i", &tmp) == 1){
        *result = tmp;
        return(ERR_NONE);
    }

    while(pPair->pStr != NULL){
        if(strcasecmp(pStr, pPair->pStr) == 0){
            *result = pPair->value;
            return(ERR_NONE);
        }
        pPair++;
    }

    ThrowException(ERR_CONVERSION);
    return(ERR_CONVERSION);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %r8, %rdx
movl %r9d, %ecx
callq 0x4d02
testq %rax, %rax
je 0x51ab
movq %rax, %r12
leaq 0x3f28(%rip), %rsi      # 0x90b6
xorl %r13d, %r13d
leaq -0x2c(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4160
cmpl $0x1, %eax
jne 0x51b3
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
jmp 0x51f5
movl $0x4, %r13d
jmp 0x51f5
movq (%r15), %rsi
testq %rsi, %rsi
je 0x51d7
addq $0x10, %r15
movq %r12, %rdi
callq 0x41a0
testl %eax, %eax
je 0x51ec
movq (%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x51bf
movl $0x8, %r13d
movq %r14, %rdi
movl $0x8, %esi
callq 0x5048
jmp 0x51f5
movl -0x8(%r15), %eax
movl %eax, (%rbx)
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::Find(double*, IniFile::StrDoublePair*, char const*, char const*, int)
IniFile::ErrorCode
IniFile::Find(double *result, StrDoublePair *pPair,
     const char *tag, const char *section, int num)
{
    const char                  *pStr;
    double                      tmp;

    if((pStr = Find(tag, section, num)) == NULL){
        // We really need an ErrorCode return from Find() and should be passing
        // in a buffer. Just pick a suitable ErrorCode for now.
        return(ERR_TAG_NOT_FOUND);
    }

    if(sscanf(pStr, "%lf", &tmp) == 1){
        *result = tmp;
        return(ERR_NONE);
    }

    while(pPair->pStr != NULL){
        if(strcasecmp(pStr, pPair->pStr) == 0){
            *result = pPair->value;
            return(ERR_NONE);
        }
        pPair++;
    }

    ThrowException(ERR_CONVERSION);
    return(ERR_CONVERSION);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %r8, %rdx
movl %r9d, %ecx
callq 0x4d02
testq %rax, %rax
je 0x525d
movq %rax, %r12
leaq 0x3e7d(%rip), %rsi      # 0x90b9
xorl %r13d, %r13d
leaq -0x30(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4160
cmpl $0x1, %eax
jne 0x5265
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx)
jmp 0x52ab
movl $0x4, %r13d
jmp 0x52ab
movq (%r15), %rsi
testq %rsi, %rsi
je 0x5289
addq $0x10, %r15
movq %r12, %rdi
callq 0x41a0
testl %eax, %eax
je 0x529e
movq (%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x5271
movl $0x8, %r13d
movq %r14, %rdi
movl $0x8, %esi
callq 0x5048
jmp 0x52ab
movsd -0x8(%r15), %xmm0
movsd %xmm0, (%rbx)
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::CheckIfOpen()
bool
IniFile::CheckIfOpen(void)
{
    if(IsOpen())
        return(true);

    ThrowException(ERR_NOT_OPEN);

    return(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
jne 0x52d6
movl $0x1, %esi
callq 0x5048
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: check_line_endings(char const*)
static bool check_line_endings(const char *s) {
    if(!s) return false;
    for(; *s; s++ ) {
        if(*s == '\r') {
            char c = s[1];
            if(c == '\n' || c == '\0') {
                static bool warned = 0;
                if(!warned) 
                    fprintf(stderr, "inifile: warning: File contains DOS-style line endings.\n");
                warned = true;
                continue;
            }
            fprintf(stderr, "inifile: error: File contains ambiguous carriage returns\n");
            return true;
        }
    }
    return false;
}

// Assembly:
movb 0x8ef7(%rip), %al       # 0xe1e0
testb %al, %al
je 0x5335
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x8ee7(%rip), %rbx      # 0xe1e1
cmpb $0xd, %al
jne 0x531a
movzbl (%rbx), %eax
cmpl $0xa, %eax
je 0x530a
testl %eax, %eax
jne 0x5338
cmpb $0x0, 0x8fd0(%rip)      # 0xe2e1
je 0x5325
movb $0x1, 0x8fc7(%rip)      # 0xe2e1
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x52fa
jmp 0x532c
callq 0x44cd
jmp 0x5313
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
callq 0x44fc
movb $0x1, %al
jmp 0x532e
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/inifile.cc
// Function: IniFile::Exception::Print(_IO_FILE*)
void
IniFile::Exception::Print(FILE *fp)
{
    const char                  *msg;

    switch(errCode){
    case ERR_NONE:
        msg = "ERR_NONE";
        break;

    case ERR_NOT_OPEN:
        msg = "ERR_NOT_OPEN";
        break;

    case ERR_SECTION_NOT_FOUND:
        msg = "ERR_SECTION_NOT_FOUND";
        break;

    case ERR_TAG_NOT_FOUND:
        msg = "ERR_TAG_NOT_FOUND";
        break;

    case ERR_CONVERSION:
        msg = "ERR_CONVERSION";
        break;

    case ERR_LIMITS:
        msg = "ERR_LIMITS";
        break;

    default:
        msg = "UNKNOWN";
    }

    fprintf(fp, "INIFILE: %s, section=%s, tag=%s, num=%d, lineNo=%d\n",
            msg, section, tag, num, lineNo);
}

// Assembly:
movq %rsi, %rax
movl (%rdi), %ecx
cmpq $0x8, %rcx
ja 0x53de
leaq 0x3cc4(%rip), %rdx      # 0x9090
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x3ceb(%rip), %rdx      # 0x90c7
jmp 0x5417
cmpl $0x10, %ecx
jne 0x53ec
leaq 0x3d2a(%rip), %rdx      # 0x9114
jmp 0x5417
leaq 0x3d2c(%rip), %rdx      # 0x911f
jmp 0x5417
leaq 0x3d09(%rip), %rdx      # 0x9105
jmp 0x5417
leaq 0x3cd8(%rip), %rdx      # 0x90dd
jmp 0x5417
leaq 0x3cc2(%rip), %rdx      # 0x90d0
jmp 0x5417
leaq 0x3cdc(%rip), %rdx      # 0x90f3
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rcx
movl 0x18(%rdi), %r9d
movl 0x1c(%rdi), %esi
movl %esi, (%rsp)
leaq 0x3cef(%rip), %rsi      # 0x9127
movq %rax, %rdi
xorl %eax, %eax
callq 0x4230
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/saicanon.cc
// Function: print_nc_line_number()
void print_nc_line_number()
{
  char text[256];
  int k;
  int m;

  if(NULL == _outfile)
    {
      _outfile = stdout;
    }

  interp_new.line_text(text, 256);
  for (k = 0;
       ((k < 256) &&
        ((text[k] == '\t') || (text[k] == ' ') || (text[k] == '/')));
       k++);
  if ((k < 256) && ((text[k] == 'n') || (text[k] == 'N')))
    {
      fputc('N', _outfile);
      for (k++, m = 0;
           ((k < 256) && (text[k] >= '0') && (text[k] <= '9'));
           k++, m++)
        fputc(text[k], _outfile);
      for (; m < 6; m++)
        fputc(' ', _outfile);
    }
  else if (k < 256)
    fprintf(_outfile, "N..... ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
cmpq $0x0, 0x8e08(%rip)      # 0xe2f0
jne 0x54fb
movq 0x7ac7(%rip), %rax      # 0xcfb8
movq (%rax), %rax
movq %rax, 0x8df5(%rip)      # 0xe2f0
leaq 0x7cce(%rip), %rdi      # 0xd1d0
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4250
xorl %ebx, %ebx
movabsq $0x800100000200, %rax   # imm = 0x800100000200
movzbl -0x120(%rbp,%rbx), %ecx
cmpq $0x2f, %rcx
ja 0x5544
btq %rcx, %rax
jae 0x5544
incq %rbx
cmpq $0x100, %rbx            # imm = 0x100
jne 0x551f
jmp 0x55f0
cmpl $0x4e, %ecx
je 0x554e
cmpl $0x6e, %ecx
jne 0x55ae
movq 0x8d9b(%rip), %rsi      # 0xe2f0
movl $0x4e, %edi
callq 0x41f0
xorl %r14d, %r14d
cmpq $0xfe, %rbx
ja 0x55d6
movl $0xff, %r14d
subq %rbx, %r14
xorl %r15d, %r15d
leaq (%r15,%rbp), %rax
addq $-0x120, %rax           # imm = 0xFEE0
movzbl 0x1(%rbx,%rax), %edi
leal -0x30(%rdi), %eax
cmpb $0x9, %al
ja 0x55cd
movq 0x8d5c(%rip), %rsi      # 0xe2f0
callq 0x41f0
leaq 0x1(%r15), %rax
addl %ebx, %r15d
cmpl $0xfe, %r15d
movq %rax, %r15
jne 0x5577
jmp 0x55d0
movq 0x8d3b(%rip), %rcx      # 0xe2f0
leaq 0x3c54(%rip), %rdi      # 0x9210
movl $0x7, %esi
movl $0x1, %edx
callq 0x42e0
jmp 0x55f0
movl %r15d, %r14d
cmpl $0x5, %r14d
ja 0x55f0
addl $-0x6, %r14d
movq 0x8d0f(%rip), %rsi      # 0xe2f0
movl $0x20, %edi
callq 0x41f0
incl %r14d
jne 0x55da
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/saicanon.cc
// Function: SET_XY_ROTATION(double)
void SET_XY_ROTATION(double t) {
  fprintf(_outfile, "%5d ", _line_number++);
  print_nc_line_number();
  fprintf(_outfile, "SET_XY_ROTATION(%.4f)\n", t);
  // CJR XXX 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movq 0x8cde(%rip), %rdi      # 0xe2f0
movl 0x7b8c(%rip), %edx      # 0xd1a4
leal 0x1(%rdx), %eax
movl %eax, 0x7b83(%rip)      # 0xd1a4
leaq 0x3bf0(%rip), %rsi      # 0x9218
xorl %eax, %eax
callq 0x4230
callq 0x54d0
movq 0x8cb5(%rip), %rdi      # 0xe2f0
leaq 0x3bdb(%rip), %rsi      # 0x921d
movsd -0x8(%rbp), %xmm0
movb $0x1, %al
addq $0x10, %rsp
popq %rbp
jmp 0x4230