LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_all_sorted
GtUword gt_seedextend_match_iterator_all_sorted(GtSeedextendMatchIterator *semi,
                                                bool ascending)

{
  GtQuerymatch *querymatchptr;
  gt_assert(semi != NULL);

  while ((querymatchptr = gt_seedextend_match_iterator_next(semi)) != NULL)
  {
    gt_querymatch_table_add(&semi->querymatch_table,querymatchptr);
  }
  gt_querymatch_table_sort(&semi->querymatch_table,ascending);
  semi->currentmatchindex = 0;
  semi->currentmatch = NULL;
  return semi->querymatch_table.nextfreeGtQuerymatch;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1e9bb7
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1e9928
testq %rax, %rax
je 0x1e9b94
leaq 0x88(%rbx), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c3882
movq %rbx, %rdi
callq 0x1e9928
testq %rax, %rax
jne 0x1e9b7c
leaq 0x88(%rbx), %rdi
movzbl %bpl, %esi
callq 0x1c4f77
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq 0x98(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x762e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_querymatchoutoptions_set
int gt_seedextend_match_iterator_querymatchoutoptions_set(
                    GtSeedextendMatchIterator *semi,
                    bool always_polished_ends,
                    GtExtendCharAccess a_extend_char_access,
                    GtExtendCharAccess b_extend_char_access,
                    const GtSeedExtendDisplayFlag *out_display_flag,
                    GtError *err)
{
  double matchscore_bias = GT_DEFAULT_MATCHSCORE_BIAS;

  semi->querymatchoutoptions
    = gt_querymatchoutoptions_new(out_display_flag,gt_str_get(semi->ii),err);
  if (semi->querymatchoutoptions == NULL)
  {
    return -1;
  }
  gt_assert(semi->in_display_flag != NULL && out_display_flag != NULL);
  if (gt_querymatch_cigar_display(semi->in_display_flag) &&
      gt_querymatch_cigarX_display(out_display_flag))
  {
    gt_error_set(err,"match file with alignments in cigar format cannot be "
                     "converted to cigarX format");
    return -1;
  }
  if (gt_seedextend_match_iterator_bias_parameters(semi))
  {
    matchscore_bias = gt_greedy_dna_sequence_bias_get(semi->aencseq);
  }
  gt_querymatchoutoptions_for_align_only(semi->querymatchoutoptions,
                            semi->errorpercentage,
                            matchscore_bias,
                            gt_seedextend_match_iterator_history_size(semi),
                            always_polished_ends,
                            a_extend_char_access,
                            b_extend_char_access,
                            out_display_flag);
  gt_querymatch_outoptions_set(semi->querymatchptr,semi->querymatchoutoptions);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %r15
movl %ecx, 0x14(%rsp)
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x120d23
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1c1d54
movq %rax, 0x80(%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1e9cb8
testq %r15, %r15
je 0x1e9cc9
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x1e9cc9
callq 0x1c2b43
testb %al, %al
je 0x1e9c69
movq %r15, %rdi
callq 0x1c2b54
testb %al, %al
je 0x1e9c69
leaq 0x1d31a6(%rip), %rsi    # 0x3bce03
movq %r13, %rdi
xorl %eax, %eax
callq 0x1019cf
jmp 0x1e9cb8
cmpb $0x1, 0x11(%rbx)
jne 0x1e9c7a
movq 0x18(%rbx), %rdi
callq 0x1ea072
jmp 0x1e9c82
movsd 0x1655a6(%rip), %xmm0   # 0x34f228
movq 0x80(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %r15, (%rsp)
movzbl %r12b, %ecx
movl %r14d, %r8d
movl 0x14(%rsp), %r9d
callq 0x1c1fbc
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rsi
callq 0x1c3942
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x76359
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_xdrop_matchinfo_new
GtXdropmatchinfo *gt_xdrop_matchinfo_new(GtUword userdefinedleastlength,
                                         GtUword errorpercentage,
                                         double evalue_threshold,
                                         GtXdropscore xdropbelowscore,
                                         GtUword sensitivity)
{
  GtXdropmatchinfo *xdropmatchinfo = gt_malloc(sizeof *xdropmatchinfo);

  xdropmatchinfo->useq = gt_seqabstract_new_empty();
  xdropmatchinfo->vseq = gt_seqabstract_new_empty();
  xdropmatchinfo->arbitscores.mat = 2;
  xdropmatchinfo->arbitscores.mis = -1;
  xdropmatchinfo->arbitscores.ins = -2;
  xdropmatchinfo->arbitscores.del = -2;
  xdropmatchinfo->res = gt_xdrop_resources_new(&xdropmatchinfo->arbitscores);
  xdropmatchinfo->userdefinedleastlength = userdefinedleastlength;
  xdropmatchinfo->errorpercentage = errorpercentage;
  xdropmatchinfo->evalue_threshold = evalue_threshold;
  if (xdropbelowscore == 0)
  {
    xdropmatchinfo->belowscore = gt_optimalxdropbelowscore(errorpercentage,
                                                           sensitivity);
  } else
  {
    xdropmatchinfo->belowscore = xdropbelowscore;
  }
  return xdropmatchinfo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r13
leaq 0x1d4157(%rip), %rsi    # 0x3bdea4
movl $0x98, %edi
movl $0x43, %edx
callq 0x1092b2
movq %rax, %r15
callq 0x1ec02a
movq %rax, 0x70(%r15)
callq 0x1ec02a
movq %rax, 0x78(%r15)
movaps 0x1d3138(%rip), %xmm0   # 0x3bceb0
movups %xmm0, (%r15)
movq %r15, %rdi
callq 0x20cd7d
movq %rax, 0x10(%r15)
movq %r13, 0x80(%r15)
movq %r12, 0x88(%r15)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x90(%r15)
testq %rbx, %rbx
jne 0x1e9db8
movq %r12, %rdi
movq %r14, %rsi
callq 0x1e9cec
movq %rax, %rbx
movq %rbx, 0x68(%r15)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_xdrop_matchinfo_delete
void gt_xdrop_matchinfo_delete(GtXdropmatchinfo *xdropmatchinfo)
{
  if (xdropmatchinfo != NULL)
  {
    gt_seqabstract_delete(xdropmatchinfo->useq);
    gt_seqabstract_delete(xdropmatchinfo->vseq);
    gt_xdrop_resources_delete(xdropmatchinfo->res);
    gt_free(xdropmatchinfo);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1e9e23
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
callq 0x1ec2af
movq 0x78(%rbx), %rdi
callq 0x1ec2af
movq 0x10(%rbx), %rdi
callq 0x20ce46
leaq 0x1d408f(%rip), %rsi    # 0x3bdea4
movq %rbx, %rdi
movl $0x69, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_sesp_show
void gt_sesp_show(const GtSeedextendSeqpair *sesp)
{
  printf("db_seedpos=" GT_WU ",query_seedpos=" GT_WU ",seedlength=" GT_WU "\n",
           gt_sesp_db_seedpos(sesp),
           gt_sesp_query_seedpos(sesp),
           sesp->seedlength);
  printf("dbseqnum=" GT_WU ",db_seqstart=" GT_WU ",dpseqlength="
                 GT_WU "\n",
                   sesp->dbseqnum,
                   sesp->db_seqstart,
                   sesp->dbseqlength);
  printf("queryseqnum=" GT_WU ",query_seqstart=" GT_WU ",query_seqlen="
         GT_WU "\n",sesp->queryseqnum,sesp->query_seqstart,sesp->query_seqlen);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1e9e8d
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e9e9d
movq 0x40(%rbx), %rcx
leaq 0x1d4076(%rip), %rdi    # 0x3bdebc
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq 0x10(%rbx), %rdx
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
leaq 0x1d4088(%rip), %rdi    # 0x3bdeed
xorl %eax, %eax
callq 0x17070
movq 0x30(%rbx), %rdx
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rcx
leaq 0x1d409c(%rip), %rdi    # 0x3bdf1b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_greedy_extend_char_access
int gt_greedy_extend_char_access(GtExtendCharAccess *cam_a,
                                 GtExtendCharAccess *cam_b,
                                 const char *full_cam_string,
                                 GtError *err)
{
  const char *comma_ptr = strchr(full_cam_string,(int) ',');
  int had_err = 0;

  if (comma_ptr != NULL)
  {
    char *copy = strdup(full_cam_string);
    size_t comma_pos = (size_t) (comma_ptr - full_cam_string);

    copy[comma_pos] = '\0';
    *cam_a = gt_parse_char_access(copy,err);
    if ((int) *cam_a == -1)
    {
      had_err = -1;
    } else
    {
      *cam_b = gt_parse_char_access(comma_ptr + 1,err);
      if ((int) *cam_b == -1)
      {
        had_err = -1;
      }
    }
    free(copy);
  } else
  {
    *cam_b = *cam_a = gt_parse_char_access(full_cam_string,err);
    if ((int) *cam_b == -1)
    {
      had_err = -1;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r12
movq %rdx, %rdi
movl $0x2c, %esi
callq 0x17280
testq %rax, %rax
je 0x1e9f37
movq %rax, %r13
movq %rbp, %rdi
callq 0x17e80
movq %rax, %r15
movq %r13, %rax
subq %rbp, %rax
movb $0x0, (%r15,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e9f72
movl %eax, (%r12)
cmpl $-0x1, %eax
je 0x1e9f54
incq %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x1e9f72
movl %eax, (%rbx)
xorl %ebx, %ebx
cmpl $-0x1, %eax
sete %bl
negl %ebx
jmp 0x1e9f59
movq %rbp, %rdi
movq %r14, %rsi
callq 0x1e9f72
movl %eax, (%r12)
movl %eax, (%rbx)
xorl %ebx, %ebx
cmpl $-0x1, %eax
sete %bl
negl %ebx
jmp 0x1e9f61
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0x17fe8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_parse_char_access
static int gt_parse_char_access(const char *cam_string,GtError *err)
{
  if (strcmp(cam_string,"encseq") == 0)
  {
    return GT_EXTEND_CHAR_ACCESS_ENCSEQ;
  }
  if (strcmp(cam_string,"encseq_reader") == 0)
  {
    return GT_EXTEND_CHAR_ACCESS_ENCSEQ_READER;
  }
  if (strcmp(cam_string,"bytes") == 0)
  {
    return GT_EXTEND_CHAR_ACCESS_DIRECT;
  }
  if (strcmp(cam_string,"any") == 0)
  {
    return GT_EXTEND_CHAR_ACCESS_ANY;
  }
  gt_error_set(err,"illegal parameter for option -cam: %s",
                    gt_cam_extendgreedy_comment());
  return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1a6653(%rip), %rsi    # 0x3905d6
callq 0x17a40
testl %eax, %eax
je 0x1e9fe4
leaq 0x1ff010(%rip), %rsi    # 0x3e8fa3
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1e9fe8
leaq 0x1c3830(%rip), %rsi    # 0x3ad7d6
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1e9fef
leaq 0x1d4071(%rip), %rsi    # 0x3be02a
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1e9ff6
leaq 0x1d437f(%rip), %rsi    # 0x3be34b
leaq 0x1d3f98(%rip), %rdx    # 0x3bdf6b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1e9ffb
xorl %eax, %eax
jmp 0x1e9ffb
movl $0x1, %eax
jmp 0x1e9ffb
movl $0x2, %eax
jmp 0x1e9ffb
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_greedy_dna_sequence_bias_get
double gt_greedy_dna_sequence_bias_get(const GtEncseq *encseq)
{
  GtUword atcount, gccount;

  gt_greedy_at_gc_count(&atcount,&gccount,encseq);
  if (atcount + gccount > 0) /* for DNA sequence */
  {
    double ratio;
    int bias_index;

    ratio = (double) GT_MIN(atcount, gccount) / (atcount + gccount);
    bias_index = (int) GT_MAX(0.0, (ratio + 0.025) * 20.0 - 1.0);
    gt_assert(bias_index < sizeof bias_factor/sizeof bias_factor[0]);
    return bias_factor[bias_index];
  }
  return GT_DEFAULT_MATCHSCORE_BIAS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xf02da
movq %rax, %r14
movq %rbx, %rdi
callq 0xec1d8
testq %rax, %rax
je 0x1ea186
movq %r14, %rdi
callq 0xd3c75
testb %al, %al
je 0x1ea0e1
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf02fa
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0xf02fa
movq %rax, %r14
addq %r15, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf02fa
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf02fa
addq %r15, %rax
jmp 0x1ea0e6
xorl %r14d, %r14d
xorl %eax, %eax
movq %rax, %rcx
addq %r14, %rcx
je 0x1ea178
cmpq %rax, %r14
cmovbq %r14, %rax
movq %rax, %xmm0
movq 0x1667da(%rip), %xmm1   # 0x3508e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1667de(%rip), %xmm2   # 0x3508f0
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq %rcx, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
addsd 0x1d2d79(%rip), %xmm3   # 0x3bcec0
mulsd 0x1c6071(%rip), %xmm3   # 0x3b01c0
addsd 0x18ae61(%rip), %xmm3   # 0x374fb8
xorpd %xmm0, %xmm0
maxsd %xmm3, %xmm0
cvttsd2si %xmm0, %eax
cmpl $0xa, %eax
jae 0x1ea18b
movl %eax, %eax
leaq 0x1d3c5f(%rip), %rcx    # 0x3bddd0
movsd (%rcx,%rax,8), %xmm0
jmp 0x1ea180
movsd 0x1650a8(%rip), %xmm0   # 0x34f228
popq %rbx
popq %r14
popq %r15
retq
callq 0x76554
callq 0x7651b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_greedy_show_matchscore_table
void gt_greedy_show_matchscore_table(void)
{
  const int numentries = sizeof bias_factor/sizeof bias_factor[0];
  int idx;

  for (idx = numentries - 1; idx >= 0; idx--)
  {
    if (idx == numentries - 1 || bias_factor[idx] != bias_factor[idx+1])
    {
      GtUword correlation;
      double matchscore_bias = bias_factor[idx];

      for (correlation = 70UL; correlation <= 99UL; correlation++)
      {
        GtUword minmatchnum;
        const GtWord match_score
          = (GtUword) (1000.0 * (1.0 - correlation / 100.0) * matchscore_bias);
        GtUword difference_score;
        gt_assert(match_score <= 1000.0);
        difference_score = 1000.0 - match_score;
        minmatchnum
          = (GtUword) (60 *
                       (1.0 - matchscore_bias * (1.0 - correlation/100.0))),
        printf("correlation=%.2f, mscore=" GT_WD ", dscore=" GT_WD
               ", ave_path=" GT_WU ", bias=%.4f\n",
               correlation / 100.0,
               match_score,
               difference_score,
               minmatchnum,
               matchscore_bias);
      }
      printf("\n");
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x9, %r14d
leaq 0x1d3c28(%rip), %r15    # 0x3bddd0
movsd 0x165078(%rip), %xmm4   # 0x34f228
movsd 0x1a34b8(%rip), %xmm3   # 0x38d670
movsd 0x166b60(%rip), %xmm5   # 0x350d20
leaq 0x1d3f20(%rip), %rbx    # 0x3be0e7
cmpq $0x9, %r14
je 0x1ea1e2
movsd (%r15,%r14,8), %xmm0
ucomisd 0x8(%r15,%r14,8), %xmm0
jne 0x1ea1e2
jnp 0x1ea302
movsd (%r15,%r14,8), %xmm1
movapd %xmm1, %xmm0
xorpd 0x16e88c(%rip), %xmm0   # 0x358a80
movapd %xmm0, (%rsp)
movl $0x46, %r12d
movapd %xmm1, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
divsd 0x1685db(%rip), %xmm0   # 0x3527f0
movapd %xmm4, %xmm6
subsd %xmm0, %xmm6
movapd %xmm6, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
subsd %xmm5, %xmm2
cvttsd2si %xmm2, %rsi
sarq $0x3f, %rcx
andq %rcx, %rsi
orq %rax, %rsi
cmpq $0x3e9, %rsi            # imm = 0x3E9
jge 0x1ea318
xorps %xmm2, %xmm2
cvtsi2sd %rsi, %xmm2
movsd 0x1a340f(%rip), %xmm3   # 0x38d670
subsd %xmm2, %xmm3
cvttsd2si %xmm3, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd %xmm5, %xmm3
cvttsd2si %xmm3, %rdx
andq %rcx, %rdx
mulsd (%rsp), %xmm6
addsd %xmm4, %xmm6
mulsd 0x1d2c3a(%rip), %xmm6   # 0x3bcec8
cvttsd2si %xmm6, %rdi
orq %rax, %rdx
movq %rdi, %rax
sarq $0x3f, %rax
subsd %xmm5, %xmm6
cvttsd2si %xmm6, %rcx
andq %rax, %rcx
orq %rdi, %rcx
movq %rbx, %rdi
movb $0x2, %al
callq 0x17070
movaps 0x10(%rsp), %xmm1
movsd 0x166a5d(%rip), %xmm5   # 0x350d20
movsd 0x1a33a5(%rip), %xmm3   # 0x38d670
movsd 0x164f55(%rip), %xmm4   # 0x34f228
incq %r12
cmpq $0x64, %r12
jne 0x1ea205
movl $0xa, %edi
callq 0x17a20
movsd 0x166a2e(%rip), %xmm5   # 0x350d20
movsd 0x1a3376(%rip), %xmm3   # 0x38d670
movsd 0x164f26(%rip), %xmm4   # 0x34f228
subq $0x1, %r14
jae 0x1ea1c7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x7658d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_greedy_extend_matchinfo_delete
void gt_greedy_extend_matchinfo_delete(GtGreedyextendmatchinfo *ggemi)
{
  if (ggemi != NULL)
  {
    front_trace_delete(ggemi->left_front_trace);
    front_trace_delete(ggemi->right_front_trace);
    gt_encseq_reader_delete(ggemi->encseq_r_in_u);
    gt_encseq_reader_delete(ggemi->encseq_r_in_v);
    gt_free(ggemi->usequence_cache.space);
    gt_free(ggemi->vsequence_cache.space);
    gt_free(ggemi->frontspace_reservoir.space);
    gt_free(ggemi);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1ea4ae
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3243c5
movq 0x8(%rbx), %rdi
callq 0x3243c5
movq 0x58(%rbx), %rdi
callq 0xed7bf
movq 0x60(%rbx), %rdi
callq 0xed7bf
movq 0x68(%rbx), %rdi
leaq 0x1d3a42(%rip), %r14    # 0x3bdea4
movq %r14, %rsi
movl $0x241, %edx            # imm = 0x241
callq 0x109670
movq 0x80(%rbx), %rdi
movq %r14, %rsi
movl $0x242, %edx            # imm = 0x242
callq 0x109670
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x243, %edx            # imm = 0x243
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x244, %edx            # imm = 0x244
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_minidentity2errorpercentage
GtUword gt_minidentity2errorpercentage(GtUword minidentity)
{
  if (minidentity >= 1 &&
      minidentity <= 100 - GT_EXTEND_MIN_IDENTITY_PERCENTAGE)
  {
    return minidentity;
  } else
  {
    gt_assert(minidentity >= GT_EXTEND_MIN_IDENTITY_PERCENTAGE);
    return 100 - minidentity;
  }
}

// Assembly:
leaq -0x1(%rdi), %rax
cmpq $0x1e, %rax
jb 0x1ea925
cmpq $0x45, %rdi
jbe 0x1ea929
movl $0x64, %eax
subq %rdi, %rax
movq %rax, %rdi
movq %rdi, %rax
retq
pushq %rax
callq 0x7671c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_extend_seed_relative
static bool gt_extend_seed_relative(bool forxdrop,
                                    void *info,
                                    const GtSeqorEncseq *dbes,
                                    GtUword dbseqnum,
                                    GtUword dbstart_relative,
                                    const GtSeqorEncseq *queryes,
                                    bool same_encseq,
                                    GtUword queryseqnum,
                                    GtUword querystart_relative,
                                    GtUword len,
                                    GtReadmode query_readmode)
{
  GtSeedextendSeqpair sesp;

  sesp.db_seqstart = (dbes->encseq != NULL) ?  dbes->seqstartpos : 0;
  sesp.dbseqlength = dbes->seqlength;
  sesp.query_seqstart = (queryes->encseq != NULL) ? queryes->seqstartpos : 0;
  sesp.query_seqlen = queryes->seqlength;
  gt_sesp_from_relative(&sesp,
                        dbseqnum,
                        dbstart_relative,
                        same_encseq,
                        queryseqnum,
                        querystart_relative,
                        len,
                        query_readmode);
  return gt_extend_sesp(forxdrop, info, dbes, queryes, &sesp);
}

// Assembly:
cmpq $0x0, 0x8(%rdx)
je 0x1eac05
movq 0x18(%rdx), %rax
jmp 0x1eac07
xorl %eax, %eax
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl 0xa0(%rsp), %r10d
movq 0x98(%rsp), %r14
movq 0x90(%rsp), %r11
movq 0x88(%rsp), %rbx
movb 0x80(%rsp), %bpl
movq %rax, 0x18(%rsp)
movq 0x20(%rdx), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x8(%r9)
je 0x1eac54
movq 0x18(%r9), %r15
jmp 0x1eac57
xorl %r15d, %r15d
leaq 0x8(%rsp), %rax
movq %r15, 0x30(%rax)
movq 0x20(%r9), %r15
movq %r15, 0x28(%rax)
movb %bpl, 0x4c(%rax)
movq %r14, 0x40(%rax)
movq %rcx, (%rax)
movq %rbx, 0x20(%rax)
movq %r8, 0x18(%rax)
movq %r11, 0x38(%rax)
movl %r10d, 0x48(%rax)
movzbl %dil, %edi
movq %r9, %rcx
movq %rax, %r8
callq 0x1eb039
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_rf_extend_selfmatch_with_output
static void gt_sesp_from_absolute(GtSeedextendSeqpair *sesp,
                                  const GtEncseq *dbencseq,
                                  GtUword pos1,
                                  const GtEncseq *queryencseq,
                                  bool same_encseq,
                                  GtUword pos2,
                                  GtUword len)
{
  gt_assert(pos1 < pos2);
  sesp->same_encseq = same_encseq;
  sesp->seedlength = len;
  sesp->dbseqnum = gt_encseq_seqnum(dbencseq,pos1),
  sesp->db_seqstart = gt_encseq_seqstartpos(dbencseq,sesp->dbseqnum),
  sesp->dbseqlength = gt_encseq_seqlength(dbencseq,sesp->dbseqnum);
  if (dbencseq == queryencseq && pos2 < sesp->db_seqstart + sesp->dbseqlength)
  { /* second match in same sequence */
    sesp->queryseqnum = sesp->dbseqnum;
    sesp->query_seqstart = sesp->db_seqstart;
    sesp->query_seqlen = sesp->dbseqlength;
  } else
  {
    sesp->queryseqnum = gt_encseq_seqnum(queryencseq,pos2);
    gt_assert(dbencseq != queryencseq || sesp->dbseqnum < sesp->queryseqnum);
    sesp->query_seqstart = gt_encseq_seqstartpos(queryencseq,sesp->queryseqnum);
    sesp->query_seqlen = gt_encseq_seqlength(queryencseq,sesp->queryseqnum);
  }
  gt_assert(sesp->db_seqstart <= pos1);
  sesp->dbstart_relative = pos1 - sesp->db_seqstart;
  gt_assert(sesp->query_seqstart <= pos2);
  sesp->querystart_relative = pos2 - sesp->query_seqstart;
  sesp->query_readmode = GT_READMODE_FORWARD;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
cmpq %r9, %r8
jae 0x1eae35
movq %r9, %r15
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movb $0x1, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq %rdx, %rdi
movq %r8, %rsi
callq 0xefc48
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %rax, %rsi
callq 0xefce0
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xeffd3
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax), %rdx
cmpq %r15, %rdx
jbe 0x1ead80
movq 0x8(%rsp), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, 0x38(%rsp)
jmp 0x1eadb8
movq %r14, %rdi
movq %r15, %rsi
callq 0xefc48
movq %rax, 0x28(%rsp)
cmpq %rax, 0x8(%rsp)
jae 0x1eae44
movq %r14, %rdi
movq %rax, %rsi
callq 0xefce0
movq %rax, 0x38(%rsp)
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xeffd3
movq %rax, 0x30(%rsp)
subq 0x18(%rsp), %r12
jb 0x1eae3a
movq %r12, 0x20(%rsp)
subq 0x38(%rsp), %r15
jb 0x1eae3f
leaq 0x8(%rsp), %r8
movq %r15, 0x38(%r8)
movl $0x0, 0x48(%r8)
leaq 0x58(%rsp), %rcx
movq %r14, 0x8(%rcx)
xorl %eax, %eax
movq %rax, (%rcx)
movq %rax, 0x10(%rcx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x18(%rcx)
movq %rax, 0x28(%rcx)
movw $0x100, 0x30(%rcx)      # imm = 0x100
movzbl %bpl, %ebp
movl %ebp, %edi
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x1eb039
testb %al, %al
je 0x1eae25
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1eb74c
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x768e4
callq 0x7698f
callq 0x76956
callq 0x7691d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_seqabstract_reinit_generic
static void gt_seqabstract_reinit_generic(bool rightextension,
                                          GtReadmode query_readmode,
                                          GtSeqabstract *seqabstract,
                                          const GtSeqorEncseq *seqorencseq,
                                          GtUword len,
                                          GtUword offset,
                                          GtUword seqstartpos,
                                          GtUword seqlength)
{
  if (seqorencseq->encseq != NULL)
  {
    /* it is important to set it before the next call */
    if (GT_ISDIRREVERSE(query_readmode))
    {
      gt_seqabstract_seqstartpos_set(seqabstract,seqstartpos);
      gt_seqabstract_totallength_set(seqabstract,seqlength);
    }
    gt_seqabstract_reinit_encseq(rightextension,
                                 query_readmode,
                                 seqabstract,
                                 seqorencseq->encseq,
                                 len,
                                 offset);
  } else
  {
    gt_seqabstract_reinit_gtuchar(rightextension,
                                  query_readmode,
                                  seqabstract,
                                  seqorencseq->seq,
                                  len,
                                  offset,
                                  seqlength);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r12d
movq 0x58(%rsp), %rbx
cmpq $0x0, 0x8(%rcx)
je 0x1eb724
movl %ebp, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x1eb701
movq 0x50(%rsp), %rsi
movq %r15, %rdi
movq %r9, 0x10(%rsp)
callq 0x1ec068
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1ec078
movq 0x10(%rsp), %r9
movq 0x8(%r13), %rcx
movzbl %r12b, %edi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ec1ee
movq (%r13), %rcx
movq %rbx, (%rsp)
movzbl %r12b, %edi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %r8
callq 0x1ec088
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_rf_seed_extend_prettyprint
static void gt_rf_seed_extend_prettyprint(bool forxdrop,void *info)
{
  GtProcessinfo_and_querymatchspaceptr *info_querymatch
    = (GtProcessinfo_and_querymatchspaceptr *) info;
  GtUword userdefinedleastlength, errorpercentage;
  double evalue = 0.0, bit_score = 0.0, evalue_threshold = 0.0;

  gt_assert(info_querymatch != NULL);
  if (forxdrop)
  {
    GtXdropmatchinfo *xdropmatchinfo = info_querymatch->processinfo;
    userdefinedleastlength = xdropmatchinfo->userdefinedleastlength;
    errorpercentage = xdropmatchinfo->errorpercentage;
    evalue_threshold = xdropmatchinfo->evalue_threshold;
  } else
  {
    GtGreedyextendmatchinfo *ggemi = info_querymatch->processinfo;
    userdefinedleastlength = ggemi->userdefinedleastlength;
    errorpercentage = ggemi->errorpercentage;
    evalue_threshold = ggemi->evalue_threshold;
  }
  if (gt_querymatch_check_final(&evalue,
                                &bit_score,
                                info_querymatch->karlin_altschul_stat,
                                info_querymatch->querymatchspaceptr,
                                userdefinedleastlength,
                                errorpercentage,
                                evalue_threshold))
  {
    gt_querymatch_prettyprint(evalue,bit_score,
                              info_querymatch->out_display_flag,
                              info_querymatch->querymatchspaceptr);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
testq %rsi, %rsi
je 0x1eb7d7
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq 0x38(%rax), %rdx
leaq 0x80(%rax), %rsi
leaq 0x40(%rax), %r8
leaq 0x88(%rax), %r9
leaq 0x48(%rax), %r10
addq $0x90, %rax
testb %dil, %dil
cmovneq %rsi, %rdx
cmoveq %r8, %r9
cmoveq %r10, %rax
movq (%rdx), %r8
movq (%r9), %r9
movsd (%rax), %xmm0
movq 0x10(%rbx), %rdx
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x1c45f8
testb %al, %al
je 0x1eb7d1
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x1c3b64
addq $0x10, %rsp
popq %rbx
retq
callq 0x76ce4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_seqendpos
GtUword gt_sequence_parts_info_seqendpos(const GtSequencePartsInfo *spi,
                                         GtUword seqnum)
{
  if (spi->ssptab != NULL)
  {
    return seqnum < spi->numofsequences - 1 ? (spi->ssptab[seqnum] - 1)
                                            : (spi->totallength - 1);
  } else
  {
    return (seqnum + 1) * (spi->same_length + 1) - 2;
  }
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1eb828
movq 0x20(%rdi), %rcx
decq %rcx
addq $0x18, %rdi
cmpq %rsi, %rcx
leaq (%rax,%rsi,8), %rax
cmovbeq %rdi, %rax
movq (%rax), %rax
decq %rax
retq
incq %rsi
movq 0x10(%rdi), %rax
incq %rax
imulq %rsi, %rax
addq $-0x2, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_delete
void gt_sequence_parts_info_delete(GtSequencePartsInfo *spi)
{
  if (spi != NULL)
  {
    gt_free(spi->ssptab);
    gt_free(spi->ranges);
    gt_free(spi);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1ebca8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1d2a55(%rip), %r14    # 0x3be6c9
movq %r14, %rsi
movl $0xd9, %edx
callq 0x109670
movq (%rbx), %rdi
movq %r14, %rsi
movl $0xda, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0xdb, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_overlap
bool gt_sequence_parts_info_overlap(const GtSequencePartsInfo *spia,
                                    GtUword aidx,
                                    const GtSequencePartsInfo *spib,
                                    GtUword bidx)
{
  GtRange range_a, range_b;

  range_a.start = gt_sequence_parts_info_start_get(spia,aidx);
  range_a.end = gt_sequence_parts_info_end_get(spia,aidx);
  range_b.start = gt_sequence_parts_info_start_get(spib,bidx);
  range_b.end = gt_sequence_parts_info_end_get(spib,bidx);
  return gt_range_overlap(&range_a,&range_b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1ebca9
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1ebcc6
movq %rax, 0x8(%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ebca9
movq %rsp, %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ebcc6
movq %rax, 0x8(%r15)
movq %r13, %rdi
movq %r15, %rsi
callq 0x117826
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_equal
bool gt_sequence_parts_info_equal(const GtSequencePartsInfo *spia,
                                  GtUword aidx,
                                  const GtSequencePartsInfo *spib,
                                  GtUword bidx)
{
  return (gt_sequence_parts_info_start_get(spia,aidx) ==
          gt_sequence_parts_info_start_get(spib,bidx)) &&
         (gt_sequence_parts_info_end_get(spia,aidx) ==
          gt_sequence_parts_info_end_get(spib,bidx)) ? true : false;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1ebca9
movq %rax, %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ebca9
cmpq %rax, %r13
jne 0x1ebe02
movq %r12, %rdi
movq %r15, %rsi
callq 0x1ebcc6
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ebcc6
cmpq %rax, %r15
sete %al
jmp 0x1ebe04
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_variance_show
void gt_sequence_parts_info_variance_show(const GtSequencePartsInfo *spi)
{
  GtUword variance_sum = 0, idx, avgpartlength;

  avgpartlength = spi->totallength/spi->parts_number;
  for (idx = 0; idx < spi->parts_number; idx++)
  {
    const GtUword partlength
      = gt_sequence_parts_info_partlength(
             spi,
             gt_sequence_parts_info_start_get(spi,idx),
             gt_sequence_parts_info_end_get(spi,idx));
    if (partlength > avgpartlength)
    {
      GtUword diff = partlength - avgpartlength;
      variance_sum += diff * diff;
    } else
    {
      GtUword diff = avgpartlength - partlength;
      variance_sum += diff * diff;
    }
    printf("# Part " GT_WU ": sequence " GT_WU "..." GT_WU ", total length="
           GT_WU ", max_length=" GT_WU "\n",idx+1,
           gt_sequence_parts_info_start_get(spi,idx),
           gt_sequence_parts_info_end_get(spi,idx),
           partlength,
           gt_sequence_parts_info_max_length_get(spi,idx));
  }
  printf("# Variance of parts is %.2e\n",
           (double) variance_sum/spi->parts_number);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
xorl %edx, %edx
divq 0x28(%rdi)
movq %rax, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ebca9
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ebcc6
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1eb83b
movq %rax, %r13
subq %r14, %rax
ja 0x1ebe6c
movq %r14, %rax
subq %r13, %rax
imulq %rax, %rax
addq %rax, %r15
leaq 0x1(%r12), %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ebca9
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ebcc6
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ebd27
leaq 0x1d29ea(%rip), %rdi    # 0x3be892
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x17070
movq 0x28(%rbx), %rax
movq %rbp, %r12
cmpq %rax, %rbp
movq 0x8(%rsp), %r14
jb 0x1ebe37
movq %r15, %xmm1
movq 0x1649fe(%rip), %xmm2   # 0x3508e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x164a02(%rip), %xmm3   # 0x3508f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
leaq 0x1d29b2(%rip), %rdi    # 0x3be8d4
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_seq_extract
GtUchar *gt_sequence_parts_info_seq_extract(const GtEncseq *encseq,
                                            const GtSequencePartsInfo *spi,
                                            GtUword idx)
{
  GtUchar *byte_sequence;
  const GtUword
    firstseqnum = gt_sequence_parts_info_start_get(spi,idx),
    lastseqnum = gt_sequence_parts_info_end_get(spi,idx),
    firstpos = gt_sequence_parts_info_seqstartpos(spi,firstseqnum),
    lastpos = gt_sequence_parts_info_seqendpos(spi,lastseqnum);

  gt_assert(firstpos <= lastpos);
  byte_sequence = gt_malloc(sizeof *byte_sequence * (lastpos - firstpos + 1));
  gt_encseq_extract_encoded(encseq,byte_sequence,firstpos,lastpos);
  return byte_sequence;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1ebca9
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x1ebcc6
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x1ebf79
testq %r12, %r12
je 0x1ebf86
movq -0x8(%rcx,%r12,8), %r14
incq %r14
jmp 0x1ebf89
movq 0x10(%r15), %r14
incq %r14
imulq %r12, %r14
jmp 0x1ebf89
xorl %r14d, %r14d
testq %rcx, %rcx
je 0x1ebfac
movq 0x20(%r15), %rdx
decq %rdx
addq $0x18, %r15
cmpq %rax, %rdx
leaq (%rcx,%rax,8), %rax
cmovbeq %r15, %rax
movq (%rax), %r15
decq %r15
jmp 0x1ebfbe
incq %rax
movq 0x10(%r15), %r15
incq %r15
imulq %rax, %r15
addq $-0x2, %r15
movq %r15, %rdi
subq %r14, %rdi
jb 0x1ebffd
incq %rdi
leaq 0x1d26f9(%rip), %rsi    # 0x3be6c9
movl $0x142, %edx            # imm = 0x142
callq 0x1092b2
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xed6e0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x76f8c
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_reset
void gt_seqabstract_reset(GtSeqabstract *sa)
{
  sa->seqtype = GT_SEQABSTRACT_UNDEF;
  sa->len = sa->offset = 0;
  sa->read_seq_left2right = true;
  sa->dir_is_complement = false;
  sa->totallength = GT_SEQABSTRACT_TOTALLENGTH_UNDEF;
  sa->seqstartpos = 0;
  sa->seq.string = NULL;
}

// Assembly:
movl $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movw $0x1, 0x24(%rdi)
movq $-0x1, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movq %rax, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_reinit_gtuchar
void gt_seqabstract_reinit_gtuchar(bool rightextension,
                                   GtReadmode readmode,
                                   GtSeqabstract *sa,
                                   const GtUchar *string,
                                   GtUword len,
                                   GtUword startpos,
                                   GtUword totallength)
{
  gt_assert(sa != NULL && totallength != GT_SEQABSTRACT_TOTALLENGTH_UNDEF);

  sa->seqtype = GT_SEQABSTRACT_STRING;
  sa->totallength = totallength;
  sa->seq.string = string;
  gt_seqabstract_init(sa,
                      rightextension,
                      readmode,
                      len,
                      startpos,
                      totallength);
}

// Assembly:
pushq %rax
testq %rdx, %rdx
je 0x1ec0bf
movq 0x10(%rsp), %r10
cmpq $-0x1, %r10
je 0x1ec0bf
movl %esi, %eax
movl $0x1, 0x20(%rdx)
movq %r10, 0x10(%rdx)
movq %rcx, 0x28(%rdx)
movzbl %dil, %esi
movq %rdx, %rdi
movl %eax, %edx
movq %r8, %rcx
movq %r9, %r8
movq %r10, %r9
popq %rax
jmp 0x1ec0c4
callq 0x77033
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_init
static void gt_seqabstract_init(GtSeqabstract *sa,
                                bool rightextension,
                                GtReadmode readmode,
                                GtUword len,
                                GtUword startpos,
                                GtUword totallength)
{
  sa->len = len;
  gt_assert(startpos >= sa->seqstartpos && (
            !GT_ISDIRREVERSE(readmode) ||
            totallength != GT_SEQABSTRACT_TOTALLENGTH_UNDEF));
  sa->offset = GT_EXTEND_OFFSET(rightextension,
                                readmode,
                                totallength,
                                sa->seqstartpos,
                                startpos,
                                len);
  sa->read_seq_left2right = GT_EXTEND_READ_SEQ_LEFT2RIGHT(rightextension,
                                                          readmode);
  sa->dir_is_complement = GT_ISDIRCOMPLEMENT(readmode) ? true : false;
}

// Assembly:
pushq %rbx
movq %rcx, (%rdi)
movq 0x18(%rdi), %r10
cmpq %r8, %r10
ja 0x1ec15c
movl %edx, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
setne %r11b
cmpq $-0x1, %r9
setne %bl
orb %r11b, %bl
je 0x1ec15c
testb %sil, %sil
je 0x1ec108
movl %edx, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x1ec127
notq %r8
addq %r9, %r8
leaq (%r8,%r10,2), %r8
jmp 0x1ec127
movl %edx, %r11d
orl $0x2, %r11d
cmpl $0x3, %r11d
jne 0x1ec121
addq %rcx, %r8
subq %r8, %r9
leaq (%r9,%r10,2), %r8
jmp 0x1ec127
addq %rcx, %r8
decq %r8
movq %r8, 0x8(%rdi)
testb %sil, %sil
je 0x1ec13a
movl %edx, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x1ec157
cmpl $0x1, %eax
sete %al
xorb $0x1, %sil
andb %al, %sil
movb %sil, 0x24(%rdi)
andl $-0x2, %edx
cmpl $0x2, %edx
sete 0x25(%rdi)
popq %rbx
retq
movb $0x1, %sil
jmp 0x1ec147
callq 0x7706a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_new_gtuchar
GtSeqabstract *gt_seqabstract_new_gtuchar(bool rightextension,
                                          GtReadmode readmode,
                                          const GtUchar *string,
                                          GtUword len,
                                          GtUword startpos,
                                          GtUword totallength)
{
  GtSeqabstract *sa = gt_seqabstract_new_empty();

  gt_seqabstract_reinit_gtuchar(rightextension, readmode, sa, string, len,
                                startpos, totallength);
  return sa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movl %edi, %r13d
leaq 0x1d27e8(%rip), %rsi    # 0x3be971
movl $0x30, %edi
movl $0x40, %edx
callq 0x1092b2
movq %rax, %r14
movl $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movw $0x1, 0x24(%rax)
movq $-0x1, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x18(%r14)
movq %rax, 0x28(%r14)
movq %rbx, (%rsp)
movl %r13d, %edi
movl %ebp, %esi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
callq 0x1ec088
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_new_encseq
GtSeqabstract *gt_seqabstract_new_encseq(bool rightextension,
                                         GtReadmode readmode,
                                         const GtEncseq *encseq,
                                         GtUword len,
                                         GtUword startpos)
{
  GtSeqabstract *sa = gt_seqabstract_new_empty();

  gt_seqabstract_reinit_encseq(rightextension, readmode, sa, encseq, len,
                               startpos);
  return sa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r12d
leaq 0x1d2730(%rip), %rsi    # 0x3be971
movl $0x30, %edi
movl $0x40, %edx
callq 0x1092b2
movq %rax, %r13
movl $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movw $0x1, 0x24(%rax)
movq $-0x1, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x18(%r13)
movq %rax, 0x28(%r13)
movl %r12d, %edi
movl %ebp, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x1ec1ee
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_lcp
GtUword gt_seqabstract_lcp(bool rightextension,
                           const GtSeqabstract *useq,
                           const GtSeqabstract *vseq,
                           GtUword u_start,
                           GtUword v_start)
{
  GtUword lcp, maxlen;

  gt_assert(useq != NULL && vseq != NULL &&
            useq->len >= u_start && vseq->len >= v_start);
  maxlen = GT_MIN(useq->len - u_start, vseq->len - v_start);
  for (lcp = 0; lcp < maxlen; lcp++)
  {
    GtUchar u_cc, v_cc;

    u_cc = gt_seqabstract_get_encoded_char(rightextension,useq,u_start + lcp);
    if (GT_ISSPECIAL(u_cc))
    {
      break;
    }
    if (useq->dir_is_complement)
    {
      u_cc = GT_COMPLEMENTBASE(u_cc);
    }
    v_cc = gt_seqabstract_get_encoded_char(rightextension,vseq,v_start + lcp);
    if (GT_ISSPECIAL(v_cc))
    {
      break;
    }
    if (vseq->dir_is_complement)
    {
      v_cc = GT_COMPLEMENTBASE(v_cc);
    }
    if (u_cc != v_cc)
    {
      break;
    }
  }
  return lcp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rsi, %rsi
je 0x1ec394
movq %rdx, %r15
testq %rdx, %rdx
je 0x1ec394
movq %rsi, %r12
movq (%rsi), %rax
subq 0x10(%rsp), %rax
jb 0x1ec394
movq (%r15), %rbx
subq 0x8(%rsp), %rbx
jb 0x1ec394
cmpq %rbx, %rax
cmovbq %rax, %rbx
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x1ec382
movq 0x10(%rsp), %rax
leaq (%rax,%r13), %rsi
movq %r12, %rdi
callq 0x1ec399
cmpb $-0x3, %al
ja 0x1ec382
movl %eax, %ebp
movb 0x25(%r12), %r14b
movq 0x8(%rsp), %rax
leaq (%rax,%r13), %rsi
movq %r15, %rdi
callq 0x1ec399
cmpb $-0x3, %al
ja 0x1ec382
movb $0x3, %cl
subb %bpl, %cl
movzbl %cl, %ecx
movzbl %bpl, %edx
testb %r14b, %r14b
cmovnel %ecx, %edx
movb $0x3, %cl
subb %al, %cl
movzbl %cl, %ecx
cmpb $0x0, 0x25(%r15)
movzbl %al, %eax
cmovnel %ecx, %eax
cmpb %al, %dl
jne 0x1ec382
incq %r13
cmpq %r13, %rbx
jne 0x1ec321
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x77113
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_get
char *gt_seqabstract_get(bool rightextension,const GtSeqabstract *seq)
{
  GtUword idx;
  char *buffer = gt_malloc(sizeof *buffer * (seq->len+1));
  char *map = "acgt";

  for (idx = 0; idx < seq->len; idx++)
  {
    GtUchar cc = gt_seqabstract_get_encoded_char(rightextension,seq,idx);

    if (cc == GT_WILDCARD)
    {
      buffer[idx] = '#';
    } else
    {
      if (cc == GT_SEPARATOR)
      {
        buffer[idx] = '$';
      } else
      {
        gt_assert(cc < 4);
        buffer[idx] = map[cc];
      }
    }
  }
  buffer[seq->len] = '\0';
  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rdi
incq %rdi
leaq 0x1d258e(%rip), %rsi    # 0x3be971
movl $0xf9, %edx
callq 0x1092b2
movq %rax, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x1ec43b
xorl %r15d, %r15d
leaq 0x17af7a(%rip), %r12    # 0x36737c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1ec399
cmpb $-0x2, %al
je 0x1ec420
movzbl %al, %ecx
cmpl $0xff, %ecx
jne 0x1ec424
movb $0x24, %al
jmp 0x1ec42c
movb $0x23, %al
jmp 0x1ec42c
cmpb $0x4, %al
jae 0x1ec44f
movb (%rcx,%r12), %al
movb %al, (%r14,%r15)
incq %r15
movq (%rbx), %rax
cmpq %rax, %r15
jb 0x1ec402
movb $0x0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x77185
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seqnumrelpos.c
// Function: gt_seqnumrelpos_new
GtSeqnumrelpos *gt_seqnumrelpos_new(unsigned int bitsforrelpos,
                                    const GtEncseq *encseq)
{
  GtSeqnumrelpos *snrp;

  snrp = gt_malloc(sizeof (*snrp));
  snrp->bitsforrelpos = bitsforrelpos;
  snrp->relposmask = (1UL << snrp->bitsforrelpos) - 1;
  snrp->encseq = encseq;
  return snrp;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1d271c(%rip), %rsi    # 0x3beb7f
movl $0x18, %edi
movl $0x22, %edx
callq 0x1092b2
movl %ebp, 0x10(%rax)
movq $-0x1, %rdx
movl %ebp, %ecx
shlq %cl, %rdx
notq %rdx
movq %rdx, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq