LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::checkSkillConstraints(double*)
bool HMMProblemSt::checkSkillConstraints(NUMBER* param_skill) {
    NPAR nS = this->task->nS, nO = this->task->nO;
	NCAT skill1_n = nS * (1 + nS + nO); // number of params per 1 skill slot
    NUMBER sum = 0.0;
    
    for(NPAR l=0; l<skill1_n; l++) {
        if( param_skill[l]>1.0 || param_skill[l]<0.0)
            return false;
        sum += param_skill[l];
    }
    if( sum/(skill1_n/2) != 1.0 )
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0x19(%rbp)
movq 0x68(%rax), %rax
movb 0x901(%rax), %al
movb %al, -0x1a(%rbp)
movsbl -0x19(%rbp), %eax
movsbl -0x19(%rbp), %ecx
addl $0x1, %ecx
movsbl -0x1a(%rbp), %edx
addl %edx, %ecx
imull %ecx, %eax
movl %eax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x11a6d
movq -0x18(%rbp), %rax
movsbq -0x29(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xa014(%rip), %xmm1     # 0x1ba40
ucomisd %xmm1, %xmm0
ja 0x11a45
movq -0x18(%rbp), %rax
movsbq -0x29(%rbp), %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x11a4b
movb $0x0, -0x1(%rbp)
jmp 0x11aa1
movq -0x18(%rbp), %rax
movsbq -0x29(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movb -0x29(%rbp), %al
addb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x11a0d
movsd -0x28(%rbp), %xmm0
movl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd 0x9fb3(%rip), %xmm1     # 0x1ba40
ucomisd %xmm1, %xmm0
jne 0x11a97
jp 0x11a97
jmp 0x11a9d
movb $0x0, -0x1(%rbp)
jmp 0x11aa1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::readModel(char const*, bool)
void HMMProblemSt::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 task inittask;
    set_task_defaults(&inittask);
    
    //
    // read solver info
    //
    if(overwrite)
        readSolverInfo(fid, this->task, &line_no);
    else
        readSolverInfo(fid, &inittask, &line_no);
    //
    // read model
    //
    readModelBody(fid, &inittask, &line_no, overwrite);
		
	fclose(fid);
	free(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x9d0, %rsp            # imm = 0x9D0
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x9d0(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9664(%rip), %rsi      # 0x1b144
callq 0x3310
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11b16
movq 0x104e1(%rip), %rax     # 0x21fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x9641(%rip), %rsi      # 0x1b146
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movl $0x400, -0x24(%rbp)     # imm = 0x400
movslq -0x24(%rbp), %rdi
shlq $0x0, %rdi
callq 0x3380
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x9c8(%rbp), %rdi
callq 0x8d90
testb $0x1, -0x11(%rbp)
je 0x11b61
movq -0x9d0(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x68(%rax), %rsi
leaq -0x34(%rbp), %rdx
callq 0x98a0
jmp 0x11b75
movq -0x20(%rbp), %rdi
leaq -0x9c8(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x98a0
movq -0x9d0(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x11(%rbp), %r8b
movq (%rdi), %rax
leaq -0x9c8(%rbp), %rdx
leaq -0x34(%rbp), %rcx
andb $0x1, %r8b
movzbl %r8b, %r8d
callq *0x60(%rax)
movq -0x20(%rbp), %rdi
callq 0x3260
movq -0x30(%rbp), %rdi
callq 0x3320
addq $0x9d0, %rsp            # imm = 0x9D0
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getPI(int)
NUMBER* HMMProblemSt::getPI(NCAT x) {
	if( x > (this->task->nK-1) ) {
		fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, this->task->nK-1);
		exit(1);
	}
	return &this->param_skill[this->skill1_n*x + 0];
}

// 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 0x68(%rcx), %rcx
movl 0x908(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x11f81
movq -0x18(%rbp), %rax
movq 0x10082(%rip), %rcx     # 0x21fd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movq 0x68(%rax), %rax
movl 0x908(%rax), %ecx
subl $0x1, %ecx
leaq 0xa37c(%rip), %rsi      # 0x1c2ec
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
movl 0x38(%rcx), %ecx
imull -0xc(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getA(int)
NUMBER* HMMProblemSt::getA(NCAT x) {
    NPAR nS = this->task->nS;
    NCAT nK = this->task->nK;
	if( x > (nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
		exit(1);
	}
	return &this->param_skill[this->skill1_n*x + nS];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0xd(%rbp)
movq 0x68(%rax), %rax
movl 0x908(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x12019
movq 0xffe3(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
leaq 0xa2e4(%rip), %rsi      # 0x1c2ec
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rax
movl 0x38(%rcx), %ecx
imull -0xc(%rbp), %ecx
movsbl -0xd(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getB(int)
NUMBER* HMMProblemSt::getB(NCAT x) {
    NPAR nS = this->task->nS;
    NCAT nK = this->task->nK;
	if( x > (nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
		exit(1);
	}
	return &this->param_skill[ this->skill1_n*x + nS*(nS+1) ];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0xd(%rbp)
movq 0x68(%rax), %rax
movl 0x908(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x120a9
movq 0xff53(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
leaq 0xa254(%rip), %rsi      # 0x1c2ec
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rax
movl 0x38(%rcx), %ecx
imull -0xc(%rbp), %ecx
movsbl -0xd(%rbp), %edx
movsbl -0xd(%rbp), %esi
addl $0x1, %esi
imull %esi, %edx
addl %edx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getPI(int, signed char)
NUMBER HMMProblemSt::getPI(NCAT x, NPAR i) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    NCAT nK = this->task->nK;
    if( x > (this->task->nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
        exit(1);
    }
    // checks done
    return this->param_skill[this->skill1_n*x + i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x68(%rcx), %rax
movl 0x908(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movq 0x68(%rcx), %rcx
movl 0x908(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x12148
movq 0xfeb4(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
leaq 0xa1b5(%rip), %rsi      # 0x1c2ec
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rax
movl 0x38(%rcx), %ecx
imull -0xc(%rbp), %ecx
movsbl -0xd(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getA(int, signed char, signed char)
NUMBER HMMProblemSt::getA(NCAT x, NPAR i, NPAR j) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    NPAR nS = this->task->nS;
    NCAT nK = this->task->nK;
    if( x > (nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
        exit(1);
    }
    // checks done
    return this->param_skill[this->skill1_n*x + nS + i*nS + j];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %cl, -0xd(%rbp)
movb %al, -0xe(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0xf(%rbp)
movq 0x68(%rax), %rax
movl 0x908(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x121e3
movq 0xfe19(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
leaq 0xa11a(%rip), %rsi      # 0x1c2ec
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rax
movl 0x38(%rcx), %ecx
imull -0xc(%rbp), %ecx
movsbl -0xf(%rbp), %edx
addl %edx, %ecx
movsbl -0xd(%rbp), %edx
movsbl -0xf(%rbp), %esi
imull %esi, %edx
addl %edx, %ecx
movsbl -0xe(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getB(int, signed char, signed char)
NUMBER HMMProblemSt::getB(NCAT x, NPAR i, NPAR m) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    NPAR nS = this->task->nS;
    NPAR nO = this->task->nO;
    NCAT nK = this->task->nK;
    if( x > (nK-1) ) {
        fprintf(stderr,"While accessing PI, skill index %d exceeded the last skill index %d.\n", x, nK-1);
        exit(1);
    }
    if(m<0)
        return 1;
    // checks done
    return this->param_skill[this->skill1_n*x + nS * (1 + nS )+ i*nO + m];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %cl, -0x15(%rbp)
movb %al, -0x16(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0x17(%rbp)
movq 0x68(%rax), %rcx
movb 0x901(%rcx), %cl
movb %cl, -0x18(%rbp)
movq 0x68(%rax), %rax
movl 0x908(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x122a0
movq 0xfd5c(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
leaq 0xa05d(%rip), %rsi      # 0x1c2ec
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movsbl -0x16(%rbp), %eax
cmpl $0x0, %eax
jge 0x122b8
movsd 0x978f(%rip), %xmm0     # 0x1ba40
movsd %xmm0, -0x8(%rbp)
jmp 0x122f7
movq -0x28(%rbp), %rcx
movq 0x28(%rcx), %rax
movl 0x38(%rcx), %ecx
imull -0x14(%rbp), %ecx
movsbl -0x17(%rbp), %edx
movsbl -0x17(%rbp), %esi
addl $0x1, %esi
imull %esi, %edx
addl %edx, %ecx
movsbl -0x15(%rbp), %edx
movsbl -0x18(%rbp), %esi
imull %esi, %edx
addl %edx, %ecx
movsbl -0x16(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::getB(context*, signed char, signed char)
NUMBER HMMProblemSt::getB (struct context* ctx, NPAR i, NPAR m) {
//    if(task->structure != STRUCTURE_SKILL) {
//        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
//        exit(1);
//    }
    // checks done
    NPAR nS = this->task->nS;
    NPAR nO = this->task->nO;
    // 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->param_skill[this->skill1_n*ctx->k + nS * (1 + nS )+ i*nO + 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)
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0x1b(%rbp)
movq 0x68(%rax), %rax
movb 0x901(%rax), %al
movb %al, -0x1c(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jge 0x12400
movsd 0x9647(%rip), %xmm0     # 0x1ba40
movsd %xmm0, -0x8(%rbp)
jmp 0x12442
movq -0x28(%rbp), %rcx
movq 0x28(%rcx), %rax
movl 0x38(%rcx), %ecx
movq -0x18(%rbp), %rdx
imull (%rdx), %ecx
movsbl -0x1b(%rbp), %edx
movsbl -0x1b(%rbp), %esi
addl $0x1, %esi
imull %esi, %edx
addl %edx, %ecx
movsbl -0x19(%rbp), %edx
movsbl -0x1c(%rbp), %esi
imull %esi, %edx
addl %edx, %ecx
movsbl -0x1a(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::initAlphaEtAl()
void HMMProblemSt::initAlphaEtAl() {
    NPAR nS = this->task->nS;
    NCAT nK = this->task->nK, nG = this->task->nG;
    NDAT Nst = this->task->Nst;
    NPAR f_is_scaled = this->task->is_scaled==1;
    toZero2D(this->alpha, Nst, nS);
    // if scaled, new parameter values are multiplied, if not scaled – added
    if(f_is_scaled)
        toValue2D(this->po_param_gk, nG, nK, 1.0);
    else
        toZero2D(this->po_param_gk, nG, nK);
    toZero1D(this->loglik_k, nK);
    
    toValue3D(this->group_skill_map, (NDAT)nG, (NDAT)nK, (NDAT)nS, -1.0); // -1 means not set (use pLo)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0x9(%rbp)
movq 0x68(%rax), %rcx
movl 0x908(%rcx), %ecx
movl %ecx, -0x10(%rbp)
movq 0x68(%rax), %rcx
movl 0x904(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq 0x68(%rax), %rcx
movl 0x8fc(%rcx), %ecx
movl %ecx, -0x18(%rbp)
movq 0x68(%rax), %rcx
movsbl 0x41(%rcx), %ecx
cmpl $0x1, %ecx
sete %cl
andb $0x1, %cl
movb %cl, -0x19(%rbp)
movq 0x70(%rax), %rdi
movl -0x18(%rbp), %esi
movsbl -0x9(%rbp), %edx
callq 0x19280
cmpb $0x0, -0x19(%rbp)
je 0x124df
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
movsd 0x9568(%rip), %xmm0     # 0x1ba40
callq 0x192e0
jmp 0x124f2
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x19280
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x19350
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
movsbl -0x9(%rbp), %ecx
movsd 0x952e(%rip), %xmm0     # 0x1ba50
callq 0x19390
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::fit()
void HMMProblemSt::fit() {
    FitNullSkill(/*loglik_rmse, false do RMSE*/);
    switch(this->task->solver)
    {
        case METHOD_BW: // Baum Welch Method
        case METHOD_GD: // Gradient Descent
        case METHOD_CGD: // Conjugate Gradient Descent
        case METHOD_GDL: // Gradient Descent, Lagrange
        case METHOD_GBB: // Brzilai Borwein Gradient Method
            Cycle();
            break;
        default:
            fprintf(stderr,"Solver specified is not supported.\n");
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x15cb0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movsbl 0x4f(%rax), %eax
decl %eax
subl $0x4, %eax
ja 0x15c8d
jmp 0x15c7e
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
jmp 0x15ca5
movq 0xc344(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
leaq 0x683a(%rip), %rsi      # 0x1c4d8
movb $0x0, %al
callq 0x33c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::FitNullSkill()
void HMMProblemSt::FitNullSkill() {
    if(this->task->N_null==0) {
        this->null_obs_ratios[0] = 1; // set first obs to 1, simplex preserved
        return; // 0 loglik
    }
    NDAT t;
    NPAR o, m;
    // count distribution of onservations
    for(t=this->task->first_null_skill; t<=this->task->last_null_skill; t++) {
        o = this->task->dat_obs[ t ];
        this->null_obs_ratios[ o ]++;
    }
    // produce per-observation means
    this->null_skill_obs = 0;
    this->null_skill_obs_prob = 0;
    for(m=0;m<this->task->nO;m++) {
        this->null_obs_ratios[ m ] /= this->task->N_null;
        if( this->null_obs_ratios[m] > this->null_skill_obs_prob ) {
            this->null_skill_obs_prob = this->null_obs_ratios[m];
            this->null_skill_obs = m;
        }
    }
    this->null_skill_obs_prob = safe01num(this->null_skill_obs_prob); // safety for logging
    // metrics don't need to be computed it's handled in computeAlpha... -- main negative log-ikelihood computation
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x68(%rax), %rax
cmpl $0x0, 0x914(%rax)
jne 0x15cea
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movsd 0x5d5f(%rip), %xmm0     # 0x1ba40
movsd %xmm0, (%rax)
jmp 0x15e02
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x918(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x68(%rcx), %rcx
cmpl 0x91c(%rcx), %eax
jg 0x15d4d
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
movq 0x880(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movb (%rcx,%rdx), %cl
movb %cl, -0xd(%rbp)
movq 0x10(%rax), %rax
movsbq -0xd(%rbp), %rcx
movsd 0x5d08(%rip), %xmm0     # 0x1ba40
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15cfb
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movb $0x0, -0xe(%rbp)
movq -0x18(%rbp), %rcx
movsbl -0xe(%rbp), %eax
movq 0x68(%rcx), %rcx
movsbl 0x901(%rcx), %ecx
cmpl %ecx, %eax
jge 0x15deb
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
cvtsi2sdl 0x914(%rcx), %xmm1
movq 0x10(%rax), %rcx
movsbq -0xe(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0x10(%rax), %rcx
movsbq -0xe(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
ucomisd 0x20(%rax), %xmm0
jbe 0x15ddc
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movsbq -0xe(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, 0x20(%rax)
movsbl -0xe(%rbp), %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x18(%rax)
jmp 0x15dde
movb -0xe(%rbp), %al
addb $0x1, %al
movb %al, -0xe(%rbp)
jmp 0x15d65
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
callq 0x7580
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::readNullObsRatio(_IO_FILE*, task*, int*)
void HMMProblemSt::readNullObsRatio(FILE *fid, struct task* task, NDAT *line_no) {
	NPAR i;
	//
	// read null skill ratios
	//
    fscanf(fid, "Null skill ratios\t");
    this->null_obs_ratios =Calloc(NUMBER, (size_t)this->task->nO);
    this->null_skill_obs      = 0;
    this->null_skill_obs_prob = 0;
	for(i=0; i<task->nO; i++) {
        if( i==(task->nO-1) ) // end
            fscanf(fid,"%lf\n",&this->null_obs_ratios[i] );
        else
            fscanf(fid,"%lf\t",&this->null_obs_ratios[i] );
		
        if( this->null_obs_ratios[i] > this->null_skill_obs_prob ) {
            this->null_skill_obs_prob = this->null_obs_ratios[i];
            this->null_skill_obs = i;
        }
	}
    (*line_no)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3e6b(%rip), %rsi      # 0x1c356
movb $0x0, %al
callq 0x34e0
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rax
movsbq 0x901(%rax), %rdi
movl $0x8, %esi
callq 0x3170
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movb $0x0, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl 0x901(%rcx), %ecx
cmpl %ecx, %eax
jge 0x185f2
movsbl -0x21(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl 0x901(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x18580
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
movsbq -0x21(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x3fcd(%rip), %rsi      # 0x1c544
movb $0x0, %al
callq 0x34e0
jmp 0x185a6
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
movsbq -0x21(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x3faa(%rip), %rsi      # 0x1c549
movb $0x0, %al
callq 0x34e0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movsbq -0x21(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
ucomisd 0x20(%rax), %xmm0
jbe 0x185e3
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movsbq -0x21(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, 0x20(%rax)
movsbl -0x21(%rbp), %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x18(%rax)
jmp 0x185e5
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x1852b
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::toFileAlphaBetaObs(char const*, int)
void HMMProblemSt::toFileAlphaBetaObs(const char *filename, NCAT k) {
    NDAT t, tt=0;
    NPAR nS = this->task->nS;
    FILE *fid = fopen(filename,"w");
    
    if(fid == NULL) {
        fprintf(stderr,"Can't write output model file %s\n",filename);
        exit(1);
    }
    
    // first time skill k starts
    while(this->task->dat_skill_stacked[tt]!=k) {
        tt++;
    }
    
    do {
        t = tt;
        for(NPAR i=0; i<nS; i++) fprintf(fid,"%20.17f\t",this->alpha[tt][i]);
        for(NPAR i=0; i<nS; i++) fprintf(fid,"%20.17f\t",this->beta[tt][i]);
        fprintf(fid,"%i\n",this->task->dat_obs_stacked[tt]);
        tt = this->forward_ix[tt];
    }
    while(this->forward_ix[t]!=-1);
    fclose(fid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movq 0x68(%rax), %rax
movb 0x900(%rax), %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x34a8(%rip), %rsi      # 0x1c332
callq 0x3310
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x18ec0
movq 0x9137(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3485(%rip), %rsi      # 0x1c334
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
jmp 0x18ec2
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x8a0(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
je 0x18ee8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18ec2
jmp 0x18eea
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movb $0x0, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
movsbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
jge 0x18f36
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x70(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x29(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x3643(%rip), %rsi      # 0x1c568
movb $0x1, %al
callq 0x33c0
movb -0x29(%rbp), %al
addb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x18ef4
movb $0x0, -0x2a(%rbp)
movsbl -0x2a(%rbp), %eax
movsbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
jge 0x18f7f
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x90(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x2a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x35fa(%rip), %rsi      # 0x1c568
movb $0x1, %al
callq 0x33c0
movb -0x2a(%rbp), %al
addb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x18f3a
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x68(%rax), %rax
movq 0x888(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0x2cd9(%rip), %rsi      # 0x1bc7a
movb $0x0, %al
callq 0x33c0
movq -0x38(%rbp), %rax
movq 0xb8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rax
movq 0xb8(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x18eea
movq -0x28(%rbp), %rdi
callq 0x3260
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: myudelson[P]hmm-scalable/./utilsSt.h
// Function: signed char* initToValue1D<signed char>(int, signed char)
T* initToValue1D(NDAT size, T val) {
    T* ar = Calloc(T, (size_t)size);
    for(NDAT i=0; i<size; i++)
        ar[i] = val;
    return ar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x3170
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1903b
movb -0x5(%rbp), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1901a
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: myudelson[P]hmm-scalable/./utilsSt.h
// Function: double** init2D<double>(int, int)
T** init2D(NDAT size1, NDAT size2) {
    T** ar = (T **)Calloc(T *, (size_t)size1);
    for(NDAT i=0; i<size1; i++)
        ar[i] = (T *)Calloc(T, (size_t)size2);
    return ar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x3170
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x190a7
movslq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3170
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19077
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/./utilsSt.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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x3170
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x191eb
movslq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3170
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x191de
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3170
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x191a6
jmp 0x191e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1917a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: myudelson[P]hmm-scalable/./utilsSt.h
// Function: void toValue3D<double>(double***, int, int, int, double)
void toValue3D(T*** ar, NDAT size1, NDAT size2, NDAT size3, T val) {
    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] = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1941a
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1940d
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x19400
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x193cb
jmp 0x19402
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x193bc
jmp 0x1940f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x193ad
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::HMMProblemEloSt()
HMMProblemEloSt::HMMProblemEloSt() {
    if(task->structure != STRUCTURE_ELO) {
        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
        exit(1);
    }
    this->param_elo = NULL;
    this->gradient_elo = NULL;
    this->param_elo_n = 0;
    this->elo_track_g = NULL;
    this->elo_count_g = NULL;
    this->elo_track_t = NULL;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x112f0
movq -0x10(%rbp), %rax
leaq 0x83cc(%rip), %rcx      # 0x21cd0
movq %rcx, (%rax)
movq $0x0, 0xd8(%rax)
movq $0x0, 0xd0(%rax)
movq 0x68(%rax), %rax
movsbl 0x4e(%rax), %eax
cmpl $0xe, %eax
je 0x1994c
movq 0x86a7(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
leaq 0x2c67(%rip), %rsi      # 0x1c5a2
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movq -0x10(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq $0x0, 0xe8(%rax)
movb $0x0, 0xf0(%rax)
movq $0x0, 0xf8(%rax)
movq $0x0, 0x100(%rax)
movq $0x0, 0x108(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::HMMProblemEloSt(task*)
HMMProblemEloSt::HMMProblemEloSt(struct task *task) {
//    printf("HMMProblemEloSt::HMMProblemEloSt\n");
    if(task->structure != STRUCTURE_ELO) {
        fprintf(stderr,"Model structure specified is not supported and should have been caught earlier\n");
        exit(1);
    }
    // check done
    this->model_param_n = task->nK * 4;
    // init
    init(task);
}

// 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 0x112f0
movq -0x28(%rbp), %rax
leaq 0x8308(%rip), %rcx      # 0x21cd0
movq %rcx, (%rax)
movq $0x0, 0xd8(%rax)
movq $0x0, 0xd0(%rax)
movq -0x10(%rbp), %rax
movsbl 0x4e(%rax), %eax
cmpl $0xe, %eax
je 0x19a10
movq 0x85e3(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
leaq 0x2ba3(%rip), %rsi      # 0x1c5a2
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x908(%rax), %eax
shll $0x2, %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
jmp 0x19a33
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 0x11bc0
movq -0x18(%rbp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::sensitivity_U1b(context*)
NUMBER HMMProblemEloSt::sensitivity_U1b(struct context *ctx) {
    // handle negative b by transferring it to the whole resulting K
    NUMBER sig = (this->param_elo[0]>=0)?1.0:-1.0;
    NDAT n = this->elo_count_g[ctx->g];
    return sig*1/(1+sig*this->param_elo[0]*n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
movsd (%rcx), %xmm1
movsd 0x1d9d(%rip), %xmm3     # 0x1ba40
movsd 0x1da5(%rip), %xmm2     # 0x1ba50
xorps %xmm0, %xmm0
cmplesd %xmm1, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x100(%rax), %rcx
movq -0x10(%rbp), %rdx
movslq 0x4(%rdx), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x1c(%rbp)
movsd 0x1d5c(%rip), %xmm0     # 0x1ba40
mulsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq 0xe0(%rax), %rax
mulsd (%rax), %xmm1
cvtsi2sdl -0x1c(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x1d36(%rip), %xmm2     # 0x1ba40
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::sensitivity_U1bexp0_01(context*)
NUMBER HMMProblemEloSt::sensitivity_U1bexp0_01(struct context *ctx) {
    // handle negative b by transferring it to the whole resulting K
    NUMBER sig = (this->param_elo[0]>=0)?1.0:-1.0;
    NDAT n = this->elo_count_g[ctx->g];
    return sig*1/(1+sig*this->param_elo[0]*exp(0.01*n));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
movsd (%rcx), %xmm1
movsd 0x1cf9(%rip), %xmm3     # 0x1ba40
movsd 0x1d01(%rip), %xmm2     # 0x1ba50
xorps %xmm0, %xmm0
cmplesd %xmm1, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x100(%rax), %rcx
movq -0x10(%rbp), %rdx
movslq 0x4(%rdx), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x1c(%rbp)
movsd 0x1cb8(%rip), %xmm0     # 0x1ba40
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movq 0xe0(%rax), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm1
movsd 0x1d04(%rip), %xmm0     # 0x1bab8
mulsd %xmm1, %xmm0
callq 0x34c0
movsd -0x30(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
mulsd %xmm2, %xmm1
movsd 0x1c6a(%rip), %xmm2     # 0x1ba40
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::sensitivity_O2Z_IN_B(context*)
NUMBER HMMProblemEloSt::sensitivity_O2Z_IN_B(struct context *ctx) {
    // handle negative b by transferring it to the whole resulting K
    NUMBER sig = (this->param_elo[0]>=0)?1.0:-1.0;
    NDAT n = this->elo_count_g[ctx->g];
    return sig*MAX(1-n/this->param_elo[0],0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0xe0(%rax), %rcx
movsd (%rcx), %xmm1
movsd 0x1c29(%rip), %xmm3     # 0x1ba40
movsd 0x1c31(%rip), %xmm2     # 0x1ba50
xorps %xmm0, %xmm0
cmplesd %xmm1, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x100(%rax), %rcx
movq -0x10(%rbp), %rdx
movslq 0x4(%rdx), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm1
movq 0xe0(%rax), %rax
divsd (%rax), %xmm1
movsd 0x1bce(%rip), %xmm0     # 0x1ba40
subsd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x19ea6
movq -0x30(%rbp), %rax
cvtsi2sdl -0x1c(%rbp), %xmm1
movq 0xe0(%rax), %rax
divsd (%rax), %xmm1
movsd 0x1ba5(%rip), %xmm0     # 0x1ba40
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x19eb0
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x19eb0
movsd -0x28(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
mulsd %xmm1, %xmm0
popq %rbp
retq
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::~HMMProblemEloSt()
HMMProblemEloSt::~HMMProblemEloSt() {
//    printf("HMMProblemEloSt::~HMMProblemEloSt\n");
    // all of these are not done by HMMProblemSt
    if(this->param_elo == NULL) free(this->param_elo);
    if(this->gradient_elo == NULL) free(this->gradient_elo);
    
    if(this->elo_count_g == NULL) free(this->elo_count_g);
    if(this->elo_track_g == NULL) free(this->elo_track_g);
    if(this->elo_track_t == NULL) free(this->elo_track_t);
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x7de5(%rip), %rcx      # 0x21cc0
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0xe0(%rax)
jne 0x19efc
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
jne 0x19f1a
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0x19f38
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x19f56
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x108(%rax)
jne 0x19f74
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
callq 0x3320
movq -0x10(%rbp), %rdi
callq 0x11bc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::getPI(context*, signed char)
NUMBER HMMProblemEloSt::getPI(struct context* ctx, NPAR i) {
//    if(this->task->structure != STRUCTURE_ELO)
//    {
//        fprintf(stderr,"Solver specified is not supported.\n");
//        exit(1);
//    }
    // BKT part
    NUMBER ret = this->param_skill[this->skill1_n*ctx->k + i];
    // Elo part
    if( (this->task->elo_scope & BKT_PARAMETER_SCOPE_PI)>0 ) {
//        if( ctx->g > -1) {
        NUMBER sig = ((i==0)?1.0:(-1.0));
        ret = sigmoid( sig * this->elo_track_g[ctx->g] + logit(ret));
//        }
    }
    return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x28(%rax), %rcx
movl 0x38(%rax), %edx
movq -0x10(%rbp), %rsi
imull (%rsi), %edx
movsbl -0x11(%rbp), %esi
addl %esi, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x68(%rax), %rax
movl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jle 0x1a098
movsbl -0x11(%rbp), %eax
movsd 0x1a23(%rip), %xmm0     # 0x1ba40
movsd 0x1a2b(%rip), %xmm1     # 0x1ba50
movsd %xmm1, -0x40(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x38(%rbp)
je 0x1a03e
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0xf8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x7730
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x76e0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::getA(context*, signed char, signed char)
NUMBER HMMProblemEloSt::getA (struct context* ctx, NPAR i, NPAR j) {
//    if(this->task->structure != STRUCTURE_ELO)
//    {
//        fprintf(stderr,"Solver specified is not supported.\n");
//        exit(1);
//    }
    NPAR nS = this->task->nS;
    // BKT part
    NUMBER ret = this->param_skill[this->skill1_n*ctx->k + nS + i*nS + j];
    // Elo part
    if( (this->task->elo_scope & BKT_PARAMETER_SCOPE_A)>0 ) {
//        if( ctx->g > -1) {
        NUMBER sig = ((j==0)?1.0:(-1.0));
        ret = sigmoid( sig * this->elo_track_g[ctx->g] + logit(ret));
//        }
    }
    return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0x13(%rbp)
movq 0x28(%rax), %rcx
movl 0x38(%rax), %edx
movq -0x10(%rbp), %rsi
imull (%rsi), %edx
movsbl -0x13(%rbp), %esi
addl %esi, %edx
movsbl -0x11(%rbp), %esi
movsbl -0x13(%rbp), %edi
imull %edi, %esi
addl %esi, %edx
movsbl -0x12(%rbp), %esi
addl %esi, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x68(%rax), %rax
movl 0x24(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jle 0x1a1ad
movsbl -0x12(%rbp), %eax
movsd 0x190e(%rip), %xmm0     # 0x1ba40
movsd 0x1916(%rip), %xmm1     # 0x1ba50
movsd %xmm1, -0x40(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x38(%rbp)
je 0x1a153
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0xf8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x7730
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x76e0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::getB(context*, signed char, signed char)
NUMBER HMMProblemEloSt::getB (struct context* ctx, NPAR i, NPAR m) {
//    if(this->task->structure != STRUCTURE_ELO)
//    {
//        fprintf(stderr,"Solver specified is not supported.\n");
//        exit(1);
//    }
    NPAR nS = this->task->nS;
    NPAR nO = this->task->nO;
    // 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 ret = this->param_skill[this->skill1_n*ctx->k + nS * (1 + nS )+ i*nO + m];
    if( (this->task->elo_scope & BKT_PARAMETER_SCOPE_B)>0 ) {
//        if( ctx->g > -1) {
        NUMBER sig = ((m==0)?1.0:(-1.0));
        ret = sigmoid( sig * this->elo_track_g[ctx->g] + logit(ret));
//        }
    }
    return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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)
movq 0x68(%rax), %rcx
movb 0x900(%rcx), %cl
movb %cl, -0x1b(%rbp)
movq 0x68(%rax), %rax
movb 0x901(%rax), %al
movb %al, -0x1c(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jge 0x1a217
movsd 0x1833(%rip), %xmm0     # 0x1ba40
movsd %xmm0, -0x8(%rbp)
jmp 0x1a2fd
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rcx
movl 0x38(%rax), %edx
movq -0x18(%rbp), %rsi
imull (%rsi), %edx
movsbl -0x1b(%rbp), %esi
movsbl -0x1b(%rbp), %edi
addl $0x1, %edi
imull %edi, %esi
addl %esi, %edx
movsbl -0x19(%rbp), %esi
movsbl -0x1c(%rbp), %edi
imull %edi, %esi
addl %esi, %edx
movsbl -0x1a(%rbp), %esi
addl %esi, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0x68(%rax), %rax
movl 0x24(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jle 0x1a2f3
movsbl -0x1a(%rbp), %eax
movsd 0x17c8(%rip), %xmm0     # 0x1ba40
movsd 0x17d0(%rip), %xmm1     # 0x1ba50
movsd %xmm1, -0x48(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x40(%rbp)
je 0x1a299
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq 0xf8(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x7730
movsd -0x58(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x76e0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::initAlphaEtAl()
void HMMProblemEloSt::initAlphaEtAl() {
    // call the parent initAlphaEtAl
    HMMProblemSt::initAlphaEtAl();
    // init Elo-related stuff
    toZero1D<NCAT>(this->elo_count_g, (NDAT)this->task->nG);
    toZero1D<NUMBER>(this->elo_track_g, (NDAT)this->task->nG); // init on logit scale
    toZero1D<NUMBER>(this->elo_track_t, (NDAT)this->task->N); // init on logit scale
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x12450
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
movq 0x68(%rax), %rax
movl 0x904(%rax), %esi
callq 0x19610
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rdi
movq 0x68(%rax), %rax
movl 0x904(%rax), %esi
callq 0x19350
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
movq 0x68(%rax), %rax
movl 0x8f8(%rax), %esi
callq 0x19350
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::updateValuesLocal(double***, int*, signed char, double*, context*)
void HMMProblemEloSt::updateValuesLocal(NUMBER*** group_skill_map, NCAT* skills, NPAR n_skills, NUMBER* local_pred, struct context *ctx) {
    // parent (BKT's) updateValuesLocal
    HMMProblemSt::updateValuesLocal(group_skill_map, skills, n_skills, local_pred, ctx);
    
    // local Elo updateValuesLocal
    NPAR corr = (NPAR)(1-ctx->o);
    this->elo_track_g[ctx->g] += (this->*sensitivity)(ctx) * (corr - local_pred[0]);
    this->elo_track_t[ctx->t] = this->elo_track_g[ctx->g];
    // update counts
    this->elo_count_g[ctx->g]++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsbl -0x19(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x15080
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movb 0x10(%rax), %dl
movb $0x1, %al
subb %dl, %al
movb %al, -0x31(%rbp)
movq 0xd0(%rcx), %rax
movq %rax, -0x48(%rbp)
movq 0xd8(%rcx), %rdx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1a410
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x58(%rbp)
jmp 0x1a418
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rax
movq -0x30(%rbp), %rsi
callq *%rax
movq -0x50(%rbp), %rax
movsbl -0x31(%rbp), %ecx
cvtsi2sd %ecx, %xmm2
movq -0x28(%rbp), %rcx
subsd (%rcx), %xmm2
movq 0xf8(%rax), %rcx
movq -0x30(%rbp), %rdx
movslq 0x4(%rdx), %rdx
movsd (%rcx,%rdx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0xf8(%rax), %rcx
movq -0x30(%rbp), %rdx
movslq 0x4(%rdx), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x108(%rax), %rcx
movq -0x30(%rbp), %rdx
movslq 0xc(%rdx), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x100(%rax), %rax
movq -0x30(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)