LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemSt.cpp
// Function: HMMProblemSt::doLagrangeStep(FitBitSt*)
void HMMProblemSt::doLagrangeStep(FitBitSt *fb) {
    // goal: for PI, and every row of A, and B multiply by negative gradient and average over the sum
        
    NUMBER buf;
    //NCAT active = 0;
    for(NCAT l=0; l<fb->sclsmplx_n; l++) { // for all vectors (simplexes) that are supposed to sum to 1
        if(fb->sclsmplx_blocks[l]==0) continue; // if the simplex belongs to block that is not in active set, skip
        buf = 0;
        for(NCAT i=fb->sclsmplx_offsets[l]; i<(fb->sclsmplx_offsets[l]+fb->sclsmplx_sizes[l]); i++)
            //if( (this->active_set_param[i] + this->unblocked_param[i]) == 2 ) // in active set and unblocked
                buf -= fb->PARAM[i]*fb->GRAD[i];
        for(NCAT i=fb->sclsmplx_offsets[l]; i<(fb->sclsmplx_offsets[l]+fb->sclsmplx_sizes[l]); i++)
            //if( (this->active_set_param[i] + this->unblocked_param[i]) == 2 ) // in active set and unblocked
                fb->PARAM[i] = (buf>0)? (-fb->PARAM[i]*fb->GRAD[i])/buf : fb->PARAM[i];
    }
}

