LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::getA(int, signed char)
NUMBER** HMMProblemSlicedA::getA(NCAT x, NPAR z) {
    if( x > (this->sizes[1]-1) ) {
        fprintf(stderr,"While accessing A, skill index %d or slize index %d exceeded last index of the data %d.\n", x, z, this->sizes[1]-1);
        exit(1);
    }
    return this->A[x][z];
}

// Assembly:
movl %esi, %eax
movq %rdi, %rcx
movl 0x10(%rdi), %edi
cmpl %esi, %edi
jle 0x2bee6
movq 0x90(%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movsbq %dl, %rcx
movq (%rax,%rcx,8), %rax
retq
pushq %rax
movzbl %dl, %esi
movl %eax, %edx
callq 0x54f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::getB(data*, signed char, signed char)
NUMBER HMMProblemSlicedA::getB (struct data* dt, NPAR i, NPAR m) {
    // special attention for "unknown" 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)
        return 1;
    switch(this->p->structure)
    {
        case STRUCTURE_SKAslc:
            return this->B[dt->k][i][m];
            break;
        default:
            fprintf(stderr,"Solver specified is not supported.\n");
            exit(1);
            break;
    }
}

// Assembly:
testb %cl, %cl
js 0x2bf98
movq 0x88(%rdi), %rax
cmpb $0xc, 0x3e(%rax)
jne 0x2bfa1
movq 0x48(%rdi), %rax
movslq 0x58(%rsi), %rsi
movq (%rax,%rsi,8), %rax
movsbq %dl, %rdx
movq (%rax,%rdx,8), %rax
movzbl %cl, %ecx
movsd (%rax,%rcx,8), %xmm0
retq
movsd 0x8950(%rip), %xmm0     # 0x348f0
retq
pushq %rax
callq 0x551b
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::toZero3Params(double*&, double***&, double**&, signed char, signed char, signed char)
void HMMProblemSlicedA::toZero3Params(NUMBER* &PI, NUMBER*** &A, NUMBER** &B, NPAR nZ, NPAR nS, NPAR nO) { // sliced
    toZero1D<NUMBER>(PI, (NDAT)nS);
    toZero3D<NUMBER>(A,  (NDAT)nZ, (NDAT)nS, (NDAT)nS);
    toZero2D<NUMBER>(B,  (NDAT)nS, (NDAT)nO);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r14d
movl %r8d, %ebp
movq %rcx, (%rsp)
movq %rdx, %r15
testb %r14b, %r14b
jle 0x2dc14
movq (%rsi), %rdi
leal (,%r14,8), %edx
xorl %esi, %esi
callq 0x4120
movl %r14d, %r12d
testb %bpl, %bpl
jle 0x2dc6f
movq (%r15), %rax
movq %rax, 0x8(%rsp)
movzbl %bpl, %eax
movq %rax, 0x10(%rsp)
leaq (,%r12,8), %r15
xorl %ebx, %ebx
movq %r14, %rbp
testb %r14b, %r14b
jle 0x2dc62
movq 0x8(%rsp), %rax
movq (%rax,%rbx,8), %r13
xorl %r14d, %r14d
movq (%r13,%r14,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4120
incq %r14
cmpq %r14, %r12
jne 0x2dc4b
incq %rbx
cmpq 0x10(%rsp), %rbx
movq %rbp, %r14
jne 0x2dc37
testb %r14b, %r14b
jle 0x2dca8
movb 0x50(%rsp), %bpl
movq (%rsp), %rax
movq (%rax), %r14
movsbq %bpl, %rax
movl %eax, %ebx
shlq $0x3, %rbx
xorl %r15d, %r15d
testb %bpl, %bpl
jle 0x2dca0
movq (%r14,%r15,8), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4120
incq %r15
cmpq %r15, %r12
jne 0x2dc8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::cpy3Params(double*&, double***&, double**&, double*&, double***&, double**&, signed char, signed char, signed char)
void HMMProblemSlicedA::cpy3Params(NUMBER* &soursePI, NUMBER*** &sourseA, NUMBER** &sourseB, NUMBER* &targetPI, NUMBER*** &targetA, NUMBER** &targetB, NPAR nZ, NPAR nS, NPAR nO) {  // sliced
    cpy1D<NUMBER>(soursePI, targetPI, (NDAT)nS);
    cpy3D<NUMBER>(sourseA,  targetA,  (NDAT)nZ, (NDAT)nS, (NDAT)nS);
    cpy2D<NUMBER>(sourseB,  targetB,  (NDAT)nS, (NDAT)nO);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movsbq 0x60(%rsp), %r13
movb 0x58(%rsp), %bl
movq (%rsi), %rsi
movq (%r8), %rdi
movq %r13, %r14
shlq $0x3, %r14
movq %r14, %rdx
callq 0x41c0
movq %r13, (%rsp)
movl %r13d, %r13d
testb %bl, %bl
jle 0x2dd3e
movq (%r12), %r12
movq (%r15), %r15
movzbl %bl, %eax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
cmpb $0x0, (%rsp)
jle 0x2dd34
xorl %ebx, %ebx
movq (%r15,%rbp,8), %rax
movq (%rax,%rbx,8), %rdi
movq (%r12,%rbp,8), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdx
callq 0x41c0
incq %rbx
cmpq %rbx, %r13
jne 0x2dd14
incq %rbp
cmpq 0x10(%rsp), %rbp
jne 0x2dd0c
cmpb $0x0, (%rsp)
jle 0x2dd79
movq 0x50(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %r14
movq (%rax), %r15
movsbq 0x68(%rsp), %rbx
shlq $0x3, %rbx
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq (%r14,%r12,8), %rsi
movq %rbx, %rdx
callq 0x41c0
incq %r12
cmpq %r12, %r13
jne 0x2dd61
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::free3Params(double*&, double***&, double**&, signed char, signed char)
void HMMProblemSlicedA::free3Params(NUMBER* &PI, NUMBER*** &A, NUMBER** &B, NPAR nZ, NPAR nS) {  // sliced
    free(PI);
    free3D<NUMBER>(A, (NDAT)nZ, (NDAT)nS);
    free2D<NUMBER>(B, (NDAT)nS);
    PI = NULL;
    A  = NULL;
    B  = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq (%rsi), %rdi
callq 0x42a0
movq (%r15), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0xca4f
movq (%r14), %rdi
movl %ebx, %esi
callq 0xa5e0
xorl %eax, %eax
movq %rax, (%r12)
movq %rax, (%r15)
movq %rax, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemComp.cpp
// Function: HMMProblemComp::HMMProblemComp(param*)
HMMProblemComp::HMMProblemComp(struct param *param) {
    for(NPAR i=0; i<3; i++) this->sizes[i] = param->nK;
//    this->sizes = {param->nK, param->nK, param->nK};
    this->n_params = param->nK * 4;
  
    init(param);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x10b14
leaq 0xecda(%rip), %rax      # 0x3fcc8
movq %rax, (%rbx)
movl $0x3, %eax
movl 0x8c0(%r14), %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0x6, %rax
jne 0x30ff6
movl 0x8c0(%r14), %eax
shll $0x2, %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3103c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x11386
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemComp.cpp
// Function: HMMProblemComp::getPI(data*, signed char)
NUMBER HMMProblemComp::getPI(struct data* dt, NPAR i) {
	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
	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->pi[dt->k][i];
	} 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->pi[dt->k][i];
		} 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->pi[k][i];
			}
			r = this->pu->unite(q, n_skills, NULL, 0); //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
movl %edx, %ebp
movq %rdi, %rbx
movq 0x88(%rdi), %r12
cmpl $0x0, 0x9a0(%r12)
je 0x31773
movq 0x90(%rbx), %rcx
movslq 0x58(%rsi), %rax
cmpb $0x0, (%rcx,%rax)
je 0x31773
movq 0x890(%r12), %rcx
movslq 0x8(%rsi), %r13
movslq (%rcx,%r13,4), %r14
cmpq $0x1, %r14
jne 0x31797
movq 0x38(%rbx), %rcx
movq (%rcx,%rax,8), %rax
jmp 0x3177f
movq 0x38(%rbx), %rax
movslq 0x58(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movsbq %bpl, %rcx
movsd (%rax,%rcx,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %esi
movq %r14, %rdi
callq 0x4130
movq %rax, %r15
testl %r14d, %r14d
jle 0x317e9
movq 0x898(%r12), %rax
movslq (%rax,%r13,4), %rax
movq 0x38(%rbx), %rcx
movsbq %bpl, %rdx
shlq $0x2, %rax
addq 0x888(%r12), %rax
xorl %esi, %esi
movslq (%rax,%rsi,4), %rdi
movq (%rcx,%rdi,8), %rdi
movsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%r15,%rsi,8)
incq %rsi
cmpq %rsi, %r14
jne 0x317ce
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x8(%rax)
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x42a0
movsd (%rsp), %xmm0
jmp 0x31788
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemComp.cpp
// Function: HMMProblemComp::getA(data*, signed char, signed char)
NUMBER HMMProblemComp::getA(struct data* dt, NPAR i, NPAR j) {
	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
	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->A[dt->k][i][j];
	} 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->A[dt->k][i][j];
		} 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->A[k][i][j];
			}
			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
movl %ecx, %ebp
movl %edx, %r12d
movq %rdi, %rbx
movq 0x88(%rdi), %r13
cmpl $0x0, 0x9a0(%r13)
je 0x3186c
movq 0x90(%rbx), %rcx
movslq 0x58(%rsi), %rax
cmpb $0x0, (%rcx,%rax)
je 0x3186c
movq 0x890(%r13), %rcx
movslq 0x8(%rsi), %rdx
movslq (%rcx,%rdx,4), %r14
cmpq $0x1, %r14
jne 0x31898
movq 0x40(%rbx), %rcx
movq (%rcx,%rax,8), %rax
jmp 0x31878
movq 0x40(%rbx), %rax
movslq 0x58(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movsbq %r12b, %rcx
movq (%rax,%rcx,8), %rax
movsbq %bpl, %rcx
movsd (%rax,%rcx,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, (%rsp)
movl $0x8, %esi
movq %r14, %rdi
callq 0x4130
movq %rax, %r15
testl %r14d, %r14d
jle 0x318f9
movq 0x898(%r13), %rax
movq (%rsp), %rcx
movslq (%rax,%rcx,4), %rax
movq 0x40(%rbx), %rcx
movsbq %r12b, %rdx
movsbq %bpl, %rsi
shlq $0x2, %rax
addq 0x888(%r13), %rax
xorl %edi, %edi
movslq (%rax,%rdi,4), %r8
movq (%rcx,%r8,8), %r8
movq (%r8,%rdx,8), %r8
movsd (%r8,%rsi,8), %xmm0
movsd %xmm0, (%r15,%rdi,8)
incq %rdi
cmpq %rdi, %r14
jne 0x318d9
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x8(%rax)
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x42a0
movsd (%rsp), %xmm0
jmp 0x31889
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %ecx, %ebp
testb %bpl, %bpl
js 0x319a3
movl %edx, %r15d
movq %rdi, %rbx
movq 0x88(%rdi), %r13
cmpl $0x0, 0x9a0(%r13)
je 0x31981
movq 0x90(%rbx), %rcx
movslq 0x58(%rsi), %rax
cmpb $0x0, (%rcx,%rax)
je 0x31981
movq 0x890(%r13), %rcx
movslq 0x8(%rsi), %rdx
movslq (%rcx,%rdx,4), %r14
cmpq $0x1, %r14
jne 0x319b0
movq 0x48(%rbx), %rcx
movq (%rcx,%rax,8), %rax
jmp 0x3198d
movq 0x48(%rbx), %rax
movslq 0x58(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movsbq %r15b, %rcx
movq (%rax,%rcx,8), %rax
movzbl %bpl, %ecx
movsd (%rax,%rcx,8), %xmm0
jmp 0x31a3b
movsd 0x2f45(%rip), %xmm0     # 0x348f0
jmp 0x31a3b
movq %rdx, (%rsp)
movl $0x8, %esi
movq %r14, %rdi
callq 0x4130
movq %rax, %r12
testl %r14d, %r14d
jle 0x31a11
movq 0x898(%r13), %rax
movq (%rsp), %rcx
movslq (%rax,%rcx,4), %rax
movq 0x48(%rbx), %rcx
movsbq %r15b, %rdx
movzbl %bpl, %esi
shlq $0x2, %rax
addq 0x888(%r13), %rax
xorl %edi, %edi
movslq (%rax,%rdi,4), %r8
movq (%rcx,%r8,8), %r8
movq (%r8,%rdx,8), %r8
movsd (%r8,%rsi,8), %xmm0
movsd %xmm0, (%r12,%rdi,8)
incq %rdi
cmpq %rdi, %r14
jne 0x319f1
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movq %r12, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x8(%rax)
movsd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x42a0
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x2, %edi
movl $0x8, %esi
callq 0x4130
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1442c
movq 0x88(%rbx), %rax
cmpb $0xd, 0x3e(%rax)
jne 0x3211d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
addsd (%r14), %xmm0
movsd %xmm0, (%r14)
movsd %xmm0, 0x20(%rbx)
movq %r14, %rdi
callq 0x42a0
movq 0x88(%rbx), %rax
movl $0x1, 0x9a0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x563e
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x583b(%rip), %r14      # 0x7fd0
leaq 0x2868(%rip), %rsi      # 0x5004
movl $0x6, %edx
movq %r14, %rdi
callq 0x2190
leaq 0x9(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2190
movq %rax, %r14
leaq 0x2843(%rip), %rsi      # 0x500b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
testq %rbx, %rbx
je 0x27f2
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x280c
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2230
leaq 0x27fa(%rip), %rsi      # 0x500d
movl $0x3a, %edx
movq %r14, %rdi
callq 0x2190
leaq 0xa(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2190
movq %rax, %r14
leaq 0x27cc(%rip), %rsi      # 0x500b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
testq %rbx, %rbx
je 0x2869
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x2883
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2230
leaq 0x27be(%rip), %rsi      # 0x5048
movl $0x3b, %edx
movq %r14, %rdi
callq 0x2190
leaq 0xb(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2190
movq %rax, %r14
leaq 0x2755(%rip), %rsi      # 0x500b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
testq %rbx, %rbx
je 0x28e0
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x28fa
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2230
leaq 0x2783(%rip), %rsi      # 0x5084
movl $0x3b, %edx
movq %r14, %rdi
callq 0x2190
movb $0xa, %bpl
leaq 0xc(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2190
movq %rax, %rbx
leaq 0x2790(%rip), %rsi      # 0x50c0
movl $0x2e, %edx
movq %rax, %rdi
callq 0x2190
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2190
movq %rax, %rbx
leaq 0x2793(%rip), %rsi      # 0x50ef
movl $0x1d, %edx
movq %rax, %rdi
callq 0x2190
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2190
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/pairblob.h
// Function: hm3::PairBlob::cmp(char const*) const
int cmp(const char *key) const noexcept{
		// because of strlen nullptr, we do it in this way
		return StringRef::fastEmptyChar(key) ?
			CMP_NULLKEY :
			StringRef::compare(getKey(), getKeyLen(), key, strlen(key) );
	}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x2d18
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x2d0d
movq %rdi, %r14
movzwl 0x10(%rdi), %eax
addq $0x13, %r14
rolw $0x8, %ax
movzwl %ax, %r12d
movq %rbx, %rdi
callq 0x2090
movq %rax, %r15
movq %r14, %rcx
xorq %rbx, %rcx
movq %r12, %rdx
xorq %rax, %rdx
xorl %eax, %eax
orq %rcx, %rdx
je 0x2d0d
cmpq %r12, %r15
movq %r12, %rdx
cmovbq %r15, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20a0
testl %eax, %eax
jne 0x2d0d
subq %r15, %r12
xorl %eax, %eax
testq %r12, %r12
setg %al
sarq $0x3f, %r12
addl %eax, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/pairblob.h
// Function: hm3::PairBlob::equals(char const*) const
bool equals(const char *key) const noexcept{
		// because of strlen nullptr, we do it in this way
		return StringRef::fastEmptyChar(key) ?
			bool(CMP_NULLKEY) :
			StringRef::equals(getKey(), getKeyLen(), key, strlen(key) );
	}

// Assembly:
movb $0x1, %al
testq %rsi, %rsi
je 0x2da6
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x2da1
movq %rdi, %r14
movzwl 0x10(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %r15d
movq %rbx, %rdi
callq 0x2090
cmpq %r15, %rax
jne 0x2d9f
addq $0x13, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2180
testl %eax, %eax
sete %al
jmp 0x2da1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3007
movq %rsi, %r14
movzwl 0x10(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl 0xc(%rsi), %ecx
bswapl %ecx
leaq (%rax,%rcx), %r15
addq $0x15, %r15
movq %r15, %rdi
callq 0x2160
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2130
jmp 0x300e
movq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x3029
cmpl $0x0, 0xc(%rbx)
je 0x304c
movl 0x8(%rbx), %r14d
testl %r14d, %r14d
je 0x3050
movq (%rbx), %rax
bswapq %rax
bswapl %r14d
shlq $0x20, %r14
addq %rax, %r14
callq 0x312a
cmpq %rax, %r14
jae 0x3050
xorl %eax, %eax
jmp 0x3084
leaq 0x13(%rbx), %rax
movzwl 0x10(%rbx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movl 0xc(%rbx), %edx
bswapl %edx
addq %rbx, %rcx
addq $0x13, %rcx
addq %rcx, %rdx
addq $0x2, %rdx
xorl %ecx, %ecx
xorb (%rax), %cl
incq %rax
cmpq %rdx, %rax
jb 0x3074
cmpb 0x12(%rbx), %cl
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
leaq 0x13(%rdi), %rbx
cmpl $0x0, 0xc(%rdi)
je 0x30b3
movzwl 0x10(%r15), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq (%rax,%rbx), %r14
incq %r14
jmp 0x30b6
xorl %r14d, %r14d
movq (%r15), %rdi
bswapq %rdi
leaq 0x20be(%rip), %rsi      # 0x5181
callq 0x317c
movl 0x8(%r15), %r9d
bswapl %r9d
leaq 0x208f(%rip), %rdi      # 0x5165
movl $0x14, %ecx
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/common/myhash_impl.h
// Function: hm3::PairBlob::calcChecksum_(char const*, unsigned long)
uint operator()(const char *s, size_t const size) const{
			uint hash = offset_basis;

			for(const char *c = s; c < s + size; ++c)
				h_.add(hash, *c);

			return hash;
		}

// Assembly:
testq %rsi, %rsi
jle 0x3105
addq %rdi, %rsi
xorl %eax, %eax
xorb (%rdi), %al
incq %rdi
cmpq %rsi, %rdi
jb 0x30fa
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
imulq %rdx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x1a, %rdx
addq %rdx, %rsi
imulq $-0x3b9aca00, %rsi, %rax # imm = 0xC4653600
addq %rcx, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x7, %rdx
addl %edx, %eax
shlq $0x20, %rsi
orq %rsi, %rax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31b6
movq %rsi, %rbx
movq %rsp, %rdi
callq 0x2100
testq %rax, %rax
je 0x31b6
leaq 0x4fef(%rip), %r14      # 0x8190
movl $0x14, %esi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2120
jmp 0x31b9
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43c2
leaq 0x50(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rbx)
callq 0x43c2
leaq 0x68(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
callq 0x43c2
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
subq $-0x80, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x43c2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3fd4
movq %rsi, %rbx
cmpb $0x1, 0x98(%rdi)
jne 0x3fd6
leaq 0x13(%rbx), %rdi
movzwl 0x10(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl 0xc(%rbx), %ecx
bswapl %ecx
leaq (%rax,%rcx), %rsi
addq $0x2, %rsi
callq 0x30f0
xorl %ecx, %ecx
cmpb 0x12(%rbx), %al
cmovneq %rcx, %rbx
jmp 0x3fd6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdx, %rdx
jne 0x3ff9
movzwl 0x10(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl 0xc(%rsi), %ecx
bswapl %ecx
leaq (%rax,%rcx), %rdx
addq $0x15, %rdx
addq %rsi, %rdx
movq 0xb0(%rdi), %r8
movq 0xb8(%rdi), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %r9b
orb %al, %r9b
movq %rdx, %rax
subq %r8, %rax
addq $0x14, %rax
xorl %r10d, %r10d
cmpq %rcx, %rax
movq %rdx, %rax
cmovaq %r10, %rax
testb %r9b, %r9b
cmovneq %r10, %rax
cmpq %r8, %rdx
cmovbq %r10, %rax
testq %rsi, %rsi
cmoveq %rsi, %rax
testb %r9b, %r9b
jne 0x407f
testq %rax, %rax
je 0x407f
cmpq %rax, %r8
ja 0x407f
movzwl 0x10(%rax), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movl 0xc(%rax), %esi
bswapl %esi
subq %r8, %rdx
addq %rsi, %rdx
addq %rax, %rdx
addq $0x15, %rdx
cmpq %rcx, %rdx
ja 0x407f
movq %rax, %rsi
jmp 0x3f96
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40c1
movq 0x18(%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x40c1
addq $0x28, %rbx
jmp 0x4136
testq %r14, %r14
je 0x40f5
cmpb $0x0, 0x10(%rbx)
je 0x40f5
movq 0x8(%rbx), %rax
decq %rax
cmpq %rax, 0x18(%rbx)
jne 0x40f5
movq (%rbx), %r15
leaq 0x28(%rbx), %rdi
callq 0x2bb4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3fdc
jmp 0x4101
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3ef8
movq %rax, 0x20(%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rbx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a58
addq $0x28, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a10
leaq 0x8(%rsp), %rdi
callq 0x29e8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x29e8
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4209
movq %r12, %rbp
subq %r14, %rbp
shrq %rbp
addq %r14, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x3ed2
testl %eax, %eax
js 0x41ee
movb $0x1, %al
je 0x41f8
movq %rbp, %r12
jmp 0x4201
incq %rbp
movb $0x1, %al
movq %rbp, %r14
jmp 0x4201
movq (%rsp), %rax
movq %rbp, (%rax)
xorl %eax, %eax
testb %al, %al
jne 0x41be
movb $0x1, %al
jmp 0x4256
cmpq %r14, %r12
jbe 0x424d
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3ed2
testl %eax, %eax
je 0x422b
setg %al
movzbl %al, %eax
shll $0x2, %eax
jmp 0x4237
movq (%rsp), %rax
movq %r14, (%rax)
movl $0x1, %eax
testl %eax, %eax
jne 0x4248
incq %r14
cmpq %r14, %r12
jne 0x420e
movq %r12, %r14
jmp 0x424d
cmpl $0x1, %eax
je 0x4205
movq (%rsp), %rax
movq %r14, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x43c2
movq 0x8(%r15), %rdi
xorl %r15d, %r15d
movl %ebp, %esi
xorl %eax, %eax
callq 0x20f0
testl %eax, %eax
js 0x43a5
movl %eax, %ebp
xorl %r12d, %r12d
movl %eax, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2280
movq %rax, %r15
testq %rax, %rax
cmovleq %r12, %r15
jle 0x439b
xorl %edi, %edi
movq %r15, %rsi
movl %r14d, %edx
movl $0x1, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x2260
cmpq $-0x1, %rax
je 0x439b
movq %rax, %r14
movl 0x14(%rbx), %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movl %ebp, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq %r14, (%rbx)
movb $0x1, %r15b
jmp 0x43a5
movl %ebp, %edi
callq 0x2290
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43e5
movq 0x8(%rbx), %rsi
callq 0x20c0
movl 0x10(%rbx), %edi
callq 0x2290
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x20f0
testl %eax, %eax
js 0x4427
movl %eax, %r14d
movl %eax, %edi
movq %rbx, %rsi
callq 0x21d0
movl %eax, %ebx
movl %r14d, %edi
callq 0x2290
testl %ebx, %ebx
sete %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movw $0x0, 0x30(%rsi)
movl $0x11, %edx
movq %r14, %rdi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x4571
cmpl $0x4553555a, (%rsp)     # imm = 0x4553555A
je 0x457b
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)
movl $0x21, %edx
movq %r14, %rdi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x45c6
cmpq $0x20, 0x8(%r14)
jg 0x45c6
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
jmp 0x45fb
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 0x4573
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movw $0x0, 0x30(%rdi)
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_O1/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 0xcb2(%rip), %rdi       # 0x53c6
leaq 0xcb6(%rip), %rsi       # 0x53d1
xorl %eax, %eax
callq 0x2030
movq 0x8(%rbx), %rdx
leaq 0xcac(%rip), %rdi       # 0x53d9
leaq 0xcb1(%rip), %rsi       # 0x53e5
xorl %eax, %eax
callq 0x2030
movq 0x10(%rbx), %rdi
leaq 0xcba(%rip), %r14       # 0x5400
movq %r14, %rdx
testq %rdi, %rdi
je 0x475d
leaq 0xa2c(%rip), %rsi       # 0x5181
callq 0x317c
movq %rax, %rdx
leaq 0xc89(%rip), %r15       # 0x53ed
leaq 0xc8d(%rip), %rsi       # 0x53f8
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0xc8f(%rip), %rax       # 0x540b
leaq 0xc8c(%rip), %rdx       # 0x540f
cmpb $0x0, 0x18(%rbx)
cmovneq %rax, %rdx
leaq 0xc72(%rip), %rsi       # 0x5404
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
movq 0x20(%rbx), %rdx
leaq 0xc32(%rip), %rdi       # 0x53d9
leaq 0xc64(%rip), %rsi       # 0x5412
xorl %eax, %eax
callq 0x2030
movq 0x28(%rbx), %rdi
movq %r14, %rdx
testq %rdi, %rdi
je 0x47d0
leaq 0x9b9(%rip), %rsi       # 0x5181
callq 0x317c
movq %rax, %rdx
leaq 0xc16(%rip), %rdi       # 0x53ed
leaq 0xc3f(%rip), %rsi       # 0x541d
xorl %eax, %eax
callq 0x2030
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x47fd
leaq 0x98c(%rip), %rsi       # 0x5181
callq 0x317c
movq %rax, %r14
leaq 0xbe9(%rip), %rdi       # 0x53ed
leaq 0xc1f(%rip), %rsi       # 0x542a
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %r8
movq %rsi, %rax
subq %r8, %rax
cmpq $0x8, %rax
je 0x13541f
cmpq $0x3, %rax
jne 0x135461
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x135453
cmpb $0x69, (%r8)
leaq 0x287ad4(%rip), %r9     # 0x3bcf06
leaq 0x287ac4(%rip), %r8     # 0x3bcefd
cmoveq %r9, %r8
movb (%r8), %r9b
cmpb (%rax), %r9b
jne 0x135461
incq %rax
movq %rax, (%rdi)
incq %r8
cmpq %rsi, %rax
jne 0x13543d
testb %cl, %cl
jne 0x135464
movsd 0x27cdc9(%rip), %xmm0   # 0x3b2228
jmp 0x13546c
xorl %eax, %eax
retq
movsd 0x27cdb4(%rip), %xmm0   # 0x3b2220
movsd %xmm0, (%rdx)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x446939(%rip), %r15    # 0x57be40
movq %rsp, %rbx
xorl %ecx, %ecx
xorl %r13d, %r13d
movq %rcx, 0x18(%rsp)
movb $0x1, %bpl
xorl %r12d, %r12d
leaq (%r15,%r12), %rdi
movsd 0x20(%r12,%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x1eac48
movzbl %bpl, %ebp
testb %al, %al
cmovel %r14d, %ebp
addq $0x28, %r12
cmpq $0xa780, %r12           # imm = 0xA780
jne 0x13551a
testb $0x1, %bpl
je 0x135565
cmpq $0x9, %r13
leaq 0x1(%r13), %rax
setae %cl
movq %rax, %r13
cmpq $0xa, %rax
jne 0x13550f
jmp 0x13556c
testb $0x1, 0x18(%rsp)
je 0x1355e8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1eb658
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0x1355dc
movb $0x1, %bl
xorl %r15d, %r15d
leaq 0x20(%rsp), %r14
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
xorl %r13d, %r13d
xorl %ebp, %ebp
movsd 0x20(%rdi,%r13), %xmm0
addq %r13, %rdi
movsd %xmm0, 0x20(%rsp)
movq %r14, %rsi
callq 0x1eac48
movzbl %bl, %ebx
testb %al, %al
cmovel %r15d, %ebx
incq %rbp
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x28, %r13
cmpq %rax, %rbp
jb 0x135599
jmp 0x1355de
movb $0x1, %bl
movq %rsp, %rdi
callq 0x1eb868
jmp 0x1355ea
xorl %ebx, %ebx
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
movq %rsp, %rdi
callq 0x1eb868
movq %rbx, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
subq %rcx, %rax
sete %bl
je 0x1ebc87
sarq $0x3, %rax
cmpq $0x1, %rax
movq %rax, %r8
adcq $0x0, %r8
cmpq %rsi, %rcx
je 0x1ebc73
movq (%rsi), %rdx
cmpq (%rcx), %rdx
je 0x1ebc73
addq $0x8, %rcx
movl $0x1, %r9d
subq %r8, %r9
xorl %r8d, %r8d
cmpq %r8, %r9
je 0x1ebc79
decq %r8
cmpq %rsi, %rcx
je 0x1ebc6a
leaq 0x8(%rcx), %r10
cmpq (%rcx), %rdx
movq %r10, %rcx
jne 0x1ebc51
negq %r8
cmpq %rax, %r8
setae %bl
testb %bl, %bl
jne 0x1ebc87
jmp 0x1ebc90
movl $0x1, %ecx
subq %r8, %rcx
cmpq %rax, %rcx
setae %bl
addq $0x8, %rdi
callq 0x1f216a
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movq 0x318(%rsi), %rdi
cmpq %rdi, 0x338(%rsi)
je 0x1ecfe1
movq %rdi, %rcx
subq 0x320(%rsi), %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x30c30c30c30c30c3, %rax # imm = 0xCF3CF3CF3CF3CF3D
imulq %rdx, %rax
cmpq $0x3, %rax
jb 0x1ed024
movq 0x330(%rsi), %rsi
testq %rcx, %rcx
jle 0x1ed000
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq %rdx
jmp 0x1ed016
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d48f2(%rip), %rsi    # 0x3c18e1
leaq 0x1d48f3(%rip), %rdx    # 0x3c18e9
movq %rbx, %rdi
callq 0x1eabb8
jmp 0x1ed03e
notq %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq %rdx
notq %rdx
imulq $-0x1f8, %rdx, %rdi     # imm = 0xFE08
addq (%rsi,%rdx,8), %rdi
addq %rcx, %rdi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x38(%rdi), %rsi
movq 0x40(%rdi), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1eda34
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f149a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1f1466
decq (%r15)
jne 0x1f1466
movq %r15, %rdi
callq 0x1f14de
movl $0x40, %esi
movq %r15, %rdi
callq 0x1200c0
movl $0x40, %edi
callq 0x1200f0
movq $0x1, (%rax)
movq %r14, 0x8(%rax)
leaq 0x30(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movb $0x0, 0x30(%rax)
movq %rcx, 0x38(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop