LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: getIdx
int getIdx(File in, bool gz, char* line, bool qvalOpt,
    int* idxQ) {
  if (getLine(line, MAX_SIZE, in, gz) == NULL)
    exit(error("<header>", ERRLOGIDX));
  char matchP[8] = "-log(p)";
  char matchQ[8] = "-log(q)";
  int idxP = -1;
  int i = 0;
  char* field = strtok(line, TABN);
  while (field != NULL) {
    if (!strncmp(field, matchP, 7))
      idxP = i;
    else if (!strncmp(field, matchQ, 7))
      *idxQ = i;
    field = strtok(NULL, TABN);
    i++;
  }
  if (idxP == -1)
    exit(error(matchP, ERRLOGIDX));
  if (qvalOpt && *idxQ == -1)
    exit(error(matchQ, ERRLOGIDX));
  return idxP;
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, 0x40(%rsp)
andb $0x1, %cl
movb %cl, 0x3f(%rsp)
movq %rdx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movb 0x3f(%rsp), %al
movq 0x40(%rsp), %rdx
movl $0xfff0, %esi           # imm = 0xFFF0
andb $0x1, %al
movzbl %al, %ecx
callq 0x2a20
cmpq $0x0, %rax
jne 0x6df0
leaq 0x18a46(%rip), %rdi     # 0x1f825
movl $0x1f, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movq 0x1882b(%rip), %rax     # 0x1f622
movq %rax, 0x18(%rsp)
movq 0x187ec(%rip), %rax     # 0x1f5ef
movq %rax, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x18a0a(%rip), %rsi     # 0x1f82e
callq 0x2280
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x6e9c
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0x7, %edx
callq 0x2060
cmpl $0x0, %eax
jne 0x6e56
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x6e7b
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x7, %edx
callq 0x2060
cmpl $0x0, %eax
jne 0x6e79
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x6e7b
xorl %eax, %eax
movl %eax, %edi
leaq 0x189a8(%rip), %rsi     # 0x1f82e
callq 0x2280
movq %rax, (%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x6e2d
cmpl $-0x1, 0xc(%rsp)
jne 0x6eb9
leaq 0x18(%rsp), %rdi
movl $0x1f, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
testb $0x1, 0x2f(%rsp)
je 0x6ee0
movq 0x20(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x6ee0
leaq 0x10(%rsp), %rdi
movl $0x1f, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: loadBDG
void loadBDG(char* line, char** chr, uint32_t* start,
    uint32_t* end, char** pStat, int idxP, char** qStat,
    int idxQ, bool qvalOpt) {
  int idx = qvalOpt ? idxQ : idxP;
  char* field = strtok(line, TABN);
  for (int i = 0; i <= idx; i++) {
    if (field == NULL)
      exit(error("", ERRLOG));
    switch (i) {
      case CHR: *chr = field; break;
      case START: *start = getInt(field); break;
      case END: *end = getInt(field); break;
      default:
        if (i == idxP)
          *pStat = field;
        else if (i == idxQ)
          *qStat = field;
    }
    field = strtok(NULL, TABN);
  }
}

// Assembly:
subq $0x58, %rsp
movb 0x70(%rsp), %al
movl 0x68(%rsp), %r10d
movq 0x60(%rsp), %r10
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
andb $0x1, %al
movb %al, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
je 0x6f37
movl 0x68(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x6f3f
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x188db(%rip), %rsi     # 0x1f82e
callq 0x2280
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jg 0x7049
cmpq $0x0, 0x18(%rsp)
jne 0x6f93
leaq 0x18df0(%rip), %rdi     # 0x1fd72
movl $0x20, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x6fb7
jmp 0x6fa1
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x6fc6
jmp 0x6fac
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x6fdb
jmp 0x6ff0
movq 0x18(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
jmp 0x7024
movq 0x18(%rsp), %rdi
callq 0x2980
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
jmp 0x7024
movq 0x18(%rsp), %rdi
callq 0x2980
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
jmp 0x7024
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jne 0x7009
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
jmp 0x7022
movl 0x14(%rsp), %eax
cmpl 0x68(%rsp), %eax
jne 0x7020
movq 0x18(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
jmp 0x7022
jmp 0x7024
xorl %eax, %eax
movl %eax, %edi
leaq 0x187ff(%rip), %rsi     # 0x1f82e
callq 0x2280
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6f65
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: do_del
double do_del(double y, double temp, bool ret) {
  double xsq = trunc(y * 16) / 16;
  double del = (y - xsq) * (y + xsq);
  if (ret)
    return log1p(-exp((-xsq * xsq - del) / 2.0) * temp);
  return (-xsq * xsq - del) / 2.0 + log(temp);
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movsd 0x161d7(%rip), %xmm0    # 0x1e0b8
mulsd 0x28(%rsp), %xmm0
callq 0x2080
movsd 0x161c4(%rip), %xmm1    # 0x1e0b8
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x7fae
movsd 0x10(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x160ad(%rip), %xmm1    # 0x1e028
divsd %xmm1, %xmm0
callq 0x22d0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd 0x20(%rsp), %xmm0
callq 0x2160
movsd %xmm0, 0x30(%rsp)
jmp 0x8024
movsd 0x10(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x1602a(%rip), %xmm1    # 0x1e028
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2170
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: calcPval
float calcPval(float exptVal, float ctrlVal) {
  if (ctrlVal == SKIP)
    return SKIP; // in a skipped region
  if (ctrlVal == 0.0f)
    return exptVal == 0.0f ? 0.0f : FLT_MAX;
  if (exptVal == 0.0f)
    return 0.0f;

  // calculate meanlog and sdlog for plnorm()
  double meanlog, sdlog;
  double mu = ctrlVal;
  if (mu > 7.0) {
    double sd = 10.0 * log10(mu);
    mu *= mu;
    sd *= sd;
    meanlog = log(mu / sqrt(sd + mu));
    sdlog = sqrt(log1p(sd / mu));
  } else {
    meanlog = log(mu) - LOGSQRT;
    sdlog = SQRTLOG;
  }

  // calculate pval by plnorm()
  double pval = plnorm(exptVal, meanlog, sdlog);
  return pval > FLT_MAX ? FLT_MAX : (float) pval;
}

// Assembly:
subq $0x48, %rsp
movss %xmm0, 0x40(%rsp)
movss %xmm1, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
movss 0x15b26(%rip), %xmm1    # 0x1e194
ucomiss %xmm1, %xmm0
jne 0x8688
jp 0x8688
movss 0x15b17(%rip), %xmm0    # 0x1e194
movss %xmm0, 0x44(%rsp)
jmp 0x882e
movss 0x3c(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x86c5
jp 0x86c5
movss 0x40(%rsp), %xmm0
xorps %xmm3, %xmm3
movss 0x15ae7(%rip), %xmm2    # 0x1e190
cmpeqss %xmm3, %xmm0
movaps %xmm0, %xmm1
andps %xmm3, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movss %xmm0, 0x44(%rsp)
jmp 0x882e
movss 0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x86e3
jp 0x86e3
xorps %xmm0, %xmm0
movss %xmm0, 0x44(%rsp)
jmp 0x882e
movss 0x3c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x15a6f(%rip), %xmm1    # 0x1e170
ucomisd %xmm1, %xmm0
jbe 0x87a2
movsd 0x20(%rsp), %xmm0
callq 0x21b0
movaps %xmm0, %xmm1
movsd 0x15a67(%rip), %xmm0    # 0x1e188
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
callq 0x22c0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x2170
movsd %xmm0, 0x30(%rsp)
movsd 0x18(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
callq 0x2160
callq 0x22c0
movsd %xmm0, 0x28(%rsp)
jmp 0x87cd
movsd 0x20(%rsp), %xmm0
callq 0x2170
movsd 0x159cb(%rip), %xmm1    # 0x1e180
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x159b1(%rip), %xmm0    # 0x1e178
movsd %xmm0, 0x28(%rsp)
movss 0x40(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
callq 0x85a0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x158ac(%rip), %xmm1    # 0x1e0a8
ucomisd %xmm1, %xmm0
jbe 0x8812
movss 0x15986(%rip), %xmm0    # 0x1e190
movss %xmm0, 0x4(%rsp)
jmp 0x8822
movsd 0x10(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x44(%rsp)
movss 0x44(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: countIntervals
uint32_t countIntervals(Chrom* chr) {
  uint32_t num = 0;
  uint32_t k = 0;
  for (uint32_t j = 0; j < chr->exptLen; j++) {
    while (k < chr->ctrlLen
        && chr->ctrl->end[k] < chr->expt->end[j]) {
      num++;
      k++;
    }
    if (chr->ctrl->end[k] == chr->expt->end[j])
      k++;
    num++;
  }
  return num;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x30(%rcx), %eax
jae 0x8922
jmp 0x8871
movl -0x10(%rsp), %ecx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpl 0x40(%rdx), %ecx
movb %al, -0x15(%rsp)
jae 0x88b2
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movl -0x10(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx), %rcx
movl -0x14(%rsp), %edx
cmpl (%rcx,%rdx,4), %eax
setb %al
movb %al, -0x15(%rsp)
movb -0x15(%rsp), %al
testb $0x1, %al
jne 0x88bc
jmp 0x88d4
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x8871
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movl -0x10(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx), %rcx
movl -0x14(%rsp), %edx
cmpl (%rcx,%rdx,4), %eax
jne 0x8907
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x885d
movl -0xc(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: printPileHeader
void printPileHeader(File pile, char* exptName,
    char* ctrlName, bool gzOut) {
  if (gzOut) {
    gzprintf(pile.gzf, "# experimental file: %s; control file: %s\n",
      exptName, ctrlName && strcmp(ctrlName, "null") ? ctrlName : NA);
    gzprintf(pile.gzf, "chr\tstart\tend\texperimental\tcontrol\t-log(p)\n");
  } else {
    fprintf(pile.f, "# experimental file: %s; control file: %s\n",
      exptName, ctrlName && strcmp(ctrlName, "null") ? ctrlName : NA);
    fprintf(pile.f, "chr\tstart\tend\texperimental\tcontrol\t-log(p)\n");
  }
}

// Assembly:
subq $0x58, %rsp
movb %cl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
je 0x89d0
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x8990
movq 0x40(%rsp), %rdi
leaq 0x173e8(%rip), %rsi     # 0x1fd62
callq 0x21a0
cmpl $0x0, %eax
je 0x8990
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x899e
leaq 0x16c9c(%rip), %rax     # 0x1f633
movq %rax, 0x20(%rsp)
jmp 0x899e
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x16fcd(%rip), %rsi     # 0x1f981
movb $0x0, %al
callq 0x20e0
movq 0x50(%rsp), %rdi
leaq 0x16fe5(%rip), %rsi     # 0x1f9ac
movb $0x0, %al
callq 0x20e0
jmp 0x8a4c
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x8a0e
movq 0x40(%rsp), %rdi
leaq 0x1736a(%rip), %rsi     # 0x1fd62
callq 0x21a0
cmpl $0x0, %eax
je 0x8a0e
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x8a1c
leaq 0x16c1e(%rip), %rax     # 0x1f633
movq %rax, 0x8(%rsp)
jmp 0x8a1c
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
leaq 0x16f4f(%rip), %rsi     # 0x1f981
movb $0x0, %al
callq 0x21c0
movq 0x50(%rsp), %rdi
leaq 0x16f67(%rip), %rsi     # 0x1f9ac
movb $0x0, %al
callq 0x21c0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: printPile
void printPile(File pile, char* name, uint32_t start,
    uint32_t end, float expt, float ctrl, float pval,
    bool gzOut) {
  if (gzOut) {
    if (ctrl == SKIP)
      gzprintf(pile.gzf, "%s\t%d\t%d\t%f\t%f\t%s\n",
        name, start, end, expt, 0.0f, NA);
    else
      gzprintf(pile.gzf, "%s\t%d\t%d\t%f\t%f\t%f\n",
        name, start, end, expt, ctrl, pval);
  } else {
    if (ctrl == SKIP)
      fprintf(pile.f, "%s\t%d\t%d\t%f\t%f\t%s\n",
        name, start, end, expt, 0.0f, NA);
    else
      fprintf(pile.f, "%s\t%d\t%d\t%f\t%f\t%f\n",
        name, start, end, expt, ctrl, pval);
  }
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm2, 0x4(%rsp)
andb $0x1, %al
movb %al, 0x3(%rsp)
testb $0x1, 0x3(%rsp)
je 0x8b2c
movss 0x8(%rsp), %xmm0
movss 0x156ea(%rip), %xmm1    # 0x1e194
ucomiss %xmm1, %xmm0
jne 0x8ae8
jp 0x8ae8
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x16f03(%rip), %rsi     # 0x1f9d8
xorps %xmm1, %xmm1
leaq 0x16b54(%rip), %r9      # 0x1f633
movb $0x2, %al
callq 0x20e0
jmp 0x8b27
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x8(%rsp), %xmm1
cvtss2sd %xmm1, %xmm1
movss 0x4(%rsp), %xmm2
cvtss2sd %xmm2, %xmm2
leaq 0x16ecb(%rip), %rsi     # 0x1f9eb
movb $0x3, %al
callq 0x20e0
jmp 0x8bb9
movss 0x8(%rsp), %xmm0
movss 0x1565a(%rip), %xmm1    # 0x1e194
ucomiss %xmm1, %xmm0
jne 0x8b78
jp 0x8b78
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x16e73(%rip), %rsi     # 0x1f9d8
xorps %xmm1, %xmm1
leaq 0x16ac4(%rip), %r9      # 0x1f633
movb $0x2, %al
callq 0x21c0
jmp 0x8bb7
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x8(%rsp), %xmm1
cvtss2sd %xmm1, %xmm1
movss 0x4(%rsp), %xmm2
cvtss2sd %xmm2, %xmm2
leaq 0x16e3b(%rip), %rsi     # 0x1f9eb
movb $0x3, %al
callq 0x21c0
jmp 0x8bb9
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: saveConst
void saveConst(Pileup* p, uint32_t* size, uint32_t* mem,
    uint32_t len, float val) {
  if (! *mem) {
    p->end = (uint32_t*) memalloc(sizeof(uint32_t));
    p->cov = (float*) memalloc(sizeof(float));
    *mem = 1;
  }
  p->end[0] = len;
  p->cov[0] = val;
  *size = 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x912d
movl $0x4, %edi
callq 0x2890
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x4, %edi
callq 0x2890
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movss 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movss %xmm0, (%rax)
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: calcLambda
float calcLambda(Chrom* chrom, int chromLen,
    double fragLen, uint64_t genomeLen) {
  if (! genomeLen) {
    for (int i = 0; i < chromLen; i++) {
      Chrom* chr = chrom + i;
      if (! chr->skip && chr->save) {
        genomeLen += chr->len;
        for (int j = 0; j < chr->bedLen; j += 2)
          genomeLen -= chr->bed[j+1] - chr->bed[j];
      }
    }
    if (! genomeLen)
      exit(error("", ERRGEN));
  }
  return fragLen / genomeLen;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x9269
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x9247
movq 0x30(%rsp), %rax
movslq 0x14(%rsp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x9235
movq 0x8(%rsp), %rax
testb $0x1, 0xd(%rax)
je 0x9235
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x9233
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x4(%rsp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x4(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x4(%rsp)
jmp 0x91e0
jmp 0x9235
jmp 0x9237
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x918c
cmpq $0x0, 0x18(%rsp)
jne 0x9267
leaq 0x16b1c(%rip), %rdi     # 0x1fd72
movl $0x14, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
jmp 0x9269
movsd 0x20(%rsp), %xmm0
movaps 0x14f6a(%rip), %xmm2    # 0x1e1e0
movq 0x18(%rsp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x14f68(%rip), %xmm2    # 0x1e1f0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: savePileupNoCtrl
void savePileupNoCtrl(Chrom* chrom, int chromLen,
    double fragLen, uint64_t genomeLen, bool verbose) {
  float lambda = calcLambda(chrom, chromLen, fragLen,
    genomeLen);
  if (verbose)
    fprintf(stderr, "  Background pileup value: %f\n",
      lambda);
  for (int i = 0; i < chromLen; i++) {
    Chrom* chr = chrom + i;
    if (chr->skip || ! chr->save)
      continue;
    saveLambda(chr, lambda);
  }
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movsd 0x20(%rsp), %xmm0
movq 0x18(%rsp), %rdx
callq 0x9160
movss %xmm0, 0x10(%rsp)
testb $0x1, 0x17(%rsp)
je 0x9578
movq 0x19a9b(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movss 0x10(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x1648d(%rip), %rsi     # 0x1f9fe
movb $0x1, %al
callq 0x21c0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x95d1
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x95b3
movq (%rsp), %rax
testb $0x1, 0xd(%rax)
jne 0x95b5
jmp 0x95c4
movq (%rsp), %rdi
movss 0x10(%rsp), %xmm0
callq 0x92b0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9580
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: getVal
float getVal(int32_t cov, uint8_t frac) {
  return (float) cov
    + ((frac & 0x7) / 8.0f)
    + (((frac >> 3) & 0x3) / 6.0f)
    + (((frac >> 5) & 0x7) / 10.0f);
}

// Assembly:
movb %sil, %al
movl %edi, -0x4(%rsp)
movb %al, -0x5(%rsp)
cvtsi2ssl -0x4(%rsp), %xmm0
movzbl -0x5(%rsp), %eax
andl $0x7, %eax
cvtsi2ss %eax, %xmm1
movss 0x14ba3(%rip), %xmm2    # 0x1e1a8
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movzbl -0x5(%rsp), %eax
sarl $0x3, %eax
andl $0x3, %eax
cvtsi2ss %eax, %xmm1
movss 0x14b80(%rip), %xmm2    # 0x1e1a4
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movzbl -0x5(%rsp), %eax
sarl $0x5, %eax
andl $0x7, %eax
cvtsi2ss %eax, %xmm1
movss 0x14b5d(%rip), %xmm2    # 0x1e1a0
divss %xmm2, %xmm1
addss %xmm1, %xmm0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: printBED
void printBED(File bed, bool gzOut, char* chr,
    int64_t start, int64_t end, char* qname,
    uint8_t count, bool ctrl, int sample) {
  if (gzOut)
    gzprintf(bed.gzf, "%s\t%ld\t%ld\t%s_%d_%c_%d\n",
      chr, start, end, qname, count, ctrl ? 'C' : 'E',
      sample);
  else
    fprintf(bed.f, "%s\t%ld\t%ld\t%s_%d_%c_%d\n",
      chr, start, end, qname, count, ctrl ? 'C' : 'E',
      sample);
}

// Assembly:
subq $0x58, %rsp
movl 0x70(%rsp), %eax
movb 0x68(%rsp), %al
movb 0x60(%rsp), %r10b
movq %rdi, 0x50(%rsp)
andb $0x1, %sil
movb %sil, 0x4f(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
testb $0x1, 0x4f(%rsp)
je 0xb628
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movzbl 0x60(%rsp), %r11d
movb 0x27(%rsp), %sil
movl $0x45, %r10d
movl $0x43, %eax
testb $0x1, %sil
cmovnel %eax, %r10d
movl 0x70(%rsp), %eax
leaq 0x144e4(%rip), %rsi     # 0x1faf6
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x20e0
jmp 0xb67e
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movzbl 0x60(%rsp), %r11d
movb 0x27(%rsp), %sil
movl $0x45, %r10d
movl $0x43, %eax
testb $0x1, %sil
cmovnel %eax, %r10d
movl 0x70(%rsp), %eax
leaq 0x1448c(%rip), %rsi     # 0x1faf6
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x21c0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: calcAvgLen
int calcAvgLen(double totalLen, uint64_t pairedPr,
    bool verbose) {
  if (! pairedPr) {
    if (verbose) {
      fprintf(stderr, "Warning! No paired alignments to calculate avg frag ");
      fprintf(stderr, "length --\n  Printing unpaired alignments \"as is\"\n");
    }
    return 0;
  }
  return (int) (totalLen / pairedPr + 0.5);
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movsd %xmm0, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xbc71
testb $0x1, 0xf(%rsp)
je 0xbc67
movq 0x173ba(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x13fab(%rip), %rsi     # 0x1fbf3
movb $0x0, %al
callq 0x21c0
movq 0x173a2(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x13fc8(%rip), %rsi     # 0x1fc28
movb $0x0, %al
callq 0x21c0
movl $0x0, 0x24(%rsp)
jmp 0xbcb7
movsd 0x18(%rsp), %xmm0
movaps 0x12562(%rip), %xmm2    # 0x1e1e0
movq 0x10(%rsp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x12560(%rip), %xmm2    # 0x1e1f0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x124bd(%rip), %xmm1    # 0x1e168
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: saveAvgExt
void saveAvgExt(char* qname, Aln* b, uint8_t count,
    Aln*** unpair, int* unpairIdx, int* unpairLen,
    int* unpairMem) {

  // alloc memory if necessary
  if (*unpairLen == 0 && *unpairIdx == *unpairMem) {
    *unpair = (Aln**) memrealloc(*unpair,
      (*unpairMem + 1) * sizeof(Aln*));
    (*unpair)[*unpairMem] = (Aln*) memalloc(MAX_SIZE
      * sizeof(Aln));
    (*unpairMem)++;
  }

  // copy alignment info
  Aln* a = (*unpair)[*unpairIdx] + *unpairLen;
  a->name = (char*) memalloc(1 + strlen(qname));
  strcpy(a->name, qname);
  a->chrom = b->chrom;
  a->strand = b->strand;
  a->pos[0] = b->pos[0];
  a->pos[1] = b->pos[1];
  a->count = count;

  (*unpairLen)++;
  if (*unpairLen == MAX_SIZE) {
    *unpairLen = 0;
    (*unpairIdx)++;
  }
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq 0x40(%rsp), %rdx
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xc0a8
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xc0a8
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x28e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl $0x27fd80, %edi         # imm = 0x27FD80
callq 0x2890
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x40(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movslq (%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2890
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x2070
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rax
movb 0x10(%rax), %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq 0x28(%rsp), %rax
movl (%rax), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movb 0x27(%rsp), %cl
movq (%rsp), %rax
movb %cl, 0x11(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
cmpl $0xfff0, (%rax)         # imm = 0xFFF0
jne 0xc17c
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: createRead
Read* createRead(Read*** read, int* readIdx,
    int* readLen, int* readMem) {
  // alloc memory if necessary
  if (*readLen == 0 && *readIdx == *readMem) {
    // check if max. number of reads exceeded
    if ((*readMem + 1) * MAX_SIZE > UINT32_MAX) {
      char msg[MAX_ALNS];
      sprintf(msg, "Exceeded max. number of reads (%u)",
        UINT32_MAX);
      exit(error(msg, ERRISSUE));
    }

    *read = (Read**) memrealloc(*read,
      (*readMem + 1) * sizeof(Read*));
    (*read)[*readMem] = (Read*) memalloc(MAX_SIZE
      * sizeof(Read));
    (*readMem)++;
  }
  Read* r = (*read)[*readIdx] + *readLen;

  // update indexes
  (*readLen)++;
  if (*readLen == MAX_SIZE) {
    *readLen = 0;
    (*readIdx)++;
  }
  return r;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq 0xa0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xcbc0
movq 0xa8(%rsp), %rax
movl (%rax), %eax
movq 0x98(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xcbc0
movq 0x98(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
imull $0xfff0, %eax, %eax     # imm = 0xFFF0
cmpl $-0x1, %eax
jbe 0xcb58
leaq 0x10(%rsp), %rdi
leaq 0x13124(%rip), %rsi     # 0x1fc5a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x22a0
leaq 0x10(%rsp), %rdi
movl $0x21, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movq 0xb0(%rsp), %rax
movq (%rax), %rdi
movq 0x98(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x28e0
movq %rax, %rcx
movq 0xb0(%rsp), %rax
movq %rcx, (%rax)
movl $0x2ffd00, %edi         # imm = 0x2FFD00
callq 0x2890
movq %rax, %rdx
movq 0xb0(%rsp), %rax
movq (%rax), %rax
movq 0x98(%rsp), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x98(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0xb0(%rsp), %rax
movq (%rax), %rax
movq 0xa8(%rsp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0xa0(%rsp), %rcx
movslq (%rcx), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0xa0(%rsp), %rax
cmpl $0xfff0, (%rax)         # imm = 0xFFF0
jne 0xcc2d
movq 0xa0(%rsp), %rax
movl $0x0, (%rax)
movq 0xa8(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: saveAlnsSingle
void saveAlnsSingle(char* qname, Aln* aln, int alnLen,
    float score, float asDiff, bool first, Read* r,
    uint16_t qual) {
  // populate Read* struct
  r->name = (char*) memalloc(1 + strlen(qname));
  strcpy(r->name, qname);
  r->qual = qual;
  r->first = first;
  r->score = score;

  // copy alignments to struct
  copyAlns(aln, alnLen, score, asDiff, first, &r->aln,
    &r->alnLen);
}

// Assembly:
subq $0x38, %rsp
movw %r9w, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movss %xmm0, 0x20(%rsp)
movss %xmm1, 0x1c(%rsp)
andb $0x1, %cl
movb %cl, 0x1b(%rsp)
movq %r8, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movq 0x30(%rsp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2890
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x2070
movw 0xe(%rsp), %cx
movq 0x10(%rsp), %rax
movw %cx, 0x22(%rax)
movb 0x1b(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x24(%rax)
movss 0x20(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x28(%rax)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movss 0x20(%rsp), %xmm0
movss 0x1c(%rsp), %xmm1
movb 0x1b(%rsp), %al
movq 0x10(%rsp), %rcx
addq $0x8, %rcx
movq 0x10(%rsp), %r8
addq $0x10, %r8
andb $0x1, %al
movzbl %al, %edx
callq 0xcc40
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: saveAlnsDiscord
void saveAlnsDiscord(char* qname, Aln* aln, int alnLen,
    float scoreR1, float scoreR2, float asDiff,
    Read* r, uint16_t qualR1, uint16_t qualR2) {
  // save R1 alignments
  saveAlnsSingle(qname, aln, alnLen, scoreR1, asDiff,
    true, r, qualR1);
  // save R2 alignments
  copyAlns(aln, alnLen, scoreR2, asDiff, false, &r->alnR2,
    &r->alnLenR2);
  r->qual = MIN(qualR1 + qualR2, UINT16_MAX);
  r->scoreR2 = scoreR2;
}

// Assembly:
subq $0x58, %rsp
movl %r8d, 0xc(%rsp)
movq %rcx, %rax
movl 0xc(%rsp), %ecx
movq %rax, 0x10(%rsp)
movl %edx, %eax
movq 0x10(%rsp), %rdx
movl %eax, 0x1c(%rsp)
movq %rsi, %rax
movl 0x1c(%rsp), %esi
movq %rax, 0x20(%rsp)
movq %rdi, %r8
movq 0x20(%rsp), %rdi
movw %r9w, %ax
movq %r8, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movss %xmm0, 0x40(%rsp)
movss %xmm1, 0x3c(%rsp)
movss %xmm2, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movw %cx, 0x2e(%rsp)
movw %ax, 0x2c(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x44(%rsp), %edx
movss 0x40(%rsp), %xmm0
movss 0x38(%rsp), %xmm1
movq 0x30(%rsp), %r8
movl $0x1, %ecx
movzwl 0x2e(%rsp), %r9d
callq 0xce70
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
movss 0x3c(%rsp), %xmm0
movss 0x38(%rsp), %xmm1
movq 0x30(%rsp), %rcx
addq $0x18, %rcx
movq 0x30(%rsp), %r8
addq $0x20, %r8
xorl %edx, %edx
callq 0xcc40
movzwl 0x2e(%rsp), %eax
movzwl 0x2c(%rsp), %ecx
addl %ecx, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jge 0xd029
movzwl 0x2e(%rsp), %eax
movzwl 0x2c(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x8(%rsp)
jmp 0xd034
movl $0xffff, %eax           # imm = 0xFFFF
movl %eax, 0x8(%rsp)
jmp 0xd034
movl 0x8(%rsp), %eax
movw %ax, %cx
movq 0x30(%rsp), %rax
movw %cx, 0x22(%rax)
movss 0x3c(%rsp), %xmm0
movq 0x30(%rsp), %rax
movss %xmm0, 0x2c(%rax)
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: johnSort
void johnSort(uint16_t* qual, uint32_t* order,
    uint32_t low, uint32_t high, uint16_t* qual0,
    uint16_t* qual1, uint16_t* qual2, uint32_t* order0,
    uint32_t* order1, uint32_t* order2) {
  if (low + 1 < high) {
    uint32_t idx1 = 0; // new low index for upper recursive call
    uint32_t idx = johnPartition(qual, order, low, high,
      qual0, qual1, qual2, order0, order1, order2, &idx1);
    if (idx)
      // lower recursive call
      johnSort(qual, order, low, idx, qual0, qual1,
        qual2, order0, order1, order2);
    if (idx1)
      // upper recursive call
      johnSort(qual, order, idx1, high, qual0, qual1,
        qual2, order0, order1, order2);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x30(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
cmpl 0x40(%rsp), %eax
jae 0xf27e
movl $0x0, 0x2c(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x44(%rsp), %edx
movl 0x40(%rsp), %ecx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x70(%rsp), %r14
movq 0x78(%rsp), %rbx
movq 0x80(%rsp), %r11
movq 0x88(%rsp), %r10
leaq 0x2c(%rsp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xee30
movl %eax, 0x28(%rsp)
cmpl $0x0, 0x28(%rsp)
je 0xf227
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x44(%rsp), %edx
movl 0x28(%rsp), %ecx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x70(%rsp), %rbx
movq 0x78(%rsp), %r11
movq 0x80(%rsp), %r10
movq 0x88(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0xf120
cmpl $0x0, 0x2c(%rsp)
je 0xf27c
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x2c(%rsp), %edx
movl 0x40(%rsp), %ecx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x70(%rsp), %rbx
movq 0x78(%rsp), %r11
movq 0x80(%rsp), %r10
movq 0x88(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0xf120
jmp 0xf27e
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: sortReads
void sortReads(Read** arr, uint32_t count, uint32_t* order,
    uint16_t* qual, uint32_t* order0, uint32_t* order1,
    uint32_t* order2, uint16_t* qual0, uint16_t* qual1,
    uint16_t* qual2) {

  // initialize order and qual arrays
  for (uint32_t i = 0; i < count; i++) {
    order[i] = i;
    qual[i] = (arr[i / MAX_SIZE] + i % MAX_SIZE)->qual;
  }

  // initialize johnSort()
  johnSort(qual, order, 0, count, qual0, qual1, qual2,
    order0, order1, order2);
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x64(%rsp), %eax
jae 0xf356
movl 0x3c(%rsp), %edx
movq 0x58(%rsp), %rax
movl 0x3c(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x3c(%rsp), %eax
movl $0xfff0, %ecx           # imm = 0xFFF0
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
movl 0x3c(%rsp), %eax
movl $0xfff0, %ecx           # imm = 0xFFF0
xorl %edx, %edx
divl %ecx
movq 0x30(%rsp), %rax
movl %edx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movw 0x22(%rax), %dx
movq 0x50(%rsp), %rax
movl 0x3c(%rsp), %ecx
movw %dx, (%rax,%rcx,2)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0xf2da
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x64(%rsp), %ecx
movq 0x88(%rsp), %r8
movq 0x90(%rsp), %r9
movq 0x98(%rsp), %rbx
movq 0x48(%rsp), %r11
movq 0x40(%rsp), %r10
movq 0x80(%rsp), %rax
xorl %edx, %edx
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0xf120
addq $0x70, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: calcHashSize
uint32_t calcHashSize(uint32_t count) {
  uint32_t size = 2;
  uint32_t val = MIN(UINT32_MAX, 4 * count / 3);
  for (int i = 1; i < 31; i++) {
    if (size >= val)
      return size;
    size *= 2;
  }
  // max size 2^31
  return size;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl $0x2, -0xc(%rsp)
movl -0x8(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jae 0xf3e2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rsp)
jmp 0xf3f6
movl -0x8(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x10(%rsp)
movl $0x1, -0x14(%rsp)
cmpl $0x1f, -0x14(%rsp)
jge 0xf438
movl -0xc(%rsp), %eax
cmpl -0x10(%rsp), %eax
jb 0xf421
movl -0xc(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xf440
movl -0xc(%rsp), %eax
shll %eax
movl %eax, -0xc(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xf406
movl -0xc(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: addToHash
void addToHash(Chrom* chrom, Chrom* chrom1, uint32_t pos,
    uint32_t pos1, bool strand, bool strand1,
    HashAln** table, uint32_t idx, char* name) {
  HashAln* h = (HashAln*) memalloc(sizeof(HashAln));
  h->chrom = chrom;
  h->chrom1 = chrom1;
  h->pos = pos;
  h->pos1 = pos1;
  h->strand = strand;
  h->strand1 = strand1;
  h->name = NULL;
  if (name) {
    h->name = (char*) memalloc(1 + strlen(name));
    strcpy(h->name, name);
  }
  h->next = table[idx];
  table[idx] = h;
}

// Assembly:
subq $0x48, %rsp
movl %r8d, 0xc(%rsp)
movl %ecx, %eax
movl 0xc(%rsp), %ecx
movl %eax, 0x10(%rsp)
movl %edx, %eax
movl 0x10(%rsp), %edx
movl %eax, 0x14(%rsp)
movq %rsi, %rax
movl 0x14(%rsp), %esi
movq %rax, 0x18(%rsp)
movq %rdi, %r8
movq 0x18(%rsp), %rdi
movb %r9b, %al
movq 0x60(%rsp), %r9
movl 0x58(%rsp), %r9d
movq 0x50(%rsp), %r9
movq %r8, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
andb $0x1, %cl
movb %cl, 0x2f(%rsp)
andb $0x1, %al
movb %al, 0x2e(%rsp)
movl $0x30, %edi
callq 0x2890
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x34(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x30(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x1c(%rax)
movb 0x2f(%rsp), %cl
movq 0x20(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movb 0x2e(%rsp), %cl
movq 0x20(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x21(%rax)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x60(%rsp)
je 0xf81a
movq 0x60(%rsp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2890
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x60(%rsp), %rsi
callq 0x2070
movq 0x50(%rsp), %rax
movl 0x58(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rdx
movq 0x50(%rsp), %rax
movl 0x58(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: checkAndAdd
void checkAndAdd(HashAln** tableSn, uint32_t hashSizeSn,
    Chrom* chrom, uint32_t pos, bool strand, char* name) {
  uint32_t idx = jenkins_hash_aln(chrom, NULL, pos, 0,
    strand, 0, SINGLE, hashSizeSn);
  if (! checkHash(chrom, NULL, pos, 0, strand, 0, SINGLE,
      tableSn, idx))
    addToHash(chrom, NULL, pos, 0, strand, 0, tableSn,
      idx, name);
}

// Assembly:
subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
andb $0x1, %al
movb %al, 0x2b(%rsp)
movq %r9, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %edx
movb 0x2b(%rsp), %r8b
movl 0x3c(%rsp), %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %r9d, %r9d
andb $0x1, %r8b
movl %r9d, %ecx
movzbl %r8b, %r8d
movl $0x1, (%rsp)
movl %eax, 0x8(%rsp)
callq 0xf450
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %edx
movb 0x2b(%rsp), %r8b
movq 0x40(%rsp), %r10
movl 0x1c(%rsp), %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %r9d, %r9d
andb $0x1, %r8b
movl %r9d, %ecx
movzbl %r8b, %r8d
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0xf850
cmpq $0x0, %rax
jne 0xfb32
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %edx
movb 0x2b(%rsp), %r8b
movq 0x40(%rsp), %r11
movl 0x1c(%rsp), %r10d
movq 0x20(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %r9d, %r9d
andb $0x1, %r8b
movl %r9d, %ecx
movzbl %r8b, %r8d
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xf710
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: checkHashPr
bool checkHashPr(Read* r, HashAln** table,
    uint32_t hashSize, File dups, bool dupsVerb,
    bool gzOut) {
  for (int k = 0; k < r->alnLen; k++) {
    Aln* a = r->aln + k;
    uint32_t idx = jenkins_hash_aln(a->chrom, NULL,
      a->pos[0], a->pos[1], 0, 0, PAIRED, hashSize);
    HashAln* h = checkHash(a->chrom, NULL, a->pos[0],
      a->pos[1], 0, 0, PAIRED, table, idx);
    if (h) {
      if (dupsVerb)
        logDup(dups, gzOut, r->name, a->chrom, NULL,
          a->pos[0], a->pos[1], 0, 0, h->name, PAIRED);
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x78, %rsp
movl %r8d, 0x2c(%rsp)
movq %rcx, %r8
movl 0x2c(%rsp), %ecx
movb %r9b, %al
movq %r8, 0x68(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
andb $0x1, %cl
movb %cl, 0x53(%rsp)
andb $0x1, %al
movb %al, 0x52(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movq 0x60(%rsp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jge 0x10275
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x40(%rsp), %rax
movl (%rax), %edx
movq 0x40(%rsp), %rax
movl 0x4(%rax), %ecx
movl 0x54(%rsp), %eax
xorl %esi, %esi
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x0, (%rsp)
movl %eax, 0x8(%rsp)
callq 0xf450
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x40(%rsp), %rax
movl (%rax), %edx
movq 0x40(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x58(%rsp), %r10
movl 0x3c(%rsp), %eax
xorl %esi, %esi
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0xf850
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x10263
testb $0x1, 0x53(%rsp)
je 0x1025c
movb 0x52(%rsp), %sil
movq 0x60(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x40(%rsp), %rax
movl (%rax), %r9d
movq 0x40(%rsp), %rax
movl 0x4(%rax), %r10d
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x68(%rsp), %rdi
xorl %r8d, %r8d
xorl %r11d, %r11d
andb $0x1, %sil
movzbl %sil, %esi
movl %r10d, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
callq 0xfb40
movb $0x1, 0x77(%rsp)
jmp 0x1027a
jmp 0x10265
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x1013b
movb $0x0, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: addHashSn
void addHashSn(Read* r, HashAln** table,
    uint32_t hashSize, bool dupsVerb) {
  for (int k = 0; k < r->alnLen; k++) {
    Aln* a = r->aln + k;
    uint32_t pos = (a->strand ? a->pos[0] : a->pos[1]);
    uint32_t idx = jenkins_hash_aln(a->chrom, NULL,
      pos, 0, a->strand, 0, SINGLE, hashSize);
    addToHash(a->chrom, NULL, pos, 0, a->strand, 0,
      table, idx, dupsVerb ? r->name : NULL);
  }
}

// Assembly:
subq $0x78, %rsp
movb %cl, %al
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
andb $0x1, %al
movb %al, 0x63(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movq 0x70(%rsp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jge 0x11a34
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x5c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x11939
movq 0x50(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x44(%rsp)
jmp 0x11945
movq 0x50(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x4c(%rsp), %edx
movq 0x50(%rsp), %rax
movb 0x10(%rax), %r8b
movl 0x64(%rsp), %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %r9d, %r9d
andb $0x1, %r8b
movl %r9d, %ecx
movzbl %r8b, %r8d
movl $0x1, (%rsp)
movl %eax, 0x8(%rsp)
callq 0xf450
movl %eax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movb 0x10(%rax), %al
movb %al, 0x37(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x40(%rsp)
testb $0x1, 0x63(%rsp)
je 0x119d7
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x119e0
xorl %eax, %eax
movq %rax, 0x20(%rsp)
jmp 0x119e0
movl 0x30(%rsp), %edx
movq 0x28(%rsp), %rdi
movb 0x37(%rsp), %al
movq 0x38(%rsp), %rsi
movl 0x40(%rsp), %r8d
movq 0x20(%rsp), %r9
xorl %ecx, %ecx
xorl %ecx, %ecx
movq %rsp, %rcx
movq %r9, 0x10(%rcx)
movl %r8d, 0x8(%rcx)
movq %rsi, (%rcx)
movzbl %al, %r8d
andl $0x1, %r8d
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
callq 0xf710
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x118f2
addq $0x78, %rsp
retq
nopl (%rax)