LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x96fa
movzbl 0x1(%rdi), %r8d
movq (%rsi), %rax
xorl %esi, %esi
testb %r8b, %r8b
cmovlel %esi, %r8d
movzbl %r8b, %r8d
movaps 0x2325c(%rip), %xmm0    # 0x2c940
cmpq %rsi, %r8
je 0x96fa
movsd (%rax,%rsi,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax,%rsi,8)
incq %rsi
jmp 0x96e4
cmpq $0x0, 0x18(%rdi)
je 0x9766
movzbl 0x2(%rdi), %r9d
movzbl 0x1(%rdi), %eax
xorl %esi, %esi
testb %al, %al
movl $0x0, %r8d
cmovgl %eax, %r8d
testb %r9b, %r9b
cmovlel %esi, %r9d
movzbl %r9b, %r9d
movaps 0x23216(%rip), %xmm0    # 0x2c940
cmpq %r9, %rsi
je 0x9766
xorl %r10d, %r10d
cmpq %r8, %r10
je 0x9761
movq (%rdx), %r11
xorl %ebx, %ebx
cmpq %rbx, %rax
je 0x975c
movq (%r11,%rsi,8), %r14
movq (%r14,%r10,8), %r14
movsd (%r14,%rbx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r14,%rbx,8)
incq %rbx
jmp 0x973c
incq %r10
jmp 0x9732
incq %rsi
jmp 0x972a
cmpq $0x0, 0x20(%rdi)
je 0x97bc
movl (%rdi), %eax
xorl %edx, %edx
testb %al, %al
cmovlel %edx, %eax
movzbl 0x1(%rdi), %esi
testb %sil, %sil
cmovlel %edx, %esi
movl $0xff, %edi
andl %edi, %esi
andl %edi, %eax
movaps 0x231b0(%rip), %xmm0    # 0x2c940
cmpq %rsi, %rdx
je 0x97bc
movq (%rcx), %rdi
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x97b7
movq (%rdi,%rdx,8), %r9
movsd (%r9,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r9,%r8,8)
incq %r8
jmp 0x979b
incq %rdx
jmp 0x9790
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9987
movq (%r15), %rdi
callq 0x4290
cmpq $0x0, 0x18(%r12)
je 0x99a8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x99a8
movsbl 0x2(%r12), %esi
movsbl 0x1(%r12), %edx
callq 0xa064
cmpq $0x0, 0x20(%r12)
je 0x99c3
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x99c3
movsbl 0x1(%r12), %esi
callq 0x7f2c
andq $0x0, (%r15)
andq $0x0, (%r14)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::add(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBitSlicedA::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 $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x8(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x30(%rsp), %r12
andq $0x0, (%r12)
movq %r12, %r8
callq 0x9ac6
leaq 0x28(%rsp), %r13
andq $0x0, (%r13)
leaq 0x20(%rsp), %r14
andq $0x0, (%r14)
leaq 0x18(%rsp), %r15
andq $0x0, (%r15)
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x9ac6
leaq 0x10(%rsp), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %rax
movq (%rax), %rdx
movq (%r12), %rcx
movq (%r13), %r8
movq (%r14), %r9
movq (%r15), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x98ce
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::checkConvergence(FitResult*)
bool FitBitSlicedA::checkConvergence(FitResult *fr) {

	NUMBER criterion = 0;
    bool res = false;
    switch (this->tol_mode) {
        case 'p':
            for(NPAR i=0; i<this->nS; i++)
                if(this->pi != NULL) criterion += pow( this->pi[i]-this->PIm1[i], 2 )/*:0*/;
            
            for(NPAR z=0; z<this->nZ; z++)
                for(NPAR i=0; i<this->nS; i++)
                {
                    for(NPAR j=0; (this->A != NULL) && j<this->nS; j++) {
                        criterion += pow(this->A[z][i][j] - this->Am1[z][i][j],2);
                    }
                    
                }
            for(NPAR i=0; i<this->nS; i++)
            {
                for(NPAR k=0; (this->B != NULL) && k<this->nO; k++) {
                    criterion += pow(this->B[i][k] - this->Bm1[i][k],2);
                }
            }
            res = sqrt(criterion) < this->tol; // double the truth or false
            break;
        case 'l':
            criterion = (fr->pOmid-fr->pO)/fr->ndat;
            res = criterion < this->tol;
            break;
    }
    return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl 0xf0(%rdi), %eax
cmpl $0x6c, %eax
je 0x9d54
cmpl $0x70, %eax
jne 0x9d69
movsbq 0x1(%rbx), %rcx
movq 0x10(%rbx), %rdx
movq 0x28(%rbx), %rsi
xorl %edi, %edi
testb %cl, %cl
movl $0x0, %eax
cmovgl %ecx, %eax
cltq
xorpd %xmm0, %xmm0
cmpq %rdi, %rax
je 0x9c97
testq %rdx, %rdx
je 0x9c92
movsd (%rdx,%rdi,8), %xmm1
subsd (%rsi,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdi
jmp 0x9c76
movzbl 0x2(%rbx), %r8d
movq 0x18(%rbx), %rdx
movq 0x30(%rbx), %rsi
xorl %edi, %edi
testb %r8b, %r8b
cmovlel %edi, %r8d
movzbl %r8b, %r8d
cmpq %r8, %rdi
je 0x9cfe
xorl %r9d, %r9d
cmpq %rax, %r9
je 0x9cf9
xorl %r10d, %r10d
testq %rdx, %rdx
je 0x9cf4
cmpq %rcx, %r10
jge 0x9cf4
movq (%rdx,%rdi,8), %r11
movq (%r11,%r9,8), %r11
movsd (%r11,%r10,8), %xmm1
movq (%rsi,%rdi,8), %r11
movq (%r11,%r9,8), %r11
subsd (%r11,%r10,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r10
jmp 0x9cc1
incq %r9
jmp 0x9cb9
incq %rdi
jmp 0x9cb1
movq 0x20(%rbx), %rcx
movq 0x38(%rbx), %rdx
movsbq (%rbx), %rsi
xorl %edi, %edi
cmpq %rax, %rdi
je 0x9d44
xorl %r8d, %r8d
testq %rcx, %rcx
je 0x9d3f
cmpq %rsi, %r8
jge 0x9d3f
movq (%rcx,%rdi,8), %r9
movsd (%r9,%r8,8), %xmm1
movq (%rdx,%rdi,8), %r9
subsd (%r9,%r8,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r8
jmp 0x9d14
incq %rdi
jmp 0x9d0c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9d6d
sqrtsd %xmm0, %xmm0
jmp 0x9d72
movsd 0x10(%rsi), %xmm0
subsd 0x18(%rsi), %xmm0
cvtsi2sdl 0x24(%rsi), %xmm1
divsd %xmm1, %xmm0
jmp 0x9d72
xorl %eax, %eax
jmp 0x9d81
callq 0x41a0
movsd 0xe8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
seta %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x18(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x10(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x8(%rsp), %r8
andq $0x0, (%r8)
callq 0x9ac6
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x9dc7
movq 0x18(%rsp), %rdi
movsbl 0x1(%rbx), %edx
callq 0x6d73
cmpq $0x0, 0x18(%rbx)
je 0x9dfc
movq 0x10(%rsp), %r14
xorl %r15d, %r15d
movsbq 0x2(%rbx), %rax
cmpq %rax, %r15
jge 0x9dfc
movq (%r14,%r15,8), %rdi
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rsi
movsbl 0x1(%rbx), %ecx
movl %ecx, %edx
callq 0x7062
incq %r15
jmp 0x9dd6
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x9e1f
movq 0x8(%rsp), %rdi
movsbl 0x1(%rbx), %edx
movsbl (%rbx), %ecx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7062
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
movq %rdi, %r15
testl %esi, %esi
cmovlel %r12d, %r14d
cmpq %r14, %r12
je 0xa0ad
xorl %r13d, %r13d
movq (%r15,%r12,8), %rdi
cmpq %r13, %rbx
je 0xa0a3
movq (%rdi,%r13,8), %rdi
callq 0x4290
incq %r13
jmp 0xa08c
callq 0x4290
incq %r12
jmp 0xa084
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4290
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13d
movl %esi, %r12d
movslq %edi, %rbp
pushq $0x8
popq %r14
movq %rbp, %rdi
movq %r14, %rsi
callq 0x4120
movq %rax, (%rsp)
movslq %r12d, %rax
xorl %r15d, %r15d
testl %eax, %eax
movl $0x0, %ebx
movq %rax, 0x8(%rsp)
cmovgl %eax, %ebx
movslq %r13d, %r13
testl %ebp, %ebp
cmovlel %r15d, %ebp
movq %rbp, 0x10(%rsp)
cmpq 0x10(%rsp), %r15
je 0xa14c
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4120
movq %rax, %rbp
movq (%rsp), %rax
movq %rbp, (%rax,%r15,8)
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0xa147
movq %r13, %rdi
movq %r14, %rsi
callq 0x4120
movq %rax, (%rbp,%r12,8)
incq %r12
jmp 0xa12d
incq %r15
jmp 0xa10b
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/./utils.h
// Function: void toZero3D<double>(double***, int, int, int)
void toZero3D(T*** ar, NDAT size1, NDAT size2, NDAT size3) {
    for(NDAT i=0; i<size1; i++)
        for(NDAT j=0; j<size2; j++)
            for(NDAT l=0; l<size3; l++)
                ar[i][j][l] = 0;
}

// Assembly:
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
testl %edx, %edx
cmovlel %eax, %edx
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rsi, %rax
je 0xa1a1
xorl %r8d, %r8d
cmpq %rdx, %r8
je 0xa19c
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0xa197
movq (%rdi,%rax,8), %r10
movq (%r10,%r8,8), %r10
andq $0x0, (%r10,%r9,8)
incq %r9
jmp 0xa180
incq %r8
jmp 0xa178
incq %rax
jmp 0xa170
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xa484
movq %rsi, %r12
movq (%rsi), %rdi
movsbl 0x1(%r14), %esi
testq %rdi, %rdi
je 0xa479
callq 0x9311
jmp 0xa484
movl %esi, %edi
callq 0x7dde
movq %rax, (%r12)
cmpq $0x0, 0x18(%r14)
je 0xa4b2
movq (%r15), %rdi
movsbl 0x2(%r14), %esi
movsbl 0x1(%r14), %edx
testq %rdi, %rdi
je 0xa4a6
movl %edx, %ecx
callq 0xa15f
jmp 0xa4b2
movl %esi, %edi
movl %edx, %esi
callq 0xa0be
movq %rax, (%r15)
cmpq $0x0, 0x20(%r14)
je 0xa4ed
movq (%rbx), %rdi
movsbl 0x2(%r14), %esi
movsbl 0x1(%r14), %edx
movsbl (%r14), %ecx
testq %rdi, %rdi
je 0xa4df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa15f
movl %esi, %edi
movl %edx, %esi
movl %ecx, %edx
callq 0xa0be
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0xa536
movzbl 0x1(%rdi), %r8d
movq (%rsi), %rax
xorl %esi, %esi
testb %r8b, %r8b
cmovlel %esi, %r8d
movzbl %r8b, %r8d
movaps 0x22420(%rip), %xmm0    # 0x2c940
cmpq %rsi, %r8
je 0xa536
movsd (%rax,%rsi,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax,%rsi,8)
incq %rsi
jmp 0xa520
cmpq $0x0, 0x18(%rdi)
je 0xa5a2
movzbl 0x2(%rdi), %r9d
movzbl 0x1(%rdi), %eax
xorl %esi, %esi
testb %al, %al
movl $0x0, %r8d
cmovgl %eax, %r8d
testb %r9b, %r9b
cmovlel %esi, %r9d
movzbl %r9b, %r9d
movaps 0x223da(%rip), %xmm0    # 0x2c940
cmpq %r9, %rsi
je 0xa5a2
xorl %r10d, %r10d
cmpq %r8, %r10
je 0xa59d
movq (%rdx), %r11
xorl %ebx, %ebx
cmpq %rbx, %rax
je 0xa598
movq (%r11,%rsi,8), %r14
movq (%r14,%r10,8), %r14
movsd (%r14,%rbx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r14,%rbx,8)
incq %rbx
jmp 0xa578
incq %r10
jmp 0xa56e
incq %rsi
jmp 0xa566
cmpq $0x0, 0x20(%rdi)
je 0xa61d
movzbl 0x2(%rdi), %eax
movzbl 0x1(%rdi), %edx
xorl %esi, %esi
testb %dl, %dl
cmovlel %esi, %edx
testb %al, %al
cmovlel %esi, %eax
movl $0xff, %r8d
andl %r8d, %eax
andl %r8d, %edx
movaps 0x22370(%rip), %xmm0    # 0x2c940
xorl %r8d, %r8d
cmpq %rax, %r8
je 0xa61d
movl (%rdi), %r9d
testb %r9b, %r9b
cmovlel %esi, %r9d
movzbl %r9b, %r9d
xorl %r10d, %r10d
cmpq %rdx, %r10
je 0xa618
movq (%rcx), %r11
xorl %ebx, %ebx
cmpq %rbx, %r9
je 0xa613
movq (%r11,%r8,8), %r14
movq (%r14,%r10,8), %r14
movsd (%r14,%rbx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r14,%rbx,8)
incq %rbx
jmp 0xa5f3
incq %r10
jmp 0xa5e9
incq %r8
jmp 0xa5d3
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa7f9
movq (%r15), %rdi
callq 0x4290
cmpq $0x0, 0x18(%r12)
je 0xa81a
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa81a
movsbl 0x2(%r12), %esi
movsbl 0x1(%r12), %edx
callq 0xa064
cmpq $0x0, 0x20(%r12)
je 0xa83b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa83b
movsbl 0x2(%r12), %esi
movsbl 0x1(%r12), %edx
callq 0xa064
andq $0x0, (%r15)
andq $0x0, (%r14)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::doLog10ScaleGentle(FIT_BIT_SLOT)
void FitBitSlicedAB::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);
//        doLog10Scale3DGentle(a_A,  this->A,  this->nZ, this->nS, this->nS);
	if(this->B  != NULL)
        for(NPAR z=0; z<this->nZ; z++)
            doLog10Scale2DGentle(a_B[z],  this->B[z], this->nS, this->nO);
//        doLog10Scale3DGentle(a_B,  this->B,  this->nZ, this->nS, this->nO);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x10(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x8(%rsp), %r8
andq $0x0, (%r8)
callq 0xa93e
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0xac55
movq 0x18(%rsp), %rdi
movsbl 0x1(%rbx), %edx
callq 0x6d73
cmpq $0x0, 0x18(%rbx)
je 0xac8a
movq 0x10(%rsp), %r14
xorl %r15d, %r15d
movsbq 0x2(%rbx), %rax
cmpq %rax, %r15
jge 0xac8a
movq (%r14,%r15,8), %rdi
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rsi
movsbl 0x1(%rbx), %ecx
movl %ecx, %edx
callq 0x7062
incq %r15
jmp 0xac64
cmpq $0x0, 0x20(%rbx)
je 0xacc0
movq 0x8(%rsp), %r14
xorl %r15d, %r15d
movsbq 0x2(%rbx), %rax
cmpq %rax, %r15
jge 0xacc0
movq (%r14,%r15,8), %rdi
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rsi
movsbl 0x1(%rbx), %edx
movsbl (%rbx), %ecx
callq 0x7062
incq %r15
jmp 0xac99
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/InputUtil.cpp
// Function: InputUtil::writeString(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void InputUtil::writeString(FILE *f, string str) {
    // Create char pointer from string.
    char* text = const_cast<char*>(str.c_str());
    // Find the length of the string.
    NDAT size = (NDAT)str.size();
    // Write the string's size to the file.
    fwrite(&size, sizeof(NDAT), 1, f);
    // Followed by the string itself.
    fwrite(text, 1, (size_t)size, f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
movl 0x8(%rsi), %eax
leaq 0x4(%rsp), %r15
movl %eax, (%r15)
pushq $0x4
popq %rsi
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x44b0
movslq (%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/InputUtil.cpp
// Function: InputUtil::readString[abi:cxx11](_IO_FILE*)
string InputUtil::readString(FILE *f) {
    // Create new string object to store the retrieved text and to return to the calling function.
    string str;
    // UInt for storing the string's size.
    NDAT size;
    // Read the size of the string from the file and store it in size.
    fread(&size, sizeof(NDAT), 1, f);
    // Create a char pointer for temporary storage.
    char* text = new char[size];
    // Read [size] number of characters from the string and store them in text.
    fread(text, 1, (size_t)size, f);
    // Store the contents of text in str.
    str = text;
    // Resize str to match the size else we get extra cruft (line endings methinks).
    str.resize((size_t)size);
    // Finally, return the string to the calling function.
    delete[] text;
    return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x4(%rsp), %r14
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x4380
movslq (%r14), %r12
movq %r12, %rdi
callq 0x4030
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x4380
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4330
movq %r14, %rdi
callq 0x42e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x40f0
movq %r14, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/InputUtil.cpp
// Function: InputUtil::writeInputMatrix(char const*, param*, int, data**)
void InputUtil::writeInputMatrix(const char *filename, struct param* p, NCAT xndat, struct data** x_data) {
//    FILE *fid = fopen(filename,"w");
//    if(fid == NULL) {
//        fprintf(stderr,"Can't write output model file %s\n",filename);
//        exit(1);
//    }
    
    std::ofstream file;
    file.open(filename);
    
    NDAT nmax = 0;
    for(NCAT x=0; x<xndat; x++)
        if(nmax < x_data[x]->n)
            nmax = x_data[x]->n;
    
    for(NCAT x=0; x<xndat; x++) {
        std::stringstream ss;
        for(NDAT t=0; t<nmax; t++) {
            
            if(t<x_data[x]->n) {
                ss << ((t>0)?" ":"") << (int)(1+p->dat_obs[ x_data[x]->ix[t] ]);
            } else {
                ss << " " << 0;
            }
        }
        ss << "\n";
        file << ss.str();
    } // for all groups in skill
    
//    fclose(fid);
    file.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp            # imm = 0x3B8
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
leaq 0x1b8(%rsp), %r13
movq %r13, %rdi
callq 0x4420
pushq $0x10
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x4060
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
xorl %r13d, %r13d
cmpq %rax, %r15
je 0xc832
movq (%rbx,%rax,8), %rcx
movl (%rcx), %ecx
cmpl %ecx, %r13d
cmovlel %ecx, %r13d
incq %rax
jmp 0xc81b
leaq 0x40(%rsp), %r12
xorl %r14d, %r14d
testl %r13d, %r13d
cmovlel %r14d, %r13d
leaq 0x20ab7(%rip), %rbp     # 0x2d2ff
movq %r15, (%rsp)
cmpq %r15, %r14
je 0xc916
leaq 0x30(%rsp), %rdi
callq 0x4150
xorl %r15d, %r15d
cmpq %r15, %r13
je 0xc8c6
movq (%rbx,%r14,8), %rax
movslq (%rax), %rax
cmpq %rax, %r15
jge 0xc8ac
testq %r15, %r15
movq %rbp, %rsi
leaq 0x213c7(%rip), %rax     # 0x2dc47
cmoveq %rax, %rsi
movq %r12, %rdi
callq 0x4200
movq 0x8(%rsp), %rcx
movq 0x870(%rcx), %rcx
movq (%rbx,%r14,8), %rdx
movq 0x10(%rdx), %rdx
movslq (%rdx,%r15,4), %rdx
movsbl (%rcx,%rdx), %esi
incl %esi
jmp 0xc8b9
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4200
xorl %esi, %esi
movq %rax, %rdi
callq 0x4430
incq %r15
jmp 0xc862
movq %r12, %rdi
leaq 0x1f98d(%rip), %rsi     # 0x2c25d
callq 0x4200
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x43e0
movq (%rsp), %r15
leaq 0x1b8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x41e0
leaq 0x10(%rsp), %rdi
callq 0x40f0
leaq 0x30(%rsp), %rdi
callq 0x4180
incq %r14
jmp 0xc84c
leaq 0x1b8(%rsp), %rdi
callq 0x4340
leaq 0x1b8(%rsp), %rdi
callq 0x4370
addq $0x3b8, %rsp            # imm = 0x3B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc959
jmp 0xc959
jmp 0xc95e
jmp 0xc95e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x40f0
jmp 0xc961
movq %rax, %rbx
jmp 0xc96b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4180
leaq 0x1b8(%rsp), %rdi
callq 0x4370
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::add(signed char)
void StripedArray<T>::add(T value) {
	if(this->size == (NDAT_MAX-1)) {
		fprintf(stderr, "Error! Maximum array size reached.\n");
		return;
	}
	
	// add stripe if necessary
	if( this->nstripes==0 || this->size_last_stripe==this->stripe_size)
		this->addStripe();
	// place data
	this->stripes[this->nstripes-1][this->size_last_stripe++] = value;
	this->size++;
}

// Assembly:
cmpl $0x7ffffffe, (%rdi)     # imm = 0x7FFFFFFE
je 0xc9ce
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0xc99f
movl 0xc(%rbx), %ecx
cmpl 0x4(%rbx), %ecx
jne 0xc9ad
movq %rbx, %rdi
callq 0xcdf8
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ecx
movq 0x10(%rbx), %rdx
cltq
movq -0x8(%rdx,%rax,8), %rax
leal 0x1(%rcx), %edx
movl %edx, 0xc(%rbx)
movslq %ecx, %rcx
movb %bpl, (%rax,%rcx)
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x2c603(%rip), %rax     # 0x38fd8
movq (%rax), %rcx
leaq 0x20922(%rip), %rdi     # 0x2d301
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
jmp 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<int>::toArray()
T* StripedArray<T>::toArray() {
    T *result = (T*)malloc( (size_t)this->size*sizeof(T));
    for(NDAT i=0; i<this->nstripes; i++) {
        T* dest = &result[ i*this->stripe_size ];
        size_t sz = sizeof(T)*( (i<(this->nstripes-1))?this->stripe_size:this->size_last_stripe );
        memcpy( dest, this->stripes[i], sz );  
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movslq (%rdi), %rdi
shlq $0x2, %rdi
callq 0x4300
movslq 0x8(%r14), %rcx
movslq 0x4(%r14), %r12
movq %rcx, 0x10(%rsp)
decq %rcx
movq %rcx, 0x8(%rsp)
movl 0xc(%r14), %ebp
movq 0x10(%r14), %rbx
movq %r12, %r15
shlq $0x2, %r12
xorl %r13d, %r13d
movq %rax, (%rsp)
movq %rax, %r14
cmpq 0x10(%rsp), %r13
jge 0xcba4
cmpq 0x8(%rsp), %r13
movl %ebp, %eax
cmovll %r15d, %eax
movslq %eax, %rdx
shlq $0x2, %rdx
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
callq 0x41c0
incq %r13
addq %r12, %r14
jmp 0xcb77
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::~StripedArray()
StripedArray<T>::~StripedArray() {
	for(NDAT i=0; i<this->nstripes;i++) {
//        if(this->complex)
//            for(NDAT j=0; j<( (i<(this->nstripes-1))?this->stripe_size:this->size_last_stripe );j++)
//                free(  (void *)(this->stripes[i][j]) );
		free(this->stripes[i]);
    }
	free(this->stripes);
//	for(NDAT i=0; i<this->nstripes;i++)
//		delete [] this->stripes[i];
//	delete [] this->stripes;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
cmpq %rax, %r14
jge 0xcb1f
movq (%rdi,%r14,8), %rdi
callq 0x4290
incq %r14
jmp 0xcb04
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4290
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::StripedArray(_IO_FILE*, int)
StripedArray<T>::StripedArray(FILE *f, NDAT N) {
	stripe_size = 20000;
//    complex = false;
	size = N;
	nstripes = (NDAT)ceil((double)N/stripe_size);
	size_last_stripe = (NDAT)fmod(N, stripe_size);
	stripes = (T **) calloc((size_t)nstripes, sizeof(T*));
    NDAT num;
    NDAT nread;
    for(NDAT i=0; i<nstripes; i++) {
        num = (i<(nstripes-1)?stripe_size:size_last_stripe);
        stripes[i] = (T*)calloc((size_t)num, sizeof(T)); // alloc data
        nread = (NDAT)fread (stripes[i], sizeof(T), (size_t)num, f);
        if(nread != num) {
            fprintf(stderr,"Error reading data from file\n");
            return;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4e20, 0x4(%rdi)      # imm = 0x4E20
movl %edx, (%rdi)
cvtsi2sd %edx, %xmm0
divsd 0x2036e(%rip), %xmm0    # 0x2cf80
callq 0x4090
cvttsd2si %xmm0, %eax
movl %eax, 0x8(%r14)
movl %ebp, %edi
movl $0x4e20, %esi           # imm = 0x4E20
callq 0xd406
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%r14)
movslq 0x8(%r14), %rdi
pushq $0x8
popq %rsi
callq 0x4120
movq %rax, 0x10(%r14)
xorl %r13d, %r13d
pushq $0x1
popq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0xccbe
decq %rax
xorl %ecx, %ecx
cmpq %rax, %r13
setge %cl
movslq 0x4(%r14,%rcx,8), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4120
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x4380
incq %r13
cmpl %eax, %r12d
je 0xcc4a
movq 0x2c33d(%rip), %rax     # 0x38fd8
movq (%rax), %rcx
leaq 0x206ca(%rip), %rdi     # 0x2d36f
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x44b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::addStripe()
void StripedArray<T>::addStripe() {
	if(this->size_last_stripe<this->stripe_size && this->nstripes>0) {
		fprintf(stderr, "Exception! You can only add stripes when none exits or previous is full.\n");
		return;
	}
	
	this->stripes = (T **) realloc(this->stripes,(size_t)(++this->nstripes)*sizeof(T*)); // add pointer
//	T** new_stripes = Calloc(T*, (this->nstripes));
//	memcpy(new_stripes, this->stripes, sizeof(T*)*this->nstripes );
//	free(this->stripes);
//	this->stripes = Malloc(T*,this->nstripes+1);
//	memcpy(this->stripes, new_stripes, sizeof(T*)*this->nstripes );
//	this->nstripes++;
//	free(new_stripes);
	
//	this->stripes[this->nstripes-1] = Calloc(T, (size_t)this->stripe_size); // alloc data
	this->stripes[this->nstripes-1] = (T*)calloc((size_t)this->stripe_size, sizeof(T)); // alloc data
	this->size_last_stripe = 0; // reset counter
}

// Assembly:
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
cmpl 0x4(%rdi), %ecx
setl %cl
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0xce59
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cltq
movq 0x10(%rdi), %rdi
leaq 0x1(%rax), %rcx
movl %ecx, 0x8(%rbx)
leaq 0x8(,%rax,8), %rsi
callq 0x4410
movq %rax, %r14
movq %rax, 0x10(%rbx)
movslq 0x4(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x4120
movslq 0x8(%rbx), %rcx
movq %rax, -0x8(%r14,%rcx,8)
andl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2c178(%rip), %rax     # 0x38fd8
movq (%rax), %rcx
leaq 0x204bb(%rip), %rdi     # 0x2d325
pushq $0x49
popq %rsi
pushq $0x1
popq %rdx
jmp 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/PULogistic.cpp
// Function: PULogistic::unite(double*, int, double*, int)
NUMBER PULogistic::unite(NUMBER* standard, NCAT nstandard, NUMBER* pooled, NCAT npooled) {
	NUMBER num = 1;
	NUMBER den = 1;
	NUMBER safe = 0;
	if(standard != NULL && nstandard > 0) {
		for(NCAT i=0; i<=nstandard; i++) {
			safe = safe01num(standard[i]);
			num *= 1 - safe;
			den *=     safe;
		}
	}
	if(pooled != NULL && npooled > 0) {
		for(NCAT i=0; i<=nstandard; i++) {
			safe = safe01num(pooled[i]);
			num *= 1 - safe;
			den *=     safe;
		}
	}
	return 1/( 1 + num/safe0num(den) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movq %rcx, %rbx
movl %edx, %r14d
testq %rsi, %rsi
sete %al
testl %edx, %edx
setle %cl
orb %al, %cl
jne 0xd4f0
movq %rsi, %r15
leal 0x1(%r14), %r12d
movapd 0x1f4bb(%rip), %xmm0    # 0x2c970
movapd %xmm0, (%rsp)
xorl %r13d, %r13d
cmpq %r13, %r12
je 0xd4fd
movsd (%r15,%r13,8), %xmm0
callq 0x67a5
movsd 0x1f41b(%rip), %xmm1    # 0x2c8f0
subsd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd (%rsp), %xmm0
mulpd %xmm1, %xmm0
movapd %xmm0, (%rsp)
incq %r13
jmp 0xd4bd
movapd 0x1f478(%rip), %xmm0    # 0x2c970
movapd %xmm0, (%rsp)
testq %rbx, %rbx
sete %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
jne 0xd545
movslq %r14d, %r14
xorl %r15d, %r15d
cmpq %r14, %r15
jg 0xd545
movsd (%rbx,%r15,8), %xmm0
callq 0x67a5
movsd 0x1f3c6(%rip), %xmm1    # 0x2c8f0
subsd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd (%rsp), %xmm0
mulpd %xmm1, %xmm0
movapd %xmm0, (%rsp)
incq %r15
jmp 0xd512
movapd (%rsp), %xmm0
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
callq 0x67cb
movapd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x1f38c(%rip), %xmm0    # 0x2c8f0
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/PULogistic.cpp
// Function: PULogistic::derivativePair(double, double, signed char)
NUMBER PULogistic::derivativePair(NUMBER standard, NUMBER pooled, NPAR which) {
	NUMBER united = pair(standard, pooled);
	// which 0-standard, 1-pooled
	NUMBER deriv_param = 0;
	if(which==0) {
		NUMBER safe_standard = safe01num(standard);
		deriv_param = 1 / ( safe_standard * (1 - safe_standard) );
	} else if(which==1) {
		NUMBER safe_pooled   = safe01num(pooled);
		deriv_param = 1 / (   safe_pooled * (1 -   safe_pooled) );
	}
	return united * (1-united) * deriv_param;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq (%rdi), %rax
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq *(%rax)
movapd %xmm0, %xmm2
testl %ebx, %ebx
je 0xd5af
xorpd %xmm1, %xmm1
cmpl $0x1, %ebx
jne 0xd5db
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm2, (%rsp)
callq 0x67a5
movsd 0x1f32a(%rip), %xmm1    # 0x2c8f0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movsd (%rsp), %xmm2
movsd 0x1f30d(%rip), %xmm0    # 0x2c8f0
subsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/PULogistic.cpp
// Function: PULogistic::derivativeUnite(double*, int, double*, int, signed char, int)
NUMBER PULogistic::derivativeUnite(NUMBER* standard, NCAT nstandard, NUMBER* pooled, NCAT npooled, NPAR which, NCAT index) {
	NUMBER united = unite(standard, nstandard, pooled, npooled);
	// which 0-standard, 1-pooled
	NUMBER deriv_param = 0;
	if(which==0) {
		NUMBER safe_standard = safe01num(standard[index]);
		deriv_param = 1 / ( safe_standard * (1 - safe_standard) );
	} else if(which==1) {
		NUMBER safe_pooled   = safe01num(pooled[index]);
		deriv_param = 1 / (   safe_pooled * (1 -   safe_pooled) );
	}
	return united * (1-united) * deriv_param;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebp
movq %rcx, %rbx
movq %rsi, %r14
movq (%rdi), %rax
callq *0x8(%rax)
movapd %xmm0, %xmm2
testl %ebp, %ebp
je 0xd621
xorpd %xmm1, %xmm1
cmpl $0x1, %ebp
jne 0xd655
movq %rbx, %r14
movslq 0x30(%rsp), %rax
movsd (%r14,%rax,8), %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x67a5
movsd 0x1f2b1(%rip), %xmm1    # 0x2c8f0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movsd 0x8(%rsp), %xmm2
movsd 0x1f293(%rip), %xmm0    # 0x2c8f0
subsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/PULogistic.cpp
// Function: PULogistic::derivativeUnite(double, double, double, signed char)
NUMBER PULogistic::derivativeUnite(NUMBER united, NUMBER standard, NUMBER pooled, NPAR which) {
	// which 0-standard, 1-pooled
	NUMBER deriv_param = 0;
	if(which==0) {
		NUMBER safe_standard = safe01num(standard);
		deriv_param = 1 / ( safe_standard * (1 - safe_standard) );
	} else if(which==1) {
		NUMBER safe_pooled   = safe01num(pooled);
		deriv_param = 1 / (   safe_pooled * (1 -   safe_pooled) );
	}
	return united * (1-united) * deriv_param;
}

// Assembly:
pushq %rax
movapd %xmm0, %xmm3
testl %esi, %esi
je 0xd688
xorpd %xmm1, %xmm1
cmpl $0x1, %esi
jne 0xd6b3
movapd %xmm2, %xmm1
movapd %xmm1, %xmm0
movsd %xmm3, (%rsp)
callq 0x67a5
movsd (%rsp), %xmm3
movsd 0x1f24d(%rip), %xmm1    # 0x2c8f0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movsd 0x1f235(%rip), %xmm0    # 0x2c8f0
subsd %xmm3, %xmm0
mulsd %xmm3, %xmm0
mulsd %xmm1, %xmm0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/PUCorbettianAdditive.cpp
// Function: PUCorbettianAdditive::sumOdds(double*, int, double*, int)
NUMBER PUCorbettianAdditive::sumOdds(NUMBER* standard, NCAT nstandard, NUMBER* pooled, NCAT npooled) {
	NUMBER sum_odds = 0;
	if(standard != NULL && nstandard > 0) {
		for(NCAT i=0; i<=nstandard; i++) {
			sum_odds += standard[i] / safe0num(1-standard[i]);
		}
	}
	if(pooled != NULL && npooled > 0) {
		for(NCAT i=0; i<=nstandard; i++) {
			sum_odds += pooled[i];
		}
	}
	return sum_odds;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movq %rcx, %rbx
movl %edx, %r14d
testq %rsi, %rsi
sete %al
testl %edx, %edx
setle %cl
xorpd %xmm0, %xmm0
orb %al, %cl
jne 0xd78f
movq %rsi, %r15
leal 0x1(%r14), %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0xd78f
movsd (%r15,%r13,8), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd 0x1f183(%rip), %xmm0    # 0x2c8f0
subsd %xmm1, %xmm0
callq 0x67cb
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r13
jmp 0xd74e
testq %rbx, %rbx
sete %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
jne 0xd7b2
movslq %r14d, %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jg 0xd7b2
addsd (%rbx,%rcx,8), %xmm0
incq %rcx
jmp 0xd7a3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/PUCorbettianAdditive.cpp
// Function: PUCorbettianAdditive::derivativeUnite(double*, int, double*, int, signed char, int)
NUMBER PUCorbettianAdditive::derivativeUnite(NUMBER* standard, NCAT nstandard, NUMBER* pooled, NCAT npooled, NPAR which, NCAT index) {
	NUMBER sum_odds = sumOdds(standard, nstandard, pooled, npooled);
	// which 0-standard
	// \frac{1}{ (1+O_{ x_{ i },g_{ j } }^{ add } )^2 } \frac { 1 }{ (1-x_{ i })^2 }
	// which 1-pooled
	// \frac{1}{ (1+O_{ x_{ i },g_{ j } }^{ add } )2 }
	return 1 / ( pow(1+sum_odds,2) ) * ((which==0) ? ( 1/(pow( safe0num(1-standard[index]) ,2)) ) : 1 );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %rsi, %rbx
callq 0xd71a
movapd %xmm0, %xmm1
movsd 0x1f088(%rip), %xmm0    # 0x2c8f0
movapd %xmm0, %xmm2
testb %bpl, %bpl
jne 0xd8aa
movslq 0x20(%rsp), %rax
movsd 0x1f072(%rip), %xmm0    # 0x2c8f0
subsd (%rbx,%rax,8), %xmm0
movsd %xmm1, (%rsp)
callq 0x67cb
movsd 0x1f05b(%rip), %xmm2    # 0x2c8f0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm2
movsd 0x1f046(%rip), %xmm0    # 0x2c8f0
addsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::HMMProblem(param*)
HMMProblem::HMMProblem(struct param *param) {
    NPAR i;
    switch (param->structure) {
        case STRUCTURE_SKILL: // Expectation Maximization (Baum-Welch)
            for(i=0; i<3; i++) this->sizes[i] = param->nK;
            this->n_params = param->nK * 4;
            break;
//        case STRUCTURE_GROUP: // Gradient Descent by group
//            for(i=0; i<3; i++) this->sizes[i] = param->nG;
//            this->n_params = param->nG * 4;
//            break;
        default:
            fprintf(stderr,"Structure specified is not supported and should have been caught earlier\n");
            break;
    }
    init(param);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2ac2f(%rip), %rax     # 0x385b8
movq %rax, (%rdi)
cmpb $0x1, 0x3e(%rsi)
jne 0xd9c4
xorl %ecx, %ecx
movl 0x8c0(%rbx), %edx
cmpq $0x3, %rcx
je 0xd9aa
movl %edx, 0xc(%r14,%rcx,4)
incq %rcx
jmp 0xd994
shll $0x2, %edx
movl %edx, 0x8(%r14)
movq 0x70(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0x2b60d(%rip), %rax     # 0x38fd8
movq (%rax), %rcx
leaq 0x1fa0c(%rip), %rdi     # 0x2d3e1
pushq $0x49
popq %rsi
pushq $0x1
popq %rdx
callq 0x44b0
movq (%r14), %rax
jmp 0xd9b1
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::checkPIABConstraints(double*, double**, double**)
bool HMMProblem::checkPIABConstraints(NUMBER* a_PI, NUMBER** a_A, NUMBER** a_B) {
	NPAR i, j;
	// check values
	NUMBER sum_pi = 0.0;
	NUMBER sum_a_row[this->p->nS];
	NUMBER sum_b_row[this->p->nS];
	for(i=0; i<this->p->nS; i++) {
		sum_a_row[i] = 0.0;
		sum_b_row[i] = 0.0;
	}
	
	for(i=0; i<this->p->nS; i++) {
		if( a_PI[i]>1.0 || a_PI[i]<0.0)
			return false;
		sum_pi += a_PI[i];
		for(j=0; j<this->p->nS; j++) {
			if( a_A[i][j]>1.0 || a_A[i][j]<0.0)
				return false;
			sum_a_row[i] += a_A[i][j];
		}// all states 2
		for(int m=0; m<this->p->nO; m++) {
			if( a_B[i][m]>1.0 || a_B[i][m]<0.0)
				return false;
			sum_b_row[i] += a_B[i][m];
		}// all observations
	}// all states
	if(sum_pi!=1.0)
		return false;
	for(i=0; i<this->p->nS; i++)
		if( sum_a_row[i]!=1.0 || sum_b_row[i]!=1.0)
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x88(%rdi), %r10
movzbl 0x8b8(%r10), %r11d
leal 0xf(,%r11,8), %eax
andl $-0x10, %eax
movq %rsp, %rdi
subq %rax, %rdi
movq %rdi, %rsp
movq %rsp, %r8
subq %rax, %r8
movq %r8, %rsp
xorl %eax, %eax
testb %r11b, %r11b
movl %r11d, %r9d
cmovlel %eax, %r9d
cmpq %rax, %r9
je 0xdf27
andq $0x0, (%rdi,%rax,8)
andq $0x0, (%r8,%rax,8)
incq %rax
jmp 0xdf13
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
movsd 0x1e9bb(%rip), %xmm0    # 0x2c8f0
xorl %r14d, %r14d
xorpd %xmm2, %xmm2
cmpq %r9, %r14
je 0xdfe0
movsd (%rsi,%r14,8), %xmm3
xorl %eax, %eax
ucomisd %xmm0, %xmm3
ja 0xdfee
ucomisd %xmm3, %xmm1
ja 0xdfee
addsd %xmm3, %xmm2
xorl %r15d, %r15d
cmpq %r15, %r11
je 0xdf96
movq (%rdx,%r14,8), %rax
movsd (%rax,%r15,8), %xmm3
xorl %eax, %eax
ucomisd %xmm0, %xmm3
ja 0xdfee
ucomisd %xmm3, %xmm1
ja 0xdfee
addsd (%rdi,%r14,8), %xmm3
movsd %xmm3, (%rdi,%r14,8)
incq %r15
jmp 0xdf68
movzbl 0x8b9(%r10), %eax
testb %al, %al
cmovlel %ebx, %eax
movzbl %al, %r15d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0xdfd8
movq (%rcx,%r14,8), %rax
movsd (%rax,%r12,8), %xmm3
xorl %eax, %eax
ucomisd %xmm0, %xmm3
ja 0xdfee
ucomisd %xmm3, %xmm1
ja 0xdfee
addsd (%r8,%r14,8), %xmm3
movsd %xmm3, (%r8,%r14,8)
incq %r12
jmp 0xdfaa
incq %r14
jmp 0xdf3c
ucomisd 0x1e908(%rip), %xmm2    # 0x2c8f0
jne 0xdfec
jnp 0xdffb
xorl %eax, %eax
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
cmpq %rcx, %r9
sete %al
je 0xdfee
movsd (%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0xdfee
jp 0xdfee
movsd (%r8,%rcx,8), %xmm1
incq %rcx
ucomisd %xmm0, %xmm1
jne 0xdfee
jnp 0xdffd
jmp 0xdfee
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::readModel(char const*, bool)
void HMMProblem::readModel(const char *filename, bool overwrite) {
	FILE *fid = fopen(filename,"r");
	if(fid == NULL)
	{
		fprintf(stderr,"Can't read model file %s\n",filename);
		exit(1);
	}
	int max_line_length = 1024;
	char *line = Malloc(char,(size_t)max_line_length);
	NDAT line_no = 0;
    struct param initparam;
    set_param_defaults(&initparam);
    
    //
    // read solver info
    //
    if(overwrite)
        readSolverInfo(fid, this->p, &line_no);
    else
        readSolverInfo(fid, &initparam, &line_no);
    //
    // read model
    //
    readModelBody(fid, &initparam, &line_no, overwrite);
		
	fclose(fid);
	free(line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x9b8, %rsp            # imm = 0x9B8
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1e002(%rip), %rsi     # 0x2c044
movq %r15, %rdi
callq 0x4280
testq %rax, %rax
je 0xe0b1
movq %rax, %rbx
andl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x7532
testb %bpl, %bpl
je 0xe06f
movq 0x88(%r14), %rsi
jmp 0xe074
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x7a11
movq (%r14), %rax
movzbl %bpl, %r8d
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x68(%rax)
movq %rbx, %rdi
callq 0x4210
addq $0x9b8, %rsp            # imm = 0x9B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2af20(%rip), %rax     # 0x38fd8
movq (%rax), %rdi
leaq 0x1df84(%rip), %rsi     # 0x2c046
movq %r15, %rdx
xorl %eax, %eax
callq 0x4350
pushq $0x1
popq %rdi
callq 0x42a0
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::destroy()
void HMMProblem::destroy() {
	// destroy model data
    if(this->null_obs_ratio != NULL) free(this->null_obs_ratio);
	if(this->pi != NULL) free2D<NUMBER>(this->pi, this->sizes[0]);
	if(this->A  != NULL) free3D<NUMBER>(this->A,  this->sizes[1], this->p->nS);
	if(this->B  != NULL) free3D<NUMBER>(this->B,  this->sizes[2], this->p->nS);
	if(this->lbPI!=NULL) free(this->lbPI);
	if(this->ubPI!=NULL) free(this->ubPI);
	if(this->lbA!=NULL) free2D<NUMBER>(this->lbA, this->p->nS);
	if(this->ubA!=NULL) free2D<NUMBER>(this->ubA, this->p->nS);
	if(this->lbB!=NULL) free2D<NUMBER>(this->lbB, this->p->nS);
	if(this->ubB!=NULL) free2D<NUMBER>(this->ubB, this->p->nS);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x4290
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xe11a
movl 0xc(%rbx), %esi
callq 0x7f2c
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xe139
movl 0x10(%rbx), %esi
movq 0x88(%rbx), %rax
movsbl 0x8b8(%rax), %edx
callq 0xa064
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xe158
movl 0x14(%rbx), %esi
movq 0x88(%rbx), %rax
movsbl 0x8b8(%rax), %edx
callq 0xa064
movq 0x50(%rbx), %rdi
callq 0x4290
movq 0x68(%rbx), %rdi
callq 0x4290
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xe186
movq 0x88(%rbx), %rax
movsbl 0x8b8(%rax), %esi
callq 0x7f2c
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0xe1a2
movq 0x88(%rbx), %rax
movsbl 0x8b8(%rax), %esi
callq 0x7f2c
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xe1be
movq 0x88(%rbx), %rax
movsbl 0x8b8(%rax), %esi
callq 0x7f2c
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0xe1db
movq 0x88(%rbx), %rax
movsbl 0x8b8(%rax), %esi
popq %rbx
jmp 0x7f2c
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::getPI(int)
NUMBER* HMMProblem::getPI(NCAT x) {
	if( x > (this->sizes[0]-1) ) {
		fprintf(stderr,"While accessing PI, skill index %d exceeded last index of the data %d.\n", x, this->sizes[0]-1);
		exit(1);
	}
	return this->pi[x];
}

// Assembly:
movl %esi, %edx
movl 0xc(%rdi), %ecx
cmpl %esi, %ecx
jle 0xe20d
movq 0x38(%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
retq
pushq %rax
decl %ecx
movq 0x2adc1(%rip), %rax     # 0x38fd8
movq (%rax), %rdi
leaq 0x1f22b(%rip), %rsi     # 0x2d44c
xorl %eax, %eax
callq 0x4350
pushq $0x1
popq %rdi
callq 0x42a0
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::getA(int)
NUMBER** HMMProblem::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:
movl %esi, %edx
movl 0x10(%rdi), %ecx
cmpl %esi, %ecx
jle 0xe245
movq 0x40(%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
retq
pushq %rax
decl %ecx
movq 0x2ad89(%rip), %rax     # 0x38fd8
movq (%rax), %rdi
leaq 0x1f23b(%rip), %rsi     # 0x2d494
xorl %eax, %eax
callq 0x4350
pushq $0x1
popq %rdi
callq 0x42a0
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::getB(int)
NUMBER** HMMProblem::getB(NCAT x) {
	if( x > (this->sizes[2]-1) ) {
		fprintf(stderr,"While accessing B, skill index %d exceeded last index of the data %d.\n", x, this->sizes[2]-1);
		exit(1);
	}
	return this->B[x];
}

// Assembly:
movl %esi, %edx
movl 0x14(%rdi), %ecx
cmpl %esi, %ecx
jle 0xe27d
movq 0x48(%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
retq
pushq %rax
decl %ecx
movq 0x2ad51(%rip), %rax     # 0x38fd8
movq (%rax), %rdi
leaq 0x1f24a(%rip), %rsi     # 0x2d4db
xorl %eax, %eax
callq 0x4350
pushq $0x1
popq %rdi
callq 0x42a0