LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_spacelog_addentry
static void gt_spacelog_addentry(GtFirstcodesspacelog *fcsl,
                                 const char *filename,int line,
                                 const char *title,size_t size,
                                 bool work)
{
  gt_assert(fcsl->nextfree <= fcsl->allocated);
  if (fcsl->nextfree == fcsl->allocated)
  {
    fcsl->allocated += 16UL;
    fcsl->entries = gt_realloc(fcsl->entries,sizeof (*fcsl->entries) *
                                             fcsl->allocated);
  }
  gt_spacelog_updateaddentry(fcsl->entries + fcsl->nextfree,
                             filename,line,title,size,work);
  fcsl->nextfree++;
}

// Assembly:
subq $0x38, %rsp
movb %r9b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x4bf051
movq 0x17cf80(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x56fe9(%rip), %rsi     # 0x516013
leaq 0xf8c63(%rip), %rdx     # 0x5b7c94
leaq 0xf8c7e(%rip), %rcx     # 0x5b7cb6
leaq 0xf8ab7(%rip), %r8      # 0x5b7af6
movl $0x77, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4bf053
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x4bf0a8
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x38(%rax)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rsp), %rax
imulq $0x28, 0x38(%rax), %rsi
leaq 0xf8a64(%rip), %rdx     # 0x5b7af6
movl $0x7c, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rsp), %rax
imulq $0x28, 0x30(%rax), %rax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x4bef70
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_updatemax
static void gt_firstcodes_updatemax(GtFirstcodesspacelog *fcsl)
{
  if (fcsl->workspace + fcsl->splitspace > fcsl->spacepeak)
  {
    fcsl->spacepeak = fcsl->workspace + fcsl->splitspace;
    gt_log_log("update spacepeak to %.2f MB",
               GT_MEGABYTES(fcsl->spacepeak));
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
addq 0x8(%rcx), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x4bf175
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %xmm0
movaps 0x597f0(%rip), %xmm1    # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x597f4(%rip), %xmm1    # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x597bd(%rip), %xmm1    # 0x518920
divsd %xmm1, %xmm0
leaq 0xf8b5d(%rip), %rdi     # 0x5b7ccb
movb $0x1, %al
callq 0xe7740
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_subtract_error
static void gt_firstcodes_subtract_error(const char *title,
                                         const char *filename,
                                         int line,
                                         size_t size,
                                         bool work,
                                         size_t sumspace)
{
  fprintf(stderr,"for title \"%s\" (from file %s, line %d) "
                 "in spacelog entries: "
                 "size="GT_WU" > "GT_WU"=%sspace\n",title,filename,line,
                 (GtUword) size,(GtUword) sumspace,
                 work ? "work" : "split");
}

// Assembly:
subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %r9, 0x18(%rsp)
movq 0x17cdf4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %r10
movb 0x27(%rsp), %r11b
leaq 0x575a4(%rip), %rax     # 0x516778
leaq 0xf894c(%rip), %rsi     # 0x5b7b27
testb $0x1, %r11b
cmovneq %rsi, %rax
leaq 0xf8afd(%rip), %rsi     # 0x5b7ce7
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x199f0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_new
static void gt_firstcodes_countocc_new(GtFirstcodesspacelog *fcsl,
                                       GtFirstcodestab *fct,
                                       unsigned int bitsforcount,
                                       GtUword numofsequences)
{
  if (bitsforcount < (unsigned int) (sizeof (GtCountAFCtype) * CHAR_BIT))
  {
    fct->countocc_small = gt_malloc((size_t) (numofsequences+1) *
                                    sizeof (*fct->countocc_small));
    GT_FCI_ADDWORKSPACE(fcsl,"countocc_small",
                        sizeof (*fct->countocc_small) *
                        (numofsequences+1));
  } else
  {
    fct->countocc_small = NULL;
  }
  fct->countocc_exceptions = ul_u32_gt_hashmap_new();
  gt_assert(fct->countocc_exceptions != NULL);
  fct->outfilenameleftborder = NULL;
  fct->leftborder_samples = NULL;
#if defined (_LP64) || defined (_WIN64)
  GT_INITARRAY(&fct->bitchangepoints,GtUword);
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
cmpl $0x8, 0x14(%rsp)
jae 0x4bf961
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0xf847c(%rip), %rsi     # 0x5b7d8e
movl $0x2b, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
addq $0x1, %rax
shlq $0x0, %rax
movl $0x2e, %esi
leaq 0xf8448(%rip), %rdx     # 0x5b7d8e
movl $0x1, %r9d
leaq 0xf873f(%rip), %r8      # 0x5b8092
movl %r9d, %ecx
movq %rax, (%rsp)
callq 0x4bea60
jmp 0x4bf96e
movq 0x18(%rsp), %rax
movq $0x0, 0x38(%rax)
callq 0x4c1270
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x4bf9c3
movq 0x17c60e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x56677(%rip), %rsi     # 0x516013
leaq 0xf87f6(%rip), %rdx     # 0x5b8199
leaq 0xf8810(%rip), %rcx     # 0x5b81ba
leaq 0xf83dd(%rip), %r8      # 0x5b7d8e
movl $0x34, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4bf9c5
movq 0x18(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x70(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x80(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x78(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_set
static void gt_firstcodes_countocc_set(GtFirstcodestab *fct,
                                       GtUword *differences,
                                       GtUword idx,
                                       GtUword value)
{
  gt_assert(value > 0);
  if (fct->countocc_small == NULL)
  {
    if (value <= fct->countmax)
    {
      differences[idx] |= (value << fct->shiftforcounts);
    } else
    {
      differences[idx] &= fct->differencemask;
      ul_u32_gt_hashmap_add(fct->countocc_exceptions,idx,
                            (uint32_t) (value - fct->countmax));
      fct->hashmap_addcount++;
    }
  } else
  {
    if (value <= GT_FIRSTCODES_MAXSMALL)
    {
      fct->countocc_small[idx] = (GtCountAFCtype) value;
    } else
    {
      fct->countocc_small[idx] = 0;
      ul_u32_gt_hashmap_add(fct->countocc_exceptions,idx,
                            value - GT_FIRSTCODES_MAXSMALL);
      fct->hashmap_addcount++;
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
ja 0x4bfa68
movq 0x17c569(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x565d2(%rip), %rsi     # 0x516013
leaq 0x71521(%rip), %rdx     # 0x530f69
leaq 0xf8786(%rip), %rcx     # 0x5b81d5
leaq 0xf8338(%rip), %r8      # 0x5b7d8e
movl $0x41, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4bfa6a
movq 0x20(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x4bfb01
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x60(%rcx), %rax
ja 0x4bfab0
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movl 0x68(%rax), %eax
movl %eax, %ecx
shlq %cl, %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x4bfaff
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
subq 0x60(%rcx), %rax
movl %eax, %edx
callq 0x4c12c0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x4bfb6b
cmpq $0xff, 0x8(%rsp)
ja 0x4bfb26
movq 0x8(%rsp), %rax
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4bfb69
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
subq $0xff, %rax
movl %eax, %edx
callq 0x4c12c0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x4bfb6b
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_get
static uint32_t gt_firstcodes_countocc_get(const GtFirstcodestab *fct,
                                           const GtUword *differences,
                                           GtUword idx)
{
  if (fct->countocc_small == NULL)
  {
    GtUword count;

    if ((count = (GtUword) (differences[idx] >> fct->shiftforcounts)) > 0)
    {
      return (uint32_t) count;
    } else
    {
      uint32_t *valueptr = ul_u32_gt_hashmap_get(fct->countocc_exceptions,idx);

      gt_assert(valueptr != NULL);
      return *valueptr + (uint32_t) fct->countmax;
    }
  } else
  {
    if (fct->countocc_small[idx] > 0)
    {
      return (uint32_t) fct->countocc_small[idx];
    } else
    {
      uint32_t *valueptr = ul_u32_gt_hashmap_get(fct->countocc_exceptions,idx);

      gt_assert(valueptr != NULL);
      return *valueptr + (uint32_t) GT_FIRSTCODES_MAXSMALL;
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x4c0c4a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movl 0x68(%rcx), %ecx
shrq %cl, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jbe 0x4c0bd5
movq 0x10(%rsp), %rax
movl %eax, 0x34(%rsp)
jmp 0x4c0ce0
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x4c1310
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4c0c2d
movq 0x17b3a4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5540d(%rip), %rsi     # 0x516013
leaq 0xf7636(%rip), %rdx     # 0x5b8243
leaq 0xf7640(%rip), %rcx     # 0x5b8254
leaq 0xf7173(%rip), %r8      # 0x5b7d8e
movl $0x1a6, %r9d            # imm = 0x1A6
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c0c2f
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq 0x28(%rsp), %rcx
movq 0x60(%rcx), %rcx
addl %ecx, %eax
movl %eax, 0x34(%rsp)
jmp 0x4c0ce0
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jle 0x4c0c79
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x34(%rsp)
jmp 0x4c0ce0
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x4c1310
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4c0ccf
movq 0x17b302(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5536b(%rip), %rsi     # 0x516013
leaq 0xf7594(%rip), %rdx     # 0x5b8243
leaq 0xf759e(%rip), %rcx     # 0x5b8254
leaq 0xf70d1(%rip), %r8      # 0x5b7d8e
movl $0x1b2, %r9d            # imm = 0x1B2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c0cd1
movq (%rsp), %rax
movl (%rax), %eax
addl $0xff, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_get_leftborder
GtUword gt_firstcodes_get_leftborder(const GtFirstcodestab *fct,
                                           GtUword idx)
{
#if defined (_LP64) || defined (_WIN64)
  GT_CHANGEPOINT_GET(changepoint);

  return (GtUword) fct->leftborder[idx]
                         + (changepoint << GT_MODVALUEBITS);
#else
  return (GtUword) fct->leftborder[idx];
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpq 0x80(%rdx), %rcx
movb %al, -0x19(%rsp)
jae 0x4c0dca
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x70(%rcx), %rcx
movq -0x18(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
seta %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %al
testb $0x1, %al
jne 0x4c0dd4
jmp 0x4c0de4
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x4c0d93
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rsp), %rcx
shlq $0x20, %rcx
addq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_findfirstsamplelarger
GtUword gt_firstcodes_findfirstsamplelarger(const GtFirstcodestab *fct,
                                                  GtUword suftaboffset)
{
  GtUword left = 0, right, mid, midval, found;

  right = found = fct->numofsamples;
  while (left+1 < right)
  {
    mid = GT_DIV2(left+right);
    midval = gt_firstcodes_get_sample(fct,mid);
    if (suftaboffset == midval)
    {
      return mid;
    }
    if (suftaboffset < midval)
    {
      found = mid;
      right = mid - 1;
    } else
    {
      left = mid + 1;
    }
  }
  gt_assert(suftaboffset <= gt_firstcodes_get_sample(fct,found));
  return found;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
cmpq 0x20(%rsp), %rax
jae 0x4c0ed4
movq 0x28(%rsp), %rax
addq 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4c0d10
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x4c0e9b
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x4c0f3e
movq 0x30(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x4c0ec1
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4c0ecf
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x4c0e4a
jmp 0x4c0ed6
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4c0d10
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jbe 0x4c0f32
movq 0x17b09f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x55108(%rip), %rsi     # 0x516013
leaq 0xf7215(%rip), %rdx     # 0x5b8127
leaq 0xf7242(%rip), %rcx     # 0x5b815b
leaq 0xf6e6e(%rip), %r8      # 0x5b7d8e
movl $0x286, %r9d            # imm = 0x286
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c0f34
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_sample2full
GtUword gt_firstcodes_sample2full(const GtFirstcodestab *fct,
                                        GtUword idx)
{
  gt_assert(idx <= fct->numofsamples);
  if (idx < fct->numofsamples)
  {
    return (GtUword) idx << (GtUword) fct->sampleshift;
  }
  return fct->differentcodes - 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4c0fa4
movq 0x17b02d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x55096(%rip), %rsi     # 0x516013
leaq 0xf7171(%rip), %rdx     # 0x5b80f5
leaq 0xf71f4(%rip), %rcx     # 0x5b817f
leaq 0xf6dfc(%rip), %r8      # 0x5b7d8e
movl $0x28d, %r9d            # imm = 0x28D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c0fa6
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4c0fcb
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x28(%rcx), %ecx
shlq %cl, %rax
movq %rax, 0x10(%rsp)
jmp 0x4c0fdc
movq 0x8(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_samples_delete
void gt_firstcodes_samples_delete(GtFirstcodesspacelog *fcsl,
                                  GtFirstcodestab *fct)
{
  if (fct->leftborder_samples != NULL)
  {
    gt_free(fct->leftborder_samples);
    GT_FCI_SUBTRACTWORKSPACE(fcsl,"leftborder_samples");
    fct->leftborder_samples = NULL;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4c1060
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0xf6d74(%rip), %rsi     # 0x5b7d8e
movl $0x29a, %edx            # imm = 0x29A
callq 0xe88c0
movq 0x10(%rsp), %rdi
movl $0x29b, %esi            # imm = 0x29B
leaq 0xf6d59(%rip), %rdx     # 0x5b7d8e
xorl %ecx, %ecx
leaq 0xf6f2e(%rip), %r8      # 0x5b7f6c
movl $0x1, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x4bea60
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_delete
void gt_firstcodes_countocc_delete(GtFirstcodesspacelog *fcsl,
                                   GtFirstcodestab *fct)
{
  if (fct->countocc_small != NULL)
  {
    GT_FCI_SUBTRACTWORKSPACE(fcsl,"countocc_small");
    gt_free(fct->countocc_small);
    fct->countocc_small = NULL;
  }
  gt_hashtable_delete(fct->countocc_exceptions);
  fct->countocc_exceptions = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x4c10e0
movq 0x10(%rsp), %rdi
movl $0x2a5, %esi            # imm = 0x2A5
leaq 0xf6cf3(%rip), %rdx     # 0x5b7d8e
xorl %ecx, %ecx
leaq 0xf6fee(%rip), %r8      # 0x5b8092
movl $0x1, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x4bea60
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0xf6cc5(%rip), %rsi     # 0x5b7d8e
movl $0x2a6, %edx            # imm = 0x2A6
callq 0xe88c0
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0xe3360
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_tab_delete
void gt_firstcodes_tab_delete(GtFirstcodesspacelog *fcsl,GtFirstcodestab *fct)
{
  gt_firstcodes_samples_delete(fcsl,fct);
  gt_str_delete(fct->outfilenameleftborder);
  fct->outfilenameleftborder = NULL;
#if defined (_LP64) || defined (_WIN64)
  GT_FREEARRAY(&fct->bitchangepoints,GtUword);
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4c0ff0
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x4c1188
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rdi
leaq 0xf6c3a(%rip), %rsi     # 0x5b7d8e
movl $0x2b3, %edx            # imm = 0x2B3
callq 0xe88c0
movq 0x8(%rsp), %rax
movq $0x0, 0x78(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x80(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x70(%rax)
jmp 0x4c118a
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_setnull
void gt_firstcodes_countocc_setnull(GtFirstcodestab *fct)
{
  fct->leftborder = NULL;
  fct->countocc_small = NULL;
  fct->leftborder_samples = NULL;
  fct->countocc_exceptions = NULL;
  fct->differentcodes = 0;
  fct->hashmap_addcount = 0;
  fct->hashmap_getcount = 0;
  fct->outfilenameleftborder = NULL;
#if defined (_LP64) || defined (_WIN64)
  GT_INITARRAY(&fct->bitchangepoints,GtUword);
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x80(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x78(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-keyval.c
// Function: gt_determinenumberofspecialstostore
GtUword gt_determinenumberofspecialstostore(const GtSpecialcharinfo
                                                        *specialcharinfo)
{
  GtUword addprefixsuffix = 0;

  if (specialcharinfo->lengthofspecialprefix > 0)
  {
    addprefixsuffix++;
  }
  if (specialcharinfo->lengthofspecialsuffix > 0)
  {
    addprefixsuffix++;
  }
  return specialcharinfo->realspecialranges + 1 - addprefixsuffix;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x4c1388
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x4c13a2
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
subq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-keyval.c
// Function: determinefmindexsize
static GtUword determinefmindexsize (const Fmindex *fm,
                                           const GtSpecialcharinfo
                                              *specialcharinfo,
                                           unsigned int suffixlength,
                                           bool storeindexpos)
{
  uint64_t sumsize = 0;

  sumsize +=
          (uint64_t) sizeof (GtUword) * (uint64_t) TFREQSIZE(fm->mapsize);
  sumsize += (uint64_t) sizeof (GtUword) *
             (uint64_t) SUPERBFREQSIZE(fm->mapsize,fm->nofsuperblocks);
  if (storeindexpos)
  {
    sumsize += (uint64_t) sizeof (GtUword) *
               (uint64_t) MARKPOSTABLELENGTH(fm->bwtlength,fm->markdist);
  }
  if (suffixlength > 0)
  {
    sumsize += (uint64_t) sizeof (GtUwordBound) * (uint64_t) fm->numofcodes;
  }
  if (storeindexpos)
  {
    sumsize += (uint64_t) sizeof (GtPairBwtidx) *
               (uint64_t) gt_determinenumberofspecialstostore(specialcharinfo);
  }
  sumsize += (uint64_t) sizeof (GtUchar) *
             (uint64_t) BFREQSIZE(fm->mapsize,fm->nofblocks);
  return CALLCASTFUNC(uint64_t,unsigned_long,sumsize);
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x78(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x78(%rax), %eax
movq 0x20(%rsp), %rcx
imulq 0xb0(%rcx), %rax
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x13(%rsp)
je 0x4c16b5
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movq 0x20(%rsp), %rcx
xorl %edx, %edx
divq 0xb8(%rcx)
addq $0x1, %rax
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jbe 0x4c16d6
movq 0x20(%rsp), %rax
movq 0xc0(%rax), %rax
shlq $0x4, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x13(%rsp)
je 0x4c16f5
movq 0x18(%rsp), %rdi
callq 0x4c1360
shlq $0x4, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x78(%rax), %eax
movq 0x20(%rsp), %rcx
imulq 0xa8(%rcx), %rax
shlq $0x0, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdx
leaq 0xf6b4b(%rip), %rdi     # 0x5b826f
movl $0x45, %esi
callq 0x4c1740
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_pretty_print
char gt_eoplist_pretty_print(GtEopType eoptype,bool distinguish_mismatch_match)
{
  switch (eoptype)
  {
    case GtDeletionOp:
      return DELETION_CHAR;
    case GtInsertionOp:
      return INSERTION_CHAR;
    case GtMismatchOp:
      return distinguish_mismatch_match ? MISMATCH_CHAR : REPLACEMENT_CHAR;
    case GtMatchOp:
      return distinguish_mismatch_match ? MATCH_CHAR : REPLACEMENT_CHAR;
    default:
      fprintf(stderr,"file %s, line %d: illegal eoptype = %d\n",
              __FILE__,__LINE__,(int) eoptype);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movl %edi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movl 0x10(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x4c17d5
movq (%rsp), %rax
leaq 0xf6afe(%rip), %rcx     # 0x5b8288
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x44, 0x17(%rsp)
jmp 0x4c1808
movb $0x49, 0x17(%rsp)
jmp 0x4c1808
movb 0xf(%rsp), %dl
movl $0x4d, %eax
movl $0x58, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, 0x17(%rsp)
jmp 0x4c1808
movb 0xf(%rsp), %dl
movl $0x4d, %eax
movl $0x3d, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, 0x17(%rsp)
jmp 0x4c1808
movq 0x17a7c4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movl 0x10(%rsp), %r8d
leaq 0xf6b25(%rip), %rsi     # 0x5b8310
leaq 0xf6b46(%rip), %rdx     # 0x5b8338
movl $0x25, %ecx
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reset
void gt_eoplist_reset(GtEoplist *eoplist)
{
  if (eoplist != NULL)
  {
    eoplist->nextfreeuint8_t = 0;
    eoplist->countdeletions = 0;
    eoplist->countinsertions = 0;
    eoplist->useq = eoplist->vseq = NULL;
    eoplist->ulen = eoplist->vlen = 0;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x4c1887
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_new
GtEoplist *gt_eoplist_new(void)
{
  GtEoplist *eoplist = gt_malloc(sizeof *eoplist);

  gt_assert(eoplist != NULL);
  eoplist->allocateduint8_t = 0;
  eoplist->spaceuint8_t = NULL;
  eoplist->display_seed_in_alignment = false;
  eoplist->withpolcheck = false;
  eoplist->pol_info_out = false;
  eoplist->useedoffset = eoplist->seedlen = 0;
  eoplist->pol_info = NULL;
  GT_INITARRAY(&eoplist->trace,int);
  eoplist->fet_segment = gt_full_front_edist_trace_new();
  gt_eoplist_reset(eoplist);
  return eoplist;
}

// Assembly:
pushq %rax
movl $0x98, %edi
leaq 0xf6a9b(%rip), %rsi     # 0x5b8338
movl $0x45, %edx
callq 0xe80f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4c18ea
movq 0x17a6e7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x54750(%rip), %rsi     # 0x516013
leaq 0x85609(%rip), %rdx     # 0x546ed3
leaq 0xf6a7e(%rip), %rcx     # 0x5b834f
leaq 0xf6a60(%rip), %r8      # 0x5b8338
movl $0x47, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c18ec
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movb $0x0, 0x5a(%rax)
movq (%rsp), %rax
movb $0x0, 0x58(%rax)
movq (%rsp), %rax
movb $0x0, 0x59(%rax)
movq (%rsp), %rax
movq $0x0, 0x68(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movq $0x0, 0x88(%rax)
movq (%rsp), %rax
movq $0x0, 0x70(%rax)
movq (%rsp), %rax
movq $0x0, 0x80(%rax)
movq (%rsp), %rax
movq $0x0, 0x78(%rax)
callq 0x4cfbc0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rdi
callq 0x4c1820
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist2cigar_string
char *gt_eoplist2cigar_string(const GtEoplist *eoplist,
                              bool distinguish_mismatch_match)
{
  GtStringBuffer sbuf = {NULL,0,0};
  GtCigarOp co;
  GtEoplistReader *eoplist_reader = gt_eoplist_reader_new();

  gt_eoplist_reader_reset(eoplist_reader,eoplist,true);
  while (gt_eoplist_reader_next_cigar(&co,eoplist_reader,
                                      distinguish_mismatch_match))
  {
    stringbuffer_append_cigar(&sbuf,&co,distinguish_mismatch_match);
  }
  gt_eoplist_reader_delete(eoplist_reader);
  return sbuf.space;
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x19360
callq 0x4c1a20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl $0x1, %edx
callq 0x4c1b40
movq 0x8(%rsp), %rsi
movb 0x3f(%rsp), %al
leaq 0x10(%rsp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x4c1c90
testb $0x1, %al
jne 0x4c19ef
jmp 0x4c1a09
movb 0x3f(%rsp), %al
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
andb $0x1, %al
movzbl %al, %edx
callq 0x4c2110
jmp 0x4c19d1
movq 0x8(%rsp), %rdi
callq 0x4c2280
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_new
GtEoplistReader *gt_eoplist_reader_new(void)
{
  GtEoplistReader *eoplist_reader;

  eoplist_reader = gt_malloc(sizeof *eoplist_reader);
  gt_assert(eoplist_reader != NULL);
  eoplist_reader->width = 0;
  eoplist_reader->outbuffer = NULL;
  eoplist_reader->width = 70;
  eoplist_reader->outbuffer
    = gt_realloc(eoplist_reader->outbuffer,
                 sizeof *eoplist_reader->outbuffer *
                 gt_eoplist_outbuffer_size(eoplist_reader->width));
  eoplist_reader->difference = 0;
  eoplist_reader->currenteop = NULL;
  eoplist_reader->endeoplist = NULL;
  eoplist_reader->aligned_u = eoplist_reader->aligned_v
                            = eoplist_reader->repcount = 0;
  return eoplist_reader;
}

// Assembly:
subq $0x18, %rsp
movl $0x40, %edi
leaq 0xf6908(%rip), %rsi     # 0x5b8338
movl $0x14e, %edx            # imm = 0x14E
callq 0xe80f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4c1a7f
movq 0x17a552(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x545bb(%rip), %rsi     # 0x516013
leaq 0xf6a45(%rip), %rdx     # 0x5b84a4
leaq 0xf6aad(%rip), %rcx     # 0x5b8513
leaq 0xf68cb(%rip), %r8      # 0x5b8338
movl $0x14f, %r9d            # imm = 0x14F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c1a81
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movl $0x46, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %edi
callq 0x4c3260
movq 0x8(%rsp), %rdi
movq %rax, %rsi
shlq $0x0, %rsi
leaq 0xf6864(%rip), %rdx     # 0x5b8338
movl $0x156, %ecx            # imm = 0x156
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_reset
void gt_eoplist_reader_reset(GtEoplistReader *eoplist_reader,
                             const GtEoplist *eoplist,bool forward)
{
  gt_assert(eoplist != NULL && eoplist_reader != NULL);
  if (eoplist->spaceuint8_t == NULL || eoplist->nextfreeuint8_t == 0)
  {
    eoplist_reader->currenteop = NULL;
    eoplist_reader->endeoplist = NULL;
  } else
  {
    if (forward)
    {
      eoplist_reader->currenteop = eoplist->spaceuint8_t;
      eoplist_reader->endeoplist = eoplist->spaceuint8_t +
                                   eoplist->nextfreeuint8_t;
      eoplist_reader->difference = 1;
    } else
    {
      eoplist_reader->currenteop = eoplist->spaceuint8_t +
                                   eoplist->nextfreeuint8_t - 1;
      eoplist_reader->endeoplist = eoplist->spaceuint8_t - 1;
      eoplist_reader->difference = -1;
    }
  }
  eoplist_reader->aligned_u = eoplist_reader->aligned_v
                            = eoplist_reader->repcount = 0;
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4c1b66
cmpq $0x0, 0x10(%rsp)
jne 0x4c1b9e
movq 0x17a433(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5449c(%rip), %rsi     # 0x516013
leaq 0xf6913(%rip), %rdx     # 0x5b8491
leaq 0xf6936(%rip), %rcx     # 0x5b84bb
leaq 0xf67ac(%rip), %r8      # 0x5b8338
movl $0x11f, %r9d            # imm = 0x11F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c1ba0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4c1bb7
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x4c1bd5
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x4c1c56
testb $0x1, 0x7(%rsp)
je 0x4c1c15
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
addq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x10(%rax)
jmp 0x4c1c54
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
addq (%rax), %rcx
addq $-0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
jmp 0x4c1c56
movq 0x10(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: stringbuffer_append_cigar
static void stringbuffer_append_cigar(GtStringBuffer *sbuf,
                                      const GtCigarOp *co,
                                      bool distinguish_mismatch_match)
{
  const size_t gt_uword_maxwidth = sizeof ("18446744073709551615");

  if (sbuf->nextfree + gt_uword_maxwidth + 1 + 1 >= sbuf->allocated)
  {
    sbuf->allocated = sbuf->allocated * 1.2 + gt_uword_maxwidth + 1 + 1 + 1;
    sbuf->space = gt_realloc(sbuf->space,sizeof *sbuf->space * sbuf->allocated);
  }
  sbuf->nextfree +=
    sprintf(sbuf->space + sbuf->nextfree,GT_WU "%c",
            co->iteration,gt_eoplist_pretty_print(co->eoptype,
                                                  distinguish_mismatch_match));
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq $0x15, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x15, %rax
addq $0x1, %rax
addq $0x1, %rax
movq 0x30(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x4c220b
movq 0x30(%rsp), %rax
movq 0x10(%rax), %xmm0
movaps 0x567cc(%rip), %xmm1    # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x567d0(%rip), %xmm1    # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x56be1(%rip), %xmm1    # 0x518d68
mulsd %xmm1, %xmm0
movsd 0xf6175(%rip), %xmm1    # 0x5b8308
addsd %xmm1, %xmm0
movsd 0x550a1(%rip), %xmm1    # 0x517240
addsd %xmm1, %xmm0
addsd %xmm1, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x56bae(%rip), %xmm1    # 0x518d70
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
shlq $0x0, %rsi
leaq 0xf6142(%rip), %rdx     # 0x5b8338
movl $0x64, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
addq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %edi
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4c1760
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movsbl %al, %ecx
leaq 0xbc0a0(%rip), %rsi     # 0x57e2f8
movb $0x0, %al
callq 0x19100
movslq %eax, %rcx
movq 0x30(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_delete
void gt_eoplist_reader_delete(GtEoplistReader *eoplist_reader)
{
  if (eoplist_reader != NULL)
  {
    if (eoplist_reader->outbuffer != NULL)
    {
      gt_free(eoplist_reader->outbuffer);
    }
    gt_free(eoplist_reader);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4c22c5
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4c22b0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0xf6092(%rip), %rsi     # 0x5b8338
movl $0x165, %edx            # imm = 0x165
callq 0xe88c0
movq (%rsp), %rdi
leaq 0xf607d(%rip), %rsi     # 0x5b8338
movl $0x167, %edx            # imm = 0x167
callq 0xe88c0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_delete
void gt_eoplist_delete(GtEoplist *eoplist)
{
  if (eoplist != NULL)
  {
    GT_FREEARRAY(&eoplist->trace,int);
    gt_full_front_edist_trace_delete(eoplist->fet_segment);
    gt_free(eoplist->spaceuint8_t);
    gt_free(eoplist);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4c2fdd
jmp 0x4c2f52
movq (%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x4c2f9d
movq (%rsp), %rax
movq 0x70(%rax), %rdi
leaq 0xf53cc(%rip), %rsi     # 0x5b8338
movl $0xb5, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x78(%rax)
movq (%rsp), %rax
movq $0x0, 0x80(%rax)
movq (%rsp), %rax
movq $0x0, 0x70(%rax)
jmp 0x4c2f9f
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x4cfc50
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0xf537a(%rip), %rsi     # 0x5b8338
movl $0xb7, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0xf5365(%rip), %rsi     # 0x5b8338
movl $0xb8, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reverse_end
void gt_eoplist_reverse_end(GtEoplist *eoplist,GtUword firstindex)
{
  uint8_t *fwd, *bck;

  gt_assert(eoplist != NULL);
  if (firstindex + 1 >= eoplist->nextfreeuint8_t)
  {
    return;
  }
  for (fwd = eoplist->spaceuint8_t + firstindex,
       bck = eoplist->spaceuint8_t + eoplist->nextfreeuint8_t - 1; fwd < bck;
       fwd++, bck--)
  {
    uint8_t tmp = *fwd;
    *fwd = *bck;
    *bck = tmp;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4c305e
movq 0x178f73(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x52fdc(%rip), %rsi     # 0x516013
leaq 0x83e95(%rip), %rdx     # 0x546ed3
leaq 0xf53fe(%rip), %rcx     # 0x5b8443
leaq 0xf52ec(%rip), %r8      # 0x5b8338
movl $0xf7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c3060
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x4c3075
jmp 0x4c30f0
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rsp), %rcx
addq (%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x4c30f0
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rax
movb (%rax), %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4c30a2
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_reset_width
void gt_eoplist_reader_reset_width(GtEoplistReader *eoplist_reader,
                                   unsigned int width)
{
  if (eoplist_reader->width < width)
  {
    eoplist_reader->outbuffer = gt_realloc(eoplist_reader->outbuffer,
                                           sizeof *eoplist_reader->outbuffer *
                                           gt_eoplist_outbuffer_size(width));
    gt_assert(eoplist_reader->outbuffer != NULL);
  }
  eoplist_reader->width = width;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
cmpl 0xc(%rsp), %eax
jae 0x4c3245
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %edi
callq 0x4c3260
movq (%rsp), %rdi
movq %rax, %rsi
shlq $0x0, %rsi
leaq 0xf5151(%rip), %rdx     # 0x5b8338
movl $0x144, %ecx            # imm = 0x144
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x4c3241
movq 0x178d90(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x52df9(%rip), %rsi     # 0x516013
leaq 0xf52b2(%rip), %rdx     # 0x5b84d3
leaq 0xf52cd(%rip), %rcx     # 0x5b84f5
leaq 0xf5109(%rip), %r8      # 0x5b8338
movl $0x145, %r9d            # imm = 0x145
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c3243
jmp 0x4c3245
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_show_plain
void gt_eoplist_show_plain(const GtEoplist *eoplist,FILE *fp)
{
  GtUword idx;

  fprintf(fp,"[");
  for (idx = 0; idx < eoplist->nextfreeuint8_t; idx++)
  {
    if (eoplist->spaceuint8_t[idx] == FT_EOPCODE_DELETION)
    {
      fputc(DELETION_CHAR,fp);
    } else
    {
      if (eoplist->spaceuint8_t[idx] == FT_EOPCODE_INSERTION)
      {
        fputc(INSERTION_CHAR,fp);
      } else
      {
        if (eoplist->spaceuint8_t[idx] == FT_EOPCODE_MISMATCH)
        {
          fputc(MISMATCH_CHAR,fp);
        } else
        {
          fprintf(fp,"%d",eoplist->spaceuint8_t[idx]);
        }
      }
    }
    fputc(idx + 1 < eoplist->nextfreeuint8_t ? ',' : ']',fp);
  }
  fputc('\n',fp);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0xd0570(%rip), %rsi     # 0x5941fa
movb $0x0, %al
callq 0x199f0
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x4c3d89
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xfe, %eax
jne 0x4c3cd4
movq 0x8(%rsp), %rsi
movl $0x44, %edi
callq 0x198d0
jmp 0x4c3d4e
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jne 0x4c3cfd
movq 0x8(%rsp), %rsi
movl $0x49, %edi
callq 0x198d0
jmp 0x4c3d4c
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xfd, %eax
jne 0x4c3d26
movq 0x8(%rsp), %rsi
movl $0x58, %edi
callq 0x198d0
jmp 0x4c3d4a
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0xd975f(%rip), %rsi     # 0x59d4a2
movb $0x0, %al
callq 0x199f0
jmp 0x4c3d4c
jmp 0x4c3d4e
movq (%rsp), %rcx
addq $0x1, %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movl $0x5d, %edi
movl $0x2c, %eax
cmpq %rdx, %rcx
cmovbl %eax, %edi
movq 0x8(%rsp), %rsi
callq 0x198d0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4c3c99
movq 0x8(%rsp), %rsi
movl $0xa, %edi
callq 0x198d0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_show_cigar
void gt_eoplist_show_cigar(GtEoplistReader *eoplist_reader,
                           bool distinguish_mismatch_match,FILE *fp)
{
  GtCigarOp co;

  while (gt_eoplist_reader_next_cigar(&co,eoplist_reader,
                                      distinguish_mismatch_match))
  {
    fprintf(fp,GT_WU "%c",co.iteration,
            gt_eoplist_pretty_print(co.eoptype,distinguish_mismatch_match));
  }
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rsi
movb 0x2f(%rsp), %al
leaq 0x10(%rsp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x4c1c90
testb $0x1, %al
jne 0x4c3dd5
jmp 0x4c3e16
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edi
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4c1760
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movsbl %al, %ecx
leaq 0xba4eb(%rip), %rsi     # 0x57e2f8
movb $0x0, %al
callq 0x199f0
jmp 0x4c3db7
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_set_sequences
void gt_eoplist_set_sequences(GtEoplist *eoplist,
                              const GtUchar *useq,
                              GtUword ustart,
                              GtUword ulen,
                              const GtUchar *vseq,
                              GtUword vstart,
                              GtUword vlen)
{
  gt_assert(eoplist != NULL);
  eoplist->useq = useq;
  eoplist->ustart = ustart;
  eoplist->ulen = ulen;
  eoplist->vseq = vseq;
  eoplist->vstart = vstart;
  eoplist->vlen = vlen;
}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x4c3e87
movq 0x17814a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x521b3(%rip), %rsi     # 0x516013
leaq 0x8306c(%rip), %rdx     # 0x546ed3
leaq 0xf48ed(%rip), %rcx     # 0x5b875b
leaq 0xf44c3(%rip), %r8      # 0x5b8338
movl $0x30e, %r9d            # imm = 0x30E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c3e89
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_polished_ends
void gt_eoplist_polished_ends(GtEoplist *eoplist,
                              const GtFtPolishing_info *pol_info,
                              bool withpolcheck,
                              bool pol_info_out)
{
  gt_assert(eoplist != NULL);
  eoplist->pol_info = pol_info;
  eoplist->withpolcheck = withpolcheck;
  eoplist->pol_info_out = pol_info_out;
}

// Assembly:
subq $0x18, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
andb $0x1, %cl
movb %cl, 0x7(%rsp)
andb $0x1, %al
movb %al, 0x6(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4c669f
movq 0x175932(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4f99b(%rip), %rsi     # 0x516013
leaq 0x80854(%rip), %rdx     # 0x546ed3
leaq 0xf235e(%rip), %rcx     # 0x5b89e4
leaq 0xf1cab(%rip), %r8      # 0x5b8338
movl $0x541, %r9d            # imm = 0x541
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c66a1
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x88(%rax)
movb 0x7(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x58(%rax)
movb 0x6(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x59(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)