// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: callPeaksLog
void callPeaksLog(File in, bool gz, File out, bool gzOut,
    char* line, int xcount, char** xchrList, int xBedLen,
    Bed* xBed, float minPQval, bool qvalOpt, int minLen,
    int maxGap, float minAUC, uint64_t genomeLen,
    bool verbose) {
  // determine index of fields ([pq]-value) to analyze
  int idxQ = -1;
  int idxP = getIdx(in, gz, line, qvalOpt, &idxQ);

  // initialize variables for genomic regions to be excluded
  uint32_t* bed = NULL;         // array of BED coordinates
  int bedLen = 0;               // length of bed array
  int bedIdx = 0;               // index into bed array
  uint32_t bedPos = UINT32_MAX; // next coordinate
  bool save = true;             // status of current interval
  bool warn = false;            // warn of new skipped regions?

  // initialize counting variables
  int count = 0;
  uint64_t peakBP = 0;
  bool genomeOpt = genomeLen == 0;

  // initialize peak variables
  float auc = 0.0f;                     // area under the curve (signif.)
  int64_t peakStart = -1, peakEnd = -1; // ends of potential peak
  float summitVal = -1.0f;              // summit p/q value
  uint32_t summitPos = 0;               // distance from peakStart to summit
  uint32_t summitLen = 0;               // length of summit interval
  float summitPval = -1.0f, summitQval = -1.0f; // summit p- and q-values

  // parse bedgraph records
  char prev[MAX_ALNS];              // previous chrom name
  prev[0] = '\0';
  bool skip = false;                // skip current chrom?
  char* chr, *stat, *pStat, *qStat; // chrom and stats/NA of current interval
  uint32_t start, end;              // coordinates of current interval
  float pqval;                      // [pq]-value of current interval
  while (getLine(line, MAX_SIZE, in, gz) != NULL) {

    // load fields from bedgraph record
    loadBDG(line, &chr, &start, &end, &pStat, idxP,
      &qStat, idxQ, qvalOpt);

    // new chromosome
    if (strcmp(prev, chr)) {
      // check if previous chrom's last peak is valid
      checkPeak(out, gzOut, prev, peakStart, peakEnd,
        &count, auc, summitPval, summitQval, summitPos,
        minAUC, minLen, &peakBP);

      // reset peak variables
      resetVars(&peakStart, &summitVal, &summitLen, &auc);

      // check if new chrom should be skipped
      skip = checkChrom(chr, xcount, xchrList);
      if (verbose && skip) {
        fprintf(stderr, "Warning! Skipping chromosome %s --\n  ", chr);
        fprintf(stderr, "Reads aligning to it were used in the background");
        fprintf(stderr, " pileup calculation,\n  and its length was included");
        fprintf(stderr, " in the genome length %scalculation\n",
          qvalOpt ? "(and q-value) " : "");
      }

      // check for regions to be skipped
      bedLen = 0;
      if (! skip) {
        // load regions from xBed
        // (note: cannot check validity of coordinates)
        saveXBed(chr, UINT32_MAX, &bedLen, &bed, xBedLen,
          xBed, verbose);

        // load next coordinate
        bedIdx = 0;
        bedPos = bedIdx < bedLen ? bed[bedIdx]
          : UINT32_MAX;
        save = true;
      }

      strcpy(prev, chr);  // update current chrom
    }
    if (skip)
      continue; // current chrom to be skipped

    // check stat for 'NA' (skipped region)
    stat = qvalOpt ? qStat : pStat;
    if (!strcmp(stat, NA)) {
      // check if previous peak is valid
      checkPeak(out, gzOut, chr, peakStart, peakEnd,
        &count, auc, summitPval, summitQval, summitPos,
        minAUC, minLen, &peakBP);

      // reset peak variables
      resetVars(&peakStart, &summitVal, &summitLen, &auc);
      continue;
    }
    pqval = getFloat(stat);

    // check if current interval starts at a position
    //   to be skipped (new -E)
    if (bedPos == start) {
      if (save) {
        // check if previous peak is valid
        checkPeak(out, gzOut, chr, peakStart, peakEnd,
          &count, auc, summitPval, summitQval, summitPos,
          minAUC, minLen, &peakBP);
        // reset peak variables
        resetVars(&peakStart, &summitVal, &summitLen, &auc);
      }

      // load next coordinate
      save = ! save;
      bedIdx++;
      bedPos = bedIdx < bedLen ? bed[bedIdx] : UINT32_MAX;
    }

    // check if current interval contains the next position
    //   to be skipped (new -E)
    uint32_t subStart = start;  // start of current subinterval
    while (bedPos > start && bedPos < end) {

      if (save) {
        // interval *not* to be skipped:
        //   update peak if necessary, then print if valid
        if (pqval > minPQval) {
          // interval reaches significance
          updatePeak(&peakStart, &peakEnd, subStart,
            bedPos, &auc, pqval, minPQval,
            qvalOpt ? getFloat(pStat) : pqval,
            qvalOpt ? pqval : SKIP,
            &summitVal, &summitPval, &summitQval,
            &summitPos, &summitLen);
        }
        // check if peak is valid
        checkPeak(out, gzOut, chr, peakStart, peakEnd,
          &count, auc, summitPval, summitQval, summitPos,
          minAUC, minLen, &peakBP);
        // reset peak variables
        resetVars(&peakStart, &summitVal, &summitLen, &auc);
        if (genomeOpt)
          genomeLen += bedPos - subStart; // update genome length
      } else
        warn = true;

      // load next coordinate
      subStart = bedPos;
      save = ! save;
      bedIdx++;
      bedPos = bedIdx < bedLen ? bed[bedIdx] : UINT32_MAX;
    }
    if (! save) {
      warn = true;
      continue;
    }
    start = subStart; // reset start coordinate

    // check [pq]-value for significance
    if (genomeOpt)
      genomeLen += end - start; // update genome length
    if (pqval > minPQval) {

      // interval reaches significance
      updatePeak(&peakStart, &peakEnd, start, end,
        &auc, pqval, minPQval,
        qvalOpt ? getFloat(pStat) : pqval,
        qvalOpt ? pqval : SKIP,
        &summitVal, &summitPval, &summitQval,
        &summitPos, &summitLen);

    } else {

      // interval does not reach significance --
      //   check if distance is beyond maxGap from peak
      if (end - peakEnd > maxGap) {
        // check if previous peak is valid
        checkPeak(out, gzOut, chr, peakStart, peakEnd,
          &count, auc, summitPval, summitQval, summitPos,
          minAUC, minLen, &peakBP);

        // reset peak variables
        resetVars(&peakStart, &summitVal, &summitLen, &auc);
      }
    }

  }

  // check if last peak is valid
  checkPeak(out, gzOut, chr, peakStart, peakEnd,
    &count, auc, summitPval, summitQval, summitPos,
    minAUC, minLen, &peakBP);

  if (verbose) {
    if (warn) {
      fprintf(stderr, "Warning! Skipping given BED regions --\n  ");
      fprintf(stderr, "Reads aligning to them were used in the background");
      fprintf(stderr, " pileup calculation,\n  and the lengths were included");
      fprintf(stderr, " in the genome length %scalculation\n",
        qvalOpt ? "(and q-value) " : "");
    }
    fprintf(stderr, "Peak-calling parameters:\n");
    fprintf(stderr, "  Genome length: %ldbp\n", genomeLen);
    fprintf(stderr, "  Significance threshold: -log(%c) > %.3f\n",
      qvalOpt ? 'q' : 'p', minPQval);
    fprintf(stderr, "  Min. AUC: %.3f\n", minAUC);
    if (minLen)
      fprintf(stderr, "  Min. peak length: %dbp\n", minLen);
    fprintf(stderr, "  Max. gap between sites: %dbp\n", maxGap);
    fprintf(stderr, "Peaks identified: %d (%ldbp)\n",
      count, peakBP);
  }

  free(bed);
}

