// File: /workspace/github_c_makefile_star2_O2/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 $0x1e8, %rsp            # imm = 0x1E8
movq %r9, 0xf0(%rsp)
movq %r8, 0xb8(%rsp)
movq %rcx, 0x90(%rsp)
movq %rdx, 0x78(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x278(%rsp), %r13
movq 0x258(%rsp), %r10
movq 0x220(%rsp), %rcx
movq 0x228(%rsp), %r8
leaq (%r10,%r13), %rax
xorl %r14d, %r14d
movl $0x3e8, %esi            # imm = 0x3E8
movq %rax, 0x80(%rsp)
xorl %edx, %edx
divq %rsi
movq %rax, 0x120(%rsp)
shlq $0x7, %r8
pushq $0x64
popq %rsi
movq %r8, %rax
xorl %edx, %edx
divq %rsi
cmpq $0x1, %rdx
sbbq $-0x1, %rax
movq %rax, 0xe8(%rsp)
pushq $-0x1
popq %rax
movq %rax, %rdx
shlq %cl, %rdx
cmpq $0x40, %rcx
notq %rdx
cmoveq %rax, %rdx
movq %rdx, 0xe0(%rsp)
movl %edi, %ebx
movq 0x268(%rsp), %r15
movq 0x248(%rsp), %r12
movq 0x270(%rsp), %rbp
movq 0x250(%rsp), %rax
movl 0x34(%r12), %esi
movzbl 0x38(%r12), %edx
movl 0x30(%r12), %r9d
movq (%r12), %rcx
leaq 0x188(%rsp), %rdi
movl %ebx, %r8d
pushq 0x28(%r12)
pushq 0x20(%r12)
pushq 0x18(%r12)
pushq 0x8(%r12)
pushq 0x10(%r12)
pushq %r10
pushq %rax
pushq $0x0
callq 0x2bee9f
addq $0x40, %rsp
movl 0x34(%r15), %esi
movzbl 0x38(%r15), %edx
movl 0x30(%r15), %r9d
movq (%r15), %rcx
leaq 0x128(%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 0x298(%rsp)
callq 0x2bee9f
addq $0x40, %rsp
cmpb $0x0, 0x280(%rsp)
je 0x2be093
leaq 0x10b4(%rip), %rax      # 0x2bf145
jmp 0x2be0d1
cmpb $0x1, 0x39(%r12)
jne 0x2be0a4
movzbl 0x39(%r15), %r14d
shll $0x4, %r14d
leaq 0x188(%rsp), %rdi
callq 0x2bfe0c
movl %eax, %ebx
leaq 0x128(%rsp), %rdi
callq 0x2bfe0c
leal (%rax,%rbx,4), %eax
orl %r14d, %eax
leaq 0x17e5f3(%rip), %rcx    # 0x43c6c0
movq (%rcx,%rax,8), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %r12
movq 0x90(%rsp), %rbp
andq $0x0, 0x8(%r12)
pushq $-0x1
popq %rax
movq %rax, %rdx
movq 0x240(%rsp), %rcx
shlq %cl, %rdx
cmpq $0x40, %rcx
notq %rdx
cmovaeq %rax, %rdx
movq %rdx, 0x108(%rsp)
movq 0x220(%rsp), %r14
cmpq %rcx, %r14
cmovbq %r14, %rcx
movq %rcx, 0x110(%rsp)
movq 0x278(%rsp), %rax
movq %rax, %rdx
movq 0x258(%rsp), %rcx
subq %rcx, %rdx
movq %rdx, 0xd0(%rsp)
subq %rax, %rcx
movq %rcx, 0x118(%rsp)
pushq $0x1
popq %rsi
pushq $0x30
popq %rax
movq %rax, 0xc8(%rsp)
movq $0x0, 0xd8(%rsp)
movq $0x0, 0xc0(%rsp)
movq $0x0, 0x88(%rsp)
xorl %ebx, %ebx
xorl %r15d, %r15d
leaq 0x1(,%r15,2), %rax
cmpq %rax, %rsi
ja 0x2bed1d
movq 0x88(%rsp), %rax
cmpq %rsi, %rax
cmovbeq %rsi, %rax
movq %rax, 0x88(%rsp)
movq 0x8(%r12), %rcx
movq 0x10(%r12), %rdx
movq %rbx, %rax
subq %rcx, %rax
movq %rsi, 0x10(%rsp)
addq %rsi, %rax
cmpq %rdx, %rax
jb 0x2be27b
movq %rdx, %xmm0
movq 0x29706(%rip), %xmm2    # 0x2e78e0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x2970a(%rip), %xmm3    # 0x2e78f0
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x29b1a(%rip), %xmm1    # 0x2e7d18
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 0xc5c9d(%rip), %xmm1    # 0x383ec0
cvttsd2si %xmm1, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd 0x29ae9(%rip), %xmm1    # 0x2e7d20
cvttsd2si %xmm1, %rcx
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x10(%r12)
cmpq %rcx, %rax
jae 0x2bee6e
movq (%r12), %rdi
imulq $0x18, %rcx, %rsi
leaq 0xc5cb3(%rip), %rdx     # 0x383f12
movl $0x237, %ecx            # imm = 0x237
callq 0x93472
movq %rax, (%r12)
testq %rax, %rax
je 0x2bee3d
movq 0x8(%r12), %rcx
movq %rbx, %rax
subq %rcx, %rax
jb 0x2bed4b
movq 0x120(%rsp), %rdx
movq 0x10(%rsp), %r8
cmpq %rdx, %r8
cmovaq %r8, %rdx
movq (%r12), %rdi
cmpq %rdx, %rax
jbe 0x2be2ca
imulq $0x18, %rbx, %rax
addq %rdi, %rax
negq %rcx
imulq $0x18, %rcx, %rsi
addq %rax, %rsi
imulq $0x18, %r8, %rdx
callq 0x17630
movq %rbx, 0x8(%r12)
movq (%r12), %rdi
movq %rbx, %rcx
negq %rcx
imulq $0x18, %rcx, %r13
addq %rdi, %r13
testq %r15, %r15
movq %r13, 0x58(%rsp)
movq %r15, 0x20(%rsp)
movq %rbx, 0x8(%rsp)
je 0x2be4f0
movq 0x10(%rsp), %rbx
cmpq $0x2, %rbx
jbe 0x2beddb
imulq $0x18, 0x10(%r12), %rax
leaq (%rdi,%rax), %rsi
addq $-0x18, %rsi
imulq $0x18, 0x8(%rsp), %rax
movq 0x58(%rsp), %r13
movq %rax, 0x48(%rsp)
leaq (%rax,%r13), %r15
movq %r15, %rdx
callq 0x2bf244
imulq $0x18, 0x10(%r12), %rax
movq (%r12), %rdi
leaq (%rdi,%rax), %rsi
addq $-0x18, %rsi
imulq $0x18, %rbx, %rax
movq %rax, 0x38(%rsp)
leaq (%rax,%r15), %rdx
addq $-0x18, %rdx
movq %rdx, 0x100(%rsp)
callq 0x2bf244
imulq $0x18, 0x20(%rsp), %rcx
leaq (%rcx,%r13), %rsi
cmpq $0x3, %rbx
movq %rsi, 0x40(%rsp)
movq %rcx, 0x30(%rsp)
jne 0x2be552
movq 0x10(%r15), %rax
movq %rax, 0x40(%r15)
movupd (%r15), %xmm0
movupd %xmm0, 0x30(%r15)
movupd %xmm0, 0x18(%r15)
movq %rax, 0x28(%r15)
incl 0x8(%r15)
movb $0x4, 0x11(%r15)
movzbl 0x10(%r15), %eax
cmpq %r14, %rax
movq 0x288(%rsp), %r10
jae 0x2be3b1
incb %al
movb %al, 0x10(%r15)
shlq (%r15)
subq $0x8, %rsp
movq 0x20(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
leaq 0x190(%rsp), %r8
leaq 0x130(%rsp), %r9
pushq %r10
callq 0x2bf1ac
popq %rax
popq %rcx
movl 0x8(%r15), %r12d
incl 0x20(%r15)
movb $0x1, 0x29(%r15)
incl 0x2c(%r15)
movzbl 0x28(%r15), %eax
cmpq %r14, %rax
jae 0x2be3fd
incb %al
movb %al, 0x28(%r15)
leaq 0x18(%r15), %r13
shlq 0x18(%r15)
subq $0x8, %rsp
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq %r13, %rdx
movq %r14, %rcx
leaq 0x190(%rsp), %r8
leaq 0x130(%rsp), %r9
pushq 0x290(%rsp)
callq 0x2bf1ac
popq %rax
popq %rcx
movl 0x20(%r15), %ecx
movb $0x2, 0x41(%r15)
movzbl 0x40(%r15), %eax
cmpq %r14, %rax
jae 0x2be450
incb %al
movb %al, 0x40(%r15)
leaq 0x30(%r15), %rbx
movq 0x40(%rsp), %rax
subq %rax, %r13
movq %rax, %rsi
movq %r13, %rax
cqto
pushq $0x18
popq %r13
idivq %r13
addl %ecx, %ecx
addq %rax, %rcx
movq 0x48(%rsp), %rax
subq 0x30(%rsp), %rax
cqto
idivq %r13
addl %r12d, %r12d
addq %rax, %r12
cmpq %rcx, %r12
cmovbeq %rcx, %r12
shlq 0x30(%r15)
subq $0x8, %rsp
movq 0x20(%rsp), %rdi
movq %rsi, %r13
movq %rbx, %rdx
movq %r14, %rcx
leaq 0x190(%rsp), %r8
leaq 0x130(%rsp), %r9
pushq 0x290(%rsp)
callq 0x2bf1ac
popq %rax
popq %rcx
movl 0x38(%r15), %ecx
addl %ecx, %ecx
subq %r13, %rbx
movq %rbx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
movq %rax, %rdx
addq %rcx, %rdx
cmpq %rdx, %r12
cmovaq %r12, %rdx
movq 0x20(%rsp), %r15
movq 0x10(%rsp), %rbx
jmp 0x2be956
andl $0x0, 0x8(%r13)
movq 0x108(%rsp), %rax
movq %rax, (%r13)
movq 0x110(%rsp), %rax
movb %al, 0x10(%r13)
movb $0x0, 0x11(%r13)
andl $0x0, 0x14(%r13)
subq $0x8, %rsp
movq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r13, %rdx
movq %r14, %rcx
leaq 0x190(%rsp), %r8
leaq 0x130(%rsp), %r9
pushq 0x290(%rsp)
callq 0x2bf1ac
popq %rax
popq %rcx
movl 0x8(%r13), %edx
addl %edx, %edx
jmp 0x2be948
movq (%r15), %rax
movl 0x8(%r15), %r13d
movl 0xc(%r15), %ecx
movl %ecx, 0x4(%rsp)
movzbl 0x10(%r15), %r12d
movzwl 0x12(%r15), %ecx
movw %cx, (%rsp)
movl 0x14(%r15), %ecx
movq %rcx, 0xa8(%rsp)
leal 0x1(%r13), %ebx
cmpq %r14, %r12
movl %r12d, %ecx
adcb $0x0, %cl
movq %rax, 0x70(%rsp)
addq %rax, %rax
movq %rax, 0xb0(%rsp)
movq %rax, (%r15)
movl %ebx, 0x8(%r15)
movq %rcx, 0x60(%rsp)
movb %cl, 0x10(%r15)
movb $0x4, 0x11(%r15)
subq $0x8, %rsp
movq 0x20(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
leaq 0x190(%rsp), %r8
leaq 0x130(%rsp), %r9
pushq 0x290(%rsp)
callq 0x2bf1ac
popq %rax
popq %rcx
movq 0x48(%rsp), %rax
subq 0x30(%rsp), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
movq 0x18(%r15), %rcx
movl 0x20(%r15), %r9d
movl 0x24(%r15), %r8d
movb 0x28(%r15), %r10b
movzwl 0x2a(%r15), %edi
movl 0x2c(%r15), %esi
leal 0x1(%r9), %edx
cmpl %edx, %ebx
movq %r13, 0xf8(%rsp)
movq %rsi, 0x68(%rsp)
movw %di, 0x2(%rsp)
movl %r8d, 0x2c(%rsp)
movq %r9, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movb %r10b, 0x30(%rsp)
jae 0x2be654
movzbl %r10b, %r9d
cmpq %r14, %r9
adcb $0x0, %r9b
leaq (%rcx,%rcx), %r11
movb $0x4, %cl
movl %esi, %r10d
movl %edi, %esi
movl %r8d, %edi
jmp 0x2be687
movq 0xa8(%rsp), %rcx
leal 0x1(%rcx), %r10d
movb $0x1, %cl
cmpl %r9d, %r13d
jne 0x2be670
cmpl %esi, %r10d
cmovbel %esi, %r10d
movb $0x5, %cl
movzwl (%rsp), %esi
movl 0x4(%rsp), %edi
movl %ebx, %edx
movq 0x60(%rsp), %r9
movq 0xb0(%rsp), %r11
movq 0x38(%rsp), %rbx
addq %r15, %rbx
movl 0x8(%r15), %r8d
addl %r8d, %r8d
addq %r8, %rax
movq %rax, 0x38(%rsp)
leaq 0x18(%r15), %r13
movq %r11, 0x18(%r15)
movl %edx, 0x20(%r15)
movl %edi, 0x24(%r15)
movb %r9b, 0x28(%r15)
movb %cl, 0x29(%r15)
movw %si, 0x2a(%r15)
movl %r10d, 0x2c(%r15)
subq $0x8, %rsp
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq %r13, %rdx
movq %r14, %rcx
leaq 0x190(%rsp), %r8
leaq 0x130(%rsp), %r9
pushq 0x290(%rsp)
callq 0x2bf1ac
popq %rax
popq %rcx
movl 0x20(%r15), %ecx
addl %ecx, %ecx
subq 0x40(%rsp), %r13
movq %r13, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
movq %rax, %rdx
addq %rcx, %rdx
movq 0x38(%rsp), %rax
cmpq %rdx, %rax
cmovaq %rax, %rdx
addq $0x30, %r15
leaq -0x30(%rbx), %rax
movq %rax, 0x60(%rsp)
addq $-0x48, %rbx
movq %rbx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
addq 0xc8(%rsp), %rdi
movb 0x30(%rsp), %bl
cmpq 0x100(%rsp), %r15
movq 0xf8(%rsp), %r10
movq 0xa8(%rsp), %r11
ja 0x2be943
movq %rdi, 0x48(%rsp)
movb $0x2, %al
cmpq 0x60(%rsp), %r15
movq %rdx, 0x30(%rsp)
jbe 0x2be789
movl %r11d, %ecx
movzwl (%rsp), %edx
movl %r12d, %r9d
movl 0x4(%rsp), %esi
movl %r10d, %edi
movq 0x70(%rsp), %r8
jmp 0x2be7e4
movq 0xa0(%rsp), %rcx
leal 0x1(%rcx), %edi
cmpl %edi, %r10d
jae 0x2be7b9
movq 0x68(%rsp), %rax
leal 0x1(%rax), %ecx
movb $0x1, %al
movzwl 0x2(%rsp), %edx
movl %ebx, %r9d
movl 0x2c(%rsp), %esi
movq 0x98(%rsp), %r8
jmp 0x2be7e4
movl %r11d, %ecx
movzwl (%rsp), %edx
movl %r12d, %r9d
movl 0x4(%rsp), %esi
movl %r10d, %edi
movq 0x70(%rsp), %r8
jne 0x2be7e4
movq 0x68(%rsp), %rax
leal 0x1(%rax), %ecx
cmpl %ecx, %r11d
cmoval %r11d, %ecx
movb $0x3, %al
jmp 0x2be774
cmpq 0x38(%rsp), %r15
ja 0x2be819
movl 0x8(%r15), %r10d
incl %r10d
cmpl %r10d, %edi
jae 0x2be812
movq (%r15), %r8
movl 0xc(%r15), %esi
movb 0x10(%r15), %r9b
movzwl 0x12(%r15), %edx
movl 0x14(%r15), %ecx
movb $0x4, %al
movl %r10d, %edi
jmp 0x2be819
jne 0x2be816
orb $0x4, %al
movzbl %al, %eax
movzbl %r9b, %r9d
cmpq %r14, %r9
adcb $0x0, %r9b
addq %r8, %r8
cmpq 0x100(%rsp), %r15
jae 0x2be8bd
movq 0x98(%rsp), %r10
movq %r10, 0x70(%rsp)
movq (%r15), %r10
movq 0xa0(%rsp), %r11
movq %r11, 0xf8(%rsp)
movl 0x8(%r15), %r11d
movl %ebx, %r13d
movl 0x2c(%rsp), %ebx
movl %ebx, 0x4(%rsp)
movl 0xc(%r15), %r12d
movb 0x10(%r15), %bl
movzwl 0x2(%rsp), %ebp
movw %bp, (%rsp)
movzwl 0x12(%r15), %r14d
movq 0x68(%rsp), %rbp
movq %rbp, 0xa8(%rsp)
movl 0x14(%r15), %ebp
movq %rbp, 0x68(%rsp)
movq 0x90(%rsp), %rbp
movq %r11, 0xa0(%rsp)
movq %r10, 0x98(%rsp)
movw %r14w, 0x2(%rsp)
movq 0x220(%rsp), %r14
movl %r12d, 0x2c(%rsp)
jmp 0x2be8c0
movl %r12d, %r13d
movl %r13d, %r12d
movq %r8, (%r15)
movl %edi, 0x8(%r15)
movl %esi, 0xc(%r15)
movb %r9b, 0x10(%r15)
movb %al, 0x11(%r15)
movw %dx, 0x12(%r15)
movl %ecx, 0x14(%r15)
subq $0x8, %rsp
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
leaq 0x190(%rsp), %r8
leaq 0x130(%rsp), %r9
pushq 0x290(%rsp)
callq 0x2bf1ac
popq %rax
popq %rcx
movl 0x8(%r15), %ecx
addl %ecx, %ecx
movq 0x48(%rsp), %rdi
movq %rdi, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
addq %rcx, %rax
movq 0x30(%rsp), %rdx
cmpq %rax, %rdx
cmovbeq %rax, %rdx
addq $0x18, %r15
addq $0x18, %rdi
jmp 0x2be740
movq 0x20(%rsp), %r15
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x2bedaa
addq %rbx, 0xc0(%rsp)
subq 0x230(%rsp), %rdx
movl $0x0, %r14d
cmovaeq %rdx, %r14
imulq $0x18, %r15, %r12
movq 0x58(%rsp), %rcx
addq %rcx, %r12
imulq $0x18, 0x8(%rsp), %rax
addq %rcx, %rax
imulq $0x18, %rbx, %r10
addq %rax, %r10
pushq $0x1
popq %rdi
movq %r15, %rsi
movq 0x258(%rsp), %rdx
movq 0x278(%rsp), %rcx
movq 0xe8(%rsp), %r8
movq %r14, %r9
pushq 0xe0(%rsp)
pushq %r10
pushq %rax
pushq %r12
pushq 0x98(%rsp)
pushq 0x118(%rsp)
callq 0x2bf288
addq $0x30, %rsp
testq %rax, %rax
je 0x2be9fe
cmpq %rax, %rbx
movq 0xb8(%rsp), %r13
jb 0x2bee0c
subq %rax, %rbx
movq %rbx, 0x10(%rsp)
je 0x2bec79
movq 0x8(%rsp), %rcx
addq %rax, %rcx
jmp 0x2bea0b
movq 0xb8(%rsp), %r13
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rsp)
imulq $0x18, %rcx, %rbx
movq 0x58(%rsp), %rcx
leaq (%rcx,%rbx), %r15
movq 0x10(%rsp), %r11
imulq $0x18, %r11, %rax
addq %r15, %rax
addq $-0x18, %rax
leaq (%rcx,%rbx), %r10
addq $-0x18, %r10
xorl %edi, %edi
movq 0x20(%rsp), %rsi
movq 0x258(%rsp), %rdx
movq 0x278(%rsp), %rcx
movq 0xe8(%rsp), %r8
movq %r14, %r9
movq %r11, %r14
pushq 0xe0(%rsp)
pushq %r10
pushq %rax
pushq %r12
pushq 0x98(%rsp)
pushq 0x118(%rsp)
callq 0x2bf288
addq $0x30, %rsp
cmpq %rax, %r14
jbe 0x2bed79
testq %rax, %rax
movq 0x50(%rsp), %r12
je 0x2bea99
subq %rax, %r14
je 0x2bec8a
testq %rbp, %rbp
je 0x2beaae
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x2ba4d5
movq %r14, 0x10(%rsp)
imulq $0x18, %r14, %rax
leaq (%r15,%rax), %r14
addq $-0x18, %r14
addq 0xd8(%rsp), %rbx
cmpq %r14, %r15
ja 0x2beba1
movl 0x8(%r15), %esi
movq %rbx, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq $-0x18, %rbx
jg 0x2beaf4
movq %rax, %rcx
negq %rcx
cmpq %rcx, %rsi
jl 0x2bece5
leal (%rsi,%rsi), %ecx
addq %rcx, %rax
movq 0x78(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x2beb7e
movq (%r15), %rdi
movzbl 0x10(%r15), %edx
movq 0x10(%r13), %rcx
cmpq %rdx, %rcx
jbe 0x2beb29
subl %edx, %ecx
pushq $-0x1
popq %r8
shlq %cl, %r8
notq %r8
movl %edx, %ecx
shlq %cl, %r8
orq %r8, %rdi
movq 0x18(%r13), %r8
movq 0x30(%r13), %rdx
movq %r8, %r9
andq %rdi, %r9
cmpw $0x0, 0x2(%rdx,%r9,4)
js 0x2beb7e
movb 0x8(%r13), %cl
shrq %cl, %rdi
movswl (%rdx,%r9,4), %ecx
andq %r8, %rdi
movswl 0x2(%rdx,%rdi,4), %edx
addl %ecx, %edx
js 0x2beb7e
movq 0x78(%rsp), %rcx
movq %rax, (%rcx)
movq %rsi, 0x8(%rcx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rcx)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rcx)
movl 0x14(%r15), %eax
movq %rax, 0x20(%rcx)
testq %rbp, %rbp
je 0x2beb94
movzbl 0x11(%r15), %esi
movl 0xc(%r15), %edx
movq %rbp, %rdi
callq 0x2ba6f5
addq $0x18, %r15
addq $0x18, %rbx
jmp 0x2beac7
movq 0x258(%rsp), %rax
cmpq %rax, 0x278(%rsp)
seta %al
movq 0x20(%rsp), %r15
cmpq %r15, 0xd0(%rsp)
setbe %dl
cmpq %r15, 0x118(%rsp)
seta %cl
testb %dl, %al
jne 0x2bebd7
orb %cl, %al
jne 0x2bebfe
movq 0xd0(%rsp), %rax
addq %r15, %rax
cmpq 0x8(%rsp), %rax
jb 0x2bebfe
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
addq %rdx, %rcx
decq %rcx
cmpq %rcx, %rax
jbe 0x2bec40
cmpq 0x80(%rsp), %r15
movq 0x220(%rsp), %r14
movq 0x288(%rsp), %rdi
jae 0x2bec75
incq %r15
movq 0x10(%rsp), %rsi
addq $0x2, %rsi
addq $-0x18, 0xc8(%rsp)
addq $-0x18, 0xd8(%rsp)
movq 0x8(%rsp), %rbx
jmp 0x2be184
xorl %ebx, %ebx
cmpq 0x80(%rsp), %r15
movq 0x220(%rsp), %r14
movq 0x288(%rsp), %rdi
jae 0x2bec99
imulq $0x18, %rax, %rax
movq 0x58(%rsp), %rcx
movl 0x8(%rcx,%rax), %eax
cmpq 0x258(%rsp), %rax
jne 0x2bec18
jmp 0x2bec99
xorl %ebx, %ebx
jmp 0x2bec99
movb $0x1, %bl
movq 0x50(%rsp), %r12
movq 0x288(%rsp), %rdi
jmp 0x2bec99
movb $0x1, %bl
movq 0x288(%rsp), %rdi
movq 0x20(%rsp), %r15
testq %rdi, %rdi
je 0x2becbf
imulq $0x18, 0x10(%r12), %r9
movzbl %bl, %esi
movq 0xc0(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq %r15, %r8
callq 0x15d2e9
movq 0x80(%rsp), %rax
incq %rax
testb %bl, %bl
cmovneq %rax, %r15
movq %r15, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x17927c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2631d(%rip), %rsi     # 0x2e5013
leaq 0xc55f7(%rip), %rdx     # 0x3842f4
leaq 0xc5642(%rip), %rcx     # 0x384346
leaq 0xc5207(%rip), %r8      # 0x383f12
movl $0x256, %r9d            # imm = 0x256
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x179244(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x262e5(%rip), %rsi     # 0x2e5013
leaq 0xc51a3(%rip), %rdx     # 0x383ed8
leaq 0xc51bc(%rip), %rcx     # 0x383ef8
leaq 0xc51cf(%rip), %r8      # 0x383f12
movl $0x2c7, %r9d            # imm = 0x2C7
jmp 0x2bed11
movq 0x179216(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x262b7(%rip), %rsi     # 0x2e5013
leaq 0xc5511(%rip), %rdx     # 0x384274
leaq 0xc54e4(%rip), %rcx     # 0x38424e
leaq 0xc51a1(%rip), %r8      # 0x383f12
movl $0x23a, %r9d            # imm = 0x23A
jmp 0x2bed11
movq 0x1791e8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x26289(%rip), %rsi     # 0x2e5013
leaq 0xc51c1(%rip), %rdx     # 0x383f52
leaq 0xc5160(%rip), %rcx     # 0x383ef8
leaq 0xc5173(%rip), %r8      # 0x383f12
movl $0x326, %r9d            # imm = 0x326
jmp 0x2bed11
movq 0x1791b7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x26258(%rip), %rsi     # 0x2e5013
leaq 0xc5178(%rip), %rdx     # 0x383f3a
leaq 0xc512f(%rip), %rcx     # 0x383ef8
leaq 0xc5142(%rip), %r8      # 0x383f12
movl $0x300, %r9d            # imm = 0x300
jmp 0x2bed11
movq 0x179186(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x26227(%rip), %rsi     # 0x2e5013
leaq 0xc513a(%rip), %rdx     # 0x383f2d
leaq 0xc50fe(%rip), %rcx     # 0x383ef8
leaq 0xc5111(%rip), %r8      # 0x383f12
movl $0x2e1, %r9d            # imm = 0x2E1
jmp 0x2bed11
movq 0x179155(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x261f6(%rip), %rsi     # 0x2e5013
leaq 0xc5120(%rip), %rdx     # 0x383f44
leaq 0xc50cd(%rip), %rcx     # 0x383ef8
leaq 0xc50e0(%rip), %r8      # 0x383f12
movl $0x314, %r9d            # imm = 0x314
jmp 0x2bed11
movq 0x179124(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x261c5(%rip), %rsi     # 0x2e5013
leaq 0xc540d(%rip), %rdx     # 0x384262
leaq 0xc53f2(%rip), %rcx     # 0x38424e
leaq 0xc50af(%rip), %r8      # 0x383f12
movl $0x238, %r9d            # imm = 0x238
jmp 0x2bed11
movq 0x1790f3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x26194(%rip), %rsi     # 0x2e5013
leaq 0xc539a(%rip), %rdx     # 0x384220
leaq 0xc53c1(%rip), %rcx     # 0x38424e
leaq 0xc507e(%rip), %r8      # 0x383f12
movl $0x236, %r9d            # imm = 0x236
jmp 0x2bed11