LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: myudelson[P]hmm-scalable/HMMProblemPiGK.cpp
// Function: HMMProblemPiGK::HMMProblemPiGK(param*)
HMMProblemPiGK::HMMProblemPiGK(struct param *param) {
    for(NPAR i=0; i<3; i++) this->sizes[i] = param->nK;
//    this->sizes = {param->nK, param->nK, param->nK};
    this->n_params = param->nK * 4 + param->nG;
    init(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x194e0
movq -0x30(%rbp), %rax
leaq 0x32780(%rip), %rcx     # 0x5a638
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3, %eax
jge 0x27eed
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c0(%rcx), %edx
movsbq -0x11(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,4)
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x27ec3
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8bc(%rax), %edx
movl 0x8c0(%rax), %eax
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,4), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x27f1a
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1a300
movq -0x20(%rbp), %rdi
callq 0x5540
nop
// File: myudelson[P]hmm-scalable/HMMProblemPiGK.cpp
// Function: HMMProblemPiGK::getPIk(int)
NUMBER* HMMProblemPiGK::getPIk(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing PI_k, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->pi[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x28897
movq -0x18(%rbp), %rax
movq 0x3276f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x28048(%rip), %rsi     # 0x508ce
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiGK.cpp
// Function: HMMProblemPiGK::getPIg(int)
NUMBER* HMMProblemPiGK::getPIg(NCAT x) {
	if( x > (this->p->nG-1) ) {
		fprintf(stderr,"While accessing PI_g, skill index %d exceeded last index of the data %d.\n", x, this->p->nG-1);
		exit(1);
	}
	return this->PIg[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x28917
movq -0x18(%rbp), %rax
movq 0x326ef(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8bc(%rax), %ecx
subl $0x1, %ecx
leaq 0x28012(%rip), %rsi     # 0x50918
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: myudelson[P]hmm-scalable/HMMProblemPiGK.cpp
// Function: HMMProblemPiGK::getB(data*, signed char, signed char)
NUMBER HMMProblemPiGK::getB(struct data* dt, NPAR i, NPAR m) {
    // special attention for "unknonw" observations, i.e. the observation was there but we do not know what it is
    // in this case we simply return 1, effectively resulting in no change in \alpha or \beta vatiables
    if(m<0)
        return 1;
    return this->B[dt->k][i][m];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jge 0x28a16
movsd 0x26ff9(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x8(%rbp)
jmp 0x28a42
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x19(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x1a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiGK.cpp
// Function: HMMProblemPiGK::fit()
void HMMProblemPiGK::fit() {
    NUMBER* loglik_rmse = init1D<NUMBER>(2);
    FitNullSkill(loglik_rmse, false /*do not need RMSE/SE*/);
    if(this->p->structure == STRUCTURE_PIgk) {
        loglik_rmse[0] += GradientDescent();
    } else {
        fprintf(stderr,"Solver specified is not supported.\n");
        exit(1);
    }
    this->neg_log_lik = loglik_rmse[0];
    free(loglik_rmse);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0xc410
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1e830
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x3e(%rax), %eax
cmpl $0x4, %eax
jne 0x29330
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x29352
movq 0x31ca1(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x27225(%rip), %rsi     # 0x50566
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x5380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiGKww.cpp
// Function: HMMProblemPiGKww::init(param*)
void HMMProblemPiGKww::init(struct param *param){
//    HMMProblemPiGK::init(param);
    this->ww = init1D<NUMBER>(3);
	this->ww[0] = 0.5;//1;
	this->ww[1] = 0.5;//1;
    this->ww[2] = 0;//0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x3, %edi
callq 0xc410
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x98(%rax)
movq 0x98(%rax), %rcx
movsd 0x24c39(%rip), %xmm0    # 0x4fa78
movsd %xmm0, (%rcx)
movq 0x98(%rax), %rcx
movsd 0x24c26(%rip), %xmm0    # 0x4fa78
movsd %xmm0, 0x8(%rcx)
movq 0x98(%rax), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiGKww.cpp
// Function: HMMProblemPiGKww::computeGradients(FitBit*)
NDAT HMMProblemPiGKww::computeGradients(FitBit *fb){
    fb->toZero(FBS_GRAD);
    
    NDAT ndat = computeAlphaAndPOParam(fb->xndat, fb->x_data);
    computeBeta(fb->xndat, fb->x_data);

    /*vv diff vv*/
    if(fb->pi != NULL && this->p->block_fitting[0]==0) setGradPI(fb);
    if(fb->pi != NULL && this->p->block_fitting[0]==0) setGradWW(fb);
    /*^^ diff ^^*/

    if(fb->A  != NULL && this->p->block_fitting[1]==0) setGradA(fb);
    if(fb->B  != NULL && this->p->block_fitting[2]==0) setGradB(fb);
    return ndat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0xdff0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xe8(%rax), %esi
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdx
callq 0x1b0c0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xe8(%rax), %esi
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdx
callq 0x1b690
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2be35
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x981(%rax), %eax
cmpl $0x0, %eax
jne 0x2be35
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2be68
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x981(%rax), %eax
cmpl $0x0, %eax
jne 0x2be68
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0xc8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2be98
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x982(%rax), %eax
cmpl $0x0, %eax
jne 0x2be98
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2bec8
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x983(%rax), %eax
cmpl $0x0, %eax
jne 0x2bec8
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemAGK.cpp
// Function: HMMProblemAGK::HMMProblemAGK(param*)
HMMProblemAGK::HMMProblemAGK(struct param *param) {
    this->sizes[0] = param->nK;
    this->sizes[1] = param->nK;
    this->sizes[2] = param->nK;
    this->n_params = param->nK * 4 + param->nG;
    init(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x194e0
movq -0x28(%rbp), %rdi
leaq 0x2cc98(%rip), %rax     # 0x5a830
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0xc(%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0x14(%rdi)
movq -0x10(%rbp), %rax
movl 0x8bc(%rax), %edx
movl 0x8c0(%rax), %eax
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,4), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x2dbeb
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1a300
movq -0x18(%rbp), %rdi
callq 0x5540
nop
// File: myudelson[P]hmm-scalable/HMMProblemAGK.cpp
// Function: HMMProblemAGK::destroy()
void HMMProblemAGK::destroy() {
	// destroy model data
    if( this->Ag != NULL) {
        free3D<NUMBER>(this->Ag, this->p->nG, this->p->nS);
        this->Ag = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x90(%rax)
je 0x2e508
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x88(%rax), %rcx
movl 0x8bc(%rcx), %esi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %edx
callq 0x11290
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/HMMProblemAGK.cpp
// Function: HMMProblemAGK::getPI(int)
NUMBER* HMMProblemAGK::getPI(NCAT x) { // same as getPIk(x)
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing PI_k, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->pi[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2e5f7
movq -0x18(%rbp), %rax
movq 0x2ca0f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x222e8(%rip), %rsi     # 0x508ce
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemAGK.cpp
// Function: HMMProblemAGK::getA(int)
NUMBER** HMMProblemAGK::getA(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing A, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->A[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2e677
movq -0x18(%rbp), %rax
movq 0x2c98f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x21e72(%rip), %rsi     # 0x504d8
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemAGK.cpp
// Function: HMMProblemAGK::getB(int)
NUMBER** HMMProblemAGK::getB(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing B, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->B[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2e6f7
movq -0x18(%rbp), %rax
movq 0x2c90f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x21e39(%rip), %rsi     # 0x5051f
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemAGK.cpp
// Function: HMMProblemAGK::getAg(int)
NUMBER** HMMProblemAGK::getAg(NCAT x) {
	if( x > (this->p->nG-1) ) {
		fprintf(stderr,"While accessing A, skill index %d exceeded last index of the data %d.\n", x, this->p->nG-1);
		exit(1);
	}
	return this->Ag[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2e7f7
movq -0x18(%rbp), %rax
movq 0x2c80f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8bc(%rax), %ecx
subl $0x1, %ecx
leaq 0x21cf2(%rip), %rsi     # 0x504d8
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: myudelson[P]hmm-scalable/HMMProblemAGK.cpp
// Function: HMMProblemAGK::fit()
void HMMProblemAGK::fit() {
    NUMBER* loglik_rmse = init1D<NUMBER>(2);
    FitNullSkill(loglik_rmse, false /*do not need RMSE/SE*/);
    if(this->p->structure==STRUCTURE_Agk)
        loglik_rmse[0] += GradientDescent();
    else {
        fprintf(stderr,"Solver specified is not supported.\n");
        exit(1);
    }
    this->neg_log_lik = loglik_rmse[0];
    free(loglik_rmse);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0xc410
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1e830
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x3e(%rax), %eax
cmpl $0x6, %eax
jne 0x2f2f0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x2f312
movq 0x2bce1(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x21265(%rip), %rsi     # 0x50566
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x5380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiAGK.cpp
// Function: HMMProblemPiAGK::HMMProblemPiAGK(param*)
HMMProblemPiAGK::HMMProblemPiAGK(struct param *param) {
//    this->sizes = {param->nK, param->nK, param->nK};
    this->sizes[0] = param->nK;
    this->sizes[1] = param->nK;
    this->sizes[2] = param->nK;
    this->n_params = param->nK * 4 + param->nG * 2;
    init(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x194e0
movq -0x28(%rbp), %rdi
leaq 0x29b38(%rip), %rax     # 0x5a900
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0xc(%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0x14(%rdi)
movq -0x10(%rbp), %rax
movl 0x8bc(%rax), %edx
movl 0x8c0(%rax), %eax
addl %edx, %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,4), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x30e1d
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1a300
movq -0x18(%rbp), %rdi
callq 0x5540
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiAGK.cpp
// Function: HMMProblemPiAGK::getPIk(int)
NUMBER* HMMProblemPiAGK::getPIk(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing PI_k, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->pi[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x31a57
movq -0x18(%rbp), %rax
movq 0x295af(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x1ee88(%rip), %rsi     # 0x508ce
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiAGK.cpp
// Function: HMMProblemPiAGK::getAk(int)
NUMBER** HMMProblemPiAGK::getAk(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing A, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->A[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x31bc7
movq -0x18(%rbp), %rax
movq 0x2943f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x1e922(%rip), %rsi     # 0x504d8
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiAGK.cpp
// Function: HMMProblemPiAGK::getAg(int)
NUMBER** HMMProblemPiAGK::getAg(NCAT x) {
	if( x > (this->p->nG-1) ) {
		fprintf(stderr,"While accessing A, skill index %d exceeded last index of the data %d.\n", x, this->p->nG-1);
		exit(1);
	}
	return this->Ag[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x31c47
movq -0x18(%rbp), %rax
movq 0x293bf(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8bc(%rax), %ecx
subl $0x1, %ecx
leaq 0x1e8a2(%rip), %rsi     # 0x504d8
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: myudelson[P]hmm-scalable/HMMProblemPiAGK.cpp
// Function: HMMProblemPiAGK::fit()
void HMMProblemPiAGK::fit() {
    NUMBER* loglik_rmse = init1D<NUMBER>(2);
    FitNullSkill(loglik_rmse, false /*do not need RMSE/SE*/);
    if(this->p->structure==STRUCTURE_PIAgk) {
        loglik_rmse[0] += GradientDescent();
    } else {
        fprintf(stderr,"Solver specified is not supported.\n");
        exit(1);
    }
    this->neg_log_lik = loglik_rmse[0];
    free(loglik_rmse);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0xc410
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1e830
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x3e(%rax), %eax
cmpl $0x5, %eax
jne 0x32a20
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x32a42
movq 0x285b1(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x1db35(%rip), %rsi     # 0x50566
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x5380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::HMMProblemPiABGK(param*)
HMMProblemPiABGK::HMMProblemPiABGK(struct param *param) {
    //    this->sizes = {param->nK, param->nK, param->nK};
    this->sizes[0] = param->nK;
    this->sizes[1] = param->nK;
    this->sizes[2] = param->nK;
    this->n_params = param->nK * 4 + param->nG * 4;
    init(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x194e0
movq -0x28(%rbp), %rdi
leaq 0x263c8(%rip), %rax     # 0x5a9d0
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0xc(%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %eax
movl %eax, 0x14(%rdi)
movq -0x10(%rbp), %rax
movl 0x8bc(%rax), %edx
movl 0x8c0(%rax), %eax
shll $0x2, %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,4), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x3465e
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1a300
movq -0x18(%rbp), %rdi
callq 0x5540
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::destroy()
void HMMProblemPiABGK::destroy() {
	// destroy model data - only additional stuff
	free2D<NUMBER>(this->PIg, this->p->nG);
	free3D<NUMBER>(this->Ag, this->p->nG, this->p->nS);
	free3D<NUMBER>(this->Bg, this->p->nG, this->p->nS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x90(%rax), %rdi
movq 0x88(%rax), %rax
movl 0x8bc(%rax), %esi
callq 0xc7f0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
movq 0x88(%rax), %rcx
movl 0x8bc(%rcx), %esi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %edx
callq 0x11290
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
movq 0x88(%rax), %rcx
movl 0x8bc(%rcx), %esi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %edx
callq 0x11290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::getA(int)
NUMBER** HMMProblemPiABGK::getA(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing A_k, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->A[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x35277
movq -0x18(%rbp), %rax
movq 0x25d8f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x1b8a0(%rip), %rsi     # 0x50b06
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::getB(int)
NUMBER** HMMProblemPiABGK::getB(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing B_k, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->B[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x352f7
movq -0x18(%rbp), %rax
movq 0x25d0f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x1b869(%rip), %rsi     # 0x50b4f
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::getAk(int)
NUMBER** HMMProblemPiABGK::getAk(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing A_k, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->A[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x35477
movq -0x18(%rbp), %rax
movq 0x25b8f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x1b6a0(%rip), %rsi     # 0x50b06
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::getAg(int)
NUMBER** HMMProblemPiABGK::getAg(NCAT x) {
	if( x > (this->p->nG-1) ) {
		fprintf(stderr,"While accessing A_g, skill index %d exceeded last index of the data %d.\n", x, this->p->nG-1);
		exit(1);
	}
	return this->Ag[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x354f7
movq -0x18(%rbp), %rax
movq 0x25b0f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8bc(%rax), %ecx
subl $0x1, %ecx
leaq 0x1b6b2(%rip), %rsi     # 0x50b98
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::getBk(int)
NUMBER** HMMProblemPiABGK::getBk(NCAT x) {
	if( x > (this->p->nK-1) ) {
		fprintf(stderr,"While accessing B_k, skill index %d exceeded last index of the data %d.\n", x, this->p->nK-1);
		exit(1);
	}
	return this->B[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x35577
movq -0x18(%rbp), %rax
movq 0x25a8f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8c0(%rax), %ecx
subl $0x1, %ecx
leaq 0x1b5e9(%rip), %rsi     # 0x50b4f
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::getBg(int)
NUMBER** HMMProblemPiABGK::getBg(NCAT x) {
	if( x > (this->p->nG-1) ) {
		fprintf(stderr,"While accessing B_g, skill index %d exceeded last index of the data %d.\n", x, this->p->nG-1);
		exit(1);
	}
	return this->Bg[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq 0x88(%rcx), %rcx
movl 0x8bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x355f7
movq -0x18(%rbp), %rax
movq 0x25a0f(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x88(%rax), %rax
movl 0x8bc(%rax), %ecx
subl $0x1, %ecx
leaq 0x1b5fb(%rip), %rsi     # 0x50be1
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: myudelson[P]hmm-scalable/HMMProblemPiABGK.cpp
// Function: HMMProblemPiABGK::getB(data*, signed char, signed char)
NUMBER HMMProblemPiABGK::getB(struct data* dt, NPAR i, NPAR m) {
    // special attention for "unknonw" observations, i.e. the observation was there but we do not know what it is
    // in this case we simply return 1, effectively resulting in no change in \alpha or \beta vatiables
    if(m<0)
        return 1;
    NUMBER p = this->B[dt->k][i][m], q = this->Bg[dt->g][i][m];
    return pairing(p,q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jge 0x3574a
movsd 0x1a2c5(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x8(%rbp)
jmp 0x357b5
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x18(%rbp), %rdx
movslq 0x58(%rdx), %rdx
movq (%rcx,%rdx,8), %rcx
movsbq -0x19(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbq -0x1a(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0xa0(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x5c(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x19(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x1a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
callq 0x9c10
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::HMMProblemSlicedAB(param*)
HMMProblemSlicedAB::HMMProblemSlicedAB(struct param *param) {
    NPAR i;
    switch (param->structure) {
        case STRUCTURE_SKABslc: // Expectation Maximization (Baum-Welch)
            for(i=0; i<3; i++) this->sizes[i] = param->nK;
            this->n_params = param->nK * 4 * param->nZ;
            break;
        default:
            fprintf(stderr,"Structure specified is not supported and should have been caught earlier\n");
            break;
    }
    init(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x194e0
movq -0x30(%rbp), %rax
leaq 0x22348(%rip), %rcx     # 0x5aaa0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb 0x3e(%rax), %al
subb $0xb, %al
jne 0x387ba
jmp 0x38768
movb $0x0, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3, %eax
jge 0x38796
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c0(%rcx), %edx
movsbq -0x11(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,4)
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x3876c
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c0(%rcx), %ecx
shll $0x2, %ecx
movq -0x10(%rbp), %rdx
movsbl 0x8c8(%rdx), %edx
imull %edx, %ecx
movl %ecx, 0x8(%rax)
jmp 0x387d2
movq 0x22817(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x17c5a(%rip), %rsi     # 0x50425
movb $0x0, %al
callq 0x5440
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x387e5
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1a300
movq -0x20(%rbp), %rdi
callq 0x5540
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::init3Params(double*&, double***&, double***&, signed char, signed char, signed char)
void HMMProblemSlicedAB::init3Params(NUMBER* &PI, NUMBER*** &A, NUMBER*** &B, NPAR nZ, NPAR nS, NPAR nO) {  // sliced
    PI = init1D<NUMBER>((NDAT)nS);
    A  = init3D<NUMBER>((NDAT)nZ, (NDAT)nS, (NDAT)nS);
    B  = init3D<NUMBER>((NDAT)nZ, (NDAT)nS, (NDAT)nO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r8d, -0x44(%rbp)
movq %rcx, %rax
movl -0x44(%rbp), %ecx
movq %rax, -0x40(%rbp)
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movb 0x10(%rbp), %r9b
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
movb %al, -0x22(%rbp)
movsbl -0x22(%rbp), %edi
callq 0xc410
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x21(%rbp), %edi
movsbl -0x22(%rbp), %esi
movsbl -0x22(%rbp), %edx
callq 0x11310
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x21(%rbp), %edi
movsbl -0x22(%rbp), %esi
movsbl 0x10(%rbp), %edx
callq 0x11310
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::destroy()
void HMMProblemSlicedAB::destroy() {
    NPAR nS = this->p->nS, nZ = this->p->nZ;
	// destroy model data
	if(this->A  != NULL) free4D<NUMBER>(this->A,  this->sizes[1], this->p->nZ, this->p->nS);
	if(this->B  != NULL) free4D<NUMBER>(this->B,  this->sizes[2], this->p->nZ, this->p->nS);
	if(this->lbPI!=NULL) free(this->lbPI);
	if(this->ubPI!=NULL) free(this->ubPI);
	if(this->lbA!=NULL) free3D<NUMBER>(this->lbA, nZ, nS);
	if(this->ubA!=NULL) free3D<NUMBER>(this->ubA, nZ, nS);
	if(this->lbB!=NULL) free3D<NUMBER>(this->lbB, nZ, nS);
	if(this->ubB!=NULL) free3D<NUMBER>(this->ubB, nZ, nS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x88(%rax), %rcx
movb 0x8b8(%rcx), %cl
movb %cl, -0x9(%rbp)
movq 0x88(%rax), %rcx
movb 0x8c8(%rcx), %cl
movb %cl, -0xa(%rbp)
cmpq $0x0, 0x90(%rax)
je 0x39a0d
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rdi
movl 0x10(%rax), %esi
movq 0x88(%rax), %rcx
movsbl 0x8c8(%rcx), %edx
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %ecx
callq 0x42330
movq -0x18(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x39a4a
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rdi
movl 0x14(%rax), %esi
movq 0x88(%rax), %rcx
movsbl 0x8c8(%rcx), %edx
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %ecx
callq 0x42330
movq -0x18(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x39a68
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x5380
movq -0x18(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x39a86
movq -0x18(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x5380
movq -0x18(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x39aac
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rdi
movsbl -0xa(%rbp), %esi
movsbl -0x9(%rbp), %edx
callq 0x11290
movq -0x18(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x39ad2
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rdi
movsbl -0xa(%rbp), %esi
movsbl -0x9(%rbp), %edx
callq 0x11290
movq -0x18(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x39af8
movq -0x18(%rbp), %rax
movq 0xb0(%rax), %rdi
movsbl -0xa(%rbp), %esi
movsbl -0x9(%rbp), %edx
callq 0x11290
movq -0x18(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x39b1e
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rdi
movsbl -0xa(%rbp), %esi
movsbl -0x9(%rbp), %edx
callq 0x11290
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::getA(int)
NUMBER*** HMMProblemSlicedAB::getA(NCAT x) {
    if( x > (this->sizes[1]-1) ) {
        fprintf(stderr,"While accessing A, skill index %d exceeded last index of the data %d.\n", x, this->sizes[1]-1);
        exit(1);
    }
    return this->A[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x39c53
movq -0x18(%rbp), %rax
movq 0x213a9(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movl 0x10(%rax), %ecx
subl $0x1, %ecx
leaq 0x16896(%rip), %rsi     # 0x504d8
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::getB(int)
NUMBER*** HMMProblemSlicedAB::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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl 0x14(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x39cc3
movq -0x18(%rbp), %rax
movq 0x21339(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movl 0x14(%rax), %ecx
subl $0x1, %ecx
leaq 0x1686d(%rip), %rsi     # 0x5051f
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::getB(data*, signed char, signed char)
NUMBER HMMProblemSlicedAB::getB (struct data* dt, NPAR i, NPAR m) {
    // special attention for "unknonw" observations, i.e. the observation was there but we do not know what it is
    // in this case we simply return 1, effectively resulting in no change in \alpha or \beta vatiables
    if(m<0)
        return 1;
    NPAR z = this->p->dat_slice[ dt->t ]; // find current slice in global array by local index
    //    switch(this->p->structure)
    //    {
    //        case STRUCTURE_SKILL:
    return this->B[dt->k][z][i][m];
    //            break;
    //        case STRUCTURE_GROUP:
    //            return this->B[dt->g][z][i][m];
    //            break;
    //        default:
    //            fprintf(stderr,"Solver specified is not supported.\n");
    //            exit(1);
    //            break;
    //    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jge 0x39f46
movsd 0x15ac9(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x8(%rbp)
jmp 0x39f9a
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rcx
movq 0x8a8(%rcx), %rcx
movq -0x18(%rbp), %rdx
movslq 0x8(%rdx), %rdx
movb (%rcx,%rdx), %cl
movb %cl, -0x1b(%rbp)
movq 0x98(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x1b(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x19(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x1a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::toZero3Params(double*&, double***&, double***&, signed char, signed char, signed char)
void HMMProblemSlicedAB::toZero3Params(NUMBER* &PI, NUMBER*** &A, NUMBER*** &B, NPAR nZ, NPAR nS, NPAR nO) { // sliced
    toZero1D<NUMBER>(PI, (NDAT)nS);
    toZero3D<NUMBER>(A,  (NDAT)nZ, (NDAT)nS, (NDAT)nS);
    toZero3D<NUMBER>(B,  (NDAT)nZ, (NDAT)nS, (NDAT)nO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r8d, -0x44(%rbp)
movq %rcx, %rax
movl -0x44(%rbp), %ecx
movq %rax, -0x40(%rbp)
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movb 0x10(%rbp), %r9b
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movsbl -0x22(%rbp), %esi
callq 0xf540
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movsbl -0x21(%rbp), %esi
movsbl -0x22(%rbp), %edx
movsbl -0x22(%rbp), %ecx
callq 0x113c0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movsbl -0x21(%rbp), %esi
movsbl -0x22(%rbp), %edx
movsbl 0x10(%rbp), %ecx
callq 0x113c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::cpy3Params(double*&, double***&, double***&, double*&, double***&, double***&, signed char, signed char, signed char)
void HMMProblemSlicedAB::cpy3Params(NUMBER* &soursePI, NUMBER*** &sourseA, NUMBER*** &sourseB, NUMBER* &targetPI, NUMBER*** &targetA, NUMBER*** &targetB, NPAR nZ, NPAR nS, NPAR nO) {  // sliced
    cpy1D<NUMBER>(soursePI, targetPI, (NDAT)nS);
    cpy3D<NUMBER>(sourseA,  targetA,  (NDAT)nZ, (NDAT)nS, (NDAT)nS);
    cpy3D<NUMBER>(sourseB,  targetB,  (NDAT)nZ, (NDAT)nS, (NDAT)nO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb 0x28(%rbp), %al
movb 0x20(%rbp), %al
movb 0x18(%rbp), %al
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movsbl 0x20(%rbp), %edx
callq 0xc440
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movsbl 0x18(%rbp), %edx
movsbl 0x20(%rbp), %ecx
movsbl 0x20(%rbp), %r8d
callq 0x11450
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq 0x10(%rbp), %rax
movq (%rax), %rsi
movsbl 0x18(%rbp), %edx
movsbl 0x20(%rbp), %ecx
movsbl 0x28(%rbp), %r8d
callq 0x11450
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSlicedAB.cpp
// Function: HMMProblemSlicedAB::free3Params(double*&, double***&, double***&, signed char, signed char)
void HMMProblemSlicedAB::free3Params(NUMBER* &PI, NUMBER*** &A, NUMBER*** &B, NPAR nZ, NPAR nS) {  // sliced
    free(PI);
    free3D<NUMBER>(A, (NDAT)nZ, (NDAT)nS);
    free3D<NUMBER>(B, (NDAT)nZ, (NDAT)nS);
    PI = NULL;
    A  = NULL;
    B  = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r8d, -0x44(%rbp)
movq %rcx, %rax
movl -0x44(%rbp), %ecx
movq %rax, -0x40(%rbp)
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5380
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movsbl -0x21(%rbp), %esi
movsbl -0x22(%rbp), %edx
callq 0x11290
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movsbl -0x21(%rbp), %esi
movsbl -0x22(%rbp), %edx
callq 0x11290
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/./utils.h
// Function: double**** init4D<double>(int, int, int, int)
T**** init4D(NDAT size1, NDAT size2, NDAT size3, NDAT size4) {
    NDAT i,j, l;
    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);
            for(l=0; l<size3; l++)
                ar[i][j][l] = Calloc(T, (size_t)size4);
        }
    }
    return ar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x42321
movslq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x42311
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x42301
movslq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x422c1
jmp 0x42303
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4228d
jmp 0x42313
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4225d
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/./utils.h
// Function: void free4D<double>(double****, int, int, int)
void free4D(T**** ar, NDAT size1, NDAT size2, NDAT size3) {
    for(NDAT i=0; i<size1; i++) {
        for(NDAT j=0; j<size2; j++) {
            for(NDAT l=0; l<size3; l++)
                free(ar[i][j][l]);
            free(ar[i][j]);
        }
        free(ar[i]);
    }
    free(ar);
    //    &ar = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x423e5
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x423c6
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x423a2
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5380
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4236e
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5380
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4235f
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5380
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4234c
movq -0x8(%rbp), %rdi
callq 0x5380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: myudelson[P]hmm-scalable/HMMProblemSlicedA.cpp
// Function: HMMProblemSlicedA::HMMProblemSlicedA(param*)
HMMProblemSlicedA::HMMProblemSlicedA(struct param *param) {
    NPAR i;
    switch (param->structure) {
        case STRUCTURE_SKAslc: 
            for(i=0; i<3; i++) this->sizes[i] = param->nK;
            this->n_params = param->nK * 4 * param->nZ;
            break;
        default:
            fprintf(stderr,"Structure specified is not supported and should have been caught earlier\n");
            break;
    }
    init(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x194e0
movq -0x30(%rbp), %rax
leaq 0x18738(%rip), %rcx     # 0x5aba0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb 0x3e(%rax), %al
subb $0xc, %al
jne 0x424ca
jmp 0x42478
movb $0x0, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3, %eax
jge 0x424a6
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c0(%rcx), %edx
movsbq -0x11(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,4)
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x4247c
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c0(%rcx), %ecx
shll $0x2, %ecx
movq -0x10(%rbp), %rdx
movsbl 0x8c8(%rdx), %edx
imull %edx, %ecx
movl %ecx, 0x8(%rax)
jmp 0x424e2
movq 0x18b07(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0xdf4a(%rip), %rsi      # 0x50425
movb $0x0, %al
callq 0x5440
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x424f5
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1a300
movq -0x20(%rbp), %rdi
callq 0x5540
nopl (%rax)