LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-sufbwtstream.c
// Function: set0frequencies
static void set0frequencies(Fmindex *fm)
{
  GtUword i;

  for (i = 0; i < (GtUword) TFREQSIZE(fm->mapsize); i++)
  {
    fm->tfreq[i] = 0;
  }
  for (i = 0; i < (GtUword) BFREQSIZE(fm->mapsize,fm->nofblocks); i++)
  {
    fm->bfreq[i] = 0;
  }
  for (i = 0;
       i < (GtUword) SUPERBFREQSIZE(fm->mapsize,fm->nofsuperblocks);
       i++)
  {
    fm->superbfreq[i] = 0;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x78(%rcx), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x24edbb
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x24ed7e
movq $0x0, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x78(%rcx), %ecx
movq -0x8(%rsp), %rdx
imulq 0xa8(%rdx), %rcx
cmpq %rcx, %rax
jae 0x24ee05
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x24edc4
movq $0x0, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x78(%rcx), %ecx
movq -0x8(%rsp), %rdx
imulq 0xb0(%rdx), %rcx
cmpq %rcx, %rax
jae 0x24ee53
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x24ee0e
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-sufbwtstream.c
// Function: finalizefmfrequencies
static void finalizefmfrequencies(Fmindex *fm)
{
  unsigned int j;
  GtUword i, *freqptr;

  for (j = 2U; j <= fm->mapsize; j++)
  {
    fm->tfreq[j] += fm->tfreq[j - 1];
  }
  freqptr = fm->superbfreq;
  for (j = 0; j < fm->mapsize; j++)
  {
    for (i = (GtUword) 2; i < fm->nofsuperblocks; i++)
    {
      freqptr[i] += freqptr[i-1];
    }
    freqptr += fm->nofsuperblocks;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x2, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x78(%rcx), %eax
ja 0x24f283
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rsp), %ecx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x24f23d
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x78(%rcx), %eax
jae 0x24f321
movq $0x2, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0xb0(%rcx), %rax
jae 0x24f2f7
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x24f2b0
movq -0x8(%rsp), %rax
movq 0xb0(%rax), %rax
shlq $0x3, %rax
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x24f299
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-polish.c
// Function: polishing_info_show
void polishing_info_show(const GtFtPolishing_info *pol_info)
{
  GtUword idx;

  printf("pi->cut_depth=" GT_WU "\n",pol_info->cut_depth);
  printf("pi->entries=" GT_WU "\n",pol_info->entries);
  printf("pi->match_score=" GT_WD "\n",pol_info->match_score);
  printf("pi->difference_score=" GT_WD "\n",pol_info->difference_score);
  printf("pi->mask=%s\n",
         polish_intbits2string(pol_info->cut_depth,pol_info->mask));
  for (idx = 0; idx < pol_info->entries; idx++)
  {
    printf("[%s]=%+hd/%+hd\n",polish_intbits2string(pol_info->cut_depth,idx),
                              pol_info->values[idx].score_sum,
                              pol_info->values[idx].diff_from_max);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x329c6b(%rip), %rdi    # 0x579474
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
movq (%rax), %rsi
leaq 0x329c68(%rip), %rdi    # 0x579487
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x329c62(%rip), %rdi    # 0x579498
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
leaq 0x329c60(%rip), %rdi    # 0x5794ad
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x24f900
movq %rax, %rsi
leaq 0x329c52(%rip), %rdi    # 0x5794c7
movb $0x0, %al
callq 0x19070
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x24f8ed
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x24f900
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rsp), %rcx
movswl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rsp), %rcx
movswl 0x2(%rax,%rcx,4), %ecx
leaq 0x329bfe(%rip), %rdi    # 0x5794d4
movb $0x0, %al
callq 0x19070
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x24f885
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-polish.c
// Function: polish_intbits2string
static char *polish_intbits2string(GtUword bits,GtUword bs)
{
  char *csptr;
  GtUword mask;
  static char cs[64+1];

  gt_assert(bits > 0 && bits <= sizeof (GtUword) * CHAR_BIT);
  for (csptr = cs, mask = ((GtUword) 1) << (bits-1); mask > 0;
       mask >>= 1, csptr++)
  {
     *csptr = (bs & mask) ? '1' : '0';
  }
  *csptr = '\0';
  return cs;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jbe 0x24f91e
cmpq $0x40, 0x20(%rsp)
jbe 0x24f956
movq 0x3ec67b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c66e4(%rip), %rsi    # 0x516013
leaq 0x329c91(%rip), %rdx    # 0x5795c7
leaq 0x329cba(%rip), %rcx    # 0x5795f7
leaq 0x329ac4(%rip), %r8     # 0x579408
movl $0x50, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24f958
leaq 0x3f3621(%rip), %rax    # 0x642f80
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jbe 0x24f9c3
movq 0x18(%rsp), %rdx
andq 0x8(%rsp), %rdx
movl $0x30, %eax
movl $0x31, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
shrq %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x24f97a
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
leaq 0x3f35ae(%rip), %rax    # 0x642f80
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-polish.c
// Function: history_is_polished_brute_force
bool history_is_polished_brute_force(const GtFtPolishing_info *pol_info,
                                     uint64_t matchhistory,
                                     bool withoutput)
{
  GtUword idx;
  uint64_t mask;
  GtWord sum_score = 0;

  for (mask = (uint64_t) 1, idx = 0; idx < 2 * pol_info->cut_depth;
       idx++, mask <<= 1)
  {
    if (matchhistory & mask)
    {
      sum_score += pol_info->match_score;
    } else
    {
      sum_score -= pol_info->difference_score;
    }
    if (withoutput)
    {
      printf(GT_WU ": sum_score=" GT_WD "\n",idx,sum_score);
    }
    if (sum_score < 0)
    {
      return false;
    }
  }
  return true;
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq $0x0, (%rsp)
movq $0x1, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x24faef
movq 0x20(%rsp), %rax
andq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x24fa8d
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x24faa1
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
subq %rcx, %rax
movq %rax, (%rsp)
testb $0x1, 0x1f(%rsp)
je 0x24fabf
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
leaq 0x329a2c(%rip), %rdi    # 0x5794e4
movb $0x0, %al
callq 0x19070
cmpq $0x0, (%rsp)
jge 0x24facd
movb $0x0, 0x37(%rsp)
jmp 0x24faf4
jmp 0x24facf
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
shlq %rax
movq %rax, 0x8(%rsp)
jmp 0x24fa50
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-trimstat.c
// Function: gt_ft_trimstat_new
GtFtTrimstat *gt_ft_trimstat_new(void)
{
  GtFtTrimstat *trimstat = gt_malloc(sizeof *trimstat);

  gt_assert(trimstat != 0);
  trimstat->trim_dist = gt_calloc(101,sizeof *trimstat->trim_dist);
  gt_assert(trimstat->trim_dist != NULL);
  trimstat->matchlength_dist = gt_calloc(101,
                                         sizeof *trimstat->matchlength_dist);
  gt_assert(trimstat->matchlength_dist != NULL);
  trimstat->diedout = 0;
  GT_INITARRAY(&trimstat->distance_dist,GtUword);
  GT_INITARRAY(&trimstat->maxvalid_dist,GtUword);
  trimstat->spaceforfront_total = 0;
  trimstat->sum_meanvalid = 0.0;
  return trimstat;
}

// Assembly:
pushq %rax
movl $0x58, %edi
leaq 0x329b0b(%rip), %rsi    # 0x579618
movl $0x11, %edx
callq 0xe80f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x24fb5a
movq 0x3ec477(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c64e0(%rip), %rsi    # 0x516013
leaq 0x329af6(%rip), %rdx    # 0x579630
leaq 0x329afd(%rip), %rcx    # 0x57963e
leaq 0x329ad0(%rip), %r8     # 0x579618
movl $0x13, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24fb5c
movl $0x65, %edi
movl $0x8, %esi
leaq 0x329aab(%rip), %rdx    # 0x579618
movl $0x14, %ecx
callq 0xe83c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x24fbc5
movq 0x3ec40c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c6475(%rip), %rsi    # 0x516013
leaq 0x329aac(%rip), %rdx    # 0x579651
leaq 0x329a92(%rip), %rcx    # 0x57963e
leaq 0x329a65(%rip), %r8     # 0x579618
movl $0x15, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24fbc7
movl $0x65, %edi
movl $0x8, %esi
leaq 0x329a40(%rip), %rdx    # 0x579618
movl $0x17, %ecx
callq 0xe83c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x24fc30
movq 0x3ec3a1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c640a(%rip), %rsi    # 0x516013
leaq 0x329afd(%rip), %rdx    # 0x57970d
leaq 0x329a27(%rip), %rcx    # 0x57963e
leaq 0x3299fa(%rip), %r8     # 0x579618
movl $0x18, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24fc32
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
jmp 0x24fc63
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-trimstat.c
// Function: gt_ft_trimstat_delete
void gt_ft_trimstat_delete(GtFtTrimstat *trimstat)
{
  if (trimstat != NULL)
  {
    gt_free(trimstat->trim_dist);
    GT_FREEARRAY(&trimstat->distance_dist,GtUword);
    GT_FREEARRAY(&trimstat->maxvalid_dist,GtUword);
    gt_free(trimstat->matchlength_dist);
    gt_free(trimstat);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x25029d
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x329449(%rip), %rsi    # 0x579618
movl $0x81, %edx
callq 0xe88c0
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x250221
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x329425(%rip), %rsi    # 0x579618
movl $0x82, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x250223
jmp 0x250225
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x25026d
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x3293d9(%rip), %rsi    # 0x579618
movl $0x83, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
jmp 0x25026f
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x32939a(%rip), %rsi    # 0x579618
movl $0x84, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x329385(%rip), %rsi    # 0x579618
movl $0x85, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-trimstat.c
// Function: gt_ft_trimstat_compare_GtUword
static int gt_ft_trimstat_compare_GtUword(const void *va, const void *vb)
{
  GtUword a = *((const GtUword *) va);
  GtUword b = *((const GtUword *) vb);

  if (a < b)
  {
    return -1;
  }
  if (a > b)
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0x25071a
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x250738
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jbe 0x250730
movl $0x1, -0x4(%rsp)
jmp 0x250738
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_new
GtGfaWriter* gt_gfa_writer_new(GtFile *file,
                               const GtEncseq *encseq,
                               GtGfaVersion version)
{
  GtGfaWriter *gw;
  gw = gt_malloc(sizeof (*gw));
  gw->file = gt_file_ref(file);
  gw->encseq = gt_encseq_ref((GtEncseq*)encseq);
  gw->version = version;
  return gw;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl $0x18, %edi
leaq 0x3290d3(%rip), %rsi    # 0x579831
movl $0x22, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xdd6f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
callq 0xaebc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_show_header
int gt_gfa_writer_show_header(GtGfaWriter *gw,
    GtUword minlen, const char *inputfilename, bool has_containments,
    bool has_transitives, GT_UNUSED GtError *err)
{
  gt_assert(gw != NULL);
  gt_file_xprintf(gw->file,
      "H\tVN:Z:%s\n"
      "H\tpn:Z:readjoiner\n"
      "H\tol:i:"GT_WU"\n"
      "H\tin:Z:%s\n"
      "H\tcn:i:%c\n"
      "H\tte:i:%c\n",
      gt_gfa_writer_versionstr(gw->version),
      minlen,
      inputfilename,
      has_containments ? '1' : '0',
      has_transitives ? '1' : '0');
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %cl
movb %cl, 0x1f(%rsp)
andb $0x1, %al
movb %al, 0x1e(%rsp)
movq %r9, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x250818
movq 0x3eb7b9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c5822(%rip), %rsi    # 0x516013
leaq 0x329050(%rip), %rdx    # 0x579848
leaq 0x329054(%rip), %rcx    # 0x579853
leaq 0x32902b(%rip), %r8     # 0x579831
movl $0x3a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x25081a
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x250890
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movb 0x1f(%rsp), %sil
movl $0x30, %r9d
movl $0x31, %eax
testb $0x1, %sil
cmovnel %eax, %r9d
movb 0x1e(%rsp), %r10b
movl $0x30, %eax
movl $0x31, %esi
testb $0x1, %r10b
cmovnel %esi, %eax
leaq 0x328ff2(%rip), %rsi    # 0x57986d
movl %eax, (%rsp)
movb $0x0, %al
callq 0xddca0
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_versionstr
static inline const char *gt_gfa_writer_versionstr(GtGfaVersion version)
{
  switch (version) {
    case GT_GFA_VERSION_1_0:
      return "1.0";
    case GT_GFA_VERSION_2_0:
      return "2.0";
    default:
      gt_assert(false);
  }
  return "UNKNOWN";
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x2508b1
jmp 0x2508a6
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x2508bf
jmp 0x2508cd
leaq 0x2d401b(%rip), %rax    # 0x5248d3
movq %rax, 0x10(%rsp)
jmp 0x250907
leaq 0x2d401f(%rip), %rax    # 0x5248e5
movq %rax, 0x10(%rsp)
jmp 0x250907
jmp 0x2508cf
movq 0x3eb6ca(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c5733(%rip), %rsi    # 0x516013
leaq 0x30847c(%rip), %rdx    # 0x558d63
leaq 0x328fe1(%rip), %rcx    # 0x5798cf
leaq 0x328f3c(%rip), %r8     # 0x579831
movl $0x31, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_show_segment
static inline void gt_gfa_writer_show_segment(GtGfaVersion version,
    GtFile *file, GtUword seqnum, const char *sequence)
{
    switch (version) {
      case GT_GFA_VERSION_1_0:
        gt_gfa_writer_show_gfa1_segment(file, seqnum, sequence);
        break;
      case GT_GFA_VERSION_2_0:
        gt_gfa_writer_show_gfa2_segment(file, seqnum, sequence);
        break;
      default:
        gt_assert(false);
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x250bd0
jmp 0x250bc5
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x250be6
jmp 0x250bfc
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2510a0
jmp 0x250c36
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2510e0
jmp 0x250c36
jmp 0x250bfe
movq 0x3eb39b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c5404(%rip), %rsi    # 0x516013
leaq 0x30814d(%rip), %rdx    # 0x558d63
leaq 0x328ccb(%rip), %rcx    # 0x5798e8
leaq 0x328c0d(%rip), %r8     # 0x579831
movl $0x62, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_spmproc_show_gfa
void gt_spmproc_show_gfa(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *gfa_writer)
{
  GtGfaWriter *gw = gfa_writer;
  const GtUword sl1 = gt_encseq_seqlength(gw->encseq, suffix_readnum),
                sl2 = gt_encseq_seqlength(gw->encseq, prefix_readnum);
  gt_gfa_writer_show_edge(gw->version, gw->file,
      suffix_readnum, suffixseq_direct,
      prefix_readnum, prefixseq_direct,
      suffixseq_direct ? sl1 - length : 0,
      suffixseq_direct ? sl1 : length,
      suffixseq_direct,
      prefixseq_direct ? 0 : sl2 - length,
      prefixseq_direct ? length : sl2,
      !prefixseq_direct,
      length);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movb %r8b, %al
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
andb $0x1, %cl
movb %cl, 0xd7(%rsp)
andb $0x1, %al
movb %al, 0xd6(%rsp)
movq %r9, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xe8(%rsp), %rsi
callq 0xb09f0
movq %rax, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xe0(%rsp), %rsi
callq 0xb09f0
movq %rax, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x84(%rsp)
movq 0xc0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x88(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x90(%rsp)
movb 0xd7(%rsp), %al
movb %al, 0x9f(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movb 0xd6(%rsp), %al
movb %al, 0xaf(%rsp)
testb $0x1, 0xd7(%rsp)
je 0x250d5a
movq 0xb8(%rsp), %rax
subq 0xd8(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x250d63
xorl %eax, %eax
movq %rax, 0x78(%rsp)
jmp 0x250d63
movq 0x78(%rsp), %rax
movq %rax, 0x70(%rsp)
testb $0x1, 0xd7(%rsp)
je 0x250d86
movq 0xb8(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x250d93
movq 0xd8(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
movb 0xd7(%rsp), %al
movb %al, 0x67(%rsp)
testb $0x1, 0xd6(%rsp)
je 0x250dbb
xorl %eax, %eax
movq %rax, 0x50(%rsp)
jmp 0x250dd0
movq 0xb0(%rsp), %rax
subq 0xd8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
testb $0x1, 0xd6(%rsp)
je 0x250df3
movq 0xd8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x250e00
movq 0xb0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xa0(%rsp), %r8
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rsi
movl 0x84(%rsp), %edi
movb 0xaf(%rsp), %al
movb 0x9f(%rsp), %cl
movb 0x67(%rsp), %r10b
movq 0x70(%rsp), %rbx
movq 0x58(%rsp), %r14
movq 0x48(%rsp), %r15
movq 0x40(%rsp), %r12
movb 0xd6(%rsp), %r11b
xorb $-0x1, %r11b
movq 0xd8(%rsp), %r13
movq %rsp, %r9
movq %r13, 0x30(%r9)
movq %r12, 0x20(%r9)
movq %r15, 0x18(%r9)
movq %r14, 0x8(%r9)
movq %rbx, (%r9)
movzbl %r11b, %r11d
andl $0x1, %r11d
movl %r11d, 0x28(%r9)
movzbl %r10b, %r10d
andl $0x1, %r10d
movl %r10d, 0x10(%r9)
movzbl %cl, %ecx
andl $0x1, %ecx
movzbl %al, %r9d
andl $0x1, %r9d
callq 0x250eb0
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_show_edge
static inline void gt_gfa_writer_show_edge(GtGfaVersion version, GtFile *file,
    GtUword seqnum1, bool seq1_direct, GtUword seqnum2, bool seq2_direct,
    GtUword start1, GtUword end1, bool end1_last,
    GtUword start2, GtUword end2, bool end2_last,
    GtUword spmlen)
{

  switch (version) {
    case GT_GFA_VERSION_1_0:
      gt_gfa_writer_show_edge_gfa1(file, seqnum1, seq1_direct, seqnum2,
          seq2_direct, spmlen);
      break;
    case GT_GFA_VERSION_2_0:
      gt_gfa_writer_show_edge_gfa2(file, seqnum1, seq1_direct, seqnum2,
          seq2_direct, start1, end1, end1_last, start2, end2, end2_last,
          spmlen);
      break;
    default:
      gt_assert(false);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %r9d, %eax
movq %rdx, 0x38(%rsp)
movq %rsi, %r9
movl %edi, %r10d
movq 0x38(%rsp), %rdi
movb %al, %dl
movb %cl, %sil
movq 0xc0(%rsp), %rax
movb 0xb8(%rsp), %al
movq 0xb0(%rsp), %rcx
movq 0xa8(%rsp), %rcx
movb 0xa0(%rsp), %cl
movq 0x98(%rsp), %r11
movq 0x90(%rsp), %r11
movl %r10d, 0x6c(%rsp)
movq %r9, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
andb $0x1, %sil
movb %sil, 0x57(%rsp)
movq %r8, 0x48(%rsp)
andb $0x1, %dl
movb %dl, 0x47(%rsp)
andb $0x1, %cl
movb %cl, 0x46(%rsp)
andb $0x1, %al
movb %al, 0x45(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x40(%rsp)
testl %eax, %eax
je 0x250f53
jmp 0x250f45
movl 0x40(%rsp), %eax
subl $0x1, %eax
je 0x250f88
jmp 0x251013
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movb 0x57(%rsp), %dl
movq 0x48(%rsp), %rcx
movb 0x47(%rsp), %al
movq 0xc0(%rsp), %r9
andb $0x1, %dl
andb $0x1, %al
movzbl %dl, %edx
movzbl %al, %r8d
callq 0x251140
jmp 0x25104d
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movb 0x57(%rsp), %dl
movq 0x48(%rsp), %rcx
movb 0x47(%rsp), %r8b
movq 0x90(%rsp), %r9
movq 0x98(%rsp), %r14
movb 0x46(%rsp), %bpl
movq 0xa8(%rsp), %rbx
movq 0xb0(%rsp), %r11
movb 0x45(%rsp), %r10b
movq 0xc0(%rsp), %rax
andb $0x1, %dl
andb $0x1, %r8b
andb $0x1, %bpl
andb $0x1, %r10b
movzbl %dl, %edx
movzbl %r8b, %r8d
movq %r14, (%rsp)
movzbl %bpl, %ebp
movl %ebp, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x2511d0
jmp 0x25104d
jmp 0x251015
movq 0x3eaf84(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c4fed(%rip), %rsi    # 0x516013
leaq 0x307d36(%rip), %rdx    # 0x558d63
leaq 0x3288e7(%rip), %rcx    # 0x57991b
leaq 0x3287f6(%rip), %r8     # 0x579831
movl $0xc7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_show_edge_gfa1
static inline void gt_gfa_writer_show_edge_gfa1(GtFile *file,
    GtUword seqnum1, bool seq1_direct,
    GtUword seqnum2, bool seq2_direct,
    GtUword spmlen)
{
  gt_file_xprintf(file, "L\t"GT_WU"\t%c\t"GT_WU"\t%c\t"
                        GT_WU"M\n",
                        seqnum1, seq1_direct ? '+' : '-',
                        seqnum2, seq2_direct ? '+' : '-',
                        spmlen);
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %dl
movb %dl, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
movb 0x27(%rsp), %sil
movl $0x2d, %ecx
movl $0x2b, %eax
testb $0x1, %sil
cmovnel %eax, %ecx
movq 0x18(%rsp), %r8
movb 0x17(%rsp), %sil
movl $0x2d, %r9d
movl $0x2b, %eax
testb $0x1, %sil
cmovnel %eax, %r9d
movq 0x8(%rsp), %rax
leaq 0x328782(%rip), %rsi    # 0x579933
movq %rax, (%rsp)
movb $0x0, %al
callq 0xddca0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_show_edge_gfa2
static inline void gt_gfa_writer_show_edge_gfa2(GtFile *file,
    GtUword seqnum1, bool seq1_direct,
    GtUword seqnum2, bool seq2_direct,
    GtUword start1, GtUword end1, bool end1_last,
    GtUword start2, GtUword end2, bool end2_last,
    GtUword spmlen)
{
  gt_file_xprintf(file, "E\t*\t"GT_WU"%c\t"GT_WU"%c\t"
                        GT_WU"\t"GT_WU"%s\t"GT_WU"\t"GT_WU"%s\t"
                        GT_WU"M\n",
                        seqnum1, seq1_direct ? '+' : '-',
                        seqnum2, seq2_direct ? '+' : '-',
                        start1, end1, end1_last ? "$" : "",
                        start2, end2, end2_last ? "$" : "",
                        spmlen);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, 0x44(%rsp)
movq %rcx, %rax
movl 0x44(%rsp), %ecx
movq %rax, 0x48(%rsp)
movl %edx, %eax
movq %rsi, %r8
movq 0x48(%rsp), %rsi
movq %rdi, %r10
movb %cl, %dl
movb %al, %dil
movq 0xd8(%rsp), %rax
movb 0xd0(%rsp), %al
movq 0xc8(%rsp), %rcx
movq 0xc0(%rsp), %rcx
movb 0xb8(%rsp), %cl
movq 0xb0(%rsp), %r11
movq %r10, 0x80(%rsp)
movq %r8, 0x78(%rsp)
andb $0x1, %dil
movb %dil, 0x77(%rsp)
movq %rsi, 0x68(%rsp)
andb $0x1, %dl
movb %dl, 0x67(%rsp)
movq %r9, 0x58(%rsp)
andb $0x1, %cl
movb %cl, 0x57(%rsp)
andb $0x1, %al
movb %al, 0x56(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rdx
movb 0x77(%rsp), %sil
movl $0x2d, %ecx
movl $0x2b, %eax
testb $0x1, %sil
cmovnel %eax, %ecx
movq 0x68(%rsp), %r8
movb 0x67(%rsp), %sil
movl $0x2d, %r9d
movl $0x2b, %eax
testb $0x1, %sil
cmovnel %eax, %r9d
movq 0x58(%rsp), %r12
movq 0xb0(%rsp), %r15
movb 0x57(%rsp), %sil
leaq 0x34c36c(%rip), %r14    # 0x59d628
leaq 0x2edb66(%rip), %rax    # 0x53ee29
testb $0x1, %sil
cmovneq %rax, %r14
movq 0xc0(%rsp), %rbx
movq 0xc8(%rsp), %r11
movb 0x56(%rsp), %sil
leaq 0x34c341(%rip), %r10    # 0x59d628
leaq 0x2edb3b(%rip), %rax    # 0x53ee29
testb $0x1, %sil
cmovneq %rax, %r10
movq 0xd8(%rsp), %rax
leaq 0x328644(%rip), %rsi    # 0x579949
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movb $0x0, %al
callq 0xddca0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/giextract.c
// Function: compareFixedkeys
static int compareFixedkeys(const void *a,const void *b)
{
  const Fixedsizekey *fa = a;
  const Fixedsizekey *fb = b;
  return strcmp(((const Fixedsizekey *) fa)->key,
                ((const Fixedsizekey *) fb)->key);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x19980
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/giextract.c
// Function: readkeysize
static int readkeysize(const char *indexname,GtError *err)
{
  FILE *fp;
  bool haserr = false;
  char cc = '\0';

  gt_error_check(err);
  fp = gt_fa_fopen_with_suffix(indexname,GT_KEYSTABFILESUFFIX,"rb",err);
  if (fp == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    GT_UNUSED size_t ret;

    ret = fread(&cc,sizeof cc, (size_t) 1, fp);
    if (ferror(fp))
    {
      gt_error_set(err,"error when trying to read first byte of file %s%s: %s",
                   indexname,GT_KEYSTABFILESUFFIX,strerror(errno));
      haserr = true;
    }
  }
  gt_assert(cc >= 0);
  gt_fa_xfclose(fp);
  return haserr ? -1 : (int) cc;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x2f(%rsp)
movb $0x0, 0x2e(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x2521b8
movq 0x38(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x252180
jmp 0x2521b8
movq 0x3e9e19(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c3e82(%rip), %rsi    # 0x516013
leaq 0x2c4027(%rip), %rdx    # 0x5161bf
leaq 0x327a5b(%rip), %rcx    # 0x579bfa
leaq 0x3277cd(%rip), %r8     # 0x579973
movl $0x2ec, %r9d            # imm = 0x2EC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2521ba
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %r9
leaq 0x3277be(%rip), %rsi    # 0x579989
leaq 0x325d13(%rip), %rdx    # 0x577ee5
leaq 0x32779a(%rip), %rcx    # 0x579973
movl $0x2ed, %r8d            # imm = 0x2ED
callq 0xd92c0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x2521f6
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x252271
movq 0x30(%rsp), %rcx
leaq 0x2e(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x19a70
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x19e10
cmpl $0x0, %eax
je 0x25226f
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x19060
movl (%rax), %edi
callq 0x19200
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq %rax, %r8
leaq 0x3279aa(%rip), %rsi    # 0x579c06
leaq 0x327726(%rip), %rcx    # 0x579989
movb $0x0, %al
callq 0xd88c0
movb $0x1, 0x2f(%rsp)
jmp 0x252271
jmp 0x252273
movsbl 0x2e(%rsp), %eax
cmpl $0x0, %eax
jge 0x2522b5
movq 0x3e9d1c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c3d85(%rip), %rsi    # 0x516013
leaq 0x3279a7(%rip), %rdx    # 0x579c3c
leaq 0x32795e(%rip), %rcx    # 0x579bfa
leaq 0x3276d0(%rip), %r8     # 0x579973
movl $0x2fe, %r9d            # imm = 0x2FE
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2522b7
movq 0x30(%rsp), %rdi
callq 0xd9570
testb $0x1, 0x2f(%rsp)
je 0x2522d3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x2522dc
movsbl 0x2e(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/giextract.c
// Function: searchdesinfastakeyqueries
static GtUword searchdesinfastakeyqueries(const char *extractkey,
                                                const Fastakeyquery
                                                  *fastakeyqueries,
                                                GtUword numofqueries)
{
  const Fastakeyquery *leftptr, *rightptr, *midptr;
  int cmp;

  leftptr = fastakeyqueries;
  rightptr = fastakeyqueries + numofqueries - 1;
  while (leftptr <= rightptr)
  {
    midptr = leftptr + GT_DIV2((GtUword) (rightptr-leftptr));
    cmp = strcmp(extractkey,midptr->fastakey);
    if (cmp == 0)
    {
      if (midptr > fastakeyqueries &&
          strcmp(extractkey,(midptr-1)->fastakey) == 0)
      {
        rightptr = midptr - 1;
      } else
      {
        return (GtUword) (midptr - fastakeyqueries);
      }
    } else
    {
      if (cmp < 0)
      {
        rightptr = midptr-1;
      } else
      {
        leftptr = midptr + 1;
      }
    }
  }
  return numofqueries;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
addq $-0x20, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x252ee3
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
subq %rdx, %rcx
sarq $0x5, %rcx
shrq %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x19980
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x252eb7
movq 0x10(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x252e9d
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movq -0x20(%rax), %rsi
callq 0x19980
cmpl $0x0, %eax
jne 0x252e9d
movq 0x10(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x18(%rsp)
jmp 0x252eb5
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
subq %rcx, %rax
sarq $0x5, %rax
movq %rax, 0x40(%rsp)
jmp 0x252eed
jmp 0x252ede
cmpl $0x0, 0xc(%rsp)
jge 0x252ece
movq 0x10(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x18(%rsp)
jmp 0x252edc
movq 0x10(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x20(%rsp)
jmp 0x252ede
jmp 0x252e17
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/giextract.c
// Function: outputnonmarked
static void outputnonmarked(const Fastakeyquery *fastakeyqueries,
                            GtUword numofqueries)
{
  GtUword idx, countmissing = 0;

  for (idx=0; idx<numofqueries; idx++)
  {
    if (!fastakeyqueries[idx].markhit)
    {
      printf("unsatisfied %s",fastakeyqueries[idx].fastakey);
      if (COMPLETE(fastakeyqueries + idx))
      {
        printf(" complete\n");
      } else
      {
        printf(" "GT_WU" "GT_WU"\n",fastakeyqueries[idx].frompos,
                            fastakeyqueries[idx].topos);
      }
      countmissing++;
    }
  }
  printf("# number of unsatified fastakey-queries: "GT_WU"\n",countmissing);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x253008
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
testb $0x1, 0x18(%rax)
jne 0x252ff3
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x326ee2(%rip), %rdi    # 0x579e48
movb $0x0, %al
callq 0x19070
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x1, 0x8(%rax)
jne 0x252fad
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0x252fad
leaq 0x326eb3(%rip), %rdi    # 0x579e57
movb $0x0, %al
callq 0x19070
jmp 0x252fe5
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
leaq 0x30149e(%rip), %rdi    # 0x55447c
movb $0x0, %al
callq 0x19070
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x252ff5
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x252f20
movq 0x8(%rsp), %rsi
leaq 0x326c66(%rip), %rdi    # 0x579c7a
movb $0x0, %al
callq 0x19070
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/giextract.c
// Function: fastakeyqueries_delete
static void fastakeyqueries_delete(Fastakeyquery *fastakeyqueries,
                                   GtUword numofqueries)
{
  if (fastakeyqueries != NULL)
  {
    GtUword idx;

    for (idx=0; idx<numofqueries; idx++)
    {
      gt_free(fastakeyqueries[idx].fastakey);
    }
    gt_free(fastakeyqueries);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x253091
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x25307b
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq 0x326910(%rip), %rsi    # 0x579973
movl $0x9f, %edx
callq 0xe88c0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x25303e
movq 0x10(%rsp), %rdi
leaq 0x3268ec(%rip), %rsi    # 0x579973
movl $0xa1, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/giextract.c
// Function: searchfastaqueryindes
static GtUword searchfastaqueryindes(const char *extractkey,
                                           const char *keytab,
                                           GtUword numofkeys,
                                           GtUword keysize)
{
  GtUword left = 0, right = numofkeys - 1, mid;
  int cmp;

  while (left <= right)
  {
    mid = left + GT_DIV2((GtUword) (right-left));
    cmp = strcmp(extractkey,keytab + 1UL + mid * (keysize+1));
    if (cmp < 0)
    {
      gt_assert(mid > 0);
      right = mid-1;
    } else
    {
      if (cmp > 0)
      {
        left = mid+1;
      } else
      {
        gt_assert(mid < numofkeys);
        return mid;
      }
    }
  }
  return numofkeys;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x2534f2
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq 0x18(%rsp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
addq %rax, %rsi
callq 0x19980
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x253480
jmp 0x25342e
cmpq $0x0, 0x8(%rsp)
ja 0x25346e
movq 0x3e8b63(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c2bcc(%rip), %rsi    # 0x516013
leaq 0x326929(%rip), %rdx    # 0x579d77
leaq 0x32692a(%rip), %rcx    # 0x579d7f
leaq 0x326517(%rip), %r8     # 0x579973
movl $0x290, %r9d            # imm = 0x290
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x253470
movq 0x8(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2534ed
cmpl $0x0, 0x4(%rsp)
jle 0x253497
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2534eb
jmp 0x253499
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jb 0x2534dd
movq 0x3e8af4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c2b5d(%rip), %rsi    # 0x516013
leaq 0x3268d8(%rip), %rdx    # 0x579d95
leaq 0x3268bb(%rip), %rcx    # 0x579d7f
leaq 0x3264a8(%rip), %r8     # 0x579973
movl $0x299, %r9d            # imm = 0x299
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2534df
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2534fc
jmp 0x2534ed
jmp 0x2533cf
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/giextract.c
// Function: comparefastakeys
static int comparefastakeys(const void *a,const void *b)
{
  int cmp = strcmp(((Fastakeyquery *) a)->fastakey,
                   ((Fastakeyquery *) b)->fastakey);

  if (cmp < 0)
  {
    return -1;
  }
  if (cmp > 0)
  {
    return 1;
  }
  if (((Fastakeyquery *) a)->frompos < ((Fastakeyquery *) b)->frompos)
  {
    return -1;
  }
  if (((Fastakeyquery *) a)->frompos > ((Fastakeyquery *) b)->frompos)
  {
    return 1;
  }
  if (((Fastakeyquery *) a)->topos < ((Fastakeyquery *) b)->topos)
  {
    return -1;
  }
  if (((Fastakeyquery *) a)->topos > ((Fastakeyquery *) b)->topos)
  {
    return 1;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x19980
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x25354b
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2535df
cmpl $0x0, 0xc(%rsp)
jle 0x25355f
movl $0x1, 0x24(%rsp)
jmp 0x2535df
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x25357d
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2535df
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x25359b
movl $0x1, 0x24(%rsp)
jmp 0x2535df
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2535b9
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2535df
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2535d7
movl $0x1, 0x24(%rsp)
jmp 0x2535df
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/greedyedist.c
// Function: gt_frontresource_new
GtFrontResource *gt_frontresource_new(GtUword maxdist)
{
  GtFrontResource *ftres = gt_malloc(sizeof *ftres);

  ftres->currentallocated = sumofoddnumbers(maxdist);
  ftres->frontspace = gt_malloc(sizeof *ftres->frontspace
                                * ftres->currentallocated);
  return ftres;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x28, %edi
leaq 0x32663d(%rip), %rsi    # 0x579e62
movl $0x3c, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x253880
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
shlq $0x3, %rdi
leaq 0x326606(%rip), %rsi    # 0x579e62
movl $0x40, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/greedyedist.c
// Function: firstfrontforward
static void firstfrontforward(const GtSeqabstract *useq,
                              const GtSeqabstract *vseq,
                              GtFrontResource *ftres,
                              GtFrontspec *fspec)
{
  fspec->left = fspec->offset = 0;
  fspec->width = 1L;
  if (ftres->ulen == 0 || ftres->vlen == 0)
  {
    GT_FRONT_STORE(ftres,GT_FRONT_ROWVALUE(&ftres->frontspace[0]),0);
  } else
  {
    GtUword lcp = gt_seqabstract_lcp(true,
                                     useq,
                                     vseq,
                                     0,
                                     0);
    GT_FRONT_STORE(ftres,GT_FRONT_ROWVALUE(&ftres->frontspace[0]),(GtWord) lcp);
  }
#ifdef SKDEBUG
  printf("forward front[0]="GT_WD"\n",GT_FRONT_ROWVALUE(&ftres->frontspace[0]));
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x253d36
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x253d48
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq $0x0, (%rax)
jmp 0x253d78
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2b0d50
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/greedyedist.c
// Function: frontspecparms
static void frontspecparms(const GtFrontResource *ftres,
                           GtFrontspec *fspec,
                           GtWord p,
                           GtWord r)
{
  if (r <= 0)
  {
    fspec->left = -p;
    fspec->width = p + p + 1;
  } else
  {
    fspec->left = GT_MAX(-ftres->ulen,-p);
    fspec->width = GT_MIN(ftres->vlen,p) - fspec->left + 1;
  }
#ifdef SKDEBUG
  printf("p="GT_WD",offset="GT_WD",left="GT_WD",width="GT_WD"\n",p,
                                                 fspec->offset,
                                                 fspec->left,
                                                 fspec->width);
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
jg 0x253dca
xorl %eax, %eax
movl %eax, %ecx
subq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rcx
addq -0x18(%rsp), %rcx
addq $0x1, %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x253e52
movq -0x8(%rsp), %rcx
xorl %eax, %eax
subq 0x8(%rcx), %rax
xorl %ecx, %ecx
subq -0x18(%rsp), %rcx
cmpq %rcx, %rax
jle 0x253df3
movq -0x8(%rsp), %rcx
xorl %eax, %eax
subq 0x8(%rcx), %rax
movq %rax, -0x28(%rsp)
jmp 0x253dff
xorl %eax, %eax
subq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rsp), %rax
jge 0x253e2d
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
jmp 0x253e37
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rcx
movq -0x10(%rsp), %rax
subq 0x10(%rax), %rcx
addq $0x1, %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/greedyedist.c
// Function: evalfrontforward
static bool evalfrontforward(const GtSeqabstract *useq,
                             const GtSeqabstract *vseq,
                             GtFrontResource *ftres,
                             const GtFrontspec *prevfspec,
                             const GtFrontspec *fspec,
                             GtWord r)
{
  GtWord k;
  bool defined = false;
  GtFrontvalue *fval;

  for (fval = ftres->frontspace + fspec->offset, k = fspec->left;
       k < fspec->left + fspec->width; k++, fval++)
  {
    if (r <= 0 || k <= -r || k >= r)
    {
      evalentryforward(useq,vseq,ftres,fval,prevfspec,k);
      if (GT_FRONT_ROWVALUE(fval) >= 0)
      {
        defined = true;
      }
#ifdef SKDEBUG
      printf("store front[k="GT_WD"]="GT_WD" ",k,GT_FRONT_ROWVALUE(fval));
      printf("at index "GT_WD"\n",(GtWord) (fval-ftres->frontspace));
#endif
    } else
    {
#ifdef SKDEBUG
      printf("store front[k="GT_WD"]=GT_FRONT_MINUSINFINITY ",k);
      printf("at index "GT_WD"\n",(GtWord) (fval-ftres->frontspace));
#endif
      GT_FRONT_STORE(ftres,GT_FRONT_ROWVALUE(fval),
                     GT_FRONT_MINUSINFINITY(ftres));
    }
  }
#ifdef SKDEBUG
  printf("frontvalues[r="GT_WD"]=",r);
  showfront(ftres,fspec,r);
#endif
  return defined;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x20(%rsp), %rdx
addq 0x8(%rdx), %rcx
cmpq %rcx, %rax
jge 0x253f5a
cmpq $0x0, 0x18(%rsp)
jle 0x253ef6
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
subq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jle 0x253ef6
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jl 0x253f29
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x253fe0
movq (%rsp), %rax
cmpq $0x0, (%rax)
jl 0x253f27
movb $0x1, 0xf(%rsp)
jmp 0x253f39
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
jmp 0x253f3b
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
jmp 0x253eb1
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/greedyfwdmat.c
// Function: showunitnum
static void showunitnum(uint64_t unitnum,
                        const char *desc,
                        GT_UNUSED void *info)
{
  printf("unit " Formatuint64_t, PRINTuint64_tcast(unitnum));
  if (desc != NULL && desc[0] != '\0')
  {
    printf(" (%s)",desc);
  }
  printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rsi
leaq 0x325a54(%rip), %rdi    # 0x579f12
movb $0x0, %al
callq 0x19070
cmpq $0x0, 0x8(%rsp)
je 0x2544ed
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2544ed
movq 0x8(%rsp), %rsi
leaq 0x31b66b(%rip), %rdi    # 0x56fb51
movb $0x0, %al
callq 0x19070
leaq 0x33ed7f(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
addq $0x18, %rsp
retq