// File: /workspace/github_c_makefile_star2_O3/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 $0x118, %rsp            # imm = 0x118
movq %r9, 0xb8(%rsp)
movq %r8, 0x68(%rsp)
movq %rcx, 0x90(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, %r12
movl 0x190(%rsp), %ebp
movq 0x1c8(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x1b8(%rsp), %rbx
movq 0x1b0(%rsp), %r14
movq 0x1a8(%rsp), %rax
movq %rax, 0x80(%rsp)
movb 0x1a0(%rsp), %r15b
movl 0x198(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl 0x188(%rsp), %r13d
movq 0x180(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x170(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x88(%rsp)
movq %rdi, 0x8(%rsp)
callq 0x1952d2
movq %rax, %rsi
movq 0x8(%r12), %rcx
leaq -0x1(%rcx), %rax
xorl %edx, %edx
divq %rbp
cmpq %rbp, %rcx
jb 0x196c4a
movq %r12, %rdi
movq %rax, %r12
incq %r12
je 0x196c4a
movq %rax, 0x48(%rsp)
movq %rsi, %rax
subq %r12, %rax
movq %rax, 0x70(%rsp)
jb 0x196c19
cmpb $0x0, 0x78(%rdi)
jne 0x195926
cmpb $0x1, 0x79(%rdi)
jne 0x196c19
testb %r15b, %r15b
movq %rbx, 0xa0(%rsp)
movb %r15b, 0x1f(%rsp)
movq %rdi, 0x40(%rsp)
movq %rbp, 0x78(%rsp)
movq %rsi, 0xb0(%rsp)
je 0x19596f
callq 0x11c954
movq %rax, %rbp
movq %rax, %rdi
callq 0x11c9e3
movq 0x8(%rsp), %rax
cmpb $0x0, 0xb1(%rax)
je 0x1959c9
movq 0x48(%rsp), %r12
jmp 0x195988
movq 0x8(%rsp), %rax
cmpb $0x0, 0xb1(%rax)
movq 0x48(%rsp), %r12
je 0x195a51
xorl %ebp, %ebp
leaq 0x20b5fe(%rip), %rdi    # 0x3a0f8d
movl $0x3e, %esi
movl $0x1, %edx
movq 0x80(%rsp), %rcx
callq 0x17fa0
xorl %r14d, %r14d
movq $0x0, 0x30(%rsp)
movq $0x0, 0xa8(%rsp)
xorl %ecx, %ecx
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0x19604c
movq 0x60(%rsp), %rdi
movq %rax, %rbx
callq 0xebd5d
movq %rax, %r15
movq 0xb8(%rbx), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rdx
movq %r15, %rsi
callq 0x307e8c
movq %rax, 0x10(%rsp)
leaq 0x20b6d9(%rip), %rdi    # 0x3a10d5
movl $0x20, %esi
movl $0x1, %edx
movq 0x80(%rsp), %rbx
movq %rbx, %rcx
callq 0x17fa0
leaq 0x20b6d9(%rip), %rdi    # 0x3a10f6
movl $0x22, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
movq 0x78(%rsp), %rax
cmpl %eax, %r13d
jae 0x195a65
leaq 0x20b6d9(%rip), %rsi    # 0x3a1119
movq %rbx, %rdi
movl %r13d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x17ab0
jmp 0x195a78
movq 0x60(%rsp), %rdi
callq 0xebd5d
movq %rax, %r15
xorl %ebp, %ebp
jmp 0x195b09
leaq 0x20b6d2(%rip), %rsi    # 0x3a113e
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x17ab0
movq 0x40(%rsp), %r13
movq 0x8(%r13), %r8
leaq 0x20b6c5(%rip), %rsi    # 0x3a114d
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x17ab0
cmpb $0x1, 0x78(%r13)
jne 0x195ae6
movq 0x18(%r13), %rax
movq %rax, 0x10(%rsp)
movq %rbp, %r12
movq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0x1e17d2
movq %rax, %r13
movq %rbp, %rdi
movq %r12, %rbp
callq 0x1e17c2
leaq 0x20b6c2(%rip), %rsi    # 0x3a1191
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x17ab0
jmp 0x195b04
movq 0x28(%rsp), %rdi
callq 0x1e0645
leaq 0x20b711(%rip), %rsi    # 0x3a1208
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17ab0
movq 0x48(%rsp), %r12
movq 0x8(%rsp), %rax
movq 0xb8(%rax), %rdi
movq 0x40(%rsp), %rbx
movq (%rbx), %rdx
movq %r15, %rsi
callq 0x307ea3
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x11b0ca
testq %rax, %rax
je 0x195b6d
xorl %esi, %esi
cmpl $0x3, 0x5c(%rsp)
setne %sil
movq %r14, %rdi
callq 0x3081f7
movq %rax, %r14
leaq 0x172775(%rip), %rax    # 0x3082c9
movq %rax, 0xa8(%rsp)
movb $0x1, %al
movq %rax, 0x30(%rsp)
xorl %ebx, %ebx
movq %r14, %rcx
jmp 0x196047
leaq 0x20a068(%rip), %rsi    # 0x39fbdc
movl $0x198, %edi            # imm = 0x198
movl $0xda4, %edx            # imm = 0xDA4
callq 0x104226
movq %rax, %r14
cmpb $0x0, 0x78(%rbx)
je 0x195b95
leaq 0x4b8a6(%rip), %rax     # 0x1e1439
jmp 0x195b9c
leaq 0x4b7b1(%rip), %rax     # 0x1e134d
movq %rax, 0x158(%r14)
movq 0x58(%rbx), %rdi
callq 0x1b9f17
movq %r14, %r13
movl %eax, %r15d
movq 0x40(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x1b9f79
movq 0x40(%rsp), %rdx
movl %eax, %r14d
movl 0x50(%rdx), %ebx
movl 0x54(%rdx), %r12d
movq %r13, 0x50(%rsp)
movq $-0x1, 0xc8(%r13)
cmpq $0x0, 0x68(%rsp)
je 0x195c05
testb %r15b, %r15b
je 0x195c05
movq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0xec569
movq 0x40(%rsp), %rdx
movq %r15, %rcx
testb %al, %al
jne 0x195c07
xorl %ecx, %ecx
movq 0x50(%rsp), %r15
movq %rcx, 0xf0(%r15)
cmpq $0x0, 0x60(%rsp)
sete %al
xorb $0x1, %r14b
orb %al, %r14b
jne 0x195c3d
movq 0x60(%rsp), %rdi
callq 0xec569
movq 0x40(%rsp), %rdx
movq 0x60(%rsp), %rcx
testb %al, %al
jne 0x195c3f
xorl %ecx, %ecx
movq %rcx, 0xf8(%r15)
cmpl $0x2, %ebx
movq 0x20(%rsp), %r14
jne 0x195cce
movq 0xb8(%rsp), %r13
movq %r13, %rdi
movl %ebx, %r14d
movl %r12d, %ebx
movq 0x88(%rsp), %r12
movq %r12, %rsi
callq 0x1e2426
movq %rax, 0xd0(%r15)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1e1f74
movq %rax, 0xd8(%r15)
movq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebx, %r12d
movl %r14d, %ebx
movq 0x20(%rsp), %r14
callq 0x1e26b4
movq 0x50(%rsp), %rcx
movq %rax, 0xb8(%rcx)
movq %r15, %rdi
movq 0x50(%rsp), %r15
callq 0xec68e
movq 0x40(%rsp), %rdx
testq %rax, %rax
setne %al
jmp 0x195cff
xorl %eax, %eax
movq %rax, 0xb8(%r15)
movq 0x68(%rsp), %rcx
movq %rcx, 0x50(%r15)
movq %rax, 0x48(%r15)
movq %rax, 0x58(%r15)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x60(%r15)
movq %rax, 0x70(%r15)
movw $0x100, 0x78(%r15)      # imm = 0x100
movb $0x1, %al
movb %al, 0x31(%r15)
cmpl $0x2, %r12d
movq 0xc0(%rsp), %rdi
jne 0x195d81
cmpl $0x2, %ebx
setne %bl
movq %r14, %rsi
movq %r15, %r13
movq %rdi, %r15
callq 0x1e2426
movq %rax, 0xe0(%r13)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1e1f74
movq %rax, 0xe8(%r13)
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rcx
xorq %rcx, %rax
movq 0x88(%rsp), %rdx
xorq %r14, %rdx
orq %rax, %rdx
setne %al
orb %bl, %al
movq 0x48(%rsp), %r12
jne 0x195ddb
movb $0x0, 0x30(%r13)
movq 0xb8(%r13), %rax
movq %rax, 0xc0(%r13)
movb 0x31(%r13), %al
jmp 0x195e06
xorl %eax, %eax
movq %rax, 0xc0(%r15)
movq 0x60(%rsp), %rcx
movq %rcx, 0x88(%r15)
movq %rax, 0x80(%r15)
movq %rax, 0x90(%r15)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x98(%r15)
movq %rax, 0xa8(%r15)
movw $0x100, 0xb0(%r15)      # imm = 0x100
movb $0x1, 0x32(%r15)
cmpl $0x2, %ebx
movq 0x80(%rsp), %rbx
movq 0x48(%rsp), %r12
je 0x195e12
jmp 0x195e46
movb $0x1, 0x30(%r13)
movq %rcx, %rbx
movq %rcx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1e26b4
movq %rax, 0xc0(%r13)
movq %rbx, %rdi
callq 0xec68e
testq %rax, %rax
setne %al
movq 0x80(%rsp), %rbx
movb %al, 0x32(%r13)
movq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0xebce1
movq 0x50(%rsp), %rcx
movq %rax, 0x38(%rcx)
movq %r15, %rdi
movq 0x50(%rsp), %r15
callq 0xebcd9
movq %rax, %rdi
callq 0xd11f1
movq 0x40(%rsp), %rdx
movb %al, 0x40(%r15)
movq 0x28(%rsp), %rax
movq %rax, 0x108(%r15)
cmpq $0x0, 0x70(%rdx)
je 0x195e70
movq %r15, %r13
movq %rbp, %r15
movq $0x0, 0x110(%r13)
movl 0x5c(%rsp), %ebp
jmp 0x195edd
callq 0x1baabc
movq %rax, %rdi
movq %rax, 0x110(%r15)
movq 0x40(%rsp), %rax
cmpb $0x1, 0x7d(%rax)
jne 0x195e96
callq 0x1bac70
movq 0x110(%r15), %rdi
movq 0x90(%rsp), %rsi
movq %rbp, %r15
testq %rsi, %rsi
je 0x195eb9
callq 0x1babe3
movq 0x50(%rsp), %r13
movq 0x110(%r13), %rdi
jmp 0x195ebe
movq 0x50(%rsp), %r13
movl 0x5c(%rsp), %ebp
movl %ebp, %esi
callq 0x1bac69
movq 0x110(%r13), %rdi
movq %rbx, %rsi
callq 0x1bac0e
movq 0x40(%rsp), %rdx
movq 0x30(%rsp), %r14
movq %r14, 0x118(%r13)
movq 0x58(%rdx), %rax
movq %rax, 0x120(%r13)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x128(%r13)
movdqu %xmm0, 0x138(%r13)
movdqu %xmm0, 0x148(%r13)
movq 0xa0(%rsp), %rax
movq %rax, 0x190(%r13)
movups 0x30(%rdx), %xmm0
movups %xmm0, (%r13)
movq 0x68(%rdx), %rax
movq %rax, 0x10(%r13)
movq 0x8(%rdx), %rax
movq %rax, 0x18(%r13)
movb 0x7e(%rdx), %al
movb %al, 0x20(%r13)
movsd 0x40(%rdx), %xmm0
movsd %xmm0, 0x28(%r13)
movl %ebp, 0x100(%r13)
movq 0x60(%rsp), %rax
cmpq %rax, 0x68(%rsp)
sete 0x104(%r13)
callq 0x103d66
movq 0x40(%rsp), %rcx
movb %al, 0x105(%r13)
movq 0xc8(%rsp), %rax
movq %rax, 0x160(%r13)
movq 0x98(%rsp), %rax
movq %rax, 0x168(%r13)
movq %r14, 0x170(%r13)
movq 0x58(%rcx), %rax
movq %rax, 0x178(%r13)
movb 0x7b(%rcx), %al
movb %al, 0x180(%r13)
movq 0x70(%rcx), %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(%r13)
leaq 0x1b83(%rip), %rax      # 0x197b5e
movq %rax, 0xa8(%rsp)
movb $0x1, %al
movq %rax, 0x30(%rsp)
cmpb $0x0, 0x1f(%rsp)
je 0x196c2b
cmpq $0x0, 0xb8(%r13)
movq %r15, %rbp
movq %r13, %r14
jne 0x19600f
cmpq $0x0, 0xc0(%r14)
je 0x196042
leaq 0x20afb6(%rip), %rdi    # 0x3a0fcc
movl $0x1a, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
leaq 0x20a603(%rip), %rsi    # 0x3a0632
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x11ca64
movq %rbp, %rdi
callq 0x11c9e3
xorl %ecx, %ecx
movq %r14, %rbx
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %r10
movl 0x18(%r10), %eax
cmpl $0x1, %eax
movq %rbp, 0xf0(%rsp)
movq %r14, 0x50(%rsp)
movq %rcx, 0xf8(%rsp)
movq %rbx, 0x88(%rsp)
je 0x19639b
testl %eax, %eax
jne 0x1966f2
movq (%r10), %rax
testq %rax, %rax
je 0x196c72
movq (%rax), %r15
movq 0xb0(%rsp), %rdx
shlq $0x4, %rdx
addq %r15, %rdx
movq %r12, %rsi
notq %rsi
shlq $0x4, %rsi
addq %rdx, %rsi
cmpq %rsi, %r15
ja 0x196c81
movq 0x88(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x50(%rsp)
setne %al
movq 0x30(%rsp), %rcx
andb %al, %cl
movq %rcx, 0x30(%rsp)
shlq $0x4, %r12
movq %rdx, 0x28(%rsp)
movq %r12, 0x48(%rsp)
movq %rsi, 0x20(%rsp)
movl (%r15), %r14d
movl 0x4(%r15), %r13d
cmpl 0x4(%r15,%r12), %r13d
jne 0x1961db
leaq (%r15,%r12), %rax
cmpl (%rax), %r14d
jne 0x1961db
movl $0xa, %ebx
movl $0x10, %eax
movq %rax, %r12
cmpb $0x0, 0xb0(%r10)
jne 0x19614e
movl -0xc(%r15,%rbx,2), %esi
movl -0x8(%r15,%rbx,2), %edx
movq 0x10(%rsp), %rdi
movq 0x78(%rsp), %rcx
callq 0x308001
movq 0x28(%rsp), %rdx
movq 0x8(%rsp), %r10
movq -0xc(%r15,%rbx,2), %rax
movq %rax, -0xa(%r15,%rbx)
leaq (%r15,%r12), %rbp
cmpq %rdx, %rbp
jae 0x19617a
cmpl (%r15,%rbx,2), %r13d
jne 0x19617a
leaq 0x8(%rbx), %rcx
leaq 0x10(%r12), %rax
cmpl -0x4(%r15,%rbx,2), %r14d
movq %rcx, %rbx
je 0x19611e
cmpq $0x0, 0x88(%rsp)
je 0x1961aa
movq 0x70(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq %r13, %rdx
movq 0xc0(%rsp), %rcx
movq %r14, %r8
callq 0x19822d
movq 0x8(%rsp), %r10
sarq $0x4, %r12
movq 0xc8(%rsp), %rbx
testq %rbx, %rbx
je 0x196204
movq 0x98(%rsp), %rdi
movq %r14, %rsi
callq *%rbx
movq 0x8(%rsp), %r10
testb %al, %al
je 0x196204
movq 0x10(%rsp), %rbx
jmp 0x19633c
addq $0x10, %r15
movq %r15, %rbp
cmpq %rdx, %r15
jae 0x19638a
cmpl 0x4(%rbp), %r13d
jne 0x19638a
leaq 0x10(%rbp), %r15
cmpl (%rbp), %r14d
je 0x1961df
jmp 0x19638a
cmpb $0x1, 0xb0(%r10)
jne 0x1962e7
xorl %edi, %edi
cmpl $0x3, 0x5c(%rsp)
setne %dil
movq 0x40(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x38(%rsp), %rsi
movq %r13, %rdx
movq %r14, %rcx
movq 0x78(%rsp), %r8
pushq 0x80(%rsp)
pushq 0xe8(%rsp)
pushq 0xa8(%rsp)
pushq %rbx
pushq 0xc0(%rsp)
pushq %r12
pushq %r15
pushq 0xb8(%r10)
callq 0x19836d
movq 0x78(%rsp), %rax
addq $0x40, %rsp
testq %rax, %rax
je 0x1962b8
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x196c5e
movq %rbx, %rdi
callq 0x307e9a
testb %al, %al
je 0x196c5e
movq 0x38(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3080b9
cmpb $0x0, 0x30(%rsp)
je 0x196c59
movq 0x38(%rsp), %rax
jmp 0x196301
cmpq $0x0, 0x10(%rsp)
jne 0x196c6d
testq %rax, %rax
movq 0x8(%rsp), %r10
movq 0x28(%rsp), %rdx
jne 0x1962e7
testb $0x1, 0xb0(%r10)
je 0x1962e7
movq 0x48(%rsp), %r12
jmp 0x196385
cmpb $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rbx
je 0x196c59
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x196306
movq (%rax), %rax
jmp 0x196308
xorl %eax, %eax
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq %r13, %rcx
movq %r14, %r8
movq %rbx, %r9
pushq %r12
pushq %r15
pushq 0x88(%rsp)
pushq %rax
callq *0xc8(%rsp)
addq $0x20, %rsp
movq 0x8(%rsp), %r10
testq %rbx, %rbx
je 0x19637b
movq %rbx, %rdi
callq 0x307e9a
testb %al, %al
jne 0x196376
movl $0x0, %edx
movq 0x38(%rsp), %rax
testq %rax, %rax
movl $0x0, %ecx
cmovneq %rcx, %r15
je 0x196368
movq (%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x3080fc
movq 0x8(%rsp), %r10
movq 0x48(%rsp), %r12
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq %rbp, %r15
cmpq %rsi, %rbp
jbe 0x1960f5
jmp 0x196af3
movq 0x8(%r10), %rax
testq %rax, %rax
je 0x196c77
movq (%rax), %rbp
movq 0xb0(%rsp), %rax
leaq (,%rax,8), %r15
addq %rbp, %r15
movq %r12, %rax
notq %rax
leaq (%r15,%rax,8), %rsi
cmpq %rsi, %rbp
ja 0x196c86
movq (%rbp), %rbx
movb 0x9c(%r10), %cl
shrq %cl, %rbx
movq 0x88(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x90(%rsp)
cmpq $0x0, 0x50(%rsp)
setne %al
movq 0x30(%rsp), %rcx
andb %al, %cl
movq %rcx, 0x30(%rsp)
movq %rsi, 0x70(%rsp)
movq (%rbp,%r12,8), %rdx
movl 0x9c(%r10), %eax
movl %eax, %ecx
shrq %cl, %rdx
cmpq %rdx, %rbx
jne 0x1964d0
movq (%rbp), %rdx
movb 0x98(%r10), %cl
movq %rdx, %rsi
shrq %cl, %rsi
andq 0x20(%r10), %rsi
movq %rdx, %rdi
movl %eax, %ecx
shrq %cl, %rdi
addq 0x48(%r10), %rsi
movq %rsi, 0x20(%rsp)
andq 0x28(%r10), %rdi
addq 0x50(%r10), %rdi
movq %rdi, 0x28(%rsp)
movl $0x8, %eax
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 0x1964ab
movq 0x10(%rsp), %rdi
movq 0x78(%rsp), %rcx
callq 0x308001
movq 0x8(%rsp), %r10
leaq (%r14,%rbp), %r12
cmpq %r15, %r12
jae 0x1964f4
movq (%r12), %rdx
movb 0x9c(%r10), %cl
movq %rdx, %r13
shrq %cl, %r13
leaq 0x8(%r14), %rax
cmpq %r13, %rbx
je 0x19645f
jmp 0x1964f7
addq $0x8, %rbp
cmpq %r15, %rbp
jae 0x1964e9
movq (%rbp), %r13
movl %eax, %ecx
shrq %cl, %r13
cmpq %r13, %rbx
je 0x1964d0
jmp 0x1964ec
movq %rbx, %r13
movq %rbp, %r12
jmp 0x1966d9
movq %rbx, %r13
cmpq $0x0, 0x88(%rsp)
je 0x19652e
movq 0x90(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0xc0(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x19822d
movq 0x8(%rsp), %r10
sarq $0x3, %r14
movq 0xc8(%rsp), %rbx
testq %rbx, %rbx
je 0x196561
movq 0x98(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq *%rbx
movq 0x8(%rsp), %r10
testb %al, %al
je 0x196561
movq 0x10(%rsp), %rbx
jmp 0x196695
cmpb $0x1, 0xb0(%r10)
jne 0x19663d
xorl %edi, %edi
cmpl $0x3, 0x5c(%rsp)
setne %dil
movq 0x40(%rsp), %rax
movq 0x30(%rax), %r9
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x78(%rsp), %r8
pushq 0x80(%rsp)
pushq 0xe8(%rsp)
pushq 0xa8(%rsp)
pushq %rbx
pushq 0xc0(%rsp)
pushq %r14
pushq %rbp
pushq 0xb8(%r10)
callq 0x19836d
movq 0x78(%rsp), %rax
addq $0x40, %rsp
testq %rax, %rax
je 0x196619
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x196c54
callq 0x307e9a
testb %al, %al
je 0x196c54
movq 0x38(%rsp), %rbx
movq (%rbx), %rsi
movq 0x10(%rbx), %r14
movq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x3080b9
movq %rbx, %rax
movq 0x10(%rsp), %rbx
cmpb $0x0, 0x30(%rsp)
jne 0x196657
jmp 0x196c45
cmpq $0x0, 0x10(%rsp)
jne 0x196c68
testq %rax, %rax
movq 0x8(%rsp), %r10
jne 0x19663d
testb $0x1, 0xb0(%r10)
jne 0x1966d4
cmpb $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rbx
je 0x196c45
testq %rax, %rax
je 0x19665c
movq (%rax), %rax
jmp 0x19665e
xorl %eax, %eax
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %rbx, %r9
pushq %r14
pushq %rbp
pushq 0x88(%rsp)
pushq %rax
callq *0xc8(%rsp)
addq $0x20, %rsp
movq 0x8(%rsp), %r10
testq %rbx, %rbx
je 0x1966d4
movq %rbx, %rdi
callq 0x307e9a
testb %al, %al
jne 0x1966cf
movl $0x0, %edx
movq 0x38(%rsp), %rax
testq %rax, %rax
movl $0x0, %ecx
cmovneq %rcx, %rbp
je 0x1966c1
movq (%rax), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rcx
callq 0x3080fc
movq 0x8(%rsp), %r10
movq 0x70(%rsp), %rsi
movq %r12, %rbp
movq %r13, %rbx
cmpq %rsi, %r12
movq 0x48(%rsp), %r12
jbe 0x19640d
jmp 0x196af3
cmpl $0x2, %eax
jne 0x196c7c
movq 0x90(%r10), %rcx
imulq %rcx, %r12
movq %r12, 0x48(%rsp)
movq 0x70(%rsp), %rax
imulq %rcx, %rax
movq %rax, 0x70(%rsp)
imulq 0xb0(%rsp), %rcx
movq %rcx, 0x28(%rsp)
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
movq %r10, %rsi
xorl %edx, %edx
callq 0x197aa4
movq 0x8(%rsp), %r10
leaq 0x30(%rbx), %rax
movq %rax, 0x100(%rsp)
testq %r14, %r14
setne %al
movq 0x30(%rsp), %rcx
andb %al, %cl
movq %rcx, 0x30(%rsp)
movl (%r15), %ebx
movl 0x4(%r15), %r13d
xorl %r12d, %r12d
movq 0x48(%rsp), %rax
leaq (%r12,%rax), %rdx
leaq 0x108(%rsp), %rdi
movq %r10, %rsi
callq 0x197aa4
cmpl 0x10c(%rsp), %r13d
jne 0x19684a
cmpl 0x108(%rsp), %ebx
jne 0x19684a
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x18f2c2
movq %r14, %r10
addq %r12, %rax
movq %rax, 0x20(%rsp)
movl $0x8, %eax
movq %rax, %r14
movl 0xd8(%rsp), %r15d
movl 0xdc(%rsp), %ebp
cmpb $0x0, 0xb0(%r10)
jne 0x1967ef
movq 0x10(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
movq 0x78(%rsp), %rcx
callq 0x308001
movq 0x8(%rsp), %r10
movq 0x20(%rsp), %rax
movl %r15d, -0x8(%rax,%r14)
movl %ebp, -0x4(%rax,%r14)
addq 0x90(%r10), %r12
cmpq 0x28(%rsp), %r12
jae 0x1968ad
leaq 0xd0(%rsp), %rdi
movq %r10, %rsi
movq %r12, %rdx
callq 0x197aa4
movl 0xd0(%rsp), %ebp
movl 0xd4(%rsp), %r15d
cmpl %r15d, %r13d
jne 0x1968b4
leaq 0x8(%r14), %rax
cmpl %ebp, %ebx
movq 0x8(%rsp), %r10
je 0x1967ba
jmp 0x1968b9
movq 0x8(%rsp), %r10
movq 0x90(%r10), %r14
addq %r14, %r12
movq %r12, %rax
movq %rax, %r12
cmpq 0x28(%rsp), %rax
jae 0x1968a3
leaq 0xd0(%rsp), %rdi
movq %r10, %rsi
movq %r12, %rdx
callq 0x197aa4
movl 0xd0(%rsp), %ebp
movl 0xd4(%rsp), %r15d
cmpl %r15d, %r13d
jne 0x196ade
leaq (%r12,%r14), %rax
cmpl %ebp, %ebx
movq 0x8(%rsp), %r10
je 0x19685c
jmp 0x196ae3
movl %ebx, %ebp
movl %r13d, %r15d
jmp 0x196ae3
movl %ebx, %ebp
movl %r13d, %r15d
jmp 0x1968b9
movq 0x8(%rsp), %r10
addl 0x48(%r10), %r13d
addl 0x50(%r10), %ebx
movl %ebx, %r8d
movl %r13d, %r13d
cmpq $0x0, 0x88(%rsp)
je 0x1968fd
movq 0x100(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq %r13, %rdx
movq 0xc0(%rsp), %rcx
movq %r8, %rbx
callq 0x19822d
movq %rbx, %r8
movq 0x8(%rsp), %r10
sarq $0x3, %r14
movq 0xc8(%rsp), %rbx
testq %rbx, %rbx
movq %r13, 0x90(%rsp)
je 0x196944
movq 0x98(%rsp), %rdi
movq %r8, %rsi
movq %r8, %r13
callq *%rbx
movq %r13, %r8
movq 0x90(%rsp), %r13
movq 0x8(%rsp), %r10
testb %al, %al
je 0x196944
movq 0x10(%rsp), %rbx
jmp 0x196a98
cmpb $0x1, 0xb0(%r10)
jne 0x196a44
xorl %edi, %edi
cmpl $0x3, 0x5c(%rsp)
setne %dil
movq 0x40(%rsp), %rax
movq 0x30(%rax), %r9
movq %r13, %rdx
movq 0x38(%rsp), %r13
movq %r13, %rsi
movq %r8, 0xe8(%rsp)
movq %r8, %rcx
movq 0x78(%rsp), %r8
pushq 0x80(%rsp)
pushq 0xe8(%rsp)
pushq 0xa8(%rsp)
pushq %rbx
pushq 0xc0(%rsp)
pushq %r14
pushq 0x50(%rsp)
pushq 0xb8(%r10)
callq 0x19836d
addq $0x40, %rsp
testq %r13, %r13
je 0x196a10
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x196c4f
movq %rbx, %rdi
callq 0x307e9a
testb %al, %al
je 0x196c4f
movq 0x38(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3080b9
cmpb $0x0, 0x30(%rsp)
movq 0xe8(%rsp), %r8
movq 0x90(%rsp), %r13
je 0x196c40
movq 0x38(%rsp), %rax
jmp 0x196a5e
cmpq $0x0, 0x10(%rsp)
jne 0x196c63
testq %r13, %r13
movq 0x8(%rsp), %r10
movq 0xe8(%rsp), %r8
movq 0x90(%rsp), %r13
jne 0x196a44
testb $0x1, 0xb0(%r10)
jne 0x196ae3
cmpb $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rbx
je 0x196c40
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x196a63
movq (%rax), %rax
jmp 0x196a65
xorl %eax, %eax
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq %r13, %rcx
movq %rbx, %r9
pushq %r14
pushq 0x28(%rsp)
pushq 0x88(%rsp)
pushq %rax
callq *0xc8(%rsp)
addq $0x20, %rsp
movq 0x8(%rsp), %r10
testq %rbx, %rbx
je 0x196ae3
movq %rbx, %rdi
callq 0x307e9a
testb %al, %al
jne 0x196ade
movl $0x0, %edx
movq 0x38(%rsp), %rax
testq %rax, %rax
movl $0x0, %ecx
movq 0x20(%rsp), %rsi
cmovneq %rcx, %rsi
movq %rsi, 0x20(%rsp)
je 0x196ace
movq (%rax), %rdx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movq %r14, %rcx
callq 0x3080fc
movq 0x8(%rsp), %r10
movl %ebp, %ebx
movl %r15d, %r13d
cmpq 0x70(%rsp), %r12
jbe 0x196769
cmpq $0x0, 0x10(%rsp)
movq 0xa0(%rsp), %rbx
movb 0x1f(%rsp), %bpl
movq 0x88(%rsp), %r15
je 0x196b36
testb %bpl, %bpl
je 0x196b27
movq 0x10(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x307f41
movq 0x10(%rsp), %rdi
callq 0x307fac
movq 0x8(%rsp), %r10
testb %bpl, %bpl
je 0x196b85
testq %rbx, %rbx
movq 0xf0(%rsp), %r14
je 0x196b7d
movq 0x58(%r10), %rax
subq 0x48(%r10), %rax
movq 0x60(%r10), %rcx
incq %rax
subq 0x50(%r10), %rcx
incq %rcx
movq 0xb0(%rsp), %rdx
addq %rdx, (%rbx)
imulq %rax, %rcx
addq %rcx, 0x8(%rbx)
movq %r14, %rdi
callq 0x11cb86
addq %rax, 0x48(%rbx)
movq %r14, %rdi
callq 0x11d054
testq %r15, %r15
movq 0xf8(%rsp), %rbx
je 0x196bf3
movq 0x110(%r15), %rdi
callq 0x1badd6
movq 0xc0(%r15), %rdi
testq %rdi, %rdi
je 0x196bc2
cmpb $0x1, 0x30(%r15)
jne 0x196bc2
leaq 0x209024(%rip), %rsi    # 0x39fbdc
movl $0xa45, %edx            # imm = 0xA45
callq 0x1045eb
movq 0xb8(%r15), %rdi
testq %rdi, %rdi
je 0x196bdf
leaq 0x209007(%rip), %rsi    # 0x39fbdc
movl $0xa49, %edx            # imm = 0xA49
callq 0x1045eb
leaq 0x208ff6(%rip), %rsi    # 0x39fbdc
movq %r15, %rdi
movl $0xde8, %edx            # imm = 0xDE8
callq 0x1045eb
testq %rbx, %rbx
je 0x196c19
movq %rbx, %rdi
callq 0x30828b
movq %rbx, %rdi
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30824f
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
movq %r15, %rbp
movq %r13, %rbx
movq 0x10(%rsp), %rax
movq %r13, %r14
jmp 0x19604c
callq 0x5d9da
callq 0x5d767
callq 0x5d6bc
callq 0x5d968
callq 0x5d6f5
callq 0x5d884
callq 0x5d812
callq 0x5d9a1
callq 0x5d72e
callq 0x5d84b
callq 0x5d8f6
callq 0x5d7d9
callq 0x5d92f
callq 0x5d8bd
callq 0x5d7a0