// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_process_seeds
static void gt_diagbandseed_process_seeds(GtSeedpairlist *seedpairlist,
                                         const GtDiagbandseedExtendParams *extp,
                                          void *processinfo,
                                          GtQuerymatchoutoptions *querymoutopt,
                                          const GtEncseq *aencseq,
                                          const GtSequencePartsInfo *aseqranges,
                                          GtUword aidx,
                                          const GtEncseq *bencseq,
                                          const GtSequencePartsInfo *bseqranges,
                                          GtUword bidx,
                                          const GtKarlinAltschulStat
                                            *karlin_altschul_stat,
                                          GtArrayGtDiagbandseedMaximalmatch
                                            *memstore,
                                          const GtChain2Dimmode *chainmode,
                                          unsigned int spacedseedweight,
                                          unsigned int seedlength,
                                          GtReadmode query_readmode,
                                          bool verbose,
                                          FILE *stream,
                                          const GtStr *diagband_statistics_arg,
                                          GtDiagbandseedState
                                            *dbs_state,
                                          GtSegmentRejectFunc
                                            segment_reject_func,
                                          GtSegmentRejectInfo
                                            *segment_reject_info)
{
  const bool forward = query_readmode == GT_READMODE_REVCOMPL ? false : true;
  /* Although the sequences of the parts processed are shorter, we need to
     set amaxlen and bmaxlen to the maximum size of all sequences
     to get the same division into diagonal bands for all parts and thus
     obtain results independent of the number of parts chosen. */
  const GtUword mlistlen = gt_seedpairlist_length(seedpairlist),
                minsegmentlen = (extp->mincoverage - 1) / seedlength + 1;
  GtTimer *timer = NULL;
  GtDiagbandStruct *diagband_struct = NULL;
  GtDiagbandseedExtendSegmentInfo *esi = NULL;
  GtDiagbandStatistics *diagband_statistics = NULL;
  GtDiagbandseedProcessSegmentFunc segment_proc_func = NULL;
  void *segment_proc_info = NULL;

  gt_assert(extp->mincoverage >= seedlength && minsegmentlen >= 1);
  if (mlistlen == 0 || mlistlen < minsegmentlen ||
      (!extp->extendgreedy && !extp->extendxdrop))
  {
    return;
  }
  if (verbose)
  {
    timer = gt_timer_new();
    gt_timer_start(timer);
  }
  if (seedpairlist->maxmat_show)
  {
    fprintf(stream,"# Fields: s.len, s.seqnum, s.start, strand, q.seqnum, "
                   "q.start\n");
  } else
  {
    const GtUword bmaxlen = gt_encseq_max_seq_length(bencseq);
    if (verbose)
    {
      gt_diagbandseed_match_header(stream,extp,processinfo,
                                   spacedseedweight,
                                   seedlength,
                                   gt_diagband_struct_num_diagbands(
                                              seedpairlist->amaxlen,bmaxlen,
                                              extp->logdiagbandwidth),
                                   minsegmentlen);
    }
    diagband_struct = gt_diagband_struct_new(seedpairlist->amaxlen,bmaxlen,
                                             extp->logdiagbandwidth);
    if (gt_str_length(diagband_statistics_arg) == 0)
    {
      esi = gt_diagbandseed_extendSI_new(extp,
                                         processinfo,
                                         querymoutopt,
                                         aencseq,
                                         aseqranges,
                                         aidx,
                                         bencseq,
                                         bseqranges,
                                         bidx,
                                         karlin_altschul_stat,
                                         query_readmode,
                                         stream,
                                         dbs_state,
                                         segment_reject_func,
                                         segment_reject_info);
      if (verbose)
      {
        if (esi->plainsequence_info.a_byte_sequence != NULL ||
            esi->plainsequence_info.b_byte_sequence != NULL)
        {
          fprintf(stream, "# ... extracted sequences ");
          gt_timer_show_formatted(timer, GT_DIAGBANDSEED_FMT, stream);
          gt_timer_start(timer);
        }
      }
      segment_proc_func = gt_diagbandseed_segment2matches;
      segment_proc_info = esi;
    } else
    {
      diagband_statistics = gt_diagband_statistics_new(diagband_statistics_arg,
                                                       forward);
      segment_proc_func = gt_diagband_statistics_add;
      segment_proc_info = diagband_statistics;
    }
  }
  if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_STRUCT)
  {
    const GtDiagbandseedSeedPair
      *mlist = gt_seedpairlist_mlist_struct(seedpairlist),
      *mlistend = mlist + mlistlen,
      *last_segment_start = mlistend - minsegmentlen,
      *nextsegm = mlist;

    gt_assert(nextsegm <= last_segment_start);
    /* iterate through segments of equal k-mers */
    while (nextsegm <= last_segment_start)
    {
      GtSeedpairPositions *spp_ptr, *segment_positions;
      GtUword segment_length;
      const GtDiagbandseedSeedPair *currsegm = nextsegm;
      const GtDiagbandseedSeqnum currsegm_aseqnum = currsegm->aseqnum;
      const GtDiagbandseedSeqnum currsegm_bseqnum = currsegm->bseqnum;

      /* if insuffienct number of kmers in segment: skip whole segment */
      if (currsegm_aseqnum != currsegm[minsegmentlen - 1].aseqnum ||
          currsegm_bseqnum != currsegm[minsegmentlen - 1].bseqnum)
      {
        do
        {
          nextsegm++;
        } while (nextsegm < mlistend &&
                 currsegm_aseqnum == nextsegm->aseqnum &&
                 currsegm_bseqnum == nextsegm->bseqnum);
        continue; /* process next segment */
      }

      /* this segment begining with nextsegm possibly has enough seeds */
      spp_ptr = segment_positions = (GtSeedpairPositions *) currsegm;
      do
      {
        if (!seedpairlist->maxmat_compute)
        {
          gt_diagband_struct_single_update(diagband_struct,
                                           GT_DIAGBANDSEED_GETPOS_A(nextsegm),
                                           GT_DIAGBANDSEED_GETPOS_B(nextsegm),
                                           (GtDiagbandseedPosition) seedlength);
        }
        spp_ptr->apos = GT_DIAGBANDSEED_GETPOS_A(nextsegm);
        spp_ptr->bpos = GT_DIAGBANDSEED_GETPOS_B(nextsegm);
        spp_ptr++;
        nextsegm++;
      } while (nextsegm < mlistend &&
               currsegm_aseqnum == nextsegm->aseqnum &&
               currsegm_bseqnum == nextsegm->bseqnum);

      if (esi != NULL)
      {
        gt_diagbandseed_plainsequence_next_segment(&esi->plainsequence_info,
                                                   aseqranges,
                                                   currsegm_aseqnum,
                                                   bseqranges,
                                                   currsegm_bseqnum);
      }

      /* from here on we only need the apos and bpos values of the segment, as
         the segment boundaries have been identified.
         second scan: test for mincoverage and overlap to previous extension,
         based on apos and bpos values. */
      segment_length = (GtUword) (nextsegm - currsegm);
      GT_DIAGBANDSEED_PROCESS_SEGMENT;
    }
  } else
  {
    if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
    {
      const GtUword *mlist = gt_seedpairlist_mlist_ulong(seedpairlist),
                    *mlistend = mlist + mlistlen,
                    *last_segment_start = mlistend - minsegmentlen,
                    *nextsegm = mlist;
     GtUword nextsegm_a_bseqnum, segment_length;

      gt_assert(nextsegm <= last_segment_start);
      /* iterate through segments of equal k-mers */
      nextsegm_a_bseqnum
        = gt_seedpairlist_a_bseqnum_ulong (seedpairlist,*mlist);
      while (nextsegm <= last_segment_start)
      {
        GtSeedpairPositions *spp_ptr, *segment_positions;
        GtUword currsegm_aseqnum, currsegm_bseqnum;
        const GtUword *currsegm = nextsegm;
        const GtUword currsegm_a_bseqnum = nextsegm_a_bseqnum;

        /* if insuffienct number of kmers in segment: skip whole segment */
        if (currsegm_a_bseqnum !=
            gt_seedpairlist_a_bseqnum_ulong (seedpairlist,
                                             currsegm[minsegmentlen-1]))
        {
          do
          {
            nextsegm++;
          } while (nextsegm < mlistend &&
                   currsegm_a_bseqnum ==
                   (nextsegm_a_bseqnum =
                   gt_seedpairlist_a_bseqnum_ulong (seedpairlist,*nextsegm)));
          continue; /* process next segment */
        }

        /* this segment begining with nextsegm pssibly has enough seeds */
        currsegm_aseqnum = gt_seedpairlist_extract_ulong(seedpairlist,*currsegm,
                                                         idx_aseqnum) +
                           seedpairlist->aseqrange_start;
        currsegm_bseqnum = gt_seedpairlist_extract_ulong(seedpairlist,*currsegm,
                                                         idx_bseqnum) +
                           seedpairlist->bseqrange_start;
        spp_ptr = segment_positions = (GtSeedpairPositions *) currsegm;
        do
        {
          GtUword apos = gt_seedpairlist_extract_ulong(seedpairlist,*nextsegm,
                                                       idx_apos);

          spp_ptr->bpos
            = gt_seedpairlist_extract_ulong(seedpairlist,*nextsegm,idx_bpos);
          spp_ptr->apos = apos;
          if (!seedpairlist->maxmat_compute)
          {
            gt_diagband_struct_single_update(diagband_struct,
                                             spp_ptr->apos,
                                             spp_ptr->bpos,
                                             (GtDiagbandseedPosition)
                                                 seedlength);
          }
          spp_ptr++;
          nextsegm++;
        } while (nextsegm < mlistend &&
                 currsegm_a_bseqnum ==
                 (nextsegm_a_bseqnum =
                 gt_seedpairlist_a_bseqnum_ulong (seedpairlist,*nextsegm)));

        if (esi != NULL)
        {
          gt_diagbandseed_plainsequence_next_segment(&esi->plainsequence_info,
                                                     aseqranges,
                                                     currsegm_aseqnum,
                                                     bseqranges,
                                                     currsegm_bseqnum);
        }

        /* from here on we only need the apos and bpos values of the segment, as
           the segment boundaries have been identified.
           second scan: test for mincoverage and overlap to previous extension,
           based on apos and bpos values. */
        segment_length = (GtUword) (nextsegm - currsegm);
        GT_DIAGBANDSEED_PROCESS_SEGMENT;
      }
    } else
    {
      GtDiagbandseedSeedPair nextsegment;
      const GtUword minsegmentlen_offset = (minsegmentlen - 1) *
                                           seedpairlist->bytes_seedpair,
                    last_segment_offset = (mlistlen - minsegmentlen) *
                                          seedpairlist->bytes_seedpair,
                    mlistlen_offset = mlistlen * seedpairlist->bytes_seedpair;
      GtUword nextsegment_offset = 0, segment_length;

      gt_assert(seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_BYTESTRING);
      /* iterate through segments of equal k-mers, segment has length > 0 */
      gt_diagbandseed_decode_seedpair(&nextsegment,seedpairlist,0);
      while (nextsegment_offset <= last_segment_offset)
      {
        GtSeedpairPositions *spp_ptr, *segment_positions;
        GtDiagbandseedSeedPair endminsegment;
        GtDiagbandseedSeqnum currsegm_aseqnum = nextsegment.aseqnum;
        GtDiagbandseedSeqnum currsegm_bseqnum = nextsegment.bseqnum;

        gt_diagbandseed_decode_seedpair(&endminsegment,seedpairlist,
                                        nextsegment_offset +
                                        minsegmentlen_offset);
        if (currsegm_aseqnum != endminsegment.aseqnum ||
            currsegm_bseqnum != endminsegment.bseqnum)
        {
          /* insuffienct number of kmers in segment: skip whole segment */
          while (true)
          {
            nextsegment_offset += seedpairlist->bytes_seedpair;
            if (nextsegment_offset >= mlistlen_offset)
            {
              break;
            }
            gt_diagbandseed_decode_seedpair(&nextsegment,seedpairlist,
                                            nextsegment_offset);
            if (currsegm_aseqnum != nextsegment.aseqnum ||
                currsegm_bseqnum != nextsegment.bseqnum)
            {
              break;
            }
          }
          continue; /* process next segment */
        }

        spp_ptr = segment_positions
                = (GtSeedpairPositions *)
                  (gt_seedpairlist_mlist_bytestring(seedpairlist) +
                   nextsegment_offset);
        do
        {
          if (!seedpairlist->maxmat_compute)
          {
            gt_diagband_struct_single_update(
                                         diagband_struct,
                                         GT_DIAGBANDSEED_GETPOS_A(&nextsegment),
                                         GT_DIAGBANDSEED_GETPOS_B(&nextsegment),
                                         (GtDiagbandseedPosition) seedlength);
          }
          spp_ptr->apos = GT_DIAGBANDSEED_GETPOS_A(&nextsegment);
          spp_ptr->bpos = GT_DIAGBANDSEED_GETPOS_B(&nextsegment);
          spp_ptr++;
          nextsegment_offset += seedpairlist->bytes_seedpair;
          if (nextsegment_offset >= mlistlen_offset)
          {
            break;
          }
          gt_diagbandseed_decode_seedpair(&nextsegment,seedpairlist,
                                          nextsegment_offset);
        } while (currsegm_aseqnum == nextsegment.aseqnum &&
                 currsegm_bseqnum == nextsegment.bseqnum);

        /* from here on we only need the apos and bpos values of the segment, as
           the segment boundaries have been identified.
           second scan: test for mincoverage and overlap to previous extension,
           based on apos and bpos values. */
        currsegm_aseqnum += seedpairlist->aseqrange_start;
        currsegm_bseqnum += seedpairlist->bseqrange_start;
        if (esi != NULL)
        {
          gt_diagbandseed_plainsequence_next_segment(&esi->plainsequence_info,
                                                     aseqranges,
                                                     currsegm_aseqnum,
                                                     bseqranges,
                                                     currsegm_bseqnum);
        }
        segment_length = (GtUword) (spp_ptr - segment_positions);
        GT_DIAGBANDSEED_PROCESS_SEGMENT;
      }
    }
  }
  if (diagband_struct != NULL)
  {
    if (verbose)
    {
      gt_diagband_struct_reset_counts(diagband_struct,stream);
    }
    gt_diagband_struct_delete(diagband_struct);
  }
  if (verbose)
  {
    if (dbs_state != NULL)
    {
      const GtUword numseqpairs = (seedpairlist->aseqrange_end -
                                   seedpairlist->aseqrange_start + 1) *
                                  (seedpairlist->bseqrange_end -
                                   seedpairlist->bseqrange_start + 1);
      gt_diagbandseed_dbs_state_update(dbs_state,mlistlen,numseqpairs);
#ifndef _WIN32
      dbs_state->total_process_seeds_usec
        += gt_timer_elapsed_usec(timer);
#endif
    }
    gt_timer_delete(timer);
  }
  gt_diagbandseed_extendSI_delete(esi);
  if (diagband_statistics != NULL)
  {
    gt_diagband_statistics_display(diagband_statistics);
    gt_diagband_statistics_delete(diagband_statistics);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, 0xc8(%rsp)
movq %r8, 0x48(%rsp)
movq %rcx, 0x68(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movl 0x170(%rsp), %ebp
movq 0x1a8(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x1a0(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x198(%rsp), %r14
movq 0x190(%rsp), %r15
movq 0x188(%rsp), %rax
movq %rax, 0x80(%rsp)
movb 0x180(%rsp), %al
movb %al, 0x7(%rsp)
movl 0x178(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x168(%rsp), %r13d
movq 0x160(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x88(%rsp)
callq 0x19d824
movq %rax, 0xa0(%rsp)
movq %r12, 0x50(%rsp)
movq 0x8(%r12), %rcx
leaq -0x1(%rcx), %rax
xorl %edx, %edx
divq %rbp
cmpq %rbp, %rcx
jb 0x19f0a7
movq %rax, %r12
incq %r12
je 0x19f0a7
movq %rax, 0x28(%rsp)
movq 0xa0(%rsp), %rax
subq %r12, %rax
movq %rax, 0x58(%rsp)
jb 0x19f095
movq 0x50(%rsp), %rax
cmpb $0x0, 0x78(%rax)
jne 0x19de8e
movq 0x50(%rsp), %rax
cmpb $0x1, 0x79(%rax)
jne 0x19f095
cmpb $0x0, 0x7(%rsp)
movq %rbp, 0x60(%rsp)
je 0x19deb1
callq 0x1226a4
movq %rax, 0xd0(%rsp)
movq %rax, %rdi
callq 0x122733
jmp 0x19debd
movq $0x0, 0xd0(%rsp)
movq 0x20(%rsp), %rdi
movb 0xb1(%rbx), %al
movb %al, 0x6(%rsp)
cmpb $0x1, %al
movq %r14, 0x78(%rsp)
jne 0x19df11
leaq 0x20c60e(%rip), %rdi    # 0x3aa4ea
movl $0x3e, %esi
movl $0x1, %edx
movq 0x80(%rsp), %rcx
callq 0x17fa0
xorl %r13d, %r13d
movq $0x0, 0x40(%rsp)
xorl %ecx, %ecx
xorl %r14d, %r14d
xorl %r12d, %r12d
movq 0x28(%rsp), %r15
jmp 0x19e570
callq 0xf035e
movq %rax, %r14
cmpb $0x0, 0x7(%rsp)
je 0x19e035
movq 0xb8(%rbx), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rdx
movq %r14, %rsi
callq 0x311cd8
movq %rax, 0x10(%rsp)
leaq 0x20c6eb(%rip), %rdi    # 0x3aa632
movl $0x20, %esi
movl $0x1, %edx
movq 0x80(%rsp), %rbp
movq %rbp, %rcx
callq 0x17fa0
leaq 0x20c6eb(%rip), %rdi    # 0x3aa653
movl $0x22, %esi
movl $0x1, %edx
movq %rbp, %rcx
callq 0x17fa0
movq 0x60(%rsp), %rax
cmpl %eax, %r13d
jae 0x19df9c
leaq 0x20c6eb(%rip), %rsi    # 0x3aa676
movq %rbp, %rdi
movl %r13d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x17ab0
jmp 0x19dfaf
leaq 0x20c6f8(%rip), %rsi    # 0x3aa69b
movq %rbp, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x17ab0
movq 0x50(%rsp), %r13
movq 0x8(%r13), %r8
leaq 0x20c6eb(%rip), %rsi    # 0x3aa6aa
movq %rbp, %rdi
movq 0x10(%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x17ab0
cmpb $0x1, 0x78(%r13)
jne 0x19e017
movq 0x18(%r13), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1eb029
movq %rax, %r13
movq %r12, %rdi
callq 0x1eb019
leaq 0x20c6ee(%rip), %rsi    # 0x3aa6ee
movq %rbp, %rdi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x17ab0
jmp 0x19e035
movq 0x8(%rsp), %rdi
callq 0x1e9ead
leaq 0x20c73d(%rip), %rsi    # 0x3aa765
movq %rbp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17ab0
movq 0xb8(%rbx), %rdi
movq 0x50(%rsp), %r12
movq (%r12), %rdx
movq %r14, %rsi
callq 0x311cef
movq %rax, 0x10(%rsp)
movq %r15, %rdi
callq 0x120d4c
testq %rax, %rax
je 0x19e091
xorl %esi, %esi
cmpl $0x3, 0x1c(%rsp)
setne %sil
movq %r15, %rdi
callq 0x312043
movq %rax, %r13
leaq 0x174099(%rip), %rax    # 0x312115
movq %rax, 0x40(%rsp)
xorl %r14d, %r14d
movq %r13, %rcx
movq 0x28(%rsp), %r15
jmp 0x19e56b
leaq 0x20b034(%rip), %rsi    # 0x3a90cc
movl $0x198, %edi            # imm = 0x198
movl $0xda4, %edx            # imm = 0xDA4
callq 0x1092b2
movq %rax, %r13
cmpb $0x0, 0x78(%r12)
je 0x19e0bb
leaq 0x4cbe4(%rip), %rax     # 0x1eac9d
jmp 0x19e0c2
leaq 0x4caef(%rip), %rax     # 0x1eabb1
movq %rax, 0x158(%r13)
movq 0x58(%r12), %rdi
callq 0x1c2ba7
movl %eax, %r15d
movq 0x58(%r12), %rdi
callq 0x1c2c09
movl %eax, %r14d
movl 0x50(%r12), %ebp
movl 0x54(%r12), %eax
movl %eax, 0x40(%rsp)
movq %r13, %r12
movq $-0x1, 0xc8(%r13)
cmpq $0x0, 0x48(%rsp)
je 0x19e11d
testb %r15b, %r15b
je 0x19e11d
movq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0xf0b65
testb %al, %al
jne 0x19e120
xorl %r15d, %r15d
movq %r15, 0xf0(%r12)
cmpq $0x0, 0x20(%rsp)
sete %al
xorb $0x1, %r14b
orb %al, %r14b
jne 0x19e14d
movq 0x20(%rsp), %rdi
callq 0xf0b65
movq 0x20(%rsp), %rcx
testb %al, %al
jne 0x19e14f
xorl %ecx, %ecx
movq %r12, %r13
movq %rcx, 0xf8(%r12)
movl %ebp, 0xb8(%rsp)
cmpl $0x2, %ebp
movq 0x78(%rsp), %r14
jne 0x19e1d0
movq 0xc8(%rsp), %r15
movq %r15, %rdi
movq 0x88(%rsp), %r14
movq %r14, %rsi
callq 0x1ebca9
movq %rax, 0xd0(%r13)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1eb7dc
movq %rax, 0xd8(%r13)
movq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x78(%rsp), %r14
callq 0x1ebf37
movq %rax, 0xb8(%r13)
movq %rbp, %rdi
callq 0xf0c8a
testq %rax, %rax
setne 0x31(%r13)
jmp 0x19e204
xorl %eax, %eax
movq %rax, 0xb8(%r13)
movq 0x48(%rsp), %rcx
movq %rcx, 0x50(%r13)
movq %rax, 0x48(%r13)
movq %rax, 0x58(%r13)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x60(%r13)
movq %rax, 0x70(%r13)
movw $0x100, 0x78(%r13)      # imm = 0x100
movb $0x1, 0x31(%r13)
movl 0x1c(%rsp), %ebp
movl 0x40(%rsp), %esi
cmpl $0x2, %esi
jne 0x19e29a
cmpl $0x2, 0xb8(%rsp)
setne %r14b
movq 0xc0(%rsp), %r15
movq %r15, %rdi
movq 0x70(%rsp), %rbp
movq %rbp, %rsi
callq 0x1ebca9
movq %r12, %r13
movq %rax, 0xe0(%r12)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1eb7dc
movq %rax, 0xe8(%r12)
movq 0x48(%rsp), %rax
movq 0x20(%rsp), %rdx
xorq %rdx, %rax
movq 0x88(%rsp), %rcx
xorq %rbp, %rcx
orq %rax, %rcx
setne %al
orb %r14b, %al
jne 0x19e2ea
movb $0x0, 0x30(%r13)
movq 0xb8(%r13), %rax
movq %rax, 0xc0(%r13)
movb 0x31(%r13), %al
movb %al, 0x32(%r13)
jmp 0x19e31d
xorl %eax, %eax
movq %rax, 0xc0(%r12)
movq 0x20(%rsp), %rdx
movq %rdx, 0x88(%r12)
movq %rax, 0x80(%r12)
movq %rax, 0x90(%r12)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x98(%r12)
movq %rax, 0xa8(%r12)
movw $0x100, 0xb0(%r12) # imm = 0x100
movb $0x1, 0x32(%r12)
jmp 0x19e32a
movb $0x1, 0x30(%r13)
movq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1ebf37
movq %rax, 0xc0(%r13)
movq 0x20(%rsp), %rdi
callq 0xf0c8a
movq 0x20(%rsp), %rdx
testq %rax, %rax
setne 0x32(%r13)
movq 0x78(%rsp), %r14
movl 0x1c(%rsp), %ebp
movl 0x40(%rsp), %esi
cmpl $0x2, %esi
setne %al
cmpl $0x2, 0xb8(%rsp)
setne %cl
testb %al, %cl
movq %r12, %r13
jne 0x19e370
movq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0xf02e2
movq %rax, 0x38(%r13)
movq %r15, %rdi
callq 0xf02da
movq %rax, %rdi
callq 0xd3746
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ebp
movb %al, 0x40(%r13)
movq 0x8(%rsp), %rax
movq %rax, 0x108(%r13)
movq 0x50(%rsp), %r15
cmpq $0x0, 0x70(%r15)
je 0x19e39a
movq $0x0, 0x110(%r13)
movq 0x28(%rsp), %r15
jmp 0x19e3fb
callq 0x1c3820
movq %rax, 0x110(%r13)
cmpb $0x1, 0x7d(%r15)
jne 0x19e3b5
movq %rax, %rdi
callq 0x1c39cf
movq 0x68(%rsp), %rsi
testq %rsi, %rsi
movq 0x28(%rsp), %r15
je 0x19e3d0
movq 0x110(%r13), %rdi
callq 0x1c3942
movq 0x110(%r13), %rdi
movl 0x1c(%rsp), %ebp
movl %ebp, %esi
callq 0x1c39c8
movq 0x110(%r13), %rdi
movq 0x80(%rsp), %rsi
callq 0x1c396d
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %r12
movq %r12, 0x118(%r13)
movq 0x50(%rsp), %rcx
movq 0x58(%rcx), %rax
movq %rax, 0x120(%r13)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x128(%r13)
movdqu %xmm0, 0x138(%r13)
movdqu %xmm0, 0x148(%r13)
movq %r14, 0x190(%r13)
movq %rcx, %r14
movups 0x30(%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x68(%rcx), %rax
movq %rax, 0x10(%r13)
movq 0x8(%rcx), %rax
movq %rax, 0x18(%r13)
movb 0x7e(%rcx), %al
movb %al, 0x20(%r13)
movsd 0x40(%rcx), %xmm0
movsd %xmm0, 0x28(%r13)
movl %ebp, 0x100(%r13)
cmpq %rdx, 0x48(%rsp)
sete 0x104(%r13)
callq 0x108df6
movb %al, 0x105(%r13)
movq 0x98(%rsp), %rax
movq %rax, 0x160(%r13)
movq 0x90(%rsp), %rax
movq %rax, 0x168(%r13)
movq %r12, 0x170(%r13)
movq 0x58(%r14), %rax
movq %rax, 0x178(%r13)
movb 0x7b(%r14), %al
movb %al, 0x180(%r13)
movq 0x70(%r14), %rax
movl 0x1c(%rsp), %ecx
andl $-0x3, %ecx
xorl %edx, %edx
cmpl $0x1, %ecx
sete %dl
shll $0x4, %edx
addq %rax, %rdx
testq %rax, %rax
cmoveq %rax, %rdx
movq %rdx, 0x188(%r13)
leaq 0x1b2d(%rip), %rax      # 0x1a0021
movq %rax, 0x40(%rsp)
cmpb $0x0, 0x7(%rsp)
je 0x19e566
cmpq $0x0, 0xb8(%r13)
movq 0x80(%rsp), %r14
movq 0xd0(%rsp), %r15
movq 0x10(%rsp), %r12
jne 0x19e529
cmpq $0x0, 0xc0(%r13)
je 0x19e55c
leaq 0x20bff9(%rip), %rdi    # 0x3aa529
movl $0x1a, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x17fa0
leaq 0x20b669(%rip), %rsi    # 0x3a9bb2
movq %r15, %rdi
movq %r14, %rdx
callq 0x1227b4
movq %r15, %rdi
callq 0x122733
xorl %ecx, %ecx
movq %r13, %r14
jmp 0x19df07
xorl %ecx, %ecx
movq %r13, %r14
movq 0x10(%rsp), %r12
movq %r12, 0x10(%rsp)
movl 0x18(%rbx), %eax
cmpl $0x1, %eax
movq %r13, 0x70(%rsp)
movq %rcx, 0xe0(%rsp)
movq %r14, 0x88(%rsp)
je 0x19e8c7
testl %eax, %eax
jne 0x19ec28
testq %rbx, %rbx
je 0x19f0d9
testl %eax, %eax
jne 0x19f0d9
movq (%rbx), %rax
testq %rax, %rax
je 0x19f0d9
movq (%rax), %r13
movq 0xa0(%rsp), %rdx
shlq $0x4, %rdx
addq %r13, %rdx
movq %r15, %rax
notq %rax
shlq $0x4, %rax
addq %rdx, %rax
movq %rax, 0x58(%rsp)
cmpq %rax, %r13
ja 0x19f0e8
leaq 0x30(%r14), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x70(%rsp)
sete %al
orb %al, 0x6(%rsp)
shlq $0x4, %r15
movq %rdx, 0x8(%rsp)
movq %r15, 0x28(%rsp)
movl (%r13), %r14d
movl 0x4(%r13), %r12d
cmpl 0x4(%r13,%r15), %r12d
jne 0x19e7bd
leaq (%r15,%r13), %rax
cmpl (%rax), %r14d
jne 0x19e7bd
movl $0xa, %r15d
movl $0x10, %eax
movq %rax, %r10
cmpb $0x0, 0xb0(%rbx)
jne 0x19e667
movl -0xc(%r13,%r15,2), %esi
movl -0x8(%r13,%r15,2), %edx
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rcx
movq %r10, %rbp
callq 0x311e4d
movq %rbp, %r10
movq 0x8(%rsp), %rdx
movq -0xc(%r13,%r15,2), %rax
movq %rax, -0xa(%r13,%r15)
leaq (%r10,%r13), %rbp
cmpq %rdx, %rbp
jae 0x19e693
cmpl (%r13,%r15,2), %r12d
jne 0x19e693
leaq 0x8(%r15), %rcx
leaq 0x10(%r10), %rax
cmpl -0x4(%r13,%r15,2), %r14d
movq %rcx, %r15
je 0x19e637
cmpq $0x0, 0x88(%rsp)
je 0x19e6c9
movq 0x38(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq %r12, %rdx
movq 0xc0(%rsp), %rcx
movq %r14, %r8
movq %r10, %r15
callq 0x1a0738
movq %r15, %r10
movq 0x8(%rsp), %rdx
sarq $0x4, %r10
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x19e6ff
movq 0x90(%rsp), %rdi
movq %r14, %rsi
movq %r10, %r15
callq *%rax
movq %r15, %r10
movq 0x28(%rsp), %r15
movq 0x8(%rsp), %rdx
testb %al, %al
jne 0x19e816
cmpb $0x1, 0xb0(%rbx)
jne 0x19e7e6
xorl %edi, %edi
cmpl $0x3, 0x1c(%rsp)
setne %dil
movq 0x50(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x30(%rsp), %r15
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq 0x60(%rsp), %r8
pushq 0x80(%rsp)
pushq 0xe0(%rsp)
pushq 0xa0(%rsp)
pushq 0xb0(%rsp)
pushq 0x98(%rsp)
pushq %r10
pushq %r13
pushq 0xb8(%rbx)
movq %r10, 0xa8(%rsp)
callq 0x1a0878
addq $0x40, %rsp
testq %r15, %r15
je 0x19e7ed
movq 0x10(%rsp), %r15
testq %r15, %r15
je 0x19f0c0
movq %r15, %rdi
callq 0x311ce6
testb %al, %al
je 0x19f0c0
movq 0x30(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rcx
movq %r15, %rdi
movq %rcx, %r15
movq %rcx, %rdx
callq 0x311f05
movq %r15, %r10
movq 0x30(%rsp), %r15
movq 0x8(%rsp), %rdx
jmp 0x19e803
addq $0x10, %r13
movq %r13, %rbp
cmpq %rdx, %r13
jae 0x19e8b4
cmpl 0x4(%rbp), %r12d
jne 0x19e8b4
leaq 0x10(%rbp), %r13
cmpl (%rbp), %r14d
je 0x19e7c1
jmp 0x19e8b4
movq 0x30(%rsp), %r15
jmp 0x19e803
cmpq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq 0x68(%rsp), %r10
jne 0x19f0de
testq %r15, %r15
jne 0x19e81d
cmpb $0x0, 0xb0(%rbx)
je 0x19e81d
movq 0x28(%rsp), %r15
movq 0x10(%rsp), %r14
jmp 0x19e872
cmpb $0x0, 0x6(%rsp)
jne 0x19f0c5
testq %r15, %r15
je 0x19e832
movq (%r15), %rax
jmp 0x19e834
xorl %eax, %eax
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r12, %rcx
movq %r14, %r8
movq 0x10(%rsp), %r14
movq %r14, %r9
pushq %r10
pushq %r13
pushq 0x70(%rsp)
pushq %rax
movq %r10, %r15
callq *0x60(%rsp)
movq %r15, %r10
addq $0x20, %rsp
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %r15
testq %r14, %r14
je 0x19e8b4
movq %r10, %r12
movq %r14, %rdi
callq 0x311ce6
testb %al, %al
jne 0x19e8af
movl $0x0, %edx
movq 0x30(%rsp), %rax
testq %rax, %rax
movl $0x0, %ecx
cmovneq %rcx, %r13
je 0x19e8a1
movq (%rax), %rdx
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rcx
callq 0x311f48
movq 0x8(%rsp), %rdx
movq %rbp, %r13
cmpq 0x58(%rsp), %rbp
jbe 0x19e60c
jmp 0x19ef7a
testq %rbx, %rbx
je 0x19f0d4
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x19f0d4
movq (%rax), %r14
movq 0xa0(%rsp), %rax
leaq (%r14,%rax,8), %rdi
movq %r15, %rax
notq %rax
leaq (%rdi,%rax,8), %rdx
cmpq %rdx, %r14
ja 0x19f0ed
movq (%r14), %r13
movb 0x9c(%rbx), %cl
shrq %cl, %r13
movq 0x88(%rsp), %rax
addq $0x30, %rax
movq %rax, 0xb8(%rsp)
cmpq $0x0, 0x70(%rsp)
sete %al
orb %al, 0x6(%rsp)
movq %rdi, 0x8(%rsp)
movq %rdx, 0x68(%rsp)
movq (%r14,%r15,8), %rax
movl 0x9c(%rbx), %ecx
shrq %cl, %rax
cmpq %rax, %r13
jne 0x19eb15
movq (%r14), %rdx
movb 0x98(%rbx), %cl
movb 0x9c(%rbx), %al
movq %rdx, %rsi
shrq %cl, %rsi
andq 0x20(%rbx), %rsi
addq 0x48(%rbx), %rsi
movq %rsi, 0x38(%rsp)
movl %eax, %ecx
shrq %cl, %rdx
andq 0x28(%rbx), %rdx
addq 0x50(%rbx), %rdx
movq %rdx, 0x58(%rsp)
leaq 0x8(%r14), %rax
movl $0x8, %ecx
movq %r13, %r12
movq %rax, %rbp
movq %rcx, %r15
movq -0x8(%rax), %rdx
movb 0xa0(%rbx), %al
movb 0xa4(%rbx), %cl
movq %rdx, %rsi
shrq %cl, %rsi
movl %eax, %ecx
shrq %cl, %rdx
andl 0x38(%rbx), %esi
andl 0x30(%rbx), %edx
movl %edx, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpb $0x0, 0xb0(%rbx)
jne 0x19e9d6
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rcx
callq 0x311e4d
movq 0x8(%rsp), %rdi
leaq -0x8(%rbp), %rax
addq $0x8, %rax
cmpq %rdi, %rax
jae 0x19e9fd
movq (%rbp), %r12
movb 0x9c(%rbx), %cl
shrq %cl, %r12
leaq 0x8(%rbp), %rax
leaq 0x8(%r15), %rcx
cmpq %r12, %r13
je 0x19e98c
cmpq $0x0, 0x88(%rsp)
je 0x19ea34
movq 0xb8(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0xc0(%rsp), %rcx
movq 0x58(%rsp), %r8
callq 0x1a0738
movq 0x8(%rsp), %rdi
sarq $0x3, %r15
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x19ea61
movq 0x90(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq *%rax
movq 0x8(%rsp), %rdi
testb %al, %al
jne 0x19eb69
cmpb $0x1, 0xb0(%rbx)
jne 0x19eb43
xorl %edi, %edi
cmpl $0x3, 0x1c(%rsp)
setne %dil
movq 0x50(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x30(%rsp), %r13
movq %r13, %rsi
movq 0x38(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %r8
pushq 0x80(%rsp)
pushq 0xe0(%rsp)
pushq 0xa0(%rsp)
pushq 0xb0(%rsp)
pushq 0x98(%rsp)
pushq %r15
pushq %r14
pushq 0xb8(%rbx)
callq 0x1a0878
addq $0x40, %rsp
testq %r13, %r13
je 0x19eb4a
movq 0x10(%rsp), %r13
testq %r13, %r13
je 0x19f0b1
movq %r13, %rdi
callq 0x311ce6
testb %al, %al
je 0x19f0b1
movq 0x30(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %r15
movq %r13, %rdi
movq %r15, %rdx
callq 0x311f05
movq 0x30(%rsp), %r13
movq 0x8(%rsp), %rdi
jmp 0x19eb5b
addq $0x8, %r14
cmpq %rdi, %r14
jae 0x19eb3b
movq (%r14), %r12
shrq %cl, %r12
cmpq %r12, %r13
jne 0x19ec17
addq $0x8, %r14
cmpq %rdi, %r14
jb 0x19eb1e
jmp 0x19ec17
movq %r13, %r12
jmp 0x19ec17
movq 0x30(%rsp), %r13
jmp 0x19eb5b
cmpq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
jne 0x19f0cf
testq %r13, %r13
jne 0x19eb70
cmpb $0x0, 0xb0(%rbx)
je 0x19eb70
movq 0x10(%rsp), %r13
jmp 0x19ebbf
cmpb $0x0, 0x6(%rsp)
jne 0x19f0bb
testq %r13, %r13
je 0x19eb86
movq (%r13), %rax
jmp 0x19eb88
xorl %eax, %eax
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x58(%rsp), %r8
movq 0x10(%rsp), %r13
movq %r13, %r9
pushq %r15
pushq %r14
pushq 0x70(%rsp)
pushq %rax
callq *0x60(%rsp)
addq $0x20, %rsp
movq 0x8(%rsp), %rdi
testq %r13, %r13
je 0x19ec0a
movq %r13, %rdi
callq 0x311ce6
testb %al, %al
jne 0x19ebfb
movl $0x0, %edx
movq 0x30(%rsp), %rax
testq %rax, %rax
movl $0x0, %ecx
cmovneq %rcx, %r14
je 0x19ebeb
movq (%rax), %rdx
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x311f48
movq %rbp, %r14
movq 0x28(%rsp), %r15
movq 0x8(%rsp), %rdi
jmp 0x19ec12
movq %rbp, %r14
movq 0x28(%rsp), %r15
movq 0x68(%rsp), %rdx
movq %r12, %r13
cmpq %rdx, %r14
jbe 0x19e936
jmp 0x19ef7a
cmpl $0x2, %eax
jne 0x19f0e3
movq 0x90(%rbx), %r13
imulq %r13, %r15
movq %r15, 0x28(%rsp)
movq 0x58(%rsp), %rax
imulq %r13, %rax
movq %rax, 0x58(%rsp)
imulq 0xa0(%rsp), %r13
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x19ff67
leaq 0x30(%r14), %rax
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x70(%rsp)
sete %al
orb %al, 0x6(%rsp)
xorl %r15d, %r15d
movl 0xa8(%rsp), %r12d
movl 0xac(%rsp), %ebp
movq 0x28(%rsp), %rax
leaq (%r15,%rax), %rdx
leaq 0xe8(%rsp), %rdi
movq %rbx, %rsi
callq 0x19ff67
cmpl 0xec(%rsp), %ebp
jne 0x19ee6a
cmpl 0xe8(%rsp), %r12d
jne 0x19ee6a
movq %rbx, %rdi
callq 0x197922
addq %r15, %rax
movq %rax, 0x8(%rsp)
movl $0x8, %eax
movq %rax, %r14
cmpb $0x0, 0xb0(%rbx)
jne 0x19ed04
movl 0xb0(%rsp), %esi
movl 0xb4(%rsp), %edx
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rcx
callq 0x311e4d
movq 0xb0(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rax, -0x8(%rcx,%r14)
addq 0x90(%rbx), %r15
cmpq %r13, %r15
jae 0x19ed4c
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x19ff67
cmpl 0xac(%rsp), %ebp
jne 0x19ed4c
leaq 0x8(%r14), %rax
cmpl 0xa8(%rsp), %r12d
je 0x19ecdb
addl 0x48(%rbx), %ebp
addl 0x50(%rbx), %r12d
movl %r12d, %r8d
cmpq $0x0, 0x88(%rsp)
je 0x19ed83
movl %ebp, %edx
movq 0x68(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xc0(%rsp), %rcx
movq %r8, %r12
callq 0x1a0738
movq %r12, %r8
sarq $0x3, %r14
movq 0x98(%rsp), %r10
testq %r10, %r10
movq %r8, 0x38(%rsp)
je 0x19edba
movq 0x90(%rsp), %rdi
movq %r8, %rsi
movq %r10, %r12
callq *%r10
movq %r12, %r10
movq 0x38(%rsp), %r8
testb %al, %al
jne 0x19eedf
cmpb $0x1, 0xb0(%rbx)
jne 0x19eeb6
xorl %edi, %edi
cmpl $0x3, 0x1c(%rsp)
setne %dil
movl %ebp, %edx
movq 0x50(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x30(%rsp), %r12
movq %r12, %rsi
movq %r8, %rcx
movq 0x60(%rsp), %r8
pushq 0x80(%rsp)
pushq 0xe0(%rsp)
pushq 0xa0(%rsp)
pushq %r10
pushq 0x98(%rsp)
pushq %r14
pushq 0x38(%rsp)
pushq 0xb8(%rbx)
callq 0x1a0878
addq $0x40, %rsp
testq %r12, %r12
je 0x19eebd
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x19f0ac
movq %r14, %rdi
callq 0x311ce6
testb %al, %al
je 0x19f0ac
movq %r14, %rdi
movq 0x30(%rsp), %r12
movq (%r12), %rsi
movq 0x10(%r12), %r14
movq %r14, %rdx
callq 0x311f05
movq %r12, %rax
movq 0x38(%rsp), %r8
jmp 0x19eed1
movq 0x90(%rbx), %r14
addq %r14, %r15
movq %r15, %rax
movq %rax, %r15
cmpq %r13, %rax
jae 0x19ef6f
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x19ff67
cmpl 0xac(%rsp), %ebp
jne 0x19ef6f
leaq (%r15,%r14), %rax
cmpl 0xa8(%rsp), %r12d
je 0x19ee77
jmp 0x19ef6f
movq 0x30(%rsp), %rax
jmp 0x19eed1
movq %r12, %rax
cmpq $0x0, 0x10(%rsp)
movq 0x38(%rsp), %r8
jne 0x19f0ca
testq %rax, %rax
jne 0x19eee6
cmpb $0x0, 0xb0(%rbx)
je 0x19eee6
movq 0x10(%rsp), %r12
jmp 0x19ef29
cmpb $0x0, 0x6(%rsp)
movq 0x10(%rsp), %r12
jne 0x19f0b6
testq %rax, %rax
je 0x19ef00
movq (%rax), %rax
jmp 0x19ef02
xorl %eax, %eax
movl %ebp, %ecx
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r12, %r9
pushq %r14
pushq 0x10(%rsp)
pushq 0x70(%rsp)
pushq %rax
callq *0x60(%rsp)
addq $0x20, %rsp
testq %r12, %r12
je 0x19ef6f
movq %r12, %rdi
callq 0x311ce6
testb %al, %al
jne 0x19ef6f
movl $0x0, %edx
movq 0x30(%rsp), %rax
testq %rax, %rax
movl $0x0, %ecx
movq 0x8(%rsp), %rsi
cmovneq %rcx, %rsi
movq %rsi, 0x8(%rsp)
je 0x19ef5f
movq (%rax), %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rcx
callq 0x311f48
cmpq 0x58(%rsp), %r15
jbe 0x19ec83
movq 0x10(%rsp), %r12
testq %r12, %r12
movq 0x78(%rsp), %r14
movq 0xd0(%rsp), %r15
je 0x19efb0
cmpb $0x0, 0x7(%rsp)
je 0x19efa8
movq %r12, %rdi
movq 0x80(%rsp), %rsi
callq 0x311d8d
movq %r12, %rdi
callq 0x311df8
cmpb $0x0, 0x7(%rsp)
je 0x19eff9
testq %r14, %r14
je 0x19eff1
movq 0x58(%rbx), %rax
subq 0x48(%rbx), %rax
movq 0x60(%rbx), %rcx
incq %rax
subq 0x50(%rbx), %rcx
incq %rcx
movq 0xa0(%rsp), %rdx
addq %rdx, (%r14)
imulq %rax, %rcx
addq %rcx, 0x8(%r14)
movq %r15, %rdi
callq 0x1228c4
addq %rax, 0x48(%r14)
movq %r15, %rdi
callq 0x122d79
movq 0x88(%rsp), %r14
testq %r14, %r14
movq 0xe0(%rsp), %rbx
je 0x19f06f
movq 0x110(%r14), %rdi
callq 0x1c3b35
movq 0xc0(%r14), %rdi
testq %rdi, %rdi
je 0x19f03e
cmpb $0x1, 0x30(%r14)
jne 0x19f03e
leaq 0x20a098(%rip), %rsi    # 0x3a90cc
movl $0xa45, %edx            # imm = 0xA45
callq 0x109670
movq 0xb8(%r14), %rdi
testq %rdi, %rdi
je 0x19f05b
leaq 0x20a07b(%rip), %rsi    # 0x3a90cc
movl $0xa49, %edx            # imm = 0xA49
callq 0x109670
leaq 0x20a06a(%rip), %rsi    # 0x3a90cc
movq %r14, %rdi
movl $0xde8, %edx            # imm = 0xDE8
callq 0x109670
testq %rbx, %rbx
je 0x19f095
movq %rbx, %rdi
callq 0x3120d7
movq %rbx, %rdi
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31209b
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5eb30
callq 0x5eddc
callq 0x5eb69
callq 0x5ee4e
callq 0x5ebdb
callq 0x5ec86
callq 0x5ecf8
callq 0x5ee15
callq 0x5eba2
callq 0x5ec4d
callq 0x5ed6a
callq 0x5ecbf
callq 0x5eda3
callq 0x5ed31
callq 0x5ec14