// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-front-prune.c
// Function: front_prune_edist_inplace
GtUword front_prune_edist_inplace(
                         bool rightextension,
                         GtAllocatedMemory *frontspace,
                         GtFtPolished_point *best_polished_point,
                         GtFrontTrace *front_trace,
                         const GtFtPolishing_info *pol_info,
                         GtTrimmingStrategy trimstrategy,
                         GtUword max_history,
                         GtUword minmatchpercentage,
                         GtUword maxalignedlendifference,
                         bool showfrontinfo,
                         GtUword seedlength,
                         GtFTsequenceResources *ufsr,
                         GtUword ustart,
                         GtUword ulen,
                         GtUword vseqstartpos,
                         GtFTsequenceResources *vfsr,
                         GtUword vstart,
                         GtUword vlen,
                         bool cam_generic,
                         GtFtTrimstat *trimstat)
{
  const GtUword sumseqlength = ulen + vlen,
                minsizeforshift = sumseqlength/1000;
  /* so the space for allocating the fronts is
     sizeof (GtFtFrontvalue) * ((m+n)/1000 + maxvalid), where maxvalid is a
     small constant. */
  GtUword distance, trimleft = 0, valid = 1UL, maxvalid = 0, sumvalid = 0;
  GtFtFrontvalue *validbasefront;
  bool diedout = false;
  GtFtSequenceObject useq, vseq;
  /* This transformation allows to compute the /100  by >> 7 */
  const GtUword minmatchpercentage128
    = (minmatchpercentage * 128)/100 +
      (((minmatchpercentage * 128) % 100 == 0) ? 0 : 1);
  const uint64_t max_history_mask
    = max_history == 64 ? (~((uint64_t) 0))
                        : ((((uint64_t) 1) << max_history) - 1);
  GtLongestCommonFunc ft_longest_common;

  ft_sequenceobject_init(&useq,
                         ufsr->extend_char_access,
                         ufsr->twobit_possible,
                         ufsr->encseq,
                         rightextension,
                         ufsr->readmode,
                         0,
                         ustart,
                         ulen,
                         ufsr->encseq_r,
                         ufsr->sequence_cache,
                         ufsr->bytesequence,
                         ufsr->totallength,
                         ufsr->full_totallength);
  ft_sequenceobject_init(&vseq,
                         vfsr->extend_char_access,
                         vfsr->twobit_possible,
                         vfsr->encseq,
                         rightextension,
                         vfsr->readmode,
                         vseqstartpos,
                         vstart,
                         vlen,
                         vfsr->encseq_r,
                         vfsr->sequence_cache,
                         vfsr->bytesequence,
                         vfsr->totallength,
                         vfsr->full_totallength);
  if (cam_generic)
  {
    ft_longest_common = ft_longest_common_all;
  } else
  {
    const bool haswildcards
      = (ufsr->haswildcards && vfsr->haswildcards) ? true : false;
    const int func_index
      = gt_sequenceobject_longest_func_index(&useq,&vseq,haswildcards);
    ft_longest_common = ft_longest_common_func_tab[func_index];
  }
  frontspace->offset = 0;
  for (distance = 0, valid = 1UL; /* Nothing */; distance++, valid += 2)
  {
    GtUword trim, maxalignedlen, minlenfrommaxdiff;

    gt_assert(valid <= GT_MULT2(distance) + 1);
    sumvalid += valid;
    if (maxvalid < valid)
    {
      maxvalid = valid;
    }
    validbasefront = frontspace_allocate(minsizeforshift,trimleft,valid,
                                         frontspace);
    if (distance == 0)
    {
      validbasefront->row = 0;
      if (seedlength >= sizeof (validbasefront->matchhistory_bits) * CHAR_BIT)
      {
        validbasefront->matchhistory_bits = ~((uint64_t) 0);
      } else
      {
        validbasefront->matchhistory_bits = (((uint64_t) 1) << seedlength) - 1;
      }
      validbasefront->matchhistory_size = GT_MIN(max_history,seedlength);
      validbasefront->backreference = 0; /* No back reference */
      validbasefront->max_mismatches = 0;
      front_prune_add_matches(ft_longest_common,validbasefront + distance,
                              validbasefront,max_history,&useq,&vseq,trimstat);
      maxalignedlen = GT_MULT2(validbasefront->row);
    } else
    {
      gt_assert(valid >= 3UL);
      frontspace_check((const GtFtFrontvalue *) frontspace->space,
                       ((const GtFtFrontvalue *) frontspace->space)
                        + frontspace->allocated - 1,
                       validbasefront + trimleft);
      frontspace_check((const GtFtFrontvalue *) frontspace->space,
                       ((const GtFtFrontvalue *) frontspace->space)
                         + frontspace->allocated - 1,
                       validbasefront + trimleft + valid - 1);
      if (valid == 3UL)
      {
        maxalignedlen = front_second_inplace(ft_longest_common,
                                             validbasefront + distance,
                                             validbasefront + trimleft,
                                             max_history,
                                             &useq,
                                             &vseq,
                                             trimstat);
      } else
      {
        maxalignedlen
          = front_next_inplace(ft_longest_common,
                               validbasefront + distance,
                               validbasefront + trimleft,
                               validbasefront + trimleft + valid - 1,
                               max_history,
                               &useq,
                               &vseq,
                               trimstat);
      }
    }
    gt_assert(valid > 0);
    minlenfrommaxdiff = maxalignedlen >= maxalignedlendifference
                          ? maxalignedlen - maxalignedlendifference
                          : 0;
    trim = trim_front(true,
                      distance,
                      ulen,
                      vlen,
                      minmatchpercentage128,
                      minlenfrommaxdiff,
                      trimstrategy,
                      best_polished_point,
                      validbasefront + distance,
                      validbasefront + trimleft,
                      validbasefront + trimleft + valid,
                      max_history_mask,
                      showfrontinfo);
    if (trim > 0)
    {
      trimleft += trim;
      gt_assert(valid >= trim);
      valid -= trim;
    }
    if (valid > 0)
    {
      trim = trim_front(false,
                        distance,
                        ulen,
                        vlen,
                        minmatchpercentage128,
                        minlenfrommaxdiff,
                        trimstrategy,
                        best_polished_point,
                        validbasefront + distance,
                        validbasefront + trimleft + valid - 1,
                        validbasefront + trimleft - 1,
                        max_history_mask,
                        showfrontinfo);
      gt_assert(trim < valid);
      if (trim > 0)
      {
        gt_assert(valid >= trim);
        valid -= trim;
      }
    }
    if (valid == 0)
    {
      diedout = true;
      break;
    }
    if (front_trace != NULL)
    {
      front_trace_add_gen(front_trace,trimleft,valid);
    }
    ft_update_trace_and_polished(best_polished_point,
                                 front_trace,
                                 pol_info,
                                 distance,
                                 trimleft,
                                 validbasefront + distance,
                                 validbasefront + trimleft,
                                 validbasefront + trimleft + valid - 1,
                                 showfrontinfo);
    if ((vlen > ulen && vlen - ulen <= distance) ||
        (vlen <= ulen && ulen - vlen <= distance))
    {
      if (distance + vlen - ulen >= trimleft &&
          distance + vlen - ulen <= trimleft + valid - 1 &&
          validbasefront[distance + vlen - ulen].row == ulen)
      {
        break;
      }
    }
    if (distance >= sumseqlength)
    {
      break;
    }
  }
  if (trimstat != NULL)
  {
    gt_ft_trimstat_add(trimstat,diedout,sumvalid,maxvalid,distance,
                       sizeof (GtFtFrontvalue) * frontspace->allocated);
  }
  return diedout ? sumseqlength + 1 : distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %r9, 0xf8(%rsp)
movq %r8, 0x128(%rsp)
movq %rcx, 0x78(%rsp)
movq %rdx, 0x90(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x288(%rsp), %r13
movq 0x268(%rsp), %r10
movq 0x230(%rsp), %r8
movq 0x238(%rsp), %rcx
leaq (%r10,%r13), %rax
movq %rax, 0xc0(%rsp)
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
mulq %rdx
movq %rdx, 0xd0(%rsp)
movabsq $-0x51eb851eb851eb80, %rsi # imm = 0xAE147AE147AE1480
imulq %rcx, %rsi
shlq $0x5, %rcx
movabsq $0x3fffffffffffffe0, %rax # imm = 0x3FFFFFFFFFFFFFE0
andq %rcx, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shrq $0x2, %rdx
movq %rdx, 0x98(%rsp)
rorq $0x2, %rsi
movabsq $0x28f5c28f5c28f5c, %rax # imm = 0x28F5C28F5C28F5C
xorl %r14d, %r14d
cmpq %rax, %rsi
seta %r14b
movq $-0x1, %rax
movl %r8d, %ecx
shlq %cl, %rax
movl %edi, %ebx
movq $-0x1, %rcx
cmpq $0x40, %r8
notq %rax
cmoveq %rcx, %rax
movq %rax, 0xf0(%rsp)
movq 0x278(%rsp), %r15
movq 0x258(%rsp), %r12
movq 0x280(%rsp), %rbp
movl 0x34(%r12), %esi
movzbl 0x38(%r12), %edx
movl 0x30(%r12), %r9d
movq (%r12), %rcx
leaq 0x198(%rsp), %rdi
movl %ebx, %r8d
pushq 0x28(%r12)
pushq 0x20(%r12)
pushq 0x18(%r12)
pushq 0x8(%r12)
pushq 0x10(%r12)
pushq %r10
pushq 0x290(%rsp)
pushq $0x0
callq 0x328709
addq $0x40, %rsp
movl 0x34(%r15), %esi
movzbl 0x38(%r15), %edx
movl 0x30(%r15), %r9d
movq (%r15), %rcx
leaq 0x138(%rsp), %rdi
movl %ebx, %r8d
pushq 0x28(%r15)
pushq 0x20(%r15)
pushq 0x18(%r15)
pushq 0x8(%r15)
pushq 0x10(%r15)
pushq %r13
pushq %rbp
pushq 0x2a8(%rsp)
callq 0x328709
addq $0x40, %rsp
cmpb $0x0, 0x290(%rsp)
je 0x32770c
leaq 0x11da(%rip), %rax      # 0x3288e4
jmp 0x32774a
xorl %ebp, %ebp
cmpb $0x1, 0x39(%r12)
jne 0x32771e
movzbl 0x39(%r15), %ebp
shll $0x4, %ebp
leaq 0x198(%rsp), %rdi
callq 0x3294cd
movl %eax, %ebx
leaq 0x138(%rsp), %rdi
callq 0x3294cd
leal (%rax,%rbx,4), %eax
orl %ebp, %eax
leaq 0x1a0fca(%rip), %rcx    # 0x4c8710
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %r13
shrq $0x4, 0xd0(%rsp)
addq %r14, 0x98(%rsp)
movq $0x0, 0x8(%r13)
movq $-0x1, %rdx
movq 0x250(%rsp), %rcx
shlq %cl, %rdx
cmpq $0x40, %rcx
notq %rdx
movq $-0x1, %rax
cmovaeq %rax, %rdx
movq %rdx, 0x110(%rsp)
movq 0x230(%rsp), %rax
cmpq %rcx, %rax
cmovbq %rax, %rcx
movq %rcx, 0x118(%rsp)
movq 0x288(%rsp), %rax
movq %rax, %rdx
movq 0x268(%rsp), %rcx
subq %rcx, %rdx
movq %rdx, 0xc8(%rsp)
subq %rax, %rcx
movq %rcx, 0x120(%rsp)
movl $0x1, %ecx
movl $0x30, %eax
movq %rax, 0xd8(%rsp)
movq $0x0, 0xe0(%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
xorl %eax, %eax
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq %rcx, %rax
cmovbeq %rcx, %rax
movq %rax, 0x100(%rsp)
movq %rbp, %rax
subq 0x8(%r13), %rax
movq %rcx, 0x20(%rsp)
addq %rcx, %rax
movq 0x10(%r13), %rcx
cmpq %rcx, %rax
jb 0x3278db
movq %rcx, %xmm0
movq 0x290a4(%rip), %xmm2    # 0x3508e0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x290a8(%rip), %xmm3    # 0x3508f0
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x294b8(%rip), %xmm1    # 0x350d18
movq %rax, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm3, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
maxsd %xmm2, %xmm1
addsd 0xc5a0b(%rip), %xmm1    # 0x3ed290
cvttsd2si %xmm1, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd 0x29487(%rip), %xmm1    # 0x350d20
cvttsd2si %xmm1, %rcx
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x10(%r13)
cmpq %rcx, %rax
jae 0x3286ff
movq (%r13), %rdi
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rsi
leaq 0xc5a1e(%rip), %rdx     # 0x3ed2e2
movl $0x237, %ecx            # imm = 0x237
callq 0x1094e6
movq %rax, (%r13)
testq %rax, %rax
je 0x3286fa
movq 0x8(%r13), %rax
movq %rbp, %rcx
subq %rax, %rcx
jb 0x3286e1
movq 0xd0(%rsp), %rdx
movq 0x20(%rsp), %rsi
cmpq %rdx, %rsi
cmovaq %rsi, %rdx
leaq (,%rbp,2), %rbx
addq %rbp, %rbx
cmpq %rdx, %rcx
jbe 0x32793c
movq (%r13), %rdi
leaq (%rdi,%rbx,8), %rcx
negq %rax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rsi
movq 0x20(%rsp), %rax
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rdx
callq 0x17660
movq %rbp, 0x8(%r13)
movq %rbx, 0x130(%rsp)
movq (%r13), %rdi
movq 0x8(%r13), %rax
xorl %ecx, %ecx
subq %rax, %rcx
leaq (%rcx,%rcx,2), %rax
leaq (%rdi,%rax,8), %rbx
testq %r14, %r14
movq %r14, 0x30(%rsp)
movq %rbx, 0x40(%rsp)
movq %r15, 0xe8(%rsp)
movq %r12, 0xa0(%rsp)
movq %rbp, 0x28(%rsp)
je 0x327cbd
movq 0x20(%rsp), %rbx
cmpq $0x2, %rbx
jbe 0x3286eb
movq 0x10(%r13), %rax
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,8), %rsi
addq $-0x18, %rsi
leaq (,%rbp,8), %rax
leaq (%rax,%rax,2), %r15
movq 0x40(%rsp), %r14
leaq (%r14,%r15), %rbp
movq %rbp, %rdx
callq 0x328950
movq (%r13), %rdi
movq 0x10(%r13), %rax
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,8), %rsi
addq $-0x18, %rsi
leaq (%rbx,%rbx,2), %rax
movq %rax, 0x88(%rsp)
leaq -0x18(,%rax,8), %rdx
addq %rbp, %rdx
movq %rdx, 0x108(%rsp)
callq 0x328950
movq 0x30(%rsp), %rcx
leaq (,%rcx,8), %rax
leaq (%rax,%rax,2), %rdi
negq %rdi
leaq (%rcx,%rcx,2), %rax
leaq (%r14,%rax,8), %r13
cmpq $0x3, %rbx
jne 0x327d74
movq %r15, %rdx
movq 0x10(%rbp), %rax
movq %rax, 0x40(%rbp)
movupd (%rbp), %xmm0
movupd %xmm0, 0x30(%rbp)
movupd %xmm0, 0x18(%rbp)
movq %rax, 0x28(%rbp)
movl 0x8(%rbp), %eax
incl %eax
movl %eax, 0x8(%rbp)
movb $0x4, 0x11(%rbp)
movzbl 0x10(%rbp), %ecx
cmpq 0x230(%rsp), %rcx
movq 0x298(%rsp), %r15
jae 0x327a60
incb %cl
movb %cl, 0x10(%rbp)
shlq (%rbp)
movl %eax, %esi
addq %rdx, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdi
movq %rdi, %r12
leaq (%rdi,%rsi), %rcx
leaq 0x198(%rsp), %rdi
leaq 0x138(%rsp), %rdx
callq *0x10(%rsp)
movq %rax, %rcx
movl %ecx, 0xc(%rbp)
testl %ecx, %ecx
je 0x327af5
movl %ecx, %eax
movq $-0x1, %rdx
shlq %cl, %rdx
movq 0x230(%rsp), %rsi
cmpq %rsi, %rax
notq %rdx
movq $-0x1, %rax
cmovaeq %rax, %rdx
movq (%rbp), %rax
shlq %cl, %rax
orq %rdx, %rax
movq %rax, (%rbp)
movzbl 0x10(%rbp), %eax
cmpq %rsi, %rax
jae 0x327af2
movl %ecx, %edx
addl %eax, %edx
movq 0x230(%rsp), %rax
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movb %dl, 0x10(%rbp)
addl %ecx, 0x8(%rbp)
testq %r15, %r15
je 0x327b04
movq %r15, %rdi
movl %ecx, %esi
callq 0x1b8972
movl 0x8(%rbp), %ebx
movl 0x20(%rbp), %eax
incl %eax
movl %eax, 0x20(%rbp)
movb $0x1, 0x29(%rbp)
incl 0x2c(%rbp)
movzbl 0x28(%rbp), %ecx
cmpq 0x230(%rsp), %rcx
jae 0x327b29
incb %cl
movb %cl, 0x28(%rbp)
shlq 0x18(%rbp)
leaq 0x18(%rbp), %r14
movl %eax, %esi
subq %r13, %r14
sarq $0x3, %r14
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r14
leaq (%r14,%rsi), %rcx
leaq 0x198(%rsp), %rdi
leaq 0x138(%rsp), %rdx
callq *0x10(%rsp)
movq %rax, %rcx
movl %ecx, 0x24(%rbp)
testl %ecx, %ecx
je 0x327bbf
movl %ecx, %eax
movq $-0x1, %rdx
shlq %cl, %rdx
movq 0x230(%rsp), %rsi
cmpq %rsi, %rax
notq %rdx
movq $-0x1, %rax
cmovaeq %rax, %rdx
movq 0x18(%rbp), %rax
shlq %cl, %rax
orq %rdx, %rax
movq %rax, 0x18(%rbp)
movzbl 0x28(%rbp), %eax
cmpq %rsi, %rax
jae 0x327bbc
movl %ecx, %edx
addl %eax, %edx
movq 0x230(%rsp), %rax
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movb %dl, 0x28(%rbp)
addl %ecx, 0x20(%rbp)
testq %r15, %r15
je 0x327bce
movq %r15, %rdi
movl %ecx, %esi
callq 0x1b8972
movq %r13, %rcx
movl 0x20(%rbp), %r15d
movb $0x2, 0x41(%rbp)
movzbl 0x40(%rbp), %eax
cmpq 0x230(%rsp), %rax
jae 0x327bec
incb %al
movb %al, 0x40(%rbp)
shlq 0x30(%rbp)
leaq 0x30(%rbp), %r13
movl 0x38(%rbp), %esi
subq %rcx, %r13
sarq $0x3, %r13
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
leaq (%rsi,%r13), %rcx
leaq 0x198(%rsp), %rdi
leaq 0x138(%rsp), %rdx
callq *0x10(%rsp)
movq %rax, %rcx
movl %ecx, 0x3c(%rbp)
testl %ecx, %ecx
je 0x327c83
movl %ecx, %eax
movq $-0x1, %rdx
shlq %cl, %rdx
movq 0x230(%rsp), %rsi
cmpq %rsi, %rax
notq %rdx
movq $-0x1, %rax
cmovaeq %rax, %rdx
movq 0x30(%rbp), %rax
shlq %cl, %rax
orq %rdx, %rax
movq %rax, 0x30(%rbp)
movzbl 0x40(%rbp), %eax
cmpq %rsi, %rax
jae 0x327c80
movl %ecx, %edx
addl %eax, %edx
movq 0x230(%rsp), %rax
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movb %dl, 0x40(%rbp)
addl %ecx, 0x38(%rbp)
movq 0x298(%rsp), %rdi
testq %rdi, %rdi
je 0x327c97
movl %ecx, %esi
callq 0x1b8972
addl %r15d, %r15d
addq %r15, %r14
addl %ebx, %ebx
addq %rbx, %r12
cmpq %r14, %r12
cmovbeq %r14, %r12
movl 0x38(%rbp), %eax
addl %eax, %eax
addq %rax, %r13
cmpq %r13, %r12
cmovaq %r12, %r13
jmp 0x328311
xorl %ecx, %ecx
movl %ecx, 0x8(%rbx)
movq 0x110(%rsp), %rax
movq %rax, (%rbx)
movq 0x118(%rsp), %rax
movb %al, 0x10(%rbx)
movb $0x0, 0x11(%rbx)
movl %ecx, 0x14(%rbx)
leaq 0x198(%rsp), %rdi
xorl %esi, %esi
leaq 0x138(%rsp), %rdx
xorl %ecx, %ecx
callq *0x10(%rsp)
movq %rax, %rcx
movl %ecx, 0xc(%rbx)
testl %ecx, %ecx
movq 0x298(%rsp), %rdi
je 0x327d5c
movl %ecx, %eax
movq $-0x1, %rdx
shlq %cl, %rdx
movq 0x230(%rsp), %rsi
cmpq %rsi, %rax
notq %rdx
movq $-0x1, %rax
cmovaeq %rax, %rdx
movq (%rbx), %rax
shlq %cl, %rax
orq %rdx, %rax
movq %rax, (%rbx)
movzbl 0x10(%rbx), %eax
cmpq %rsi, %rax
jae 0x327d59
movl %ecx, %edx
addl %eax, %edx
movq 0x230(%rsp), %rax
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movb %dl, 0x10(%rbx)
addl %ecx, 0x8(%rbx)
testq %rdi, %rdi
je 0x327d68
movl %ecx, %esi
callq 0x1b8972
movl 0x8(%rbx), %r13d
addl %r13d, %r13d
jmp 0x328311
movq %r13, 0xa8(%rsp)
movq (%rbp), %rax
movl 0x8(%rbp), %ecx
movl 0xc(%rbp), %edx
movl %edx, 0x8(%rsp)
movzbl 0x10(%rbp), %edx
movzwl 0x12(%rbp), %esi
movw %si, 0x4(%rsp)
movl 0x14(%rbp), %esi
movq %rsi, 0x48(%rsp)
movq %rcx, %r13
leal 0x1(%rcx), %esi
cmpq 0x230(%rsp), %rdx
movq %rdx, 0x60(%rsp)
adcb $0x0, %dl
movq %rax, 0x68(%rsp)
leaq (%rax,%rax), %rbx
movq %rbx, (%rbp)
movl %esi, 0x8(%rbp)
movq %rdx, 0x58(%rsp)
movb %dl, 0x10(%rbp)
movb $0x4, 0x11(%rbp)
addq %r15, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdi
movq %rdi, 0x80(%rsp)
leaq (%rdi,%rsi), %rcx
leaq 0x198(%rsp), %rdi
movq %rsi, 0x38(%rsp)
leaq 0x138(%rsp), %rdx
callq *0x10(%rsp)
movq %rax, %rcx
movl %ecx, 0xc(%rbp)
testl %ecx, %ecx
movq 0x298(%rsp), %rdi
movq %r15, %r14
je 0x327e75
movl %ecx, %eax
movq $-0x1, %rdx
shlq %cl, %rdx
movq 0x230(%rsp), %rsi
cmpq %rsi, %rax
notq %rdx
movq $-0x1, %rax
cmovaeq %rax, %rdx
movq (%rbp), %rax
shlq %cl, %rax
orq %rdx, %rax
movq %rax, (%rbp)
movzbl 0x10(%rbp), %eax
cmpq %rsi, %rax
jae 0x327e72
movl %ecx, %edx
addl %eax, %edx
movq 0x230(%rsp), %rax
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movb %dl, 0x10(%rbp)
addl %ecx, 0x8(%rbp)
testq %rdi, %rdi
je 0x327e81
movl %ecx, %esi
callq 0x1b8972
movl 0x8(%rbp), %r12d
movq 0x18(%rbp), %r8
movl 0x20(%rbp), %edi
movl 0x24(%rbp), %r9d
movb 0x28(%rbp), %r10b
movzwl 0x2a(%rbp), %r11d
movl 0x2c(%rbp), %esi
leal 0x1(%rdi), %edx
cmpl %edx, 0x38(%rsp)
movq %r13, %r15
movq %rsi, 0x70(%rsp)
movq %rdi, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movl %r9d, 0xc(%rsp)
movb %r10b, 0x7(%rsp)
movw %r11w, 0x1e(%rsp)
jae 0x327eed
movzbl %r10b, %r10d
cmpq 0x230(%rsp), %r10
adcb $0x0, %r10b
leaq (%r8,%r8), %rbx
movb $0x4, %cl
movl %esi, %eax
movl %r11d, %esi
movl %r9d, %edi
jmp 0x327f15
movq 0x48(%rsp), %rax
incl %eax
movb $0x1, %cl
cmpl %edi, %r13d
jne 0x327f02
cmpl %esi, %eax
cmovbel %esi, %eax
movb $0x5, %cl
movzwl 0x4(%rsp), %esi
movl 0x8(%rsp), %edi
movq 0x38(%rsp), %rdx
movq 0x58(%rsp), %r10
leaq 0x18(%rbp), %r13
movq %rbx, 0x18(%rbp)
movl %edx, 0x20(%rbp)
movl %edi, 0x24(%rbp)
movb %r10b, 0x28(%rbp)
movb %cl, 0x29(%rbp)
movw %si, 0x2a(%rbp)
movl %eax, 0x2c(%rbp)
movl %edx, %esi
subq 0xa8(%rsp), %r13
sarq $0x3, %r13
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
leaq (%rsi,%r13), %rcx
leaq 0x198(%rsp), %rdi
leaq 0x138(%rsp), %rdx
callq *0x10(%rsp)
movq %rax, %rcx
movl %ecx, 0x24(%rbp)
testl %ecx, %ecx
movl 0xc(%rsp), %ebx
movq %r15, %r8
je 0x327fcb
movl %ecx, %eax
movq $-0x1, %rdx
shlq %cl, %rdx
movq 0x230(%rsp), %rsi
cmpq %rsi, %rax
notq %rdx
movq $-0x1, %rax
cmovaeq %rax, %rdx
movq 0x18(%rbp), %rax
shlq %cl, %rax
orq %rdx, %rax
movq %rax, 0x18(%rbp)
movzbl 0x28(%rbp), %eax
cmpq %rsi, %rax
jae 0x327fc8
movl %ecx, %edx
addl %eax, %edx
movq 0x230(%rsp), %rax
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movb %dl, 0x28(%rbp)
addl %ecx, 0x20(%rbp)
movq 0x298(%rsp), %rdi
testq %rdi, %rdi
je 0x327fe2
movl %ecx, %esi
callq 0x1b8972
movq %r15, %r8
addl %r12d, %r12d
movq 0x80(%rsp), %rcx
addq %r12, %rcx
movl 0x20(%rbp), %eax
addl %eax, %eax
addq %rax, %r13
cmpq %r13, %rcx
cmovaq %rcx, %r13
cmpq $0x3, 0x20(%rsp)
jl 0x328311
movq 0x88(%rsp), %rax
leaq (,%rax,8), %rax
addq %rbp, %rax
addq $0x30, %rbp
leaq -0x30(%rax), %rcx
movq %rcx, 0x58(%rsp)
addq $-0x48, %rax
movq %rax, 0xa8(%rsp)
addq 0xd8(%rsp), %r14
movb 0x7(%rsp), %r11b
movzwl 0x1e(%rsp), %edx
movb $0x2, %al
cmpq 0x58(%rsp), %rbp
movl %ebx, 0xc(%rsp)
jbe 0x328079
movq 0x48(%rsp), %rcx
movl %ecx, %r12d
movzwl 0x4(%rsp), %ecx
movq 0x60(%rsp), %rsi
movl %esi, %r9d
movl 0x8(%rsp), %edi
movl %r8d, %r10d
movq 0x68(%rsp), %r15
jmp 0x3280e5
movq 0xb8(%rsp), %rcx
leal 0x1(%rcx), %r10d
cmpl %r10d, %r8d
jae 0x3280a6
movq 0x70(%rsp), %rax
leal 0x1(%rax), %r12d
movb $0x1, %al
movl %edx, %ecx
movl %r11d, %r9d
movl %ebx, %edi
movq 0xb0(%rsp), %r15
jmp 0x3280e5
movq 0x48(%rsp), %rcx
movl %ecx, %r12d
movzwl 0x4(%rsp), %ecx
movq 0x60(%rsp), %rsi
movl %esi, %r9d
movl 0x8(%rsp), %edi
movl %r8d, %r10d
movq 0x68(%rsp), %r15
jne 0x3280e5
movq 0x70(%rsp), %rax
leal 0x1(%rax), %r12d
movq 0x48(%rsp), %rax
cmpl %r12d, %eax
cmoval %eax, %r12d
movb $0x3, %al
jmp 0x32805e
movq %r8, %rbx
cmpq 0xa8(%rsp), %rbp
ja 0x328131
movl 0x8(%rbp), %r8d
incl %r8d
cmpl %r8d, %r10d
jae 0x328114
movq (%rbp), %r15
movl 0xc(%rbp), %edi
movb 0x10(%rbp), %r9b
movzwl 0x12(%rbp), %esi
movl 0x14(%rbp), %ecx
movb $0x4, %al
jmp 0x328139
movl %edx, %esi
movl %r11d, %edx
leal 0x4(%rax), %r11d
cmpl %r8d, %r10d
movzbl %al, %r8d
movzbl %r11b, %eax
movl %edx, %r11d
movl %esi, %edx
cmovnel %r8d, %eax
movl %r10d, %r8d
movl %ecx, %esi
movl %r12d, %ecx
movzbl %r9b, %r9d
cmpq 0x230(%rsp), %r9
adcb $0x0, %r9b
cmpq 0x108(%rsp), %rbp
jae 0x3281f8
movq 0xb0(%rsp), %r10
movq %r10, 0x68(%rsp)
movq (%rbp), %r10
movq %r10, 0xb0(%rsp)
movl %edx, %r12d
movl %r11d, %edx
movq 0xb8(%rsp), %r11
movq %r11, 0x88(%rsp)
movl 0x8(%rbp), %r11d
movl %edi, %r10d
movq %rax, %rdi
movl %ecx, %eax
movl %esi, %ecx
movl 0xc(%rbp), %esi
movl %esi, 0x80(%rsp)
movb 0x10(%rbp), %sil
movb %sil, 0x38(%rsp)
movq %r13, %rsi
movzwl 0x12(%rbp), %r13d
movq 0x70(%rsp), %rbx
movq %rbx, 0x48(%rsp)
movq %r14, %rbx
movl 0x14(%rbp), %r14d
movw %r12w, 0x4(%rsp)
movl %edx, %r12d
movq %r12, 0x60(%rsp)
movl %r13d, %r12d
movq %rsi, %r13
movl %ecx, %esi
movl %eax, %ecx
movq %rdi, %rax
movl %r10d, %edi
movl 0xc(%rsp), %edx
movl %edx, 0x8(%rsp)
movq %r14, 0x70(%rsp)
movq %rbx, %r14
movq %r11, 0xb8(%rsp)
jmp 0x328213
movq %rbx, 0x88(%rsp)
movl %edx, %r12d
movb %r11b, 0x38(%rsp)
movl 0xc(%rsp), %edx
movl %edx, 0x80(%rsp)
addq %r15, %r15
movq %r15, (%rbp)
movl %r8d, 0x8(%rbp)
movl %edi, 0xc(%rbp)
movb %r9b, 0x10(%rbp)
movb %al, 0x11(%rbp)
movw %si, 0x12(%rbp)
movl %ecx, 0x14(%rbp)
movl %r8d, %esi
movq %r14, %rbx
sarq $0x3, %r14
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r14
leaq (%r14,%rsi), %rcx
leaq 0x198(%rsp), %rdi
leaq 0x138(%rsp), %rdx
callq *0x10(%rsp)
movq %rax, %rcx
movl %ecx, 0xc(%rbp)
testl %ecx, %ecx
je 0x3282be
movl %ecx, %eax
movq $-0x1, %rdx
shlq %cl, %rdx
movq 0x230(%rsp), %rsi
cmpq %rsi, %rax
notq %rdx
movq $-0x1, %rax
cmovaeq %rax, %rdx
movq (%rbp), %rax
shlq %cl, %rax
orq %rdx, %rax
movq %rax, (%rbp)
movzbl 0x10(%rbp), %eax
cmpq %rsi, %rax
jae 0x3282bb
movl %ecx, %edx
addl %eax, %edx
movq 0x230(%rsp), %rax
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movb %dl, 0x10(%rbp)
addl %ecx, 0x8(%rbp)
movq 0x298(%rsp), %rdi
testq %rdi, %rdi
je 0x3282d2
movl %ecx, %esi
callq 0x1b8972
movl 0x8(%rbp), %eax
addl %eax, %eax
addq %rax, %r14
cmpq %r14, %r13
cmovbeq %r14, %r13
addq $0x18, %rbp
movq %rbx, %r14
addq $0x18, %r14
movl 0x80(%rsp), %ebx
movb 0x38(%rsp), %r11b
movl %r12d, %edx
cmpq 0x108(%rsp), %rbp
movq 0x88(%rsp), %r8
jbe 0x328049
movq 0x20(%rsp), %rbx
testq %rbx, %rbx
je 0x3286e6
subq 0x240(%rsp), %r13
movl $0x0, %r12d
cmovaeq %r13, %r12
movq 0x30(%rsp), %rsi
leaq (%rsi,%rsi,2), %rax
movq 0x40(%rsp), %rcx
leaq (%rcx,%rax,8), %r14
movq 0x130(%rsp), %rax
leaq (%rcx,%rax,8), %rax
leaq (%rbx,%rbx,2), %rcx
leaq (%rax,%rcx,8), %r10
movl $0x1, %edi
movq 0x268(%rsp), %rdx
movq 0x288(%rsp), %rcx
movq 0x98(%rsp), %r8
movq %r12, %r9
pushq 0xf0(%rsp)
pushq %r10
pushq %rax
pushq %r14
pushq 0xb0(%rsp)
pushq 0x120(%rsp)
callq 0x328961
addq $0x30, %rsp
testq %rax, %rax
movq 0x128(%rsp), %rbp
je 0x3283bc
subq %rax, %rbx
movq 0x50(%rsp), %r13
jb 0x3286f5
addq %rax, 0x28(%rsp)
jmp 0x3283c1
movq 0x50(%rsp), %r13
testq %rbx, %rbx
je 0x328452
movq 0x28(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq 0x40(%rsp), %rsi
leaq (%rsi,%rax,8), %rcx
leaq (%rbx,%rbx,2), %rdx
leaq (%rcx,%rdx,8), %r10
addq $-0x18, %r10
leaq (%rsi,%rax,8), %rax
addq $-0x18, %rax
xorl %edi, %edi
movq 0x30(%rsp), %rsi
movq 0x268(%rsp), %rdx
movq 0x288(%rsp), %rcx
movq 0x98(%rsp), %r8
movq %r12, %r9
pushq 0xf0(%rsp)
pushq %rax
pushq %r10
pushq %r14
pushq 0xb0(%rsp)
pushq 0x120(%rsp)
callq 0x328961
addq $0x30, %rsp
cmpq %rax, %rbx
jbe 0x3286f0
testq %rax, %rax
movq 0x78(%rsp), %rdi
je 0x328459
subq %rax, %rbx
jae 0x328459
jmp 0x328704
xorl %ebx, %ebx
movq 0x78(%rsp), %rdi
testq %rbx, %rbx
je 0x328627
testq %rdi, %rdi
movq 0x28(%rsp), %r14
je 0x32847c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x324433
movq 0x78(%rsp), %rdi
leaq (%r14,%r14,2), %rax
movq 0x40(%rsp), %rcx
leaq (%rcx,%rax,8), %r14
leaq (%rbx,%rbx,2), %rcx
leaq (%r14,%rcx,8), %r15
addq $-0x18, %r15
cmpq %r15, %r14
ja 0x328598
movq 0xe0(%rsp), %rcx
leaq (%rcx,%rax,8), %r12
movl 0x8(%r14), %edx
movq %r12, %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
cmpq $-0x18, %r12
jg 0x3284d8
movq %rsi, %rax
negq %rax
cmpq %rax, %rdx
jl 0x3286dc
leal (%rdx,%rdx), %eax
addq %rax, %rsi
movq 0x90(%rsp), %rax
cmpq (%rax), %rsi
jbe 0x32856f
movq (%r14), %r10
movzbl 0x10(%r14), %eax
movq 0x10(%rbp), %rcx
cmpq %rax, %rcx
jbe 0x328517
subl %eax, %ecx
movq $-0x1, %r8
shlq %cl, %r8
notq %r8
movl %eax, %ecx
shlq %cl, %r8
orq %r8, %r10
movq 0x18(%rbp), %r8
movq 0x30(%rbp), %rax
movq %r8, %r9
andq %r10, %r9
cmpw $0x0, 0x2(%rax,%r9,4)
js 0x32856f
movb 0x8(%rbp), %cl
shrq %cl, %r10
movswl (%rax,%r9,4), %ecx
andq %r8, %r10
movswl 0x2(%rax,%r10,4), %eax
addl %ecx, %eax
js 0x32856f
movq 0x90(%rsp), %rcx
movq %rsi, (%rcx)
movq %rdx, 0x8(%rcx)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rcx)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rcx)
movl 0x14(%r14), %eax
movq %rax, 0x20(%rcx)
testq %rdi, %rdi
je 0x328587
movzbl 0x11(%r14), %esi
movl 0xc(%r14), %edx
callq 0x324540
movq 0x78(%rsp), %rdi
addq $0x18, %r14
addq $0x18, %r12
cmpq %r15, %r14
jbe 0x3284aa
movq 0x268(%rsp), %rax
cmpq %rax, 0x288(%rsp)
seta %al
movq 0x30(%rsp), %r14
cmpq %r14, 0xc8(%rsp)
setbe %dl
cmpq %r14, 0x120(%rsp)
seta %cl
testb %dl, %al
movq 0x28(%rsp), %rbp
jne 0x3285d3
orb %cl, %al
jne 0x32860a
movq 0xc8(%rsp), %rax
addq %r14, %rax
cmpq %rbp, %rax
jb 0x32860a
leaq (%rbx,%rbp), %rcx
decq %rcx
cmpq %rcx, %rax
ja 0x32860a
leaq (%rax,%rax,2), %rax
movq 0x40(%rsp), %rcx
movl 0x8(%rcx,%rax,8), %eax
cmpq 0x268(%rsp), %rax
jne 0x32860a
xorl %eax, %eax
jmp 0x328615
cmpq 0xc0(%rsp), %r14
setb %al
movq 0xe8(%rsp), %r15
movq 0xa0(%rsp), %r12
jmp 0x32863e
movb $0x1, %r15b
xorl %eax, %eax
movq 0x30(%rsp), %r14
movq 0xa0(%rsp), %r12
movq 0x28(%rsp), %rbp
addq 0x20(%rsp), %r12
testb %al, %al
je 0x328681
addq $0x2, %rbx
leaq 0x3(,%r14,2), %rax
incq %r14
addq $-0x18, 0xd8(%rsp)
addq $-0x18, 0xe0(%rsp)
movq %rbx, %rcx
cmpq %rax, %rbx
movq 0x100(%rsp), %rax
jbe 0x327804
callq 0x9533e
movq 0x298(%rsp), %rdi
testq %rdi, %rdi
je 0x3286b4
movq 0x10(%r13), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r9
movzbl %r15b, %esi
andl $0x1, %esi
movq %r12, %rdx
movq 0x100(%rsp), %rcx
movq %r14, %r8
callq 0x1b8749
movq 0xc0(%rsp), %rax
incq %rax
testb $0x1, %r15b
cmovneq %rax, %r14
movq %r14, %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x95305
callq 0x953b0
callq 0x95377
callq 0x95221
callq 0x95293
callq 0x9525a
callq 0x951e8
callq 0x951af
callq 0x952cc