LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/./utils.h
// Function: void free4D<double>(double****, int, int, int)
void free4D(T**** ar, NDAT size1, NDAT size2, NDAT size3) {
    for(NDAT i=0; i<size1; i++) {
        for(NDAT j=0; j<size2; j++) {
            for(NDAT l=0; l<size3; l++)
                free(ar[i][j][l]);
            free(ar[i][j]);
        }
        free(ar[i]);
    }
    free(ar);
    //    &ar = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %rdi, %r14
testl %esi, %esi
jle 0x2ad76
movl %esi, %eax
movq %rax, 0x10(%rsp)
movl 0x8(%rsp), %r12d
movl 0xc(%rsp), %r13d
xorl %ebp, %ebp
cmpl $0x0, 0x8(%rsp)
jle 0x2ad63
xorl %r15d, %r15d
cmpl $0x0, 0xc(%rsp)
jle 0x2ad4e
xorl %ebx, %ebx
movq (%r14,%rbp,8), %rax
movq (%rax,%r15,8), %rax
movq (%rax,%rbx,8), %rdi
callq 0x42a0
incq %rbx
cmpq %rbx, %r13
jne 0x2ad35
movq (%r14,%rbp,8), %rax
movq (%rax,%r15,8), %rdi
callq 0x42a0
incq %r15
cmpq %r12, %r15
jne 0x2ad2c
movq (%r14,%rbp,8), %rdi
callq 0x42a0
incq %rbp
cmpq 0x10(%rsp), %rbp
jne 0x2ad22
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::HMMProblemSlicedA(param*)
HMMProblemSlicedA::HMMProblemSlicedA(struct param *param) {
    NPAR i;
    switch (param->structure) {
        case STRUCTURE_SKAslc: 
            for(i=0; i<3; i++) this->sizes[i] = param->nK;
            this->n_params = param->nK * 4 * param->nZ;
            break;
        default:
            fprintf(stderr,"Structure specified is not supported and should have been caught earlier\n");
            break;
    }
    init(param);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1094c
leaq 0x13e06(%rip), %rax     # 0x3ebc8
movq %rax, (%rbx)
cmpb $0xc, 0x3e(%r14)
jne 0x2ae03
movl 0x8c0(%r14), %ecx
movl %ecx, 0xc(%rbx)
movl %ecx, 0x10(%rbx)
movl %ecx, 0x14(%rbx)
movsbl 0x8c8(%r14), %ecx
imull 0x8c0(%r14), %ecx
shll $0x2, %ecx
movl %ecx, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x70(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x141ce(%rip), %rax     # 0x3efd8
movq (%rax), %rcx
leaq 0x95cd(%rip), %rdi      # 0x343e1
movl $0x49, %esi
movl $0x1, %edx
callq 0x4480
movq (%rbx), %rax
jmp 0x2adf2
movq %rax, %r14
movq %rbx, %rdi
callq 0x11218
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::destroy()
void HMMProblemSlicedA::destroy() {
    NPAR nS = this->p->nS, nZ = this->p->nZ;
	// destroy model data
    if(this->A  != NULL) {
        free4D<NUMBER>(this->A,  this->sizes[1], this->p->nZ, this->p->nS);
        this->A = NULL;
    }
    if(this->lbA!=NULL) {
        free3D<NUMBER>(this->lbA, nZ, nS);
        this->lbA = NULL;
    }
    if(this->ubA!=NULL) {
        free3D<NUMBER>(this->ubA, nZ, nS);
        this->ubA = NULL;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x88(%rdi), %rax
movq 0x90(%rdi), %rdi
movsbl 0x8b8(%rax), %ebp
movsbl 0x8c8(%rax), %r14d
testq %rdi, %rdi
je 0x2ba09
movl 0x10(%rbx), %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x2acf2
movq $0x0, 0x90(%rbx)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x2ba2a
movl %r14d, %esi
movl %ebp, %edx
callq 0xca4f
movq $0x0, 0x98(%rbx)
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x2ba4b
movl %r14d, %esi
movl %ebp, %edx
callq 0xca4f
movq $0x0, 0xa0(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::getA(int)
NUMBER*** HMMProblemSlicedA::getA(NCAT x) {
    if( x > (this->sizes[1]-1) ) {
        fprintf(stderr,"While accessing A, skill index %d exceeded last index of the data %d.\n", x, this->sizes[1]-1);
        exit(1);
    }
    return this->A[x];
}

// Assembly:
movq %rdi, %rax
movl 0x10(%rdi), %edi
cmpl %esi, %edi
jle 0x2ba99
movq 0x90(%rax), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
retq
pushq %rax
callq 0x541a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2bade
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 0x5468
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2bb90
movq 0x88(%rdi), %rax
cmpb $0xc, 0x3e(%rax)
jne 0x2bb99
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 0x7d58(%rip), %xmm0     # 0x338f0
retq
pushq %rax
callq 0x5493
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d77e
movq (%rsi), %rdi
leal (,%r14,8), %edx
xorl %esi, %esi
callq 0x4120
movl %r14d, %r12d
testb %bpl, %bpl
jle 0x2d7d9
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 0x2d7cc
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 0x2d7b5
incq %rbx
cmpq 0x10(%rsp), %rbx
movq %rbp, %r14
jne 0x2d7a1
testb %r14b, %r14b
jle 0x2d812
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 0x2d80a
movq (%r14,%r15,8), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4120
incq %r15
cmpq %r15, %r12
jne 0x2d7f7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d8a8
movq (%r12), %r12
movq (%r15), %r15
movzbl %bl, %eax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
cmpb $0x0, (%rsp)
jle 0x2d89e
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 0x2d87e
incq %rbp
cmpq 0x10(%rsp), %rbp
jne 0x2d876
cmpb $0x0, (%rsp)
jle 0x2d8e3
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 0x2d8cb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1094c
leaq 0xe17e(%rip), %rax      # 0x3ecc8
movq %rax, (%rbx)
movl 0x8c0(%r14), %eax
movl %eax, 0xc(%rbx)
movl %eax, 0x10(%rbx)
movl %eax, 0x14(%rbx)
movl 0x8c0(%r14), %eax
shll $0x2, %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30b90
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x11218
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3136f
movq 0x90(%rbx), %rcx
movslq 0x58(%rsi), %rax
cmpb $0x0, (%rcx,%rax)
je 0x31373
movq 0x890(%r12), %rcx
movslq 0x8(%rsi), %r13
movslq (%rcx,%r13,4), %r14
cmpq $0x1, %r14
je 0x31373
movl $0x8, %esi
movq %r14, %rdi
callq 0x4130
movq %rax, %r15
testl %r14d, %r14d
jle 0x31343
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 0x31328
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 0x31384
movslq 0x58(%rsi), %rax
movq 0x38(%rbx), %rcx
movq (%rcx,%rax,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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15d
movq %rdi, %rbx
movq 0x88(%rdi), %r13
cmpl $0x0, 0x9a0(%r13)
je 0x31477
movq 0x90(%rbx), %rcx
movslq 0x58(%rsi), %rax
cmpb $0x0, (%rcx,%rax)
je 0x3147b
movq 0x890(%r13), %rcx
movslq 0x8(%rsi), %rdx
movslq (%rcx,%rdx,4), %r14
cmpq $0x1, %r14
je 0x3147b
movq %rdx, (%rsp)
movl $0x8, %esi
movq %r14, %rdi
callq 0x4130
movq %rax, %r12
testl %r14d, %r14d
jle 0x3144b
movq 0x898(%r13), %rax
movq (%rsp), %rcx
movslq (%rax,%rcx,4), %rax
movq 0x40(%rbx), %rcx
movsbq %r15b, %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, (%r12,%rdi,8)
incq %rdi
cmpq %rdi, %r14
jne 0x3142b
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
jmp 0x31494
movslq 0x58(%rsi), %rax
movq 0x40(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movsbq %r15b, %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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31590
movl %edx, %r14d
movq %rdi, %rbx
movq 0x88(%rdi), %r13
cmpl $0x0, 0x9a0(%r13)
je 0x3159a
movq 0x90(%rbx), %rcx
movslq 0x58(%rsi), %rax
cmpb $0x0, (%rcx,%rax)
je 0x3159e
movq 0x890(%r13), %rcx
movslq 0x8(%rsi), %rdx
movslq (%rcx,%rdx,4), %r15
cmpq $0x1, %r15
je 0x3159e
movq %rdx, (%rsp)
movl $0x8, %esi
movq %r15, %rdi
callq 0x4130
movq %rax, %r12
testl %r15d, %r15d
jle 0x31564
movq 0x898(%r13), %rax
movq (%rsp), %rcx
movslq (%rax,%rcx,4), %rax
movq 0x48(%rbx), %rcx
movsbq %r14b, %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, %r15
jne 0x31544
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x8(%rax)
movsd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x42a0
movsd (%rsp), %xmm0
jmp 0x315b7
movsd 0x2358(%rip), %xmm0     # 0x338f0
jmp 0x315b7
movslq 0x58(%rsi), %rax
movq 0x48(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movsbq %r14b, %rcx
movq (%rax,%rcx,8), %rax
movzbl %bpl, %ecx
movsd (%rax,%rcx,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x142a2
movq 0x88(%rbx), %rax
cmpb $0xd, 0x3e(%rax)
jne 0x31c5e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
addsd (%r14), %xmm0
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 0x559a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5846(%rip), %r14      # 0x7fd0
leaq 0x2873(%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 0x284e(%rip), %rsi      # 0x500b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
testq %rbx, %rbx
je 0x27e7
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x2801
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2230
leaq 0x2805(%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 0x27d7(%rip), %rsi      # 0x500b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
testq %rbx, %rbx
je 0x285e
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x2878
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2230
leaq 0x27c9(%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 0x2760(%rip), %rsi      # 0x500b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
testq %rbx, %rbx
je 0x28d5
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x28ef
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2230
leaq 0x278e(%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 0x279b(%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 0x279e(%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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d0c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x2d01
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 0x2d01
cmpq %r12, %r15
movq %r12, %rdx
cmovbq %r15, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20a0
testl %eax, %eax
jne 0x2d01
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_O3/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 0x2d98
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x2d93
movq %rdi, %r14
movzwl 0x10(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %r15d
movq %rbx, %rdi
callq 0x2090
cmpq %r15, %rax
jne 0x2d91
addq $0x13, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2180
testl %eax, %eax
sete %al
jmp 0x2d93
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ffe
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 0x2160
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2130
jmp 0x3001
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_O3/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:
movl 0xc(%rdi), %eax
testl %eax, %eax
sete %cl
testb %cl, %sil
je 0x3024
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
testl %r14d, %r14d
je 0x3055
movq (%rbx), %rax
bswapq %rax
bswapl %r14d
shlq $0x20, %r14
addq %rax, %r14
callq 0x312e
cmpq %rax, %r14
jae 0x3052
xorl %eax, %eax
jmp 0x3086
movl 0xc(%rbx), %eax
leaq 0x13(%rbx), %rcx
movzwl 0x10(%rbx), %edx
rolw $0x8, %dx
movzwl %dx, %edx
bswapl %eax
addq %rbx, %rdx
addq $0x13, %rdx
addq %rax, %rdx
addq $0x2, %rdx
xorl %eax, %eax
xorb (%rcx), %al
incq %rcx
cmpq %rdx, %rcx
jb 0x3076
cmpb 0x12(%rbx), %al
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x30b5
movzwl 0x10(%r15), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq (%rax,%rbx), %r14
incq %r14
jmp 0x30b8
xorl %r14d, %r14d
movq (%r15), %rdi
bswapq %rdi
leaq 0x20bc(%rip), %rsi      # 0x5181
callq 0x3180
movl 0x8(%r15), %r9d
bswapl %r9d
leaq 0x208d(%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_O3/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 0x3107
addq %rdi, %rsi
xorl %eax, %eax
xorb (%rdi), %al
incq %rdi
cmpq %rsi, %rdi
jb 0x30fc
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31ba
movq %rsi, %rbx
movq %rsp, %rdi
callq 0x2100
testq %rax, %rax
je 0x31ba
leaq 0x4feb(%rip), %r14      # 0x8190
movl $0x14, %esi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2120
jmp 0x31bd
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42e8
leaq 0x50(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rbx)
callq 0x42e8
leaq 0x68(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
callq 0x42e8
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
subq $-0x80, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x42e8
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f28
movq %rsi, %rbx
cmpb $0x1, 0x98(%rdi)
jne 0x3f2a
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 0x30f2
xorl %ecx, %ecx
cmpb 0x12(%rbx), %al
cmovneq %rcx, %rbx
jmp 0x3f2a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f4d
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 0x3fd3
testq %rax, %rax
je 0x3fd3
cmpq %rax, %r8
ja 0x3fd3
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 0x3fd3
movq %rax, %rsi
jmp 0x3eea
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4018
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rax
cmpq %rsi, %rax
jne 0x4026
addq $0x28, %rbx
jmp 0x4084
movq 0x8(%rbx), %rsi
movq (%rbx), %rdi
callq 0x3e4c
jmp 0x404f
leaq -0x1(%rsi), %rcx
cmpq %rcx, %rax
jne 0x401c
cmpb $0x0, 0x10(%rbx)
je 0x401c
movq (%rbx), %r15
leaq 0x28(%rbx), %rdi
callq 0x2ba8
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3f30
movq %rax, 0x20(%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rbx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a4c
addq $0x28, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a04
leaq 0x8(%rsp), %rdi
callq 0x29dc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x29dc
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movq %rsi, %r14
movq %rdi, %r12
movq 0x40(%rsp), %rbx
leaq (%rsi,%rbx), %rax
cmpq %rdx, %rax
jae 0x4149
movq %r13, %rbp
subq %r14, %rbp
shrq %rbp
addq %r14, %rbp
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x3e26
testl %eax, %eax
js 0x413a
je 0x4176
movq %rbp, %r13
jmp 0x4140
incq %rbp
movq %rbp, %r14
leaq (%r14,%rbx), %rax
cmpq %r13, %rax
jb 0x4115
cmpq %r13, %r14
jae 0x4172
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3e26
testl %eax, %eax
jns 0x416b
incq %r14
cmpq %r14, %r13
jne 0x414e
movq %r13, %r14
testl %eax, %eax
sete %al
jmp 0x417b
xorl %eax, %eax
jmp 0x417b
movb $0x1, %al
movq %rbp, %r14
movq (%rsp), %rcx
movq %r14, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42e8
movq 0x8(%r15), %rdi
xorl %r15d, %r15d
movl %ebp, %esi
xorl %eax, %eax
callq 0x20f0
testl %eax, %eax
js 0x42c9
movl %eax, %ebp
movl %eax, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2280
testq %rax, %rax
jle 0x42bf
movq %rax, %r15
xorl %edi, %edi
movq %rax, %rsi
movl %r14d, %edx
movl $0x1, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x2260
cmpq $-0x1, %rax
je 0x42bf
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 0x42c9
movl %ebp, %edi
callq 0x2290
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_O3/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 0x430b
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_O3/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 0x4495
cmpl $0x4553555a, (%rsp)     # imm = 0x4553555A
je 0x449f
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 0x44ea
cmpq $0x20, 0x8(%r14)
jg 0x44ea
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
jmp 0x451f
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 0x4497
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdb6(%rip), %rdi       # 0x53c6
leaq 0xdba(%rip), %rsi       # 0x53d1
xorl %eax, %eax
callq 0x2030
movq 0x8(%rbx), %rdx
leaq 0xdb0(%rip), %rdi       # 0x53d9
leaq 0xdb5(%rip), %rsi       # 0x53e5
xorl %eax, %eax
callq 0x2030
movq 0x10(%rbx), %rdi
leaq 0xdbe(%rip), %r14       # 0x5400
movq %r14, %rdx
testq %rdi, %rdi
je 0x4659
leaq 0xb30(%rip), %rsi       # 0x5181
callq 0x3180
movq %rax, %rdx
leaq 0xd8d(%rip), %r15       # 0x53ed
leaq 0xd91(%rip), %rsi       # 0x53f8
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0xd93(%rip), %rax       # 0x540b
leaq 0xd90(%rip), %rdx       # 0x540f
cmpb $0x0, 0x18(%rbx)
cmovneq %rax, %rdx
leaq 0xd76(%rip), %rsi       # 0x5404
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
movq 0x20(%rbx), %rdx
leaq 0xd36(%rip), %rdi       # 0x53d9
leaq 0xd68(%rip), %rsi       # 0x5412
xorl %eax, %eax
callq 0x2030
movq 0x28(%rbx), %rdi
movq %r14, %rdx
testq %rdi, %rdi
je 0x46cc
leaq 0xabd(%rip), %rsi       # 0x5181
callq 0x3180
movq %rax, %rdx
leaq 0xd1a(%rip), %rdi       # 0x53ed
leaq 0xd43(%rip), %rsi       # 0x541d
xorl %eax, %eax
callq 0x2030
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x46f9
leaq 0xa90(%rip), %rsi       # 0x5181
callq 0x3180
movq %rax, %r14
leaq 0xced(%rip), %rdi       # 0x53ed
leaq 0xd23(%rip), %rsi       # 0x542a
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq %rsi, %r8
subq %rax, %r8
cmpq $0x8, %r8
je 0x133ee6
cmpq $0x3, %r8
jne 0x133f24
cmpq %rsi, %rax
je 0x133f16
cmpb $0x69, (%rax)
leaq 0x260069(%rip), %r9     # 0x393f5e
leaq 0x260059(%rip), %r8     # 0x393f55
cmoveq %r9, %r8
movb (%r8), %r9b
cmpb (%rax), %r9b
jne 0x133f24
incq %rax
movq %rax, (%rdi)
incq %r8
cmpq %rsi, %rax
jne 0x133f00
testb %cl, %cl
jne 0x133f27
movsd 0x2552fe(%rip), %xmm0   # 0x389220
jmp 0x133f2f
xorl %eax, %eax
retq
movsd 0x2552e9(%rip), %xmm0   # 0x389218
movsd %xmm0, (%rdx)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40de7b(%rip), %r15    # 0x541e40
leaq 0x8(%rsp), %rbx
movb $0x1, %bpl
xorl %r12d, %r12d
leaq (%r15,%r12), %rdi
movsd 0x20(%r12,%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rsi
callq 0x1e47d5
andb %al, %bpl
addq $0x28, %r12
cmpq $0xa780, %r12           # imm = 0xA780
jne 0x133fd0
testb %bpl, %bpl
je 0x134071
incq %r14
cmpq $0xa, %r14
jne 0x133fca
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1e51b6
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0x134075
movb $0x1, %bl
xorl %r15d, %r15d
leaq 0x20(%rsp), %r14
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
xorl %r13d, %r13d
movsd 0x20(%rdi,%r15), %xmm0
addq %r15, %rdi
movsd %xmm0, 0x20(%rsp)
movq %r14, %rsi
callq 0x1e47d5
andb %al, %bl
incq %r13
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x28, %r15
cmpq %rax, %r13
jb 0x134034
jmp 0x134077
xorl %ebx, %ebx
jmp 0x134081
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x1e53c6
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 0x1e53c6
movq %rbx, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0x1e57a8
sarq $0x3, %rax
cmpq $0x1, %rax
movq %rax, %r8
adcq $0x0, %r8
xorl %ebx, %ebx
cmpq %rsi, %rcx
je 0x1e57c3
movq (%rsi), %rdx
cmpq (%rcx), %rdx
je 0x1e57c3
addq $0x8, %rcx
movl $0x1, %r9d
subq %r8, %r9
xorl %r8d, %r8d
cmpq %r8, %r9
je 0x1e57ac
decq %r8
cmpq %rsi, %rcx
je 0x1e579d
leaq 0x8(%rcx), %r10
cmpq (%rcx), %rdx
movq %r10, %rcx
jne 0x1e5784
negq %r8
cmpq %rax, %r8
setae %bl
jmp 0x1e57c3
movb $0x1, %bl
jmp 0x1e57ba
movl $0x1, %ecx
subq %r8, %rcx
cmpq %rax, %rcx
setae %bl
addq $0x8, %rdi
callq 0x1eb0e8
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r8
cmpq %r8, 0x338(%rsi)
je 0x1e6ce3
movq 0x330(%rsi), %rdi
movq %r8, %rcx
subq 0x320(%rsi), %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x30c30c30c30c30c3, %rax # imm = 0xCF3CF3CF3CF3CF3D
imulq %rdx, %rax
cmpq $-0xa7, %rcx
jl 0x1e6d02
cmpq $0x3, %rax
jb 0x1e6d26
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq %rdx
jmp 0x1e6d18
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1b1c1a(%rip), %rsi    # 0x39890b
leaq 0x1b1c1b(%rip), %rdx    # 0x398913
movq %rbx, %rdi
callq 0x1e4740
jmp 0x1e6d40
notq %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq %rdx
notq %rdx
imulq $-0x1f8, %rdx, %r8      # imm = 0xFE08
addq (%rdi,%rdx,8), %r8
addq %rcx, %r8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x38(%r8), %rsi
movq 0x40(%r8), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1e7738
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ea45a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1ea426
decq (%r15)
jne 0x1ea426
movq %r15, %rdi
callq 0x1ea4a4
movl $0x40, %esi
movq %r15, %rdi
callq 0x11e0c0
movl $0x40, %edi
callq 0x11e0f0
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