LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::init3Params(double*&, double***&, double**&, signed char, signed char, signed char)
void HMMProblemSlicedA::init3Params(NUMBER* &PI, NUMBER*** &A, NUMBER** &B, NPAR nZ, NPAR nS, NPAR nO) {  // sliced
    PI = init1D<NUMBER>((NDAT)nS);
    A  = init3D<NUMBER>((NDAT)nZ, (NDAT)nS, (NDAT)nS);
    B  = init2D<NUMBER>((NDAT)nS, (NDAT)nO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r8d, -0x44(%rbp)
movq %rcx, %rax
movl -0x44(%rbp), %ecx
movq %rax, -0x40(%rbp)
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movb 0x10(%rbp), %r9b
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
movb %al, -0x22(%rbp)
movsbl -0x22(%rbp), %edi
callq 0xc410
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x21(%rbp), %edi
movsbl -0x22(%rbp), %esi
movsbl -0x22(%rbp), %edx
callq 0x11310
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x22(%rbp), %edi
movsbl 0x10(%rbp), %esi
callq 0xf580
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x88(%rax), %rcx
movb 0x8b8(%rcx), %cl
movb %cl, -0x9(%rbp)
movq 0x88(%rax), %rcx
movb 0x8c8(%rcx), %cl
movb %cl, -0xa(%rbp)
cmpq $0x0, 0x90(%rax)
je 0x4357c
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rdi
movl 0x10(%rax), %esi
movq 0x88(%rax), %rcx
movsbl 0x8c8(%rcx), %edx
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %ecx
callq 0x42330
movq -0x18(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x435b1
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rdi
movsbl -0xa(%rbp), %esi
movsbl -0x9(%rbp), %edx
callq 0x11290
movq -0x18(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x435e6
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rdi
movsbl -0xa(%rbp), %esi
movsbl -0x9(%rbp), %edx
callq 0x11290
movq -0x18(%rbp), %rax
movq $0x0, 0xa0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x43713
movq -0x18(%rbp), %rax
movq 0x178e9(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movl 0x10(%rax), %ecx
subl $0x1, %ecx
leaq 0xcdd6(%rip), %rsi      # 0x504d8
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x437fe
movq -0x18(%rbp), %rax
movq 0x17804(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movsbl -0xd(%rbp), %ecx
movl 0x10(%rax), %r8d
subl $0x1, %r8d
leaq 0xd4f3(%rip), %rsi      # 0x50ce0
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0xd(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jge 0x4398a
movsd 0xc085(%rip), %xmm0     # 0x4fa08
movsd %xmm0, -0x8(%rbp)
jmp 0x439ee
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rax
movb 0x3e(%rax), %al
subb $0xc, %al
jne 0x439cc
jmp 0x4399e
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x19(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x1a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x439ee
movq 0x17605(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0xcb89(%rip), %rsi      # 0x50566
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb 0x28(%rbp), %al
movb 0x20(%rbp), %al
movb 0x18(%rbp), %al
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movsbl 0x20(%rbp), %edx
callq 0xc440
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movsbl 0x18(%rbp), %edx
movsbl 0x20(%rbp), %ecx
movsbl 0x20(%rbp), %r8d
callq 0x11450
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq 0x10(%rbp), %rax
movq (%rax), %rsi
movsbl 0x20(%rbp), %edx
movsbl 0x28(%rbp), %ecx
callq 0xf650
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x194e0
movq -0x30(%rbp), %rax
leaq 0xf718(%rip), %rcx      # 0x5ac90
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3, %eax
jge 0x4b5ad
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c0(%rcx), %edx
movsbq -0x11(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,4)
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x4b583
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
shll $0x2, %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x4b5d0
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1a300
movq -0x20(%rbp), %rdi
callq 0x5540
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemComp.cpp
// Function: HMMProblemComp::destroy()
void HMMProblemComp::destroy() {
	// destroy additional model data
	free(this->is_multi);
	// delete parameter union
	free(this->pu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x90(%rax), %rdi
callq 0x5380
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x5380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x88(%rax), %rax
cmpl $0x0, 0x9a0(%rax)
je 0x4c1a1
movq -0x40(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x4c1c9
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x11(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x4c2d1
movq -0x40(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x890(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x4c217
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x11(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x4c2cf
movslq -0x24(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4c2a4
movq -0x40(%rbp), %rax
movq 0x88(%rax), %rcx
movq 0x888(%rcx), %rcx
movq 0x88(%rax), %rdx
movq 0x898(%rdx), %rdx
movq -0x10(%rbp), %rsi
movslq 0x8(%rsi), %rsi
movl (%rdx,%rsi,4), %edx
addl -0x38(%rbp), %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x34(%rbp)
movq 0x38(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x11(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4c237
movq -0x40(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
movq (%rdi), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0x8(%rax)
movsd %xmm0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5380
jmp 0x4c2d1
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0xc410
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1e830
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x3e(%rax), %eax
cmpl $0xd, %eax
jne 0x4d0f0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x4d112
movq 0xdee1(%rip), %rax      # 0x5afd8
movq (%rax), %rdi
leaq 0x3465(%rip), %rsi      # 0x50566
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x5380
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movl $0x1, 0x9a0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemComp.cpp
// Function: HMMProblemComp::toFile(char const*)
void HMMProblemComp::toFile(const char *filename) {
	switch(this->p->structure)
	{
		case STRUCTURE_COMP:
			toFileSkill(filename);
			break;
			//        case STRUCTURE_GROUP:
			//            toFileGroup(filename);
			//            break;
		default:
			fprintf(stderr,"Solver specified is not supported.\n");
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x88(%rax), %rax
movb 0x3e(%rax), %al
subb $0xd, %al
jne 0x4df07
jmp 0x4def8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4df30
jmp 0x4df1f
movq 0xd0ca(%rip), %rax      # 0x5afd8
movq (%rax), %rdi
leaq 0x264e(%rip), %rsi      # 0x50566
movb $0x0, %al
callq 0x5440
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/main/db_file.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 3){
		printUsage(argv[0]);
		return 10;
	}

	// =======================

	const auto op		= argv[1];
	const auto filename	= argv[2];

	size_t const keyCount	= (size_t) argc - 3;
	char **keys		= & argv[3];

	// =======================

	using DiskTable = hm3::DiskTable;

	DiskTable list;
	list.open(filename);
	list.printHeader();

	// =======================

	switch(op[0]){
	case 'r':	return op_filesearch(list, keyCount, keys);
	case 'l':	return op_list(list, keyCount, keys);
	}

	printUsage(argv[0]);
	return 1;
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movl $0x0, 0x144(%rsp)
movl %edi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
cmpl $0x3, 0x140(%rsp)
jg 0x253b
movq 0x138(%rsp), %rax
movq (%rax), %rdi
callq 0x26d0
movl $0xa, 0x144(%rsp)
jmp 0x26aa
movq 0x138(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x130(%rsp)
movq 0x138(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x128(%rsp)
movslq 0x140(%rsp), %rax
addq $-0x3, %rax
movq %rax, 0x120(%rsp)
movq 0x138(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x118(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x2ae0
movq 0x128(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2c10
jmp 0x25ae
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x55a0
jmp 0x25bf
leaq 0x38(%rsp), %rdi
callq 0x2c60
jmp 0x25cb
movq 0x130(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x14(%rsp)
subl $0x6c, %eax
je 0x2641
jmp 0x25e1
movl 0x14(%rsp), %eax
subl $0x72, %eax
je 0x260c
jmp 0x267b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2c70
jmp 0x26b9
movq 0x120(%rsp), %rsi
movq 0x118(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x27f0
movl %eax, 0x10(%rsp)
jmp 0x262c
movl 0x10(%rsp), %eax
movl %eax, 0x144(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x26a0
movq 0x120(%rsp), %rsi
movq 0x118(%rsp), %rdx
leaq 0x38(%rsp), %rdi
movl $0xa, %ecx
callq 0x28b0
movl %eax, 0xc(%rsp)
jmp 0x2666
movl 0xc(%rsp), %eax
movl %eax, 0x144(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x26a0
movq 0x138(%rsp), %rax
movq (%rax), %rdi
callq 0x26d0
jmp 0x268d
movl $0x1, 0x144(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2c70
movl 0x144(%rsp), %eax
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x20(%rsp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq 0xa8f4(%rip), %rdi      # 0xcfd0
leaq 0x6921(%rip), %rsi      # 0x9004
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x690c(%rip), %rsi      # 0x900b
callq 0x21b0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x21b0
movq %rax, %rdi
leaq 0x68f3(%rip), %rsi      # 0x900d
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x68d5(%rip), %rsi      # 0x900b
callq 0x21b0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x21b0
movq %rax, %rdi
leaq 0x68f7(%rip), %rsi      # 0x9048
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x689e(%rip), %rsi      # 0x900b
callq 0x21b0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x21b0
movq %rax, %rdi
leaq 0x68fc(%rip), %rsi      # 0x9084
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x691c(%rip), %rsi      # 0x90c0
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x692f(%rip), %rsi      # 0x90ef
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/main/db_helper_impl.h
// Function: int op_filesearch<hm3::DiskTable>(hm3::DiskTable const&, unsigned long, char**)
static int op_filesearch(const LIST &list, size_t const keyCount, char **keys){
	for(size_t i = 0; i < keyCount; ++i){
		const auto key = keys[i];

		const auto &pair = list.get(key);

		if ( pair )
			pair.print();
	}

	return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x289d
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2c10
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x62e0
leaq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2e40
testb $0x1, %al
jne 0x2876
jmp 0x2880
movq 0x28(%rsp), %rdi
callq 0x37d0
leaq 0x20(%rsp), %rdi
callq 0x3190
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x280c
xorl %eax, %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/main/db_helper_impl.h
// Function: void op_list<hm3::DiskTable>(hm3::DiskTable const&, StringRef const&, unsigned long)
static void op_list(const LIST &list, const StringRef &key, size_t const count){
	const auto bit = key == '-' ? list.begin() : list.lowerBound(key);
	const auto eit = list.end();

	size_t c = 0;
	for(auto it = bit; it != eit; ++it){
		it->print();

		if (++c >= count)
			break;
	}
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xc8(%rsp), %rdi
movl $0x2d, %esi
callq 0x2f30
testb $0x1, %al
jne 0x2967
jmp 0x297e
movq 0xd0(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x2f80
jmp 0x299b
movq 0xd0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
leaq 0x90(%rsp), %rdi
callq 0x6360
movq 0xd0(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x2fd0
jmp 0x29af
movq $0x0, 0x48(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x3020
jmp 0x29cc
jmp 0x29ce
leaq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x3070
movb %al, 0x13(%rsp)
jmp 0x29e3
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x2a3a
jmp 0x29ed
movl $0x2, 0x14(%rsp)
jmp 0x2a8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x2abd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x2ab3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x30f0
jmp 0x2ab3
leaq 0x18(%rsp), %rdi
callq 0x30a0
movq %rax, 0x8(%rsp)
jmp 0x2a4b
movq 0x8(%rsp), %rdi
callq 0x37d0
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
cmpq 0xc0(%rsp), %rax
jb 0x2a77
movl $0x2, 0x14(%rsp)
jmp 0x2a8a
jmp 0x2a79
leaq 0x18(%rsp), %rdi
callq 0x30d0
jmp 0x2a85
jmp 0x29ce
leaq 0x18(%rsp), %rdi
callq 0x30f0
leaq 0x60(%rsp), %rdi
callq 0x30f0
leaq 0x90(%rsp), %rdi
callq 0x30f0
addq $0xd8, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x30f0
leaq 0x90(%rsp), %rdi
callq 0x30f0
movq 0x58(%rsp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nop
// File: nmmmnu[P]HM3/hm3/pair.cc
// Function: hm3::Pair::cmpTime(hm3::Pair const&) const
int Pair::cmpTime(const Pair &pair) const noexcept{
	// Compare time
	auto const c1 = getCreated();
	auto const c2 = pair.getCreated();

	if (c1 == c2)
		return 0;

	return c1 > c2 ? +1 : -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3490
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3490
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jne 0x36a0
movl $0x0, 0x24(%rsp)
jmp 0x36bd
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpq %rsi, %rdx
cmoval %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/pair.cc
// Function: hm3::Pair::print() const
void Pair::print() const noexcept{
	if (pimpl == nullptr){
		printf("--- Pair is empty ---\n");
		return;
	}

	pimpl->print();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3ec0
testb $0x1, %al
jne 0x37f2
jmp 0x3804
leaq 0x591d(%rip), %rdi      # 0x9116
xorl %eax, %eax
callq 0x2030
jmp 0x3802
jmp 0x3816
movq 0x8(%rsp), %rdi
callq 0x3ae0
movq %rax, %rdi
callq 0x4cf0
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x2d70
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/pair.cc
// Function: hm3::Pair::fwrite(std::ostream&) const
bool Pair::fwrite(std::ostream & os) const{
	if (pimpl == nullptr)
		return false;

	os.write((const char *) pimpl.get(), (std::streamsize) getBytes() );

	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3ec0
testb $0x1, %al
jne 0x3857
jmp 0x385e
movb $0x0, 0x37(%rsp)
jmp 0x3898
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2ea0
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3780
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2230
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/pairblob.h
// Function: hm3::PairBlob::getVal() const
const char *getVal() const noexcept{
		// vallen is 0 no matter of endianness
		if (vallen == 0)
			return nullptr;

		return & buffer[ getKeyLen() + 1 ];
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0xc(%rax)
jne 0x3b84
movq $0x0, 0x20(%rsp)
jmp 0x3bae
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x13, %rax
movq %rax, 0x8(%rsp)
callq 0x3b00
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x1, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4510
movb %al, 0x37(%rsp)
jmp 0x3cd8
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x3ce2
jmp 0x3ced
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x24(%rsp)
jmp 0x3d3a
movq 0x28(%rsp), %rdi
callq 0x3af0
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x3b00
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x20a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
callq 0x4370
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x2d70
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4510
testb $0x1, %al
jne 0x3df8
jmp 0x3e00
movb $0x1, %al
movb %al, 0x1f(%rsp)
jmp 0x3e4b
movq 0x20(%rsp), %rdi
callq 0x3af0
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
callq 0x3b00
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x20a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0x4540
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/include/stringref.h
// Function: StringRef::compare(char const*, unsigned long, char const*, unsigned long)
inline int StringRef::compare(const char *s1, size_t const size1, const char *s2, size_t const size2) noexcept{
	if (COMPARE_MICRO_OPTIMIZATIONS){
		if (s1 == s2 && size1 == size2)
			return 0;
	}

	return compare__(s1, size1, s2, size2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x43a8
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
jne 0x43a8
movl $0x0, 0x24(%rsp)
jmp 0x43c4
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq 0x43d0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: nmmmnu[P]HM3/include/stringref.h
// Function: StringRef::compare__(char const*, unsigned long, char const*, unsigned long)
inline int StringRef::compare__(const char *s1, size_t const size1, const char *s2, size_t const size2) noexcept{
	// First idea was lazy based on LLVM::StringRef
	// http://llvm.org/docs/doxygen/html/StringRef_8h_source.html

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

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x44a0
movq %rax, 0x18(%rsp)
jmp 0x4412
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
callq 0x4470
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x443e
movl 0x2c(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x445b
movq 0x40(%rsp), %rax
subq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x44e0
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
movq %rax, %rdi
callq 0x2d70
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x4bbf
movq 0x8(%rsp), %rdi
callq 0x4e70
jmp 0x4c23
movq 0x28(%rsp), %rdi
callq 0x3e80
movq %rax, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x20(%rsp), %rsi
movl $0x14, %edi
callq 0x4ea0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4e00
movq 0x8(%rsp), %rdi
callq 0x2ea0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2170
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x4c21
movq 0x8(%rsp), %rdi
callq 0x39d0
jmp 0x4c23
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x27(%rsp)
je 0x4c65
movq 0x18(%rsp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x4c65
movb $0x0, 0x37(%rsp)
jmp 0x4cd6
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x4cb0
movq 0x18(%rsp), %rdi
callq 0x3bf0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %edi
callq 0x4b20
movl %eax, 0x14(%rsp)
jmp 0x4c95
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0x4ec0
testb $0x1, %al
jne 0x4ca9
jmp 0x4cb0
movb $0x0, 0x37(%rsp)
jmp 0x4cd6
movq 0x18(%rsp), %rdi
callq 0x4e30
movq 0x18(%rsp), %rcx
movzbl %al, %eax
movzbl 0x12(%rcx), %ecx
cmpl %ecx, %eax
je 0x4cd1
movb $0x0, 0x37(%rsp)
jmp 0x4cd6
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x2d70
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x84a6(%rip), %rax      # 0xd1b0
movq %rax, (%rsp)
callq 0x3af0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x3b60
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3bf0
movq %rax, %rdi
leaq 0x444a(%rip), %rsi      # 0x9185
callq 0x5240
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rsp)
movl 0x8(%rax), %edi
callq 0x4b20
movl %eax, 0x2c(%rsp)
jmp 0x4d5b
movl 0x2c(%rsp), %r9d
movq 0x20(%rsp), %r8
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
xorl %eax, %eax
movl $0x14, %ecx
callq 0x2030
jmp 0x4d81
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x2d70
nop
// File: nmmmnu[P]HM3/common/myhash_impl.h
// Function: myhash::impl::MyHashBase<myhash::impl::NMEA0183>::operator()(char const*, unsigned long) const
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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
addq 0x20(%rsp), %rcx
cmpq %rcx, %rax
jae 0x4fa7
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
leaq 0x1f(%rsp), %rsi
movsbl (%rax), %edx
callq 0x50d0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4f6c
movb 0x1f(%rsp), %al
addq $0x38, %rsp
retq
// File: 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:
subq $0x68, %rsp
callq 0x2040
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x52d0
movq %rax, 0x30(%rsp)
jmp 0x518f
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x52f0
movq %rax, 0x28(%rsp)
jmp 0x51aa
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x5360
movq %rax, 0x20(%rsp)
jmp 0x51ca
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5330
movq %rax, 0x18(%rsp)
jmp 0x51e5
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5320
movq %rax, 0x10(%rsp)
jmp 0x5200
movq 0x10(%rsp), %rax
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x53d0
movq %rax, 0x8(%rsp)
jmp 0x521a
movq 0x8(%rsp), %rax
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %edi
movl 0x38(%rsp), %esi
callq 0x4f10
addq $0x68, %rsp
retq
movq %rax, %rdi
callq 0x2d70
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x53e0
movl %eax, %eax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5272
movq $0x0, 0x20(%rsp)
jmp 0x52b8
leaq 0x8(%rsp), %rdi
callq 0x2140
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x5292
movq $0x0, 0x20(%rsp)
jmp 0x52b8
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x7f3e(%rip), %rdi      # 0xd1e0
movl $0x14, %esi
callq 0x2160
leaq 0x7f2d(%rip), %rax      # 0xd1e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
addq $0x38, %rdi
addq $0xa0, %rsi
callq 0x7290
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x50, %rdi
addq $0xb0, %rsi
callq 0x7290
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x68, %rdi
addq $0xc0, %rsi
callq 0x7290
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x80, %rdi
addq $0xd0, %rsi
callq 0x7290
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::getAtFromDisk_(unsigned long) const
const PairBlob *DiskTable::getAtFromDisk_(size_type const index) const{
	const uint64_t *ptrs_be = blobIndx_.as<const uint64_t>(0, getCount());

	if (!ptrs_be)
		return nullptr;

	const uint64_t ptr_be = ptrs_be[index];

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

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

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

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

	return nullptr;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
addq $0xa0, %rax
movq %rax, 0x20(%rsp)
callq 0x3120
movq 0x20(%rsp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0x76d0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x64b5
movq $0x0, 0x60(%rsp)
jmp 0x656f
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5f80
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0xb0, %rdi
movq 0x38(%rsp), %rsi
movl $0x1, %edx
callq 0x7720
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rsp)
addq $0xb0, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3e80
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x7750
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x6566
testb $0x1, 0x2f(%rsp)
jne 0x6566
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x6580
movq %rax, 0x60(%rsp)
jmp 0x656f
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x65ab
movq $0x0, 0x20(%rsp)
jmp 0x65ef
movq 0x8(%rsp), %rax
testb $0x1, 0x98(%rax)
jne 0x65c5
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x65ef
movq 0x10(%rsp), %rdi
callq 0x76a0
cmpb $0x0, %al
je 0x65de
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x65e6
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x65e6
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x6634
movq 0x40(%rsp), %rdi
callq 0x3e80
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0xb0, %rdi
movq 0x30(%rsp), %rsi
addq 0x38(%rsp), %rsi
movl $0x1, %edx
callq 0x77c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rsp)
addq $0xb0, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3e80
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x77f0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x66d2
testb $0x1, 0x27(%rsp)
jne 0x66d2
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x6580
movq %rax, 0x50(%rsp)
jmp 0x66db
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rax)
je 0x678c
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rax
cmpq 0x8(%rcx), %rax
jne 0x678c
movq 0x20(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x50(%rsp)
jmp 0x6879
movq 0x20(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x67f1
movq 0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x67f1
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rax
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x67f1
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rdi), %rax
movq %rax, 0x18(%rsp)
addq $0x28, %rdi
callq 0x3780
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x6600
movq %rax, 0x40(%rsp)
jmp 0x6807
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x6460
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rax), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3290
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x28, %rdi
callq 0x31d0
jmp 0x6845
leaq 0x38(%rsp), %rdi
callq 0x3190
movq 0x20(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x50(%rsp)
jmp 0x6879
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3190
jmp 0x6883
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x22c0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x30(%rsp), %rax
addq 0x50(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x7504
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
subq 0x30(%rsp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x7c70
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x74d6
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x74ff
cmpl $0x0, 0x4(%rsp)
jle 0x74e9
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x74fd
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x47(%rsp)
jmp 0x7574
jmp 0x74ff
jmp 0x7477
jmp 0x7506
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x7562
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x7c70
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jne 0x7548
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x47(%rsp)
jmp 0x7574
cmpl $0x0, (%rsp)
jle 0x7550
jmp 0x7562
jmp 0x7552
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x7506
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: nmmmnu[P]HM3/hm3/disktable.cc
// Function: hm3::DiskTable::search_(StringRef const&, unsigned long&) const
inline bool DiskTable::search_(const StringRef &key, size_type &result) const{
	if (mmapTree_ && mmapKeys_){
		log__("btree");
		return btreeSearch_(key, result);
	}else{
		log__("binary");
		return binarySearch_(key, result);
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x68, %rdi
callq 0x7270
testb $0x1, %al
jne 0x75ab
jmp 0x75e8
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x7270
testb $0x1, %al
jne 0x75c1
jmp 0x75e8
leaq 0x1cd2(%rip), %rdi      # 0x929a
callq 0x5f50
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x5930
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x760d
leaq 0x1cb1(%rip), %rdi      # 0x92a0
callq 0x5f50
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x7320
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/include/blobref.h
// Function: BlobRef::safeAccessMemory(void const*, unsigned long) const
const void *safeAccessMemory(const void *ptr, size_t const size) const noexcept{
		const char *ptrc = (const char *) ptr;

		if (empty() || size == 0 || ptrc == nullptr || ptrc < mem_)
			return nullptr;

		/* long int */ auto const pos = ptrc - mem_;

		return safeAccessMemory( (size_t) pos, size);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x7bb0
testb $0x1, %al
jne 0x783d
cmpq $0x0, 0x18(%rsp)
je 0x783d
cmpq $0x0, 0x10(%rsp)
je 0x783d
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq (%rcx), %rax
jae 0x7848
movq $0x0, 0x30(%rsp)
jmp 0x7870
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rdi), %rcx
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x7750
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)