// File: /workspace/github_c_makefile_star2_O2/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 $0x108, %rsp            # imm = 0x108
movq %r9, 0xe0(%rsp)
movq %r8, 0x50(%rsp)
movq %rcx, 0x90(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %rbp
movl 0x180(%rsp), %r15d
movq 0x1b8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x1b0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x1a8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x1a0(%rsp), %r14
movq 0x198(%rsp), %rax
movq %rax, 0x70(%rsp)
movb 0x190(%rsp), %bl
movl 0x188(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x178(%rsp), %r13d
movq 0x170(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
callq 0x13f027
movq %rax, %rsi
movq 0x8(%rbp), %rcx
leaq -0x1(%rcx), %rax
xorl %edx, %edx
divq %r15
movq %r15, 0x58(%rsp)
cmpq %r15, %rcx
jb 0x1409e6
movq %rax, %r15
movq %rax, %r12
incq %r12
je 0x1409e6
movq %rsi, %rax
subq %r12, %rax
movq %rax, 0x68(%rsp)
jb 0x14099a
cmpb $0x0, 0x78(%rbp)
jne 0x13f725
cmpb $0x1, 0x79(%rbp)
jne 0x14099a
testb %bl, %bl
movb %bl, 0x17(%rsp)
movq %rsi, 0xc8(%rsp)
je 0x13f747
callq 0xaf478
movq %rax, %rbx
movq %rax, %rdi
callq 0xaf4d6
jmp 0x13f749
xorl %ebx, %ebx
movq 0x8(%rsp), %rax
movq %rbx, 0xf0(%rsp)
movb 0xb1(%rax), %al
movb %al, 0x7(%rsp)
cmpb $0x1, %al
movq %rbp, 0x78(%rsp)
movq %r15, 0x48(%rsp)
jne 0x13f7b0
leaq 0x201b07(%rip), %rdi    # 0x34127c
pushq $0x3e
popq %rsi
pushq $0x1
popq %rdx
movq 0x70(%rsp), %rcx
callq 0x17f00
movq $0x0, 0x30(%rsp)
movq $0x0, 0x80(%rsp)
movq $0x0, 0xa8(%rsp)
xorl %ebx, %ebx
xorl %r13d, %r13d
jmp 0x13fddf
movq 0x60(%rsp), %rdi
callq 0x755c5
movq %rax, %r15
cmpb $0x0, 0x17(%rsp)
je 0x13f8cf
movq 0x8(%rsp), %rax
movq 0xb8(%rax), %rdi
movq (%rbp), %rdx
movq %r15, %rsi
callq 0x2a6718
movq %rax, 0x30(%rsp)
leaq 0x201bd8(%rip), %rdi    # 0x3413c4
pushq $0x20
popq %rsi
pushq $0x1
popq %rbp
movq %rbp, %rdx
movq 0x70(%rsp), %rbx
movq %rbx, %rcx
callq 0x17f00
leaq 0x201bdc(%rip), %rdi    # 0x3413e5
pushq $0x22
popq %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x17f00
movq 0x58(%rsp), %rcx
cmpl %ecx, %r13d
jae 0x13f837
leaq 0x201be0(%rip), %rsi    # 0x341408
movq %rbx, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0x17a50
jmp 0x13f84a
leaq 0x201bef(%rip), %rsi    # 0x34142d
movq %rbx, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x17a50
movq 0x78(%rsp), %rbp
movq 0x8(%rbp), %r8
leaq 0x201be2(%rip), %rsi    # 0x34143c
movq %rbx, %rdi
movq 0x30(%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x17a50
cmpb $0x1, 0x78(%rbp)
jne 0x13f8b1
movq 0x18(%rbp), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x190408
movq %rax, %r13
movq %r12, %rdi
callq 0x1903c5
leaq 0x201be6(%rip), %rsi    # 0x341480
movq %rbx, %rdi
movq 0x30(%rsp), %rdx
movq %r13, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x17a50
jmp 0x13f8cf
movq 0x20(%rsp), %rdi
callq 0x18edb6
leaq 0x201c35(%rip), %rsi    # 0x3414f7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17a50
movq 0x8(%rsp), %rax
movq 0xb8(%rax), %rdi
movq (%rbp), %rdx
movq %r15, %rsi
callq 0x2a672f
movq %rax, %r13
movq %r14, %rdi
callq 0xad289
testq %rax, %rax
je 0x13f92d
xorl %esi, %esi
cmpl $0x3, 0x3c(%rsp)
setne %sil
movq %r14, %rdi
callq 0x2a6b5e
leaq 0x1673ac(%rip), %rcx    # 0x2a6cbd
movq %rcx, 0x80(%rsp)
xorl %ebx, %ebx
movq %rax, 0x30(%rsp)
movq %rax, 0xa8(%rsp)
jmp 0x13fdda
leaq 0x200588(%rip), %rsi    # 0x33febc
movl $0x198, %edi            # imm = 0x198
movl $0xda4, %edx            # imm = 0xDA4
callq 0x93160
movq %rax, %rbx
cmpb $0x0, 0x78(%rbp)
je 0x13f955
leaq 0x505b3(%rip), %rax     # 0x18ff06
jmp 0x13f95c
leaq 0x504c0(%rip), %rax     # 0x18fe1c
movq %rax, 0x158(%rbx)
movq 0x58(%rbp), %rdi
callq 0x1690fa
movl %eax, %r15d
movq 0x58(%rbp), %rdi
callq 0x169118
movl %eax, %r14d
movq %rbp, %rax
movl 0x50(%rbp), %ebp
movl 0x54(%rax), %r12d
movq %rbx, 0x30(%rsp)
orq $-0x1, 0xc8(%rbx)
cmpq $0x0, 0x50(%rsp)
je 0x13f9b0
testb %r15b, %r15b
je 0x13f9b0
movq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x7609a
testb %al, %al
jne 0x13f9b2
xorl %ebx, %ebx
movq 0x30(%rsp), %r15
movq %rbx, 0xf0(%r15)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
sete %al
xorb $0x1, %r14b
orb %al, %r14b
jne 0x13f9e0
callq 0x7609a
movq 0x60(%rsp), %rcx
testb %al, %al
jne 0x13f9e2
xorl %ecx, %ecx
movq %rcx, 0xf8(%r15)
cmpl $0x2, %ebp
movb 0x17(%rsp), %r14b
jne 0x13fa7c
movq 0xe0(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, 0x80(%rsp)
movl %r12d, %ebp
movl %r14d, %r12d
movq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x19128d
movq %rax, 0xd0(%r15)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x190d60
movq %rax, 0xd8(%r15)
movq %r13, %r15
movq 0x50(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r14d
movl %ebp, %r12d
movl 0x80(%rsp), %ebp
callq 0x1915f3
movq 0x30(%rsp), %rcx
movq %rax, 0xb8(%rcx)
movq %r13, %rdi
movq %r15, %r13
movq 0x30(%rsp), %r15
callq 0x7628b
testq %rax, %rax
setne %al
jmp 0x13faaf
andq $0x0, 0xb8(%r15)
movq 0x50(%rsp), %rax
movq %rax, 0x50(%r15)
andq $0x0, 0x48(%r15)
andq $0x0, 0x58(%r15)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x60(%r15)
andq $0x0, 0x70(%r15)
movw $0x100, 0x78(%r15)      # imm = 0x100
movb $0x1, %al
movb %al, 0x31(%r15)
cmpl $0x2, %r12d
jne 0x13fb2b
cmpl $0x2, %ebp
setne %bl
movq 0xd8(%rsp), %r12
movq %r12, %rdi
movq 0x98(%rsp), %rbp
movq %rbp, %rsi
callq 0x19128d
movq %rax, 0xe0(%r15)
movq %r12, %rdi
movq %rax, %rsi
callq 0x190d60
movq %rax, 0xe8(%r15)
movq 0x50(%rsp), %rax
movq 0x60(%rsp), %rdi
xorq %rdi, %rax
movq 0x18(%rsp), %rcx
xorq %rbp, %rcx
orq %rax, %rcx
setne %al
orb %bl, %al
jne 0x13fb7f
movb $0x0, 0x30(%r15)
movq 0xb8(%r15), %rax
movq %rax, 0xc0(%r15)
movb 0x31(%r15), %al
jmp 0x13fba7
andq $0x0, 0xc0(%r15)
andq $0x0, 0x80(%r15)
andq $0x0, 0x90(%r15)
andq $0x0, 0xa8(%r15)
movq 0x60(%rsp), %rax
movq %rax, 0x88(%r15)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x98(%r15)
movw $0x100, 0xb0(%r15)      # imm = 0x100
movb $0x1, 0x32(%r15)
cmpl $0x2, %ebp
movq 0x78(%rsp), %r12
je 0x13fbb0
jmp 0x13fbd5
movb $0x1, 0x30(%r15)
movq %rdi, %rbx
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1915f3
movq %rax, 0xc0(%r15)
movq %rbx, %rdi
callq 0x7628b
testq %rax, %rax
setne %al
movq 0x78(%rsp), %r12
movb %al, 0x32(%r15)
movq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x754e5
movq %rax, 0x38(%r15)
movq %rbx, %rdi
callq 0x754dd
movq %rax, %rdi
callq 0x56d5a
movb %al, 0x40(%r15)
movq 0x20(%rsp), %rax
movq %rax, 0x108(%r15)
cmpq $0x0, 0x70(%r12)
je 0x13fbf7
andq $0x0, 0x110(%r15)
movl 0x3c(%rsp), %ebp
jmp 0x13fc4f
callq 0x169e40
movq %rax, %rdi
movq %rax, 0x110(%r15)
cmpb $0x1, 0x7d(%r12)
jne 0x13fc1a
callq 0x16a0ab
movq 0x110(%r15), %rdi
movq 0x90(%rsp), %rsi
testq %rsi, %rsi
je 0x13fc33
callq 0x169fbc
movq 0x110(%r15), %rdi
movl 0x3c(%rsp), %ebp
movl %ebp, %esi
callq 0x16a0a4
movq 0x110(%r15), %rdi
movq 0x70(%rsp), %rsi
callq 0x16a018
movq 0x28(%rsp), %rbx
movq %rbx, 0x118(%r15)
movq 0x58(%r12), %rax
movq %rax, 0x120(%r15)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x128(%r15)
movdqu %xmm0, 0x138(%r15)
movdqu %xmm0, 0x148(%r15)
movq 0xb0(%rsp), %rax
movq %rax, 0x190(%r15)
movups 0x30(%r12), %xmm0
movups %xmm0, (%r15)
movq 0x68(%r12), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r12), %rax
movq %rax, 0x18(%r15)
movb 0x7e(%r12), %al
movb %al, 0x20(%r15)
movsd 0x40(%r12), %xmm0
movsd %xmm0, 0x28(%r15)
movl %ebp, 0x100(%r15)
movq 0x60(%rsp), %rax
cmpq %rax, 0x50(%rsp)
sete 0x104(%r15)
callq 0x92a76
movb %al, 0x105(%r15)
movq 0xa0(%rsp), %rax
movq %rax, 0x160(%r15)
movq 0x88(%rsp), %rax
movq %rax, 0x168(%r15)
movq %rbx, 0x170(%r15)
movq 0x58(%r12), %rax
movq %rax, 0x178(%r15)
movb 0x7b(%r12), %al
movb %al, 0x180(%r15)
movq 0x70(%r12), %rax
andl $-0x3, %ebp
xorl %edx, %edx
cmpl $0x1, %ebp
sete %dl
shll $0x4, %edx
addq %rax, %rdx
testq %rax, %rax
cmoveq %rax, %rdx
movq %rdx, 0x188(%r15)
leaq 0x1d02(%rip), %rax      # 0x141a56
movq %rax, 0x80(%rsp)
testb %r14b, %r14b
je 0x13fdcb
cmpq $0x0, 0xb8(%r15)
movq 0x70(%rsp), %rbx
movq %r15, %r12
movq 0x48(%rsp), %r15
jne 0x13fd83
cmpq $0x0, 0xc0(%r12)
je 0x13fdba
leaq 0x201531(%rip), %rdi    # 0x3412bb
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x17f00
leaq 0x200b73(%rip), %rsi    # 0x340912
movq 0xf0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xaf5b6
movq %r14, %rdi
callq 0xaf4d6
movq $0x0, 0xa8(%rsp)
movq %r12, %rbx
jmp 0x13fddf
movq $0x0, 0xa8(%rsp)
movq %r15, %rbx
movq 0x48(%rsp), %r15
movq %r13, 0x20(%rsp)
movq 0x8(%rsp), %r10
movl 0x18(%r10), %eax
movq %r15, %rcx
notq %rcx
cmpl $0x1, %eax
movq %rbx, 0x98(%rsp)
je 0x140127
testl %eax, %eax
jne 0x14049a
movq (%r10), %rax
testq %rax, %rax
je 0x140aea
movq (%rax), %r15
movq 0xc8(%rsp), %rdx
shlq $0x4, %rdx
addq %r15, %rdx
shlq $0x4, %rcx
addq %rdx, %rcx
movq %rcx, 0x28(%rsp)
cmpq %rcx, %r15
ja 0x140b7d
leaq 0x30(%rbx), %rax
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x30(%rsp)
sete %al
orb %al, 0x7(%rsp)
shlq $0x4, 0x48(%rsp)
movq %rdx, 0x18(%rsp)
cmpq 0x28(%rsp), %r15
ja 0x140875
movq %r15, %rbp
movl (%r15), %r14d
movl 0x4(%r15), %r13d
movq 0x48(%rsp), %rax
cmpl 0x4(%r15,%rax), %r13d
jne 0x13ff63
addq %rbp, %rax
cmpl (%rax), %r14d
jne 0x13ff63
pushq $0x10
popq %rax
pushq $0xa
popq %rbx
movq %rax, %r12
cmpb $0x0, 0xb0(%r10)
jne 0x13fec5
movl -0xc(%rbp,%rbx,2), %esi
movl -0x8(%rbp,%rbx,2), %edx
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rcx
callq 0x2a687b
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %r10
movq -0xc(%rbp,%rbx,2), %rax
movq %rax, -0xa(%rbp,%rbx)
leaq (%r12,%rbp), %r15
cmpq %rdx, %r15
jae 0x13fef2
cmpl (%rbp,%rbx,2), %r13d
jne 0x13fef2
leaq 0x8(%rbx), %rcx
leaq 0x10(%r12), %rax
cmpl -0x4(%rbp,%rbx,2), %r14d
movq %rcx, %rbx
je 0x13fe97
cmpq $0x0, 0x98(%rsp)
je 0x13ff22
movq 0x68(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq %r13, %rdx
movq 0xd8(%rsp), %rcx
movq %r14, %r8
callq 0x142190
movq 0x8(%rsp), %r10
sarq $0x4, %r12
movq 0xa0(%rsp), %rax
testq %rax, %rax
movq 0x58(%rsp), %r11
je 0x13ff8f
movq 0x88(%rsp), %rdi
movq %r14, %rsi
movq %r11, %rbx
callq *%rax
movq %rbx, %r11
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %r10
testb %al, %al
je 0x13ff8f
movq 0x20(%rsp), %rbx
jmp 0x1400c8
addq $0x10, %rbp
cmpq %rdx, %rbp
jae 0x13ff87
cmpl 0x4(%rbp), %r13d
jne 0x13ff87
movq %rbp, %r15
leaq 0x10(%rbp), %rax
cmpl (%rbp), %r14d
movq %rax, %rbp
je 0x13ff67
jmp 0x13fe60
movq %rbp, %r15
jmp 0x13fe60
cmpb $0x1, 0xb0(%r10)
jne 0x140071
xorl %edi, %edi
cmpl $0x3, 0x3c(%rsp)
setne %dil
movq 0x78(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x40(%rsp), %rbx
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movl %r11d, %r8d
pushq 0x70(%rsp)
pushq 0xf0(%rsp)
pushq 0x98(%rsp)
pushq 0xb8(%rsp)
pushq 0xd0(%rsp)
pushq %r12
pushq %rbp
pushq 0xb8(%r10)
callq 0x142358
addq $0x40, %rsp
testq %rbx, %rbx
je 0x140040
movq 0x20(%rsp), %rbx
testq %rbx, %rbx
je 0x140a6b
movq %rbx, %rdi
callq 0x2a6726
testb %al, %al
je 0x140a6b
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x2a69c0
cmpb $0x0, 0x7(%rsp)
movq 0x58(%rsp), %r11
je 0x140084
jmp 0x140a4e
cmpq $0x0, 0x20(%rsp)
jne 0x140bd9
cmpq $0x0, 0x40(%rsp)
movq 0x8(%rsp), %r10
movq 0x18(%rsp), %rdx
movq 0x58(%rsp), %r11
jne 0x140071
testb $0x1, 0xb0(%r10)
jne 0x13fe60
cmpb $0x0, 0x7(%rsp)
jne 0x140a4e
cmpq $0x0, 0x40(%rsp)
je 0x14008e
movq 0x40(%rsp), %rax
movq (%rax), %rax
jmp 0x140090
xorl %eax, %eax
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq %r13, %rcx
movq %r14, %r8
movq 0x20(%rsp), %rbx
movq %rbx, %r9
pushq %r12
pushq %rbp
pushq %r11
pushq %rax
callq *0xa0(%rsp)
addq $0x20, %rsp
movq 0x8(%rsp), %r10
movq 0x18(%rsp), %rdx
testq %rbx, %rbx
je 0x13fe60
movq 0x20(%rsp), %rdi
callq 0x2a6726
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %r10
testb %al, %al
jne 0x13fe60
movl $0x0, %edx
movq 0x40(%rsp), %rax
testq %rax, %rax
movl $0x0, %ecx
cmovneq %rcx, %rbp
je 0x140108
movq (%rax), %rdx
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rcx
callq 0x2a6a34
movq 0x8(%rsp), %r10
movq 0x18(%rsp), %rdx
jmp 0x13fe60
movq 0x8(%r10), %rax
testq %rax, %rax
je 0x140b1b
movq (%rax), %r13
movq 0xc8(%rsp), %rax
leaq (,%rax,8), %rdi
addq %r13, %rdi
leaq (%rdi,%rcx,8), %rax
movq %rax, 0x90(%rsp)
cmpq %rax, %r13
ja 0x140bab
movq (%r13), %r12
movb 0x9c(%r10), %cl
shrq %cl, %r12
leaq 0x30(%rbx), %rax
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0x30(%rsp)
sete %al
orb %al, 0x7(%rsp)
movq 0x58(%rsp), %rbx
movq %rdi, 0x18(%rsp)
cmpq 0x90(%rsp), %r13
ja 0x140875
movq %r13, %rbp
movq %r12, %r15
movq 0x48(%rsp), %rax
movq (%r13,%rax,8), %rdx
movl 0x9c(%r10), %eax
movl %eax, %ecx
shrq %cl, %rdx
cmpq %rdx, %r12
jne 0x14026c
movq (%rbp), %rdx
movb 0x98(%r10), %cl
movq %rdx, %rsi
shrq %cl, %rsi
andq 0x20(%r10), %rsi
movq %rdx, %r8
movl %eax, %ecx
shrq %cl, %r8
addq 0x48(%r10), %rsi
movq %rsi, 0x68(%rsp)
andq 0x28(%r10), %r8
addq 0x50(%r10), %r8
movq %r8, 0x28(%rsp)
pushq $0x8
popq %rax
movq %rax, %r14
movb 0xa0(%r10), %al
movb 0xa4(%r10), %cl
movq %rdx, %rsi
shrq %cl, %rsi
movl %eax, %ecx
shrq %cl, %rdx
andl 0x38(%r10), %esi
andl 0x30(%r10), %edx
movl %edx, -0x4(%rbp,%r14)
movl %esi, -0x8(%rbp,%r14)
cmpb $0x0, 0xb0(%r10)
jne 0x140247
movq 0x20(%rsp), %rdi
movl %ebx, %ecx
callq 0x2a687b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %r10
leaq (%r14,%rbp), %r13
cmpq %rdi, %r13
jae 0x140293
movq (%r13), %rdx
movb 0x9c(%r10), %cl
movq %rdx, %r12
shrq %cl, %r12
leaq 0x8(%r14), %rax
cmpq %r12, %r15
je 0x1401f9
jmp 0x140296
addq $0x8, %rbp
cmpq %rdi, %rbp
jae 0x1403b0
movq (%rbp), %r12
movl %eax, %ecx
shrq %cl, %r12
movq %rbp, %r13
addq $0x8, %rbp
cmpq %r12, %r15
je 0x140270
jmp 0x140190
movq %r15, %r12
cmpq $0x0, 0x98(%rsp)
je 0x1402cd
movq 0xd0(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0xd8(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x142190
movq 0x8(%rsp), %r10
sarq $0x3, %r14
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0x140300
movq 0x88(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq *%rax
movq 0x8(%rsp), %r10
testb %al, %al
je 0x140300
movq 0x20(%rsp), %r15
jmp 0x140436
cmpb $0x1, 0xb0(%r10)
jne 0x1403e4
xorl %edi, %edi
cmpl $0x3, 0x3c(%rsp)
setne %dil
movq 0x78(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x40(%rsp), %r15
movq %r15, %rsi
movq 0x68(%rsp), %rdx
movq 0x28(%rsp), %rcx
movl %ebx, %r8d
pushq 0x70(%rsp)
pushq 0xf0(%rsp)
pushq 0x98(%rsp)
pushq 0xb8(%rsp)
pushq 0xd0(%rsp)
pushq %r14
pushq %rbp
pushq 0xb8(%r10)
callq 0x142358
addq $0x40, %rsp
testq %r15, %r15
je 0x1403bb
movq 0x20(%rsp), %rbx
testq %rbx, %rbx
je 0x140a31
movq %rbx, %rdi
callq 0x2a6726
testb %al, %al
je 0x140a31
movq (%r15), %rsi
movq 0x10(%r15), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2a69c0
cmpb $0x0, 0x7(%rsp)
movq 0x58(%rsp), %rbx
je 0x1403f9
jmp 0x1409c9
movq %r15, %r12
movq %rbp, %r13
jmp 0x140190
cmpq $0x0, 0x20(%rsp)
jne 0x140ab9
testq %r15, %r15
movq 0x8(%rsp), %r10
movq 0x18(%rsp), %rdi
jne 0x1403e4
testb $0x1, 0xb0(%r10)
jne 0x140190
cmpb $0x0, 0x7(%rsp)
movq 0x40(%rsp), %r15
jne 0x1409c9
testq %r15, %r15
je 0x1403fe
movq (%r15), %rax
jmp 0x140400
xorl %eax, %eax
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r15
movq %r15, %r9
pushq %r14
pushq %rbp
pushq %rbx
pushq %rax
callq *0xa0(%rsp)
addq $0x20, %rsp
movq 0x8(%rsp), %r10
testq %r15, %r15
movq 0x18(%rsp), %rdi
je 0x140190
movq 0x20(%rsp), %rdi
callq 0x2a6726
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %r10
testb %al, %al
jne 0x140190
movl $0x0, %edx
movq 0x40(%rsp), %rax
testq %rax, %rax
movl $0x0, %ecx
cmovneq %rcx, %rbp
je 0x14047b
movq (%rax), %rdx
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r14, %rcx
callq 0x2a6a34
movq 0x8(%rsp), %r10
movq 0x18(%rsp), %rdi
jmp 0x140190
cmpl $0x2, %eax
jne 0x140b4c
movq 0x90(%r10), %rbp
imulq %rbp, %r15
movq 0x68(%rsp), %rax
imulq %rbp, %rax
movq %rax, 0x68(%rsp)
imulq 0xc8(%rsp), %rbp
leaq 0xb8(%rsp), %rdi
movq %r10, %rsi
xorl %edx, %edx
callq 0x141994
movq 0x8(%rsp), %r10
leaq 0x30(%rbx), %rax
movq %rax, 0x90(%rsp)
cmpq $0x0, 0x30(%rsp)
sete %al
orb %al, 0x7(%rsp)
xorl %r12d, %r12d
movq %r15, 0x48(%rsp)
cmpq 0x68(%rsp), %r12
ja 0x140875
movl 0xb8(%rsp), %r13d
movl 0xbc(%rsp), %ebx
leaq (%r12,%r15), %rdx
leaq 0xf8(%rsp), %rdi
movq %r10, %rsi
callq 0x141994
cmpl 0xfc(%rsp), %ebx
jne 0x140696
cmpl 0xf8(%rsp), %r13d
jne 0x140696
movl %r13d, 0x28(%rsp)
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x138adf
movq %r14, %r10
addq %r12, %rax
movq %rax, 0x18(%rsp)
pushq $0x8
popq %rax
movq %rbp, %r14
movq %rax, %r13
movl 0xc0(%rsp), %r15d
movl 0xc4(%rsp), %ebp
cmpb $0x0, 0xb0(%r10)
jne 0x14059e
movq 0x20(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
movq 0x58(%rsp), %rcx
callq 0x2a687b
movq 0x8(%rsp), %r10
movq 0x18(%rsp), %rax
movl %r15d, -0x8(%rax,%r13)
movl %ebp, -0x4(%rax,%r13)
addq 0x90(%r10), %r12
movq %r14, %rbp
cmpq %r14, %r12
jae 0x1405f2
leaq 0xb8(%rsp), %rdi
movq %r10, %rsi
movq %r12, %rdx
callq 0x141994
movq 0x8(%rsp), %r10
cmpl 0xbc(%rsp), %ebx
jne 0x1405f2
leaq 0x8(%r13), %rax
movl 0x28(%rsp), %ecx
cmpl 0xb8(%rsp), %ecx
je 0x140566
addl 0x48(%r10), %ebx
movl 0x28(%rsp), %eax
addl 0x50(%r10), %eax
movl %eax, %r8d
movl %ebx, %r14d
cmpq $0x0, 0x98(%rsp)
je 0x14063a
movq 0x90(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq %r14, %rdx
movq 0xd8(%rsp), %rcx
movq %r8, %rbx
callq 0x142190
movq %rbx, %r8
movq 0x8(%rsp), %r10
sarq $0x3, %r13
movq %r13, 0x28(%rsp)
movq 0xa0(%rsp), %r15
testq %r15, %r15
movq 0x78(%rsp), %rax
movq 0x20(%rsp), %r13
je 0x1406ec
movq 0x88(%rsp), %rdi
movq %r8, %rsi
movq %r13, %rbx
movq %r14, %r13
movq %r8, %r14
callq *%r15
movq %r14, %r8
movq %r13, %r14
movq %rbx, %r13
movq 0x8(%rsp), %r10
testb %al, %al
movq 0x78(%rsp), %rax
je 0x1406ec
movq 0x40(%rsp), %r15
jmp 0x140823
movq 0x8(%rsp), %r10
movq 0x90(%r10), %r14
addq %r14, %r12
movq %r12, %rax
movq %rax, %r12
cmpq %rbp, %rax
jae 0x1404fd
leaq 0xb8(%rsp), %rdi
movq %r10, %rsi
movq %r12, %rdx
callq 0x141994
cmpl 0xbc(%rsp), %ebx
jne 0x1407a0
leaq (%r12,%r14), %rax
cmpl 0xb8(%rsp), %r13d
movq 0x8(%rsp), %r10
je 0x1406a8
jmp 0x1404fd
cmpb $0x1, 0xb0(%r10)
jne 0x1407d3
xorl %edi, %edi
cmpl $0x3, 0x3c(%rsp)
setne %dil
movq 0x30(%rax), %r9
movq 0x40(%rsp), %rsi
movq %r14, %rdx
movq %r8, 0xd0(%rsp)
movq %r8, %rcx
movq 0x58(%rsp), %rbx
movl %ebx, %r8d
pushq 0x70(%rsp)
pushq 0xf0(%rsp)
pushq 0x98(%rsp)
pushq %r15
movq %rsi, %r15
pushq 0xd0(%rsp)
pushq 0x50(%rsp)
pushq 0x48(%rsp)
pushq 0xb8(%r10)
callq 0x142358
addq $0x40, %rsp
testq %r15, %r15
je 0x1407aa
testq %r13, %r13
je 0x140a17
movq %r13, %rdi
callq 0x2a6726
testb %al, %al
je 0x140a17
movq (%r15), %rsi
movq 0x10(%r15), %rdx
movq %r13, %rdi
movq %rdx, 0x28(%rsp)
callq 0x2a69c0
cmpb $0x0, 0x7(%rsp)
movq 0xd0(%rsp), %r8
je 0x1407ed
jmp 0x1409ac
movq 0x8(%rsp), %r10
jmp 0x1404fd
testq %r13, %r13
jne 0x140a88
testq %r15, %r15
movq 0x8(%rsp), %r10
movq 0xd0(%rsp), %r8
jne 0x1407d3
testb $0x1, 0xb0(%r10)
jne 0x14086b
cmpb $0x0, 0x7(%rsp)
movq 0x58(%rsp), %rbx
movq 0x40(%rsp), %r15
jne 0x1409ac
testq %r15, %r15
je 0x1407f2
movq (%r15), %rax
jmp 0x1407f4
xorl %eax, %eax
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq %r14, %rcx
movq %r13, %r9
pushq 0x28(%rsp)
pushq 0x20(%rsp)
pushq %rbx
pushq %rax
callq *0xa0(%rsp)
addq $0x20, %rsp
movq 0x8(%rsp), %r10
testq %r13, %r13
je 0x14086b
movq %r13, %rdi
callq 0x2a6726
testb %al, %al
jne 0x140866
movl $0x0, %edx
testq %r15, %r15
movl $0x0, %eax
movq 0x18(%rsp), %rcx
cmovneq %rax, %rcx
movq %rcx, 0x18(%rsp)
je 0x140854
movq (%r15), %rdx
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rcx
callq 0x2a6a34
movq 0x8(%rsp), %r10
movq 0x48(%rsp), %r15
jmp 0x1404fd
movq 0x20(%rsp), %r14
testq %r14, %r14
movq 0xb0(%rsp), %rbx
movb 0x17(%rsp), %bpl
movq 0xa8(%rsp), %r15
je 0x1408b3
testb %bpl, %bpl
je 0x1408a6
movq %r14, %rdi
movq 0x70(%rsp), %rsi
callq 0x2a67c3
movq %r14, %rdi
callq 0x2a682c
movq 0x8(%rsp), %r10
testb %bpl, %bpl
movq 0x98(%rsp), %r12
je 0x14090a
testq %rbx, %rbx
movq 0xf0(%rsp), %r14
je 0x140902
movq 0x58(%r10), %rax
subq 0x48(%r10), %rax
movq 0x60(%r10), %rcx
incq %rax
subq 0x50(%r10), %rcx
incq %rcx
movq 0xc8(%rsp), %rdx
addq %rdx, (%rbx)
imulq %rax, %rcx
addq %rcx, 0x8(%rbx)
movq %r14, %rdi
callq 0xaf6ff
addq %rax, 0x48(%rbx)
movq %r14, %rdi
callq 0xafc5b
testq %r12, %r12
je 0x140974
movq 0x110(%r12), %rdi
callq 0x16a2a1
movq 0xc0(%r12), %rdi
testq %rdi, %rdi
je 0x140942
cmpb $0x1, 0x30(%r12)
jne 0x140942
leaq 0x1ff584(%rip), %rsi    # 0x33febc
movl $0xa45, %edx            # imm = 0xA45
callq 0x936f9
movq 0xb8(%r12), %rdi
testq %rdi, %rdi
je 0x140960
leaq 0x1ff566(%rip), %rsi    # 0x33febc
movl $0xa49, %edx            # imm = 0xA49
callq 0x936f9
leaq 0x1ff555(%rip), %rsi    # 0x33febc
movq %r12, %rdi
movl $0xde8, %edx            # imm = 0xDE8
callq 0x936f9
testq %r15, %r15
je 0x14099a
movq %r15, %rdi
callq 0x2a6c23
movq %r15, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a6be7
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2f75b5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a4656(%rip), %rsi    # 0x2e5013
leaq 0x20098e(%rip), %rdx    # 0x341352
jmp 0x140aa0
movq 0x2f7598(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a4639(%rip), %rsi    # 0x2e5013
leaq 0x200971(%rip), %rdx    # 0x341352
jmp 0x140ad1
movq 0x2f757b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a461c(%rip), %rsi    # 0x2e5013
leaq 0x20082a(%rip), %rdx    # 0x341228
leaq 0x200859(%rip), %rcx    # 0x34125e
leaq 0x1ff4b0(%rip), %r8     # 0x33febc
movl $0xe23, %r9d            # imm = 0xE23
jmp 0x140c05
movq 0x2f754a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a45eb(%rip), %rsi    # 0x2e5013
leaq 0x2008c6(%rip), %rdx    # 0x3412f5
jmp 0x140aa0
movq 0x2f7530(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a45d1(%rip), %rsi    # 0x2e5013
leaq 0x2008ac(%rip), %rdx    # 0x3412f5
jmp 0x140ad1
movq 0x2f7513(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a45b4(%rip), %rsi    # 0x2e5013
leaq 0x2008ec(%rip), %rdx    # 0x341352
jmp 0x140bf1
movq 0x2f74f6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a4597(%rip), %rsi    # 0x2e5013
leaq 0x200872(%rip), %rdx    # 0x3412f5
jmp 0x140bf1
movq 0x2f74d9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a457a(%rip), %rsi    # 0x2e5013
leaq 0x20089a(%rip), %rdx    # 0x34133a
leaq 0x2007b7(%rip), %rcx    # 0x34125e
leaq 0x1ff40e(%rip), %r8     # 0x33febc
movl $0xf52, %r9d            # imm = 0xF52
jmp 0x140c05
movq 0x2f74a8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a4549(%rip), %rsi    # 0x2e5013
leaq 0x200869(%rip), %rdx    # 0x34133a
leaq 0x200786(%rip), %rcx    # 0x34125e
leaq 0x1ff3dd(%rip), %r8     # 0x33febc
movl $0xef9, %r9d            # imm = 0xEF9
jmp 0x140c05
movq 0x2f7477(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a4518(%rip), %rsi    # 0x2e5013
leaq 0x200c60(%rip), %rdx    # 0x341762
leaq 0x200cce(%rip), %rcx    # 0x3417d7
leaq 0x1ff3ac(%rip), %r8     # 0x33febc
movl $0x63a, %r9d            # imm = 0x63A
jmp 0x140c05
movq 0x2f7446(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a44e7(%rip), %rsi    # 0x2e5013
leaq 0x2010e8(%rip), %rdx    # 0x341c1b
leaq 0x20111b(%rip), %rcx    # 0x341c55
leaq 0x1ff37b(%rip), %r8     # 0x33febc
movl $0x641, %r9d            # imm = 0x641
jmp 0x140c05
movq 0x2f7415(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a44b6(%rip), %rsi    # 0x2e5013
leaq 0x200825(%rip), %rdx    # 0x341389
leaq 0x2006f3(%rip), %rcx    # 0x34125e
leaq 0x1ff34a(%rip), %r8     # 0x33febc
movl $0xf05, %r9d            # imm = 0xF05
jmp 0x140c05
movq 0x2f73e4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a4485(%rip), %rsi    # 0x2e5013
leaq 0x200741(%rip), %rdx    # 0x3412d6
leaq 0x2006c2(%rip), %rcx    # 0x34125e
leaq 0x1ff319(%rip), %r8     # 0x33febc
movl $0xe6e, %r9d            # imm = 0xE6E
jmp 0x140c05
movq 0x2f73b6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a4457(%rip), %rsi    # 0x2e5013
leaq 0x200713(%rip), %rdx    # 0x3412d6
leaq 0x200694(%rip), %rcx    # 0x34125e
leaq 0x1ff2eb(%rip), %r8     # 0x33febc
movl $0xeb2, %r9d            # imm = 0xEB2
jmp 0x140c05
movq 0x2f7388(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a4429(%rip), %rsi    # 0x2e5013
leaq 0x200749(%rip), %rdx    # 0x34133a
leaq 0x200666(%rip), %rcx    # 0x34125e
leaq 0x1ff2bd(%rip), %r8     # 0x33febc
movl $0xea6, %r9d            # imm = 0xEA6
xorl %eax, %eax
callq 0x17a50
callq 0x17390