// Assembly:
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdx, 0x80(%rsp)
movq %rdi, %r10
movq 0x80(%rsp), %rdi
movb %cl, %dl
movb 0x228(%rsp), %al
movq 0x220(%rsp), %rcx
movl 0x218(%rsp), %ecx
movl 0x210(%rsp), %ecx
movb 0x208(%rsp), %cl
movq 0x200(%rsp), %r11
movl 0x1f8(%rsp), %r11d
movq 0x1f0(%rsp), %r11
movq %r10, 0x1d8(%rsp)
movq %rdi, 0x1d0(%rsp)
andb $0x1, %sil
movb %sil, 0x1cf(%rsp)
andb $0x1, %dl
movb %dl, 0x1ce(%rsp)
movq %r8, 0x1c0(%rsp)
movl %r9d, 0x1bc(%rsp)
movss %xmm0, 0x1b8(%rsp)
andb $0x1, %cl
movb %cl, 0x1b7(%rsp)
movss %xmm1, 0x1b0(%rsp)
andb $0x1, %al
movb %al, 0x1af(%rsp)
movl $0xffffffff, 0x1a8(%rsp) # imm = 0xFFFFFFFF
movb 0x1cf(%rsp), %cl
movq 0x1c0(%rsp), %rdx
movb 0x1b7(%rsp), %al
movq 0x1d8(%rsp), %rdi
leaq 0x1a8(%rsp), %r8
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %ecx
callq 0x6d90
movl %eax, 0x1a4(%rsp)
movq $0x0, 0x198(%rsp)
movl $0x0, 0x194(%rsp)
movl $0x0, 0x190(%rsp)
movl $0xffffffff, 0x18c(%rsp) # imm = 0xFFFFFFFF
movb $0x1, 0x18b(%rsp)
movb $0x0, 0x18a(%rsp)
movl $0x0, 0x184(%rsp)
movq $0x0, 0x178(%rsp)
cmpq $0x0, 0x220(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x177(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x170(%rsp)
movq $-0x1, 0x168(%rsp)
movq $-0x1, 0x160(%rsp)
movss 0x16fb3(%rip), %xmm0    # 0x1e194
movss %xmm0, 0x15c(%rsp)
movl $0x0, 0x158(%rsp)
movl $0x0, 0x154(%rsp)
movss 0x16f8c(%rip), %xmm0    # 0x1e194
movss %xmm0, 0x150(%rsp)
movss 0x16f7b(%rip), %xmm0    # 0x1e194
movss %xmm0, 0x14c(%rsp)
movb $0x0, 0xc0(%rsp)
movb $0x0, 0xbf(%rsp)
movq 0x1c0(%rsp), %rdi
movb 0x1cf(%rsp), %al
movq 0x1d8(%rsp), %rdx
movl $0xfff0, %esi           # imm = 0xFFF0
andb $0x1, %al
movzbl %al, %ecx
callq 0x2a20
cmpq $0x0, %rax
je 0x7c86
movq 0x1c0(%rsp), %rdi
movl 0x1a4(%rsp), %r9d
movl 0x1a8(%rsp), %r10d
movb 0x1b7(%rsp), %al
leaq 0xb0(%rsp), %rsi
leaq 0x94(%rsp), %rdx
leaq 0x90(%rsp), %rcx
leaq 0xa0(%rsp), %r8
leaq 0x98(%rsp), %r11
andb $0x1, %al
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movzbl %al, %eax
movl %eax, 0x10(%rsp)
callq 0x6ef0
leaq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x21a0
cmpl $0x0, %eax
je 0x7510
movb 0x1ce(%rsp), %sil
leaq 0xc0(%rsp), %rdx
movq 0x168(%rsp), %rcx
movq 0x160(%rsp), %r8
movss 0x170(%rsp), %xmm0
movss 0x150(%rsp), %xmm1
movss 0x14c(%rsp), %xmm2
movl 0x158(%rsp), %r11d
movss 0x1b0(%rsp), %xmm3
movl 0x210(%rsp), %r10d
movq 0x1d0(%rsp), %rdi
leaq 0x184(%rsp), %r9
leaq 0x178(%rsp), %rax
andb $0x1, %sil
movzbl %sil, %esi
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5cb0
leaq 0x168(%rsp), %rdi
leaq 0x15c(%rsp), %rsi
leaq 0x154(%rsp), %rdx
leaq 0x170(%rsp), %rcx
callq 0x5da0
movq 0xb0(%rsp), %rdi
movl 0x1bc(%rsp), %esi
movq 0x1f0(%rsp), %rdx
callq 0x6d20
andb $0x1, %al
movb %al, 0xbf(%rsp)
testb $0x1, 0x1af(%rsp)
je 0x744f
testb $0x1, 0xbf(%rsp)
je 0x744f
movq 0x1bc26(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movq 0xb0(%rsp), %rdx
leaq 0x1844d(%rip), %rsi     # 0x1f831
movb $0x0, %al
callq 0x21c0
movq 0x1bc06(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x1845b(%rip), %rsi     # 0x1f857
movb $0x0, %al
callq 0x21c0
movq 0x1bbee(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x18474(%rip), %rsi     # 0x1f888
movb $0x0, %al
callq 0x21c0
movq 0x1bbd6(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movb 0x1b7(%rsp), %cl
leaq 0x1893f(%rip), %rdx     # 0x1fd72
leaq 0x184a6(%rip), %rax     # 0x1f8e0
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x18473(%rip), %rsi     # 0x1f8bb
movb $0x0, %al
callq 0x21c0
movl $0x0, 0x194(%rsp)
testb $0x1, 0xbf(%rsp)
jne 0x74fb
movq 0xb0(%rsp), %rdi
movl 0x1f8(%rsp), %r8d
movq 0x200(%rsp), %r9
movb 0x1af(%rsp), %al
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x194(%rsp), %rdx
leaq 0x198(%rsp), %rcx
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0x6970
movl $0x0, 0x190(%rsp)
movl 0x190(%rsp), %eax
cmpl 0x194(%rsp), %eax
jge 0x74dd
movq 0x198(%rsp), %rax
movslq 0x190(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x7c(%rsp)
jmp 0x74e8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x7c(%rsp)
jmp 0x74e8
movl 0x7c(%rsp), %eax
movl %eax, 0x18c(%rsp)
movb $0x1, 0x18b(%rsp)
leaq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x2070
testb $0x1, 0xbf(%rsp)
je 0x751f
jmp 0x7232
testb $0x1, 0x1b7(%rsp)
je 0x7538
movq 0x98(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x7545
movq 0xa0(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x180d2(%rip), %rsi     # 0x1f633
callq 0x21a0
cmpl $0x0, %eax
jne 0x7620
movb 0x1ce(%rsp), %sil
movq 0xb0(%rsp), %rdx
movq 0x168(%rsp), %rcx
movq 0x160(%rsp), %r8
movss 0x170(%rsp), %xmm0
movss 0x150(%rsp), %xmm1
movss 0x14c(%rsp), %xmm2
movl 0x158(%rsp), %r11d
movss 0x1b0(%rsp), %xmm3
movl 0x210(%rsp), %r10d
movq 0x1d0(%rsp), %rdi
leaq 0x184(%rsp), %r9
leaq 0x178(%rsp), %rax
andb $0x1, %sil
movzbl %sil, %esi
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5cb0
leaq 0x168(%rsp), %rdi
leaq 0x15c(%rsp), %rsi
leaq 0x154(%rsp), %rdx
leaq 0x170(%rsp), %rcx
callq 0x5da0
jmp 0x7232
movq 0xa8(%rsp), %rdi
callq 0x2930
movss %xmm0, 0x8c(%rsp)
movl 0x18c(%rsp), %eax
cmpl 0x94(%rsp), %eax
jne 0x7766
testb $0x1, 0x18b(%rsp)
je 0x7704
movb 0x1ce(%rsp), %sil
movq 0xb0(%rsp), %rdx
movq 0x168(%rsp), %rcx
movq 0x160(%rsp), %r8
movss 0x170(%rsp), %xmm0
movss 0x150(%rsp), %xmm1
movss 0x14c(%rsp), %xmm2
movl 0x158(%rsp), %r11d
movss 0x1b0(%rsp), %xmm3
movl 0x210(%rsp), %r10d
movq 0x1d0(%rsp), %rdi
leaq 0x184(%rsp), %r9
leaq 0x178(%rsp), %rax
andb $0x1, %sil
movzbl %sil, %esi
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5cb0
leaq 0x168(%rsp), %rdi
leaq 0x15c(%rsp), %rsi
leaq 0x154(%rsp), %rdx
leaq 0x170(%rsp), %rcx
callq 0x5da0
movb 0x18b(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x18b(%rsp)
movl 0x190(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x190(%rsp)
movl 0x190(%rsp), %eax
cmpl 0x194(%rsp), %eax
jge 0x7750
movq 0x198(%rsp), %rax
movslq 0x190(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x6c(%rsp)
jmp 0x775b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x6c(%rsp)
jmp 0x775b
movl 0x6c(%rsp), %eax
movl %eax, 0x18c(%rsp)
movl 0x94(%rsp), %eax
movl %eax, 0x88(%rsp)
movl 0x18c(%rsp), %ecx
xorl %eax, %eax
cmpl 0x94(%rsp), %ecx
movb %al, 0x6b(%rsp)
jbe 0x779f
movl 0x18c(%rsp), %eax
cmpl 0x90(%rsp), %eax
setb %al
movb %al, 0x6b(%rsp)
movb 0x6b(%rsp), %al
testb $0x1, %al
jne 0x77ac
jmp 0x7a37
testb $0x1, 0x18b(%rsp)
je 0x79ba
movss 0x8c(%rsp), %xmm0
ucomiss 0x1b8(%rsp), %xmm0
jbe 0x78e2
movl 0x88(%rsp), %eax
movl %eax, 0x58(%rsp)
movl 0x18c(%rsp), %eax
movl %eax, 0x5c(%rsp)
movss 0x8c(%rsp), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x1b8(%rsp), %xmm0
movss %xmm0, 0x64(%rsp)
testb $0x1, 0x1b7(%rsp)
je 0x7824
movq 0xa0(%rsp), %rdi
callq 0x2930
movss %xmm0, 0x54(%rsp)
jmp 0x7833
movss 0x8c(%rsp), %xmm0
movss %xmm0, 0x54(%rsp)
movss 0x54(%rsp), %xmm0
movss %xmm0, 0x50(%rsp)
testb $0x1, 0x1b7(%rsp)
je 0x785a
movss 0x8c(%rsp), %xmm0
movss %xmm0, 0x4c(%rsp)
jmp 0x786a
movss 0x16932(%rip), %xmm0    # 0x1e194
movss %xmm0, 0x4c(%rsp)
jmp 0x786a
movss 0x50(%rsp), %xmm2
movss 0x64(%rsp), %xmm1
movss 0x60(%rsp), %xmm0
movl 0x5c(%rsp), %ecx
movl 0x58(%rsp), %edx
movss 0x4c(%rsp), %xmm3
leaq 0x168(%rsp), %rdi
leaq 0x160(%rsp), %rsi
leaq 0x170(%rsp), %r8
leaq 0x15c(%rsp), %r9
leaq 0x150(%rsp), %rbx
leaq 0x14c(%rsp), %r11
leaq 0x158(%rsp), %r10
leaq 0x154(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x5df0
movb 0x1ce(%rsp), %sil
movq 0xb0(%rsp), %rdx
movq 0x168(%rsp), %rcx
movq 0x160(%rsp), %r8
movss 0x170(%rsp), %xmm0
movss 0x150(%rsp), %xmm1
movss 0x14c(%rsp), %xmm2
movl 0x158(%rsp), %r11d
movss 0x1b0(%rsp), %xmm3
movl 0x210(%rsp), %r10d
movq 0x1d0(%rsp), %rdi
leaq 0x184(%rsp), %r9
leaq 0x178(%rsp), %rax
andb $0x1, %sil
movzbl %sil, %esi
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5cb0
leaq 0x168(%rsp), %rdi
leaq 0x15c(%rsp), %rsi
leaq 0x154(%rsp), %rdx
leaq 0x170(%rsp), %rcx
callq 0x5da0
testb $0x1, 0x177(%rsp)
je 0x79b8
movl 0x18c(%rsp), %eax
subl 0x88(%rsp), %eax
movl %eax, %eax
addq 0x220(%rsp), %rax
movq %rax, 0x220(%rsp)
jmp 0x79c2
movb $0x1, 0x18a(%rsp)
movl 0x18c(%rsp), %eax
movl %eax, 0x88(%rsp)
movb 0x18b(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x18b(%rsp)
movl 0x190(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x190(%rsp)
movl 0x190(%rsp), %eax
cmpl 0x194(%rsp), %eax
jge 0x7a1c
movq 0x198(%rsp), %rax
movslq 0x190(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x48(%rsp)
jmp 0x7a27
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x48(%rsp)
jmp 0x7a27
movl 0x48(%rsp), %eax
movl %eax, 0x18c(%rsp)
jmp 0x7774
testb $0x1, 0x18b(%rsp)
jne 0x7a4e
movb $0x1, 0x18a(%rsp)
jmp 0x7232
movl 0x88(%rsp), %eax
movl %eax, 0x94(%rsp)
testb $0x1, 0x177(%rsp)
je 0x7a86
movl 0x90(%rsp), %eax
subl 0x94(%rsp), %eax
movl %eax, %eax
addq 0x220(%rsp), %rax
movq %rax, 0x220(%rsp)
movss 0x8c(%rsp), %xmm0
ucomiss 0x1b8(%rsp), %xmm0
jbe 0x7bb3
movl 0x94(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x90(%rsp), %eax
movl %eax, 0x3c(%rsp)
movss 0x8c(%rsp), %xmm0
movss %xmm0, 0x40(%rsp)
movss 0x1b8(%rsp), %xmm0
movss %xmm0, 0x44(%rsp)
testb $0x1, 0x1b7(%rsp)
je 0x7af0
movq 0xa0(%rsp), %rdi
callq 0x2930
movss %xmm0, 0x34(%rsp)
jmp 0x7aff
movss 0x8c(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
movss 0x34(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
testb $0x1, 0x1b7(%rsp)
je 0x7b26
movss 0x8c(%rsp), %xmm0
movss %xmm0, 0x2c(%rsp)
jmp 0x7b36
movss 0x16666(%rip), %xmm0    # 0x1e194
movss %xmm0, 0x2c(%rsp)
jmp 0x7b36
movss 0x30(%rsp), %xmm2
movss 0x44(%rsp), %xmm1
movss 0x40(%rsp), %xmm0
movl 0x3c(%rsp), %ecx
movl 0x38(%rsp), %edx
movss 0x2c(%rsp), %xmm3
leaq 0x168(%rsp), %rdi
leaq 0x160(%rsp), %rsi
leaq 0x170(%rsp), %r8
leaq 0x15c(%rsp), %r9
leaq 0x150(%rsp), %rbx
leaq 0x14c(%rsp), %r11
leaq 0x158(%rsp), %r10
leaq 0x154(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x5df0
jmp 0x7c81
movl 0x90(%rsp), %eax
subq 0x160(%rsp), %rax
movslq 0x218(%rsp), %rcx
cmpq %rcx, %rax
jle 0x7c7f
movb 0x1ce(%rsp), %sil
movq 0xb0(%rsp), %rdx
movq 0x168(%rsp), %rcx
movq 0x160(%rsp), %r8
movss 0x170(%rsp), %xmm0
movss 0x150(%rsp), %xmm1
movss 0x14c(%rsp), %xmm2
movl 0x158(%rsp), %r11d
movss 0x1b0(%rsp), %xmm3
movl 0x210(%rsp), %r10d
movq 0x1d0(%rsp), %rdi
leaq 0x184(%rsp), %r9
leaq 0x178(%rsp), %rax
andb $0x1, %sil
movzbl %sil, %esi
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5cb0
leaq 0x168(%rsp), %rdi
leaq 0x15c(%rsp), %rsi
leaq 0x154(%rsp), %rdx
leaq 0x170(%rsp), %rcx
callq 0x5da0
jmp 0x7c81
jmp 0x7232
movb 0x1ce(%rsp), %sil
movq 0xb0(%rsp), %rdx
movq 0x168(%rsp), %rcx
movq 0x160(%rsp), %r8
movss 0x170(%rsp), %xmm0
movss 0x150(%rsp), %xmm1
movss 0x14c(%rsp), %xmm2
movl 0x158(%rsp), %r11d
movss 0x1b0(%rsp), %xmm3
movl 0x210(%rsp), %r10d
movq 0x1d0(%rsp), %rdi
leaq 0x184(%rsp), %r9
leaq 0x178(%rsp), %rax
andb $0x1, %sil
movzbl %sil, %esi
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5cb0
testb $0x1, 0x1af(%rsp)
je 0x7ea9
testb $0x1, 0x18a(%rsp)
je 0x7da1
movq 0x1b2cc(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x17bb9(%rip), %rsi     # 0x1f8ef
movb $0x0, %al
callq 0x21c0
movq 0x1b2b4(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x17bcb(%rip), %rsi     # 0x1f919
movb $0x0, %al
callq 0x21c0
movq 0x1b29c(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x17be6(%rip), %rsi     # 0x1f94c
movb $0x0, %al
callq 0x21c0
movq 0x1b284(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movb 0x1b7(%rsp), %cl
leaq 0x17fed(%rip), %rdx     # 0x1fd72
leaq 0x17b54(%rip), %rax     # 0x1f8e0
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x17b21(%rip), %rsi     # 0x1f8bb
movb $0x0, %al
callq 0x21c0
movq 0x1b250(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x178d9(%rip), %rsi     # 0x1f68b
movb $0x0, %al
callq 0x21c0
movq 0x1b238(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movq 0x220(%rsp), %rdx
leaq 0x178d3(%rip), %rsi     # 0x1f6a5
movb $0x0, %al
callq 0x21c0
movq 0x1b218(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movb 0x1b7(%rsp), %cl
movl $0x70, %edx
movl $0x71, %eax
testb $0x1, %cl
cmovnel %eax, %edx
movss 0x1b8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x178af(%rip), %rsi     # 0x1f6bd
movb $0x1, %al
callq 0x21c0
movq 0x1b1dc(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movss 0x1b0(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x178b5(%rip), %rsi     # 0x1f6e8
movb $0x1, %al
callq 0x21c0
cmpl $0x0, 0x210(%rsp)
je 0x7e63
movq 0x1b1ad(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movl 0x210(%rsp), %edx
leaq 0x1789e(%rip), %rsi     # 0x1f6fa
movb $0x0, %al
callq 0x21c0
movq 0x1b18e(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movl 0x218(%rsp), %edx
leaq 0x17899(%rip), %rsi     # 0x1f714
movb $0x0, %al
callq 0x21c0
movq 0x1b16f(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movl 0x184(%rsp), %edx
movq 0x178(%rsp), %rcx
leaq 0x178ac(%rip), %rsi     # 0x1f74e
movb $0x0, %al
callq 0x21c0
movq 0x198(%rsp), %rdi
callq 0x2040
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
retq
nop