LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::namespace_uri(pugi::xml_node)
PUGI__FN const char_t* namespace_uri(xml_node node)
	{
		namespace_uri_predicate pred = node.name();

		xml_node p = node;

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

			if (a) return a.value();

			p = p.parent();
		}

		return PUGIXML_TEXT("");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x42110
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x62230
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x41c30
cmpq $0x0, %rax
je 0x62212
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x622b0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x40990
cmpq $0x0, %rax
je 0x621fb
leaq -0x30(%rbp), %rdi
callq 0x41070
movq %rax, -0x8(%rbp)
jmp 0x6221d
leaq -0x28(%rbp), %rdi
callq 0x426e0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x621a9
leaq 0x6ef0(%rip), %rax      # 0x69109
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x622dd
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x62338
movq -0x38(%rbp), %rdi
callq 0x42960
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x40990
cmpq $0x0, %rax
je 0x6232f
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x62350
testb $0x1, %al
jne 0x62314
jmp 0x62316
jmp 0x62338
jmp 0x62318
leaq -0x8(%rbp), %rdi
callq 0x40b10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x622ea
leaq -0x8(%rbp), %rdi
callq 0x40950
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_string::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)));
			if (!result) return 0;

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

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
shlq $0x0, %rsi
callq 0x5cde0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6243e
movq $0x0, -0x8(%rbp)
jmp 0x62467
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x0, %rdx
callq 0x70b0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::convert_number_to_string_special(double)
PUGI__FN const char_t* convert_number_to_string_special(double value)
	{
	#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__)
		if (_finite(value)) return (value == 0) ? PUGIXML_TEXT("0") : 0;
		if (_isnan(value)) return PUGIXML_TEXT("NaN");
		return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
	#elif defined(fpclassify) && defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO)
		switch (fpclassify(value))
		{
		case FP_NAN:
			return PUGIXML_TEXT("NaN");

		case FP_INFINITE:
			return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");

		case FP_ZERO:
			return PUGIXML_TEXT("0");

		default:
			return 0;
		}
	#else
		// fallback
		const volatile double v = value;

		if (v == 0) return PUGIXML_TEXT("0");
		if (v != v) return PUGIXML_TEXT("NaN");
		if (v * 2 == v) return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
		return 0;
	#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x624b0
jp 0x624b0
leaq 0x9aac(%rip), %rax      # 0x6bf56
movq %rax, -0x8(%rbp)
jmp 0x6251b
movsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x624c4
jp 0x624c4
jmp 0x624d1
leaq 0xc1aa(%rip), %rax      # 0x6e675
movq %rax, -0x8(%rbp)
jmp 0x6251b
movsd -0x18(%rbp), %xmm0
movsd 0x8e62(%rip), %xmm1     # 0x6b340
mulsd %xmm1, %xmm0
movsd -0x18(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x62513
jp 0x62513
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
leaq 0xc17b(%rip), %rax      # 0x6e679
leaq 0xc175(%rip), %rcx      # 0x6e67a
ucomisd %xmm1, %xmm0
cmovaq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6251b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::convert_number_to_mantissa_exponent(double, char (&) [32], char**, int*)
PUGI__FN void convert_number_to_mantissa_exponent(double value, char (&buffer)[32], char** out_mantissa, int* out_exponent)
	{
		// get a scientific notation value with IEEE DBL_DIG decimals
		PUGI__SNPRINTF(buffer, "%.*e", DBL_DIG, value);

		// 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 -0x10(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movl $0x20, %esi
leaq 0xc125(%rip), %rdx      # 0x6e683
movl $0xf, %ecx
movb $0x1, %al
callq 0x74c0
movq -0x10(%rbp), %rdi
movl $0x65, %esi
callq 0x7520
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x62585
jmp 0x625a4
leaq 0xc0fc(%rip), %rdi      # 0x6e688
leaq 0x8dc2(%rip), %rsi      # 0x6b355
movl $0x1fdf, %edx           # imm = 0x1FDF
leaq 0xc0f9(%rip), %rcx      # 0x6e698
callq 0x7180
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x72d0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x625ce
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x625d6
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x41(%rbp)
je 0x62600
movq -0x38(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2e, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x62609
jmp 0x6260b
jmp 0x6262a
leaq 0xc0f8(%rip), %rdi      # 0x6e70a
leaq 0x8d3c(%rip), %rsi      # 0x6b355
movl $0x1fe5, %edx           # imm = 0x1FE5
leaq 0xc073(%rip), %rcx      # 0x6e698
callq 0x7180
movq -0x38(%rbp), %rax
movb (%rax), %cl
movq -0x38(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x62680
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x6271f
jmp 0x62806
movq -0x48(%rbp), %rcx
movq 0x10(%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rdx, %rax
sarq $0x4, %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x627d9
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
shlq $0x4, %rdx
movq -0x28(%rbp), %rcx
addq -0x38(%rbp), %rcx
shlq $0x4, %rcx
callq 0x60fb0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x6279c
jmp 0x62806
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq -0x38(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
shlq $0x4, %rdx
callq 0x70b0
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq $0x4, %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::apply_predicate(pugi::impl::(anonymous namespace)::xpath_node_set_raw&, unsigned long, pugi::impl::(anonymous namespace)::xpath_stack const&, bool)
void apply_predicate(xpath_node_set_raw& ns, size_t first, const xpath_stack& stack, bool once)
		{
			if (ns.size() == first) return;

			assert(_type == ast_filter || _type == ast_predicate);

			if (_test == predicate_constant || _test == predicate_constant_one)
				apply_predicate_number_const(ns, first, _right, stack);
			else if (_right->rettype() == xpath_type_number)
				apply_predicate_number(ns, first, _right, stack, once);
			else
				apply_predicate_boolean(ns, first, _right, stack, once);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61380
cmpq -0x18(%rbp), %rax
jne 0x6290c
jmp 0x629e6
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x11, %ecx
movb %al, -0x31(%rbp)
je 0x6292d
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x10, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x62936
jmp 0x62938
jmp 0x62957
leaq 0xbf02(%rip), %rdi      # 0x6e841
leaq 0x8a0f(%rip), %rsi      # 0x6b355
movl $0x25b8, %edx           # imm = 0x25B8
leaq 0xbf1d(%rip), %rcx      # 0x6e86f
callq 0x7180
movq -0x30(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x2, %eax
je 0x62971
movq -0x30(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x3, %eax
jne 0x6298c
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x64ad0
jmp 0x629e6
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4b490
cmpl $0x2, %eax
jne 0x629c2
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x64cb0
jmp 0x629e4
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x64e50
jmp 0x629e6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xpath_node* pugi::impl::(anonymous namespace)::unique<pugi::xpath_node*>(pugi::xpath_node*, pugi::xpath_node*)
I unique(I begin, I end)
	{
		// fast skip head
		while (end - begin > 1 && *begin != *(begin + 1)) begin++;

		if (begin == end) return begin;

		// last written element
		I write = begin++;

		// merge unique elements
		while (begin != end)
		{
			if (*begin != *write)
				*++write = *begin++;
			else
				begin++;
		}

		// past-the-end (write points to live element)
		return write + 1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, -0x21(%rbp)
jle 0x6469e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x49860
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x646a7
jmp 0x646b5
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x64670
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x646c9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x64742
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x64736
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x49860
testb $0x1, %al
jne 0x646f9
jmp 0x64728
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, -0x20(%rbp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x64734
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x646dc
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::apply_predicate_number(pugi::impl::(anonymous namespace)::xpath_node_set_raw&, unsigned long, pugi::impl::(anonymous namespace)::xpath_ast_node*, pugi::impl::(anonymous namespace)::xpath_stack const&, bool)
static void apply_predicate_number(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack, bool once)
		{
			assert(ns.size() >= first);
			assert(expr->rettype() == xpath_type_number);

			size_t i = 1;
			size_t size = ns.size() - first;

			xpath_node* last = ns.begin() + first;

			// remove_if... or well, sort of
			for (xpath_node* it = last; it != ns.end(); ++it, ++i)
			{
				xpath_context c(*it, i, size);

				if (expr->eval_number(c, stack) == i)
				{
					*last++ = *it;

					if (once) break;
				}
			}

			ns.truncate(last);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
callq 0x61380
cmpq -0x10(%rbp), %rax
jb 0x64ce4
jmp 0x64d03
leaq 0x9c05(%rip), %rdi      # 0x6e8f0
leaq 0x6663(%rip), %rsi      # 0x6b355
movl $0x2580, %edx           # imm = 0x2580
leaq 0x9d3b(%rip), %rcx      # 0x6ea39
callq 0x7180
movq -0x18(%rbp), %rdi
callq 0x4b490
cmpl $0x2, %eax
jne 0x64d13
jmp 0x64d32
leaq 0x9c8a(%rip), %rdi      # 0x6e9a4
leaq 0x6634(%rip), %rsi      # 0x6b355
movl $0x2581, %edx           # imm = 0x2581
leaq 0x9d0c(%rip), %rcx      # 0x6ea39
callq 0x7180
movq $0x1, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x61380
subq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ed40
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ed60
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
je 0x64e2f
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4b5d0
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
callq 0x4c1a0
movaps 0x6543(%rip), %xmm2     # 0x6b300
movq -0x30(%rbp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x6542(%rip), %xmm2     # 0x6b310
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jne 0x64e10
jp 0x64e10
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, -0x40(%rbp)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, -0x21(%rbp)
je 0x64e0e
jmp 0x64e2f
jmp 0x64e10
jmp 0x64e12
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x64d6b
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x64fb0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::apply_predicate_boolean(pugi::impl::(anonymous namespace)::xpath_node_set_raw&, unsigned long, pugi::impl::(anonymous namespace)::xpath_ast_node*, pugi::impl::(anonymous namespace)::xpath_stack const&, bool)
static void apply_predicate_boolean(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack, bool once)
		{
			assert(ns.size() >= first);
			assert(expr->rettype() != xpath_type_number);

			size_t i = 1;
			size_t size = ns.size() - first;

			xpath_node* last = ns.begin() + first;

			// remove_if... or well, sort of
			for (xpath_node* it = last; it != ns.end(); ++it, ++i)
			{
				xpath_context c(*it, i, size);

				if (expr->eval_boolean(c, stack))
				{
					*last++ = *it;

					if (once) break;
				}
			}

			ns.truncate(last);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
callq 0x61380
cmpq -0x10(%rbp), %rax
jb 0x64e81
jmp 0x64ea0
leaq 0x9a68(%rip), %rdi      # 0x6e8f0
leaq 0x64c6(%rip), %rsi      # 0x6b355
movl $0x2566, %edx           # imm = 0x2566
leaq 0x9c3f(%rip), %rcx      # 0x6eada
callq 0x7180
movq -0x18(%rbp), %rdi
callq 0x4b490
cmpl $0x2, %eax
je 0x64eb0
jmp 0x64ecf
leaq 0x9cc5(%rip), %rdi      # 0x6eb7c
leaq 0x6497(%rip), %rsi      # 0x6b355
movl $0x2567, %edx           # imm = 0x2567
leaq 0x9c10(%rip), %rcx      # 0x6eada
callq 0x7180
movq $0x1, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x61380
subq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ed40
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ed60
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
je 0x64f9b
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x4b5d0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rsi
callq 0x4b6c0
testb $0x1, %al
jne 0x64f51
jmp 0x64f7c
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, -0x40(%rbp)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, -0x21(%rbp)
je 0x64f7a
jmp 0x64f9b
jmp 0x64f7c
jmp 0x64f7e
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x64f08
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x64fb0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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)0>>(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)0>)
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
movq %rsp, %rbp
subq $0xa0, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movq -0x20(%rbp), %rdi
callq 0x49680
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41c30
cmpq $0x0, %rax
je 0x650c8
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rdi
callq 0x49680
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x459a0
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x65260
jmp 0x65185
movq -0x20(%rbp), %rdi
callq 0x496d0
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x40990
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x89(%rbp)
je 0x65112
movq -0x20(%rbp), %rdi
callq 0x496f0
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x41c30
cmpq $0x0, %rax
setne %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x6511e
jmp 0x65183
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x496d0
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x410e0
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rdi
callq 0x496f0
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x459a0
movq -0x80(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %r8
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x652f0
jmp 0x65185
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61380
cmpq -0x18(%rbp), %rax
jne 0x651c8
jmp 0x6525a
movq -0x10(%rbp), %rdi
callq 0x4ed80
movl %eax, %edi
movl -0x24(%rbp), %esi
callq 0x628a0
movb %al, %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x25(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6525a
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x39(%rbp)
jne 0x6522c
movb -0x25(%rbp), %al
movb %al, -0x39(%rbp)
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
movb -0x39(%rbp), %al
movzbl %al, %r8d
andl $0x1, %r8d
callq 0x628d0
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x651ef
addq $0x60, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%rax), %rcx
movq 0x8(%rax), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rdx
shrq %rdx
addq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
callq 0x60fb0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x670bf
jmp 0x67112
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq %rax, 0x8(%rdx)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rdx)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rdx)
movq -0x10(%rbp), %rcx
movq 0x10(%rdx), %rax
movq %rax, %rsi
addq $0x10, %rsi
movq %rsi, 0x10(%rdx)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: bool pugi::impl::(anonymous namespace)::strcpy_insitu_allow<unsigned long>(unsigned long, unsigned long const&, unsigned long, char*)
inline bool strcpy_insitu_allow(size_t length, const Header& header, uintptr_t header_mask, char_t* target)
	{
		// never reuse shared memory
		if (header & xml_memory_page_contents_shared_mask) return false;

		size_t target_length = strlength(target);

		// always reuse document buffer memory if possible
		if ((header & header_mask) == 0) return target_length >= length;

		// reuse heap memory if waste is not too great
		const size_t reuse_threshold = 32;

		return target_length >= length && (target_length < reuse_threshold || target_length - length < target_length / 2);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x6718f
movb $0x0, -0x1(%rbp)
jmp 0x67208
movq -0x28(%rbp), %rdi
callq 0x418f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
jne 0x671bf
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
setae %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x67208
movq $0x20, -0x38(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x39(%rbp)
jb 0x67200
movb $0x1, %al
cmpq $0x20, -0x30(%rbp)
movb %al, -0x3a(%rbp)
jb 0x671fa
movq -0x30(%rbp), %rax
subq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: char* pugi::impl::(anonymous namespace)::integer_to_string<unsigned int>(char*, char*, unsigned int, bool)
PUGI__FN PUGI__UNSIGNED_OVERFLOW char_t* integer_to_string(char_t* begin, char_t* end, U value, bool negative)
	{
		char_t* result = end - 1;
		U rest = negative ? 0 - value : 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
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x15(%rbp)
je 0x67426
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x6742c
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 0x67432
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x67475
jmp 0x67494
leaq 0x79f5(%rip), %rdi      # 0x6ee71
leaq 0x3ed2(%rip), %rsi      # 0x6b355
movl $0x120b, %edx           # imm = 0x120B
leaq 0x79f2(%rip), %rcx      # 0x6ee81
callq 0x7180
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
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xml_stream_chunk<char>::destroy(pugi::impl::(anonymous namespace)::xml_stream_chunk<char>*)
static void destroy(xml_stream_chunk* chunk)
		{
			// free chunk chain
			while (chunk)
			{
				xml_stream_chunk* next_ = chunk->next;

				xml_memory::deallocate(chunk);

				chunk = next_;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x67cd5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x2dd1b(%rip), %rax     # 0x959e0
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x67cac
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %esi
leaq -0x110(%rbp), %rdx
leaq 0xad7e(%rip), %rdi      # 0xf1f0
movl $0x5, %ecx
callq 0x4110
movl -0x4(%rbp), %esi
leaq -0x110(%rbp), %rdx
leaq 0xad63(%rip), %rdi      # 0xf1f0
movl $0xff, %ecx
callq 0x4110
movq 0xab42(%rip), %rax      # 0xefe0
movq (%rax), %rax
movq %rax, -0x120(%rbp)
movsbl -0x110(%rbp), %eax
cmpl $0x0, %eax
jne 0x44c4
leaq 0x6b4d(%rip), %rax      # 0xb008
movq %rax, -0x128(%rbp)
jmp 0x44d2
leaq -0x110(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x120(%rbp), %rdi
movq -0x128(%rbp), %rdx
leaq 0x6b1d(%rip), %rsi      # 0xb004
movb $0x0, %al
callq 0x4260
leaq -0x110(%rbp), %rsi
leaq 0xacf4(%rip), %rdi      # 0xf1f0
movl $0xff, %edx
callq 0x4280
movq 0xaad3(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq -0x110(%rbp), %rdx
leaq 0x6ae6(%rip), %rsi      # 0xb004
movb $0x0, %al
callq 0x4260
cmpl $0x1, -0x8(%rbp)
jne 0x4597
movl $0x0, -0x114(%rbp)
movl -0x114(%rbp), %esi
leaq -0x110(%rbp), %rdx
leaq 0xaca7(%rip), %rdi      # 0xf1f0
movl $0xff, %ecx
callq 0x41b0
movsbl -0x110(%rbp), %eax
cmpl $0x0, %eax
je 0x4580
movq 0xaa7a(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq -0x110(%rbp), %rdx
leaq 0x6a8d(%rip), %rsi      # 0xb004
movb $0x0, %al
callq 0x4260
jmp 0x4582
jmp 0x4595
jmp 0x4584
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x4535
jmp 0x4597
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: sundale[P]gcode/driver.cc
// Function: interpret_one_line(int, int, char*)
int interpret_one_line(  /* ARGUMENTS                 */
 int block_delete,            /* switch which is ON or OFF */
 int print_stack,
 char *line)             /* option which is ON or OFF */
{
	int status;
	
	status = interp_read(line);
	if ((status == INTERP_EXECUTE_FINISH) && (block_delete == ON));
	else if (status == INTERP_ENDFILE);
	else if ((status != INTERP_EXECUTE_FINISH) &&
			 (status != INTERP_OK))
	  report_error(status, print_stack);
	else
	  {
		status = interp_execute();
		if ((status == INTERP_EXIT) ||
			(status == INTERP_EXECUTE_FINISH));
		else if (status != INTERP_OK)
		  report_error(status, print_stack);
	  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xac33(%rip), %rdi      # 0xf1f0
callq 0x4050
movl %eax, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x45d3
cmpl $0x1, -0x4(%rbp)
jne 0x45d3
jmp 0x462e
cmpl $0x3, -0x14(%rbp)
jne 0x45db
jmp 0x462c
cmpl $0x2, -0x14(%rbp)
je 0x45f4
cmpl $0x0, -0x14(%rbp)
je 0x45f4
movl -0x14(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x4450
jmp 0x462a
leaq 0xabf5(%rip), %rdi      # 0xf1f0
xorl %eax, %eax
movl %eax, %esi
callq 0x4220
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x4613
cmpl $0x2, -0x14(%rbp)
jne 0x4615
jmp 0x4628
cmpl $0x0, -0x14(%rbp)
je 0x4626
movl -0x14(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x4450
jmp 0x4628
jmp 0x462a
jmp 0x462c
jmp 0x462e
ud2
// File: sundale[P]gcode/driver.cc
// Function: read_tool_file(char const*)
int read_tool_file(  /* ARGUMENTS         */
 const char * tool_file_name)   /* name of tool file */
{
  char buffer[1000];

  if (tool_file_name[0] == 0) /* ask for name if given name is empty string */
    {
      fprintf(stderr, "name of tool file => ");
      fgets(buffer, 1000, stdin);
      buffer[strlen(buffer) - 1] = 0;
      tool_file_name = buffer;
    }

  return loadToolTable(tool_file_name, _tools, 0, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x46a1
movq 0xa98e(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x69ca(%rip), %rsi      # 0xb026
movb $0x0, %al
callq 0x4260
leaq -0x3f0(%rbp), %rdi
movq 0xa95f(%rip), %rax      # 0xefd0
movq (%rax), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x42a0
leaq -0x3f0(%rbp), %rdi
callq 0x40a0
subq $0x1, %rax
movb $0x0, -0x3f0(%rbp,%rax)
leaq -0x3f0(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xbce4(%rip), %rsi      # 0x10390
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x97e0
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/driver.cc
// Function: line_demo(int, int, int, int)
void line_demo(int spi_fd, int x, int y, int z)
{
	uint16_t command_buf[10] = {0};
	int x_direct = 0;
	int y_direct = 0;
	int z_direct = 0;

	if(x>=0)
	{
		x_direct = 0;
	}
	else
	{
		x_direct = 1;
	}
	if(y>=0)
	{
		y_direct = 0;
	}
	else
	{
		y_direct = 1;
	}
	if(z>=0)
	{
		z_direct = 0;
	}
	else
	{
		z_direct = 1;
	}
	x = abs(x);
	y = abs(y);
	z = abs(z);
	command_buf[0] = 100*50;//50~1us
	command_buf[1] = (bit(15)*x_direct)|(x>>16);
	command_buf[2] = x&0x0ffff;
	command_buf[3] = (bit(15)*y_direct)|(y>>16);
	command_buf[4] = y&0x0ffff;
	command_buf[5] = (bit(15)*z_direct)|(z>>16);
	command_buf[6] = z&0x0ffff;
	command_buf[7] = 1;
	spi_write_single(spi_fd, 0x1a, 0xabcd);//reset
	spi_write_single(spi_fd, 0x10e, command_buf[0]);
	spi_write_multi(spi_fd, 0x100, &command_buf[1], 7);
	//usleep(100000);
	//spi_read_single(spi_fd, 0x22);
	//spi_read_single(spi_fd, 0x24);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x40e0
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x4718
movl $0x0, -0x34(%rbp)
jmp 0x471f
movl $0x1, -0x34(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x472e
movl $0x0, -0x38(%rbp)
jmp 0x4735
movl $0x1, -0x38(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x4744
movl $0x0, -0x3c(%rbp)
jmp 0x474b
movl $0x1, -0x3c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x10(%rbp)
movw $0x1388, -0x30(%rbp)    # imm = 0x1388
movl -0x34(%rbp), %eax
shll $0xf, %eax
movl -0x8(%rbp), %ecx
sarl $0x10, %ecx
orl %ecx, %eax
movw %ax, -0x2e(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x2c(%rbp)
movl -0x38(%rbp), %eax
shll $0xf, %eax
movl -0xc(%rbp), %ecx
sarl $0x10, %ecx
orl %ecx, %eax
movw %ax, -0x2a(%rbp)
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x28(%rbp)
movl -0x3c(%rbp), %eax
shll $0xf, %eax
movl -0x10(%rbp), %ecx
sarl $0x10, %ecx
orl %ecx, %eax
movw %ax, -0x26(%rbp)
movl -0x10(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x24(%rbp)
movw $0x1, -0x22(%rbp)
movl -0x4(%rbp), %edi
movl $0x1a, %esi
movl $0xabcd, %edx           # imm = 0xABCD
callq 0x4820
movl -0x4(%rbp), %edi
movl $0x10e, %esi            # imm = 0x10E
movzwl -0x30(%rbp), %edx
callq 0x4820
movl -0x4(%rbp), %edi
leaq -0x30(%rbp), %rdx
addq $0x2, %rdx
movl $0x100, %esi            # imm = 0x100
movl $0x7, %ecx
callq 0x4910
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sundale[P]gcode/driver.cc
// Function: spi_write_single(int, unsigned short, unsigned short)
static uint16_t spi_write_single(int fd,uint16_t addr,uint16_t dat)
{

	int ret;
	uint8_t tx_temp[4];
	uint8_t rx_temp[4];
	struct spi_ioc_transfer tr[2];

	tr[0].tx_buf = (unsigned long)tx_temp,
	tr[0].rx_buf = (unsigned long)rx_temp,
	tr[0].len = 2,
	tr[0].delay_usecs = 0,//delay,
	tr[0].speed_hz = SPI_SPEED,
	tr[0].bits_per_word = SPI_BITS,
	tr[0].cs_change = 0,
	tr[1].tx_buf = (unsigned long)&tx_temp[2],
	tr[1].rx_buf = (unsigned long)rx_temp,
	tr[1].len = 2,
	tr[1].delay_usecs = 0,//delay,
	tr[1].speed_hz = SPI_SPEED,
	tr[1].bits_per_word = SPI_BITS,
	tr[1].cs_change = 0,

	tx_temp[0] = (addr >> 8) | 0x80;
	tx_temp[1] = (addr & 0x00ff);
	tx_temp[2] = dat >> 8;
	tx_temp[3] = dat & 0x00ff;
	memset(rx_temp,0,4);
	ret = ioctl(fd, SPI_IOC_MESSAGE(2), &tr);
	if (ret < 1)
		pabort("can't send spi message");
	return 0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x2, -0x50(%rbp)
movw $0x0, -0x48(%rbp)
movl $0xf4240, -0x4c(%rbp)   # imm = 0xF4240
movb $0x8, -0x46(%rbp)
movb $0x0, -0x45(%rbp)
leaq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x2, -0x30(%rbp)
movw $0x0, -0x28(%rbp)
movl $0xf4240, -0x2c(%rbp)   # imm = 0xF4240
movb $0x8, -0x26(%rbp)
movb $0x0, -0x25(%rbp)
movzwl -0x6(%rbp), %eax
sarl $0x8, %eax
orl $0x80, %eax
movb %al, -0x10(%rbp)
movzwl -0x6(%rbp), %eax
andl $0xff, %eax
movb %al, -0xf(%rbp)
movzwl -0x8(%rbp), %eax
sarl $0x8, %eax
movb %al, -0xe(%rbp)
movzwl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
leaq -0x14(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x40e0
movl -0x4(%rbp), %edi
movl $0x40406b00, %esi       # imm = 0x40406B00
leaq -0x60(%rbp), %rdx
movb $0x0, %al
callq 0x4250
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x48fe
leaq 0x677d(%rip), %rdi      # 0xb076
callq 0x4e80
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x6226(%rip), %rdi      # 0xb03c
movl $0x2, %esi
movb $0x0, %al
callq 0x4120
movl %eax, 0xa3c0(%rip)      # 0xf1e8
cmpl $0x0, 0xa3b9(%rip)      # 0xf1e8
jge 0x4e3d
leaq 0x6204(%rip), %rdi      # 0xb03c
callq 0x4e80
movl 0xa3a5(%rip), %edi      # 0xf1e8
movl $0x40016b01, %esi       # imm = 0x40016B01
leaq 0xa355(%rip), %rdx      # 0xf1a4
movb $0x0, %al
callq 0x4250
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x4e6b
leaq 0x61e5(%rip), %rdi      # 0xb04b
callq 0x4e80
movl 0xa377(%rip), %eax      # 0xf1e8
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x618a(%rip), %rdi      # 0xb058
callq 0x4630
cmpl $0x0, %eax
je 0x4ee2
movl $0x1, %edi
callq 0x41f0
leaq 0xa307(%rip), %rdi      # 0xf1f0
callq 0x42d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x4f0b
movl -0x14(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x4450
movl $0x1, %edi
callq 0x41f0
callq 0x4e00
movl %eax, 0xa2d2(%rip)      # 0xf1e8
leaq 0x614a(%rip), %rdi      # 0xb067
movb $0x0, %al
callq 0x4030
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0xff, %edx
callq 0x40e0
leaq -0x120(%rbp), %rdi
movq 0xa08b(%rip), %rax      # 0xefd0
movq (%rax), %rdx
movl $0xff, %esi
callq 0x42a0
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
je 0x4f7b
leaq -0x120(%rbp), %rdi
leaq 0x60ff(%rip), %rsi      # 0xb070
callq 0x4240
cmpl $0x0, %eax
jne 0x4f86
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
leaq -0x120(%rbp), %rdx
callq 0x45a0
jmp 0x4f16
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x50(%rax)
movb $0x0, 0x28(%rax)
cmpq $0x0, (%rax)
je 0x4fdb
movq -0x20(%rbp), %rdi
callq 0x4ff0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, 0x8(%rax)
movw $0x0, 0xa(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq (%rax), %rdi
callq 0x41a0
movq -0x18(%rbp), %rdx
movl %eax, %edi
addq $0x8, %rdx
movl $0x6, %esi
movb $0x0, %al
callq 0x4100
cmpl $-0x1, %eax
jne 0x506a
movq -0x18(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x5059
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4190
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x506e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0xff, %edx
callq 0x40e0
movq -0x128(%rbp), %rdi
callq 0x6070
testb $0x1, %al
jne 0x50c3
jmp 0x50cf
movq -0x128(%rbp), %rdi
callq 0x5140
movq -0x128(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x51c0
leaq -0x120(%rbp), %rdi
leaq 0x5fe0(%rip), %rsi      # 0xb0d4
callq 0x41d0
movq -0x128(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x510f
movb $0x0, -0x1(%rbp)
jmp 0x512d
movq -0x128(%rbp), %rdi
movb $0x1, 0x28(%rdi)
callq 0x4ff0
testb $0x1, %al
jne 0x5129
movb $0x0, -0x1(%rbp)
jmp 0x512d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, (%rax)
je 0x51ad
movq -0x18(%rbp), %rax
movw $0x2, 0x8(%rax)
movq (%rax), %rdi
callq 0x41a0
movq -0x18(%rbp), %rdx
movl %eax, %edi
addq $0x8, %rdx
movl $0x7, %esi
movb $0x0, %al
callq 0x4100
movq -0x18(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x51a2
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4190
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
cmpl $0x0, -0xc(%rbp)
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)