LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: projsimplex(double*, signed char)
void projsimplex(NUMBER* y, NPAR size) {
    
	bool bget = false;
	NUMBER *s = init1D<NUMBER>((NDAT)size);
	cpy1D<NUMBER>(y, s, (NDAT)size);
	
	qsortNumberRev(s, size);
	NUMBER tmpsum = 0, tmax = 0;
    
	for(NPAR i=0; i<(size-1); i++) {
		tmpsum = tmpsum + s[i];
		tmax = (tmpsum - 1)/(i+1);
		if(tmax >= s[i+1]) {
			bget = true;
			break;
		}
	}
	if(!bget) tmax = (tmpsum + s[size-1] -1)/size;
	free(s);
    
	for(NPAR i=0; i<size; i++)
		y[i] = ((y[i]-tmax)<0)?0:(y[i]-tmax);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x4130
movq %rax, %r14
leaq (,%r15,8), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41c0
leaq -0xa8(%rip), %rcx       # 0x64a1
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4470
decl %r15d
xorpd %xmm0, %xmm0
cmpb $0x2, %bpl
setge %al
jl 0x65c3
addsd (%r14), %xmm0
movsd 0x2e372(%rip), %xmm3    # 0x348e8
addsd %xmm0, %xmm3
ucomisd 0x8(%r14), %xmm3
jae 0x65c7
movb $0x1, %cl
movsd 0x2e35c(%rip), %xmm1    # 0x348e8
movsbl %cl, %ecx
cmpl %ecx, %r15d
setg %al
jle 0x65c7
movslq %ecx, %rdx
addsd (%r14,%rdx,8), %xmm0
movapd %xmm0, %xmm3
addsd %xmm1, %xmm3
leal 0x1(%rcx), %esi
xorps %xmm2, %xmm2
cvtsi2sd %esi, %xmm2
divsd %xmm2, %xmm3
incb %cl
ucomisd 0x8(%r14,%rdx,8), %xmm3
jb 0x658c
jmp 0x65c7
xorpd %xmm3, %xmm3
testb %al, %al
jne 0x65ef
movslq %r15d, %rax
addsd (%r14,%rax,8), %xmm0
addsd 0x2e30c(%rip), %xmm0    # 0x348e8
movsbl %bpl, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movapd %xmm0, %xmm3
movsd %xmm3, (%rsp)
movq %r14, %rdi
callq 0x42a0
movsd (%rsp), %xmm2
testb %bpl, %bpl
jle 0x662a
movzbl %bpl, %eax
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
subsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x660c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: issimplex(double*, signed char)
bool issimplex(NUMBER* ar, NPAR size) {
	NUMBER sum = 1;
	for(NPAR i=0; i<size; i++) {
		sum -= ar[i];
		if( ar[i] < 0 || ar[i] > 1)
			return false;
	}
//    for(NPAR i=0; i<size && fabs(sum)<SAFETY && fabs(sum)>0; i++) {
//        if( (ar[i]+sum) >=0 ) {
//            ar[i]+=sum;
//            break;
//        }
//        if( (ar[i]+sum) <=1 ) {
//            ar[i]+=sum;
//            break;
//        }
//    }
	return fabs(sum)<SAFETY;
}

// Assembly:
testb %sil, %sil
setle %cl
jle 0x669b
movsd (%rdi), %xmm2
movsd 0x2e2a7(%rip), %xmm1    # 0x348f0
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
ja 0x66a3
ucomisd 0x2e28d(%rip), %xmm2    # 0x348f0
ja 0x66a3
movzbl %sil, %eax
movl $0x1, %edx
xorpd %xmm2, %xmm2
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x6693
movsd (%rdi,%rcx,8), %xmm3
subsd %xmm3, %xmm0
ucomisd %xmm3, %xmm2
ja 0x6693
leaq 0x1(%rcx), %rdx
ucomisd %xmm1, %xmm3
jbe 0x6672
cmpq %rax, %rcx
setae %cl
jmp 0x66a3
movsd 0x2e24d(%rip), %xmm0    # 0x348f0
andpd 0x2e285(%rip), %xmm0    # 0x34930
movsd 0x2e245(%rip), %xmm1    # 0x348f8
ucomisd %xmm0, %xmm1
seta %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: issimplexbounded(double*, double*, double*, signed char)
bool issimplexbounded(NUMBER* ar, NUMBER *lb, NUMBER *ub, NPAR size) {
	NUMBER sum = 1;
	for(NPAR i=0; i<size; i++) {
		sum -= ar[i];
		if( ar[i] < lb[i] || ar[i] > ub[i])
			return false;
	}
//    for(NPAR i=0; i<size && fabs(sum)<SAFETY && fabs(sum)>0; i++) {
//        if( (ar[i]+sum) >=lb[i] ) {
//            ar[i]+=sum;
//            break;
//        }
//        if( (ar[i]+sum) <=ub[i] ) {
//            ar[i]+=sum;
//            break;
//        }
//    }
	return fabs(sum)<SAFETY;
}

// Assembly:
testb %cl, %cl
setle %r8b
jle 0x6711
movsd (%rdi), %xmm1
movsd 0x2e21f(%rip), %xmm0    # 0x348f0
subsd %xmm1, %xmm0
movsd (%rsi), %xmm2
ucomisd %xmm1, %xmm2
ja 0x6719
movzbl %cl, %eax
movl $0x1, %ecx
ucomisd -0x8(%rdx,%rcx,8), %xmm1
ja 0x6719
cmpq %rax, %rcx
setae %r8b
je 0x6719
movsd (%rdi,%rcx,8), %xmm1
subsd %xmm1, %xmm0
movsd (%rsi,%rcx,8), %xmm2
incq %rcx
ucomisd %xmm1, %xmm2
jbe 0x66e7
jmp 0x6719
movsd 0x2e1d7(%rip), %xmm0    # 0x348f0
andpd 0x2e20f(%rip), %xmm0    # 0x34930
movsd 0x2e1cf(%rip), %xmm1    # 0x348f8
ucomisd %xmm0, %xmm1
seta %al
andb %r8b, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: maxn(double*, int)
NUMBER maxn(NUMBER *ar, NDAT n) {
	NUMBER mx = ar[0];
	for(NDAT i=1; i<n; i++)
		if(ar[i]>mx) mx = ar[i];
	return mx;
}

// Assembly:
movsd (%rdi), %xmm1
cmpl $0x2, %esi
jl 0x8f78
movl %esi, %eax
movl $0x1, %ecx
movsd (%rdi,%rcx,8), %xmm0
maxsd %xmm1, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jne 0x8f62
retq
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: add3DNumbersWeighted(double***, double***, signed char, signed char, signed char, double)
void add3DNumbersWeighted(NUMBER*** sourse, NUMBER*** target, NPAR size1, NPAR size2, NPAR size3, NUMBER weight) {
    for(NPAR i=0; i<size1; i++)
        for(NPAR j=0; j<size2; j++)
            for(NPAR l=0; l<size3; l++)
                target[i][j][l] = target[i][j][l] + sourse[i][j][l]*weight;
}

// Assembly:
testb %dl, %dl
jle 0x906d
pushq %r15
pushq %r14
pushq %rbx
movzbl %dl, %eax
movzbl %cl, %edx
movzbl %r8b, %r9d
xorl %r10d, %r10d
testb %cl, %cl
jle 0x9060
xorl %r11d, %r11d
testb %r8b, %r8b
jle 0x9058
movq (%rsi,%r10,8), %rbx
movq (%rbx,%r11,8), %rbx
movq (%rdi,%r10,8), %r14
movq (%r14,%r11,8), %r14
xorl %r15d, %r15d
movsd (%r14,%r15,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rbx,%r15,8), %xmm1
movsd %xmm1, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r9
jne 0x903a
incq %r11
cmpq %rdx, %r11
jne 0x9022
incq %r10
cmpq %rax, %r10
jne 0x901b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: isPasses(double*, signed char)
bool isPasses(NUMBER* ar, NPAR size) {
	NUMBER sum = 0;
	for(NPAR i=0; i<size; i++) {
		if( ar[i]<0 || ar[i]>1)
			return false;
		sum += ar[i];
	}
	return sum==1;
}

// Assembly:
testb %sil, %sil
jle 0x90e4
movsd (%rdi), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x90e3
ucomisd 0x2b865(%rip), %xmm0    # 0x348f0
ja 0x90e3
movzbl %sil, %eax
movl $0x1, %edx
movsd 0x2b852(%rip), %xmm2    # 0x348f0
xorpd %xmm3, %xmm3
movapd %xmm3, %xmm4
movq %rdx, %rcx
movapd %xmm0, %xmm3
addsd %xmm4, %xmm3
cmpq %rdx, %rax
je 0x90cb
movsd (%rdi,%rcx,8), %xmm0
ucomisd %xmm0, %xmm1
ja 0x90cb
leaq 0x1(%rcx), %rdx
ucomisd %xmm2, %xmm0
jbe 0x90a2
cmpq %rax, %rcx
setae %cl
ucomisd 0x2b817(%rip), %xmm3    # 0x348f0
setnp %dl
sete %al
andb %dl, %al
andb %cl, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: isPassesLim(double*, signed char, double*, double*)
bool isPassesLim(NUMBER* ar, NPAR size, NUMBER *lb, NUMBER* ub) {
	NUMBER sum = 0;
	for(NPAR i=0; i<size; i++) {
		if( (lb[i]-ar[i])>SAFETY || (ar[i]-ub[i])>SAFETY )
			return false;
		sum += ar[i];
	}
	return fabs(sum-1)<SAFETY;
}

// Assembly:
testb %sil, %sil
jle 0x913a
movzbl %sil, %eax
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd 0x2b7fa(%rip), %xmm1    # 0x348f8
movsd (%rdx,%rsi,8), %xmm3
movsd (%rdi,%rsi,8), %xmm2
subsd %xmm2, %xmm3
ucomisd %xmm1, %xmm3
ja 0x9137
movapd %xmm2, %xmm3
subsd (%rcx,%rsi,8), %xmm3
ucomisd %xmm1, %xmm3
ja 0x9137
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x90fe
addsd 0x2b7b3(%rip), %xmm0    # 0x348e8
jmp 0x9142
xorl %eax, %eax
retq
movsd 0x2b7a6(%rip), %xmm0    # 0x348e8
andpd 0x2b7e6(%rip), %xmm0    # 0x34930
movsd 0x2b7a6(%rip), %xmm1    # 0x348f8
ucomisd %xmm0, %xmm1
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: doLog10Scale1D(double*, signed char)
NUMBER doLog10Scale1D(NUMBER *ar, NPAR size) {
	NPAR i;
	NUMBER min_10_scale = 1000, max_10_scale = 0, candidate;
	for(i=0; i<size; i++) {
		if( fabs(ar[i]) < SAFETY ) // 0 gradient
			continue;
		candidate = floor( log10( fabs(ar[i]) ) );
		if(candidate < min_10_scale)
			min_10_scale = candidate;
		candidate = ceil( log10( fabs(ar[i]) ) );
		if(candidate > max_10_scale)
			max_10_scale = candidate;
	}
	min_10_scale++;
	max_10_scale++;
	if(max_10_scale > 0)
		for(i=0; i<size; i++)
			ar[i] = ar[i] / pow(10, max_10_scale);
    //	if(min_10_scale<1000)
    //		for(i=0; i<size; i++)
    //			ar[i] = ar[i] / pow(10, min_10_scale);
	return pow(10, max_10_scale);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movzbl %bpl, %r14d
testb %bpl, %bpl
jle 0x91ee
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movapd 0x2b7af(%rip), %xmm2    # 0x34930
movsd 0x2b76f(%rip), %xmm3    # 0x348f8
movsd (%rbx,%r15,8), %xmm0
andpd %xmm2, %xmm0
ucomisd %xmm0, %xmm3
ja 0x91dc
movsd %xmm1, 0x8(%rsp)
callq 0x4110
movsd (%rbx,%r15,8), %xmm0
andpd 0x2b77e(%rip), %xmm0    # 0x34930
callq 0x4110
callq 0x4090
movsd 0x2b734(%rip), %xmm3    # 0x348f8
movapd 0x2b764(%rip), %xmm2    # 0x34930
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x91dc
movapd %xmm0, %xmm1
incq %r15
cmpq %r15, %r14
jne 0x9189
addsd 0x2b704(%rip), %xmm1    # 0x348f0
jmp 0x91f6
movsd 0x2b6fa(%rip), %xmm1    # 0x348f0
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
setbe %al
testb %bpl, %bpl
setle %cl
orb %al, %cl
jne 0x9251
xorl %r15d, %r15d
movsd %xmm1, 0x8(%rsp)
movsd (%rbx,%r15,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x2b6e8(%rip), %xmm0    # 0x34910
movsd 0x8(%rsp), %xmm1
callq 0x4420
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x9214
movsd 0x2b6b7(%rip), %xmm0    # 0x34910
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4420
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: doLog10Scale2D(double**, signed char, signed char)
NUMBER doLog10Scale2D(NUMBER **ar, NPAR size1, NPAR size2) {
	NPAR i,j;
	NUMBER min_10_scale = 1000, max_10_scale = 0, candidate;
	for(i=0; i<size1; i++)
		for(j=0; j<size2; j++) {
			if( fabs(ar[i][j]) < SAFETY ) // 0 gradient
				continue;
			candidate = floor( log10( fabs(ar[i][j]) ) );
			if(candidate < min_10_scale)
				min_10_scale = candidate;
			candidate = ceil( log10( fabs(ar[i][j]) ) );
			if(candidate > max_10_scale)
				max_10_scale = candidate;
		}
	min_10_scale++;
	max_10_scale++;
	if(max_10_scale >0 )
		for(i=0; i<size1; i++)
			for(j=0; j<size2; j++)
				ar[i][j] = ar[i][j] / pow(10, max_10_scale);
    //	if(min_10_scale<1000)
    //		for(i=0; i<size1; i++)
    //			for(j=0; j<size2; j++)
    //				ar[i][j] = ar[i][j] / pow(10, min_10_scale);
	return pow(10, max_10_scale);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
movzbl %sil, %r15d
movzbl %bl, %r12d
testb %sil, %sil
jle 0x9324
movl %esi, 0x10(%rsp)
xorpd %xmm1, %xmm1
xorl %r13d, %r13d
movapd 0x2b691(%rip), %xmm2    # 0x34930
movsd 0x2b651(%rip), %xmm3    # 0x348f8
testb %bl, %bl
jle 0x930e
xorl %ebp, %ebp
movq (%r14,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
andpd %xmm2, %xmm0
ucomisd %xmm0, %xmm3
ja 0x9306
movsd %xmm1, 0x8(%rsp)
callq 0x4110
movq (%r14,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
andpd 0x2b654(%rip), %xmm0    # 0x34930
callq 0x4110
callq 0x4090
movsd 0x2b60a(%rip), %xmm3    # 0x348f8
movapd 0x2b63a(%rip), %xmm2    # 0x34930
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9306
movapd %xmm0, %xmm1
incq %rbp
cmpq %rbp, %r12
jne 0x92ad
incq %r13
cmpq %r15, %r13
jne 0x92a7
addsd 0x2b5d2(%rip), %xmm1    # 0x348f0
movl 0x10(%rsp), %esi
jmp 0x932c
movsd 0x2b5c4(%rip), %xmm1    # 0x348f0
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
setbe %al
testb %sil, %sil
setle %cl
orb %al, %cl
jne 0x939b
xorl %r13d, %r13d
movsd %xmm1, 0x8(%rsp)
testb %bl, %bl
jle 0x9393
xorl %ebp, %ebp
movq (%r14,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x2b5a9(%rip), %xmm0    # 0x34910
movsd 0x8(%rsp), %xmm1
callq 0x4420
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
divsd %xmm0, %xmm2
movq (%r14,%r13,8), %rax
movsd %xmm2, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r12
jne 0x9350
incq %r13
cmpq %r15, %r13
jne 0x934a
movsd 0x2b56d(%rip), %xmm0    # 0x34910
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4420
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: writeSolverInfo(_IO_FILE*, param*)
void writeSolverInfo(FILE *fid, struct param *param) {
    // solver id
    if( param->solver_setting>0 ) {
        fprintf(fid,"SolverId\t%d.%d.%d\n",param->structure,param->solver,param->solver_setting);
    } else {
        fprintf(fid,"SolverId\t%d.%d\n",param->structure,param->solver);
    }
	// nK
    fprintf(fid,"nK\t%d\n",param->nK);
    // nG
    fprintf(fid,"nG\t%d\n",param->nG);
    // nS
    fprintf(fid,"nS\t%d\n",param->nS);
    // nO
    fprintf(fid,"nO\t%d\n",param->nO);
    // nZ
    fprintf(fid,"nZ\t%d\n",param->nZ);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0x40(%rsi), %r8d
testl %r8d, %r8d
jle 0xa149
movsbl 0x3e(%r14), %edx
movsbl 0x3f(%r14), %ecx
leaq 0x2a930(%rip), %rsi     # 0x34a6d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4330
jmp 0xa164
movsbl 0x3e(%r14), %edx
movsbl 0x3f(%r14), %ecx
leaq 0x2a926(%rip), %rsi     # 0x34a80
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4330
movl 0x8c0(%r14), %edx
leaq 0x2a91e(%rip), %rsi     # 0x34a90
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4330
movl 0x8bc(%r14), %edx
leaq 0x2a90d(%rip), %rsi     # 0x34a97
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4330
movsbl 0x8b8(%r14), %edx
leaq 0x2a8fb(%rip), %rsi     # 0x34a9e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4330
movsbl 0x8b9(%r14), %edx
leaq 0x2a8e9(%rip), %rsi     # 0x34aa5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4330
movsbl 0x8c8(%r14), %edx
leaq 0x2a8d7(%rip), %rsi     # 0x34aac
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4330
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: readSolverInfo(_IO_FILE*, param*, int*)
void readSolverInfo(FILE *fid, struct param *param, NDAT *line_no) {
    string s;
    int c, i1, i2;
    // SolverId
    fscanf(fid,"SolverId\t%i.%i", &i1, &i2);
    param->structure = (NPAR) i1;
    param->solver    = (NPAR) i2;
    fscanf(fid,"SolverId\t%hhu.%hhu", &param->structure, &param->solver);
    c = fscanf(fid,".%hhu\n", &param->solver_setting);
    if( c<1 ) {
        fscanf(fid,"\n");
        param->solver_setting = -1;
    }
    (*line_no)++;
	// nK
    fscanf(fid,"nK\t%i\n",&param->nK);
    (*line_no)++;
    // nG
    fscanf(fid,"nG\t%i\n",&param->nG);
    (*line_no)++;
    // nS
    fscanf(fid,"nS\t%hhu\n",&param->nS);
    (*line_no)++;
    // nO
    fscanf(fid,"nO\t%hhu\n",&param->nO);
    (*line_no)++;
    // nZ
    fscanf(fid,"nZ\t%hhu\n",&param->nZ);
    (*line_no)++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x2a89a(%rip), %rsi     # 0x34ab3
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0x4460
movb 0xc(%rsp), %al
leaq 0x3e(%r14), %rdx
movb %al, 0x3e(%r14)
movb 0x8(%rsp), %al
leaq 0x3f(%r14), %rcx
movb %al, 0x3f(%r14)
leaq 0x2a879(%rip), %rsi     # 0x34ac2
movq %r15, %rdi
xorl %eax, %eax
callq 0x4460
leaq 0x40(%r14), %r12
leaq 0x2a877(%rip), %rsi     # 0x34ad5
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4460
testl %eax, %eax
jg 0xa285
leaq 0x29fe7(%rip), %rsi     # 0x3425d
movq %r15, %rdi
xorl %eax, %eax
callq 0x4460
movb $-0x1, (%r12)
incl (%rbx)
leaq 0x8c0(%r14), %rdx
leaq 0x2a847(%rip), %rsi     # 0x34adc
movq %r15, %rdi
xorl %eax, %eax
callq 0x4460
incl (%rbx)
leaq 0x8bc(%r14), %rdx
leaq 0x2a834(%rip), %rsi     # 0x34ae3
movq %r15, %rdi
xorl %eax, %eax
callq 0x4460
incl (%rbx)
leaq 0x8b8(%r14), %rdx
leaq 0x2a821(%rip), %rsi     # 0x34aea
movq %r15, %rdi
xorl %eax, %eax
callq 0x4460
incl (%rbx)
leaq 0x8b9(%r14), %rdx
leaq 0x2a810(%rip), %rsi     # 0x34af3
movq %r15, %rdi
xorl %eax, %eax
callq 0x4460
incl (%rbx)
addq $0x8c8, %r14            # imm = 0x8C8
leaq 0x2a7ff(%rip), %rsi     # 0x34afc
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4460
incl (%rbx)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xa323
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4220
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xa34b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4220
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: zeroLabels(param*)
void zeroLabels(struct param* param) { // set counts in data sequences to zero
	NCAT k,g;
	for(k=0; k<param->nK; k++)
		for(g=0; g<param->k_numg[k]; g++)
			param->k_g_data[k][g]->cnt = 0;
}

// Assembly:
movslq 0x8c0(%rdi), %rax
testq %rax, %rax
jle 0xa39c
movq 0x8e0(%rdi), %rcx
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,4)
jle 0xa394
movq 0x8f8(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
movl $0x0, 0x4(%r9)
incq %r8
movslq (%rcx,%rdx,4), %r9
cmpq %r9, %r8
jl 0xa37c
incq %rdx
cmpq %rax, %rdx
jne 0xa368
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: RecycleFitData(int, data**, param*)
void RecycleFitData(NCAT xndat, struct data** x_data, struct param *param) {
	NCAT x;
	NDAT t;
	for(x=0; x<xndat; x++) {
        //        if( x_data[x][0].cnt != 0)
        //            continue;
		if( x_data[x][0].alpha != NULL ) {
			free2D<NUMBER>(x_data[x][0].alpha, x_data[x][0].n);  // only free data here
			x_data[x][0].alpha = NULL;
		}
		if( x_data[x][0].c != NULL ) {
			free(x_data[x][0].c);  // only free data here
			x_data[x][0].c = NULL;
		}
		if( x_data[x][0].beta != NULL ) {
			free2D<NUMBER>(x_data[x][0].beta,  x_data[x][0].n); // only free data here
			x_data[x][0].beta = NULL;
		}
		if( x_data[x][0].gamma != NULL ) {
			free2D<NUMBER>(x_data[x][0].gamma, x_data[x][0].n); // only free data here
			x_data[x][0].gamma = NULL;
		}
		if( x_data[x][0].xi != NULL ) {
			for(t=0;t<x_data[x][0].n; t++)
				free2D<NUMBER>(x_data[x][0].xi[t],  (NDAT)param->nS); // only free data here
			x_data[x][0].xi = NULL;
		}
	}
}

// Assembly:
testl %edi, %edi
jle 0xa48f
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0xa3da
movl (%rax), %esi
callq 0xa5e0
movq (%r14,%r12,8), %rax
movq $0x0, 0x28(%rax)
movq (%r14,%r12,8), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0xa3f8
callq 0x42a0
movq (%r14,%r12,8), %rax
movq $0x0, 0x20(%rax)
movq (%r14,%r12,8), %rax
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0xa418
movl (%rax), %esi
callq 0xa5e0
movq (%r14,%r12,8), %rax
movq $0x0, 0x30(%rax)
movq (%r14,%r12,8), %rax
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0xa438
movl (%rax), %esi
callq 0xa5e0
movq (%r14,%r12,8), %rax
movq $0x0, 0x38(%rax)
movq (%r14,%r12,8), %rax
cmpq $0x0, 0x40(%rax)
je 0xa47a
movq (%r14,%r12,8), %rax
cmpl $0x0, (%rax)
jle 0xa472
xorl %r13d, %r13d
movq 0x40(%rax), %rax
movq (%rax,%r13,8), %rdi
movsbl 0x8b8(%rbx), %esi
callq 0xa5e0
incq %r13
movq (%r14,%r12,8), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
jl 0xa44f
movq $0x0, 0x40(%rax)
incq %r12
cmpq %r15, %r12
jne 0xa3ba
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/utils.cpp
// Function: sec_to_9cat(int, int, int*, signed char)
NPAR sec_to_9cat(int time1, int time2, int *limits, NPAR nlimits) {
    int diff = time2 - time1;
    
    if(diff <0 ) {
        fprintf(stderr,"ERROR! time 1 should be smaller than time 2\n");
        return 0;
    } else if ( diff < (2*60) ) { // 20min
        return 0;
    } else if ( diff < (20*60) ) { // 20min
        return 1;
    } else if (diff < (60*60) ) { // 1h
        return 2;
    } else if(diff < (14*24*60*60)) { // detect date structures
        time_t t1 = (time_t)time1;
        time_t t2 = (time_t)time2;
        struct tm * ttm1 = localtime (&t1);
        struct tm * ttm2 = localtime (&t2);
        if( diff < (24*60*60) && ttm1->tm_mday==ttm2->tm_mday ) { // same day
            return 3;
        } else if(    diff < (2*24*60*60) &&                      // next day
                  ( (ttm2->tm_wday == (ttm1->tm_wday+1)) ||
                   (ttm1->tm_wday==6 && ttm2->tm_wday==0)
                   )
                  ) {
            return 4;
        } else if( diff < (7*24*60*60) && (ttm1->tm_wday<ttm2->tm_wday) ) { // this week
            return 5;
        } else { // next week
            return 6;
        }
    } else if(diff < (30*24*60*60)) { // less than 30 days
        return 7;
    } else if(diff >= (30*24*60*60)) { // 30 days or more
        return 8;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
subl %edi, %ebp
js 0xa575
cmpl $0x78, %ebp
jge 0xa4ce
xorl %eax, %eax
jmp 0xa56c
movb $0x1, %al
cmpl $0x4b0, %ebp            # imm = 0x4B0
jl 0xa56c
movb $0x2, %al
cmpl $0xe10, %ebp            # imm = 0xE10
jl 0xa56c
cmpl $0x1274ff, %ebp         # imm = 0x1274FF
jg 0xa55f
movslq %edi, %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movslq %esi, %rax
movq %rsp, %r14
movq %rax, (%r14)
callq 0x4190
movq %rax, %rbx
movq %r14, %rdi
callq 0x4190
movq %rax, %rcx
cmpl $0x1517f, %ebp          # imm = 0x1517F
jg 0xa52b
movl 0xc(%rbx), %edx
movb $0x3, %al
cmpl 0xc(%rcx), %edx
je 0xa56c
cmpl $0x2a2ff, %ebp          # imm = 0x2A2FF
jg 0xa549
movl 0x18(%rcx), %edx
movl 0x18(%rbx), %esi
leal 0x1(%rsi), %edi
movb $0x4, %al
cmpl %edi, %edx
je 0xa56c
xorl $0x6, %esi
orl %esi, %edx
je 0xa56c
cmpl $0x93a7f, %ebp          # imm = 0x93A7F
jg 0xa55b
movl 0x18(%rbx), %edx
movb $0x5, %al
cmpl 0x18(%rcx), %edx
jl 0xa56c
movb $0x6, %al
jmp 0xa56c
cmpl $0x278d00, %ebp         # imm = 0x278D00
setl %cl
movb $0x8, %al
subb %cl, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x47e3
jmp 0xa4c7
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/./utils.h
// Function: void free2D<double>(double**, int)
void free2D(T** ar, NDAT size1) {
	for(NDAT i=0; i<size1; i++)
		free(ar[i]);
	free(ar);
    //    &ar = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0xa603
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x42a0
incq %r15
cmpq %r15, %r14
jne 0xa5f2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x42a0
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::init(double*&, double**&, double**&)
void FitBit::init(NUMBER* &a_PI, NUMBER** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL) {
        if(a_PI == NULL)
            a_PI = init1D<NUMBER>((NDAT)this->nS); // init1DNumber(this->nS);
        else
            toZero1D<NUMBER>(a_PI, (NDAT)this->nS);
    }
    if(this->A  != NULL) {
        if(a_A == NULL)
            a_A  = init2D<NUMBER>((NDAT)this->nS, (NDAT)this->nS);
        else
            toZero2D<NUMBER>(a_A,  (NDAT)this->nS, (NDAT)this->nS);
    }
    if(this->B  != NULL) {
        if(a_B == NULL)
            a_B  = init2D<NUMBER>((NDAT)this->nS, (NDAT)this->nO);
        else
            toZero2D<NUMBER>(a_B, (NDAT)this->nS, (NDAT)this->nO);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xaafd
movq %rsi, %r12
movq (%rsi), %rdi
movsbq 0x1(%r14), %rdx
testq %rdi, %rdi
je 0xaaec
testb %dl, %dl
jle 0xaafd
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x4120
jmp 0xaafd
movl $0x8, %esi
movq %rdx, %rdi
callq 0x4130
movq %rax, (%r12)
cmpq $0x0, 0x18(%r14)
je 0xab45
movq (%r15), %r12
movsbl 0x1(%r14), %edi
testq %r12, %r12
je 0xab3b
testb %dil, %dil
jle 0xab45
movslq %edi, %r13
leaq (,%r13,8), %r15
xorl %ebp, %ebp
movq (%r12,%rbp,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4120
incq %rbp
cmpq %rbp, %r13
jne 0xab23
jmp 0xab45
movl %edi, %esi
callq 0xbb5c
movq %rax, (%r15)
cmpq $0x0, 0x20(%r14)
je 0xab98
movq (%rbx), %r15
movsbl 0x1(%r14), %edi
testq %r15, %r15
je 0xab8c
testb %dil, %dil
jle 0xab98
movslq %edi, %r12
movsbq (%r14), %r14
movl %r14d, %ebx
shlq $0x3, %rbx
xorl %r13d, %r13d
testb %r14b, %r14b
jle 0xab82
movq (%r15,%r13,8), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4120
incq %r13
cmpq %r13, %r12
jne 0xab6f
jmp 0xab98
movsbl (%r14), %esi
callq 0xbb5c
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::negate(double*&, double**&, double**&)
void FitBit::negate(NUMBER* &a_PI, NUMBER** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL) {
        for(NPAR i=0; i<this->nS; i++) a_PI[i] = -a_PI[i];
    }
    if(this->A  != NULL) {
        for(NPAR i=0; i<this->nS; i++)
            for(NPAR j=0; j<this->nS; j++)
                a_A[i][j] = -a_A[i][j];
    }
    if(this->B  != NULL) {
        for(NPAR i=0; i<this->nS; i++)
            for(NPAR m=0; m<this->nO; m++)
                a_B[i][m] = -a_B[i][m];
    }
}

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0xabdc
movsbq 0x1(%rdi), %rax
testq %rax, %rax
jle 0xabdc
movq (%rsi), %rsi
xorl %r8d, %r8d
movaps 0x29d7a(%rip), %xmm0    # 0x34940
movsd (%rsi,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rsi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0xabc6
cmpq $0x0, 0x18(%rdi)
je 0xac1e
movsbq 0x1(%rdi), %rax
testq %rax, %rax
jle 0xac1e
movq (%rdx), %rdx
xorl %esi, %esi
movaps 0x29d47(%rip), %xmm0    # 0x34940
movq (%rdx,%rsi,8), %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r8,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0xac00
incq %rsi
cmpq %rax, %rsi
jne 0xabf9
cmpq $0x0, 0x20(%rdi)
je 0xac67
movsbq 0x1(%rdi), %rax
testq %rax, %rax
jle 0xac67
movzbl (%rdi), %edx
movq (%rcx), %rcx
xorl %esi, %esi
movaps 0x29d02(%rip), %xmm0    # 0x34940
testb %dl, %dl
jle 0xac5f
movq (%rcx,%rsi,8), %rdi
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rdx
jne 0xac49
incq %rsi
cmpq %rax, %rsi
jne 0xac3e
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::link(double*, double**, double**, int, data**)
void FitBit::link(NUMBER *a_PI, NUMBER **a_A, NUMBER **a_B, NCAT a_xndat, struct data** a_x_data) {
    this->pi = a_PI;
    this->A  = a_A;
    this->B  = a_B;
    this->xndat = a_xndat;
    this->x_data = a_x_data;
}

// Assembly:
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movl %r8d, 0xe8(%rdi)
movq %r9, 0xf0(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::destroy(double*&, double**&, double**&)
void FitBit::destroy(NUMBER* &a_PI, NUMBER** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL && a_PI != NULL) free(a_PI);
    if(this->A  != NULL && a_A  != NULL) free2D<NUMBER>(a_A, (NDAT)this->nS);
    if(this->B  != NULL && a_B  != NULL) free2D<NUMBER>(a_B, (NDAT)this->nS);
    a_PI = NULL;
    a_A  = NULL;
    a_B  = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x10(%rdi)
je 0xaeba
movq (%r15), %rdi
testq %rdi, %rdi
je 0xaeba
callq 0x42a0
cmpq $0x0, 0x18(%r12)
je 0xaed5
movq (%r14), %rdi
testq %rdi, %rdi
je 0xaed5
movsbl 0x1(%r12), %esi
callq 0xa5e0
cmpq $0x0, 0x20(%r12)
je 0xaef0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xaef0
movsbl 0x1(%r12), %esi
callq 0xa5e0
xorl %eax, %eax
movq %rax, (%r15)
movq %rax, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::copy(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBit::copy(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER **sourseA = NULL;
    NUMBER **sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER **targetA = NULL;
    NUMBER **targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    copy(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x18(%rsp), %rdx
movq %r12, (%rdx)
leaq 0x10(%rsp), %rcx
movq %r12, (%rcx)
leaq 0x8(%rsp), %r8
movq %r12, (%r8)
callq 0xaff2
leaq 0x30(%rsp), %r13
movq %r12, (%r13)
leaq 0x28(%rsp), %r14
movq %r12, (%r14)
leaq 0x20(%rsp), %r15
movq %r12, (%r15)
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0xaff2
movq %r15, (%rsp)
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r13, %r8
movq %r14, %r9
callq 0xad40
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::add(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBit::add(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER **sourseA = NULL;
    NUMBER **sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER **targetA = NULL;
    NUMBER **targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    add(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0x14(%rsp)
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x20(%rsp), %rdx
movq %rbp, (%rdx)
leaq 0x18(%rsp), %rcx
movq %rbp, (%rcx)
leaq 0x40(%rsp), %r12
movq %rbp, (%r12)
movq %r12, %r8
callq 0xaff2
leaq 0x38(%rsp), %r13
movq %rbp, (%r13)
leaq 0x30(%rsp), %r14
movq %rbp, (%r14)
leaq 0x28(%rsp), %r15
movq %rbp, (%r15)
movq %rbx, %rdi
movl 0x14(%rsp), %esi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0xaff2
leaq 0x20(%rsp), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %rax
movq (%rax), %rdx
movq (%r12), %rcx
movq (%r13), %r8
movq (%r14), %r9
movq (%r15), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0xae02
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/./utils.h
// Function: double** init2D<double>(int, int)
T** init2D(NDAT size1, NDAT size2) {
	T** ar = (T **)Calloc(T *, (size_t)size1);
	for(NDAT i=0; i<size1; i++)
		ar[i] = (T *)Calloc(T, (size_t)size2);
	return ar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movl %edi, %ebp
movslq %edi, %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x4130
movq %rax, %rbx
testl %r15d, %r15d
jle 0xbba3
movslq %r14d, %r14
movl %ebp, %r15d
xorl %r12d, %r12d
movl $0x8, %esi
movq %r14, %rdi
callq 0x4130
movq %rax, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xbb8a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::init(double*&, double***&, double**&)
void FitBitSlicedA::init(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL) {
        if(a_PI == NULL)
            a_PI = init1D<NUMBER>((NDAT)this->nS); // init1DNumber(this->nS);
        else
            toZero1D<NUMBER>(a_PI, (NDAT)this->nS);
    }
    if(this->A  != NULL) {
        if(a_A == NULL)
            a_A  = init3D<NUMBER>((NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
        else
            toZero3D<NUMBER>(a_A, (NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
    }
    if(this->B  != NULL) {
        if(a_B == NULL)
            a_B  = init2D<NUMBER>( (NDAT)this->nS, (NDAT)this->nO);
        else
            toZero2D<NUMBER>(a_B, (NDAT)this->nS, (NDAT)this->nO);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xbe4c
movq %rsi, %r12
movq (%rsi), %rdi
movsbq 0x1(%r14), %rdx
testq %rdi, %rdi
je 0xbe3b
testb %dl, %dl
jle 0xbe4c
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x4120
jmp 0xbe4c
movl $0x8, %esi
movq %rdx, %rdi
callq 0x4130
movq %rax, (%r12)
movq %rbx, 0x10(%rsp)
movq %r14, 0x8(%rsp)
cmpq $0x0, 0x18(%r14)
je 0xbed8
movq (%r15), %rcx
movq 0x8(%rsp), %rax
movsbl 0x2(%rax), %edi
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0xbeca
testb %dil, %dil
jle 0xbed8
movslq %edi, %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movsbq 0x1(%rax), %rbp
movl %ebp, %ebx
leaq (,%rbx,8), %r15
xorl %r14d, %r14d
testb %bpl, %bpl
jle 0xbebe
movq 0x18(%rsp), %rax
movq (%rax,%r14,8), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4120
incq %r13
cmpq %r13, %rbx
jne 0xbea8
incq %r14
cmpq 0x20(%rsp), %r14
jne 0xbe97
jmp 0xbed8
movsbl 0x1(%rax), %edx
movl %edx, %esi
callq 0xcaae
movq %rax, (%r15)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0xbf33
movq 0x10(%rsp), %rbx
movq (%rbx), %r15
movsbl 0x1(%rax), %edi
testq %r15, %r15
je 0xbf28
testb %dil, %dil
jle 0xbf33
movslq %edi, %r14
movsbq (%rax), %r12
movl %r12d, %ebx
shlq $0x3, %rbx
xorl %r13d, %r13d
testb %r12b, %r12b
jle 0xbf1e
movq (%r15,%r13,8), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4120
incq %r13
cmpq %r13, %r14
jne 0xbf0b
jmp 0xbf33
movsbl (%rax), %esi
callq 0xbb5c
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::negate(double*&, double***&, double**&)
void FitBitSlicedA::negate(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL) {
        for(NPAR i=0; i<this->nS; i++) a_PI[i] = -a_PI[i];
    }
    if(this->A  != NULL) {
        for(NPAR z=0; z<this->nZ; z++)
            for(NPAR i=0; i<this->nS; i++)
                for(NPAR j=0; j<this->nS; j++)
                    a_A[z][i][j] = -a_A[z][i][j];
    }
    if(this->B  != NULL) {
        for(NPAR i=0; i<this->nS; i++)
            for(NPAR m=0; m<this->nO; m++)
                a_B[i][m] = -a_B[i][m];
    }
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0xbf77
movsbq 0x1(%rdi), %rax
testq %rax, %rax
jle 0xbf77
movq (%rsi), %rsi
xorl %r8d, %r8d
movaps 0x289df(%rip), %xmm0    # 0x34940
movsd (%rsi,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rsi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0xbf61
cmpq $0x0, 0x18(%rdi)
je 0xbfd1
movsbq 0x2(%rdi), %rax
testq %rax, %rax
jle 0xbfd1
movzbl 0x1(%rdi), %esi
xorl %r8d, %r8d
movaps 0x289aa(%rip), %xmm0    # 0x34940
testb %sil, %sil
jle 0xbfc9
movq (%rdx), %r9
movq (%r9,%r8,8), %r9
xorl %r10d, %r10d
movq (%r9,%r10,8), %r11
xorl %ebx, %ebx
movsd (%r11,%rbx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r11,%rbx,8)
incq %rbx
cmpq %rbx, %rsi
jne 0xbfab
incq %r10
cmpq %rsi, %r10
jne 0xbfa5
incq %r8
cmpq %rax, %r8
jne 0xbf96
cmpq $0x0, 0x20(%rdi)
je 0xc01a
movsbq 0x1(%rdi), %rax
testq %rax, %rax
jle 0xc01a
movzbl (%rdi), %edx
movq (%rcx), %rcx
xorl %esi, %esi
movaps 0x2894f(%rip), %xmm0    # 0x34940
testb %dl, %dl
jle 0xc012
movq (%rcx,%rsi,8), %rdi
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rdx
jne 0xbffc
incq %rsi
cmpq %rax, %rsi
jne 0xbff1
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::link(double*, double***, double**, int, data**)
void FitBitSlicedA::link(NUMBER *a_PI, NUMBER ***a_A, NUMBER **a_B, NCAT a_xndat, struct data** a_x_data) {
    this->pi = a_PI;
    this->A  = a_A;
    this->B  = a_B;
    this->xndat = a_xndat;
    this->x_data = a_x_data;
}

// Assembly:
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movl %r8d, 0xd0(%rdi)
movq %r9, 0xd8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::destroy(double*&, double***&, double**&)
void FitBitSlicedA::destroy(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL && a_PI != NULL) free(a_PI);
    if(this->A  != NULL && a_A  != NULL) free3D<NUMBER>(a_A, (NDAT)this->nZ, (NDAT)this->nS);
    if(this->B  != NULL && a_B  != NULL) free2D<NUMBER>(a_B, (NDAT)this->nS);
    a_PI = NULL;
    a_A  = NULL;
    a_B  = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x10(%rdi)
je 0xc2fc
movq (%r15), %rdi
testq %rdi, %rdi
je 0xc2fc
callq 0x42a0
cmpq $0x0, 0x18(%r12)
je 0xc31d
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc31d
movsbl 0x2(%r12), %esi
movsbl 0x1(%r12), %edx
callq 0xca4f
cmpq $0x0, 0x20(%r12)
je 0xc338
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc338
movsbl 0x1(%r12), %esi
callq 0xa5e0
xorl %eax, %eax
movq %rax, (%r15)
movq %rax, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::copy(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBitSlicedA::copy(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER ***sourseA = NULL;
    NUMBER **sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER ***targetA = NULL;
    NUMBER **targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    copy(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x18(%rsp), %rdx
movq %r12, (%rdx)
leaq 0x10(%rsp), %rcx
movq %r12, (%rcx)
leaq 0x8(%rsp), %r8
movq %r12, (%r8)
callq 0xc43a
leaq 0x30(%rsp), %r13
movq %r12, (%r13)
leaq 0x28(%rsp), %r14
movq %r12, (%r14)
leaq 0x20(%rsp), %r15
movq %r12, (%r15)
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0xc43a
movq %r15, (%rsp)
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r13, %r8
movq %r14, %r9
callq 0xc144
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::doLog10ScaleGentle(FIT_BIT_SLOT)
void FitBitSlicedA::doLog10ScaleGentle(enum FIT_BIT_SLOT fbs) {
    // fbs - gradient or direction
    NUMBER *a_PI = NULL;
    NUMBER ***a_A = NULL;
    NUMBER **a_B = NULL;
    get(fbs, a_PI, a_A, a_B);
	if(this->pi != NULL) doLog10Scale1DGentle(a_PI, this->pi, this->nS);
    if(this->A  != NULL) {
        for(NPAR z=0; z<this->nZ; z++) {
            doLog10Scale2DGentle(a_A[z],  this->A[z], this->nS, this->nS);
        }
    }
    if(this->B  != NULL) {
        doLog10Scale2DGentle(a_B,  this->B, this->nS, this->nO);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
callq 0xc43a
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0xc784
movq 0x18(%rsp), %rdi
movsbl 0x1(%rbx), %edx
callq 0x93b6
cmpq $0x0, 0x18(%rbx)
je 0xc7bd
cmpb $0x0, 0x2(%rbx)
jle 0xc7bd
movq 0x10(%rsp), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rsi
movsbl 0x1(%rbx), %ecx
movl %ecx, %edx
callq 0x9662
incq %r15
movsbq 0x2(%rbx), %rax
cmpq %rax, %r15
jl 0xc799
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0xc7e0
movq 0x8(%rsp), %rdi
movsbl 0x1(%rbx), %edx
movsbl (%rbx), %ecx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x9662
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/./utils.h
// Function: void free3D<double>(double***, int, int)
void free3D(T*** ar, NDAT size1, NDAT size2) {
    for(NDAT i=0; i<size1; i++) {
        for(NDAT j=0; j<size2; j++)
            free(ar[i][j]);
        free(ar[i]);
    }
    free(ar);
    //    &ar = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testl %esi, %esi
jle 0xca98
movl %edx, %ebx
movl %esi, %r15d
movl %edx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0xca87
xorl %ebp, %ebp
movq (%r14,%r13,8), %rax
movq (%rax,%rbp,8), %rdi
callq 0x42a0
incq %rbp
cmpq %rbp, %r12
jne 0xca72
movq (%r14,%r13,8), %rdi
callq 0x42a0
incq %r13
cmpq %r15, %r13
jne 0xca6c
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/./utils.h
// Function: double*** init3D<double>(int, int, int)
T*** init3D(NDAT size1, NDAT size2, NDAT size3) {
	NDAT i,j;
	T*** ar = Calloc(T **, (size_t)size1);
	for(i=0; i<size1; i++) {
		ar[i] = Calloc(T*, (size_t)size2);
		for(j=0; j<size2; j++)
			ar[i][j] = Calloc(T, (size_t)size3);
	}
	return ar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r12d
movslq %edi, %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x4130
movq %rax, 0x8(%rsp)
testl %r15d, %r15d
jle 0xcb35
movslq %r14d, %r14
movslq %ebp, %r15
movl %r12d, %eax
movq %rax, 0x10(%rsp)
movl %r14d, %ebp
xorl %ebx, %ebx
movl $0x8, %esi
movq %r14, %rdi
callq 0x4130
movq %rax, %r12
movq 0x8(%rsp), %rax
movq %r12, (%rax,%rbx,8)
testl %r14d, %r14d
jle 0xcb2b
xorl %r13d, %r13d
movl $0x8, %esi
movq %r15, %rdi
callq 0x4130
movq %rax, (%r12,%r13,8)
incq %r13
cmpq %r13, %rbp
jne 0xcb12
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0xcaf1
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::init(double*&, double***&, double***&)
void FitBitSlicedAB::init(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER*** &a_B) {
    if(this->pi != NULL) {
        if(a_PI == NULL)
            a_PI = init1D<NUMBER>((NDAT)this->nS); // init1DNumber(this->nS);
        else
            toZero1D<NUMBER>(a_PI, (NDAT)this->nS);
    }
    if(this->A  != NULL) {
        if(a_A == NULL)
            a_A  = init3D<NUMBER>((NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
        else
            toZero3D<NUMBER>(a_A, (NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
    }
    if(this->B  != NULL) {
        if(a_B == NULL)
            a_B  = init3D<NUMBER>((NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nO);
        else
            toZero3D<NUMBER>(a_B, (NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nO);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xce04
movq %rsi, %r12
movq (%rsi), %rdi
movsbq 0x1(%r14), %rdx
testq %rdi, %rdi
je 0xcdf3
testb %dl, %dl
jle 0xce04
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x4120
jmp 0xce04
movl $0x8, %esi
movq %rdx, %rdi
callq 0x4130
movq %rax, (%r12)
movq %rbx, 0x18(%rsp)
movq %r14, 0x8(%rsp)
cmpq $0x0, 0x18(%r14)
je 0xce90
movq (%r15), %rcx
movq 0x8(%rsp), %rax
movsbl 0x2(%rax), %edi
movq %rcx, 0x20(%rsp)
testq %rcx, %rcx
je 0xce82
testb %dil, %dil
jle 0xce90
movslq %edi, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movsbq 0x1(%rax), %rbp
movl %ebp, %ebx
leaq (,%rbx,8), %r15
xorl %r14d, %r14d
testb %bpl, %bpl
jle 0xce76
movq 0x20(%rsp), %rax
movq (%rax,%r14,8), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4120
incq %r13
cmpq %r13, %rbx
jne 0xce60
incq %r14
cmpq 0x10(%rsp), %r14
jne 0xce4f
jmp 0xce90
movsbl 0x1(%rax), %edx
movl %edx, %esi
callq 0xcaae
movq %rax, (%r15)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0xcf0e
movq 0x18(%rsp), %rbx
movq (%rbx), %r15
movsbl 0x2(%rax), %edi
testq %r15, %r15
je 0xceff
testb %dil, %dil
jle 0xcf0e
movslq %edi, %rcx
movq %rcx, 0x10(%rsp)
movsbq 0x1(%rax), %r13
movsbq (%rax), %r14
movl %r14d, %ebx
shlq $0x3, %rbx
xorl %ebp, %ebp
testb %r13b, %r13b
jle 0xcef3
xorl %r12d, %r12d
testb %r14b, %r14b
jle 0xceeb
movq (%r15,%rbp,8), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4120
incq %r12
cmpq %r12, %r13
jne 0xced4
incq %rbp
cmpq 0x10(%rsp), %rbp
jne 0xcecc
jmp 0xcf0e
movsbl 0x1(%rax), %esi
movsbl (%rax), %edx
callq 0xcaae
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::negate(double*&, double***&, double***&)
void FitBitSlicedAB::negate(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER*** &a_B) {
    if(this->pi != NULL) {
        for(NPAR i=0; i<this->nS; i++) a_PI[i] = -a_PI[i];
    }
    if(this->A  != NULL) {
        for(NPAR z=0; z<this->nZ; z++)
            for(NPAR i=0; i<this->nS; i++)
                for(NPAR j=0; j<this->nS; j++)
                    a_A[z][i][j] = -a_A[z][i][j];
    }
    if(this->B  != NULL) {
        for(NPAR z=0; z<this->nZ; z++)
            for(NPAR i=0; i<this->nS; i++)
                for(NPAR m=0; m<this->nO; m++)
                    a_B[z][i][m] = -a_B[z][i][m];
    }
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0xcf53
movsbq 0x1(%rdi), %rax
testq %rax, %rax
jle 0xcf53
movq (%rsi), %rsi
xorl %r8d, %r8d
movaps 0x27a03(%rip), %xmm0    # 0x34940
movsd (%rsi,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rsi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0xcf3d
cmpq $0x0, 0x18(%rdi)
je 0xcfad
movsbq 0x2(%rdi), %rax
testq %rax, %rax
jle 0xcfad
movzbl 0x1(%rdi), %esi
xorl %r8d, %r8d
movaps 0x279ce(%rip), %xmm0    # 0x34940
testb %sil, %sil
jle 0xcfa5
movq (%rdx), %r9
movq (%r9,%r8,8), %r9
xorl %r10d, %r10d
movq (%r9,%r10,8), %r11
xorl %ebx, %ebx
movsd (%r11,%rbx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r11,%rbx,8)
incq %rbx
cmpq %rbx, %rsi
jne 0xcf87
incq %r10
cmpq %rsi, %r10
jne 0xcf81
incq %r8
cmpq %rax, %r8
jne 0xcf72
cmpq $0x0, 0x20(%rdi)
je 0xd00e
movsbq 0x2(%rdi), %rax
testq %rax, %rax
jle 0xd00e
movzbl 0x1(%rdi), %edx
movzbl (%rdi), %esi
xorl %edi, %edi
movaps 0x27972(%rip), %xmm0    # 0x34940
testb %dl, %dl
jle 0xd006
movq (%rcx), %r8
xorl %r9d, %r9d
testb %sil, %sil
jle 0xcffe
movq (%r8,%rdi,8), %r10
movq (%r10,%r9,8), %r10
xorl %r11d, %r11d
movsd (%r10,%r11,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r10,%r11,8)
incq %r11
cmpq %r11, %rsi
jne 0xcfe8
incq %r9
cmpq %rdx, %r9
jne 0xcfd8
incq %rdi
cmpq %rax, %rdi
jne 0xcfce
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::destroy(double*&, double***&, double***&)
void FitBitSlicedAB::destroy(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER*** &a_B) {
    if(this->pi != NULL && a_PI != NULL) free(a_PI);
    if(this->A  != NULL && a_A  != NULL) free3D<NUMBER>(a_A, (NDAT)this->nZ, (NDAT)this->nS);
    if(this->B  != NULL && a_B  != NULL) free3D<NUMBER>(a_B, (NDAT)this->nZ, (NDAT)this->nS);
    a_PI = NULL;
    a_A  = NULL;
    a_B  = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x10(%rdi)
je 0xd338
movq (%r15), %rdi
testq %rdi, %rdi
je 0xd338
callq 0x42a0
cmpq $0x0, 0x18(%r12)
je 0xd359
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd359
movsbl 0x2(%r12), %esi
movsbl 0x1(%r12), %edx
callq 0xca4f
cmpq $0x0, 0x20(%r12)
je 0xd37a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd37a
movsbl 0x2(%r12), %esi
movsbl 0x1(%r12), %edx
callq 0xca4f
xorl %eax, %eax
movq %rax, (%r15)
movq %rax, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop