// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_eqlen
void gt_radixsort_str_eqlen(GtRadixsortstringinfo *rsi,
                            GtUword *suffixes,
                            GtLcpvalues *lcpvalues,
                            GtUword subbucketleft,
                            GtUword depth,
                            GtUword sortmaxdepth,
                            GtUword width)
{
  GtUword idx, previousbucketsize,
                *bucketindex; /* overlay with sizesofbuckets */
  GtRadixsortStrBucketInfo bucket;

  gt_assert(width <= rsi->maxwidth &&
            (sortmaxdepth == 0 ||
            (depth <= sortmaxdepth && sortmaxdepth <= rsi->equallengthplus1)));

  bucket.suffixes = suffixes;
  bucket.width = width;
  bucket.depth = depth;
  bucket.lcp = depth;
  gt_assert(GT_STACK_ISEMPTY(&rsi->stack));
  GT_STACK_PUSH(&rsi->stack, bucket);

  bucketindex = rsi->sizesofbuckets;
  while (!GT_STACK_ISEMPTY(&rsi->stack))
  {
    gt_radixsort_str_bucketnum_t prevbucketnum
      = GT_RADIXSORT_STR_SPECIAL_BUCKET; /* = undefined */
    bucket = GT_STACK_POP(&rsi->stack);
    memset(rsi->sizesofbuckets, 0, rsi->bytesinsizesofbuckets);

    /* Loop A */
    for (idx = 0; idx < bucket.width; idx++)
    {
      rsi->oracle[idx] = gt_radixsort_str_get_code(rsi->twobitencoding,
                                                   bucket.suffixes[idx],
                                                   bucket.depth,
                                                   rsi->equallengthplus1,
                                                   rsi->realtotallength);
    }
    for (idx = 0; idx < bucket.width; idx++)
    {
      rsi->sizesofbuckets[rsi->oracle[idx]]++;
    }
    previousbucketsize = rsi->sizesofbuckets[0];
    bucketindex[0] = 0;
    for (idx = 1UL; idx < (GtUword) GT_RADIXSORT_STR_NOFBUCKETS; idx++)
    {
      GtUword tmp;

      tmp = bucketindex[idx-1] + previousbucketsize;
      previousbucketsize = rsi->sizesofbuckets[idx];
      bucketindex[idx] = tmp;
    }

    /* Loop B */
    gt_assert(width > 1UL);
    if (bucket.suffixes[0] > bucket.suffixes[1])
    {
      for (idx = bucket.width; idx > 0; /* Nothing */)
      {
        idx--;
        rsi->sorted[bucketindex[rsi->oracle[idx]]++] = bucket.suffixes[idx];
      }
    } else
    {
      for (idx = 0; idx < bucket.width; idx++)
      {
        rsi->sorted[bucketindex[rsi->oracle[idx]]++] = bucket.suffixes[idx];
      }
    }

    memcpy(bucket.suffixes, rsi->sorted, sizeof (*rsi->sorted) * bucket.width);

    if (bucket.depth < rsi->equallengthplus1)
    {
      gt_radixsort_str_bucketnum_t bucketnum;
      GtRadixsortStrBucketInfo subbucket;

      subbucket.suffixes = bucket.suffixes;
      subbucket.depth = bucket.depth + GT_RADIXSORT_STR_KMERSIZE;
      subbucket.lcp = bucket.lcp;
      for (bucketnum = 0;
           bucketnum < (gt_radixsort_str_bucketnum_t)
                       GT_RADIXSORT_STR_NOFBUCKETS;
           bucketnum++)
      {
        subbucket.width
          = bucketnum > 0 ? (bucketindex[bucketnum] - bucketindex[bucketnum-1])
                          : bucketindex[bucketnum];
        if (subbucket.width > 0)
        {
          GtUword offset
            = (GtUword) (subbucket.suffixes - suffixes);
          if (lcpvalues != NULL)
          {
            if (prevbucketnum != GT_RADIXSORT_STR_SPECIAL_BUCKET)
            {
              subbucket.lcp = bucket.depth +
                              gt_radixsort_str_codeslcp(rsi,prevbucketnum,
                                                        bucketnum);
            }
            if (offset > 0)
            {
              gt_lcptab_update(lcpvalues,subbucketleft,offset,
                               sortmaxdepth == 0
                                 ? subbucket.lcp
                                 : GT_MIN(subbucket.lcp,sortmaxdepth));
            }
          }
          if (GT_RADIXSORT_STR_HAS_OVERFLOW(bucketnum))
          {
            if (subbucket.width > 1UL)
            {
              gt_direct_qsort_ulong (6UL, false, subbucket.suffixes,
                                     subbucket.width);
            }
            if (lcpvalues != NULL)
            {
              GtUword j,
                            lcpvalue = bucket.depth
                                       + GT_RADIXSORT_STR_KMERSIZE
                                       - GT_RADIXSORT_STR_OVERFLOW(bucketnum);

              if (sortmaxdepth > 0 && lcpvalue > sortmaxdepth)
              {
                lcpvalue = sortmaxdepth;
              }
              for (j = 1UL; j < subbucket.width; j++)
              {
                gt_lcptab_update(lcpvalues,subbucketleft,offset+j,lcpvalue);
              }
            }
          } else
          {
            if (subbucket.width > 1UL)
            {
              if (sortmaxdepth == 0 || subbucket.depth <= sortmaxdepth)
              {
                const GtUword radixsort_str_insertion_sort_max = 31UL;

                if (subbucket.width <= radixsort_str_insertion_sort_max)
                {
                  gt_radixsort_str_insertionsort(rsi,
                                                 subbucket.suffixes,
                                                 subbucketleft + offset,
                                                 subbucket.width,
                                                 subbucket.depth,
                                                 lcpvalues,
                                                 sortmaxdepth);
                } else
                {
                  GT_STACK_PUSH(&rsi->stack, subbucket);
                }
              } else
              {
                if (lcpvalues != NULL)
                {
                  GtUword j;
                  for (j = 1UL; j < subbucket.width; j++)
                  {
                    gt_lcptab_update(lcpvalues,subbucketleft,offset+j,
                                     sortmaxdepth);
                  }
                }
              }
            }
          }
          subbucket.suffixes += subbucket.width;
          gt_assert(subbucket.suffixes <= bucket.suffixes + bucket.width);
          prevbucketnum = bucketnum;
        }
      }
      gt_assert(bucket.suffixes + bucket.width == subbucket.suffixes);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x28(%rsp)
movq %rsi, 0x40(%rsp)
movq 0xc0(%rsp), %rax
cmpq %rax, 0x20(%rdi)
jb 0x32b6f3
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %rbp
movq %rdi, %r13
testq %r9, %r9
je 0x32ac9a
cmpq %rbx, %r14
ja 0x32b6f3
cmpq %rbx, 0x10(%r13)
jb 0x32b6f3
cmpq $0x0, 0x58(%r13)
jne 0x32b6f8
cmpq $0x0, 0x48(%r13)
jne 0x32ad41
movq 0x68(%r13), %rsi
shlq $0x5, %rsi
cmpq $0x0, 0x60(%r13)
je 0x32acc8
movq 0x8070(%r13), %rdi
jmp 0x32acca
xorl %edi, %edi
leaq 0xc304d(%rip), %rdx     # 0x3edd1e
movl $0x175, %ecx            # imm = 0x175
callq 0x1094e6
movq %rax, 0x8070(%r13)
movq 0x60(%r13), %rdx
cmpq %rdx, 0x48(%r13)
jne 0x32acfc
leaq 0x70(%r13), %rsi
shlq $0x5, %rdx
movq %rax, %rdi
callq 0x17660
cmpq $0x0, 0x8078(%r13)
je 0x32ad39
cmpq $0x0, 0x68(%r13)
je 0x32ad39
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x48(%r13), %rdi
shlq $0x5, %rdi
addq 0x8070(%r13), %rdi
addq %r15, %rdi
callq *0x8078(%r13)
incq %r12
addq $0x20, %r15
cmpq 0x68(%r13), %r12
jb 0x32ad13
movq 0x68(%r13), %rax
addq %rax, 0x48(%r13)
movq 0x8070(%r13), %rax
movq 0x58(%r13), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x58(%r13)
shlq $0x5, %rcx
movq 0x40(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq 0xc0(%rsp), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq %r14, 0x10(%rax,%rcx)
movq %r14, 0x18(%rax,%rcx)
movq 0x58(%r13), %rax
cmpq %rax, 0x50(%r13)
jae 0x32ad86
movq %rax, 0x50(%r13)
movq 0x58(%r13), %rax
testq %rax, %rax
je 0x32b696
movq 0x28(%r13), %r14
leaq 0x70(%r13), %rcx
movq %rcx, 0x78(%rsp)
movq 0x28(%rsp), %rcx
incq %rcx
movq %rcx, 0x60(%rsp)
movq %rbp, 0x20(%rsp)
movq %r14, 0x48(%rsp)
movq 0x8070(%r13), %rcx
decq %rax
movq %rax, 0x58(%r13)
shlq $0x5, %rax
movq (%rcx,%rax), %rdx
movq %rdx, 0x8(%rsp)
movq 0x8(%rcx,%rax), %r12
movq 0x10(%rcx,%rax), %rdx
movq %rdx, 0x30(%rsp)
movq 0x18(%rcx,%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%r13), %rdx
movq 0x28(%r13), %rdi
xorl %esi, %esi
callq 0x173a0
testq %r12, %r12
je 0x32ae60
xorl %r15d, %r15d
movq 0x8(%rsp), %r14
movq %r12, 0x18(%rsp)
movq 0x30(%rsp), %r12
movq (%r14,%r15,8), %rsi
movq (%r13), %rdi
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
movq %r12, %rdx
callq 0x32b6fd
movq 0x38(%r13), %rcx
movw %ax, (%rcx,%r15,2)
incq %r15
cmpq %r15, 0x18(%rsp)
jne 0x32ae11
movq 0x28(%r13), %rax
movq 0x38(%r13), %rcx
xorl %edx, %edx
movq 0x48(%rsp), %r14
movq 0x18(%rsp), %r12
movzwl (%rcx,%rdx,2), %esi
incq (%rax,%rsi,8)
incq %rdx
cmpq %rdx, %r12
jne 0x32ae50
movq 0x28(%r13), %rax
movq (%rax), %rcx
movq $0x0, (%r14)
xorl %edx, %edx
xorl %esi, %esi
addq %rcx, %rsi
movq 0x8(%rax,%rdx,8), %rcx
movq %rsi, 0x8(%r14,%rdx,8)
incq %rdx
cmpq $0x400, %rdx            # imm = 0x400
jne 0x32ae72
cmpq $0x1, 0xc0(%rsp)
jbe 0x32b6e9
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jbe 0x32aee5
testq %r12, %r12
movq 0x8(%rsp), %r15
je 0x32af19
movq 0x30(%r13), %rax
movq 0x38(%r13), %rcx
movq %r12, %rdx
movq -0x8(%r15,%rdx,8), %rsi
movzwl -0x2(%rcx,%rdx,2), %edi
leaq -0x1(%rdx), %r8
movq (%r14,%rdi,8), %rdx
leaq 0x1(%rdx), %r9
movq %r9, (%r14,%rdi,8)
movq %rsi, (%rax,%rdx,8)
movq %r8, %rdx
testq %r8, %r8
jne 0x32aebd
jmp 0x32af19
testq %r12, %r12
movq 0x8(%rsp), %r15
je 0x32af19
movq 0x30(%r13), %rax
movq 0x38(%r13), %rcx
xorl %edx, %edx
movq (%r15,%rdx,8), %rsi
movzwl (%rcx,%rdx,2), %edi
movq (%r14,%rdi,8), %r8
leaq 0x1(%r8), %r9
movq %r9, (%r14,%rdi,8)
movq %rsi, (%rax,%r8,8)
incq %rdx
cmpq %rdx, %r12
jne 0x32aef9
movq 0x30(%r13), %rsi
leaq (,%r12,8), %rdx
movq %r15, %rdi
callq 0x17660
movq 0x30(%rsp), %rax
cmpq 0x10(%r13), %rax
jae 0x32b689
testq %rbx, %rbx
movq %rax, %rcx
setne %al
addq $0x4, %rcx
movq %rcx, 0x58(%rsp)
cmpq %rbx, %rcx
seta %cl
andb %al, %cl
movb %cl, 0x7(%rsp)
leaq (%r15,%r12,8), %rax
movq %rax, 0x68(%rsp)
movw $0x400, %ax             # imm = 0x400
xorl %esi, %esi
testq %rsi, %rsi
je 0x32af86
cmpq $0x401, %rsi            # imm = 0x401
je 0x32b682
movq (%r14,%rsi,8), %r12
subq -0x8(%r14,%rsi,8), %r12
jmp 0x32af8a
movq (%r14,%rsi,8), %r12
testq %r12, %r12
je 0x32b67a
movq %r15, %rcx
subq 0x40(%rsp), %rcx
sarq $0x3, %rcx
movq %rcx, 0x10(%rsp)
testq %rbp, %rbp
movq %r15, 0x8(%rsp)
movq %rsi, 0x50(%rsp)
je 0x32b0ad
movzwl %ax, %ecx
cmpl $0x400, %ecx            # imm = 0x400
movq 0x8(%rsp), %rcx
je 0x32b00f
cmpq $0x400, %rsi            # imm = 0x400
jne 0x32afd4
xorl %eax, %eax
jmp 0x32b005
movq 0x40(%r13), %rcx
movl %eax, %edx
xorl %esi, %edx
movzwl %dx, %edx
shrl $0x2, %edx
movzbl (%rcx,%rdx), %ecx
andl $0x3, %eax
movl %esi, %edx
andl $0x3, %edx
cmpw %dx, %ax
cmoval %eax, %edx
movl $0x4, %eax
subl %edx, %eax
cmpl %eax, %ecx
cmovbl %ecx, %eax
movq 0x8(%rsp), %rcx
addq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq 0x40(%rsp), %rcx
je 0x32b0ad
movq 0x38(%rsp), %rcx
cmpq %rbx, %rcx
movq %rbx, %rax
cmovbq %rcx, %rax
testq %rbx, %rbx
cmoveq %rcx, %rax
movq 0x8(%rbp), %rdx
testq %rdx, %rdx
je 0x32b6df
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rsi
addq %rsi, %rcx
addq 0x20(%rbp), %rcx
cmpq 0x10(%rbp), %rcx
jae 0x32b6df
movq (%rbp), %rsi
testq %rsi, %rsi
je 0x32b076
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
shrq %cl, %rdi
shrq $0x6, %rcx
orq %rdi, (%rsi,%rcx,8)
movq %rax, %rcx
shrq $0x20, %rcx
movq 0x50(%rsp), %rsi
jne 0x32b6e4
movq 0x20(%rbp), %rcx
leaq (%rdx,%rcx,4), %rcx
movq 0x28(%rsp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq 0x10(%rsp), %rdx
movl %eax, (%rcx,%rdx,4)
cmpq $0xff, %rax
jb 0x32b0ad
incq 0x18(%rbp)
testb $0x3, %sil
sete %al
cmpq $0x400, %rsi            # imm = 0x400
setne %cl
testb %al, %cl
jne 0x32b1b4
cmpq $0x1, %r12
je 0x32b0e0
movl $0x6, %edi
xorl %esi, %esi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
callq 0x1111f4
testq %rbp, %rbp
je 0x32b663
cmpq $0x1, %r12
je 0x32b663
movq 0x50(%rsp), %rcx
movl %ecx, %eax
andl $0x3, %eax
cmpq $0x400, %rcx            # imm = 0x400
movl $0x4, %ecx
cmoveq %rcx, %rax
movq 0x58(%rsp), %rcx
subq %rax, %rcx
cmpq %rbx, %rcx
movq %rbx, %rax
cmovbq %rcx, %rax
testq %rbx, %rbx
cmoveq %rcx, %rax
movq 0x8(%rbp), %rdx
testq %rdx, %rdx
je 0x32b6c1
cmpq $0x3, %r12
movl $0x2, %esi
cmovaeq %r12, %rsi
decq %rsi
movq 0x10(%rsp), %rdi
addq 0x60(%rsp), %rdi
movq 0x20(%rbp), %rcx
addq %rdi, %rcx
cmpq 0x10(%rbp), %rcx
jae 0x32b6c1
movq %rdi, %r9
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x32b17f
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
shrq %cl, %r8
shrq $0x6, %rcx
orq %r8, (%rdi,%rcx,8)
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x32b6c6
movq 0x20(%rbp), %rcx
leaq (%rdx,%rcx,4), %rcx
movl %eax, (%rcx,%r9,4)
cmpq $0xff, %rax
jb 0x32b1a4
incq 0x18(%rbp)
movq %r9, %rdi
incq %rdi
decq %rsi
jne 0x32b14d
jmp 0x32b663
cmpq $0x1, %r12
je 0x32b663
cmpb $0x0, 0x7(%rsp)
je 0x32b261
testq %rbp, %rbp
je 0x32b663
movq 0x8(%rbp), %rax
testq %rax, %rax
je 0x32b6d0
cmpq $0x3, %r12
movl $0x2, %edx
cmovaeq %r12, %rdx
decq %rdx
movq 0x10(%rsp), %rsi
addq 0x60(%rsp), %rsi
movq 0x20(%rbp), %rcx
addq %rsi, %rcx
cmpq 0x10(%rbp), %rcx
jae 0x32b6d0
movq %rsi, %r8
movq (%rbp), %rsi
testq %rsi, %rsi
je 0x32b22b
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
shrq %cl, %rdi
shrq $0x6, %rcx
orq %rdi, (%rsi,%rcx,8)
movq %rbx, %rcx
shrq $0x20, %rcx
jne 0x32b6d5
movq 0x20(%rbp), %rcx
leaq (%rax,%rcx,4), %rcx
movl %ebx, (%rcx,%r8,4)
cmpq $0xff, %rbx
jb 0x32b251
incq 0x18(%rbp)
movq %r8, %rsi
incq %rsi
decq %rdx
jne 0x32b1f9
jmp 0x32b663
cmpq $0x1f, %r12
ja 0x32b578
movq 0x10(%rsp), %rax
addq 0x28(%rsp), %rax
movl $0x1, %ecx
movq %r12, 0x80(%rsp)
movq %rax, 0x10(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x8(%rsp), %rax
movq -0x8(%rax,%rcx,8), %r14
movq %rcx, 0x18(%rsp)
movq (%rax,%rcx,8), %r12
xorl %eax, %eax
movq 0x58(%rsp), %rbp
testq %rbx, %rbx
je 0x32b2b4
cmpq %rbx, %rbp
ja 0x32b3b8
testl %eax, %eax
jne 0x32b3b8
movq (%r13), %rdi
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
movq %r14, %rsi
movq %rbp, %rdx
callq 0x32b6fd
movl %eax, %r15d
movq (%r13), %rdi
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
movq %r12, %rsi
movq %rbp, %rdx
callq 0x32b6fd
movzwl %r15w, %esi
xorl %ecx, %ecx
movzwl %ax, %edx
cmpl $0x400, %esi            # imm = 0x400
je 0x32b33b
cmpl $0x400, %edx            # imm = 0x400
je 0x32b33b
movq 0x40(%r13), %rcx
movl %eax, %edi
xorl %r15d, %edi
movzwl %di, %edi
shrl $0x2, %edi
movzbl (%rcx,%rdi), %edi
movl %r15d, %ecx
andl $0x3, %ecx
movl %eax, %r8d
andl $0x3, %r8d
cmpw %r8w, %cx
cmoval %ecx, %r8d
movl $0x4, %ecx
subl %r8d, %ecx
cmpl %ecx, %edi
cmovbl %edi, %ecx
cmpw %ax, %r15w
jne 0x32b37c
testb $0x3, %r15b
setne %dil
movl $0x400, %r8d            # imm = 0x400
cmpl %r8d, %esi
sete %sil
orb %dil, %sil
testb $0x3, %al
setne %dil
cmpl %r8d, %edx
sete %al
orb %dil, %al
testb %sil, %sil
je 0x32b388
cmpq %r12, %r14
setb %dl
andb %dl, %al
movzbl %al, %eax
negl %eax
jmp 0x32b383
movl $0x0, %eax
sbbl %eax, %eax
orl $0x1, %eax
jmp 0x32b38d
movzbl %al, %eax
negl %eax
movzwl %cx, %edx
addq %rdx, %rbp
testl %eax, %eax
jne 0x32b3a1
cmpw $0x4, %cx
je 0x32b2a6
testl %eax, %eax
je 0x32b6a8
cmpw $0x4, %cx
jb 0x32b2a6
jmp 0x32b6a8
cmpq $0x0, 0x20(%rsp)
je 0x32b530
movq 0x18(%rsp), %rcx
cmpq 0x70(%rsp), %rcx
jae 0x32b4a5
testl %eax, %eax
jle 0x32b4a5
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x32b6b7
movq 0x10(%rsi), %r8
movq 0x20(%rsi), %rdi
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r9
addq %r9, %rcx
addq %rdi, %rcx
cmpq %r8, %rcx
jae 0x32b6b7
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x32b432
movabsq $-0x8000000000000000, %r9 # imm = 0x8000000000000000
shrq %cl, %r9
shrq $0x6, %rcx
testq %r9, (%rsi,%rcx,8)
je 0x32b6cb
movq 0x18(%rsp), %r10
leaq 0x1(%r10), %rcx
movq 0x10(%rsp), %r9
addq %r9, %rcx
addq %rdi, %rcx
cmpq %r8, %rcx
jae 0x32b6bc
leaq (%rdx,%rdi,4), %rdi
leaq (%rdi,%r9,4), %rdi
movl (%rdi,%r10,4), %edi
testq %rsi, %rsi
je 0x32b475
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
shrq %cl, %r8
shrq $0x6, %rcx
orq %r8, (%rsi,%rcx,8)
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
leaq (%rdx,%rcx,4), %rcx
movq 0x10(%rsp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq 0x18(%rsp), %rdx
movl %edi, 0x4(%rcx,%rdx,4)
cmpl $0xff, %edi
jb 0x32b4a5
movq 0x20(%rsp), %rcx
incq 0x18(%rcx)
cmpq %rbx, %rbp
movq %rbx, %rdx
cmovbq %rbp, %rdx
testq %rbx, %rbx
cmoveq %rbp, %rdx
movq 0x20(%rsp), %r9
movq 0x8(%r9), %rsi
testq %rsi, %rsi
movq 0x10(%rsp), %r10
movq 0x18(%rsp), %r11
je 0x32b6ad
leaq (%r11,%r10), %rcx
addq 0x20(%r9), %rcx
cmpq 0x10(%r9), %rcx
jae 0x32b6ad
movq (%r9), %rdi
testq %rdi, %rdi
je 0x32b501
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
shrq %cl, %r8
shrq $0x6, %rcx
orq %r8, (%rdi,%rcx,8)
movq %rdx, %rcx
shrq $0x20, %rcx
jne 0x32b6b2
movq 0x20(%r9), %rcx
leaq (%rsi,%rcx,4), %rcx
leaq (%rcx,%r10,4), %rcx
movl %edx, (%rcx,%r11,4)
cmpq $0xff, %rdx
jb 0x32b530
movq 0x20(%rsp), %rcx
incq 0x18(%rcx)
testl %eax, %eax
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
js 0x32b550
movq %r12, -0x8(%rax,%rcx,8)
movq %r14, (%rax,%rcx,8)
decq %rcx
jne 0x32b291
movq 0x70(%rsp), %rcx
incq %rcx
movq 0x80(%rsp), %r12
cmpq %r12, %rcx
movq 0x20(%rsp), %rbp
movq 0x48(%rsp), %r14
jne 0x32b287
jmp 0x32b663
movq 0x48(%r13), %rsi
cmpq %rsi, 0x58(%r13)
jne 0x32b61c
cmpq 0x60(%r13), %rsi
jne 0x32b590
xorl %edi, %edi
jmp 0x32b597
movq 0x8070(%r13), %rdi
addq 0x68(%r13), %rsi
shlq $0x5, %rsi
leaq 0xc2778(%rip), %rdx     # 0x3edd1e
movl $0x1f8, %ecx            # imm = 0x1F8
callq 0x1094e6
movq %rax, 0x8070(%r13)
movq 0x60(%r13), %rdx
cmpq %rdx, 0x48(%r13)
jne 0x32b5d2
shlq $0x5, %rdx
movq %rax, %rdi
movq 0x78(%rsp), %rsi
callq 0x17660
cmpq $0x0, 0x8078(%r13)
je 0x32b60f
cmpq $0x0, 0x68(%r13)
je 0x32b60f
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x48(%r13), %rdi
shlq $0x5, %rdi
addq 0x8070(%r13), %rdi
addq %r14, %rdi
callq *0x8078(%r13)
incq %r15
addq $0x20, %r14
cmpq 0x68(%r13), %r15
jb 0x32b5e9
movq 0x68(%r13), %rax
addq %rax, 0x48(%r13)
movq 0x48(%rsp), %r14
movq 0x8070(%r13), %rax
movq 0x58(%r13), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x58(%r13)
shlq $0x5, %rcx
movq 0x8(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq %r12, 0x8(%rax,%rcx)
movq 0x58(%rsp), %rdx
movq %rdx, 0x10(%rax,%rcx)
movq 0x38(%rsp), %rdx
movq %rdx, 0x18(%rax,%rcx)
movq 0x58(%r13), %rax
cmpq %rax, 0x50(%r13)
jae 0x32b663
movq %rax, 0x50(%r13)
movq 0x8(%rsp), %r15
leaq (%r15,%r12,8), %r15
movq 0x50(%rsp), %rsi
movl %esi, %eax
cmpq 0x68(%rsp), %r15
ja 0x32b6da
incq %rsi
jmp 0x32af69
cmpq %r15, 0x68(%rsp)
jne 0x32b6ee
movq 0x58(%r13), %rax
testq %rax, %rax
jne 0x32adb7
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x9633d
callq 0x962cf
callq 0x96298
callq 0x96306
callq 0x96261
callq 0x9641b
callq 0x963e4
callq 0x9622a
callq 0x963ad
callq 0x96376
callq 0x96452
callq 0x961f3
callq 0x961bc
callq 0x9614a
callq 0x96183
callq 0x9648b
callq 0x96111