LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-display.c
// Function: gt_display_arg_get
static const GtSEdisplayStruct *gt_display_arg_get(char *copyspace,
                                                   const char *str,
                                                   size_t cmplen)
{
  char *copy = NULL;
  const GtSEdisplayStruct *left = gt_display_arguments_table,
                          *right = gt_display_arguments_table +
                                   sizeof gt_display_arguments_table/
                                   sizeof gt_display_arguments_table[0] - 1;

  if (cmplen > 0)
  {
    copy = copyspace;
    memcpy(copy,str,sizeof *copy * cmplen);
    copy[cmplen] = '\0';
  }
  while (left <= right)
  {
    const GtSEdisplayStruct *mid = left + (right - left + 1)/2;
    const int cmp = strcmp_ignore_ws(copy == NULL ? str : copy,mid->name);

    if (cmp < 0)
    {
      right = mid - 1;
    } else
    {
      if (cmp > 0)
      {
        left = mid + 1;
      } else
      {
        return mid;
      }
    }
  }
  return NULL;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x3d71bd(%rip), %rax    # 0x63e3b0
movq %rax, 0x28(%rsp)
leaq 0x3d71b1(%rip), %rax    # 0x63e3b0
addq $0x270, %rax            # imm = 0x270
addq $-0x10, %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x38(%rsp)
jbe 0x267246
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
shlq $0x0, %rdx
callq 0x19610
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x267248
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0x267307
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq 0x8(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x2672a8
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
jmp 0x2672b1
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x266f60
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x2672dd
movq 0x18(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x20(%rsp)
jmp 0x267302
cmpl $0x0, 0x14(%rsp)
jle 0x2672f4
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
jmp 0x267300
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x267310
jmp 0x267302
jmp 0x267248
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_new
GtQuerymatch *gt_querymatch_new(void)
{
  GtQuerymatch *querymatch = gt_malloc(sizeof *querymatch);

  gt_assert(querymatch != NULL);
  querymatch->ref_querymatchoutoptions = NULL;
  querymatch->verify_alignment = false;
  querymatch->query_readmode = GT_READMODE_FORWARD;
  querymatch->fp = stdout;
  querymatch->queryseqnum = GT_UWORD_MAX;
  querymatch->db_desc = NULL;
  querymatch->query_desc = NULL;
  return querymatch;
}

// Assembly:
pushq %rax
movl $0xb8, %edi
leaq 0x316e53(%rip), %rsi    # 0x57e180
movl $0x3f, %edx
callq 0xe80f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x26737a
movq 0x3d4c57(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2aecc0(%rip), %rsi    # 0x516013
leaq 0x320af1(%rip), %rdx    # 0x587e4b
leaq 0x316e36(%rip), %rcx    # 0x57e197
leaq 0x316e18(%rip), %r8     # 0x57e180
movl $0x41, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26737c
movq (%rsp), %rax
movq $0x0, 0x90(%rax)
movq (%rsp), %rax
movb $0x0, 0x8d(%rax)
movq (%rsp), %rax
movl $0x0, 0x88(%rax)
movq 0x3d4b8d(%rip), %rax    # 0x63bf38
movq (%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x98(%rax)
movq (%rsp), %rax
movq $-0x1, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0xa0(%rax)
movq (%rsp), %rax
movq $0x0, 0xa8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_outoptions_set
void gt_querymatch_outoptions_set(GtQuerymatch *querymatch,
                GtQuerymatchoutoptions *querymatchoutoptions)
{
  gt_assert(querymatch != NULL && querymatchoutoptions != NULL);
  querymatch->ref_querymatchoutoptions = querymatchoutoptions;
  querymatch->ref_eoplist
    = gt_querymatchoutoptions_eoplist(querymatchoutoptions);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2675be
cmpq $0x0, 0x8(%rsp)
jne 0x2675f6
movq 0x3d49db(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2aea44(%rip), %rsi    # 0x516013
leaq 0x316c19(%rip), %rdx    # 0x57e1ef
leaq 0x316c45(%rip), %rcx    # 0x57e222
leaq 0x316b9c(%rip), %r8     # 0x57e180
movl $0x58, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2675f8
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x8(%rsp), %rdi
callq 0x265620
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xb0(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_position_convert
static GtUword gt_querymatch_position_convert(GtReadmode query_readmode,
                                                GtUword matchlen,
                                                GtUword seqlen,
                                                GtUword position)
{
  if (GT_ISDIRREVERSE(query_readmode))
  {
    gt_assert(position + matchlen <= seqlen);
    return seqlen - position - matchlen;
  }
  return position;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpl $0x1, 0x1c(%rsp)
je 0x267ae4
cmpl $0x3, 0x1c(%rsp)
jne 0x267b45
jmp 0x267ae6
movq (%rsp), %rax
addq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x267b2e
movq 0x3d44a3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ae50c(%rip), %rsi    # 0x516013
leaq 0x316b21(%rip), %rdx    # 0x57e62f
leaq 0x316b38(%rip), %rcx    # 0x57e64d
leaq 0x316664(%rip), %r8     # 0x57e180
movl $0xc5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x267b30
movq 0x8(%rsp), %rax
subq (%rsp), %rax
subq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x267b4e
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_exact_match_trace_show
static void gt_querymatch_exact_match_trace_show(FILE *fp,
                                                 bool dtrace,
                                                 GtUword remaining,
                                                 GtUword trace_delta)
{
  bool first = true;

  while (true)
  {
    if (!first)
    {
      fputc(',',fp);
    } else
    {
      first = false;
    }
    if (remaining > trace_delta)
    {
      fprintf(fp,GT_WU,dtrace ? 0 : trace_delta);
      remaining -= trace_delta;
    } else
    {
      fprintf(fp,"%d",dtrace ? ((int) trace_delta - (int) remaining)
                             : (int) remaining);
      break;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x268bc9
movq 0x40(%rsp), %rsi
movl $0x2c, %edi
callq 0x198d0
jmp 0x268bce
movb $0x0, 0x27(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x268c2a
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x3f(%rsp)
je 0x268bf4
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x268bfe
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x3263fa(%rip), %rsi    # 0x58f009
movb $0x0, %al
callq 0x199f0
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x268c6f
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x3f(%rsp)
je 0x268c4d
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
subl %ecx, %eax
movl %eax, 0x4(%rsp)
jmp 0x268c56
movq 0x30(%rsp), %rax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %edx
leaq 0x33483c(%rip), %rsi    # 0x59d4a2
movb $0x0, %al
callq 0x199f0
jmp 0x268c74
jmp 0x268bb1
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_show_failed_seed
void gt_querymatch_show_failed_seed(const GtSeedExtendDisplayFlag
                                       *out_display_flag,
                                    const GtQuerymatch *querymatch)
{
  if (gt_querymatch_failed_seed_display(out_display_flag))
  {
    const char separator
      = (gt_querymatch_blast_display(out_display_flag) ||
         gt_querymatch_tabsep_display(out_display_flag)) ? '\t' : ' ';
    fprintf(querymatch->fp, "# failed_seed:%c" GT_WU "%c" GT_WU "%c"  GT_WU
                                   "%c%c%c" GT_WU "%c" GT_WU "\n",
            separator,
            querymatch->seedlen,
            separator,
            querymatch->dbseqnum,
            separator,
            querymatch->db_seedpos_rel,
            separator,
            gt_seed_extend_outflag[querymatch->query_readmode],
            separator,
            querymatch->queryseqnum,
            separator,
            querymatch->query_seedpos_rel);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x265730
testb $0x1, %al
jne 0x268e09
jmp 0x268ee9
movq 0x58(%rsp), %rdi
callq 0x265790
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x4e(%rsp)
jne 0x268e2e
movq 0x58(%rsp), %rdi
callq 0x265770
movb %al, 0x4e(%rsp)
movb 0x4e(%rsp), %dl
movl $0x20, %eax
movl $0x9, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, 0x4f(%rsp)
movq 0x50(%rsp), %rax
movq 0x98(%rax), %rdi
movsbl 0x4f(%rsp), %edx
movq 0x50(%rsp), %rax
movq 0x68(%rax), %rcx
movsbl 0x4f(%rsp), %r8d
movq 0x50(%rsp), %rax
movq (%rax), %r9
movsbl 0x4f(%rsp), %r12d
movq 0x50(%rsp), %rax
movq 0x58(%rax), %r15
movsbl 0x4f(%rsp), %r14d
movq 0x3d5796(%rip), %rax    # 0x63e620
movq 0x50(%rsp), %rsi
movl 0x88(%rsi), %esi
movsbl (%rax,%rsi), %ebp
movsbl 0x4f(%rsp), %ebx
movq 0x50(%rsp), %rax
movq 0x28(%rax), %r11
movsbl 0x4f(%rsp), %r10d
movq 0x50(%rsp), %rax
movq 0x60(%rax), %rax
leaq 0x315533(%rip), %rsi    # 0x57e3f0
movl %r12d, (%rsp)
movq %r15, 0x8(%rsp)
movl %r14d, 0x10(%rsp)
movl %ebp, 0x18(%rsp)
movl %ebx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movl %r10d, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movb $0x0, %al
callq 0x199f0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_evalue_bit_score_generic
static void gt_querymatch_evalue_bit_score_generic(double *evalue_ptr,
                                                   double *bit_score_ptr,
                                                   const GtKarlinAltschulStat
                                                     *karlin_altschul_stat,
                                                   GtUword query_seqlen,
                                                   GtUword matches,
                                                   GtUword mismatches,
                                                   GtUword indels)
{
  if (karlin_altschul_stat != NULL)
  {
    GtUword evalue_searchspace
      = gt_evalue_searchspace(karlin_altschul_stat,query_seqlen);
    GtWord raw_score = gt_evalue_raw_score(karlin_altschul_stat,
                                           matches,
                                           mismatches,
                                           indels);
    *evalue_ptr = gt_evalue_from_raw_score(karlin_altschul_stat,
                                           raw_score,
                                           evalue_searchspace);
    *bit_score_ptr = gt_evalue_raw_score2bit_score(karlin_altschul_stat,
                                                   raw_score);
    gt_assert(*evalue_ptr != DBL_MAX && *bit_score_ptr != DBL_MAX);
  }
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x26922a
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x25f3e0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x2601e0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2605a0
movq 0x40(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2603e0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x2afb85(%rip), %xmm1   # 0x518d50
ucomisd %xmm1, %xmm0
jne 0x2691d5
jp 0x2691d5
jmp 0x2691ee
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x2afb6a(%rip), %xmm1   # 0x518d50
ucomisd %xmm1, %xmm0
jne 0x269226
jp 0x269226
movq 0x3d2dab(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ace14(%rip), %rsi    # 0x516013
leaq 0x315503(%rip), %rdx    # 0x57e709
leaq 0x315530(%rip), %rcx    # 0x57e73d
leaq 0x314f6c(%rip), %r8     # 0x57e180
movl $0x111, %r9d            # imm = 0x111
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x269228
jmp 0x26922a
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_check_final
bool gt_querymatch_check_final(double *evalue_ptr,
                               double *bit_score_ptr,
                               const GtKarlinAltschulStat *karlin_altschul_stat,
                               const GtQuerymatch *querymatch,
                               GtUword userdefinedleastlength,
                               GtUword errorpercentage,
                               double evalue_threshold)
{
  GtUword aligned_len;

  if (!gt_querymatch_ordered(querymatch))
  {
#ifdef SKDEBUG
    fprintf(querymatch->fp, "# !gt_querymatch_ordered => reject\n");
#endif
    return false;
  }
  aligned_len = gt_querymatch_aligned_len(querymatch);
  return gt_querymatch_check_final_generic(
                               evalue_ptr,
                               bit_score_ptr,
                               karlin_altschul_stat,
                               querymatch->query_seqlen,
                               aligned_len,
                               querymatch->distance,
                               querymatch->mismatches,
                               userdefinedleastlength,
                               errorpercentage,
                               evalue_threshold,
                               querymatch->fp);
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x48(%rsp), %rdi
callq 0x269300
testb $0x1, %al
jne 0x26926e
movb $0x0, 0x6f(%rsp)
jmp 0x2692e6
movq 0x48(%rsp), %rdi
callq 0x268da0
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x28(%rsp), %r8
movq 0x48(%rsp), %rax
movq 0x70(%rax), %r9
movq 0x48(%rsp), %rax
movq 0x78(%rax), %rbx
movq 0x40(%rsp), %r11
movq 0x38(%rsp), %r10
movsd 0x30(%rsp), %xmm0
movq 0x48(%rsp), %rax
movq 0x98(%rax), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x268f00
andb $0x1, %al
movb %al, 0x6f(%rsp)
movb 0x6f(%rsp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_ordered
static bool gt_querymatch_ordered(const GtQuerymatch *querymatch)
{
  return (!querymatch->selfmatch ||
          querymatch->dbseqnum < querymatch->queryseqnum ||
          (querymatch->dbseqnum == querymatch->queryseqnum &&
           (querymatch->dbstart_relative <
             (GT_ISDIRREVERSE(querymatch->query_readmode)
                ? (querymatch->querystart_fwdstrand + 1)
                : querymatch->querystart)))) ? true : false;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movb $0x1, %al
testb $0x1, 0x8c(%rcx)
movb %al, -0x9(%rsp)
je 0x2693bb
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rdx
movb $0x1, %al
cmpq 0x28(%rdx), %rcx
movb %al, -0x9(%rsp)
jb 0x2693bb
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpq 0x28(%rdx), %rcx
movb %al, -0xa(%rsp)
jne 0x2693b3
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x1, 0x88(%rax)
je 0x26937d
movq -0x8(%rsp), %rax
cmpl $0x3, 0x88(%rax)
jne 0x269391
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x26939f
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0xa(%rsp)
movb -0xa(%rsp), %al
movb %al, -0x9(%rsp)
movb -0x9(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_readmode_character_code_parse
static GtReadmode gt_readmode_character_code_parse(char direction)
{
  if (direction == 'F')
  {
    return GT_READMODE_FORWARD;
  }
  if (direction == 'P')
  {
    return GT_READMODE_REVCOMPL;
  }
  gt_assert(direction == 'R');
  return GT_READMODE_REVERSE;
}

// Assembly:
pushq %rax
movb %dil, %al
movb %al, 0x3(%rsp)
movsbl 0x3(%rsp), %eax
cmpl $0x46, %eax
jne 0x269ddc
movl $0x0, 0x4(%rsp)
jmp 0x269e3e
movsbl 0x3(%rsp), %eax
cmpl $0x50, %eax
jne 0x269df0
movl $0x3, 0x4(%rsp)
jmp 0x269e3e
jmp 0x269df2
movsbl 0x3(%rsp), %eax
cmpl $0x52, %eax
je 0x269e34
movq 0x3d219d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ac206(%rip), %rsi    # 0x516013
leaq 0x314950(%rip), %rdx    # 0x57e764
leaq 0x31495a(%rip), %rcx    # 0x57e775
leaq 0x31435e(%rip), %r8     # 0x57e180
movl $0x391, %r9d            # imm = 0x391
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x269e36
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_table_sort
void gt_querymatch_table_sort(GtArrayGtQuerymatch *querymatch_table,
                              bool ascending)
{
  if (querymatch_table->nextfreeGtQuerymatch >= 2)
  {
    qsort(querymatch_table->spaceGtQuerymatch,
          querymatch_table->nextfreeGtQuerymatch,
          sizeof *querymatch_table->spaceGtQuerymatch,
          ascending ? gt_querymatch_compare_ascending
                    : gt_querymatch_compare_descending);
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x2, 0x10(%rax)
jb 0x26a662
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movb 0xf(%rsp), %dl
leaq 0x136(%rip), %rcx       # 0x26a780
leaq 0x1f(%rip), %rax        # 0x26a670
testb $0x1, %dl
cmovneq %rax, %rcx
movl $0xb8, %edx
callq 0x19e70
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_compare_ascending
static int gt_querymatch_compare_ascending(const void *va,const void *vb)
{
  const GtQuerymatch *a = (const GtQuerymatch *) va;
  const GtQuerymatch *b = (const GtQuerymatch *) vb;

  gt_assert(a != NULL && b != NULL);
  if (a->queryseqnum < b->queryseqnum ||
       (a->queryseqnum == b->queryseqnum &&
        a->querystart_fwdstrand + gt_querymatch_querylen(a) <=
        b->querystart_fwdstrand + gt_querymatch_querylen(b)))
  {
    return -1;
  }
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x26a6a2
cmpq $0x0, 0x20(%rsp)
jne 0x26a6da
movq 0x3d18f7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ab960(%rip), %rsi    # 0x516013
leaq 0x2e1cb6(%rip), %rdx    # 0x54c370
leaq 0x314172(%rip), %rcx    # 0x57e833
leaq 0x313ab8(%rip), %r8     # 0x57e180
movl $0x49f, %r9d            # imm = 0x49F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26a6dc
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x26a759
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x26a763
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2676a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2676a0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0x26a763
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x26a76b
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_compare_descending
static int gt_querymatch_compare_descending(const void *va,const void *vb)
{
  const GtQuerymatch *a = (const GtQuerymatch *) va;
  const GtQuerymatch *b = (const GtQuerymatch *) vb;

  gt_assert(a != NULL && b != NULL);
  if (a->queryseqnum < b->queryseqnum ||
       (a->queryseqnum == b->queryseqnum &&
        a->querystart_fwdstrand + gt_querymatch_querylen(a) <=
        b->querystart_fwdstrand + gt_querymatch_querylen(b)))
  {
    return 1;
  }
  return -1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x26a7b2
cmpq $0x0, 0x20(%rsp)
jne 0x26a7ea
movq 0x3d17e7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ab850(%rip), %rsi    # 0x516013
leaq 0x2e1ba6(%rip), %rdx    # 0x54c370
leaq 0x314082(%rip), %rcx    # 0x57e853
leaq 0x3139a8(%rip), %r8     # 0x57e180
movl $0x4af, %r9d            # imm = 0x4AF
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26a7ec
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x26a869
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x26a873
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2676a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2676a0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0x26a873
movl $0x1, 0x44(%rsp)
jmp 0x26a87b
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_seed_alignment
static void gt_querymatch_seed_alignment(GtQuerymatch *querymatch,
                                         GtSeqorEncseq *db_seqorencseq,
                                         GtSeqorEncseq *query_seqorencseq)
{
  gt_querymatch_alignment_prepare(querymatch,db_seqorencseq,
                                  query_seqorencseq,true);
  GT_SEQORENCSEQ_ADD_SEQ_COORDS(db_seqorencseq,querymatch->db_seqstart,
                                querymatch->db_seqlen);
  GT_SEQORENCSEQ_ADD_SEQ_COORDS(query_seqorencseq,querymatch->query_seqstart,
                                querymatch->query_seqlen);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl $0x1, %ecx
callq 0x26a2a0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x26ae6e
movq 0x3d1163(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ab1cc(%rip), %rsi    # 0x516013
leaq 0x313a26(%rip), %rdx    # 0x57e874
leaq 0x313a40(%rip), %rcx    # 0x57e895
leaq 0x313324(%rip), %r8     # 0x57e180
movl $0x4fa, %r9d            # imm = 0x4FA
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26ae70
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x26aed7
movq 0x3d10fa(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ab163(%rip), %rsi    # 0x516013
leaq 0x3139fb(%rip), %rdx    # 0x57e8b2
leaq 0x3139d7(%rip), %rcx    # 0x57e895
leaq 0x3132bb(%rip), %r8     # 0x57e180
movl $0x4fc, %r9d            # imm = 0x4FC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26aed9
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_evalue_bit_score
static void gt_querymatch_evalue_bit_score(double *evalue_ptr,
                                           double *bit_score_ptr,
                                           const GtKarlinAltschulStat
                                             *karlin_altschul_stat,
                                           const GtQuerymatch *querymatch)
{
  return gt_querymatch_evalue_bit_score_generic(evalue_ptr,
                                                bit_score_ptr,
                                                karlin_altschul_stat,
                                                querymatch->query_seqlen,
                                                gt_querymatch_matches(
                                                  querymatch),
                                                querymatch->mismatches,
                                                gt_querymatch_indels(
                                                  querymatch));
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x26b510
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x268d40
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x30(%rsp), %r9
movq %rax, (%rsp)
callq 0x269120
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_non_white_space_prefix_length
static int gt_non_white_space_prefix_length(const char *s)
{
  const char *sptr;

  gt_assert(s != NULL);
  for (sptr = s; !isspace(*sptr); sptr++)
  {
    /* Nothing */ ;
  }
  return (int) (sptr - s);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x26b239
movq 0x3d0d98(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2aae01(%rip), %rsi    # 0x516013
leaq 0x331faa(%rip), %rdx    # 0x59d1c3
leaq 0x31344c(%rip), %rcx    # 0x57e66c
leaq 0x312f59(%rip), %r8     # 0x57e180
movl $0x16d, %r9d            # imm = 0x16D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26b23b
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x197c0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x26b26f
jmp 0x26b281
jmp 0x26b271
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x26b245
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_matches
static GtUword gt_querymatch_matches(const GtQuerymatch *querymatch)
{
  const GtUword aligned_len = gt_querymatch_aligned_len(querymatch);
  return gt_querymatch_matches_generic(aligned_len,
                                       querymatch->distance,
                                       querymatch->mismatches);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x268da0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdx
callq 0x269030
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-correct.c
// Function: gt_randomcodes_correct_process_bucket
int gt_randomcodes_correct_process_bucket(void *data,
    const GtUword *bucketofsuffixes, const GtSeqnumrelpos *snrp,
    const uint16_t *lcptab_bucket, GtUword numberofsuffixes,
    GT_UNUSED unsigned int sortingdepth, GT_UNUSED GtError *err)
{
  GtUword itvstart, next_itvstart;
  unsigned int lcpvalue;
  bool haserr = false;
  GtRandomcodesCorrectData *cdata = data;

  for (itvstart = 0, next_itvstart = 1UL; next_itvstart < numberofsuffixes;
      next_itvstart++)
  {
    lcpvalue = (unsigned int) lcptab_bucket[next_itvstart];
    if (lcpvalue < cdata->k)
    {
      gt_randomcodes_correct_process_kmer_itv(bucketofsuffixes + itvstart,
          next_itvstart - itvstart, data);
      itvstart = next_itvstart;
      if (lcpvalue < cdata->k - 1)
      {
        gt_randomcodes_correct_process_kmergroup_end(snrp, data);
      }
    }
  }
  gt_randomcodes_correct_process_kmer_itv(bucketofsuffixes + itvstart,
      numberofsuffixes - itvstart, data);
  gt_randomcodes_correct_process_kmergroup_end(snrp, data);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movb $0x0, 0x13(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x26b630
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x26b61b
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
subq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x26b680
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x26b619
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x26b770
jmp 0x26b61b
jmp 0x26b61d
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x26b598
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
subq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x26b680
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x26b770
movb 0x13(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-correct.c
// Function: gt_randomcodes_correct_process_kmer_itv
static inline void gt_randomcodes_correct_process_kmer_itv(
    const GtUword *suffixes,
    GtUword nofsuffixes,
    GtRandomcodesCorrectData *cdata)
{
  unsigned int i, c = cdata->c;
  cdata->nofkmeritvs++;
  cdata->nofkmers += nofsuffixes;
  if (nofsuffixes < (GtUword)cdata->c)
  {
    cdata->alltrusted = false;
    c = (unsigned int)nofsuffixes;
  }
  for (i = 0; i < c; i++)
  {
    (cdata->kpositions + cdata->currentchar * cdata->c)[i] = suffixes[i];
  }
  cdata->count[cdata->currentchar] = (unsigned int)nofsuffixes;
  cdata->currentchar++;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
addq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movl 0x24(%rcx), %ecx
cmpq %rcx, %rax
jae 0x26b6e2
movq -0x18(%rsp), %rax
movb $0x0, 0x45(%rax)
movq -0x10(%rsp), %rax
movl %eax, -0x20(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x20(%rsp), %eax
jae 0x26b739
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rsp), %rcx
movl 0x40(%rcx), %ecx
movq -0x18(%rsp), %rsi
imull 0x24(%rsi), %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movl -0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x26b6ea
movq -0x10(%rsp), %rax
movl %eax, %edx
movq -0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rsp), %rcx
movl 0x40(%rcx), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rsp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-correct.c
// Function: gt_randomcodes_correct_data_reset
static inline void gt_randomcodes_correct_data_reset(
    GtRandomcodesCorrectData *data)
{
  unsigned int i;
  data->seprange = false;
  data->alltrusted = true;
  data->currentchar = 0;
  for (i = 0; i < data->alphasize; i++)
    data->count[i] = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, 0x44(%rax)
movq -0x8(%rsp), %rax
movb $0x1, 0x45(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x40(%rax)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x26bd9a
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rsp), %ecx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x26bd6b
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-correct.c
// Function: gt_randomcodes_correct_data_delete
void gt_randomcodes_correct_data_delete(GtRandomcodesCorrectData *cdata)
{
  if (cdata == NULL)
    return;
  if (cdata->outfile != NULL)
    gt_fa_fclose(cdata->outfile);
  gt_free(cdata->kpositions);
  gt_free(cdata->count);
  gt_free(cdata);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x26bdae
jmp 0x26be0d
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x26bdc6
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xd9390
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x312b01(%rip), %rsi    # 0x57e8d6
movl $0xe8, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x312ae8(%rip), %rsi    # 0x57e8d6
movl $0xe9, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x312ad3(%rip), %rsi    # 0x57e8d6
movl $0xea, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-correct.c
// Function: gt_randomcodes_correct_data_collect_stats
void gt_randomcodes_correct_data_collect_stats(GtRandomcodesCorrectData *cdata,
    unsigned int threadnum, GtUword *nofkmergroups,
    GtUword *nofkmeritvs, GtUword *nofkmers,
    GtUword *nofcorrections)
{
  GT_RANDOMCODES_COLLECT_STAT(nofkmergroups);
  GT_RANDOMCODES_COLLECT_STAT(nofkmeritvs);
  GT_RANDOMCODES_COLLECT_STAT(nofkmers);
  GT_RANDOMCODES_COLLECT_STAT(nofcorrections);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movl 0x2c(%rsp), %esi
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rdx
leaq 0x312ad1(%rip), %rdi    # 0x57e916
movb $0x0, %al
callq 0xe7740
cmpq $0x0, 0x20(%rsp)
je 0x26be68
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x20(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl 0x2c(%rsp), %esi
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdx
leaq 0x312ab7(%rip), %rdi    # 0x57e933
movb $0x0, %al
callq 0xe7740
cmpq $0x0, 0x18(%rsp)
je 0x26be9f
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x18(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl 0x2c(%rsp), %esi
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rdx
leaq 0x312a9b(%rip), %rdi    # 0x57e94e
movb $0x0, %al
callq 0xe7740
cmpq $0x0, 0x10(%rsp)
je 0x26bed6
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl 0x2c(%rsp), %esi
movq 0x30(%rsp), %rax
movq 0x60(%rax), %rdx
leaq 0x312a7c(%rip), %rdi    # 0x57e966
movb $0x0, %al
callq 0xe7740
cmpq $0x0, 0x8(%rsp)
je 0x26bf0d
movq 0x30(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x8(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-find-seldom.c
// Function: gt_randomcodes_find_seldom_process_bucket
int gt_randomcodes_find_seldom_process_bucket(void *data,
    const GtUword *bucketofsuffixes, const GtSeqnumrelpos *snrp,
    const uint16_t *lcptab_bucket, GtUword numberofsuffixes,
    GT_UNUSED unsigned int sortingdepth, GT_UNUSED GtError *err)
{
  GtUword itvstart, next_itvstart;
  unsigned int lcpvalue;
  GtRandomcodesFindSeldomData *sdata = data;

  for (itvstart = 0, next_itvstart = 1UL; next_itvstart < numberofsuffixes;
      next_itvstart++)
  {
    lcpvalue = (unsigned int) lcptab_bucket[next_itvstart];
    if (lcpvalue < (unsigned int)sdata->k)
    {
      gt_randomcodes_find_seldom_process_kmer_itv(snrp,
          bucketofsuffixes + itvstart, next_itvstart - itvstart, data);
      itvstart = next_itvstart;
    }
  }
  gt_randomcodes_find_seldom_process_kmer_itv(snrp,
      bucketofsuffixes + itvstart, next_itvstart - itvstart, data);
  return 0;
}

// Assembly:
subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x26bfd8
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpl %ecx, %eax
jae 0x26bfc6
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rdx
subq 0x20(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x26c010
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x26bfc8
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x26bf63
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rdx
subq 0x20(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x26c010
xorl %eax, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-find-seldom.c
// Function: gt_randomcodes_find_seldom_process_kmer_itv
static inline void gt_randomcodes_find_seldom_process_kmer_itv(
    const GtSeqnumrelpos *snrp, const GtUword *suffixes,
    GtUword nofsuffixes, GtRandomcodesFindSeldomData *sdata)
{
  GtUword i, relpos, seqnum;
  if (nofsuffixes < sdata->c)
  {
    for (i = 0; i < nofsuffixes; i++)
    {
      relpos = gt_seqnumrelpos_decode_relpos(snrp, suffixes[i]);
      seqnum = gt_seqnumrelpos_decode_seqnum(snrp, suffixes[i]);
      if (seqnum >= sdata->nofreads)
        seqnum = sdata->mirror_nofseqs - seqnum - 1UL;
      if (gt_encseq_seqlength(sdata->encseq, seqnum) - relpos >= sdata->k)
      {
        GT_SETIBIT(sdata->seldom_reads, seqnum);
        sdata->nofseldomkmers++;
        /*
        gt_log_log("seldom "GT_WU"-mer, count="GT_WU", relpos="GT_WU
                   ",seqnum="GT_WU"", sdata->k, nofsuffixes, relpos,
                   seqnum);
         */
      }
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x26c129
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x26c127
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2b1250
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2b1230
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x26c0b2
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
subq (%rsp), %rax
subq $0x1, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
callq 0xb09f0
subq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x26c112
movq (%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x26c114
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x26c045
jmp 0x26c129
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-find-seldom.c
// Function: gt_randomcodes_find_seldom_data_new
GtRandomcodesFindSeldomData *gt_randomcodes_find_seldom_data_new(
    GtEncseq *encseq, unsigned int k, unsigned int c,
    GtBitsequence *seldom_reads)
{
  GtRandomcodesFindSeldomData *sdata = gt_malloc(sizeof *sdata);
  sdata->k = (GtUword)k;
  sdata->c = (GtUword)c;
  sdata->encseq = encseq;
  sdata->mirror_nofseqs = gt_encseq_num_of_sequences(encseq);
  sdata->nofreads = sdata->mirror_nofseqs;
  sdata->seldom_reads = seldom_reads;
  if (gt_encseq_is_mirrored(sdata->encseq))
    sdata->nofreads >>= 1;
  sdata->nofseldomkmers = 0;
  return sdata;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x38, %edi
leaq 0x31288f(%rip), %rsi    # 0x57e9e1
movl $0x58, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movl 0x18(%rsp), %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0xa9d50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xc2ec0
testb $0x1, %al
jne 0x26c1d5
jmp 0x26c1e5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_find_insert
const GtUword *gt_randomcodes_find_insert(const GtRandomcodesinfo *fci,
                                               GtUword code)
{
  const GtUword *found = NULL, *leftptr = NULL, *midptr, *rightptr = NULL;

  leftptr = fci->allrandomcodes + fci->currentminindex;
  rightptr = fci->allrandomcodes + fci->currentmaxindex;
  if (code < *leftptr)
  {
    return leftptr;
  }
  while (leftptr <= rightptr)
  {
    midptr = leftptr + GT_DIV2((GtUword) (rightptr-leftptr));
    if (code < *midptr)
    {
      rightptr = midptr - 1;
      if (code > *rightptr)
      {
        return midptr;
      }
      found = midptr;
    } else
    {
      if (code > *midptr)
      {
        leftptr = midptr + 1;
        if (code <= *leftptr)
        {
          return leftptr;
        }
      } else
      {
        return midptr;
      }
    }
  }
  return found;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq $0x0, -0x38(%rsp)
movq -0x10(%rsp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x30(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rsp)
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x26c895
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x26c967
jmp 0x26c897
movq -0x28(%rsp), %rax
cmpq -0x38(%rsp), %rax
ja 0x26c95d
movq -0x28(%rsp), %rax
movq -0x38(%rsp), %rcx
movq -0x28(%rsp), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shrq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x26c910
movq -0x30(%rsp), %rax
addq $-0x8, %rax
movq %rax, -0x38(%rsp)
movq -0x18(%rsp), %rax
movq -0x38(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x26c904
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x26c967
movq -0x30(%rsp), %rax
movq %rax, -0x20(%rsp)
jmp 0x26c958
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x26c94a
movq -0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
ja 0x26c948
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x26c967
jmp 0x26c956
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x26c967
jmp 0x26c958
jmp 0x26c897
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: run_allcodes_distribution
static void run_allcodes_distribution(const GtUword *allrandomcodes,
                                      GtUword differentcodes)
{
  GtUword idx, diff, mindiff = 0, maxdiff = 0, distbits[64+1] = {0};

  for (idx = 1UL; idx < differentcodes; idx++)
  {
    gt_assert(allrandomcodes[idx-1] < allrandomcodes[idx]);
    diff = allrandomcodes[idx] - allrandomcodes[idx-1];
    if (idx == 1UL || diff < mindiff)
    {
      mindiff = diff;
    }
    if (diff > maxdiff)
    {
      maxdiff = diff;
    }
    distbits[gt_determinebitspervalue(diff)]++;
  }
  printf("allrandomcodes: mindiff=" GT_WU ", maxdiff=" GT_WU "(%u bits)\n",
         mindiff, maxdiff, gt_determinebitspervalue(maxdiff));
  for (idx = 0; idx <= 64UL; idx++)
  {
    if (distbits[idx] > 0)
    {
      printf("" GT_WU " bits: " GT_WU "\n", idx, distbits[idx]);
    }
  }
}

// Assembly:
subq $0x248, %rsp            # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq $0x0, 0x220(%rsp)
movq $0x0, 0x218(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x208, %edx            # imm = 0x208
callq 0x19360
movq $0x1, 0x230(%rsp)
movq 0x230(%rsp), %rax
cmpq 0x238(%rsp), %rax
jae 0x26e755
jmp 0x26e634
movq 0x240(%rsp), %rax
movq 0x230(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x240(%rsp), %rcx
movq 0x230(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jb 0x26e69a
movq 0x3cd937(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a79a0(%rip), %rsi    # 0x516013
leaq 0x310895(%rip), %rdx    # 0x57ef0f
leaq 0x3108ba(%rip), %rcx    # 0x57ef3b
leaq 0x31044d(%rip), %r8     # 0x57ead5
movl $0x359, %r9d            # imm = 0x359
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26e69c
movq 0x240(%rsp), %rax
movq 0x230(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x240(%rsp), %rcx
movq 0x230(%rsp), %rdx
subq $0x1, %rdx
subq (%rcx,%rdx,8), %rax
movq %rax, 0x228(%rsp)
cmpq $0x1, 0x230(%rsp)
je 0x26e6ed
movq 0x228(%rsp), %rax
cmpq 0x220(%rsp), %rax
jae 0x26e6fd
movq 0x228(%rsp), %rax
movq %rax, 0x220(%rsp)
movq 0x228(%rsp), %rax
cmpq 0x218(%rsp), %rax
jbe 0x26e71f
movq 0x228(%rsp), %rax
movq %rax, 0x218(%rsp)
movq 0x228(%rsp), %rdi
callq 0xec660
movl %eax, %eax
movq 0x10(%rsp,%rax,8), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp,%rax,8)
movq 0x230(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x230(%rsp)
jmp 0x26e61c
movq 0x220(%rsp), %rax
movq %rax, (%rsp)
movq 0x218(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x218(%rsp), %rdi
callq 0xec660
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movl %eax, %ecx
leaq 0x3107c8(%rip), %rdi    # 0x57ef55
movb $0x0, %al
callq 0x19070
movq $0x0, 0x230(%rsp)
cmpq $0x40, 0x230(%rsp)
ja 0x26e7f6
movq 0x230(%rsp), %rax
cmpq $0x0, 0x10(%rsp,%rax,8)
jbe 0x26e7de
movq 0x230(%rsp), %rsi
movq 0x230(%rsp), %rax
movq 0x10(%rsp,%rax,8), %rdx
leaq 0x3107b1(%rip), %rdi    # 0x57ef88
movb $0x0, %al
callq 0x19070
jmp 0x26e7e0
movq 0x230(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x230(%rsp)
jmp 0x26e7a0
addq $0x248, %rsp            # imm = 0x248
retq
nop