LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblemComp.cpp
// Function: HMMProblemComp::getB(data*, signed char, signed char)
NUMBER HMMProblemComp::getB(struct data* dt, NPAR i, NPAR m) {
	NUMBER r = 0;
	// dt->cnt==0 means, get dt->k'th skill only
	// if param->tag1==1, try and see whether there are other "neighbours"
	// dt->t should be set to the global index of the row in question

	// special attention for "unknonw" observations, i.e. the observation was there but we do not know what it is
	// in this case we simply return 1, effectively resulting in no change in \alpha or \beta vatiables
	if(m<0) {
		r = 1;
	} else if( this->p->tag1==0 || this->is_multi[dt->k] == 0) { // we ask for single skill specifically or this skill is never multiskill
		r = this->B[dt->k][i][m];
	} else {
		NCAT n_skills = this->p->dat_skill_rcount[ dt->t ];
		if( n_skills==1 ) { // this skill is alone on row dt->t
			r = this->B[dt->k][i][m];
		} else { // collect multiple \pi[i]
			NUMBER* q = Calloc(NUMBER, (size_t)n_skills );
			NCAT k=0;
			for(NCAT l=0; l<n_skills; l++) {
				k = this->p->dat_skill_stacked[ this->p->dat_skill_rix[ dt->t ]+l ];
				q[l] = this->B[k][i][m];
			}
			r = this->pu->unite(q, n_skills, NULL, 0); //r = squishing(q, n_skills);
			free(q);
		} // definitely multiskill
	} // end sometimes multiskill
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testb %cl, %cl
js 0x2a784
movl %edx, %ebp
movq %rdi, %rbx
movq 0x88(%rdi), %r12
cmpl $0x0, 0x9a0(%r12)
je 0x2a791
movq 0x90(%rbx), %rdx
movslq 0x58(%rsi), %rax
cmpb $0x0, (%rdx,%rax)
je 0x2a795
movq 0x890(%r12), %rdx
movslq 0x8(%rsi), %r14
movslq (%rdx,%r14,4), %rdi
movzbl %cl, %r13d
cmpq $0x1, %rdi
jne 0x2a7b2
movq 0x48(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movsbq %bpl, %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%r13,8), %xmm0
jmp 0x2a838
movsd 0x2164(%rip), %xmm0     # 0x2c8f0
jmp 0x2a838
movslq 0x58(%rsi), %rax
movq 0x48(%rbx), %rdx
movq (%rdx,%rax,8), %rax
movsbq %bpl, %rdx
movq (%rax,%rdx,8), %rax
movzbl %cl, %ecx
movsd (%rax,%rcx,8), %xmm0
jmp 0x2a838
pushq $0x8
popq %rsi
movq %rdi, %r15
callq 0x4120
movq %r15, %rdx
movq %rax, %r15
movq 0x48(%rbx), %rax
movsbq %bpl, %rcx
xorl %r9d, %r9d
testl %edx, %edx
movl $0x0, %esi
cmovgl %edx, %esi
cmpq %r9, %rsi
je 0x2a811
movq 0x888(%r12), %rdi
movq 0x898(%r12), %r8
movslq (%r8,%r14,4), %r8
addq %r9, %r8
movslq (%rdi,%r8,4), %rdi
movq (%rax,%rdi,8), %rdi
movq (%rdi,%rcx,8), %rdi
movsd (%rdi,%r13,8), %xmm0
movsd %xmm0, (%r15,%r9,8)
incq %r9
jmp 0x2a7d8
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x8(%rax)
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x4290
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblemComp.cpp
// Function: HMMProblemComp::fit()
void HMMProblemComp::fit() {
    NUMBER* loglik_rmse = init1D<NUMBER>(2);
    FitNullSkill(loglik_rmse, false /*do not need RMSE/SE*/);
    if(this->p->structure == STRUCTURE_COMP) {
        loglik_rmse[0] += GradientDescent();
    } else {
        fprintf(stderr,"Solver specified is not supported.\n");
        exit(1);
    }
    this->neg_log_lik = loglik_rmse[0];
    free(loglik_rmse);
	
	this->p->tag1 = 1; // for prediction needs after this
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rdi
callq 0x7dde
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x10bc8
movq 0x88(%rbx), %rax
cmpb $0xd, 0x3e(%rax)
jne 0x2ae7b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
addsd (%r14), %xmm0
movsd %xmm0, 0x20(%rbx)
movq %r14, %rdi
callq 0x4290
movq 0x88(%rbx), %rax
movl $0x1, 0x9a0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xe156(%rip), %rax      # 0x38fd8
movq (%rax), %rcx
leaq 0x2696(%rip), %rdi      # 0x2d522
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x44b0
pushq $0x1
popq %rdi
callq 0x42a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/main/db_file.cc
// Function: printUsage(char const*)
static void printUsage(const char *cmd){
	std::cout
		<< "Usage:"	<< '\n'
		<< "\t"		<< cmd	<< " r [file.db] [key] - load file.db, then search for the key"		<< '\n'
		<< "\t"		<< cmd	<< " l [file.db] -     - load file.db, then list using iterator"	<< '\n'
		<< "\t"		<< cmd	<< " l [file.db] [key] - load file.db, then list using iterator"	<< '\n'

		<< "\t\tPath names must be written without extention"		<< '\n'
		<< "\t\tExample 'directory/file.db'"				<< '\n'

		<< '\n';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x58c4(%rip), %rdi      # 0x7fd0
leaq 0x28f1(%rip), %rsi      # 0x5004
callq 0x2170
pushq $0xa
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
leaq 0x28df(%rip), %r15      # 0x500b
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
leaq 0x28c4(%rip), %rsi      # 0x500d
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
leaq 0x28d0(%rip), %rsi      # 0x5048
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
leaq 0x28dd(%rip), %rsi      # 0x5084
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
leaq 0x2900(%rip), %rsi      # 0x50c0
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
leaq 0x2916(%rip), %rsi      # 0x50ef
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
movq %rax, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/include/stringref.h
// Function: StringRef::compare__(char const*, unsigned long, char const*, unsigned long)
inline int StringRef::compare__(const char *s1, size_t const size1, const char *s2, size_t const size2) noexcept{
	// First idea was lazy based on LLVM::StringRef
	// http://llvm.org/docs/doxygen/html/StringRef_8h_source.html

	if ( int const res = memcmp__(s1, s2, std::min(size1, size2) ) )
		return res; // most likely exit

	// sgn helps convert size_t to int, without a branch
	return sgn__( ssize_t(size1) - ssize_t(size2) );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %rbx
cmpq %rsi, %rcx
movq %rsi, %rax
cmovbq %rcx, %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x2c5e
subq %r14, %rbx
xorl %eax, %eax
testq %rbx, %rbx
setg %al
sarq $0x3f, %rbx
addl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/include/stringref.h
// Function: StringRef::equals__(char const*, unsigned long, char const*, unsigned long)
constexpr inline bool StringRef::equals__(const char *s1, size_t const size1, const char *s2, size_t const size2) noexcept{
	// Here clang do constexpr as follows -
	// it checks the sizes and short cut memcmp__().
	// There is *NO* constexpr, if you supply same sized strings:
	// StringRef::equals__("Hello", 5, "Bello", 5);

	// Idea based on LLVM::StringRef
	// http://llvm.org/docs/doxygen/html/StringRef_8h_source.html
	return size1 == size2 && memcmp__(s1, s2, size1) == 0;
}

// Assembly:
cmpq %rcx, %rsi
jne 0x2c84
pushq %rax
movq %rsi, %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2190
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/pairblob.cc
// Function: hm3::PairBlob::create(hm3::PairBlob const*)
std::unique_ptr<PairBlob> PairBlob::create(const PairBlob *src){
	if (src == nullptr)
		return {};

	size_t const size = src->getBytes();

	std::unique_ptr<PairBlob> pair{ new(size) PairBlob };

	memcpy(pair.get(), src, size);

	return pair;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2e9a
movq %rsi, %r14
movzwl 0x10(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl 0xc(%rsi), %ecx
bswapl %ecx
leaq (%rax,%rcx), %r12
addq $0x15, %r12
movq %r12, %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2140
jmp 0x2e9d
xorl %r15d, %r15d
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/pairblob.cc
// Function: hm3::PairBlob::valid(bool) const
bool PairBlob::valid(bool const tombstoneCheck) const noexcept{
	// check key size, keylen can not be 0
	// if (keylen == 0)
	//	return false;

	if (tombstoneCheck && vallen == 0)
		return false;

	// now expires is 0 no matter of endianness
	if (expires && MyTime::expired( getCreated(), be32toh(expires) ) )
		return false;

	// calc checksum
	if (calcChecksum() != checksum)
		return false;

	// finally all OK
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x2ebe
cmpl $0x0, 0xc(%rbx)
je 0x2ed6
movl 0x8(%rbx), %esi
testl %esi, %esi
je 0x2eda
movq (%rbx), %rdi
bswapq %rdi
bswapl %esi
callq 0x2f82
testb %al, %al
je 0x2eda
xorl %eax, %eax
jmp 0x2ee8
movq %rbx, %rdi
callq 0x2f5e
cmpb 0x12(%rbx), %al
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/pairblob.cc
// Function: hm3::PairBlob::print() const
void PairBlob::print() const noexcept{
	static const char *format = "%-20s | %-20s | %-*s | %8u\n";

	printf(format,
		getKey(), getVal(),
		MyTime::STRING_SIZE, MyTime::toString(getCreated()),
		be32toh(expires)
	);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x13(%rdi), %rbx
cmpl $0x0, 0xc(%rdi)
je 0x2f11
movzwl 0x10(%r14), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq (%rax,%rbx), %r15
incq %r15
jmp 0x2f14
xorl %r15d, %r15d
movq (%r14), %rdi
bswapq %rdi
leaq 0x2260(%rip), %rsi      # 0x5181
callq 0x2fe4
movl 0x8(%r14), %r9d
bswapl %r9d
leaq 0x2231(%rip), %rdi      # 0x5165
pushq $0x14
popq %rcx
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/common/mytime.cc
// Function: MyTime::now64()
uint64_t MyTime::now64() noexcept{
	// thanks to Howard Hinnant for this
	const auto now = std::chrono::system_clock::now().time_since_epoch();

	const auto sec = std::chrono::duration_cast<std::chrono::seconds>(now);
	const auto mil = std::chrono::duration_cast<std::chrono::microseconds>(now - sec);

	const auto sec_int = (uint32_t) sec.count();
	const auto mil_int = (uint32_t) mil.count();

	return combine(sec_int, mil_int);
}

// Assembly:
pushq %rax
callq 0x2040
movq %rax, %rcx
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
cqto
idivq %rsi
movq %rax, %rsi
imulq $-0x3b9aca00, %rax, %rax # imm = 0xC4653600
addq %rcx, %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
shlq $0x20, %rsi
movl %eax, %eax
orq %rsi, %rax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/common/mytime.cc
// Function: MyTime::toString(unsigned long, char const*)
const char *MyTime::toString(uint64_t date2, const char *format) noexcept{
	time_t date = uncombine(date2);

	if (date == 0)
		return NULL;

	struct tm *tm = localtime(& date);

	if (tm == NULL)
		return NULL;

	strftime(buffer, STRING_SIZE, format, tm);

	return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
shrq $0x20, %rdi
movq %rdi, (%rsp)
je 0x301c
movq %rsi, %rbx
movq %rsp, %rdi
callq 0x2110
testq %rax, %rax
je 0x301c
leaq 0x5197(%rip), %r14      # 0x81a0
pushq $0x14
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2130
jmp 0x301f
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::open(StringRef const&)
bool DiskTable::open(const StringRef &filename){
	header_.open(diskfile::filenameMeta(filename));

	if (header_ == false)
		return false;

	openFile__(mmapIndx_, blobIndx_, diskfile::filenameIndx(filename)	);
	openFile__(mmapData_, blobData_, diskfile::filenameData(filename)	);

	openFile__(mmapTree_, blobTree_, btreeindex::filenameIndx(filename)	);
	openFile__(mmapKeys_, blobKeys_, btreeindex::filenameData(filename)	);

	return mmapIndx_ && mmapData_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x3ff4
cmpb $0x0, (%r14)
je 0x316b
leaq 0x38(%r14), %rbx
leaq 0xa0(%r14), %r12
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3b23
movq (%r13), %rax
movq 0x8(%r13), %rcx
leaq 0x28(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b02
movq %rbx, 0x20(%rsp)
movq %rsp, %rdi
callq 0x20b0
leaq 0x50(%r14), %r12
leaq 0xb0(%r14), %r13
movq %rsp, %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3b58
movq (%rbp), %rax
movq 0x8(%rbp), %rcx
leaq 0x28(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %r12, %rdi
movq %r13, %rsi
callq 0x3b02
movq %rsp, %rdi
callq 0x20b0
leaq 0x68(%r14), %r13
leaq 0xc0(%r14), %rbp
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b8d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x28(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3b02
movq %rsp, %rdi
callq 0x20b0
leaq 0x80(%r14), %rbx
addq $0xd0, %r14
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3bc2
movq (%r13), %rax
movq 0x8(%r13), %rcx
leaq 0x28(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b02
movq %rsp, %rdi
callq 0x20b0
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x316b
cmpq $0x0, (%r12)
setne %al
jmp 0x316d
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3182
jmp 0x3182
jmp 0x3182
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::close()
void DiskTable::close(){
	closeFile__(mmapIndx_, blobIndx_);
	closeFile__(mmapData_, blobData_);

	closeFile__(mmapTree_, blobTree_);
	closeFile__(mmapKeys_, blobKeys_);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rbx)
callq 0x3f46
leaq 0x50(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rbx)
callq 0x3f46
leaq 0x68(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
callq 0x3f46
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
subq $-0x80, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3f46
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::getAtFromDisk_(unsigned long) const
const PairBlob *DiskTable::getAtFromDisk_(size_type const index) const{
	const uint64_t *ptrs_be = blobIndx_.as<const uint64_t>(0, getCount());

	if (!ptrs_be)
		return nullptr;

	const uint64_t ptr_be = ptrs_be[index];

	size_t const offset = (size_t) be64toh( ptr_be );

	// here unfortunately, we overrun the buffer, since PairBlob is variable size...
	const PairBlob *blob = blobData_.as<const PairBlob>(offset);

	// so we check overrun here...
	bool const overrun = nullptr == blobData_.safeAccessMemory(offset, blob->getBytes());

	if ( blob && !overrun)
		return validateFromDisk_(blob);

	return nullptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0xa0, %rdi
movq 0x8(%rbx), %rdx
xorl %esi, %esi
callq 0x3e6c
testq %rax, %rax
je 0x3938
movq (%rax,%r14,8), %rsi
bswapq %rsi
movq 0xb0(%rbx), %rax
movq 0xb8(%rbx), %rcx
testq %rcx, %rcx
sete %dl
leaq 0x14(%rsi), %rdi
cmpq %rcx, %rdi
seta %cl
orb %dl, %cl
leaq (%rax,%rsi), %rdx
xorl %r14d, %r14d
testb $0x1, %cl
cmoveq %rdx, %r14
testq %rax, %rax
cmoveq %rax, %r14
leaq 0xb0(%rbx), %rdi
movzwl 0x10(%r14), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl 0xc(%r14), %ecx
bswapl %ecx
leaq (%rax,%rcx), %rdx
addq $0x15, %rdx
callq 0x3d54
testq %rax, %rax
je 0x3938
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3942
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::validateFromDisk_(hm3::PairBlob const*) const
const PairBlob *DiskTable::validateFromDisk_(const PairBlob *blob) const{
	if (blob == nullptr)
		return nullptr;

	if (! validate_)
		return blob;

	return blob->validChecksum() ? blob : nullptr;
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0x3966
movq %rsi, %rbx
cmpb $0x1, 0x98(%rdi)
jne 0x3968
movq %rbx, %rdi
callq 0x3d42
xorl %ecx, %ecx
testb %al, %al
cmoveq %rcx, %rbx
jmp 0x3968
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::getNextFromDisk_(hm3::PairBlob const*, unsigned long) const
const PairBlob *DiskTable::getNextFromDisk_(const PairBlob *blobPrevious, size_t size) const{
	if (size == 0)
		size = blobPrevious->getBytes();

	const char *blobc = (const char *) blobPrevious;

	// here unfortunately, we overrun the buffer, since PairBlob is variable size...
	const PairBlob *blob = blobData_.as<const PairBlob>(blobc + size);

	// so we check overrun here...
	bool const overrun = nullptr == blobData_.safeAccessMemory(blob, blob->getBytes());

	if ( blob && !overrun)
		return validateFromDisk_(blob);

	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
jne 0x3993
movzwl 0x10(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl 0xc(%rsi), %ecx
bswapl %ecx
leaq (%rax,%rcx), %rdx
addq $0x15, %rdx
leaq 0xb0(%rbx), %r15
addq %rdx, %rsi
pushq $0x14
popq %rdx
movq %r15, %rdi
callq 0x3d82
movq %rax, %r14
movzwl 0x10(%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl 0xc(%r14), %ecx
bswapl %ecx
leaq (%rax,%rcx), %rdx
addq $0x15, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d82
testq %rax, %rax
je 0x39e4
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3942
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::Iterator::operator*() const
const Pair &DiskTable::Iterator::operator*() const{
	if (tmp_pod && tmp_pos == pos_)
		return tmp_pair;

	const PairBlob *pod;

	if (useFastForward_ && tmp_pod && tmp_pos == pos_ - 1){
		// get data without seek, walk forward
		// this gives 50% performance
		pod = list_.getNextFromDisk_(tmp_pod, tmp_pair.getBytes() );
	}else{
		// get data via seek
		pod = list_.getAtFromDisk_(pos_);
	}

	// SETTING MUTABLE VARIABLES

	tmp_pod  = pod;
	tmp_pos  = pos_;
	tmp_pair = tmp_pod;

	return tmp_pair;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x3a2c
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rax
cmpq %rsi, %rax
jne 0x3a3a
addq $0x28, %rbx
jmp 0x3a98
movq 0x8(%rbx), %rsi
movq (%rbx), %rdi
callq 0x389e
jmp 0x3a63
leaq -0x1(%rsi), %rcx
cmpq %rcx, %rax
jne 0x3a30
cmpb $0x0, 0x10(%rbx)
je 0x3a30
movq (%rbx), %r15
leaq 0x28(%rbx), %rdi
callq 0x2a68
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x396e
movq %rax, 0x20(%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rbx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2914
addq $0x28, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e2
leaq 0x8(%rsp), %rdi
callq 0x28d0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x28d0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/include/binarysearch_impl.h
// Function: bool binarySearch<hm3::DiskTable, unsigned long, StringRef, BinarySearchCompList>(hm3::DiskTable const&, unsigned long, unsigned long, StringRef const&, BinarySearchCompList const&, unsigned long&, unsigned long)
bool binarySearch(const ARRAY &list,
				SIZE start, SIZE end,
				const KEY &key,
				const COMP &comp,
				SIZE &result,
				SIZE const minimum_distance){
	/*
	 * Lazy based from Linux kernel...
	 * http://lxr.free-electrons.com/source/lib/bsearch.c
	 */

	while (start + minimum_distance < end){
	//	SIZE const mid = start + ((end - start) /  2);
		SIZE const mid = SIZE(start + ((end - start) >> 1)); // 4% faster

		int const cmp = comp(list, mid, key); //list.cmpAt(mid, key);

		if (cmp < 0){
			// go right
			start = mid + 1;

			// scatter code would go here.
			// but it have negative effect.
		}else if (cmp > 0){
			// go left
			end = mid;
		}else{
			// found
			// index = mid; return 0;
			result = mid;
			return true;
		}

	}

	// fallback to linear search...
	for(; start < end; ++start){
		int const cmp = comp(list, start, key); //list.cmpAt(start, key);

		if (cmp == 0){
			// found
			// index = left; return 0;
			result = start;
			return true;
		}

		if (cmp > 0)
			break;
	}

	result = start;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq 0x40(%rsp), %rbx
leaq (%r14,%rbx), %rax
cmpq %r12, %rax
jae 0x3c7c
movq %r12, %rbp
subq %r14, %rbp
shrq %rbp
addq %r14, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x387a
testl %eax, %eax
jns 0x3c6f
incq %rbp
movq %rbp, %r14
jmp 0x3c40
movq %rbp, %r12
jne 0x3c40
movb $0x1, %al
movq (%rsp), %rbx
jmp 0x3ca7
movq (%rsp), %rbx
cmpq %r12, %r14
jae 0x3c9e
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x387a
testl %eax, %eax
je 0x3ca2
jg 0x3c9e
incq %r14
jmp 0x3c80
xorl %eax, %eax
jmp 0x3ca4
movb $0x1, %al
movq %r14, %rbp
movq %rbp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::search_(StringRef const&, unsigned long&) const
inline bool DiskTable::search_(const StringRef &key, size_type &result) const{
	if (mmapTree_ && mmapKeys_){
		log__("btree");
		return btreeSearch_(key, result);
	}else{
		log__("binary");
		return binarySearch_(key, result);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x68(%rdi)
je 0x3cf8
cmpq $0x0, 0x80(%r15)
je 0x3cf8
leaq 0x15d1(%rip), %rdi      # 0x52b1
callq 0x3695
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x31ea
leaq 0x15b8(%rip), %rdi      # 0x52b7
callq 0x3695
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3bf8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
shlq $0x4, %r14
xorl %eax, %eax
xorl %esi, %esi
cmpq %rax, %r14
je 0x3de1
addq (%r15,%rax), %rsi
addq $0x10, %rax
jmp 0x3dd2
movq %rbx, %rdi
callq 0x2220
testq %r14, %r14
je 0x3e07
movq (%r15), %rdx
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x2050
addq $0x10, %r15
addq $-0x10, %r14
jmp 0x3de9
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3e12
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3f46
movq 0x8(%r15), %rdi
xorl %r15d, %r15d
movl %ebp, %esi
xorl %eax, %eax
callq 0x2100
testl %eax, %eax
js 0x3f2b
movl %eax, %ebp
pushq $0x2
popq %rdx
movl %eax, %edi
xorl %esi, %esi
callq 0x2290
testq %rax, %rax
jle 0x3f21
movq %rax, %r15
pushq $0x1
popq %rcx
xorl %edi, %edi
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x2270
cmpq $-0x1, %rax
je 0x3f21
movq %rax, %r14
movl 0x14(%rbx), %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movl %ebp, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq %r14, (%rbx)
movb $0x1, %r15b
jmp 0x3f2b
movl %ebp, %edi
callq 0x22a0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3f69
movq 0x8(%rbx), %rsi
callq 0x20d0
movl 0x10(%rbx), %edi
callq 0x22a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
xorl %ebp, %ebp
pushq $0x42
popq %rsi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x2100
testl %eax, %eax
js 0x3fa9
movl %eax, %r14d
movl %eax, %edi
movq %rbx, %rsi
callq 0x21e0
movl %eax, %ebx
movl %r14d, %edi
callq 0x22a0
testl %ebx, %ebx
sete %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
andw $0x0, 0x30(%rsi)
pushq $0x11
popq %rdx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x40b2
cmpl $0x4553555a, (%rsp)     # imm = 0x4553555A
je 0x40bc
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x11(%rsp), %rsi
movb -0x9(%rsi), %al
movb %al, (%rbx)
movq -0x8(%rsi), %rax
bswapq %rax
movq %rax, 0x8(%rbx)
pushq $0x21
popq %rdx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x4109
cmpq $0x20, 0x8(%r14)
jg 0x4109
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x30(%rbx)
jmp 0x4142
movq 0x11(%rsp), %rax
bswapq %rax
movq %rax, 0x10(%rbx)
cmpb $0x1, 0x19(%rsp)
sete 0x18(%rbx)
movq 0x1a(%rsp), %rax
bswapq %rax
movq %rax, 0x20(%rbx)
movq 0x22(%rsp), %rax
bswapq %rax
movq %rax, 0x28(%rbx)
movq 0x2a(%rsp), %rax
bswapq %rax
movq %rax, 0x30(%rbx)
movb $0x1, %al
jmp 0x40b4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movabsq $0x3330304553555a, %rcx # imm = 0x3330304553555A
movq %rcx, (%rdi)
movb $0x3, 0x8(%rdi)
movq 0x8(%rsi), %rcx
bswapq %rcx
movq %rcx, 0x9(%rdi)
movq 0x10(%rsi), %rcx
bswapq %rcx
movq %rcx, 0x11(%rdi)
movb 0x18(%rsi), %cl
movb %cl, 0x19(%rdi)
movq 0x20(%rsi), %rcx
bswapq %rcx
movq %rcx, 0x1a(%rdi)
movq 0x28(%rsi), %rcx
bswapq %rcx
movq %rcx, 0x22(%rdi)
movq 0x30(%rsi), %rcx
bswapq %rcx
movq %rcx, 0x2a(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %edx
leaq 0x11d0(%rip), %rdi      # 0x53c6
leaq 0x11d4(%rip), %rsi      # 0x53d1
xorl %eax, %eax
callq 0x2030
movq 0x8(%rbx), %rdx
leaq 0x11ca(%rip), %rdi      # 0x53d9
leaq 0x11cf(%rip), %rsi      # 0x53e5
xorl %eax, %eax
callq 0x2030
movq 0x10(%rbx), %rdi
leaq 0x11d8(%rip), %r14      # 0x5400
movq %r14, %rdx
testq %rdi, %rdi
je 0x423f
leaq 0xf4a(%rip), %rsi       # 0x5181
callq 0x2fe4
movq %rax, %rdx
leaq 0x11a7(%rip), %r15      # 0x53ed
leaq 0x11ab(%rip), %rsi      # 0x53f8
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x11ad(%rip), %rax      # 0x540b
leaq 0x11aa(%rip), %rdx      # 0x540f
cmpb $0x0, 0x18(%rbx)
cmovneq %rax, %rdx
leaq 0x1190(%rip), %rsi      # 0x5404
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
movq 0x20(%rbx), %rdx
leaq 0x1150(%rip), %rdi      # 0x53d9
leaq 0x1182(%rip), %rsi      # 0x5412
xorl %eax, %eax
callq 0x2030
movq 0x28(%rbx), %rdi
movq %r14, %rdx
testq %rdi, %rdi
je 0x42b2
leaq 0xed7(%rip), %rsi       # 0x5181
callq 0x2fe4
movq %rax, %rdx
leaq 0x1134(%rip), %rdi      # 0x53ed
leaq 0x115d(%rip), %rsi      # 0x541d
xorl %eax, %eax
callq 0x2030
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x42df
leaq 0xeaa(%rip), %rsi       # 0x5181
callq 0x2fe4
movq %rax, %r14
leaq 0x1107(%rip), %rdi      # 0x53ed
leaq 0x113d(%rip), %rsi      # 0x542a
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %r14d, %r14d
leaq 0x3911bc(%rip), %r15    # 0x4b8e60
leaq 0x8(%rsp), %rbx
cmpq $0xa, %r14
je 0x127ced
movb $0x1, %bpl
xorl %r12d, %r12d
cmpq $0xa780, %r12           # imm = 0xA780
je 0x127ce0
leaq (%r15,%r12), %rdi
movsd 0x20(%r12,%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rsi
callq 0x193f07
andb %al, %bpl
addq $0x28, %r12
jmp 0x127cb5
incq %r14
testb $0x1, %bpl
jne 0x127ca9
xorl %ebx, %ebx
jmp 0x127d4c
leaq 0x8(%rsp), %rdi
callq 0x1946b6
movb $0x1, %bl
xorl %r15d, %r15d
pushq $0x28
popq %r12
leaq 0x20(%rsp), %r14
xorl %r13d, %r13d
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x127d42
movsd 0x20(%rdi,%r15), %xmm0
addq %r15, %rdi
movsd %xmm0, 0x20(%rsp)
movq %r14, %rsi
callq 0x193f07
andb %al, %bl
incq %r13
addq $0x28, %r15
jmp 0x127d08
leaq 0x8(%rsp), %rdi
callq 0x19484c
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x19484c
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: edge_cases<double>::test_cases[abi:cxx11]()
static inline std::vector<test_t> test_cases()
   {
      std::vector<test_t> cases;
      cases.push_back(test_t(" 2.2250738585072013831e-308",  2.2250738585072013831e-308));
      cases.push_back(test_t(" 1.7976931348623157081e+308",  1.7976931348623157081e+308));
      cases.push_back(test_t("+2.2250738585072013831e-308", +2.2250738585072013831e-308));
      cases.push_back(test_t("+1.7976931348623157081e+308", +1.7976931348623157081e+308));
      cases.push_back(test_t("-2.2250738585072013831e-308", -2.2250738585072013831e-308));
      cases.push_back(test_t("-1.7976931348623157081e+308", -1.7976931348623157081e+308));

      return cases;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movabsq $0x10000000000000, %r14 # imm = 0x10000000000000
movq %rsp, %rdx
movq %r14, (%rdx)
leaq 0x149948(%rip), %rsi    # 0x2de02c
leaq 0x8(%rsp), %rdi
callq 0x127b28
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ba354
leaq 0x8(%rsp), %rdi
callq 0x118648
movabsq $0x7fefffffffffffff, %r15 # imm = 0x7FEFFFFFFFFFFFFF
movq %rsp, %rdx
movq %r15, (%rdx)
leaq 0x14992c(%rip), %rsi    # 0x2de048
leaq 0x8(%rsp), %rdi
callq 0x127b28
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ba354
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rsp, %rdx
movq %r14, (%rdx)
leaq 0x14991a(%rip), %rsi    # 0x2de064
leaq 0x8(%rsp), %rdi
callq 0x127b28
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ba354
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rsp, %rdx
movq %r15, (%rdx)
leaq 0x149908(%rip), %rsi    # 0x2de080
leaq 0x8(%rsp), %rdi
callq 0x127b28
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ba354
leaq 0x8(%rsp), %rdi
callq 0x118648
movabsq $-0x7ff0000000000000, %rax # imm = 0x8010000000000000
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x1498ec(%rip), %rsi    # 0x2de09c
leaq 0x8(%rsp), %rdi
callq 0x127b28
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ba354
leaq 0x8(%rsp), %rdi
callq 0x118648
movabsq $-0x10000000000001, %rax # imm = 0xFFEFFFFFFFFFFFFF
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x1498d0(%rip), %rsi    # 0x2de0b8
leaq 0x8(%rsp), %rdi
callq 0x127b28
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ba354
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x19482a
jmp 0x194839
jmp 0x19482a
jmp 0x194839
jmp 0x19482a
jmp 0x194839
jmp 0x19482a
jmp 0x194839
jmp 0x19482a
jmp 0x194839
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x19483c
movq %rax, %r14
movq %rbx, %rdi
callq 0x19484c
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
addq $0x8, %rdi
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rbx
subq %rcx, %rbx
sarq $0x3, %rbx
movq (%rsi), %rax
movq %rbx, %rdx
negq %rdx
xorl %r8d, %r8d
movq %r8, %r14
cmpq %r8, %rdx
je 0x1949bd
cmpq %rsi, %rcx
je 0x1949c2
leaq -0x1(%r14), %r8
leaq 0x8(%rcx), %r9
cmpq (%rcx), %rax
movq %r9, %rcx
jne 0x19499e
jmp 0x1949c2
callq 0x198e9c
negq %r14
cmpq %rbx, %r14
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x338(%rsi), %rax
cmpq 0x318(%rsi), %rax
je 0x1955fd
addq $0x318, %rsi            # imm = 0x318
movq %rsi, %rdi
xorl %esi, %esi
callq 0x2ba0a0
leaq 0x38(%rax), %rsi
movq %rbx, %rdi
callq 0x1182f0
jmp 0x195611
leaq 0x148a11(%rip), %rsi    # 0x2de015
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x196169
testb %sil, %sil
je 0x196161
movq 0x18(%rbx), %r14
leaq 0x8(%rbx), %r15
cmpq %r14, %r15
je 0x196161
leaq 0x40(%r14), %rdi
callq 0x196174
movq %r14, %rdi
callq 0x118520
movq %rax, %r14
jmp 0x196146
movq %rbx, %rdi
callq 0x196186
andq $0x0, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r15
movq 0x8(%rsi), %rbp
movq (%rdx), %r13
movq 0x8(%rdx), %r12
cmpq %rbp, %r12
movq %rbp, (%rsp)
cmovbq %r12, %rbp
xorl %r14d, %r14d
cmpq %r14, %rbp
je 0x1968cb
movsbl (%r15,%r14), %edi
callq 0x118450
movl %eax, %ebx
movsbl (%r13,%r14), %edi
callq 0x118450
movsbl %bl, %ecx
movsbl %al, %eax
incq %r14
cmpl %ecx, %eax
je 0x19689d
setg %al
jmp 0x1968d2
cmpq %r12, (%rsp)
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x198198
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x198188
decq (%r15)
jne 0x198188
movq %r15, %rdi
callq 0x1981bc
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x1982c4
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::control_block::~control_block()
~control_block()
         {
            if (expr && details::branch_deletable(expr))
            {
               destroy_node(expr);
            }

            if (!local_data_list.empty())
            {
               for (std::size_t i = 0; i < local_data_list.size(); ++i)
               {
                  switch (local_data_list[i].type)
                  {
                     case e_expr      : delete reinterpret_cast<expression_ptr>(local_data_list[i].pointer);
                                        break;

                     case e_vecholder : delete reinterpret_cast<vector_holder_ptr>(local_data_list[i].pointer);
                                        break;

                     case e_data      : delete reinterpret_cast<T*>(local_data_list[i].pointer);
                                        break;

                     case e_vecdata   : delete [] reinterpret_cast<T*>(local_data_list[i].pointer);
                                        break;

                     case e_string    : delete reinterpret_cast<std::string*>(local_data_list[i].pointer);
                                        break;

                     default          : break;
                  }
               }
            }

            if (results)
            {
               delete results;
            }
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1981e5
callq 0x1982f4
testb %al, %al
je 0x1981e5
leaq 0x8(%rbx), %rdi
callq 0x198320
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
cmpq %rax, %rcx
je 0x198285
xorl %ebp, %ebp
pushq $0x18
popq %r14
leaq 0x136175(%rip), %r15    # 0x2ce378
xorl %r12d, %r12d
subq %rcx, %rax
cqto
idivq %r14
cmpq %rax, %r12
jae 0x198285
movl 0x8(%rcx,%rbp), %eax
decl %eax
cmpl $0x4, %eax
ja 0x198274
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq (%rcx,%rbp), %rdi
testq %rdi, %rdi
je 0x198274
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x198274
movq (%rcx,%rbp), %r13
testq %r13, %r13
je 0x198249
movq %r13, %rdi
callq 0x118648
movq %r13, %rdi
pushq $0x20
jmp 0x19826e
movq (%rcx,%rbp), %rdi
pushq $0x8
jmp 0x19826e
movq (%rcx,%rbp), %rdi
testq %rdi, %rdi
je 0x198274
callq 0x1181d0
jmp 0x198274
movq (%rcx,%rbp), %rdi
pushq $0x48
popq %rsi
callq 0x1180d0
incq %r12
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
addq $0x18, %rbp
jmp 0x198206
movq 0x28(%rbx), %r14
addq $0x10, %rbx
testq %r14, %r14
je 0x1982a6
leaq 0x8(%r14), %rdi
callq 0x198da8
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x1180d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x198de4
movq %rax, %rdi
callq 0x193e66
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x1983be
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x198454
xorl %ebx, %ebx
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbx
jae 0x19839b
movq (%rax,%rbx,8), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x198392
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, (%r14)
incq %rbx
jmp 0x19836b
movq %rsp, %rdi
callq 0x198d8a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x198d8a
movq %rbx, %rdi
callq 0x118360