// Assembly:
movslq 0xc0(%rsi), %rax
testq %rax, %rax
jle 0xed34
pushq %rbx
movq 0xb0(%rsi), %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
movapd 0x2d20(%rip), %xmm1     # 0x119a0
cmpl $0x0, (%rcx,%rdx,4)
je 0xed27
movq 0x98(%rsi), %r8
movq 0xa8(%rsi), %rdi
movslq (%r8,%rdx,4), %r8
movzbl (%rdi,%rdx), %r9d
testb %r9b, %r9b
jle 0xecd2
addq %r8, %r9
movq 0x10(%rsi), %r10
movq 0x30(%rsi), %r11
xorpd %xmm2, %xmm2
movq %r8, %rbx
movsd (%r10,%rbx,8), %xmm3
mulsd (%r11,%rbx,8), %xmm3
subsd %xmm3, %xmm2
incq %rbx
cmpq %r9, %rbx
jl 0xecb8
jmp 0xecd6
xorpd %xmm2, %xmm2
cmpb $0x0, (%rdi,%rdx)
jle 0xed27
movq 0x10(%rsi), %r9
movq %r8, %r10
ucomisd %xmm0, %xmm2
jbe 0xed07
movq 0x10(%rsi), %r11
movq 0x30(%rsi), %rbx
movsd (%r11,%r10,8), %xmm3
xorpd %xmm1, %xmm3
mulsd (%rbx,%r10,8), %xmm3
divsd %xmm2, %xmm3
jmp 0xed11
movq 0x10(%rsi), %r11
movsd (%r11,%r10,8), %xmm3
movsd %xmm3, (%r9,%r10,8)
incq %r10
movsbq (%rdi,%rdx), %r11
addq %r8, %r11
cmpq %r11, %r10
jl 0xece3
incq %rdx
cmpq %rax, %rdx
jne 0xec80
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x2607(%rip), %rsi      # 0x12262
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
movq 0x68(%r12), %rax
movsbq 0x901(%rax), %rdi
movl $0x8, %esi
callq 0x2110
movq %rax, 0x10(%r12)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%r12)
movb 0x901(%r14), %al
testb %al, %al
jle 0xfd0d
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %ebp, %ebp
movsbl %al, %eax
decl %eax
movq 0x10(%r12), %rdx
addq %rbx, %rdx
cmpl %eax, %r13d
leaq 0x27a0(%rip), %rsi      # 0x12455
leaq 0x2794(%rip), %rax      # 0x12450
cmoveq %rax, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x23a0
movq 0x10(%r12), %rax
movsd (%rax,%rbx), %xmm0
ucomisd 0x20(%r12), %xmm0
jbe 0xfcf6
movsd %xmm0, 0x20(%r12)
movsbl %r13b, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%r12)
incq %rbp
movsbq 0x901(%r14), %rax
incl %r13d
addq $0x8, %rbx
cmpq %rax, %rbp
jl 0xfc9e
movq (%rsp), %rax
incl (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movzbl 0x900(%rax), %r13d
leaq 0x1e90(%rip), %rsi      # 0x1223e
movq %r15, %rdi
callq 0x2230
testq %rax, %rax
je 0x1048b
movq %rax, %r14
movq 0x68(%rbx), %rax
movq 0x8a0(%rax), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
leaq 0x4(%rcx), %rdx
cmpl %ebp, (%rcx)
movq %rdx, %rcx
jne 0x103d2
leaq 0x208e(%rip), %r15      # 0x12474
movslq %eax, %rbp
testb %r13b, %r13b
jle 0x10414
xorl %r12d, %r12d
movq 0x70(%rbx), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x22b0
incq %r12
cmpq %r12, %r13
jne 0x103f1
testb %r13b, %r13b
jle 0x10442
xorl %r12d, %r12d
movq 0x90(%rbx), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x22b0
incq %r12
cmpq %r12, %r13
jne 0x1041c
movq 0x68(%rbx), %rax
movq 0x888(%rax), %rax
movsbl (%rax,%rbp), %edx
movq %r14, %rdi
leaq 0x16ef(%rip), %rsi      # 0x11b4a
xorl %eax, %eax
callq 0x22b0
movq 0xb8(%rbx), %rax
movl (%rax,%rbp,4), %eax
cmpl $-0x1, %eax
jne 0x103e6
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
movq %r15, %rdi
callq 0x2bce
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movl %edi, %ebp
movslq %edi, %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x2110
movq %rax, %rbx
testl %r15d, %r15d
jle 0x104da
movslq %r14d, %r14
movl %ebp, %r15d
xorl %r12d, %r12d
movl $0x8, %esi
movq %r14, %rdi
callq 0x2110
movq %rax, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x104c1
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r12d
movslq %edi, %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x2110
movq %rax, 0x8(%rsp)
testl %r15d, %r15d
jle 0x1056d
movslq %r14d, %r14
movslq %ebp, %r15
movl %r12d, %eax
movq %rax, 0x10(%rsp)
movl %r14d, %ebp
xorl %ebx, %ebx
movl $0x8, %esi
movq %r14, %rdi
callq 0x2110
movq %rax, %r12
movq 0x8(%rsp), %rax
movq %r12, (%rax,%rbx,8)
testl %r14d, %r14d
jle 0x10563
xorl %r13d, %r13d
movl $0x8, %esi
movq %r15, %rdi
callq 0x2110
movq %rax, (%r12,%r13,8)
incq %r13
cmpq %r13, %rbp
jne 0x1054a
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x10529
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/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 %rbx
movq %rdi, %rbx
callq 0xac70
leaq 0x663c(%rip), %rax      # 0x16cd0
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
movq 0x68(%rbx), %rax
cmpb $0xe, 0x4e(%rax)
jne 0x106cd
movups %xmm0, 0xe0(%rbx)
movb $0x0, 0xf0(%rbx)
movups %xmm0, 0xf8(%rbx)
movq $0x0, 0x108(%rbx)
popq %rbx
retq
callq 0x2bf2
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xac70
leaq 0x65e8(%rip), %rax      # 0x16cd0
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
cmpb $0xe, 0x4e(%r14)
jne 0x1071c
movl 0x908(%r14), %eax
shll $0x2, %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10734
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2c17
movq %rax, %r14
movq %rbx, %rdi
callq 0xb2a0
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0xe0(%rdi), %rax
movq 0x100(%rdi), %rcx
movsd (%rax), %xmm1
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
leaq 0x1bc4(%rip), %rdx      # 0x124b0
movsd (%rdx,%rax,8), %xmm0
movslq 0x4(%rsi), %rax
mulsd %xmm0, %xmm1
cvtsi2sdl (%rcx,%rax,4), %xmm2
mulsd %xmm1, %xmm2
addsd 0x1046(%rip), %xmm2     # 0x11950
divsd %xmm2, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
subq $0x18, %rsp
movq 0xe0(%rdi), %rax
movq 0x100(%rdi), %rcx
movsd (%rax), %xmm1
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
leaq 0x1b76(%rip), %rdx      # 0x124b0
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movslq 0x4(%rsi), %rax
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax,4), %xmm0
mulsd 0x1b5d(%rip), %xmm0     # 0x124c0
callq 0x2380
mulsd 0x8(%rsp), %xmm0
addsd 0xfda(%rip), %xmm0      # 0x11950
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0xe0(%rdi), %rax
movq 0x100(%rdi), %rcx
movsd (%rax), %xmm1
movslq 0x4(%rsi), %rax
cvtsi2sdl (%rcx,%rax,4), %xmm0
divsd %xmm1, %xmm0
movsd 0xf9f(%rip), %xmm2      # 0x11950
subsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
maxsd %xmm0, %xmm2
movapd 0xfdb(%rip), %xmm3      # 0x119a0
xorpd %xmm2, %xmm3
cmplesd %xmm1, %xmm0
andpd %xmm0, %xmm2
andnpd %xmm3, %xmm0
orpd %xmm2, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rsi), %eax
imull 0x38(%rdi), %eax
addl %edx, %eax
cltq
movq 0x28(%rdi), %rcx
movq 0x68(%rdi), %r8
movsd (%rcx,%rax,8), %xmm0
testb $0x1, 0x24(%r8)
jne 0x10a2d
retq
pushq %rax
xorl %eax, %eax
testb %dl, %dl
sete %al
leaq 0x1a74(%rip), %rcx      # 0x124b0
movsd (%rcx,%rax,8), %xmm1
movq 0xf8(%rdi), %rax
movslq 0x4(%rsi), %rcx
mulsd (%rax,%rcx,8), %xmm1
movsd %xmm1, (%rsp)
callq 0x60d1
addsd (%rsp), %xmm0
popq %rax
jmp 0x60ad
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x28(%rdi), %rax
movq 0x68(%rdi), %r8
movsbl 0x900(%r8), %r9d
movl (%rsi), %r10d
imull 0x38(%rdi), %r10d
imull %r9d, %edx
addl %ecx, %r9d
addl %r10d, %r9d
addl %edx, %r9d
movslq %r9d, %rdx
movsd (%rax,%rdx,8), %xmm0
testb $0x2, 0x24(%r8)
jne 0x10a9b
retq
pushq %rax
xorl %eax, %eax
testb %cl, %cl
sete %al
leaq 0x1a06(%rip), %rcx      # 0x124b0
movsd (%rcx,%rax,8), %xmm1
movq 0xf8(%rdi), %rax
movslq 0x4(%rsi), %rcx
mulsd (%rax,%rcx,8), %xmm1
movsd %xmm1, (%rsp)
callq 0x60d1
addsd (%rsp), %xmm0
popq %rax
jmp 0x60ad
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
testb %cl, %cl
js 0x10b63
movzbl %cl, %eax
movq 0x28(%rdi), %r8
movq 0x68(%rdi), %r9
movsbl 0x901(%r9), %r10d
movl (%rsi), %r11d
imull 0x38(%rdi), %r11d
movsbl 0x900(%r9), %ebx
leal 0x1(%rbx), %ebp
imull %ebx, %ebp
movsbl %dl, %edx
imull %r10d, %edx
addl %eax, %edx
addl %ebp, %edx
addl %r11d, %edx
movslq %edx, %rax
movsd (%r8,%rax,8), %xmm0
testb $0x4, 0x24(%r9)
je 0x10b6b
xorl %eax, %eax
testb %cl, %cl
sete %al
leaq 0x197c(%rip), %rcx      # 0x124b0
movsd (%rcx,%rax,8), %xmm1
movq 0xf8(%rdi), %rax
movslq 0x4(%rsi), %rcx
mulsd (%rax,%rcx,8), %xmm1
movsd %xmm1, (%rsp)
callq 0x60d1
addsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x60ad
movsd 0xde5(%rip), %xmm0      # 0x11950
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb646
movq 0x68(%rbx), %r14
movslq 0x904(%r14), %rdx
testq %rdx, %rdx
jle 0x10ba0
movq 0x100(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2100
movslq 0x904(%r14), %rdx
testq %rdx, %rdx
jle 0x10bbe
movq 0xf8(%rbx), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2100
movslq 0x8f8(%r14), %rdx
testq %rdx, %rdx
jle 0x10be3
movq 0x108(%rbx), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rdi, %r14
callq 0xd99e
movb 0x10(%rbx), %cl
movq 0xd0(%r14), %rax
movq 0xd8(%r14), %rdi
addq %r14, %rdi
testb $0x1, %al
je 0x10c21
movq (%rdi), %rdx
movq -0x1(%rdx,%rax), %rax
movb $0x1, %bpl
subb %cl, %bpl
movq %rbx, %rsi
callq *%rax
movsbl %bpl, %eax
cvtsi2sd %eax, %xmm1
subsd (%r15), %xmm1
movq 0xf8(%r14), %rax
movslq 0x4(%rbx), %rcx
mulsd %xmm0, %xmm1
addsd (%rax,%rcx,8), %xmm1
movsd %xmm1, (%rax,%rcx,8)
movq 0x108(%r14), %rax
movslq 0xc(%rbx), %rdx
movsd %xmm1, (%rax,%rdx,8)
movq 0x100(%r14), %rax
incl (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::postPredictionSave(char const*)
void HMMProblemEloSt::postPredictionSave(const char *filename) {
    // reuse prediction file name to generat new file
    if(this->task->predictions==2) { // if we are saving the skill p-known
        // set file name
        char *fn_suffix = "__ratings.txt";
        char *fn_new = (char *) malloc(1 + strlen(filename)+ strlen(fn_suffix) );
        strcpy(fn_new, filename);
        strcat(fn_new, fn_suffix);
        // open file
        FILE *fid = fopen(fn_new,"w");
        if(fid == NULL)
        {
            fprintf(stderr,"Can't write post-prediction file %s\n",fn_new);
            exit(1);
        }
        for(NDAT t=0; t<this->task->N; t++) {
            fprintf(fid,"%12.10f\n", sigmoid(this->elo_track_t[t]) ); // write probability value, not logit
        }
        // close file
        fclose(fid);
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rax
cmpl $0x2, 0x70(%rax)
jne 0x10d4b
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20e0
leaq 0xe(%rax), %rdi
callq 0x22a0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x21a0
movq %r15, %rdi
callq 0x20e0
movabsq $0x676e697461725f5f, %rcx # imm = 0x676E697461725F5F
movq %rcx, (%r15,%rax)
movabsq $0x7478742e73676e, %rcx # imm = 0x7478742E73676E
movq %rcx, 0x6(%r15,%rax)
leaq 0x155f(%rip), %rsi      # 0x1223e
movq %r15, %rdi
callq 0x2230
testq %rax, %rax
je 0x10d57
movq %rax, %r14
movq 0x68(%rbx), %rax
cmpl $0x0, 0x8f8(%rax)
jle 0x10d38
xorl %r12d, %r12d
leaq 0x1870(%rip), %r15      # 0x12576
movq 0x108(%rbx), %rax
movsd (%rax,%r12,8), %xmm0
callq 0x60ad
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x22b0
incq %r12
movq 0x68(%rbx), %rax
movslq 0x8f8(%rax), %rax
cmpq %rax, %r12
jl 0x10d06
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x2c61
// File: /workspace/github_cpp_makefile_star2_O1/tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::parseCommandLine(int, char**)
void CsvArgs::parseCommandLine(int argc, char *argv[])
{
    const int programName = 1;
    const int requiredUserArgs = 4;
    const int requiredArgs = programName + requiredUserArgs;

    if (argc != requiredArgs)
    {
        throw std::invalid_argument("Usage: ./colReplacer inputData "
            "colToOverwrite colReplaceVal outputData\n");
    }

    inputFname = argv[1];
    colToOverwrite = argv[2];
    colReplaceVal = argv[3];
    outputFname = argv[4];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x5, %esi
jne 0x2587
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %r15
leaq 0x448(%rdi), %r12
movq 0x450(%rdi), %r13
movq %r15, %rdi
callq 0x20b0
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x21b0
movq 0x10(%r14), %r15
movq 0x8(%rbx), %r12
movq %r15, %rdi
callq 0x20b0
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x21b0
movq 0x18(%r14), %r15
leaq 0x20(%rbx), %r12
movq 0x28(%rbx), %r13
movq %r15, %rdi
callq 0x20b0
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x21b0
movq 0x20(%r14), %r14
movq 0x470(%rbx), %r15
addq $0x468, %rbx            # imm = 0x468
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x1a76(%rip), %rsi      # 0x4011
movq %rax, %rdi
callq 0x2240
movq 0x3a3e(%rip), %rsi      # 0x5fe8
movq 0x3a27(%rip), %rdx      # 0x5fd8
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::~CsvArgs()
CsvArgs::~CsvArgs()
{
    if (isInputOpen)
    {
        inputFile.close();
    }
    if (isOutputOpen)
    {
        outputFile.close();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x488(%rdi)
jne 0x25e2
leaq 0x40(%rbx), %rdi
callq 0x2050
cmpb $0x1, 0x489(%rbx)
jne 0x25f7
leaq 0x248(%rbx), %rdi
callq 0x2180
movq 0x468(%rbx), %rdi
leaq 0x478(%rbx), %rax
cmpq %rax, %rdi
je 0x2615
movq (%rax), %rsi
incq %rsi
callq 0x2130
movq 0x448(%rbx), %rdi
leaq 0x458(%rbx), %rax
cmpq %rax, %rdi
je 0x2633
movq (%rax), %rsi
incq %rsi
callq 0x2130
movq 0x398e(%rip), %rax      # 0x5fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x248(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x248(%rbx,%rcx)
leaq 0x250(%rbx), %rdi
callq 0x2110
leaq 0x340(%rbx), %rdi
callq 0x2090
leaq 0x40(%rbx), %rdi
callq 0x2060
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x268d
movq (%rax), %rsi
incq %rsi
callq 0x2130
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x26a5
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x2130
popq %rbx
retq
movq %rax, %rdi
callq 0x2999
nop
// File: /workspace/github_cpp_makefile_star2_O1/tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::getInputData()
std::istream &CsvArgs::getInputData()
{
    if (!isInputOpen)
    {
        inputFile.open(inputFname.c_str(), std::ifstream::in);
        checkFile(&inputFile, "input");
        isInputOpen = true;
    }
    return inputFile;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x488(%rdi)
jne 0x2735
leaq 0x40(%rbx), %r14
movq 0x448(%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x20d0
movq 0x40(%rbx), %rax
addq -0x18(%rax), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x190c(%rip), %rsi      # 0x4004
leaq 0x190a(%rip), %rdx      # 0x4009
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2abc
movq %r14, %rsi
movq %r15, %rdx
callq 0x276a
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x272e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movb $0x1, 0x488(%rbx)
addq $0x40, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2762
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::setOutputData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CsvArgs::setOutputData(const std::string &data)
{
    if (!isOutputOpen)
    {
        outputFile.open(outputFname.c_str(), std::ofstream::out);
        checkFile(&outputFile, "output");
        isOutputOpen = true;
    }
    outputFile << data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x489(%rdi)
jne 0x290e
leaq 0x248(%rbx), %r15
movq 0x468(%rbx), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x2030
movq 0x248(%rbx), %rax
addq -0x18(%rax), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1736(%rip), %rsi      # 0x400a
leaq 0x1735(%rip), %rdx      # 0x4010
movq %rsp, %r12
movq %r12, %rdi
callq 0x2abc
movq %r15, %rsi
movq %r12, %rdx
callq 0x276a
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2907
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2130
movb $0x1, 0x489(%rbx)
addq $0x248, %rbx            # imm = 0x248
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2170
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x294b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/tscott8706[P]cpp-csv-col-replacer/src/CsvProcessor.cpp
// Function: CsvProcessor::findColToReplace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int CsvProcessor::findColToReplace(const std::string &headerName)
{
    getColHeaders();

    int colNum = COL_NOT_FOUND;
    std::istringstream colHeaderProcessor(colHeaders);
    std::string colHeader;

    while (getline(colHeaderProcessor, colHeader, ','))
    {
        if (colHeader == headerName)
        {
            colNum = numCols;
        }
        numCols++;
    }

    if (colNum == COL_NOT_FOUND)
    {
        throw std::invalid_argument("column name doesn't exist in the input "
            "data\n");
    }

    return colNum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, %r14
callq 0x326e
movl 0x2c(%r14), %ebx
leaq 0x8(%r14), %rsi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movl $0x8, %edx
callq 0x21d0
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0x2c, %edx
callq 0x2230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2dab
movq 0x10(%rsp), %rdx
cmpq 0x8(%r15), %rdx
jne 0x2d94
testq %rdx, %rdx
je 0x2d98
movq (%r15), %rsi
movq 0x8(%rsp), %rdi
callq 0x2140
testl %eax, %eax
sete %al
jmp 0x2d9a
xorl %eax, %eax
jmp 0x2d9a
movb $0x1, %al
movl 0x28(%r14), %ecx
testb %al, %al
cmovnel %ecx, %ebx
incl %ecx
movl %ecx, 0x28(%r14)
jmp 0x2d52
cmpl 0x2c(%r14), %ebx
je 0x2dfa
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2dc8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x3201(%rip), %rsi      # 0x5fd0
leaq 0x28(%rsp), %rdi
callq 0x2190
leaq 0xa0(%rsp), %rdi
callq 0x2090
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x128d(%rip), %rsi      # 0x409b
movq %rax, %rdi
callq 0x2240
movq 0x31cb(%rip), %rsi      # 0x5fe8
movq 0x31b4(%rip), %rdx      # 0x5fd8
movq %r14, %rdi
callq 0x21f0
jmp 0x2e3b
movq %rax, %rbx
movq %r14, %rdi
callq 0x20f0
jmp 0x2e3e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2e55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x3174(%rip), %rsi      # 0x5fd0
leaq 0x28(%rsp), %rdi
callq 0x2190
leaq 0xa0(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/tscott8706[P]cpp-csv-col-replacer/src/CsvProcessor.cpp
// Function: CsvProcessor::checkedGetNextWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_istringstream<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void CsvProcessor::checkedGetNextWord(std::string &word,
    std::istringstream &colProcessor, const std::string &line,
    bool expectedResult)
{
    bool result = !getline(colProcessor, word, ',').eof();
    if (result != expectedResult)
    {
        throw std::invalid_argument("Input file is malformed.  " +
            line + " has a different number of columns.  word is " + word);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %rdi
movq %rsi, %r14
movl $0x2c, %edx
callq 0x2230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movb 0x20(%rax,%rcx), %al
andb $0x2, %al
shrb %al
cmpb %bl, %al
je 0x3334
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0xd94(%rip), %rsi       # 0x40dc
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x29a4
leaq 0xd9b(%rip), %rsi       # 0x40f7
leaq 0x28(%rsp), %rdi
callq 0x2250
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3387
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x3394
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x34c8
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x2200
xorl %ebp, %ebp
movq 0x2c12(%rip), %rsi      # 0x5fe8
movq 0x2bfb(%rip), %rdx      # 0x5fd8
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x340b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x340b
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x342a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x342a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x344d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x344d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x345a
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/tscott8706[P]cpp-csv-col-replacer/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    CsvArgs args(argc, argv);
    CsvProcessor processor(args.getInputData());
    std::string output = processor.replaceColVals(args.getColToOverwrite(),
        args.getColReplaceVal());
    args.setOutputData(output);
    return 0;
}

// Assembly:
pushq %rbx
subq $0x520, %rsp            # imm = 0x520
movq %rsi, %rdx
movl %edi, %esi
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x237c
movq %rbx, %rdi
callq 0x26b0
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x2b4c
leaq 0x20(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x2954
movq %rsp, %rdi
leaq 0x90(%rsp), %rsi
callq 0x2976
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
callq 0x2b72
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35aa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2130
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35c5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2130
leaq 0x90(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2882
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35f2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2130
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x360d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2130
leaq 0x90(%rsp), %rdi
callq 0x25cc
xorl %eax, %eax
addq $0x520, %rsp            # imm = 0x520
popq %rbx
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3680
movq 0x50(%rsp), %rsi
jmp 0x3673
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3660
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x3660
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3680
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x3680
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36a0
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x36a0
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x25cc
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/IDEmbedder[P]IDembedder/./Grid.hpp
// Function: Grid::Grid(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
Grid(const std::vector<std::vector<double> >& discrete_points_for_all_dims)
            : _discrete_points(discrete_points_for_all_dims)
            , _number_of_vertices(_discrete_points[0].size())
            , _steps_between_dims(discrete_points_for_all_dims.size(), 1)
            {
                assert(_discrete_points_dim_assert() 
                && "Each dimension in the Grid should contain at least 2 discrete points");
                assert(_discrete_points_dim_sort_assert()
                && "The discrete points should be sorted per each dimension");
                
                _steps_between_dims_calc(); 
                _number_of_vertices *= _steps_between_dims[0];    
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2c58
movq (%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
movq %rcx, 0x18(%rbx)
leaq 0x20(%rbx), %r14
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
leaq 0x8(%rsp), %rdx
movq $0x1, (%rdx)
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
callq 0x2cf2
movq %rbx, %rdi
callq 0x2d70
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
imulq (%rcx), %rax
movq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1ffe
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x10f0
jmp 0x1ffe
movq %rax, %r15
movq %rbx, %rdi
callq 0x2c0a
movq %r15, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/IDEmbedder[P]IDembedder/./ID.hpp
// Function: ID::operator()(std::vector<double, std::allocator<double>> const&) const
const std::vector<Pair>& operator()(const std::vector<double>& vector_to_embed) const {
            assert( _num_of_dims() == vector_to_embed.size()
            && "Number of features should be equal to number of dimensions of discrete points");
            
            std::vector<double> norms(vector_to_embed.size());
            std::vector<size_t> lower_bounds(vector_to_embed.size());
            std::vector<size_t> indices(vector_to_embed.size());
            
            _discrete_points_for_all_dims.find_simplex(vector_to_embed, norms, lower_bounds, indices);
            _embedded_vector_lambdas_calc(norms, indices);
            _embedded_vector_indices_calc(lower_bounds, indices);
            
            return _embedded_vector;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x33b8
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3442
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3442
leaq 0x40(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34cc
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3604
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x367e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2323
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x233a
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2351
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
addq $0x38, %rbx
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x2384
movq %rax, %rbx
jmp 0x239b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2384
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x239b
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x23b2
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/IDEmbedder[P]IDembedder/./IDgroups.hpp
// Function: IDgroups::operator()(std::vector<double, std::allocator<double>> const&) const
const std::vector<Pair>& operator()(const std::vector <double>& vector_to_embed) const {
            assert( _max_number_of_dimensions == vector_to_embed.size()
            && "Number of features should be equal to number of dimensions of discrete points");
            
          	size_t shift_index = 0;
            size_t next_place_index = 0;
            
            for (size_t i = 0; i < _num_of_groups(); i++) {
                std::vector<double> temp_vector_to_embed;
                _init_temp_vector_to_embed(i, vector_to_embed, temp_vector_to_embed);
                const std::vector<Pair>& _part_results(_ids_of_groups[i](temp_vector_to_embed));
                
                _copy_part_results(_part_results, shift_index, next_place_index);
                shift_index += _number_of_vertices_of_groups[i];
            }
            
            return _embedded_vector_groups;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
je 0x27d0
movq %rsi, %r14
xorl %r15d, %r15d
movq %rsp, %r12
xorl %ebp, %ebp
xorl %r13d, %r13d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x4b70
leaq (%r15,%r15,4), %rdi
shlq $0x4, %rdi
addq 0x50(%rbx), %rdi
movq %r12, %rsi
callq 0x2272
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0x278d
movq %rbp, %rdx
shlq $0x4, %rdx
movq 0x18(%rbx), %rsi
movups (%rcx), %xmm0
movups %xmm0, (%rsi,%rdx)
movq 0x18(%rbx), %rsi
addq %r13, (%rsi,%rdx)
incq %rbp
addq $0x10, %rcx
addq $0x10, %rdx
cmpq %rax, %rcx
jne 0x276a
movq 0x30(%rbx), %rax
addq (%rax,%r15,8), %r13
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27ab
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
incq %r15
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %r15
jb 0x2722
addq $0x18, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27e8
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2801
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O1/IDEmbedder[P]IDembedder/./IDgroupsPair.hpp
// Function: IDgroupsPair::IDgroupsPair(GridsOfGroups const&, std::vector<std::vector<unsigned long, std::allocator<unsigned long>>, std::allocator<std::vector<unsigned long, std::allocator<unsigned long>>>> const&)
IDgroupsPair(const GridsOfGroups& grids_of_groups, const std::vector<std::vector<size_t> >& indices_of_groups) 
            : IDgroupsBase(  indices_of_groups, 
                            _embedded_vector_size_calc(indices_of_groups), 
                            grids_of_groups.get_max_number_of_dimensions())
                            {
                                for (size_t i = 0; i < grids_of_groups.get_number_of_groups(); i++) {
                                    _ids_of_groups.push_back(grids_of_groups[i]);
                                                                        
                                    size_t number_of_vertices = grids_of_groups[i].get_num_of_vertices();
                                    number_of_vertices *= number_of_vertices;
                                    
                                    _number_of_vertices_of_groups.push_back(number_of_vertices);
                                }
                            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rcx
movq 0x8(%rdx), %rsi
xorl %eax, %eax
cmpq %rsi, %rcx
je 0x2843
movq 0x8(%rcx), %rdi
subq (%rcx), %rdi
sarq $0x2, %rdi
addq %rdi, %rax
incq %rax
addq $0x18, %rcx
jmp 0x2827
movq 0x18(%r14), %rcx
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x43a2
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq $0x0, 0x60(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x2933
leaq 0x50(%rbx), %r15
leaq 0x30(%rbx), %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
xorl %r12d, %r12d
addq %rbp, %rsi
movq %r13, %rdi
callq 0x2510
movq %r15, %rdi
movq %r13, %rsi
callq 0x4d56
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x28b4
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x28cb
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %r13, %rdi
callq 0x2c0a
movq (%r14), %rax
movq 0x18(%rax,%rbp), %rax
imulq %rax, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x28fb
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x2907
movq (%rsp), %rdi
movq %r13, %rdx
callq 0x50e2
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rax
addq $0x38, %rbp
cmpq %rax, %r12
jb 0x2887
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2944
movq %rax, %r14
jmp 0x2956
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2b62
movq %r15, %rdi
callq 0x4d26
movq %rbx, %rdi
callq 0x442a
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/IDEmbedder[P]IDembedder/./IDgroupsPair.hpp
// Function: IDgroupsPair::operator()(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
const std::vector<Pair>& operator()(const std::vector<double>& vector_to_cmp1, const std::vector<double>& vector_to_cmp2) const {
            assert(_max_number_of_dimensions == vector_to_cmp1.size()
            && _max_number_of_dimensions == vector_to_cmp2.size()
            && "Number of features should be equal to number of dimensions of discrete points");
            
            size_t shift_index = 0;
            size_t next_place_index = 0;
            
            for (size_t i = 0; i < _num_of_groups(); i++) {
                std::vector<double> temp_vector_to_cmp1;
                std::vector<double> temp_vector_to_cmp2;
                _init_temp_vector_to_embed(i, vector_to_cmp1, temp_vector_to_cmp1);
                _init_temp_vector_to_embed(i, vector_to_cmp2, temp_vector_to_cmp2);

                const std::vector<Pair>& _part_results(_ids_of_groups[i](temp_vector_to_cmp1, temp_vector_to_cmp2));
                
                _copy_part_results(_part_results, shift_index, next_place_index);
                shift_index += _number_of_vertices_of_groups[i];
            }
            
            return _embedded_vector_groups;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x38(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
je 0x2a92
leaq 0x20(%rsp), %r12
movq %rsp, %r13
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %eax, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq 0x40(%rsp), %rdx
movq %r12, %rcx
callq 0x4b70
movq %rbx, %rdi
movq %rbp, %rsi
movq 0x38(%rsp), %rdx
movq %r13, %rcx
callq 0x4b70
leaq (,%rbp,4), %rdi
addq %rbp, %rdi
shlq $0x4, %rdi
addq 0x50(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2564
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0x2a38
movq %r14, %rdx
shlq $0x4, %rdx
movq 0x18(%rbx), %rsi
movups (%rcx), %xmm0
movups %xmm0, (%rsi,%rdx)
movq 0x18(%rbx), %rsi
addq %r15, (%rsi,%rdx)
incq %r14
addq $0x10, %rcx
addq $0x10, %rdx
cmpq %rax, %rcx
jne 0x2a15
movq 0x30(%rbx), %rax
addq (%rax,%rbp,8), %r15
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2a56
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2a6d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
incq %rbp
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %rbp
jb 0x29a6
addq $0x18, %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2aaa
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2ac3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2ada
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160