LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::StripedArray(_IO_FILE*, int)
StripedArray<T>::StripedArray(FILE *f, NDAT N) {
	stripe_size = 20000;
//    complex = false;
	size = N;
	nstripes = (NDAT)ceil((double)N/stripe_size);
	size_last_stripe = (NDAT)fmod(N, stripe_size);
	stripes = (T **) calloc((size_t)nstripes, sizeof(T*));
    NDAT num;
    NDAT nread;
    for(NDAT i=0; i<nstripes; i++) {
        num = (i<(nstripes-1)?stripe_size:size_last_stripe);
        stripes[i] = (T*)calloc((size_t)num, sizeof(T)); // alloc data
        nread = (NDAT)fread (stripes[i], sizeof(T), (size_t)num, f);
        if(nread != num) {
            fprintf(stderr,"Error reading data from file\n");
            return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x4e20, 0x4(%rax)      # imm = 0x4E20
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
cvtsi2sdl -0x14(%rbp), %xmm0
cvtsi2sdl 0x4(%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x50a0
movq -0x28(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %edi
movl 0x4(%rax), %esi
callq 0x18bc0
movq -0x28(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0xc(%rax)
movslq 0x8(%rax), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x16efc
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x16e78
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x16e82
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5180
movq %rax, %rsi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x20(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movslq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x5470
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x16eec
movq 0x440ff(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x394d0(%rip), %rsi     # 0x503b3
movb $0x0, %al
callq 0x5440
jmp 0x16efc
jmp 0x16eee
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x16e4b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::addStripe()
void StripedArray<T>::addStripe() {
	if(this->size_last_stripe<this->stripe_size && this->nstripes>0) {
		fprintf(stderr, "Exception! You can only add stripes when none exits or previous is full.\n");
		return;
	}
	
	this->stripes = (T **) realloc(this->stripes,(size_t)(++this->nstripes)*sizeof(T*)); // add pointer
//	T** new_stripes = Calloc(T*, (this->nstripes));
//	memcpy(new_stripes, this->stripes, sizeof(T*)*this->nstripes );
//	free(this->stripes);
//	this->stripes = Malloc(T*,this->nstripes+1);
//	memcpy(this->stripes, new_stripes, sizeof(T*)*this->nstripes );
//	this->nstripes++;
//	free(new_stripes);
	
//	this->stripes[this->nstripes-1] = Calloc(T, (size_t)this->stripe_size); // alloc data
	this->stripes[this->nstripes-1] = (T*)calloc((size_t)this->stripe_size, sizeof(T)); // alloc data
	this->size_last_stripe = 0; // reset counter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0xc(%rcx), %eax
cmpl 0x4(%rcx), %eax
jge 0x17500
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x17500
movq 0x43aeb(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x38e72(%rip), %rsi     # 0x50369
movb $0x0, %al
callq 0x5440
jmp 0x17555
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x54e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq 0x4(%rax), %rdi
movl $0x1, %esi
callq 0x5180
movq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movl 0x8(%rax), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq %rsi, (%rcx,%rdx,8)
movl $0x0, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/PULogistic.cpp
// Function: PULogistic::unite(double*, int, double*, int)
NUMBER PULogistic::unite(NUMBER* standard, NCAT nstandard, NUMBER* pooled, NCAT npooled) {
	NUMBER num = 1;
	NUMBER den = 1;
	NUMBER safe = 0;
	if(standard != NULL && nstandard > 0) {
		for(NCAT i=0; i<=nstandard; i++) {
			safe = safe01num(standard[i]);
			num *= 1 - safe;
			den *=     safe;
		}
	}
	if(pooled != NULL && npooled > 0) {
		for(NCAT i=0; i<=nstandard; i++) {
			safe = safe01num(pooled[i]);
			num *= 1 - safe;
			den *=     safe;
		}
	}
	return 1/( 1 + num/safe0num(den) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movsd 0x36d35(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x30(%rbp)
movsd 0x36d28(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x18d53
cmpl $0x0, -0x14(%rbp)
jle 0x18d53
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x18d51
movq -0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x99d0
movsd %xmm0, -0x40(%rbp)
movsd 0x36ce0(%rip), %xmm0    # 0x4fa08
subsd -0x40(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x40(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x18d01
jmp 0x18d53
cmpq $0x0, -0x20(%rbp)
je 0x18db9
cmpl $0x0, -0x24(%rbp)
jle 0x18db9
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x18db7
movq -0x20(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x99d0
movsd %xmm0, -0x40(%rbp)
movsd 0x36c7a(%rip), %xmm0    # 0x4fa08
subsd -0x40(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x40(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x18d67
jmp 0x18db9
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x9a40
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd 0x36c27(%rip), %xmm1    # 0x4fa08
addsd %xmm0, %xmm1
movsd 0x36c1b(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/PULogistic.cpp
// Function: PULogistic::derivativePair(double, double, signed char)
NUMBER PULogistic::derivativePair(NUMBER standard, NUMBER pooled, NPAR which) {
	NUMBER united = pair(standard, pooled);
	// which 0-standard, 1-pooled
	NUMBER deriv_param = 0;
	if(which==0) {
		NUMBER safe_standard = safe01num(standard);
		deriv_param = 1 / ( safe_standard * (1 - safe_standard) );
	} else if(which==1) {
		NUMBER safe_pooled   = safe01num(pooled);
		deriv_param = 1 / (   safe_pooled * (1 -   safe_pooled) );
	}
	return united * (1-united) * deriv_param;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq (%rdi), %rax
callq *(%rax)
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x18e7d
movsd -0x10(%rbp), %xmm0
callq 0x99d0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0x36ba7(%rip), %xmm0    # 0x4fa08
subsd -0x38(%rbp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x36b96(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x18ebe
movsbl -0x19(%rbp), %eax
cmpl $0x1, %eax
jne 0x18ebc
movsd -0x18(%rbp), %xmm0
callq 0x99d0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm1
movsd 0x36b66(%rip), %xmm0    # 0x4fa08
subsd -0x40(%rbp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x36b55(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x18ebe
movsd -0x28(%rbp), %xmm0
movsd 0x36b3d(%rip), %xmm1    # 0x4fa08
subsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/PULogistic.cpp
// Function: PULogistic::derivativeUnite(double*, int, double*, int, signed char, int)
NUMBER PULogistic::derivativeUnite(NUMBER* standard, NCAT nstandard, NUMBER* pooled, NCAT npooled, NPAR which, NCAT index) {
	NUMBER united = unite(standard, nstandard, pooled, npooled);
	// which 0-standard, 1-pooled
	NUMBER deriv_param = 0;
	if(which==0) {
		NUMBER safe_standard = safe01num(standard[index]);
		deriv_param = 1 / ( safe_standard * (1 - safe_standard) );
	} else if(which==1) {
		NUMBER safe_pooled   = safe01num(pooled[index]);
		deriv_param = 1 / (   safe_pooled * (1 -   safe_pooled) );
	}
	return united * (1-united) * deriv_param;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r9b, %al
movl 0x10(%rbp), %r9d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movq (%rdi), %rax
callq *0x8(%rax)
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x0, %eax
jne 0x18f74
movq -0x10(%rbp), %rax
movslq 0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x99d0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm1
movsd 0x36ab0(%rip), %xmm0    # 0x4fa08
subsd -0x40(%rbp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x36a9f(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x18fbd
movsbl -0x25(%rbp), %eax
cmpl $0x1, %eax
jne 0x18fbb
movq -0x20(%rbp), %rax
movslq 0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x99d0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm1
movsd 0x36a67(%rip), %xmm0    # 0x4fa08
subsd -0x48(%rbp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x36a56(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x18fbd
movsd -0x30(%rbp), %xmm0
movsd 0x36a3e(%rip), %xmm1    # 0x4fa08
subsd -0x30(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/PULogistic.cpp
// Function: PULogistic::derivativeUnite(double, double, double, signed char)
NUMBER PULogistic::derivativeUnite(NUMBER united, NUMBER standard, NUMBER pooled, NPAR which) {
	// which 0-standard, 1-pooled
	NUMBER deriv_param = 0;
	if(which==0) {
		NUMBER safe_standard = safe01num(standard);
		deriv_param = 1 / ( safe_standard * (1 - safe_standard) );
	} else if(which==1) {
		NUMBER safe_pooled   = safe01num(pooled);
		deriv_param = 1 / (   safe_pooled * (1 -   safe_pooled) );
	}
	return united * (1-united) * deriv_param;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movb %al, -0x21(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x1904a
movsd -0x18(%rbp), %xmm0
callq 0x99d0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0x369da(%rip), %xmm0    # 0x4fa08
subsd -0x38(%rbp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x369c9(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x1908b
movsbl -0x21(%rbp), %eax
cmpl $0x1, %eax
jne 0x19089
movsd -0x20(%rbp), %xmm0
callq 0x99d0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm1
movsd 0x36999(%rip), %xmm0    # 0x4fa08
subsd -0x40(%rbp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x36988(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x1908b
movsd -0x10(%rbp), %xmm0
movsd 0x36970(%rip), %xmm1    # 0x4fa08
subsd -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/PUCorbettianAdditive.cpp
// Function: PUCorbettianAdditive::sumOdds(double*, int, double*, int)
NUMBER PUCorbettianAdditive::sumOdds(NUMBER* standard, NCAT nstandard, NUMBER* pooled, NCAT npooled) {
	NUMBER sum_odds = 0;
	if(standard != NULL && nstandard > 0) {
		for(NCAT i=0; i<=nstandard; i++) {
			sum_odds += standard[i] / safe0num(1-standard[i]);
		}
	}
	if(pooled != NULL && npooled > 0) {
		for(NCAT i=0; i<=nstandard; i++) {
			sum_odds += pooled[i];
		}
	}
	return sum_odds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x191ae
cmpl $0x0, -0x14(%rbp)
jle 0x191ae
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x191ac
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd 0x36887(%rip), %xmm0    # 0x4fa08
subsd (%rax,%rcx,8), %xmm0
callq 0x9a40
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
divsd %xmm1, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x19157
jmp 0x191ae
cmpq $0x0, -0x20(%rbp)
je 0x191ee
cmpl $0x0, -0x24(%rbp)
jle 0x191ee
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x191ec
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x191c2
jmp 0x191ee
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/PUCorbettianAdditive.cpp
// Function: PUCorbettianAdditive::derivativeUnite(double*, int, double*, int, signed char, int)
NUMBER PUCorbettianAdditive::derivativeUnite(NUMBER* standard, NCAT nstandard, NUMBER* pooled, NCAT npooled, NPAR which, NCAT index) {
	NUMBER sum_odds = sumOdds(standard, nstandard, pooled, npooled);
	// which 0-standard
	// \frac{1}{ (1+O_{ x_{ i },g_{ j } }^{ add } )^2 } \frac { 1 }{ (1-x_{ i })^2 }
	// which 1-pooled
	// \frac{1}{ (1+O_{ x_{ i },g_{ j } }^{ add } )2 }
	return 1 / ( pow(1+sum_odds,2) ) * ((which==0) ? ( 1/(pow( safe0num(1-standard[index]) ,2)) ) : 1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movl 0x10(%rbp), %r9d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x19120
movsd %xmm0, -0x30(%rbp)
movsd 0x3669e(%rip), %xmm0    # 0x4fa08
addsd -0x30(%rbp), %xmm0
movl $0x2, %edi
callq 0xf6b0
movaps %xmm0, %xmm1
movsd 0x36684(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x0, %eax
jne 0x193d0
movq -0x10(%rbp), %rax
movslq 0x10(%rbp), %rcx
movsd 0x36662(%rip), %xmm0    # 0x4fa08
subsd (%rax,%rcx,8), %xmm0
callq 0x9a40
movl $0x2, %edi
callq 0xf6b0
movaps %xmm0, %xmm1
movsd 0x36643(%rip), %xmm0    # 0x4fa08
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x193df
movsd 0x36630(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x40(%rbp)
jmp 0x193df
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::HMMProblem()
HMMProblem::HMMProblem() {
    // set fields to null that you don't want to be messing up the code in the overriding classes
    // e.g., *sliced* classses would redefine A and possibly B and the HMMProblem descroy method
    // would still try to free the "old" A or B that were never initialized
    this->pi = NULL;
    this->A = NULL;
    this->B = NULL;
    this->lbPI = NULL;
    this->lbA = NULL;
    this->lbB = NULL;
    this->ubPI = NULL;
    this->ubA = NULL;
    this->ubB = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x4107d(%rip), %rcx     # 0x5a570
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::HMMProblem(param*)
HMMProblem::HMMProblem(struct param *param) {
    NPAR i;
    switch (param->structure) {
        case STRUCTURE_SKILL: // Expectation Maximization (Baum-Welch)
            for(i=0; i<3; i++) this->sizes[i] = param->nK;
            this->n_params = param->nK * 4;
            break;
//        case STRUCTURE_GROUP: // Gradient Descent by group
//            for(i=0; i<3; i++) this->sizes[i] = param->nG;
//            this->n_params = param->nG * 4;
//            break;
        default:
            fprintf(stderr,"Structure specified is not supported and should have been caught earlier\n");
            break;
    }
    init(param);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x41011(%rip), %rcx     # 0x5a580
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb 0x3e(%rax), %al
subb $0x1, %al
jne 0x195c3
jmp 0x1957f
movb $0x0, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3, %eax
jge 0x195ad
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c0(%rcx), %edx
movsbq -0x11(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,4)
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x19583
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c0(%rcx), %ecx
shll $0x2, %ecx
movl %ecx, 0x8(%rax)
jmp 0x195db
movq 0x41a0e(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x36e51(%rip), %rsi     # 0x50425
movb $0x0, %al
callq 0x5440
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x70(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::readModel(char const*, bool)
void HMMProblem::readModel(const char *filename, bool overwrite) {
	FILE *fid = fopen(filename,"r");
	if(fid == NULL)
	{
		fprintf(stderr,"Can't read model file %s\n",filename);
		exit(1);
	}
	int max_line_length = 1024;
	char *line = Malloc(char,(size_t)max_line_length);
	NDAT line_no = 0;
    struct param initparam;
    set_param_defaults(&initparam);
    
    //
    // read solver info
    //
    if(overwrite)
        readSolverInfo(fid, this->p, &line_no);
    else
        readSolverInfo(fid, &initparam, &line_no);
    //
    // read model
    //
    readModelBody(fid, &initparam, &line_no, overwrite);
		
	fclose(fid);
	free(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x9f0, %rsp            # imm = 0x9F0
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x9e8(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x34f58(%rip), %rsi     # 0x4f178
callq 0x5370
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1a256
movq 0x40da1(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x34f35(%rip), %rsi     # 0x4f17a
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movl $0x400, -0x24(%rbp)     # imm = 0x400
movslq -0x24(%rbp), %rdi
shlq $0x0, %rdi
callq 0x53e0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x9e0(%rbp), %rdi
callq 0xb1d0
testb $0x1, -0x11(%rbp)
je 0x1a2a4
movq -0x9e8(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x88(%rax), %rsi
leaq -0x34(%rbp), %rdx
callq 0xbd80
jmp 0x1a2b8
movq -0x20(%rbp), %rdi
leaq -0x9e0(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0xbd80
movq -0x9e8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x11(%rbp), %r8b
movq (%rdi), %rax
leaq -0x9e0(%rbp), %rdx
leaq -0x34(%rbp), %rcx
andb $0x1, %r8b
movzbl %r8b, %r8d
callq *0x68(%rax)
movq -0x20(%rbp), %rdi
callq 0x52c0
movq -0x30(%rbp), %rdi
callq 0x5380
addq $0x9f0, %rsp            # imm = 0x9F0
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::destroy()
void HMMProblem::destroy() {
	// destroy model data
    if(this->null_obs_ratio != NULL) free(this->null_obs_ratio);
	if(this->pi != NULL) free2D<NUMBER>(this->pi, this->sizes[0]);
	if(this->A  != NULL) free3D<NUMBER>(this->A,  this->sizes[1], this->p->nS);
	if(this->B  != NULL) free3D<NUMBER>(this->B,  this->sizes[2], this->p->nS);
	if(this->lbPI!=NULL) free(this->lbPI);
	if(this->ubPI!=NULL) free(this->ubPI);
	if(this->lbA!=NULL) free2D<NUMBER>(this->lbA, this->p->nS);
	if(this->ubA!=NULL) free2D<NUMBER>(this->ubA, this->p->nS);
	if(this->lbB!=NULL) free2D<NUMBER>(this->lbB, this->p->nS);
	if(this->ubB!=NULL) free2D<NUMBER>(this->ubB, this->p->nS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x1a398
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5380
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1a3b3
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl 0xc(%rax), %esi
callq 0xc7f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1a3dc
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movl 0x10(%rax), %esi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %edx
callq 0x11290
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1a405
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl 0x14(%rax), %esi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %edx
callq 0x11290
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x1a41d
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5380
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1a435
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x5380
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x1a45b
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %esi
callq 0xc7f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x1a481
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %esi
callq 0xc7f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1a4a7
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %esi
callq 0xc7f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x1a4cd
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq 0x88(%rax), %rax
movsbl 0x8b8(%rax), %esi
callq 0xc7f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::getPI(int)
NUMBER* HMMProblem::getPI(NCAT x) {
	if( x > (this->sizes[0]-1) ) {
		fprintf(stderr,"While accessing PI, skill index %d exceeded last index of the data %d.\n", x, this->sizes[0]-1);
		exit(1);
	}
	return this->pi[x];
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl 0x14(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x1a693
movq -0x18(%rbp), %rax
movq 0x40969(%rip), %rcx     # 0x5afd8
movq (%rcx), %rdi
movl -0xc(%rbp), %edx
movl 0x14(%rax), %ecx
subl $0x1, %ecx
leaq 0x35e9d(%rip), %rsi     # 0x5051f
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::getPI(data*, signed char)
NUMBER HMMProblem::getPI(struct data* dt, NPAR i) {
    switch(this->p->structure)
    {
        case STRUCTURE_SKILL:
            return this->pi[dt->k][i];
            break;
//        case STRUCTURE_GROUP:
//            return this->pi[dt->g][i];
//            break;
        default:
            fprintf(stderr,"Solver specified is not supported.\n");
            exit(1);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x88(%rax), %rax
movb 0x3e(%rax), %al
subb $0x1, %al
jne 0x1a881
jmp 0x1a85d
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x11(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addq $0x20, %rsp
popq %rbp
retq
movq 0x40750(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x35cd4(%rip), %rsi     # 0x50566
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::getA(data*, signed char, signed char)
NUMBER HMMProblem::getA (struct data* dt, NPAR i, NPAR j) {
    switch(this->p->structure)
    {
        case STRUCTURE_SKILL:
            return this->A[dt->k][i][j];
            break;
//        case STRUCTURE_GROUP:
//            return this->A[dt->g][i][j];
//            break;
        default:
            fprintf(stderr,"Solver specified is not supported.\n");
            exit(1);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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, -0x20(%rbp)
movq 0x88(%rax), %rax
movb 0x3e(%rax), %al
subb $0x1, %al
jne 0x1a90f
jmp 0x1a8e2
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x11(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x12(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addq $0x20, %rsp
popq %rbp
retq
movq 0x406c2(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x35c46(%rip), %rsi     # 0x50566
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::getB(data*, signed char, signed char)
NUMBER HMMProblem::getB (struct data* dt, NPAR i, NPAR m) {
    // special attention for "unknonw" observations, i.e. the observation was there but we do not know what it is
    // in this case we simply return 1, effectively resulting in no change in \alpha or \beta vatiables
    if(m<0)
        return 1;
    switch(this->p->structure)
    {
        case STRUCTURE_SKILL:
            return this->B[dt->k][i][m];
            break;
//        case STRUCTURE_GROUP:
//            return this->B[dt->g][i][m];
//            break;
        default:
            fprintf(stderr,"Solver specified is not supported.\n");
            exit(1);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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, -0x28(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jge 0x1a97a
movsd 0x35095(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x8(%rbp)
jmp 0x1a9de
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rax
movb 0x3e(%rax), %al
subb $0x1, %al
jne 0x1a9bc
jmp 0x1a98e
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x19(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x1a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1a9de
movq 0x40615(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x35b99(%rip), %rsi     # 0x50566
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::initBeta(int, data**)
void HMMProblem::initBeta(NCAT xndat, struct data** x_data) {
	NPAR nS = this->p->nS;
//    int parallel_now = this->p->parallel==2; //PAR
//    #pragma omp parallel for schedule(dynamic) if(parallel_now) //PAR
	for(NCAT x=0; x<xndat; x++) {
        NDAT t;
        NPAR i;
		if( x_data[x]->cnt!=0 ) continue; // ... and the thing has not been computed yet (e.g. from group to skill)
		// beta
		if( x_data[x]->beta == NULL ) {
			x_data[x]->beta = Calloc(NUMBER*, (size_t)x_data[x]->n);
			for(t=0; t<x_data[x]->n; t++)
				x_data[x]->beta[t] = Calloc(NUMBER, (size_t)nS);
			
		} else {
			for(t=0; t<x_data[x]->n; t++)
				for(i=0; i<nS; i++)
					x_data[x]->beta[t][i] = 0.0;
		}
	} // for all groups in skill
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movb 0x8b8(%rax), %al
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b0b9
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x4(%rax)
je 0x1afb1
jmp 0x1b0ab
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1b041
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rcx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x30(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
jge 0x1b03f
movsbq -0x19(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x30(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1aff7
jmp 0x1b0a9
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
jge 0x1b0a7
movb $0x0, -0x25(%rbp)
movsbl -0x25(%rbp), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1b09a
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x30(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x25(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movb -0x25(%rbp), %al
addb $0x1, %al
movb %al, -0x25(%rbp)
jmp 0x1b05f
jmp 0x1b09c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1b048
jmp 0x1b0a9
jmp 0x1b0ab
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1af8e
addq $0x30, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::setGradPI(FitBit*)
void HMMProblem::setGradPI(FitBit *fb){
    if(this->p->block_fitting[0]>0) return;
    NDAT t = 0, ndat = 0;
    NPAR i, o;
    struct data* dt;
    for(NCAT x=0; x<fb->xndat; x++) {
        dt = fb->x_data[x];
        if( dt->cnt!=0 ) continue;
        ndat += dt->n;
        o = this->p->dat_obs[ dt->ix[t] ];//->get( dt->ix[t] );
        for(i=0; i<this->p->nS; i++) {
            fb->gradPI[i] -= dt->beta[t][i] * ((o<0)?1:fb->B[i][o]) / safe0num(dt->p_O_param);
        }
    }
    if( this->p->Cslices>0 ) // penalty
        fb->addL2Penalty(FBV_PI, this->p, (NUMBER)ndat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x88(%rax), %rax
movsbl 0x981(%rax), %eax
cmpl $0x0, %eax
jle 0x1bdc0
jmp 0x1bf4f
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xe8(%rcx), %eax
jge 0x1bf1d
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x1be0e
jmp 0x1bf0f
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq 0x88(%rax), %rax
movq 0x870(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1a(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x38(%rbp), %rcx
movsbl -0x19(%rbp), %eax
movq 0x88(%rcx), %rcx
movsbl 0x8b8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1bf0d
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x19(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jge 0x1be9b
movsd 0x33b74(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x48(%rbp)
jmp 0x1bebb
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movsbq -0x19(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x1a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movsd 0x48(%rax), %xmm0
callq 0x9a40
movsd -0x50(%rbp), %xmm1
divsd %xmm0, %xmm1
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movsbq -0x19(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x1be46
jmp 0x1bf0f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1bdd5
movq -0x38(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x42(%rax), %eax
cmpl $0x0, %eax
jle 0x1bf4f
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x88(%rax), %rdx
cvtsi2sdl -0x18(%rbp), %xmm0
movl $0x1, %esi
callq 0xf200
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::computeGradients(FitBit*)
NDAT HMMProblem::computeGradients(FitBit *fb){
    fb->toZero(FBS_GRAD);
    
    NDAT ndat = computeAlphaAndPOParam(fb->xndat, fb->x_data);
    computeBeta(fb->xndat, fb->x_data);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0xdff0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xe8(%rax), %esi
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdx
callq 0x1b0c0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xe8(%rax), %esi
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdx
callq 0x1b690
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1c445
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x981(%rax), %eax
cmpl $0x0, %eax
jne 0x1c445
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1c475
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x982(%rax), %eax
cmpl $0x0, %eax
jne 0x1c475
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1c4a5
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x983(%rax), %eax
cmpl $0x0, %eax
jne 0x1c4a5
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::computeGradientsBig(FitBit**, int)
NDAT HMMProblem::computeGradientsBig(FitBit **fbs, NCAT nfbs){
    NCAT xndat = this->p->nSeq;
    struct data** x_data = this->p->k_data;
//    NPAR kg_flag = -1;
   
	NCAT x;
    
//    switch(this->p->structure)
//    {
//        case STRUCTURE_SKILL:
//            kg_flag = 0;
//            break;
//        case STRUCTURE_GROUP:
//            kg_flag = 1;
//            break;
//    }

    // there are as many fbs as skills or groups in this setup
    for(x=0; x<nfbs; x++)
        fbs[x]->toZero(FBS_GRAD);
    
    NDAT ndat = computeAlphaAndPOParam(xndat, x_data);
    computeBeta(xndat, x_data);

    
	for(x=0; x<nfbs; x++) {
        if(fbs[x]->pi != NULL && this->p->block_fitting[0]==0) setGradPI(fbs[x]);
        if(fbs[x]->A  != NULL && this->p->block_fitting[1]==0) setGradA (fbs[x]);
        if(fbs[x]->B  != NULL && this->p->block_fitting[2]==0) setGradB (fbs[x]);
    }// for all sequences
    return ndat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x88(%rax), %rcx
movl 0x8dc(%rcx), %ecx
movl %ecx, -0x18(%rbp)
movq 0x88(%rax), %rax
movq 0x8f0(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c51d
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x3, %esi
callq 0xdff0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c4f4
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x1b0c0
movq -0x30(%rbp), %rdi
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x1b690
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c623
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0x1c593
movq -0x30(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x981(%rax), %eax
cmpl $0x0, %eax
jne 0x1c593
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x18(%rax)
je 0x1c5d3
movq -0x30(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x982(%rax), %eax
cmpl $0x0, %eax
jne 0x1c5d3
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x20(%rax)
je 0x1c613
movq -0x30(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x983(%rax), %eax
cmpl $0x0, %eax
jne 0x1c613
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x1c615
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c547
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::toFile(char const*)
void HMMProblem::toFile(const char *filename) {
    switch(this->p->structure)
    {
        case STRUCTURE_SKILL:
            toFileSkill(filename);
            break;
//        case STRUCTURE_GROUP:
//            toFileGroup(filename);
//            break;
        default:
            fprintf(stderr,"Solver specified is not supported.\n");
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x88(%rax), %rax
movb 0x3e(%rax), %al
subb $0x1, %al
jne 0x1c667
jmp 0x1c658
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c690
jmp 0x1c67f
movq 0x3e96a(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x33eee(%rip), %rsi     # 0x50566
movb $0x0, %al
callq 0x5440
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::fit()
void HMMProblem::fit() {
    NUMBER* loglik_rmse = init1D<NUMBER>(2);
    FitNullSkill(loglik_rmse, false /*do RMSE*/);
    switch(this->p->solver)
    {
        case METHOD_BW: // Conjugate Gradient Descent
            loglik_rmse[0] += BaumWelch();
            break;
        case METHOD_GD: // Gradient Descent
        case METHOD_CGD: // Conjugate Gradient Descent
        case METHOD_GDL: // Gradient Descent, Lagrange
        case METHOD_GBB: // Brzilai Borwein Gradient Method
            loglik_rmse[0] += GradientDescent();
            break;
        default:
            fprintf(stderr,"Solver specified is not supported.\n");
            break;
    }
    this->neg_log_lik = loglik_rmse[0];
    free(loglik_rmse);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, %edi
callq 0xc410
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1e830
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movsbl 0x3f(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x1e7b7
jmp 0x1e7aa
movl -0x14(%rbp), %eax
addl $-0x2, %eax
subl $0x4, %eax
jb 0x1e7ce
jmp 0x1e7e9
movq -0x20(%rbp), %rdi
callq 0x1ebb0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x1e801
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x1e801
movq 0x3c7e8(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x31d6c(%rip), %rsi     # 0x50566
movb $0x0, %al
callq 0x5440
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x5380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::free3Params(double*&, double**&, double**&, signed char)
void HMMProblem::free3Params(NUMBER* &PI, NUMBER** &A, NUMBER** &B, NPAR nS) {
    free(PI);
    free2D<NUMBER>(A, (NDAT)nS);
    free2D<NUMBER>(B, (NDAT)nS);
    PI = NULL;
    A  = NULL;
    B  = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5380
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movsbl -0x21(%rbp), %esi
callq 0xc7f0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movsbl -0x21(%rbp), %esi
callq 0xc7f0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/HMMProblem.cpp
// Function: HMMProblem::readNullObsRatio(_IO_FILE*, param*, int*)
void HMMProblem::readNullObsRatio(FILE *fid, struct param* param, NDAT *line_no) {
	NPAR i;
	//
	// read null skill ratios
	//
    fscanf(fid, "Null skill ratios\t");
    this->null_obs_ratio =Calloc(NUMBER, (size_t)this->p->nO);
    this->null_skill_obs      = 0;
    this->null_skill_obs_prob = 0;
	for(i=0; i<param->nO; i++) {
        if( i==(param->nO-1) ) // end
            fscanf(fid,"%lf\n",&this->null_obs_ratio[i] );
        else
            fscanf(fid,"%lf\t",&this->null_obs_ratio[i] );
		
        if( this->null_obs_ratio[i] > this->null_skill_obs_prob ) {
            this->null_skill_obs_prob = this->null_obs_ratio[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 0x29613(%rip), %rsi     # 0x505ae
movb $0x0, %al
callq 0x5580
movq -0x30(%rbp), %rax
movq 0x88(%rax), %rax
movsbq 0x8b9(%rax), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movb $0x0, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl 0x8b9(%rcx), %ecx
cmpl %ecx, %eax
jge 0x270a5
movsbl -0x21(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl 0x8b9(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x27033
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
movsbq -0x21(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x29877(%rip), %rsi     # 0x508a1
movb $0x0, %al
callq 0x5580
jmp 0x27059
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
movsbq -0x21(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x29854(%rip), %rsi     # 0x508a6
movb $0x0, %al
callq 0x5580
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movsbq -0x21(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
ucomisd 0x30(%rax), %xmm0
jbe 0x27096
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movsbq -0x21(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, 0x30(%rax)
movsbl -0x21(%rbp), %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x28(%rax)
jmp 0x27098
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x26fde
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/HMMProblem.cpp
// Function: HMMProblem::toFileAlphaBetaObs(char const*, int)
void HMMProblem::toFileAlphaBetaObs(const char *filename, NCAT k) {
    NPAR nS = this->p->nS;
    FILE *fid = fopen(filename,"w");
    
    if(fid == NULL) {
        fprintf(stderr,"Can't write output model file %s\n",filename);
        exit(1);
    }
    
    struct data *dt = this->p->k_data[k];
    
    for(NDAT tt=0; tt<dt->n; tt++) {
        for(NPAR i=0; i<nS; i++) fprintf(fid,"%20.17f\t", dt->alpha[tt][i]);
        for(NPAR i=0; i<nS; i++) fprintf(fid,"%20.17f\t", dt->beta[tt][i]);
        fprintf(fid,"%i\n", this->p->dat_obs[ dt->ix[tt] ]);
    }
   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)
movq 0x88(%rax), %rax
movb 0x8b8(%rax), %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x289c4(%rip), %rsi     # 0x5058a
callq 0x5370
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x27bfc
movq 0x333fb(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x289a1(%rip), %rsi     # 0x5058c
movb $0x0, %al
callq 0x5440
movl $0x1, %edi
callq 0x5390
movq -0x38(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x8f0(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x27d02
movb $0x0, -0x2d(%rbp)
movsbl -0x2d(%rbp), %eax
movsbl -0x15(%rbp), %ecx
cmpl %ecx, %eax
jge 0x27c76
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x2d(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x28c60(%rip), %rsi     # 0x508c5
movb $0x1, %al
callq 0x5440
movb -0x2d(%rbp), %al
addb $0x1, %al
movb %al, -0x2d(%rbp)
jmp 0x27c34
movb $0x0, -0x2e(%rbp)
movsbl -0x2e(%rbp), %eax
movsbl -0x15(%rbp), %ecx
cmpl %ecx, %eax
jge 0x27cbc
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x2e(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x28c1a(%rip), %rsi     # 0x508c5
movb $0x1, %al
callq 0x5440
movb -0x2e(%rbp), %al
addb $0x1, %al
movb %al, -0x2e(%rbp)
jmp 0x27c7a
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x88(%rax), %rax
movq 0x870(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x2c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movsbl (%rax,%rcx), %edx
leaq 0x27f49(%rip), %rsi     # 0x4fc36
movb $0x0, %al
callq 0x5440
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x27c21
movq -0x20(%rbp), %rdi
callq 0x52c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)