LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: logzNormalizationReadQual
double logzNormalizationReadQual(bam1_t *thisRead, int qOff){

  int i;

  // find the average quality to save computation/precision in combinatorics
  double Qavg = getAverageQualityScoreRead(thisRead, qOff);
  double QmisMatch = (1.0 - Qavg)*Qavg; // assume probability goes mostly to next most likely (and that we hit that base)

  double logQavg = log(Qavg);
  double logQmisMatch = log(QmisMatch);
  int totalLen = thisRead->core.l_qseq;

  // normalize over the maximum value to prevent double precision underflows
  double logMaxExpMatch = 2.0*(totalLen-1)*(logQavg > logQmisMatch ? logQavg : logQmisMatch);

  // find the log expected match score
  double tmpExpMatch = 0.0;
  for(i = 0; i < totalLen; i++){
      double logTmp = 2.0*(i*logQavg + (totalLen-i-1)*logQmisMatch);
      tmpExpMatch += exp( logTmp - logMaxExpMatch );
  }
  double logExpMatch = logMaxExpMatch + log(tmpExpMatch);

  ////printf("logQavg: %lf %lf\n", logQavg, logQmisMatch);
  ////printf("logExpMatch: %lf %lf\n",  logExpMatch, logMaxExpMatch);
  ////printf("expMatch: %e %e\n", exp(logExpMatch), exp(logMaxExpMatch));
  //if (exp(logExpMatch) > expMatch * 1.00001 || exp(logExpMatch) < expMatch * 0.999999)
  //      //printf("expMatch: %e %e %e\n", expMatch - exp(logExpMatch), expMatch, exp(logExpMatch));
  return logExpMatch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7280
movsd %xmm0, -0x18(%rbp)
movsd 0x24af8(%rip), %xmm0    # 0x2ba40
subsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x3280
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x3280
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0x24af7(%rip), %xmm0    # 0x2ba88
mulsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x6fb2
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
jmp 0x6fbc
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x60(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x703f
cvtsi2sdl -0x10(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movl -0x34(%rbp), %eax
subl -0x10(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
mulsd -0x30(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x24a76(%rip), %xmm0    # 0x2ba88
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
callq 0x3680
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6fde
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x48(%rbp), %xmm0
callq 0x3280
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: binary_search_lower_bound
int binary_search_lower_bound(int *list, int first, int last, int target) {
	int middle = (first+last)/2;;
	while( first <= last ) {
		if ( list[middle] < target ) {
			first = middle + 1;
		} else if ( list[middle] == target ) {
			break;
		} else {
			last = middle - 1;
		}

		middle = (first + last)/2;
	}
	if ( first > last )
		return last;
	else
		return first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x7375
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7345
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7362
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jne 0x7357
jmp 0x7375
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7362
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
jmp 0x7322
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x7385
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x738b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: calcRefPos2SeqPos
int32_t calcRefPos2SeqPos(bam1_t *bam, int32_t targetRefPos) {
	int32_t calcSeqPos = -1, seqPos = 0, refPos = bam->core.pos, i;
	uint32_t *cigar = bam1_cigar(bam);
	assert(targetRefPos >= refPos);
	for(i = 0; i < bam->core.n_cigar; i++) {
		if (refPos > targetRefPos)
			break;
		int op = bam_cigar_op(*(cigar+i));
		int len = bam_cigar_oplen(*(cigar+i));
		int type = bam_cigar_type(op);
		if ((type & 0x02) == 0x02) {
			// consume reference
			if (refPos + len >= targetRefPos) {
				if ((type & 0x01) == 0x01) {
					// consume query
					calcSeqPos = seqPos + (targetRefPos - refPos);
				} else {
					calcSeqPos = seqPos;
				}
				break;
			}
			refPos += len;
		}
		if ((type & 0x01) == 0x01) {
			// consume query;
			seqPos += len;
		}
	}
	return calcSeqPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x18, %rcx
andq $0xff, %rcx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x73e6
jmp 0x7405
leaq 0x28f6a(%rip), %rdi     # 0x30357
leaq 0x289d1(%rip), %rsi     # 0x2fdc5
movl $0x4fd, %edx            # imm = 0x4FD
leaq 0x28f6e(%rip), %rcx     # 0x3036e
callq 0x3220
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x30, %rcx
cmpl %ecx, %eax
jge 0x74ca
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x7430
jmp 0x74ca
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %ecx
shll %ecx
movl $0x3c1a7, %eax          # imm = 0x3C1A7
sarl %cl, %eax
andl $0x3, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $0x2, %eax
cmpl $0x2, %eax
jne 0x74a6
movl -0x18(%rbp), %eax
addl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x749d
movl -0x34(%rbp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x7495
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
subl -0x18(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x749b
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x74ca
movl -0x30(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x34(%rbp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x74ba
movl -0x30(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x74bc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x740c
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: recordSNPPhases
void recordSNPPhases(FILE *snpPhaseFile, alignSet_t *aln, assemblyT *theAssembly) {
	if (snpPhaseFile == NULL || aln->likelihood == 0.0)
		return;
	int i,j;

	int printedHeader = -1;

	bam1_t *b = aln->bamOfAlignment1;
	recordSNPPhase(snpPhaseFile, &printedHeader, b, aln, theAssembly);
	b = aln->bamOfAlignment2;
	recordSNPPhase(snpPhaseFile, &printedHeader, b, aln, theAssembly);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x77de
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x77e0
jp 0x77e0
jmp 0x7831
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq -0x24(%rbp), %rsi
callq 0x7510
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq -0x24(%rbp), %rsi
callq 0x7510
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: savePlacement
void savePlacement(samfile_t *placementBam, alignSet_t *aln) {
	if (placementBam == NULL || aln == NULL || aln->likelihood == 0.0)
		return;
	if (aln->bamOfAlignment1 != NULL)
		bam_write1(placementBam->x.bam, aln->bamOfAlignment1);
	if (aln->bamOfAlignment2 != NULL)
		bam_write1(placementBam->x.bam, aln->bamOfAlignment2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7871
cmpq $0x0, -0x10(%rbp)
je 0x7871
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7873
jp 0x7873
jmp 0x78b3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x7893
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x17770
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x78b3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x17770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: digammaApprox
double digammaApprox(double x){
	double x2 = x*x;
	double x4 = x2*x2;
	double x6 = x4*x2;
    return log(x) - 1.0/(2.0*x) - 1.0/(12.0*x2) + 1.0/(120.0*x4) - 1.0/(252.0*x6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x3280
movsd 0x23f6c(%rip), %xmm2    # 0x2ba88
mulsd -0x8(%rbp), %xmm2
movsd 0x23f17(%rip), %xmm1    # 0x2ba40
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd 0x23f27(%rip), %xmm2    # 0x2ba60
mulsd -0x10(%rbp), %xmm2
movsd 0x23efa(%rip), %xmm1    # 0x2ba40
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd 0x23f6a(%rip), %xmm2    # 0x2bac0
mulsd -0x18(%rbp), %xmm2
movsd 0x23edd(%rip), %xmm1    # 0x2ba40
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd 0x23f45(%rip), %xmm2    # 0x2bab8
mulsd -0x20(%rbp), %xmm2
movsd 0x23ec0(%rip), %xmm1    # 0x2ba40
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: negBinom_like
double negBinom_like(double r, double k_avg, float *k, int N){
    double ans = 0.0;
    int i;
    for(i=0; i<N; i++){
        ans += digammaApprox(k[i] + r);
    }
    ans -= N*digammaApprox(r);
    ans += N*log(r/(r + k_avg));
    return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7bf0
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x8(%rbp), %xmm0
callq 0x7ad0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7bb8
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x7ad0
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addsd -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x3280
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: negBinom_rFinder
double negBinom_rFinder(double r_0, double k_avg, float *k, int N, int max_its){
    // through moment matching
    double std_dev = 0.0;
    int i;
    for(i=0; i<N; i++){
    	double kdiff = k_avg - (double)k[i];
        std_dev += kdiff * kdiff;
    }
    std_dev = std_dev/(double)N;
    //printf("rFinder, std=%lf mu=%lf r=%lf\n", std_dev, k_avg, k_avg/(std_dev/k_avg - 1.0));
    return k_avg/(std_dev/k_avg - 1.0);
    
    // through newtons method
    double tol = 1e-6;
    double r = r_0;
    double r_prev;
    int it = 0;
    do {
        it++;
        r_prev = r;
        r = r_prev - negBinom_like(r, k_avg, k, N)/negBinom_likePrime(r, k_avg, k, N, 1e-6);
        if (r < 0){ // kill it
            r = r_0;
            r_prev = r_0;
        }
    } while(it < max_its && fabs(r - r_prev) > tol);
    if(fabs(r - r_prev) > tol){
        //printf("Reached max its without finding params\n");
    }
    //printf("d/dr negBinom_like = %f\n", negBinom_like(r, k_avg, k, N));
    if (isnan(r)) { return r_0; }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7d65
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7d17
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
divsd -0x10(%rbp), %xmm1
movsd 0x23cb1(%rip), %xmm2    # 0x2ba40
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: negBinomPMF
double negBinomPMF(int k, double r, double p){
    double ans = 0.0;
    int i;
    for(i = 1; i <= k; i++){
        ans += log(r - 1 + i) - log(i);
    }
    ans += r*log(1.0 - p);
    ans += (double)k*log(p);
    ////printf("pmf k=%d, r=%lf, p=%lf = %lf\n", k, r, p, ans);
    return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x7e4b
movsd -0x10(%rbp), %xmm0
movsd 0x23c37(%rip), %xmm1    # 0x2ba40
subsd %xmm1, %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
addsd %xmm1, %xmm0
callq 0x3280
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x24(%rbp), %xmm0
callq 0x3280
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7df4
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x23be3(%rip), %xmm0    # 0x2ba40
subsd -0x18(%rbp), %xmm0
callq 0x3280
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x3280
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: applyExpectedMissingLength
void applyExpectedMissingLength(assemblyT *theAssembly){
    double avgDepth = theAssembly->depthAvgSum/theAssembly->depthAvgNorm;
    if(avgDepth < minAvgDepth){avgDepth = minAvgDepth;}
    double avgDepthScore = theAssembly->depthScoreAvgSum/theAssembly->depthScoreAvgNorm;
    double avgKmerScore = theAssembly->kmerAvgSum/theAssembly->kmerAvgNorm;
    double avgOverlap = theAssembly->overlapAvgSum/theAssembly->overlapAvgNorm;
    double expectedUnmappedBases = (double)theAssembly->totalUnmappedReads*theAssembly->avgReadSize + (double)theAssembly->totalMappedReads*(theAssembly->avgReadSize - avgOverlap);
    double expectedExtraLength = expectedUnmappedBases/avgDepth;
    printf("Expected extra length: %lf\n", expectedExtraLength);

    // apply avg depth and k-mer score to all positions
    // NORMALIZED NOW, so E[avgDepthScore] = 0, E[avgKmerScore] = 0
    //theAssembly->totalScore += expectedExtraLength*avgDepthScore;
    //theAssembly->totalScore += expectedExtraLength*avgKmerScore;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x58(%rax), %xmm0
movq -0x8(%rbp), %rax
divsd 0x60(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x23bdd(%rip), %xmm0    # 0x2bac8
ucomisd -0x10(%rbp), %xmm0
jbe 0x7eff
movsd 0x23bce(%rip), %xmm0    # 0x2bac8
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x8(%rbp), %rax
divsd 0x50(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
divsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x68(%rax), %xmm0
movq -0x8(%rbp), %rax
divsd 0x70(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
cvtsi2sdq 0x80(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd 0x98(%rax), %xmm2
movq -0x8(%rbp), %rax
cvtsi2sdq 0x88(%rax), %xmm1
movq -0x8(%rbp), %rax
movsd 0x98(%rax), %xmm3
subsd -0x28(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
leaq 0x285d7(%rip), %rdi     # 0x3057e
movb $0x1, %al
callq 0x3200
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: guessQualityOffset
int guessQualityOffset(bam1_t *read) {
  int len = read->core.l_qseq;
  if (len <= 0){
    return -1;
  }
  int qualOffset = -1;
  const int maxExpectedQuality = 50;
  char *qualSeq = (char*) bam1_qual(read);
  int i;
  for(i=0; i < len; i++) {
    if (qualSeq[i] > 64 && qualSeq[i] > 33+maxExpectedQuality){
      qualOffset = 64;
    }
    else if (qualSeq[i] > 0 && qualSeq[i] < 33){
      qualOffset = 0;
    }
    else if (qualSeq[i] > 33 && qualSeq[i] < maxExpectedQuality+33 && qualSeq[i] < 64 && qualSeq[i] > maxExpectedQuality+0){
      qualOffset = 33;
    }

    if (qualOffset >= 0) {
      //printf("guessed quality offset is %d\n", qualOffset);
      break;
    }
  }
  return qualOffset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x8b14
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8c44
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x32, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x30, %rcx
shll $0x2, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x18, %rcx
andq $0xff, %rcx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
sarl %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8c3e
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x40, %eax
jle 0x8bac
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x53, %eax
jle 0x8bac
movl $0x40, -0x18(%rbp)
jmp 0x8c26
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jle 0x8bd7
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x21, %eax
jge 0x8bd7
movl $0x0, -0x18(%rbp)
jmp 0x8c24
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x21, %eax
jle 0x8c22
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x53, %eax
jge 0x8c22
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x40, %eax
jge 0x8c22
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x32, %eax
jle 0x8c22
movl $0x21, -0x18(%rbp)
jmp 0x8c24
jmp 0x8c26
cmpl $0x0, -0x18(%rbp)
jl 0x8c2e
jmp 0x8c3e
jmp 0x8c30
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8b75
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: compare
int compare(int a, int b) {
    if (a==b){
        return 0;
    }else if (a < b){
        return -1;
    }else{
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x8c6b
movl $0x0, -0x4(%rbp)
jmp 0x8c83
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8c7c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8c83
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: mateTreeCmp
int mateTreeCmp(const void *pa, const void *pb) {
  assert(pa != NULL && pb != NULL);
  bam1_t *a = ((bam1_t*) pa);
  bam1_t *b = ((bam1_t*) pb);
  assert((a->core.flag & (BAM_FREAD1 | BAM_FREAD2)) != 0);
  assert((b->core.flag & (BAM_FREAD1 | BAM_FREAD2)) != 0);
  return strcmp(bam1_qname(a), bam1_qname(b));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8cb0
cmpq $0x0, -0x10(%rbp)
je 0x8cb0
jmp 0x8ccf
leaq 0x279be(%rip), %rdi     # 0x30675
leaq 0x27107(%rip), %rsi     # 0x2fdc5
movl $0x6df, %edx            # imm = 0x6DF
leaq 0x279c4(%rip), %rcx     # 0x3068e
callq 0x3220
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x8cfd
jmp 0x8d1c
leaq 0x279b6(%rip), %rdi     # 0x306ba
leaq 0x270ba(%rip), %rsi     # 0x2fdc5
movl $0x6e2, %edx            # imm = 0x6E2
leaq 0x27977(%rip), %rcx     # 0x3068e
callq 0x3220
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x8d3a
jmp 0x8d59
leaq 0x279a9(%rip), %rdi     # 0x306ea
leaq 0x2707d(%rip), %rsi     # 0x2fdc5
movl $0x6e3, %edx            # imm = 0x6E3
leaq 0x2793a(%rip), %rcx     # 0x3068e
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x3330
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: mateTreeCmpForceStore
int mateTreeCmpForceStore(const void *pa, const void *pb) {
    int cmp = mateTreeCmp(pa, pb);
    if (cmp == 0) {
        bam1_t *a = ((bam1_t*) pa);
        bam1_t *b = ((bam1_t*) pb);
        cmp = compare(a->core.tid, b->core.tid);
        if (cmp == 0) {
        	cmp = compare(a->core.pos, b->core.pos);
        	if (cmp == 0){
        		//printf("mateTreeCmpForceStore found dup: %s %d %d %d %d %d\n", bam1_qname(a), a->core.tid, a->core.pos, a->core.mtid, a->core.mpos, a->core.isize);
            }
        	return cmp;
        } else
        	return cmp;
    } else
        return cmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8c90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8dfe
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x8c50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8df6
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x8c50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8dee
jmp 0x8dee
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e04
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e04
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: mateTreeApplyRemainderPlacement
void mateTreeApplyRemainderPlacement(const void *nodep, const VISIT which, const int depth) {
    // TODO do not just ignore stragglers, apply their placement as singles (should not get here on proper BAMs)

    bam1_t *bam;
    switch(which) {
    case preorder:
    case endorder:
        break;
    case postorder:
    case leaf:
        bam = *((bam1_t**) nodep);
        if (printedExampleOrphan == 0) {
        	printf("\t%s %d\n", bam1_qname(bam), bam->core.flag);
        	printedExampleOrphan = 1;
        }
        break;
    default:
        printf("Error %d\n", which);
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x911f
movq -0x20(%rbp), %rax
leaq 0x22c12(%rip), %rcx     # 0x2bcdc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x913a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x3105d(%rip)     # 0x3a144
jne 0x911d
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %edx
leaq 0x276cd(%rip), %rdi     # 0x307d9
movb $0x0, %al
callq 0x3200
movl $0x1, 0x31027(%rip)     # 0x3a144
jmp 0x913a
movl -0xc(%rbp), %esi
leaq 0x276b8(%rip), %rdi     # 0x307e1
movb $0x0, %al
callq 0x3200
movl $0x1, %edi
callq 0x35b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: mateTreeFreeNode
void mateTreeFreeNode(void *nodep) {
  if (nodep != NULL) {
    mateTreeCount--;
    bam1_t *bam = ((bam1_t*) nodep);
    ////printf("mateTreeFreeNode(%p) freeing (%d) %s\n", nodep, mateTreeCount, bam1_qname(bam));
    bam_destroy1(bam);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x918b
movl 0x30fe7(%rip), %eax     # 0x3a140
addl $-0x1, %eax
movl %eax, 0x30fde(%rip)     # 0x3a140
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9187
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3050
movq -0x10(%rbp), %rdi
callq 0x3050
jmp 0x9189
jmp 0x918b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: isValidInsertSize
int isValidInsertSize(bam1_t *thisRead, libraryMateParametersT *mateParameters) {
    // check for > SIGMA_RANGE sigma insert size and fail to chimer
    float range = SIGMA_RANGE * mateParameters->insertStd;
    float mapLen = fabs((float) getFragmentMapLenBAM(thisRead));
    if ((mapLen > mateParameters->insertLength + range)
        || (mapLen < mateParameters->insertLength - range)) {
        return 0;
    } else {
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x2291c(%rip), %xmm0    # 0x2bad8
mulsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xddf0
cvtsi2ss %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x2290e(%rip), %xmm1    # 0x2baf0
pand %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movss -0x1c(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
ja 0x9237
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movss -0x1c(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9240
movl $0x0, -0x4(%rbp)
jmp 0x9247
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: setAlignmentForMate
void _setAlignmentForMate(alignSet_t *thisAlignment, bam1_t *read1) {
     if ((read1->core.flag & BAM_FPAIRED) != BAM_FPAIRED || (read1->core.flag & BAM_FMUNMAP) == BAM_FMUNMAP ) {
         // not mapped or not paired
         thisAlignment->start2 = -1;
         thisAlignment->end2 = -1; // no information
         thisAlignment->contigId2 = -1;
     } else {
         thisAlignment->start2 = read1->core.mpos;
         thisAlignment->end2 = -1; // no information
         thisAlignment->contigId2 = read1->core.mtid;
     }
     thisAlignment->bamOfAlignment1 = read1;
     thisAlignment->bamOfAlignment2 = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x9770
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0x8, %eax
cmpl $0x8, %eax
jne 0x9793
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
jmp 0x97ba
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getAverageQualityScore
double getAverageQualityScore(char *readQual, int qOff, int offset, int length) {
	double Qavg = 0.0;
	int i, count = 0;
	int minQ = getMinimumQuality() + qOff;
	for(i = offset; i < length; i++){
		// Illumina data below a certain quality (<=2) is *completely* unreliable,
		// so ignore those values for the average calculations
		if (readQual[i] >= minQ) {
			Qavg += getQtoP(readQual[i], qOff);
			count++;
		}
	}
	if (count == 0)
		Qavg = getQtoP(minQ, qOff);
	else
		Qavg = Qavg/(double)count;
	return Qavg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movb $0x0, %al
callq 0xbf70
addl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa136
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x2c(%rbp), %eax
jl 0xa129
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movl -0xc(%rbp), %esi
movsbl %al, %edi
callq 0xbf80
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xa12b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa0e7
cmpl $0x0, -0x28(%rbp)
jne 0xa151
movl -0x2c(%rbp), %eax
movl -0xc(%rbp), %esi
movsbl %al, %edi
callq 0xbf80
movsd %xmm0, -0x20(%rbp)
jmp 0xa164
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: countPlacements
void countPlacements(int numberMapped, libraryMateParametersT *mateParameters, enum MATE_ORIENTATION orientation)
{
    if (numberMapped > 0) {
        if(orientation <= MAPPED_PAIRED_ORIENTATION){
            if(numberMapped == 2){
                mateParameters->placed += 2;
            }else{
                mateParameters->placed++;
            }
        }
        else{
            mateParameters->placed++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xa1c6
cmpl $0x5, -0x14(%rbp)
ja 0xa1b4
cmpl $0x2, -0x4(%rbp)
jne 0xa1a2
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x30(%rax)
jmp 0xa1b2
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0xa1c4
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0xa1c6
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: buildCigarString
void buildCigarString(char *buf, uint32_t *cigar, uint32_t cigarLen) {
	int l = 0, op = 0;
	while (op < cigarLen) {
		l += sprintf(buf + l, "%d", bam_cigar_oplen(cigar[op]));
		buf[l++] = bam_cigar_opchr(cigar[op]);
		op++;
	}
	buf[l] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xba32
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
shrl $0x4, %edx
leaq 0x24aa6(%rip), %rsi     # 0x3048f
movb $0x0, %al
callq 0x35a0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2555f(%rip), %rax     # 0x30f6e
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb9c1
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: destroyRefNumForRealign
void destroyRefNumForRealign(assemblyT *theAssembly) {
	if (realignParameters == NULL)
		return;
	free(realignParameters->scoringMatrix);
	realignParameters->scoringMatrix = NULL;

	int i;
	for(i = 0; i < theAssembly->numContigs; i++) {
		contig_t *contig = theAssembly->contigs[i];
		free(contig->seqNum);
		contig->seqNum = NULL;
	}
	realignParameters = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x2e3f4(%rip)     # 0x3a138
jne 0xbd48
jmp 0xbdbd
movq 0x2e3e9(%rip), %rax     # 0x3a138
movq (%rax), %rdi
callq 0x3050
movq 0x2e3da(%rip), %rax     # 0x3a138
movq $0x0, (%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xbdb2
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3050
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbd6c
movq $0x0, 0x2e37b(%rip) # 0x3a138
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: validateLogLikelihood
double validateLogLikelihood(const double logLikelihood) {
	if (logLikelihood < getMinLogLike() || isnan(logLikelihood) || isinf(logLikelihood))
		return getMinLogLike();
	else
		return logLikelihood;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0xbdf0
movsd -0x18(%rbp), %xmm1
ucomisd %xmm1, %xmm0
ja 0xbe80
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0xbe80
movsd -0x10(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0x1fcaa(%rip), %xmm2    # 0x2baf0
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x1fc78(%rip), %xmm1    # 0x2bae0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0xbe8c
callq 0xbdf0
movsd %xmm0, -0x8(%rbp)
jmp 0xbe96
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: getQtoP
double getQtoP(char qualChar, int qOff) {
    int idx = qualChar - qOff;
    if (idx < 0 || idx >= 63 ) {
        printf("WARNING: getQtoP called out of range: %c %d %d\n", qualChar, qOff, idx);
        if (idx < 0) idx = 0;
        else idx = 62;
    }
    return QtoP[idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movsbl -0x1(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xbfa7
cmpl $0x3f, -0xc(%rbp)
jl 0xbfd7
movsbl -0x1(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x257b8(%rip), %rdi     # 0x31770
movb $0x0, %al
callq 0x3200
cmpl $0x0, -0xc(%rbp)
jge 0xbfce
movl $0x0, -0xc(%rbp)
jmp 0xbfd5
movl $0x3e, -0xc(%rbp)
jmp 0xbfd7
movslq -0xc(%rbp), %rcx
leaq 0x2d58e(%rip), %rax     # 0x39570
movsd (%rax,%rcx,8), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: getQtoLogP
double getQtoLogP(char qualChar, int qOff) {
    int idx = qualChar - qOff;
    if (idx < 0 || idx >= 63 ) {
        printf("WARNING: getQtoLogP called out of range: %c %d %d\n", qualChar, qOff, idx);
        if (idx < 0) idx = 0;
        else idx=62;
    }
    return QtoLogP[idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movsbl -0x1(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xc017
cmpl $0x3f, -0xc(%rbp)
jl 0xc047
movsbl -0x1(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x25778(%rip), %rdi     # 0x317a0
movb $0x0, %al
callq 0x3200
cmpl $0x0, -0xc(%rbp)
jge 0xc03e
movl $0x0, -0xc(%rbp)
jmp 0xc045
movl $0x3e, -0xc(%rbp)
jmp 0xc047
movslq -0xc(%rbp), %rcx
leaq 0x2d71e(%rip), %rax     # 0x39770
movsd (%rax,%rcx,8), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: getQtoLogPMiss
double getQtoLogPMiss(char qualChar, int qOff) {
    int idx = qualChar - qOff;
    if (idx < 0 || idx >= 63 ) {
        printf("WARNING: getQtoLogPMiss called out of range: %c %d %d\n", qualChar, qOff, idx);
        if (idx < 0) idx = 0;
        else idx = 62;
    }
    return QtoLogPMiss[idx]; // TODO switch to (1-Q)*Q
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movsbl -0x1(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xc087
cmpl $0x3f, -0xc(%rbp)
jl 0xc0b7
movsbl -0x1(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x2573b(%rip), %rdi     # 0x317d3
movb $0x0, %al
callq 0x3200
cmpl $0x0, -0xc(%rbp)
jge 0xc0ae
movl $0x0, -0xc(%rbp)
jmp 0xc0b5
movl $0x3e, -0xc(%rbp)
jmp 0xc0b7
movslq -0xc(%rbp), %rcx
leaq 0x2d8ae(%rip), %rax     # 0x39970
movsd (%rax,%rcx,8), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: IncreaseAssemblyPartsByOne
void IncreaseAssemblyPartsByOne(assembly_t *theAssembly, int numParts){
  assemblyPart_t *tempPartPointer = malloc(numParts* sizeof(assemblyPart_t));
  int i;
  for(i = 0; i < numParts - 1; i++){
    tempPartPointer[i] = theAssembly->assemblyParts[i];
  }
  //free(theAssembly->assemblyParts);
  theAssembly->assemblyParts = tempPartPointer;
  //return theAssembly;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x5, %rdi
callq 0x3420
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc14e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc0f7
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: poissonInt
double poissonInt(int k, double lambda){
  int i;
  double answer = 1.0;
  for(i = 1; i < k+1; i++){
    answer = answer*lambda*exp(-lambda/(float)k)/(float)i;
  }
  return answer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd 0x1f8c8(%rip), %xmm0    # 0x2ba40
movsd %xmm0, -0x20(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc1f7
movsd -0x20(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
cvtsi2ssl -0x4(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x3680
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc184
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: seqToChar
unsigned char seqToChar(const char pos1, const char pos2, const char pos3, const char pos4){
    unsigned char seqChar = 0;
    seqChar += (pos1 == 'A' || pos1 == 'G');
    seqChar += (pos1 == 'A' || pos1 == 'C')*2;
    seqChar += (pos2 == 'A' || pos2 == 'G')*4;
    seqChar += (pos2 == 'A' || pos2 == 'C')*8;
    seqChar += (pos3 == 'A' || pos3 == 'G')*16;
    seqChar += (pos3 == 'A' || pos3 == 'C')*32;
    seqChar += (pos4 == 'A' || pos4 == 'G')*64;
    seqChar += (pos4 == 'A' || pos4 == 'C')*128;
    return seqChar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x1(%rbp)
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x6(%rbp)
je 0xc32a
movsbl -0x1(%rbp), %eax
cmpl $0x47, %eax
sete %al
movb %al, -0x6(%rbp)
movb -0x6(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movzbl -0x5(%rbp), %eax
addl %ecx, %eax
movb %al, -0x5(%rbp)
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x7(%rbp)
je 0xc356
movsbl -0x1(%rbp), %eax
cmpl $0x43, %eax
sete %al
movb %al, -0x7(%rbp)
movb -0x7(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
shll %ecx
movzbl -0x5(%rbp), %eax
addl %ecx, %eax
movb %al, -0x5(%rbp)
movsbl -0x2(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x8(%rbp)
je 0xc384
movsbl -0x2(%rbp), %eax
cmpl $0x47, %eax
sete %al
movb %al, -0x8(%rbp)
movb -0x8(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x2, %ecx
movzbl -0x5(%rbp), %eax
addl %ecx, %eax
movb %al, -0x5(%rbp)
movsbl -0x2(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x9(%rbp)
je 0xc3b3
movsbl -0x2(%rbp), %eax
cmpl $0x43, %eax
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x3, %ecx
movzbl -0x5(%rbp), %eax
addl %ecx, %eax
movb %al, -0x5(%rbp)
movsbl -0x3(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0xa(%rbp)
je 0xc3e2
movsbl -0x3(%rbp), %eax
cmpl $0x47, %eax
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x4, %ecx
movzbl -0x5(%rbp), %eax
addl %ecx, %eax
movb %al, -0x5(%rbp)
movsbl -0x3(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0xb(%rbp)
je 0xc411
movsbl -0x3(%rbp), %eax
cmpl $0x43, %eax
sete %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x5, %ecx
movzbl -0x5(%rbp), %eax
addl %ecx, %eax
movb %al, -0x5(%rbp)
movsbl -0x4(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0xc(%rbp)
je 0xc440
movsbl -0x4(%rbp), %eax
cmpl $0x47, %eax
sete %al
movb %al, -0xc(%rbp)
movb -0xc(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x6, %ecx
movzbl -0x5(%rbp), %eax
addl %ecx, %eax
movb %al, -0x5(%rbp)
movsbl -0x4(%rbp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0xd(%rbp)
je 0xc46f
movsbl -0x4(%rbp), %eax
cmpl $0x43, %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x7, %ecx
movzbl -0x5(%rbp), %eax
addl %ecx, %eax
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: makeQual
void makeQual(const char qual[], const unsigned int seqLen, char quality[], int qualityHistogram[]){
  int i;
  for(i = 0; i < seqLen; i++){
    quality[i] = qual[i];
    qualityHistogram[qual[i] - 64]++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0xc4f2
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x40, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc4aa
popq %rbp
retq
nopw %cs:(%rax,%rax)