// File: /workspace/github_c_makefile_star2_O0/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 $0x358, %rsp            # imm = 0x358
movq 0x408(%rsp), %rax
movq 0x400(%rsp), %rax
movq 0x3f8(%rsp), %rax
movq 0x3f0(%rsp), %rax
movq 0x3e8(%rsp), %rax
movb 0x3e0(%rsp), %al
movl 0x3d8(%rsp), %r10d
movl 0x3d0(%rsp), %r10d
movl 0x3c8(%rsp), %r10d
movq 0x3c0(%rsp), %r10
movq 0x3b8(%rsp), %r10
movq 0x3b0(%rsp), %r10
movq 0x3a8(%rsp), %r10
movq 0x3a0(%rsp), %r10
movq 0x398(%rsp), %r10
movq 0x390(%rsp), %r10
movq %rdi, 0x350(%rsp)
movq %rsi, 0x348(%rsp)
movq %rdx, 0x340(%rsp)
movq %rcx, 0x338(%rsp)
movq %r8, 0x330(%rsp)
movq %r9, 0x328(%rsp)
andb $0x1, %al
movb %al, 0x327(%rsp)
movl 0x3d8(%rsp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x3, %edx
cmovel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x326(%rsp)
movq 0x350(%rsp), %rdi
callq 0x216940
movq %rax, 0x318(%rsp)
movq 0x348(%rsp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movl 0x3d0(%rsp), %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rax
movq %rax, 0x310(%rsp)
movq $0x0, 0x308(%rsp)
movq $0x0, 0x300(%rsp)
movq $0x0, 0x2f8(%rsp)
movq $0x0, 0x2f0(%rsp)
movq $0x0, 0x2e8(%rsp)
movq $0x0, 0x2e0(%rsp)
movq 0x348(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x3d0(%rsp), %ecx
cmpq %rcx, %rax
jb 0x217494
cmpq $0x1, 0x310(%rsp)
jae 0x2174cc
movq 0x424b05(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2feb6e(%rip), %rsi    # 0x516013
leaq 0x35c044(%rip), %rdx    # 0x5734f0
leaq 0x35c073(%rip), %rcx    # 0x573526
leaq 0x35aada(%rip), %r8     # 0x571f94
movl $0xe23, %r9d            # imm = 0xE23
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2174ce
cmpq $0x0, 0x318(%rsp)
je 0x217507
movq 0x318(%rsp), %rax
cmpq 0x310(%rsp), %rax
jb 0x217507
movq 0x348(%rsp), %rax
testb $0x1, 0x78(%rax)
jne 0x21750c
movq 0x348(%rsp), %rax
testb $0x1, 0x79(%rax)
jne 0x21750c
jmp 0x218fce
testb $0x1, 0x327(%rsp)
je 0x217530
callq 0x121340
movq %rax, 0x308(%rsp)
movq 0x308(%rsp), %rdi
callq 0x1213f0
movq 0x350(%rsp), %rax
testb $0x1, 0xb1(%rax)
je 0x21755c
movq 0x3e8(%rsp), %rdi
leaq 0x35bff4(%rip), %rsi    # 0x573544
movb $0x0, %al
callq 0x199f0
jmp 0x2177f4
movq 0x398(%rsp), %rdi
callq 0xb10b0
movq %rax, 0x2d8(%rsp)
testb $0x1, 0x327(%rsp)
je 0x21762d
movq 0x3e8(%rsp), %rax
movq %rax, 0x1a0(%rsp)
movq 0x348(%rsp), %rax
movq %rax, 0x1a8(%rsp)
movq 0x340(%rsp), %rax
movq %rax, 0x1b0(%rsp)
movl 0x3c8(%rsp), %eax
movl %eax, 0x1b8(%rsp)
movl 0x3d0(%rsp), %eax
movl %eax, 0x1bc(%rsp)
movq 0x350(%rsp), %rax
movq 0xb8(%rax), %rdi
movq 0x2d8(%rsp), %rsi
movq 0x348(%rsp), %rax
movq (%rax), %rdx
callq 0x4a30e0
movq 0x1a0(%rsp), %rdi
movq 0x1a8(%rsp), %rsi
movq 0x1b0(%rsp), %rdx
movl 0x1b8(%rsp), %ecx
movl 0x1bc(%rsp), %r8d
movq %rax, %r9
movq 0x310(%rsp), %rax
movq %rax, (%rsp)
callq 0x21b6e0
movq 0x350(%rsp), %rax
movq 0xb8(%rax), %rdi
movq 0x2d8(%rsp), %rsi
movq 0x348(%rsp), %rax
movq (%rax), %rdx
callq 0x4a3140
movq %rax, 0x300(%rsp)
movq 0x3f0(%rsp), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
jne 0x2177b2
movq 0x348(%rsp), %rdi
movq 0x340(%rsp), %rsi
movq 0x338(%rsp), %rdx
movq 0x330(%rsp), %rcx
movq 0x328(%rsp), %r8
movq 0x390(%rsp), %r9
movq 0x398(%rsp), %r13
movq 0x3a0(%rsp), %r12
movq 0x3a8(%rsp), %r15
movq 0x3b0(%rsp), %r14
movl 0x3d8(%rsp), %ebp
movq 0x3e8(%rsp), %rbx
movq 0x3f8(%rsp), %r11
movq 0x400(%rsp), %r10
movq 0x408(%rsp), %rax
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movl %ebp, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
callq 0x21b830
movq %rax, 0x2f8(%rsp)
testb $0x1, 0x327(%rsp)
je 0x217791
movq 0x2f8(%rsp), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x217750
movq 0x2f8(%rsp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x21778f
movq 0x3e8(%rsp), %rdi
leaq 0x35be24(%rip), %rsi    # 0x573583
movb $0x0, %al
callq 0x199f0
movq 0x308(%rsp), %rdi
movq 0x3e8(%rsp), %rdx
leaq 0x35b40f(%rip), %rsi    # 0x572b8c
callq 0x121520
movq 0x308(%rsp), %rdi
callq 0x1213f0
jmp 0x217791
leaq 0x4428(%rip), %rax      # 0x21bbc0
movq %rax, 0x2e8(%rsp)
movq 0x2f8(%rsp), %rax
movq %rax, 0x2e0(%rsp)
jmp 0x2177f2
movq 0x3f0(%rsp), %rdi
movb 0x326(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4a39c0
movq %rax, 0x2f0(%rsp)
leaq 0x28c3c6(%rip), %rax    # 0x4a3ba0
movq %rax, 0x2e8(%rsp)
movq 0x2f0(%rsp), %rax
movq %rax, 0x2e0(%rsp)
jmp 0x2177f4
movq 0x350(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x217f47
movq 0x350(%rsp), %rdi
callq 0x21c090
movq %rax, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rax
movq 0x318(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x2c8(%rsp)
movq 0x2c8(%rsp), %rax
xorl %ecx, %ecx
subq 0x310(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x2c0(%rsp)
movq 0x2d0(%rsp), %rax
movq %rax, 0x2b8(%rsp)
movq 0x2b8(%rsp), %rax
cmpq 0x2c0(%rsp), %rax
jbe 0x2178b5
movq 0x42471c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fe785(%rip), %rsi    # 0x516013
leaq 0x35bd09(%rip), %rdx    # 0x57359e
leaq 0x35bc8a(%rip), %rcx    # 0x573526
leaq 0x35a6f1(%rip), %r8     # 0x571f94
movl $0xe6e, %r9d            # imm = 0xE6E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2178b7
jmp 0x2178b9
movq 0x2b8(%rsp), %rax
cmpq 0x2c0(%rsp), %rax
ja 0x217f42
movq 0x2b8(%rsp), %rax
movq %rax, 0x298(%rsp)
movq 0x298(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x294(%rsp)
movq 0x298(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x290(%rsp)
movl 0x294(%rsp), %eax
movq 0x298(%rsp), %rcx
movq 0x310(%rsp), %rdx
subq $0x1, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0x21794f
movl 0x290(%rsp), %eax
movq 0x298(%rsp), %rcx
movq 0x310(%rsp), %rdx
subq $0x1, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
je 0x2179c8
jmp 0x217951
movq 0x2b8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x2b8(%rsp)
movq 0x2b8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x2c8(%rsp), %rcx
movb %al, 0x19f(%rsp)
jae 0x2179b8
movl 0x294(%rsp), %ecx
movq 0x2b8(%rsp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, 0x19f(%rsp)
jne 0x2179b8
movl 0x290(%rsp), %eax
movq 0x2b8(%rsp), %rcx
cmpl (%rcx), %eax
sete %al
movb %al, 0x19f(%rsp)
movb 0x19f(%rsp), %al
testb $0x1, %al
jne 0x217951
jmp 0x2178b9
movq 0x298(%rsp), %rax
movq %rax, 0x2a8(%rsp)
movq %rax, 0x2b0(%rsp)
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
jne 0x217a1b
movq 0x300(%rsp), %rdi
movq 0x2b8(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x2b8(%rsp), %rax
movl 0xc(%rax), %edx
movl 0x3d0(%rsp), %ecx
callq 0x4a3360
movq 0x2b8(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x2b0(%rsp), %rax
movl %ecx, (%rax)
movq 0x2b8(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x2b0(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x2b0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x2b0(%rsp)
movq 0x2b8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x2b8(%rsp)
movq 0x2b8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x2c8(%rsp), %rcx
movb %al, 0x19e(%rsp)
jae 0x217ac1
movl 0x294(%rsp), %ecx
movq 0x2b8(%rsp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, 0x19e(%rsp)
jne 0x217ac1
movl 0x290(%rsp), %eax
movq 0x2b8(%rsp), %rcx
cmpl (%rcx), %eax
sete %al
movb %al, 0x19e(%rsp)
movb 0x19e(%rsp), %al
testb $0x1, %al
jne 0x2179e0
cmpq $0x0, 0x2f8(%rsp)
je 0x217b0f
movq 0x2f8(%rsp), %rdi
addq $0x30, %rdi
movq 0x328(%rsp), %rsi
movl 0x294(%rsp), %eax
movl %eax, %edx
movq 0x3a0(%rsp), %rcx
movl 0x290(%rsp), %eax
movl %eax, %r8d
callq 0x21c100
movq 0x2b8(%rsp), %rax
movq 0x298(%rsp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, 0x2a0(%rsp)
cmpq $0x0, 0x400(%rsp)
je 0x217b5c
movq 0x400(%rsp), %rax
movq 0x408(%rsp), %rdi
movl 0x290(%rsp), %ecx
movl %ecx, %esi
callq *%rax
testb $0x1, %al
jne 0x217e81
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
je 0x217d0a
movb 0x326(%rsp), %dil
movq 0x3b8(%rsp), %rsi
movl 0x294(%rsp), %eax
movl %eax, %edx
movl 0x290(%rsp), %eax
movl %eax, %ecx
movl 0x3d0(%rsp), %r8d
movq 0x348(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x350(%rsp), %rax
movq 0xb8(%rax), %r13
movq 0x2a8(%rsp), %r12
movq 0x2a0(%rsp), %r15
movq 0x3f8(%rsp), %r14
movq 0x400(%rsp), %rbx
movq 0x408(%rsp), %r11
movq 0x3c0(%rsp), %r10
movq 0x3e8(%rsp), %rax
andb $0x1, %dil
movzbl %dil, %edi
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x21c3e0
cmpq $0x0, 0x3b8(%rsp)
je 0x217cbf
jmp 0x217c33
cmpq $0x0, 0x300(%rsp)
je 0x217c4f
movq 0x300(%rsp), %rdi
callq 0x4a3110
testb $0x1, %al
jne 0x217c87
movq 0x42434a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fe3b3(%rip), %rsi    # 0x516013
leaq 0x35b956(%rip), %rdx    # 0x5735bd
leaq 0x35b8b8(%rip), %rcx    # 0x573526
leaq 0x35a31f(%rip), %r8     # 0x571f94
movl $0xea6, %r9d            # imm = 0xEA6
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x217c89
movq 0x3b8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2a0(%rsp)
movq 0x300(%rsp), %rdi
movq 0x3b8(%rsp), %rax
movq (%rax), %rsi
movq 0x2a0(%rsp), %rdx
callq 0x4a36a0
jmp 0x217d08
jmp 0x217cc1
cmpq $0x0, 0x300(%rsp)
je 0x217d04
movq 0x4242cd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fe336(%rip), %rsi    # 0x516013
leaq 0x35b91e(%rip), %rdx    # 0x573602
leaq 0x35b83b(%rip), %rcx    # 0x573526
leaq 0x35a2a2(%rip), %r8     # 0x571f94
movl $0xea6, %r9d            # imm = 0xEA6
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x217d06
jmp 0x217d08
jmp 0x217d0a
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
je 0x217d2a
cmpq $0x0, 0x3b8(%rsp)
je 0x217e7f
jmp 0x217d2c
cmpq $0x0, 0x2e8(%rsp)
je 0x217d42
cmpq $0x0, 0x2e0(%rsp)
jne 0x217d7a
movq 0x424257(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fe2c0(%rip), %rsi    # 0x516013
leaq 0x35b8c0(%rip), %rdx    # 0x57361a
leaq 0x35b7c5(%rip), %rcx    # 0x573526
leaq 0x35a22c(%rip), %r8     # 0x571f94
movl $0xea6, %r9d            # imm = 0xEA6
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x217d7c
movq 0x2e8(%rsp), %rax
movq %rax, 0x160(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x168(%rsp)
movq 0x330(%rsp), %rax
movq %rax, 0x170(%rsp)
movq 0x398(%rsp), %rax
movq %rax, 0x178(%rsp)
movl 0x294(%rsp), %eax
movq %rax, 0x180(%rsp)
movl 0x290(%rsp), %eax
movq %rax, 0x188(%rsp)
movq 0x300(%rsp), %rax
movq %rax, 0x190(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x217e01
xorl %eax, %eax
movq %rax, 0x158(%rsp)
jmp 0x217e14
movq 0x3b8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x158(%rsp)
movq 0x160(%rsp), %rax
movq 0x190(%rsp), %r9
movq 0x188(%rsp), %r8
movq 0x180(%rsp), %rcx
movq 0x178(%rsp), %rdx
movq 0x170(%rsp), %rsi
movq 0x168(%rsp), %rdi
movq 0x158(%rsp), %r14
movl 0x3d0(%rsp), %ebx
movq 0x2a8(%rsp), %r11
movq 0x2a0(%rsp), %r10
movq %r14, (%rsp)
movl %ebx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
callq *%rax
jmp 0x217e81
cmpq $0x0, 0x300(%rsp)
je 0x217f3d
movq 0x300(%rsp), %rdi
callq 0x4a3110
testb $0x1, %al
jne 0x217f3d
movq 0x300(%rsp), %rax
movq %rax, 0x150(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x217ed2
movq 0x2a8(%rsp), %rax
movq %rax, 0x148(%rsp)
jmp 0x217ede
xorl %eax, %eax
movq %rax, 0x148(%rsp)
jmp 0x217ede
movq 0x148(%rsp), %rax
movq %rax, 0x140(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x217f05
xorl %eax, %eax
movq %rax, 0x138(%rsp)
jmp 0x217f18
movq 0x3b8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x138(%rsp)
movq 0x140(%rsp), %rsi
movq 0x150(%rsp), %rdi
movq 0x138(%rsp), %rdx
movq 0x2a0(%rsp), %rcx
callq 0x4a3760
jmp 0x2178b9
jmp 0x218eba
movq 0x350(%rsp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x218757
movq 0x350(%rsp), %rdi
callq 0x21cb50
movq %rax, 0x288(%rsp)
movq 0x288(%rsp), %rax
movq 0x318(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x280(%rsp)
movq 0x280(%rsp), %rax
xorl %ecx, %ecx
subq 0x310(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x278(%rsp)
movq 0x288(%rsp), %rax
movq %rax, 0x270(%rsp)
movq 0x270(%rsp), %rax
cmpq 0x278(%rsp), %rax
jbe 0x218008
movq 0x423fc9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fe032(%rip), %rsi    # 0x516013
leaq 0x35b5b6(%rip), %rdx    # 0x57359e
leaq 0x35b537(%rip), %rcx    # 0x573526
leaq 0x359f9e(%rip), %r8     # 0x571f94
movl $0xeb2, %r9d            # imm = 0xEB2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21800a
movq 0x350(%rsp), %rdi
movq 0x288(%rsp), %rax
movq (%rax), %rsi
callq 0x21cbb0
movq %rax, 0x268(%rsp)
movq 0x270(%rsp), %rax
cmpq 0x278(%rsp), %rax
ja 0x218752
movq 0x270(%rsp), %rax
movq %rax, 0x238(%rsp)
movq 0x268(%rsp), %rax
movq %rax, 0x230(%rsp)
movq 0x230(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x350(%rsp), %rdi
movq 0x238(%rsp), %rax
movq 0x310(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x21cbb0
movq %rax, %rcx
movq 0x130(%rsp), %rax
cmpq %rcx, %rax
je 0x218136
jmp 0x2180ab
movq 0x270(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x270(%rsp)
movq 0x270(%rsp), %rcx
xorl %eax, %eax
cmpq 0x280(%rsp), %rcx
movb %al, 0x12f(%rsp)
jae 0x218122
movq 0x230(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x350(%rsp), %rdi
movq 0x270(%rsp), %rax
movq (%rax), %rsi
callq 0x21cbb0
movq %rax, %rcx
movq 0x120(%rsp), %rax
movq %rcx, 0x268(%rsp)
cmpq %rcx, %rax
sete %al
movb %al, 0x12f(%rsp)
movb 0x12f(%rsp), %al
testb $0x1, %al
jne 0x2180ab
jmp 0x21802a
movq 0x350(%rsp), %rdi
movq 0x238(%rsp), %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x21b630
movq 0x350(%rsp), %rcx
addq 0x48(%rcx), %rax
movq %rax, 0x248(%rsp)
movq 0x350(%rsp), %rdi
movq 0x238(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x21b630
movq 0x350(%rsp), %rcx
addq 0x50(%rcx), %rax
movq %rax, 0x240(%rsp)
movq 0x238(%rsp), %rax
movq %rax, 0x250(%rsp)
movq %rax, 0x258(%rsp)
movq 0x350(%rsp), %rdi
movq 0x270(%rsp), %rax
movq (%rax), %rsi
movl $0x3, %edx
callq 0x21b630
movq %rax, 0x228(%rsp)
movq 0x350(%rsp), %rdi
movq 0x270(%rsp), %rax
movq (%rax), %rsi
movl $0x2, %edx
callq 0x21b630
movl %eax, %ecx
movq 0x258(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x228(%rsp), %rax
movl %eax, %ecx
movq 0x258(%rsp), %rax
movl %ecx, (%rax)
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
jne 0x21824a
movq 0x300(%rsp), %rdi
movq 0x258(%rsp), %rax
movl (%rax), %esi
movq 0x258(%rsp), %rax
movl 0x4(%rax), %edx
movl 0x3d0(%rsp), %ecx
callq 0x4a3360
movq 0x258(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x258(%rsp)
movq 0x270(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x270(%rsp)
movq 0x270(%rsp), %rcx
xorl %eax, %eax
cmpq 0x280(%rsp), %rcx
movb %al, 0x11f(%rsp)
jae 0x2182d5
movq 0x230(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x350(%rsp), %rdi
movq 0x270(%rsp), %rax
movq (%rax), %rsi
callq 0x21cbb0
movq %rax, %rcx
movq 0x110(%rsp), %rax
movq %rcx, 0x268(%rsp)
cmpq %rcx, %rax
sete %al
movb %al, 0x11f(%rsp)
movb 0x11f(%rsp), %al
testb $0x1, %al
jne 0x2181ad
cmpq $0x0, 0x2f8(%rsp)
je 0x218320
movq 0x2f8(%rsp), %rdi
addq $0x30, %rdi
movq 0x328(%rsp), %rsi
movq 0x248(%rsp), %rdx
movq 0x3a0(%rsp), %rcx
movq 0x240(%rsp), %r8
callq 0x21c100
movq 0x270(%rsp), %rax
movq 0x238(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x260(%rsp)
cmpq $0x0, 0x400(%rsp)
je 0x21836c
movq 0x400(%rsp), %rax
movq 0x408(%rsp), %rdi
movq 0x240(%rsp), %rsi
callq *%rax
testb $0x1, %al
jne 0x218691
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
je 0x218518
movb 0x326(%rsp), %dil
movq 0x3b8(%rsp), %rsi
movq 0x248(%rsp), %rdx
movq 0x240(%rsp), %rcx
movl 0x3d0(%rsp), %r8d
movq 0x348(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x350(%rsp), %rax
movq 0xb8(%rax), %r13
movq 0x250(%rsp), %r12
movq 0x260(%rsp), %r15
movq 0x3f8(%rsp), %r14
movq 0x400(%rsp), %rbx
movq 0x408(%rsp), %r11
movq 0x3c0(%rsp), %r10
movq 0x3e8(%rsp), %rax
andb $0x1, %dil
movzbl %dil, %edi
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x21c3e0
cmpq $0x0, 0x3b8(%rsp)
je 0x2184cd
jmp 0x218441
cmpq $0x0, 0x300(%rsp)
je 0x21845d
movq 0x300(%rsp), %rdi
callq 0x4a3110
testb $0x1, %al
jne 0x218495
movq 0x423b3c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fdba5(%rip), %rsi    # 0x516013
leaq 0x35b148(%rip), %rdx    # 0x5735bd
leaq 0x35b0aa(%rip), %rcx    # 0x573526
leaq 0x359b11(%rip), %r8     # 0x571f94
movl $0xef9, %r9d            # imm = 0xEF9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x218497
movq 0x3b8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x260(%rsp)
movq 0x300(%rsp), %rdi
movq 0x3b8(%rsp), %rax
movq (%rax), %rsi
movq 0x260(%rsp), %rdx
callq 0x4a36a0
jmp 0x218516
jmp 0x2184cf
cmpq $0x0, 0x300(%rsp)
je 0x218512
movq 0x423abf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fdb28(%rip), %rsi    # 0x516013
leaq 0x35b110(%rip), %rdx    # 0x573602
leaq 0x35b02d(%rip), %rcx    # 0x573526
leaq 0x359a94(%rip), %r8     # 0x571f94
movl $0xef9, %r9d            # imm = 0xEF9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x218514
jmp 0x218516
jmp 0x218518
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
je 0x218538
cmpq $0x0, 0x3b8(%rsp)
je 0x21868f
jmp 0x21853a
cmpq $0x0, 0x2e8(%rsp)
je 0x218550
cmpq $0x0, 0x2e0(%rsp)
jne 0x218588
movq 0x423a49(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fdab2(%rip), %rsi    # 0x516013
leaq 0x35b0b2(%rip), %rdx    # 0x57361a
leaq 0x35afb7(%rip), %rcx    # 0x573526
leaq 0x359a1e(%rip), %r8     # 0x571f94
movl $0xef9, %r9d            # imm = 0xEF9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21858a
movq 0x2e8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x330(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x398(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0x248(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0x240(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x300(%rsp), %rax
movq %rax, 0x108(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x218611
xorl %eax, %eax
movq %rax, 0xd0(%rsp)
jmp 0x218624
movq 0x3b8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq 0x108(%rsp), %r9
movq 0x100(%rsp), %r8
movq 0xf8(%rsp), %rcx
movq 0xf0(%rsp), %rdx
movq 0xe8(%rsp), %rsi
movq 0xe0(%rsp), %rdi
movq 0xd0(%rsp), %r14
movl 0x3d0(%rsp), %ebx
movq 0x250(%rsp), %r11
movq 0x260(%rsp), %r10
movq %r14, (%rsp)
movl %ebx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
callq *%rax
jmp 0x218691
cmpq $0x0, 0x300(%rsp)
je 0x21874d
movq 0x300(%rsp), %rdi
callq 0x4a3110
testb $0x1, %al
jne 0x21874d
movq 0x300(%rsp), %rax
movq %rax, 0xc8(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x2186e2
movq 0x250(%rsp), %rax
movq %rax, 0xc0(%rsp)
jmp 0x2186ee
xorl %eax, %eax
movq %rax, 0xc0(%rsp)
jmp 0x2186ee
movq 0xc0(%rsp), %rax
movq %rax, 0xb8(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x218715
xorl %eax, %eax
movq %rax, 0xb0(%rsp)
jmp 0x218728
movq 0x3b8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rsi
movq 0xc8(%rsp), %rdi
movq 0xb0(%rsp), %rdx
movq 0x260(%rsp), %rcx
callq 0x4a3760
jmp 0x21802a
jmp 0x218eb8
movq 0x310(%rsp), %rax
subq $0x1, %rax
movq 0x350(%rsp), %rcx
imulq 0x90(%rcx), %rax
movq %rax, 0x210(%rsp)
movq 0x318(%rsp), %rax
subq 0x310(%rsp), %rax
movq 0x350(%rsp), %rcx
imulq 0x90(%rcx), %rax
movq %rax, 0x208(%rsp)
movq 0x318(%rsp), %rax
movq 0x350(%rsp), %rcx
imulq 0x90(%rcx), %rax
movq %rax, 0x200(%rsp)
movq $0x0, 0x1f8(%rsp)
movq 0x350(%rsp), %rax
cmpl $0x2, 0x18(%rax)
je 0x218815
movq 0x4237bc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fd825(%rip), %rsi    # 0x516013
leaq 0x35ae5c(%rip), %rdx    # 0x573651
leaq 0x35ad2a(%rip), %rcx    # 0x573526
leaq 0x359791(%rip), %r8     # 0x571f94
movl $0xf05, %r9d            # imm = 0xF05
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x218817
movq 0x350(%rsp), %rsi
leaq 0x218(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x21b4e0
movq 0x1f8(%rsp), %rax
cmpq 0x208(%rsp), %rax
ja 0x218eb6
movl 0x21c(%rsp), %eax
movl %eax, 0x1cc(%rsp)
movl 0x218(%rsp), %eax
movl %eax, 0x1c8(%rsp)
movq 0x350(%rsp), %rsi
movq 0x1f8(%rsp), %rdx
addq 0x210(%rsp), %rdx
leaq 0x1d0(%rsp), %rdi
callq 0x21b4e0
movl 0x1cc(%rsp), %eax
cmpl 0x1d4(%rsp), %eax
jne 0x2188a7
movl 0x1c8(%rsp), %eax
cmpl 0x1d0(%rsp), %eax
je 0x218922
jmp 0x2188a9
movq 0x350(%rsp), %rax
movq 0x90(%rax), %rax
addq 0x1f8(%rsp), %rax
movq %rax, 0x1f8(%rsp)
movq 0x1f8(%rsp), %rax
cmpq 0x200(%rsp), %rax
jb 0x2188dc
jmp 0x21891d
movq 0x350(%rsp), %rsi
movq 0x1f8(%rsp), %rdx
leaq 0x218(%rsp), %rdi
callq 0x21b4e0
movl 0x1cc(%rsp), %eax
cmpl 0x21c(%rsp), %eax
jne 0x218919
movl 0x1c8(%rsp), %eax
cmpl 0x218(%rsp), %eax
je 0x21891b
jmp 0x21891d
jmp 0x2188a9
jmp 0x218830
movq 0x350(%rsp), %rdi
callq 0x20ca60
addq 0x1f8(%rsp), %rax
movq %rax, 0x1e0(%rsp)
movq %rax, 0x1e8(%rsp)
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
jne 0x21897a
movq 0x300(%rsp), %rdi
movl 0x220(%rsp), %esi
movl 0x224(%rsp), %edx
movl 0x3d0(%rsp), %ecx
callq 0x4a3360
movl 0x220(%rsp), %ecx
movq 0x1e8(%rsp), %rax
movl %ecx, (%rax)
movl 0x224(%rsp), %ecx
movq 0x1e8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x1e8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x1e8(%rsp)
movq 0x350(%rsp), %rax
movq 0x90(%rax), %rax
addq 0x1f8(%rsp), %rax
movq %rax, 0x1f8(%rsp)
movq 0x1f8(%rsp), %rax
cmpq 0x200(%rsp), %rax
jb 0x2189e4
jmp 0x218a41
movq 0x350(%rsp), %rsi
movq 0x1f8(%rsp), %rdx
leaq 0x218(%rsp), %rdi
callq 0x21b4e0
movl 0x1cc(%rsp), %ecx
xorl %eax, %eax
cmpl 0x21c(%rsp), %ecx
movb %al, 0xaf(%rsp)
jne 0x218a32
movl 0x1c8(%rsp), %eax
cmpl 0x218(%rsp), %eax
sete %al
movb %al, 0xaf(%rsp)
movb 0xaf(%rsp), %al
testb $0x1, %al
jne 0x218947
movq 0x350(%rsp), %rax
movq 0x48(%rax), %rcx
movl 0x1cc(%rsp), %eax
addq %rcx, %rax
movl %eax, 0x1cc(%rsp)
movq 0x350(%rsp), %rax
movq 0x50(%rax), %rcx
movl 0x1c8(%rsp), %eax
addq %rcx, %rax
movl %eax, 0x1c8(%rsp)
cmpq $0x0, 0x2f8(%rsp)
je 0x218aba
movq 0x2f8(%rsp), %rdi
addq $0x30, %rdi
movq 0x328(%rsp), %rsi
movl 0x1cc(%rsp), %eax
movl %eax, %edx
movq 0x3a0(%rsp), %rcx
movl 0x1c8(%rsp), %eax
movl %eax, %r8d
callq 0x21c100
movq 0x1e8(%rsp), %rax
movq 0x1e0(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x1f0(%rsp)
cmpq $0x0, 0x400(%rsp)
je 0x218b07
movq 0x400(%rsp), %rax
movq 0x408(%rsp), %rdi
movl 0x1c8(%rsp), %ecx
movl %ecx, %esi
callq *%rax
testb $0x1, %al
jne 0x218e17
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
je 0x218cb5
movb 0x326(%rsp), %dil
movq 0x3b8(%rsp), %rsi
movl 0x1cc(%rsp), %eax
movl %eax, %edx
movl 0x1c8(%rsp), %eax
movl %eax, %ecx
movl 0x3d0(%rsp), %r8d
movq 0x348(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x350(%rsp), %rax
movq 0xb8(%rax), %r13
movq 0x1e0(%rsp), %r12
movq 0x1f0(%rsp), %r15
movq 0x3f8(%rsp), %r14
movq 0x400(%rsp), %rbx
movq 0x408(%rsp), %r11
movq 0x3c0(%rsp), %r10
movq 0x3e8(%rsp), %rax
andb $0x1, %dil
movzbl %dil, %edi
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x21c3e0
cmpq $0x0, 0x3b8(%rsp)
je 0x218c6a
jmp 0x218bde
cmpq $0x0, 0x300(%rsp)
je 0x218bfa
movq 0x300(%rsp), %rdi
callq 0x4a3110
testb $0x1, %al
jne 0x218c32
movq 0x42339f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fd408(%rip), %rsi    # 0x516013
leaq 0x35a9ab(%rip), %rdx    # 0x5735bd
leaq 0x35a90d(%rip), %rcx    # 0x573526
leaq 0x359374(%rip), %r8     # 0x571f94
movl $0xf52, %r9d            # imm = 0xF52
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x218c34
movq 0x3b8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1f0(%rsp)
movq 0x300(%rsp), %rdi
movq 0x3b8(%rsp), %rax
movq (%rax), %rsi
movq 0x1f0(%rsp), %rdx
callq 0x4a36a0
jmp 0x218cb3
jmp 0x218c6c
cmpq $0x0, 0x300(%rsp)
je 0x218caf
movq 0x423322(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fd38b(%rip), %rsi    # 0x516013
leaq 0x35a973(%rip), %rdx    # 0x573602
leaq 0x35a890(%rip), %rcx    # 0x573526
leaq 0x3592f7(%rip), %r8     # 0x571f94
movl $0xf52, %r9d            # imm = 0xF52
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x218cb1
jmp 0x218cb3
jmp 0x218cb5
movq 0x350(%rsp), %rax
testb $0x1, 0xb0(%rax)
je 0x218cd5
cmpq $0x0, 0x3b8(%rsp)
je 0x218e15
jmp 0x218cd7
cmpq $0x0, 0x2e8(%rsp)
je 0x218ced
cmpq $0x0, 0x2e0(%rsp)
jne 0x218d25
movq 0x4232ac(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2fd315(%rip), %rsi    # 0x516013
leaq 0x35a915(%rip), %rdx    # 0x57361a
leaq 0x35a81a(%rip), %rcx    # 0x573526
leaq 0x359281(%rip), %r8     # 0x571f94
movl $0xf52, %r9d            # imm = 0xF52
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x218d27
movq 0x2e8(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x330(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x398(%rsp), %rax
movq %rax, 0x88(%rsp)
movl 0x1cc(%rsp), %eax
movq %rax, 0x90(%rsp)
movl 0x1c8(%rsp), %eax
movq %rax, 0x98(%rsp)
movq 0x300(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x218da3
xorl %eax, %eax
movq %rax, 0x68(%rsp)
jmp 0x218db3
movq 0x3b8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq 0xa0(%rsp), %r9
movq 0x98(%rsp), %r8
movq 0x90(%rsp), %rcx
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdi
movq 0x68(%rsp), %r14
movl 0x3d0(%rsp), %ebx
movq 0x1e0(%rsp), %r11
movq 0x1f0(%rsp), %r10
movq %r14, (%rsp)
movl %ebx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
callq *%rax
jmp 0x218e17
cmpq $0x0, 0x300(%rsp)
je 0x218eb1
movq 0x300(%rsp), %rdi
callq 0x4a3110
testb $0x1, %al
jne 0x218eb1
movq 0x300(%rsp), %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x218e5e
movq 0x1e0(%rsp), %rax
movq %rax, 0x58(%rsp)
jmp 0x218e67
xorl %eax, %eax
movq %rax, 0x58(%rsp)
jmp 0x218e67
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x3b8(%rsp)
jne 0x218e85
xorl %eax, %eax
movq %rax, 0x48(%rsp)
jmp 0x218e95
movq 0x3b8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rdx
movq 0x1f0(%rsp), %rcx
callq 0x4a3760
jmp 0x218830
jmp 0x218eb8
jmp 0x218eba
cmpq $0x0, 0x300(%rsp)
je 0x218ef1
testb $0x1, 0x327(%rsp)
je 0x218ee4
movq 0x300(%rsp), %rdi
movq 0x3e8(%rsp), %rsi
callq 0x4a3250
movq 0x300(%rsp), %rdi
callq 0x4a32f0
testb $0x1, 0x327(%rsp)
je 0x218f9c
cmpq $0x0, 0x3f8(%rsp)
je 0x218f8f
movq 0x350(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x350(%rsp), %rcx
subq 0x48(%rcx), %rax
addq $0x1, %rax
movq 0x350(%rsp), %rcx
movq 0x60(%rcx), %rcx
movq 0x350(%rsp), %rdx
subq 0x50(%rdx), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
movq %rax, 0x1c0(%rsp)
movq 0x3f8(%rsp), %rdi
movq 0x318(%rsp), %rsi
movq 0x1c0(%rsp), %rdx
callq 0x21cbd0
movq 0x308(%rsp), %rdi
callq 0x121730
movq %rax, %rcx
movq 0x3f8(%rsp), %rax
addq 0x48(%rax), %rcx
movq %rcx, 0x48(%rax)
movq 0x308(%rsp), %rdi
callq 0x121f00
movq 0x2f8(%rsp), %rdi
callq 0x21cc10
cmpq $0x0, 0x2f0(%rsp)
je 0x218fce
movq 0x2f0(%rsp), %rdi
callq 0x4a3ae0
movq 0x2f0(%rsp), %rdi
callq 0x4a3aa0
addq $0x358, %rsp            # imm = 0x358
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq