// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DAMASKER/tandem.c
// Function: report_thread
static void *report_thread(void *arg)
{ Report_Arg  *data   = (Report_Arg *) arg;

  DAZZ_READ   *aread  = MR_ablock->reads;
  KmerPos     *asort  = MG_alist;

  int         *score  = data->score;
  int         *scorp  = data->score + 1;
  int         *scorm  = data->score - 1;
  int         *lastp  = data->lastp;
  int         *lasta  = data->lasta;
  int          maxdiag = ( MR_ablock->maxlen >> Binshift);
  int          mindiag = (-MR_ablock->maxlen >> Binshift);

  FILE        *ofile  = data->ofile;

  char        *aseq   = (char *) (MR_ablock->bases);
  Work_Data   *work   = data->work;
  int          afirst = MR_ablock->tfirst;

  Overlap     _ovla, *ovla = &_ovla;
  Alignment   _align, *align = &_align;
  Path        *apath = &(ovla->path);
  int64        nfilt = 0;
  int64        ahits = 0;
  int          small, tbytes;

  int    novla;
  int    AOmax;
  Path  *amatch;

  Trace_Buffer _tbuf, *tbuf = &_tbuf;

  int      ar, aend;
  KmerPos *aoff;

  align->flags = ovla->flags = 0;
  align->path  = apath;

  if (MR_tspace <= TRACE_XOVR)
    { small  = 1;
      tbytes = sizeof(uint8);
    }
  else
    { small  = 0;
      tbytes = sizeof(uint16);
    }

  AOmax  = MATCH_CHUNK;
  amatch = Malloc(sizeof(Path)*AOmax,"Allocating match vector");

  tbuf->max   = 2*TRACE_CHUNK;
  tbuf->trace = Malloc(sizeof(short)*tbuf->max,"Allocating trace vector");

  if (amatch == NULL || tbuf->trace == NULL)
    Clean_Exit(1);

  fwrite(&ahits,sizeof(int64),1,ofile);
  fwrite(&MR_tspace,sizeof(int),1,ofile);

#ifdef TEST_GATHER
  printf("\nNEW THREAD %5d(%5lld)-%5d(%5lld)\n",asort[data->beg].read,data->beg,
                                                asort[data->end-1].read,data->end);
  fflush(stdout);
#endif

  aoff = asort + (data->beg - Kmer);
  aend = asort[data->end-1].read;
  for (ar = asort[data->beg].read; ar <= aend; ar++)
    { int alen, amarkb, amarke;
      int apos, diag;
      int setaln;

#ifdef TEST_GATHER
      printf("Read %5d\n",ar);
      fflush(stdout);
#endif
      setaln = 1;
      novla  = 0;
      tbuf->top = 0;

      alen   = aread[ar].rlen;
      amarkb = Kmer;
      amarke = PANEL_SIZE;
      if (amarke >= alen)
        amarke = alen+1;
      while (1)
        {
          // Accumulate diagonal scores

          for (apos = amarkb; apos < amarke; apos++)
            { diag = aoff[apos].code;
              if (diag == 0) continue;
              diag >>= Binshift;
              if (apos - lastp[diag] >= Kmer)
                score[diag] += Kmer;
              else
                score[diag] += apos - lastp[diag];
              lastp[diag] = apos;
            }

          // Examine diagonal scores for hits to check out

          for (apos = amarkb; apos < amarke; apos++)
            { diag = aoff[apos].code;
              if (diag == 0) continue;
              diag >>= Binshift;
              if (apos > lasta[diag] &&
                  (score[diag] + scorp[diag] >= Hitmin || score[diag] + scorm[diag] >= Hitmin))
                { int bpos;

                  bpos = apos - aoff[apos].code;
                  if (setaln)
                    { setaln = 0;
                      align->aseq = align->bseq = aseq + aread[ar].boff;
                      align->alen = align->blen = alen;
                      ovla->aread = ovla->bread = ar + afirst;
                    }
#ifdef TEST_GATHER
                  if (scorm[diag] > scorp[diag])
                    printf("  %5d.. x %5d.. %5d (%3d)",
                           bpos,apos,apos-bpos,score[diag]+scorm[diag]);
                  else
                    printf("  %5d.. x %5d.. %5d (%3d)",
                           bpos,apos,apos-bpos,score[diag]+scorp[diag]);
                  fflush(stdout);
#endif

                  nfilt += 1;

                  Local_Alignment(align,work,MR_spec,apos-bpos,apos-bpos,apos+bpos,-1,-1);

                  { int low, hgh, ae;

                    Diagonal_Span(apath,&low,&hgh);
                    if (diag < low)
                      low = diag;
                    else if (diag > hgh)
                      hgh = diag;
                    ae = apath->aepos;
                    for (diag = low; diag <= hgh; diag++)
                      if (ae > lasta[diag])
                        lasta[diag] = ae;
#ifdef TEST_GATHER
                    printf(" %d - %d @ %d",low,hgh,apath->aepos);
#endif
                  }

                  if ((apath->aepos-apath->abpos) + (apath->bepos-apath->bbpos) >= MINOVER)
                    { if (novla >= AOmax)
                        { AOmax = 1.2*novla + MATCH_CHUNK;
                          amatch = Realloc(amatch,sizeof(Path)*AOmax,
                                           "Reallocating match vector");
                          if (amatch == NULL)
                            Clean_Exit(1);
                        }
                      if (tbuf->top + apath->tlen > tbuf->max)
                        { tbuf->max = 1.2*(tbuf->top+apath->tlen) + TRACE_CHUNK;
                          tbuf->trace = Realloc(tbuf->trace,sizeof(short)*tbuf->max,
                                                "Reallocating trace vector");
                          if (tbuf->trace == NULL)
                            Clean_Exit(1);
                        }
                      amatch[novla] = *apath;
                      amatch[novla].trace = (void *) (tbuf->top);
                      memmove(tbuf->trace+tbuf->top,apath->trace,sizeof(short)*apath->tlen);
                      novla += 1;
                      tbuf->top += apath->tlen;

#ifdef TEST_GATHER
                      printf("  [%5d,%5d] x [%5d,%5d] = %4d",
                             apath->abpos,apath->aepos,apath->bbpos,apath->bepos,apath->diffs);
#endif
#ifdef SHOW_OVERLAP
                      printf("\n\n                    %d(%d) vs %d(%d)\n\n",
                             ovla->aread,ovla->alen,ovla->bread,ovla->blen);
                      Print_ACartoon(stdout,align,ALIGN_INDENT);
#ifdef SHOW_ALIGNMENT
                      Compute_Trace_ALL(align,work);
                      printf("\n                      Diff = %d\n",align->path->diffs);
                      Print_Alignment(stdout,align,work,
                                      ALIGN_INDENT,ALIGN_WIDTH,ALIGN_BORDER,0,5);
#endif
#endif // SHOW_OVERLAP
                    }
#ifdef TEST_GATHER
                  else
                    printf("  No alignment %d",
                            ((apath->aepos-apath->abpos) + (apath->bepos-apath->bbpos))/2);
                  printf("\n");
#endif
                }
            }

          // Clear diagonal scores

          for (apos = amarkb; apos < amarke; apos++)
            { diag = aoff[apos].code;
              if (diag == 0) continue;
              diag >>= Binshift;
              score[diag] = lastp[diag] = 0;
            }

          if (amarke > alen) break;

          amarkb = amarke - PANEL_OVERLAP;
          amarke = amarkb + PANEL_SIZE;
          if (amarke > alen)
            amarke = alen+1;
        }

      // Clear diagonal last positions

      for (apos = Kmer; apos <= alen; apos++)
        { int d;

          diag = aoff[apos].code;
          if (diag == 0) continue;
          diag >>= Binshift;
          for (d = diag; d <= maxdiag; d++)
            if (lasta[d] == 0)
              break;
            else
              lasta[d] = 0;
          for (d = diag-1; d >= mindiag; d--)
            if (lasta[d] == 0)
              break;
            else
              lasta[d] = 0;
        }

      // Merge overlapping alignments and remove redundant ones

      { int i;

#ifdef TEST_CONTAIN
        if (novla > 1)
          printf("\n%5d vs %5d:\n",ar,ar);
#endif

        if (novla > 1)
          novla = Handle_Redundancies(amatch,novla,tbuf);

        for (i = 0; i < novla; i++)
          { ovla->path = amatch[i];
            ovla->path.trace = tbuf->trace + (uint64) (ovla->path.trace);
            if (small)
              Compress_TraceTo8(ovla,1);
            Write_Overlap(ofile,ovla,tbytes);
          }
        ahits += novla;
      }

      aoff += alen - (Kmer-1);
    }

  free(tbuf->trace);
  free(amatch);

  data->nfilt  = nfilt;
  data->ncheck = ahits;

  rewind(ofile);
  fwrite(&ahits,sizeof(int64),1,ofile);
  fclose(ofile);

  return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x29132(%rip), %rax     # 0x2e460
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x2911b(%rip), %rax     # 0x2e458
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $-0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movq 0x290d4(%rip), %rax     # 0x2e460
movl 0x20(%rax), %eax
movl 0x2909f(%rip), %ecx     # 0x2e434
sarl %cl, %eax
movl %eax, -0x4c(%rbp)
movq 0x290bf(%rip), %rcx     # 0x2e460
xorl %eax, %eax
subl 0x20(%rcx), %eax
movl 0x29088(%rip), %ecx     # 0x2e434
sarl %cl, %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x58(%rbp)
movq 0x2909c(%rip), %rax     # 0x2e460
movq 0x58(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x68(%rbp)
movq 0x29081(%rip), %rax     # 0x2e460
movl 0x40(%rax), %eax
movl %eax, -0x6c(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq $0x0, -0xe8(%rbp)
movq $0x0, -0xf0(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xa8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0xd8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0xe0(%rbp), %rcx
movq -0xd8(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x7d, 0x28fe9(%rip)    # 0x2e450
jg 0x547f
movl $0x1, -0xf4(%rbp)
movl $0x1, -0xf8(%rbp)
jmp 0x5493
movl $0x0, -0xf4(%rbp)
movl $0x2, -0xf8(%rbp)
movl $0x64, -0x100(%rbp)
movslq -0x100(%rbp), %rdi
shlq $0x5, %rdi
leaq 0x242de(%rip), %rsi     # 0x2978d
callq 0x1d780
movq %rax, -0x108(%rbp)
movq -0x128(%rbp), %rax
movq $0x9c40, (%rax)         # imm = 0x9C40
movq -0x128(%rbp), %rax
movq (%rax), %rdi
shlq %rdi
leaq 0x242c8(%rip), %rsi     # 0x297a5
callq 0x1d780
movq %rax, %rcx
movq -0x128(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x108(%rbp)
je 0x5508
movq -0x128(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5512
movl $0x1, %edi
callq 0x2420
movq -0x58(%rbp), %rcx
leaq -0xf0(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x22e0
movq -0x58(%rbp), %rcx
leaq 0x28f19(%rip), %rdi     # 0x2e450
movl $0x4, %esi
movl $0x1, %edx
callq 0x22e0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x28ed8(%rip), %rdx     # 0x2e430
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x138(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x130(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x12c(%rbp)
movl -0x12c(%rbp), %eax
cmpl -0x130(%rbp), %eax
jg 0x5f33
movl $0x1, -0x150(%rbp)
movl $0x0, -0xfc(%rbp)
movq -0x128(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movslq -0x12c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x13c(%rbp)
movl 0x28e36(%rip), %eax     # 0x2e430
movl %eax, -0x140(%rbp)
movl $0xc350, -0x144(%rbp)   # imm = 0xC350
movl -0x144(%rbp), %eax
cmpl -0x13c(%rbp), %eax
jl 0x5627
movl -0x13c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
jmp 0x5629
movl -0x140(%rbp), %eax
movl %eax, -0x148(%rbp)
movl -0x148(%rbp), %eax
cmpl -0x144(%rbp), %eax
jge 0x5709
movq -0x138(%rbp), %rax
movslq -0x148(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, -0x14c(%rbp)
cmpl $0x0, -0x14c(%rbp)
jne 0x5673
jmp 0x56f5
movl 0x28dbb(%rip), %ecx     # 0x2e434
movl -0x14c(%rbp), %eax
sarl %cl, %eax
movl %eax, -0x14c(%rbp)
movl -0x148(%rbp), %eax
movq -0x40(%rbp), %rcx
movslq -0x14c(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
cmpl 0x28d8f(%rip), %eax     # 0x2e430
jl 0x56bc
movl 0x28d87(%rip), %edx     # 0x2e430
movq -0x28(%rbp), %rax
movslq -0x14c(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x56e1
movl -0x148(%rbp), %edx
movq -0x40(%rbp), %rax
movslq -0x14c(%rbp), %rcx
subl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movslq -0x14c(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x148(%rbp), %edx
movq -0x40(%rbp), %rax
movslq -0x14c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x148(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x148(%rbp)
jmp 0x5635
movl -0x140(%rbp), %eax
movl %eax, -0x148(%rbp)
movl -0x148(%rbp), %eax
cmpl -0x144(%rbp), %eax
jge 0x5c05
movq -0x138(%rbp), %rax
movslq -0x148(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, -0x14c(%rbp)
cmpl $0x0, -0x14c(%rbp)
jne 0x5753
jmp 0x5bf1
movl 0x28cdb(%rip), %ecx     # 0x2e434
movl -0x14c(%rbp), %eax
sarl %cl, %eax
movl %eax, -0x14c(%rbp)
movl -0x148(%rbp), %eax
movq -0x48(%rbp), %rcx
movslq -0x14c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x5bef
movq -0x28(%rbp), %rax
movslq -0x14c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rcx
movslq -0x14c(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
cmpl 0x28c95(%rip), %eax     # 0x2e438
jge 0x57cd
movq -0x28(%rbp), %rax
movslq -0x14c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x38(%rbp), %rcx
movslq -0x14c(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
cmpl 0x28c71(%rip), %eax     # 0x2e438
jl 0x5bef
movslq -0x148(%rbp), %rax
movq -0x138(%rbp), %rcx
movslq -0x148(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
subq (%rcx), %rax
movl %eax, -0x154(%rbp)
cmpl $0x0, -0x150(%rbp)
je 0x586c
movl $0x0, -0x150(%rbp)
movq -0x60(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq -0x12c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
addq 0x10(%rax), %rcx
movq -0xd8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0xd8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x13c(%rbp), %ecx
movq -0xd8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0xd8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x12c(%rbp), %ecx
addl -0x6c(%rbp), %ecx
movq -0xa8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0xa8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0xe8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe8(%rbp)
movq -0xd8(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq 0x28bd8(%rip), %rdx     # 0x2e468
movl -0x148(%rbp), %ecx
subl -0x154(%rbp), %ecx
movl -0x148(%rbp), %r8d
subl -0x154(%rbp), %r8d
movl -0x148(%rbp), %r9d
addl -0x154(%rbp), %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
callq 0x76b0
movq -0xe0(%rbp), %rdi
leaq -0x158(%rbp), %rsi
leaq -0x15c(%rbp), %rdx
callq 0x3690
movl -0x14c(%rbp), %eax
cmpl -0x158(%rbp), %eax
jge 0x5902
movl -0x14c(%rbp), %eax
movl %eax, -0x158(%rbp)
jmp 0x591e
movl -0x14c(%rbp), %eax
cmpl -0x15c(%rbp), %eax
jle 0x591c
movl -0x14c(%rbp), %eax
movl %eax, -0x15c(%rbp)
jmp 0x591e
movq -0xe0(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x160(%rbp)
movl -0x158(%rbp), %eax
movl %eax, -0x14c(%rbp)
movl -0x14c(%rbp), %eax
cmpl -0x15c(%rbp), %eax
jg 0x5985
movl -0x160(%rbp), %eax
movq -0x48(%rbp), %rcx
movslq -0x14c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x5972
movl -0x160(%rbp), %edx
movq -0x48(%rbp), %rax
movslq -0x14c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x5974
movl -0x14c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14c(%rbp)
jmp 0x593a
movq -0xe0(%rbp), %rax
movl 0x18(%rax), %eax
movq -0xe0(%rbp), %rcx
subl 0x10(%rcx), %eax
movq -0xe0(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movq -0xe0(%rbp), %rdx
subl 0x14(%rdx), %ecx
addl %ecx, %eax
leaq 0x28a6a(%rip), %rcx     # 0x2e420
cmpl (%rcx), %eax
jl 0x5bed
movl -0xfc(%rbp), %eax
cmpl -0x100(%rbp), %eax
jl 0x5a31
cvtsi2sdl -0xfc(%rbp), %xmm0
movsd 0x2362c(%rip), %xmm1    # 0x29008
mulsd %xmm1, %xmm0
movsd 0x23c78(%rip), %xmm1    # 0x29660
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x100(%rbp)
movq -0x108(%rbp), %rdi
movslq -0x100(%rbp), %rsi
shlq $0x5, %rsi
leaq 0x23dae(%rip), %rdx     # 0x297bd
callq 0x1d800
movq %rax, -0x108(%rbp)
cmpq $0x0, -0x108(%rbp)
jne 0x5a2f
movl $0x1, %edi
callq 0x2420
jmp 0x5a31
movq -0x128(%rbp), %rax
movq 0x8(%rax), %rax
movq -0xe0(%rbp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq -0x128(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x5b2e
movq -0x128(%rbp), %rax
movq 0x8(%rax), %rax
movq -0xe0(%rbp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, %xmm0
movaps 0x23c01(%rip), %xmm1    # 0x29680
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x23c05(%rip), %xmm1    # 0x29690
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x23566(%rip), %xmm1    # 0x29008
mulsd %xmm1, %xmm0
movsd 0x23bba(%rip), %xmm1    # 0x29668
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x23ba7(%rip), %xmm1    # 0x29670
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rax, %rcx
movq -0x128(%rbp), %rax
movq %rcx, (%rax)
movq -0x128(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x128(%rbp), %rax
movq (%rax), %rsi
shlq %rsi
leaq 0x23cd6(%rip), %rdx     # 0x297d7
callq 0x1d800
movq %rax, %rcx
movq -0x128(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x128(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5b2c
movl $0x1, %edi
callq 0x2420
jmp 0x5b2e
movq -0x108(%rbp), %rax
movslq -0xfc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0xe0(%rbp), %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)
movq -0x128(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x108(%rbp), %rax
movslq -0xfc(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x128(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x128(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
addq %rax, %rdi
movq -0xe0(%rbp), %rax
movq (%rax), %rsi
movq -0xe0(%rbp), %rax
movslq 0x8(%rax), %rdx
shlq %rdx
callq 0x2280
movl -0xfc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xfc(%rbp)
movq -0xe0(%rbp), %rax
movslq 0x8(%rax), %rcx
movq -0x128(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5bef
jmp 0x5bf1
movl -0x148(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x148(%rbp)
jmp 0x5715
movl -0x140(%rbp), %eax
movl %eax, -0x148(%rbp)
movl -0x148(%rbp), %eax
cmpl -0x144(%rbp), %eax
jge 0x5c91
movq -0x138(%rbp), %rax
movslq -0x148(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, -0x14c(%rbp)
cmpl $0x0, -0x14c(%rbp)
jne 0x5c48
jmp 0x5c80
movl 0x287e6(%rip), %ecx     # 0x2e434
movl -0x14c(%rbp), %eax
sarl %cl, %eax
movl %eax, -0x14c(%rbp)
movq -0x40(%rbp), %rax
movslq -0x14c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movslq -0x14c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x148(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x148(%rbp)
jmp 0x5c11
movl -0x144(%rbp), %eax
cmpl -0x13c(%rbp), %eax
jle 0x5ca1
jmp 0x5ce5
movl -0x144(%rbp), %eax
subl $0x2710, %eax           # imm = 0x2710
movl %eax, -0x140(%rbp)
movl -0x140(%rbp), %eax
addl $0xc350, %eax           # imm = 0xC350
movl %eax, -0x144(%rbp)
movl -0x144(%rbp), %eax
cmpl -0x13c(%rbp), %eax
jle 0x5ce0
movl -0x13c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
jmp 0x5629
movl 0x28745(%rip), %eax     # 0x2e430
movl %eax, -0x148(%rbp)
movl -0x148(%rbp), %eax
cmpl -0x13c(%rbp), %eax
jg 0x5dfa
movq -0x138(%rbp), %rax
movslq -0x148(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, -0x14c(%rbp)
cmpl $0x0, -0x14c(%rbp)
jne 0x5d2f
jmp 0x5de6
movl 0x286ff(%rip), %ecx     # 0x2e434
movl -0x14c(%rbp), %eax
sarl %cl, %eax
movl %eax, -0x14c(%rbp)
movl -0x14c(%rbp), %eax
movl %eax, -0x164(%rbp)
movl -0x164(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jg 0x5d92
movq -0x48(%rbp), %rax
movslq -0x164(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x5d6d
jmp 0x5d92
movq -0x48(%rbp), %rax
movslq -0x164(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x5d81
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0x5d4f
movl -0x14c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x164(%rbp)
movl -0x164(%rbp), %eax
cmpl -0x50(%rbp), %eax
jl 0x5de4
movq -0x48(%rbp), %rax
movslq -0x164(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x5dbf
jmp 0x5de4
movq -0x48(%rbp), %rax
movslq -0x164(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x5dd3
movl -0x164(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0x5da1
jmp 0x5de6
movl -0x148(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x148(%rbp)
jmp 0x5cf1
cmpl $0x1, -0xfc(%rbp)
jle 0x5e22
movq -0x108(%rbp), %rdi
movl -0xfc(%rbp), %esi
movq -0x128(%rbp), %rdx
callq 0x68e0
movl %eax, -0xfc(%rbp)
movl $0x0, -0x168(%rbp)
movl -0x168(%rbp), %eax
cmpl -0xfc(%rbp), %eax
jge 0x5ee1
movq -0xa8(%rbp), %rax
movq -0x108(%rbp), %rcx
movslq -0x168(%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)
movq -0x128(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0xa8(%rbp), %rax
movq (%rax), %rax
shlq %rax
addq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0xf4(%rbp)
je 0x5eb7
movq -0xa8(%rbp), %rdi
movl $0x1, %esi
callq 0x10760
movq -0x58(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movl -0xf8(%rbp), %edx
callq 0x106d0
movl -0x168(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x168(%rbp)
jmp 0x5e2c
movslq -0xfc(%rbp), %rax
addq -0xf0(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x13c(%rbp), %ecx
movl 0x2852e(%rip), %eax     # 0x2e430
subl $0x1, %eax
subl %eax, %ecx
movq -0x138(%rbp), %rax
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x138(%rbp)
movl -0x12c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0x55a4
movq -0x128(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x108(%rbp), %rdi
callq 0x2030
movq -0xe8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0xf0(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x58(%rbp), %rdi
callq 0x2140
movq -0x58(%rbp), %rcx
leaq -0xf0(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x22e0
movq -0x58(%rbp), %rdi
callq 0x20e0
xorl %eax, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)