LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nmmmnu[P]HM3/include/stringref.h
// Function: StringRef::concatenate[abi:cxx11](std::initializer_list<StringRef>)
inline std::string StringRef::concatenate(std::initializer_list<StringRef> args){
	// super cheap concatenation

	std::string s;

	size_t reserve_size = 0;

	for(const auto &sr : args)
		reserve_size += sr.size();

	s.reserve(reserve_size);

	for(const auto &sr : args)
		s.append(sr.data(), sr.size());

	return s;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movb $0x0, 0x7f(%rsp)
callq 0x2250
movq $0x0, 0x70(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x7a10
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x7a20
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x7934
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x3aa0
addq 0x70(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x60(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x60(%rsp)
jmp 0x78fa
movq 0x10(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x2280
jmp 0x7945
leaq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x7a10
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x7a20
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x79df
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3a90
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3aa0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x2050
jmp 0x79b3
jmp 0x79b5
movq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x30(%rsp)
jmp 0x7970
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x2110
jmp 0x7a02
movb $0x1, 0x7f(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x79f5
movq 0x10(%rsp), %rdi
callq 0x2110
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x22c0
nopl (%rax)
// File: nmmmnu[P]HM3/common/mmapfile.cc
// Function: MMAPFile::open_(StringRef const&, int, int)
bool MMAPFile::open_(const StringRef &filename, int const mode, int const prot){
	close();

	int const fd = ::open(filename.data(), mode);

	if (fd < 0)
		return false;

	off_t size2 = lseek(fd, 0, SEEK_END);

	size_t size = size2 <= 0 ? 0 : (size_t) size2;

	if (size == 0){
		::close(fd);
		return false;
	}

	/* const */ void *mem = mmap(nullptr, size, prot, MAP_SHARED, fd, /* offset */ 0);

	if (mem == MAP_FAILED){
		::close(fd);
		return false;
	}

	madvise(mem, size, madvise_);

	fd_ = fd;
	size_ = size;
	mem_ = mem;

	return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7ed0
movq 0x40(%rsp), %rdi
callq 0x3a90
movq %rax, %rdi
movl 0x3c(%rsp), %esi
movb $0x0, %al
callq 0x2130
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jge 0x7dc2
movb $0x0, 0x57(%rsp)
jmp 0x7e92
movl 0x34(%rsp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x22f0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jg 0x7dea
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x7df4
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x7e16
movl 0x34(%rsp), %edi
callq 0x2300
movb $0x0, 0x57(%rsp)
jmp 0x7e92
movq 0x20(%rsp), %rsi
movl 0x38(%rsp), %edx
movl 0x34(%rsp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %ecx
movq %r9, %rdi
callq 0x22e0
movq %rax, 0x18(%rsp)
movq $-0x1, %rax
cmpq %rax, 0x18(%rsp)
jne 0x7e59
movl 0x34(%rsp), %edi
callq 0x2300
movb $0x0, 0x57(%rsp)
jmp 0x7e92
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x14(%rax), %edx
callq 0x2200
movq 0x10(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: nmmmnu[P]HM3/common/mmapfile.cc
// Function: MMAPFile::close()
void MMAPFile::close(){
	if (mem_ == nullptr)
		return;

	munmap((void *) mem_, size_);
	::close(fd_);

	mem_ = nullptr;
	size_ = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0x7eeb
jmp 0x7f1d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x2100
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x2300
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/common/mmapfile.cc
// Function: MMAPFile::createFile(StringRef const&, unsigned long)
bool MMAPFile::createFile(const StringRef &filename, size_t const size){
	constexpr mode_t chmod = S_IRUSR | S_IWUSR;

	int const fd = ::open(filename.data(), O_RDWR | O_CREAT, chmod);

	if (fd < 0)
		return false;

	int const result = ftruncate(fd, (off_t) size);

	::close(fd);

	return result == 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x180, 0xc(%rsp)       # imm = 0x180
movq 0x18(%rsp), %rdi
callq 0x3a90
movq %rax, %rdi
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x2130
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x7f76
movb $0x0, 0x27(%rsp)
jmp 0x7f9f
movl 0x8(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x2240
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %edi
callq 0x2300
cmpl $0x0, 0x4(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/diskfile/diskfileheader.cc
// Function: hm3::diskfile::DiskFileHeader::open(std::istream&)
bool DiskFileHeader::open(std::istream &file_meta){
	POD pod;
	memset(&pod, 0, sizeof(POD));

	file_meta.read( (char *) &pod, sizeof(PODBase));

	if (! file_meta)
		return false;

	// check the logo
	if (strncmp(pod.logo, TITLE, TITLE_LOGO_SIZE) != 0)
		return false;

	version_	= pod.version;
	count_		= be64toh(pod.size);

	// read the rest, without rewind :-)
	size_t additionalSize = sizeof(POD) - sizeof(PODBase);

	file_meta.read( ((char *) &pod) + sizeof(PODBase), (std::streamsize) additionalSize);

	if (! file_meta && file_meta.gcount() < (std::streamsize) additionalSize){
		clear_();
		return true;
	}

	created_	= be64toh(pod.created);

	sorted_		= pod.sorted == HEADER_SORTED ? true : false;

	tombstones_	= be64toh(pod.tombstones);

	createdMin_	= be64toh(pod.createdMin);
	createdMax_	= be64toh(pod.createdMax);

	return true;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1e(%rsp), %rdi
xorl %esi, %esi
movl $0x32, %edx
callq 0x20f0
movq 0x50(%rsp), %rdi
leaq 0x1e(%rsp), %rsi
movl $0x11, %edx
callq 0x2210
movq 0x50(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x20c0
testb $0x1, %al
jne 0x8164
jmp 0x816e
movb $0x0, 0x67(%rsp)
jmp 0x827d
leaq 0x1e(%rsp), %rdi
leaq 0x122e(%rip), %rsi      # 0x93a8
movl $0x4, %edx
callq 0x20d0
cmpl $0x0, %eax
je 0x8193
movb $0x0, 0x67(%rsp)
jmp 0x827d
movq 0x8(%rsp), %rax
movb 0x26(%rsp), %cl
movb %cl, (%rax)
movq 0x27(%rsp), %rdi
callq 0x8290
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq $0x21, 0x10(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x1e(%rsp), %rsi
addq $0x11, %rsi
movq 0x10(%rsp), %rdx
callq 0x2210
movq 0x50(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x20c0
testb $0x1, %al
jne 0x81ec
jmp 0x820e
movq 0x50(%rsp), %rdi
callq 0x2320
cmpq 0x10(%rsp), %rax
jge 0x820e
movq 0x8(%rsp), %rdi
callq 0x8340
movb $0x1, 0x67(%rsp)
jmp 0x827d
movq 0x2f(%rsp), %rdi
callq 0x8290
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movb 0x37(%rsp), %cl
subb $0x1, %cl
sete %cl
negb %cl
andb $0x1, %cl
movb %cl, 0x18(%rax)
movq 0x38(%rsp), %rdi
callq 0x8290
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x40(%rsp), %rdi
callq 0x8290
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x48(%rsp), %rdi
callq 0x8290
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/diskfile/diskfileheader.cc
// Function: hm3::diskfile::DiskFileHeader::clear_()
void DiskFileHeader::clear_(){
	created_	= 0;
	sorted_		= false;
	tombstones_	= 0;
	createdMin_	= 0;
	createdMax_	= 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
retq
nop
// File: nmmmnu[P]HM3/hm3/diskfile/diskfileheader.cc
// Function: hm3::diskfile::DiskFileHeader::createPOD_() const
auto DiskFileHeader::createPOD_() const -> POD{
	POD pod;

	memset(&pod, 0, sizeof(POD));

	strcpy(pod.logo, TITLE);

	pod.version	= VERSION;
	pod.size	= htobe64(count_);

	pod.created	= htobe64(created_);
	pod.sorted	= sorted_ ? HEADER_SORTED : HEADER_NOT_SORTED;
	pod.tombstones	= htobe64(tombstones_);
	pod.createdMin	= htobe64(createdMin_);
	pod.createdMax	= htobe64(createdMax_);

	return pod;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %esi, %esi
movl $0x32, %edx
callq 0x20f0
movq 0x8(%rsp), %rdi
leaq 0x1001(%rip), %rsi      # 0x93a8
callq 0x2190
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movb $0x3, 0x8(%rdi)
movq 0x8(%rax), %rdi
callq 0x8290
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x9(%rdi)
movq 0x10(%rax), %rdi
callq 0x8290
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x11(%rdi)
movb 0x18(%rax), %cl
movb $0x1, %al
xorl %edx, %edx
movb %dl, 0x1e(%rsp)
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x840a
movb 0x1e(%rsp), %al
movb %al, 0x1f(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movb 0x1f(%rsp), %dl
movb %dl, 0x19(%rcx)
movq 0x20(%rax), %rdi
callq 0x8290
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq %rdx, 0x1a(%rcx)
movq 0x28(%rax), %rdi
callq 0x8290
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq %rdx, 0x22(%rcx)
movq 0x30(%rax), %rdi
callq 0x8290
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq (%rsp), %rax
movq %rdx, 0x2a(%rcx)
addq $0x28, %rsp
retq
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/diskfile/diskfileheader.cc
// Function: hm3::diskfile::DiskFileHeader::print() const
void DiskFileHeader::print() const{
	printf("%-14s: %u\n",		"Version",	version_);
	printf("%-14s: %" PRIu64 "\n",	"Records",	count_); // PRIu64
	printf("%-14s: %s\n",		"Created",	created_ ? MyTime::toString(created_) : "n/a");
	printf("%-14s: %s\n",		"Sorted",	sorted_ ? "Yes" : "No");

	printf("%-14s: %" PRIu64 "\n",	"Tombstones",	tombstones_); // PRIu64
	printf("%-14s: %s\n",		"Created::MIN",	createdMin_ ? MyTime::toString(createdMin_) : "n/a");
	printf("%-14s: %s\n",		"Created::MAX",	createdMax_ ? MyTime::toString(createdMax_) : "n/a");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movzbl (%rax), %edx
leaq 0xee3(%rip), %rdi       # 0x93b0
leaq 0xee7(%rip), %rsi       # 0x93bb
movb $0x0, %al
callq 0x2030
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0xed8(%rip), %rdi       # 0x93c3
leaq 0xedd(%rip), %rsi       # 0x93cf
movb $0x0, %al
callq 0x2030
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8521
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0xc70(%rip), %rsi       # 0x9185
callq 0x5240
movq %rax, 0x10(%rsp)
jmp 0x852f
leaq 0xec2(%rip), %rax       # 0x93ea
movq %rax, 0x10(%rsp)
jmp 0x852f
movq 0x10(%rsp), %rdx
leaq 0xe9c(%rip), %rdi       # 0x93d7
leaq 0xea0(%rip), %rsi       # 0x93e2
movb $0x0, %al
callq 0x2030
movq 0x18(%rsp), %rax
movb 0x18(%rax), %cl
leaq 0xea1(%rip), %rdx       # 0x93f9
leaq 0xe96(%rip), %rax       # 0x93f5
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0xe6a(%rip), %rdi       # 0x93d7
leaq 0xe7a(%rip), %rsi       # 0x93ee
movb $0x0, %al
callq 0x2030
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0xe38(%rip), %rdi       # 0x93c3
leaq 0xe6a(%rip), %rsi       # 0x93fc
movb $0x0, %al
callq 0x2030
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x85c1
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0xbd0(%rip), %rsi       # 0x9185
callq 0x5240
movq %rax, 0x8(%rsp)
jmp 0x85cf
leaq 0xe22(%rip), %rax       # 0x93ea
movq %rax, 0x8(%rsp)
jmp 0x85cf
movq 0x8(%rsp), %rdx
leaq 0xdfc(%rip), %rdi       # 0x93d7
leaq 0xe25(%rip), %rsi       # 0x9407
movb $0x0, %al
callq 0x2030
movq 0x18(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x8610
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0xb80(%rip), %rsi       # 0x9185
callq 0x5240
movq %rax, (%rsp)
jmp 0x861d
leaq 0xdd3(%rip), %rax       # 0x93ea
movq %rax, (%rsp)
jmp 0x861d
movq (%rsp), %rdx
leaq 0xdaf(%rip), %rdi       # 0x93d7
leaq 0xde5(%rip), %rsi       # 0x9414
movb $0x0, %al
callq 0x2030
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::parse_inf<char const*, double>(char const*&, char const*, double&, bool)
static inline bool parse_inf(Iterator& itr, const Iterator end, T& t, const bool negative)
      {
         static const char_t inf_uc[] = "INFINITY";
         static const char_t inf_lc[] = "infinity";
         static const std::size_t inf_length = 8;

         const std::size_t length = static_cast<std::size_t>(std::distance(itr,end));

         if ((3 != length) && (inf_length != length))
            return false;

         char_cptr inf_itr = ('i' == (*itr)) ? inf_lc : inf_uc;

         while (end != itr)
         {
            if (*inf_itr == static_cast<char_t>(*itr))
            {
               ++itr;
               ++inf_itr;
               continue;
            }
            else
               return false;
         }

         if (negative)
            t = -std::numeric_limits<T>::infinity();
         else
            t =  std::numeric_limits<T>::infinity();

         return true;
      }

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x22cb80
movq %rax, 0x18(%rsp)
movl $0x3, %eax
cmpq 0x18(%rsp), %rax
je 0x134374
movl $0x8, %eax
cmpq 0x18(%rsp), %rax
je 0x134374
movb $0x0, 0x47(%rsp)
jmp 0x13443b
movq 0x38(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movl $0x69, %eax
cmpl %ecx, %eax
jne 0x134396
leaq 0x4a620a(%rip), %rax    # 0x5da599
movq %rax, 0x8(%rsp)
jmp 0x1343a4
leaq 0x4a61f3(%rip), %rax    # 0x5da590
movq %rax, 0x8(%rsp)
jmp 0x1343a4
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq (%rcx), %rax
je 0x1343fa
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x1343f3
movq 0x38(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1343ae
movb $0x0, 0x47(%rsp)
jmp 0x13443b
testb $0x1, 0x27(%rsp)
je 0x134428
callq 0x25b0d0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x134436
callq 0x25b0d0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::parse_nan<char const*, double>(char const*&, char const*, double&)
static inline bool parse_nan(Iterator& itr, const Iterator end, T& t)
      {
         typedef typename std::iterator_traits<Iterator>::value_type type;

         static const std::size_t nan_length = 3;

         if (std::distance(itr,end) != static_cast<int>(nan_length))
            return false;

         if (static_cast<type>('n') == (*itr))
         {
            if (
                 (static_cast<type>('a') != *(itr + 1)) ||
                 (static_cast<type>('n') != *(itr + 2))
               )
            {
               return false;
            }
         }
         else if (
                   (static_cast<type>('A') != *(itr + 1)) ||
                   (static_cast<type>('N') != *(itr + 2))
                 )
         {
            return false;
         }

         t = std::numeric_limits<T>::quiet_NaN();

         return true;
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x22cb80
cmpq $0x3, %rax
je 0x134485
movb $0x0, 0x27(%rsp)
jmp 0x134512
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movl $0x6e, %eax
cmpl %ecx, %eax
jne 0x1344cc
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jne 0x1344c3
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %ecx
movl $0x6e, %eax
cmpl %ecx, %eax
je 0x1344ca
movb $0x0, 0x27(%rsp)
jmp 0x134512
jmp 0x1344ff
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jne 0x1344f6
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %ecx
movl $0x4e, %eax
cmpl %ecx, %eax
je 0x1344fd
movb $0x0, 0x27(%rsp)
jmp 0x134512
jmp 0x1344ff
callq 0x2361c0
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::timer::timer()
timer()
      : in_use_(false)
      {
         start_time_.tv_sec  = 0;
         start_time_.tv_usec = 0;

         stop_time_.tv_sec   = 0;
         stop_time_.tv_usec  = 0;
      }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
retq
nop
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: bool run_test00<double>()
bool run_test00()
{
   const std::size_t rounds = 10;

   for (std::size_t r = 0; r < rounds; ++r)
   {
      bool result = true;

      for (std::size_t i = 0; i < global_test_list_size; ++i)
      {
         if (!test_expression<T>(global_test_list[i].first,T(global_test_list[i].second)))
         {
            result = false;
         }
      }

      if (!result)
      {
         return false;
      }
   }

   {
      const std::vector<test_t> tests = edge_cases<T>::test_cases();

      bool result = true;

      for (std::size_t i = 0; i < tests.size(); ++i)
      {
         if (!test_expression<T>(tests[i].first,T(tests[i].second)))
         {
            result = false;
         }
      }

      if (!result)
      {
         return false;
      }
   }

   return true;
}

// Assembly:
subq $0x98, %rsp
movq $0xa, 0x88(%rsp)
movq $0x0, 0x80(%rsp)
cmpq $0xa, 0x80(%rsp)
jae 0x13752a
movb $0x1, 0x7f(%rsp)
movq $0x0, 0x70(%rsp)
cmpq $0x430, 0x70(%rsp)      # imm = 0x430
jae 0x1374fb
leaq 0x69daa2(%rip), %rdi    # 0x7d4f50
imulq $0x28, 0x70(%rsp), %rax
addq %rax, %rdi
leaq 0x69da92(%rip), %rax    # 0x7d4f50
imulq $0x28, 0x70(%rsp), %rcx
addq %rcx, %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x22cc00
xorb $-0x1, %al
testb $0x1, %al
jne 0x1374e4
jmp 0x1374e9
movb $0x0, 0x7f(%rsp)
jmp 0x1374eb
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x13749c
testb $0x1, 0x7f(%rsp)
jne 0x13750f
movb $0x0, 0x97(%rsp)
jmp 0x137630
jmp 0x137511
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x13747f
leaq 0x50(%rsp), %rdi
callq 0x22dad0
movb $0x1, 0x4f(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x22ddf0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x1375f1
movq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x22de10
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rsi
callq 0x22de10
movq 0x10(%rsp), %rdi
movsd 0x20(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x22cc00
movb %al, 0x1f(%rsp)
jmp 0x1375af
movb 0x1f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1375bb
jmp 0x1375dc
movb $0x0, 0x4f(%rsp)
jmp 0x1375dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x22de30
jmp 0x137641
jmp 0x1375de
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x137542
testb $0x1, 0x4f(%rsp)
jne 0x13760a
movb $0x0, 0x97(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x137612
movl $0x0, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x22de30
movl 0x28(%rsp), %eax
testl %eax, %eax
je 0x137628
jmp 0x137626
jmp 0x137630
movb $0x1, 0x97(%rsp)
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::timer::usec_time() const
inline unsigned long long int usec_time() const
      {
         if (!in_use_)
         {
            if (stop_time_.tv_sec >= start_time_.tv_sec)
            {
               return 1000000LLU * static_cast<details::_uint64_t>(stop_time_.tv_sec  - start_time_.tv_sec ) +
                                   static_cast<details::_uint64_t>(stop_time_.tv_usec - start_time_.tv_usec) ;
            }
            else
               return std::numeric_limits<details::_uint64_t>::max();
         }
         else
            return std::numeric_limits<details::_uint64_t>::max();
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, (%rax)
jne 0x22c936
movq (%rsp), %rcx
movq 0x18(%rcx), %rax
cmpq 0x8(%rcx), %rax
jl 0x22c92a
movq (%rsp), %rdx
movq 0x18(%rdx), %rax
subq 0x8(%rdx), %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
movq 0x20(%rdx), %rcx
subq 0x10(%rdx), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x22c940
callq 0x22c950
movq %rax, 0x10(%rsp)
jmp 0x22c940
callq 0x22c950
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::add_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::ifunction<double>&)
inline bool add_function(const std::string& function_name, function_t& function)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(function_name))
            return false;
         else if (symbol_exists(function_name))
            return false;
         else
            return local_data().function_store.add(function_name,function);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x22e3dc
movb $0x0, 0x27(%rsp)
jmp 0x22e441
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x22e3fa
movb $0x0, 0x27(%rsp)
jmp 0x22e441
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x22e413
jmp 0x22e41a
movb $0x0, 0x27(%rsp)
jmp 0x22e441
movq (%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x23b360
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::register_symbol_table(exprtk::symbol_table<double>&)
inline bool register_symbol_table(symbol_table<T>& st)
      {
         for (std::size_t i = 0; i < symbol_table_list_.size(); ++i)
         {
            if (st == symbol_table_list_[i])
            {
               return false;
            }
         }

         symbol_table_list_.push_back(st);
         return true;
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x240aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x22e58d
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
callq 0x240b00
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x240ac0
testb $0x1, %al
jne 0x22e574
jmp 0x22e57b
movb $0x0, 0x37(%rsp)
jmp 0x22e5a5
jmp 0x22e57d
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x22e521
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
callq 0x240b20
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::error[abi:cxx11]() const
inline std::string error() const
      {
         if (!error_list_.empty())
         {
            return error_list_[0].diagnostic;
         }
         else
            return std::string("No Error");
      }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x308, %rdi            # imm = 0x308
callq 0x3741c0
testb $0x1, %al
jne 0x22f86d
movq 0x18(%rsp), %rdi
addq $0x308, %rdi            # imm = 0x308
xorl %eax, %eax
movl %eax, %esi
callq 0x55c8f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x38, %rsi
callq 0x11b140
jmp 0x22f8b8
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x11b6f0
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x37bac9(%rip), %rsi    # 0x5ab354
callq 0x134520
jmp 0x22f892
leaq 0x37(%rsp), %rdi
callq 0x11b820
jmp 0x22f8b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x11b820
jmp 0x22f8c2
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::clear()
inline void clear()
      {
         if (!valid()) return;
         clear_variables      ();
         clear_functions      ();
         clear_strings        ();
         clear_vectors        ();
         clear_local_constants();
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x22fd6e
jmp 0x22fda5
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x232d70
movq 0x8(%rsp), %rdi
callq 0x232db0
movq 0x8(%rsp), %rdi
callq 0x232de0
movq 0x8(%rsp), %rdi
callq 0x232e10
movq 0x8(%rsp), %rdi
callq 0x232e40
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::clear(bool)
inline void clear(const bool delete_node = true)
         {
            if (!map.empty())
            {
               if (delete_node)
               {
                  tm_itr_t itr = map.begin();
                  tm_itr_t end = map.end  ();

                  while (end != itr)
                  {
                     deleter::process((*itr).second);
                     ++itr;
                  }
               }

               map.clear();
            }

            size = 0;
         }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x232f20
testb $0x1, %al
jne 0x232f09
testb $0x1, 0x1f(%rsp)
je 0x232f00
movq (%rsp), %rdi
callq 0x232f40
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x232f70
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x232fa0
testb $0x1, %al
jne 0x232edc
jmp 0x232efe
leaq 0x10(%rsp), %rdi
callq 0x233000
movq %rax, %rdi
addq $0x20, %rdi
callq 0x232fc0
leaq 0x10(%rsp), %rdi
callq 0x233020
jmp 0x232ec7
jmp 0x232f00
movq (%rsp), %rdi
callq 0x233050
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::add_constant(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
inline bool add_constant(const std::string& constant_name, const T& value)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(constant_name))
            return false;
         else if (symbol_exists(constant_name))
            return false;

         local_data().local_symbol_list_.push_back(value);
         T& t = local_data().local_symbol_list_.back();

         return add_variable(constant_name, t, true);
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x233e20
movb $0x0, 0x37(%rsp)
jmp 0x233ec2
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x233e42
movb $0x0, 0x37(%rsp)
jmp 0x233ec2
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x233e5c
jmp 0x233e63
movb $0x0, 0x37(%rsp)
jmp 0x233ec2
jmp 0x233e65
jmp 0x233e67
movq 0x8(%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movq 0x18(%rsp), %rsi
callq 0x234160
movq 0x8(%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x2341a0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl $0x1, %ecx
callq 0x2341e0
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::symbol_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const
inline bool symbol_exists(const std::string& symbol_name, const bool check_reserved_symb = true) const
      {
         /*
            Function will return true if symbol_name exists as either a
            reserved symbol, variable, stringvar, vector or function name
            in any of the type stores.
         */
         if (!valid())
            return false;
         else if (local_data().variable_store.symbol_exists(symbol_name))
            return true;
         #ifndef exprtk_disable_string_capabilities
         else if (local_data().stringvar_store.symbol_exists(symbol_name))
            return true;
         #endif
         else if (local_data().vector_store.symbol_exists(symbol_name))
            return true;
         else if (local_data().function_store.symbol_exists(symbol_name))
            return true;
         else if (check_reserved_symb && local_data().is_reserved_symbol(symbol_name))
            return true;
         else
            return false;
      }

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x234082
movb $0x0, 0x27(%rsp)
jmp 0x234155
movq (%rsp), %rdi
callq 0x234330
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x234670
testb $0x1, %al
jne 0x23409e
jmp 0x2340a8
movb $0x1, 0x27(%rsp)
jmp 0x234155
movq (%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x10(%rsp), %rsi
callq 0x2346f0
testb $0x1, %al
jne 0x2340cb
jmp 0x2340d5
movb $0x1, 0x27(%rsp)
jmp 0x234155
movq (%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x10(%rsp), %rsi
callq 0x234770
testb $0x1, %al
jne 0x2340f8
jmp 0x2340ff
movb $0x1, 0x27(%rsp)
jmp 0x234155
movq (%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rsi
callq 0x2347f0
testb $0x1, %al
jne 0x23411f
jmp 0x234126
movb $0x1, 0x27(%rsp)
jmp 0x234155
testb $0x1, 0xf(%rsp)
je 0x234150
movq (%rsp), %rdi
callq 0x234330
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x234350
testb $0x1, %al
jne 0x234149
jmp 0x234150
movb $0x1, 0x27(%rsp)
jmp 0x234155
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::add_variable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&, bool)
inline bool add_variable(const std::string& variable_name, T& t, const bool is_constant = false)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(variable_name))
            return false;
         else if (symbol_exists(variable_name))
            return false;
         else
            return local_data().variable_store.add(variable_name, t, is_constant);
      }

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x234215
movb $0x0, 0x37(%rsp)
jmp 0x234280
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x234234
movb $0x0, 0x37(%rsp)
jmp 0x234280
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x23424e
jmp 0x234255
movb $0x0, 0x37(%rsp)
jmp 0x234280
movq 0x8(%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x235960
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::symbol_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool symbol_exists(const std::string& symbol_name) const
         {
            if (symbol_name.empty())
               return false;
            else if (map.end() != map.find(symbol_name))
               return true;
            else
               return false;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11b260
testb $0x1, %al
jne 0x234698
jmp 0x23469f
movb $0x0, 0x37(%rsp)
jmp 0x2346e3
movq 0x8(%rsp), %rdi
callq 0x234890
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
callq 0x2348c0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x234870
testb $0x1, %al
jne 0x2346d7
jmp 0x2346de
movb $0x1, 0x37(%rsp)
jmp 0x2346e3
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::ilesscompare::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool operator() (const std::string& s1, const std::string& s2) const
         {
            const std::size_t length = std::min(s1.size(),s2.size());

            for (std::size_t i = 0; i < length; ++i)
            {
               const char_t c1 = static_cast<char_t>(std::tolower(s1[i]));
               const char_t c2 = static_cast<char_t>(std::tolower(s2[i]));

               if (c1 < c2)
                  return true;
               else if (c2 < c1)
                  return false;
            }

            return s1.size() < s2.size();
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11b270
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11b270
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x234c90
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x234ba1
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11b770
movsbl (%rax), %edi
callq 0x11b5f0
movb %al, 0x17(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11b770
movsbl (%rax), %edi
callq 0x11b5f0
movb %al, 0x16(%rsp)
movsbl 0x17(%rsp), %eax
movsbl 0x16(%rsp), %ecx
cmpl %ecx, %eax
jge 0x234b78
movb $0x1, 0x57(%rsp)
jmp 0x234bce
movsbl 0x16(%rsp), %eax
movsbl 0x17(%rsp), %ecx
cmpl %ecx, %eax
jge 0x234b8d
movb $0x0, 0x57(%rsp)
jmp 0x234bce
jmp 0x234b8f
jmp 0x234b91
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x234b21
movq 0x40(%rsp), %rdi
callq 0x11b270
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11b270
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&, bool)
inline bool add(const std::string& symbol_name, RawType& t_, const bool is_const = false)
         {
            struct tie
            {
               static inline std::pair<bool,variable_node_t*> make(T& t, const bool is_constant = false)
               {
                  return std::make_pair(is_constant, new variable_node_t(t));
               }

               #ifndef exprtk_disable_string_capabilities
               static inline std::pair<bool,stringvar_node_t*> make(std::string& t, const bool is_constant = false)
               {
                  return std::make_pair(is_constant, new stringvar_node_t(t));
               }
               #endif

               static inline std::pair<bool,function_t*> make(function_t& t, const bool is_constant = false)
               {
                  return std::make_pair(is_constant,&t);
               }

               static inline std::pair<bool,vararg_function_t*> make(vararg_function_t& t, const bool is_constant = false)
               {
                  return std::make_pair(is_constant,&t);
               }

               static inline std::pair<bool,generic_function_t*> make(generic_function_t& t, const bool is_constant = false)
               {
                  return std::make_pair(is_constant,&t);
               }
            };

            const tm_itr_t itr = map.find(symbol_name);

            if (map.end() == itr)
            {
               map[symbol_name] = tie::make(t_,is_const);
               ++size;
            }

            return true;
         }

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x38(%rsp), %rsi
callq 0x235a10
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x232f70
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x235a40
testb $0x1, %al
jne 0x2359b6
jmp 0x2359fd
movq 0x30(%rsp), %rdi
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x235a60
movq (%rsp), %rdi
movb %al, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x38(%rsp), %rsi
callq 0x235af0
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0x235be0
movq (%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::set_expression(exprtk::details::expression_node<double>*)
inline void set_expression(const expression_ptr expr)
      {
         if (expr)
         {
            if (control_block_)
            {
               if (0 == --control_block_->ref_count)
               {
                  delete control_block_;
               }
            }

            control_block_ = control_block::create(expr);
         }
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x23c439
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x23c424
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x23c422
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x23c420
movq 0x8(%rsp), %rdi
callq 0x23c540
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x11b130
jmp 0x23c422
jmp 0x23c424
movq 0x18(%rsp), %rdi
callq 0x23c780
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::node_collection_destructor<exprtk::details::expression_node<double>>::delete_nodes(exprtk::details::expression_node<double>*&)
static void delete_nodes(node_ptr_t& root)
         {
            std::vector<node_pp_t> node_delete_list;
            node_delete_list.reserve(1000);

            collect_nodes(root, node_delete_list);

            for (std::size_t i = 0; i < node_delete_list.size(); ++i)
            {
               node_ptr_t& node = *node_delete_list[i];
               exprtk_debug(("ncd::delete_nodes() - deleting: %p\n", reinterpret_cast<void*>(node)));
               delete node;
               node = reinterpret_cast<node_ptr_t>(0);
            }
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x23cad0
movq 0x10(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x23cae0
jmp 0x23ca09
movq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x23cbf0
jmp 0x23ca1a
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x23ce80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x23caad
movq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x23cea0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x23ca77
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x23ca23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x23cec0
jmp 0x23cabc
leaq 0x38(%rsp), %rdi
callq 0x23cec0
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::clear()
inline void clear()
         {
            base_itr_ = 0;
            s_itr_    = 0;
            s_end_    = 0;
            token_list_.clear();
            token_itr_ = token_list_.end();
            store_token_itr_ = token_list_.end();
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, 0x58(%rdi)
movq $0x0, 0x60(%rdi)
movq $0x0, 0x68(%rdi)
callq 0x251490
movq 0x8(%rsp), %rdi
callq 0x2514b0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rdi)
callq 0x2514b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::parser_state::reset()
void reset()
         {
            parsing_return_stmt     = false;
            parsing_break_stmt      = false;
            parsing_assert_stmt     = false;
            return_stmt_present     = false;
            side_effect_present     = false;
            scope_depth             = 0;
            stack_depth             = 0;
            parsing_loop_stmt_count = 0;
         }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
movb $0x0, 0x1(%rax)
movb $0x0, 0x2(%rax)
movb $0x0, 0x3(%rax)
movb $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::unknown_symbol_resolver::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::parser<double>::unknown_symbol_resolver::usr_symbol_type&, double&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
virtual bool process(const std::string& /*unknown_symbol*/,
                              usr_symbol_type&   st,
                              T&                 default_value,
                              std::string&       error_message)
         {
            if (e_usrmode_default != mode)
               return false;

            st = e_usr_variable_type;
            default_value = T(0);
            error_message.clear();

            return true;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x28(%rsp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
je 0x2532a0
movb $0x0, 0x37(%rsp)
jmp 0x2532c6
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rdi
callq 0x11b450
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token_joiner::process(exprtk::lexer::generator&)
inline std::size_t process(generator& g) exprtk_override
         {
            if (g.token_list_.empty())
               return 0;

            switch (stride_)
            {
               case 2  : return process_stride_2(g);
               case 3  : return process_stride_3(g);
               default : return 0;
            }
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x254a30
testb $0x1, %al
jne 0x256818
jmp 0x256823
movq $0x0, 0x20(%rsp)
jmp 0x256879
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
subq $0x2, %rax
je 0x256844
jmp 0x256838
movq (%rsp), %rax
subq $0x3, %rax
je 0x25685a
jmp 0x256870
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x256e80
movq %rax, 0x20(%rsp)
jmp 0x256879
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x257140
movq %rax, 0x20(%rsp)
jmp 0x256879
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::operator_joiner::join(exprtk::lexer::token const&, exprtk::lexer::token const&, exprtk::lexer::token const&, exprtk::lexer::token&)
inline bool join(const lexer::token& t0,
                             const lexer::token& t1,
                             const lexer::token& t2,
                             lexer::token& t) exprtk_override
            {
               // '[ * ]' --> '[*]'
               if (
                    (t0.type == lexer::token::e_lsqrbracket) &&
                    (t1.type == lexer::token::e_mul        ) &&
                    (t2.type == lexer::token::e_rsqrbracket)
                  )
               {
                  t.type     = lexer::token::e_symbol;
                  t.value    = "[*]";
                  t.position = t0.position;

                  return true;
               }
               else
                  return false;
            }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x5b, (%rax)
jne 0x256de4
movq 0x18(%rsp), %rax
cmpl $0x2a, (%rax)
jne 0x256de4
movq 0x10(%rsp), %rax
cmpl $0x5d, (%rax)
jne 0x256de4
movq 0x8(%rsp), %rax
movl $0x8, (%rax)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
leaq 0x35eac0(%rip), %rsi    # 0x5b5886
callq 0x11b340
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x256de9
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token_modifier::process(exprtk::lexer::generator&)
inline std::size_t process(generator& g) exprtk_override
         {
            std::size_t changes = 0;

            for (std::size_t i = 0; i < g.token_list_.size(); ++i)
            {
               if (modify(g.token_list_[i])) changes++;
            }

            return changes;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x254a80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x25781e
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x254bc0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x2577fe
jmp 0x25780c
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x25780e
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2577ba
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)