// File: /workspace/github_c_makefile_star2_O2/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 $0xa8, %rsp
movq %rcx, 0x30(%rsp)
movq %rsi, 0x40(%rsp)
movq 0xe0(%rsp), %rax
cmpq %rax, 0x20(%rdi)
jb 0x2c2408
movq %r9, %r12
movq %r8, %r14
movq %rdi, %r13
testq %r9, %r9
je 0x2c1b7e
cmpq %r12, %r14
ja 0x2c2408
cmpq %r12, 0x10(%r13)
jb 0x2c2408
cmpq $0x0, 0x58(%r13)
jne 0x2c2439
cmpq $0x0, 0x48(%r13)
movq %rdx, 0x10(%rsp)
je 0x2c1b9c
xorl %eax, %eax
jmp 0x2c1c2e
movq 0x68(%r13), %rsi
shlq $0x5, %rsi
cmpq $0x0, 0x60(%r13)
je 0x2c1bb4
movq 0x8070(%r13), %rdi
jmp 0x2c1bb6
xorl %edi, %edi
leaq 0xc2d7d(%rip), %rdx     # 0x38493a
movl $0x175, %ecx            # imm = 0x175
callq 0x93472
movq %rax, 0x8070(%r13)
movq 0x48(%r13), %rdx
cmpq 0x60(%r13), %rdx
jne 0x2c1be8
leaq 0x70(%r13), %rsi
shlq $0x5, %rdx
movq %rax, %rdi
callq 0x17630
cmpq $0x0, 0x8078(%r13)
je 0x2c1c22
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x68(%r13), %rax
cmpq %rax, %r15
jae 0x2c1c26
movq 0x48(%r13), %rdi
shlq $0x5, %rdi
addq 0x8070(%r13), %rdi
addq %rbx, %rdi
callq *0x8078(%r13)
incq %r15
addq $0x20, %rbx
jmp 0x2c1bf7
movq 0x68(%r13), %rax
addq %rax, 0x48(%r13)
movq 0x58(%r13), %rax
movq 0x8070(%r13), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x58(%r13)
shlq $0x5, %rax
movq 0x40(%rsp), %rdx
movq %rdx, (%rcx,%rax)
movq 0xe0(%rsp), %rdx
movq %rdx, 0x8(%rcx,%rax)
movq %r14, 0x10(%rcx,%rax)
movq %r14, 0x18(%rcx,%rax)
movq 0x58(%r13), %rax
cmpq %rax, 0x50(%r13)
jae 0x2c1c6f
movq %rax, 0x50(%r13)
movq 0x28(%r13), %r14
leaq 0x70(%r13), %rcx
movq %rcx, 0x88(%rsp)
movq %r14, 0x68(%rsp)
testq %rax, %rax
je 0x2c22d5
movq 0x8070(%r13), %rcx
decq %rax
movq %rax, 0x58(%r13)
shlq $0x5, %rax
movq (%rcx,%rax), %r15
movq 0x8(%rcx,%rax), %rbx
movq 0x10(%rcx,%rax), %rdx
movq %rdx, 0x48(%rsp)
movq 0x18(%rcx,%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%r13), %rdx
movq 0x28(%r13), %rdi
xorl %esi, %esi
callq 0x17380
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x2c1cfb
movq (%r15,%r14,8), %rsi
movq (%r13), %rdi
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
movq 0x48(%rsp), %rdx
callq 0x2c246a
movq 0x38(%r13), %rcx
movw %ax, (%rcx,%r14,2)
incq %r14
jmp 0x2c1cce
movq 0x28(%r13), %rax
xorl %ecx, %ecx
movq 0x68(%rsp), %r14
cmpq %rcx, %rbx
je 0x2c1d1c
movq 0x38(%r13), %rdx
movzwl (%rdx,%rcx,2), %edx
incq (%rax,%rdx,8)
incq %rcx
jmp 0x2c1d06
movq (%rax), %rcx
andq $0x0, (%r14)
pushq $0x1
popq %rdx
cmpq $0x401, %rdx            # imm = 0x401
je 0x2c1d44
addq -0x8(%r14,%rdx,8), %rcx
movq (%rax,%rdx,8), %rsi
movq %rcx, (%r14,%rdx,8)
incq %rdx
movq %rsi, %rcx
jmp 0x2c1d26
cmpq $0x1, 0xe0(%rsp)
jbe 0x2c23a6
movq (%r15), %rax
cmpq 0x8(%r15), %rax
jbe 0x2c1d87
movq %rbx, %rax
subq $0x1, %rax
jb 0x2c1db3
movq (%r15,%rax,8), %rcx
movq 0x30(%r13), %rdx
movq 0x38(%r13), %rsi
movzwl (%rsi,%rax,2), %esi
movq (%r14,%rsi,8), %rdi
leaq 0x1(%rdi), %r8
movq %r8, (%r14,%rsi,8)
movq %rcx, (%rdx,%rdi,8)
jmp 0x2c1d5f
xorl %eax, %eax
cmpq %rax, %rbx
je 0x2c1db3
movq (%r15,%rax,8), %rcx
movq 0x30(%r13), %rdx
movq 0x38(%r13), %rsi
movzwl (%rsi,%rax,2), %esi
movq (%r14,%rsi,8), %rdi
leaq 0x1(%rdi), %r8
movq %r8, (%r14,%rsi,8)
movq %rcx, (%rdx,%rdi,8)
incq %rax
jmp 0x2c1d89
movq 0x30(%r13), %rsi
leaq (,%rbx,8), %rdx
movq %r15, %rdi
callq 0x17630
movq 0x48(%rsp), %rax
cmpq 0x10(%r13), %rax
jae 0x2c22cc
testq %r12, %r12
movq %rax, %rcx
setne %al
addq $0x4, %rcx
movq %rcx, 0x50(%rsp)
cmpq %r12, %rcx
seta %cl
andb %al, %cl
movb %cl, 0xf(%rsp)
leaq (%r15,%rbx,8), %rax
movq %rax, 0x60(%rsp)
movw $0x400, %ax             # imm = 0x400
xorl %ecx, %ecx
movq 0x10(%rsp), %rbx
testq %rcx, %rcx
je 0x2c1e25
cmpq $0x401, %rcx            # imm = 0x401
je 0x2c22c1
movq (%r14,%rcx,8), %rbp
subq -0x8(%r14,%rcx,8), %rbp
jmp 0x2c1e28
movq (%r14), %rbp
testq %rbp, %rbp
je 0x2c1f54
movq %r15, %rdx
subq 0x40(%rsp), %rdx
sarq $0x3, %rdx
movq %rdx, 0x18(%rsp)
testq %rbx, %rbx
movq %rcx, 0x28(%rsp)
je 0x2c1ea6
cmpw $0x400, %ax             # imm = 0x400
je 0x2c1e72
movzwl %ax, %esi
movzwl %cx, %edx
movq %r13, %rdi
callq 0x2c2598
movq 0x28(%rsp), %rcx
movzwl %ax, %eax
addq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq 0x40(%rsp), %r15
je 0x2c1ea6
movq 0x38(%rsp), %rax
cmpq %r12, %rax
movq %r12, %rcx
cmovbq %rax, %rcx
testq %r12, %r12
cmoveq %rax, %rcx
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2c25d7
movq 0x28(%rsp), %rcx
testb $0x3, %cl
sete %al
cmpq $0x400, %rcx            # imm = 0x400
setne %cl
testb %al, %cl
jne 0x2c1f2e
cmpq $0x1, %rbp
je 0x2c1ed0
pushq $0x6
popq %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x9cd4c
testq %rbx, %rbx
je 0x2c1f34
movq 0x28(%rsp), %rcx
movl %ecx, %eax
andl $0x3, %eax
cmpq $0x400, %rcx            # imm = 0x400
pushq $0x4
popq %rcx
cmoveq %rcx, %rax
movq 0x50(%rsp), %rcx
subq %rax, %rcx
cmpq %r12, %rcx
movq %r12, %r14
cmovbq %rcx, %r14
testq %r12, %r12
cmoveq %rcx, %r14
pushq $0x1
popq %rbx
cmpq %rbp, %rbx
jae 0x2c1f34
movq 0x18(%rsp), %rax
leaq (%rax,%rbx), %rdx
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %r14, %rcx
callq 0x2c25d7
incq %rbx
jmp 0x2c1f09
cmpq $0x1, %rbp
jne 0x2c1f5c
leaq (%r15,%rbp,8), %r15
movq 0x28(%rsp), %rcx
movl %ecx, %eax
cmpq 0x60(%rsp), %r15
movq 0x10(%rsp), %rbx
movq 0x68(%rsp), %r14
ja 0x2c2375
incq %rcx
jmp 0x2c1e08
cmpb $0x0, 0xf(%rsp)
je 0x2c1f93
cmpq $0x0, 0x10(%rsp)
je 0x2c1f34
pushq $0x1
popq %rbx
cmpq %rbp, %rbx
jae 0x2c1f34
movq 0x18(%rsp), %rax
leaq (%rax,%rbx), %rdx
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %r12, %rcx
callq 0x2c25d7
incq %rbx
jmp 0x2c1f6e
cmpq $0x1f, %rbp
ja 0x2c21d7
movq 0x18(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
pushq $0x1
popq %rax
movq %r15, 0x98(%rsp)
movq %rbp, 0x90(%rsp)
cmpq %rbp, %rax
jae 0x2c1f34
movq %rax, %rdx
movq %rax, 0x20(%rsp)
movq %rax, 0x70(%rsp)
subq $0x1, %rdx
jb 0x2c21cf
movq %rdx, 0xa0(%rsp)
movq (%r15,%rdx,8), %rcx
movq 0x20(%rsp), %rax
movq (%r15,%rax,8), %rax
xorl %ebx, %ebx
movq %rcx, 0x80(%rsp)
movq %rax, 0x78(%rsp)
cmpq %rax, %rcx
movl $0x0, %eax
sbbl %eax, %eax
orl $0x1, %eax
movl %eax, 0x5c(%rsp)
movq 0x50(%rsp), %rbp
testq %r12, %r12
je 0x2c2027
cmpq %r12, %rbp
ja 0x2c20d6
testl %ebx, %ebx
jne 0x2c20d6
movq %r12, %r14
movq (%r13), %rdi
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
movq 0x80(%rsp), %rsi
movq %rbp, %rdx
callq 0x2c246a
movl %eax, %r12d
movq (%r13), %rdi
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
movq 0x78(%rsp), %rsi
movq %rbp, %rdx
callq 0x2c246a
movzwl %r12w, %ebx
movzwl %ax, %r15d
movq %r13, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x2c2598
movzwl %ax, %ecx
addq %rcx, %rbp
cmpw %r15w, %bx
jne 0x2c20ba
testb $0x3, %r12b
setne %cl
cmpw $0x400, %r12w           # imm = 0x400
sete %dl
orb %cl, %dl
movl 0x5c(%rsp), %ebx
jne 0x2c20c4
movl $0x0, %ebx
cmpw $0x4, %ax
movq %r14, %r12
je 0x2c2019
jmp 0x2c22e7
movl $0x0, %ebx
sbbl %ebx, %ebx
orl $0x1, %ebx
cmpw $0x4, %ax
movq %r14, %r12
jb 0x2c2019
jmp 0x2c22e7
cmpq $0x0, 0x10(%rsp)
je 0x2c218a
movq 0x20(%rsp), %rax
cmpq 0x70(%rsp), %rax
jae 0x2c2165
testl %ebx, %ebx
jle 0x2c2165
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x2c231f
movq 0x20(%rdx), %rsi
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdi
addq %rdi, %rcx
addq %rsi, %rcx
cmpq 0x10(%rdx), %rcx
jae 0x2c231f
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x2c2142
movq %rcx, %rdi
shrq $0x6, %rdi
movq (%rdx,%rdi,8), %rdx
shlq %cl, %rdx
shrq $0x3f, %rdx
je 0x2c2349
movq 0x20(%rsp), %rcx
leaq 0x1(%rcx), %rdx
leaq (%rax,%rsi,4), %rax
movq 0x18(%rsp), %rsi
leaq (%rax,%rsi,4), %rax
movl (%rax,%rcx,4), %ecx
movq 0x10(%rsp), %rdi
callq 0x2c25d7
cmpq %r12, %rbp
movq %r12, %rcx
cmovbq %rbp, %rcx
testq %r12, %r12
cmoveq %rbp, %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2c25d7
testl %ebx, %ebx
movq 0x98(%rsp), %r15
movq 0x90(%rsp), %rbp
movq 0x70(%rsp), %rax
movq 0xa0(%rsp), %rdx
js 0x2c21cf
movq 0x78(%rsp), %rcx
movq %rcx, (%r15,%rdx,8)
movq 0x20(%rsp), %rcx
movq 0x80(%rsp), %rsi
movq %rsi, (%r15,%rcx,8)
movq %rdx, 0x20(%rsp)
jmp 0x2c1fd5
incq %rax
jmp 0x2c1fbf
movq 0x58(%r13), %rsi
cmpq 0x48(%r13), %rsi
jne 0x2c227a
cmpq 0x60(%r13), %rsi
jne 0x2c21ef
xorl %edi, %edi
jmp 0x2c21f6
movq 0x8070(%r13), %rdi
addq 0x68(%r13), %rsi
shlq $0x5, %rsi
leaq 0xc2735(%rip), %rdx     # 0x38493a
movl $0x1f8, %ecx            # imm = 0x1F8
callq 0x93472
movq %rax, 0x8070(%r13)
movq 0x48(%r13), %rdx
cmpq 0x60(%r13), %rdx
jne 0x2c2234
shlq $0x5, %rdx
movq %rax, %rdi
movq 0x88(%rsp), %rsi
callq 0x17630
cmpq $0x0, 0x8078(%r13)
je 0x2c226e
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x68(%r13), %rax
cmpq %rax, %r14
jae 0x2c2272
movq 0x48(%r13), %rdi
shlq $0x5, %rdi
addq 0x8070(%r13), %rdi
addq %rbx, %rdi
callq *0x8078(%r13)
incq %r14
addq $0x20, %rbx
jmp 0x2c2243
movq 0x68(%r13), %rax
addq %rax, 0x48(%r13)
movq 0x58(%r13), %rsi
movq 0x8070(%r13), %rax
leaq 0x1(%rsi), %rcx
movq %rcx, 0x58(%r13)
shlq $0x5, %rsi
movq %r15, (%rax,%rsi)
movq %rbp, 0x8(%rax,%rsi)
movq 0x50(%rsp), %rcx
movq %rcx, 0x10(%rax,%rsi)
movq 0x38(%rsp), %rcx
movq %rcx, 0x18(%rax,%rsi)
movq 0x58(%r13), %rax
cmpq %rax, 0x50(%r13)
jae 0x2c1f34
movq %rax, 0x50(%r13)
jmp 0x2c1f34
cmpq %r15, 0x60(%rsp)
jne 0x2c23d7
movq 0x58(%r13), %rax
jmp 0x2c1c84
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x175c7a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d1b(%rip), %rsi     # 0x2e5013
leaq 0xc27dd(%rip), %rdx     # 0x384adc
leaq 0xc2844(%rip), %rcx     # 0x384b4a
leaq 0xc262d(%rip), %r8      # 0x38493a
movl $0x149, %r9d            # imm = 0x149
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x175c42(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22ce3(%rip), %rsi     # 0x2e5013
leaq 0x939b7(%rip), %rdx     # 0x355cee
leaq 0x93a4d(%rip), %rcx     # 0x355d8b
leaq 0x93a59(%rip), %r8      # 0x355d9e
pushq $0x5b
jmp 0x2c2371
movq 0x175c18(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22cb9(%rip), %rsi     # 0x2e5013
leaq 0x93a57(%rip), %rdx     # 0x355db8
leaq 0x93a23(%rip), %rcx     # 0x355d8b
leaq 0x93a2f(%rip), %r8      # 0x355d9e
pushq $0x5e
popq %r9
jmp 0x2c2313
movq 0x175bec(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22c8d(%rip), %rsi     # 0x2e5013
leaq 0xc266e(%rip), %rdx     # 0x3849fb
leaq 0xc2632(%rip), %rcx     # 0x3849c6
leaq 0xc259f(%rip), %r8      # 0x38493a
movl $0x209, %r9d            # imm = 0x209
jmp 0x2c2313
movq 0x175bbb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22c5c(%rip), %rsi     # 0x2e5013
leaq 0x938c1(%rip), %rdx     # 0x355c7f
leaq 0xc2601(%rip), %rcx     # 0x3849c6
leaq 0xc256e(%rip), %r8      # 0x38493a
movl $0x198, %r9d            # imm = 0x198
jmp 0x2c2313
movq 0x175b8a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22c2b(%rip), %rsi     # 0x2e5013
leaq 0xc2641(%rip), %rdx     # 0x384a30
leaq 0xc25d0(%rip), %rcx     # 0x3849c6
leaq 0xc253d(%rip), %r8      # 0x38493a
movl $0x20d, %r9d            # imm = 0x20D
jmp 0x2c2313
movq 0x175b59(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22bfa(%rip), %rsi     # 0x2e5013
leaq 0xc2534(%rip), %rdx     # 0x384954
leaq 0xc259f(%rip), %rcx     # 0x3849c6
leaq 0xc250c(%rip), %r8      # 0x38493a
movl $0x16e, %r9d            # imm = 0x16E
jmp 0x2c2313
movq 0x175b28(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22bc9(%rip), %rsi     # 0x2e5013
leaq 0xc258c(%rip), %rdx     # 0x3849dd
leaq 0xc256e(%rip), %rcx     # 0x3849c6
leaq 0xc24db(%rip), %r8      # 0x38493a
movl $0x174, %r9d            # imm = 0x174
jmp 0x2c2313