LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2aadf2
movq 0x3911df(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26b248(%rip), %rsi    # 0x516013
leaq 0x2cb863(%rip), %rdx    # 0x576635
leaq 0x2db769(%rip), %rcx    # 0x586542
leaq 0x2db44a(%rip), %r8     # 0x58622a
movl $0x1d5, %r9d            # imm = 0x1D5
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2aadf4
jmp 0x2aadf6
movq 0x10(%rsp), %rdi
callq 0x2aa710
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2aae21
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
movq (%rsp), %rsi
callq 0x2673f0
jmp 0x2aadf6
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x26a610
movq 0x10(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x70(%rax)
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x98, %edi
leaq 0x2dc4ba(%rip), %rsi    # 0x5876d4
movl $0x43, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
callq 0x2b0770
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x70(%rax)
callq 0x2b0770
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x8(%rsp), %rax
movl $0x2, (%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
movl $0xfffffffe, 0x8(%rax)  # imm = 0xFFFFFFFE
movq 0x8(%rsp), %rax
movl $0xfffffffe, 0xc(%rax)  # imm = 0xFFFFFFFE
movq 0x8(%rsp), %rdi
callq 0x2f8350
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x88(%rax)
movsd 0x20(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x90(%rax)
cmpq $0x0, 0x18(%rsp)
jne 0x2ab2ea
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2ab140
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x68(%rax)
jmp 0x2ab2f8
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2ab388
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x2b0d20
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x2b0d20
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2f85d0
movq (%rsp), %rdi
leaq 0x2dc356(%rip), %rsi    # 0x5876d4
movl $0x69, %edx
callq 0xe88c0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2ab430
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2ab480
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
leaq 0x2dc322(%rip), %rdi    # 0x5876ec
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x2dc32b(%rip), %rdi    # 0x58771d
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rcx
leaq 0x2dc330(%rip), %rdi    # 0x58774b
movb $0x0, %al
callq 0x19070
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2c, %esi
callq 0x19240
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2ab607
movq 0x30(%rsp), %rdi
callq 0x19d90
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2ab650
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x40(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x2ab5cb
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ab5fb
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
movq 0x28(%rsp), %rsi
callq 0x2ab650
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x2ab5f9
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ab5fb
movq 0x10(%rsp), %rdi
callq 0x19ef0
jmp 0x2ab63a
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2ab650
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x2ab638
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ab63a
movl 0x1c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x2ae30c(%rip), %rsi    # 0x559976
callq 0x19980
cmpl $0x0, %eax
jne 0x2ab681
movl $0x0, 0x24(%rsp)
jmp 0x2ab70e
movq 0x18(%rsp), %rdi
leaq 0x309706(%rip), %rsi    # 0x5b4d93
callq 0x19980
cmpl $0x0, %eax
jne 0x2ab6a1
movl $0x1, 0x24(%rsp)
jmp 0x2ab70e
movq 0x18(%rsp), %rdi
leaq 0x2cb34f(%rip), %rsi    # 0x5769fc
callq 0x19980
cmpl $0x0, %eax
jne 0x2ab6c1
movl $0x2, 0x24(%rsp)
jmp 0x2ab70e
movq 0x18(%rsp), %rdi
leaq 0x2dc18d(%rip), %rsi    # 0x58785a
callq 0x19980
cmpl $0x0, %eax
jne 0x2ab6e1
movl $0x3, 0x24(%rsp)
jmp 0x2ab70e
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2ab520
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x2dc47c(%rip), %rsi    # 0x587b7b
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdx
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2aba70
movq 0x30(%rsp), %rax
addq 0x28(%rsp), %rax
cmpq $0x0, %rax
jbe 0x2aba50
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2ab919
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2ab923
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %xmm0
movaps 0x26cffc(%rip), %xmm3   # 0x518930
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x26d000(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
addq %rcx, %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x2dad62(%rip), %xmm1   # 0x5866e8
addsd 0x20(%rsp), %xmm1
movsd 0x2cda6c(%rip), %xmm0   # 0x579400
mulsd %xmm0, %xmm1
movsd 0x291a70(%rip), %xmm0   # 0x53d410
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2ab9b8
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x2ab9e4
movsd 0x2dad28(%rip), %xmm0   # 0x5866e8
addsd 0x20(%rsp), %xmm0
movsd 0x2cda32(%rip), %xmm1   # 0x579400
mulsd %xmm1, %xmm0
movsd 0x291a36(%rip), %xmm1   # 0x53d410
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
cmpq $0xa, %rax
jb 0x2aba35
movq 0x39059c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26a605(%rip), %rsi    # 0x516013
leaq 0x2dbe8c(%rip), %rdx    # 0x5878a1
leaq 0x2dbebb(%rip), %rcx    # 0x5878d7
leaq 0x2dbcb1(%rip), %r8     # 0x5876d4
movl $0x1db, %r9d            # imm = 0x1DB
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2aba37
movslq 0x1c(%rsp), %rcx
leaq 0x2dbbbd(%rip), %rax    # 0x587600
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x2aba5e
movsd 0x26b7e8(%rip), %xmm0   # 0x517240
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_greedy_at_gc_count
static void gt_greedy_at_gc_count(GtUword *atcount,GtUword *gccount,
                                  const GtEncseq *encseq)
{
  const GtAlphabet *alpha = gt_encseq_alphabet(encseq);

  gt_assert(gt_encseq_total_length(encseq) > 0);
  if (gt_alphabet_is_dna(alpha))
  {
    /* I now know that the characters ACGT are mapped in this order
       in either lower case or upper case */
    *atcount = gt_encseq_charcount(encseq, 0);
    *atcount += gt_encseq_charcount(encseq, 3);
    *gccount = gt_encseq_charcount(encseq, 1);
    *gccount += gt_encseq_charcount(encseq, 2);
  } else
  {
    *atcount = *gccount = 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb0f00
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa9d00
cmpq $0x0, %rax
ja 0x2abada
movq 0x3904f7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26a560(%rip), %rsi    # 0x516013
leaq 0x2dc0e7(%rip), %rdx    # 0x587ba1
leaq 0x2dc103(%rip), %rcx    # 0x587bc4
leaq 0x2dbc0c(%rip), %r8     # 0x5876d4
movl $0x1bd, %r9d            # imm = 0x1BD
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2abadc
movq 0x8(%rsp), %rdi
callq 0x7f400
testb $0x1, %al
jne 0x2abaec
jmp 0x2abb59
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xb0f60
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0xb0f60
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xb0f60
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0xb0f60
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x2abb71
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2ac0d9
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x4c6940
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4c6940
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0xac3f0
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xac3f0
movq (%rsp), %rax
movq 0x68(%rax), %rdi
leaq 0x2db652(%rip), %rsi    # 0x5876d4
movl $0x241, %edx            # imm = 0x241
callq 0xe88c0
movq (%rsp), %rax
movq 0x80(%rax), %rdi
leaq 0x2db636(%rip), %rsi    # 0x5876d4
movl $0x242, %edx            # imm = 0x242
callq 0xe88c0
movq (%rsp), %rax
movq 0x98(%rax), %rdi
leaq 0x2db61a(%rip), %rsi    # 0x5876d4
movl $0x243, %edx            # imm = 0x243
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x2db605(%rip), %rsi    # 0x5876d4
movl $0x244, %edx            # imm = 0x244
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x1, 0x8(%rsp)
jb 0x2acc75
cmpq $0x1e, 0x8(%rsp)
ja 0x2acc75
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2accc8
jmp 0x2acc77
cmpq $0x46, 0x8(%rsp)
jae 0x2accb7
movq 0x38f31a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x269383(%rip), %rsi    # 0x516013
leaq 0x2dadd1(%rip), %rdx    # 0x587a68
leaq 0x2dadfb(%rip), %rcx    # 0x587a99
leaq 0x2daa2f(%rip), %r8     # 0x5876d4
movl $0x35c, %r9d            # imm = 0x35C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2accb9
movl $0x64, %eax
subq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_xdrop_extend_seed_relative
bool gt_xdrop_extend_seed_relative(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)
{
  return gt_extend_seed_relative(true,
                                 info,
                                 dbes,
                                 dbseqnum,
                                 dbstart_relative,
                                 queryes,
                                 same_encseq,
                                 queryseqnum,
                                 querystart_relative,
                                 len,
                                 query_readmode);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
movb %r9b, %al
movl 0x88(%rsp), %r9d
movq 0x80(%rsp), %r9
movq 0x78(%rsp), %r9
movq 0x70(%rsp), %r9
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movb 0x2f(%rsp), %bpl
movq 0x70(%rsp), %rbx
movq 0x78(%rsp), %r11
movq 0x80(%rsp), %r10
movl 0x88(%rsp), %eax
movl $0x1, %edi
andb $0x1, %bpl
movzbl %bpl, %ebp
movl %ebp, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x2ad2f0
andb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xa8, %rsp
movl 0xd0(%rsp), %eax
movq 0xc8(%rsp), %rax
movq 0xc0(%rsp), %rax
movq 0xb8(%rsp), %rax
movb 0xb0(%rsp), %al
andb $0x1, %dil
movb %dil, 0xa7(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq 0x90(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2ad376
movq 0x90(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2ad37f
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0x2ad37f
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x90(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2ad3b6
movq 0x78(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2ad3bf
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x2ad3bf
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdx
movb 0x77(%rsp), %cl
movq 0xb8(%rsp), %r8
movq 0xc0(%rsp), %r9
movq 0xc8(%rsp), %r10
movl 0xd0(%rsp), %eax
leaq 0x20(%rsp), %rdi
andb $0x1, %cl
movzbl %cl, %ecx
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x2ad8f0
movb 0xa7(%rsp), %al
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x78(%rsp), %rcx
leaq 0x20(%rsp), %r8
andb $0x1, %al
movzbl %al, %edi
callq 0x2ad980
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_rf_xdrop_extend_selfmatch_with_output
int gt_rf_xdrop_extend_selfmatch_with_output(void *info,
                                             const GtEncseq *encseq,
                                             GtUword len,
                                             GtUword pos1,
                                             GtUword pos2,
                                             GtError *err)
{
  return gt_rf_extend_selfmatch_with_output(true,
                                            info,
                                            encseq,
                                            len,
                                            pos1,
                                            pos2,
                                            err);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rax
movl $0x1, %edi
movq %rax, (%rsp)
callq 0x2ad570
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_rf_extend_selfmatch_with_output
static int gt_rf_extend_selfmatch_with_output(bool forxdrop,
                                              void *info,
                                              const GtEncseq *encseq,
                                              GtUword len,
                                              GtUword pos1,
                                              GtUword pos2,
                                              GT_UNUSED GtError *err)
{
  if (gt_rf_extend_selfmatch(forxdrop,
                             info,
                             encseq,
                             len,
                             pos1,
                             pos2))
  {
    gt_rf_seed_extend_prettyprint(forxdrop,info);
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
movq 0x40(%rsp), %rdi
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
andb $0x1, %al
movzbl %al, %edi
callq 0x2aef90
testb $0x1, %al
jne 0x2ad5c8
jmp 0x2ad5db
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rsi
andb $0x1, %al
movzbl %al, %edi
callq 0x2af080
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_rf_greedy_extend_selfmatch_with_output
int gt_rf_greedy_extend_selfmatch_with_output(void *info,
                                              const GtEncseq *encseq,
                                              GtUword len,
                                              GtUword pos1,
                                              GtUword pos2,
                                              GtError *err)
{
  return gt_rf_extend_selfmatch_with_output(false,
                                            info,
                                            encseq,
                                            len,
                                            pos1,
                                            pos2,
                                            err);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rax
xorl %edi, %edi
movq %rax, (%rsp)
callq 0x2ad570
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_rf_xdrop_extend_querymatch_with_output
void gt_rf_xdrop_extend_querymatch_with_output(void *info,
                                               const GtEncseq *dbencseq,
                                               const GtQuerymatch *exactseed,
                                               const GtSeqorEncseq *queryes,
                                               bool same_encseq)
{
  gt_rf_extend_querymatch_with_output(true,
                                      info,
                                      dbencseq,
                                      exactseed,
                                      queryes,
                                      same_encseq);
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movb 0x7(%rsp), %al
movl $0x1, %edi
andb $0x1, %al
movzbl %al, %r9d
callq 0x2ad690
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_rf_greedy_extend_querymatch_with_output
void gt_rf_greedy_extend_querymatch_with_output(void *info,
                                                const GtEncseq *dbencseq,
                                                const GtQuerymatch *exactseed,
                                                const GtSeqorEncseq *queryes,
                                                bool same_encseq)
{
  gt_rf_extend_querymatch_with_output(false,
                                      info,
                                      dbencseq,
                                      exactseed,
                                      queryes,
                                      same_encseq);
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movb 0x7(%rsp), %al
xorl %edi, %edi
andb $0x1, %al
movzbl %al, %r9d
callq 0x2ad690
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_FTsequenceResources_init
static void gt_FTsequenceResources_init(GtFTsequenceResources *fsr,
                                        const GtEncseq *encseq,
                                        GtReadmode readmode,
                                        GtEncseqReader *encseq_r,
                                        GtAllocatedMemory *sequence_cache,
                                        const GtUchar *bytesequence,
                                        GtUword totallength,
                                        GtUword full_totallength,
                                        GtExtendCharAccess extend_char_access,
                                        bool twobit_possible,
                                        bool haswildcards)
{
  fsr->encseq = encseq;
  fsr->readmode = readmode;
  fsr->totallength = totallength;
  fsr->full_totallength = full_totallength;
  fsr->encseq_r = encseq_r;
  fsr->sequence_cache = sequence_cache;
  fsr->bytesequence = bytesequence;
  fsr->extend_char_access = extend_char_access;
  fsr->twobit_possible = twobit_possible;
  fsr->haswildcards = haswildcards;
}

// Assembly:
movq %rcx, -0x50(%rsp)
movl %edx, %eax
movq -0x50(%rsp), %rdx
movl %eax, -0x44(%rsp)
movq %rsi, %rax
movl -0x44(%rsp), %esi
movq %rax, -0x40(%rsp)
movq %rdi, %r10
movq -0x40(%rsp), %rdi
movb 0x28(%rsp), %al
movb 0x20(%rsp), %cl
movl 0x18(%rsp), %r11d
movq 0x10(%rsp), %r11
movq 0x8(%rsp), %r11
movq %r10, -0x8(%rsp)
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
andb $0x1, %cl
movb %cl, -0x31(%rsp)
andb $0x1, %al
movb %al, -0x32(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x34(%rax)
movb -0x31(%rsp), %cl
movq -0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x38(%rax)
movb -0x32(%rsp), %cl
movq -0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x39(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_sesp_from_relative
static void gt_sesp_from_relative(GtSeedextendSeqpair *sesp,
                                  GtUword dbseqnum,
                                  GtUword dbstart_relative,
                                  bool same_encseq,
                                  GtUword queryseqnum,
                                  GtUword querystart_relative,
                                  GtUword seedlength,
                                  GtReadmode query_readmode)
{
  sesp->same_encseq = same_encseq;
  sesp->seedlength = seedlength;
  sesp->dbseqnum = dbseqnum;
  sesp->queryseqnum = queryseqnum;
  sesp->dbstart_relative = dbstart_relative;
  sesp->querystart_relative = querystart_relative;
  sesp->query_readmode = query_readmode;
}

// Assembly:
movb %cl, %al
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rcx
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
andb $0x1, %al
movb %al, -0x19(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movb -0x19(%rsp), %cl
movq -0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x4c(%rax)
movq 0x8(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movl 0x10(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x48(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dil, %al
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rdi
andb $0x1, %al
movb %al, 0x37(%rsp)
movl %esi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2aea03
cmpl $0x1, 0x30(%rsp)
je 0x2ae9b9
cmpl $0x3, 0x30(%rsp)
jne 0x2ae9d7
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2b07a0
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2b0810
movb 0x37(%rsp), %al
movl 0x30(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0bc0
jmp 0x2aea39
movb 0x37(%rsp), %dil
movl 0x30(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
movq 0x48(%rsp), %rax
andb $0x1, %dil
movzbl %dil, %edi
movq %rax, (%rsp)
callq 0x2b0880
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_querymatch_score2distance
static GtUword gt_querymatch_score2distance(GtXdropscore score,
                                            GtUword alignedlen)
{
  if (score >= 0)
  {
    gt_assert(alignedlen >= score);
    return ((GtWord) alignedlen - score)/3;
  } else
  {
    return -(((GtWord) alignedlen + score)/3);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jl 0x2aef66
jmp 0x2aef07
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x2aef4a
movq 0x38d087(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2670f0(%rip), %rsi    # 0x516013
leaq 0x2d8e60(%rip), %rdx    # 0x587d8a
leaq 0x2d8e6d(%rip), %rcx    # 0x587d9e
leaq 0x2d879c(%rip), %r8     # 0x5876d4
movl $0x1f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2aef4c
movq (%rsp), %rax
subq 0x8(%rsp), %rax
movl $0x3, %ecx
cqto
idivq %rcx
movq %rax, 0x10(%rsp)
jmp 0x2aef86
movq (%rsp), %rax
addq 0x8(%rsp), %rax
movl $0x3, %ecx
cqto
idivq %rcx
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x2af0f7
movq 0x38ceda(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x266f43(%rip), %rsi    # 0x516013
leaq 0x2d8d6f(%rip), %rdx    # 0x587e46
leaq 0x2d8d80(%rip), %rcx    # 0x587e5e
leaq 0x2d85ef(%rip), %r8     # 0x5876d4
movl $0x52f, %r9d            # imm = 0x52F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2af0f9
testb $0x1, 0x57(%rsp)
je 0x2af144
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movsd 0x90(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x2af17d
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movsd 0x18(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x269230
testb $0x1, %al
jne 0x2af1b4
jmp 0x2af1d7
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x267bd0
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_seqstartpos
GtUword gt_sequence_parts_info_seqstartpos(const GtSequencePartsInfo *spi,
                                           GtUword seqnum)
{
  if (spi->ssptab != NULL)
  {
    return seqnum > 0 ? (spi->ssptab[seqnum - 1] + 1) : 0;
  } else
  {
    return seqnum * (spi->same_length + 1);
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2af7b4
cmpq $0x0, -0x18(%rsp)
jbe 0x2af79f
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x2af7a8
xorl %eax, %eax
movq %rax, -0x20(%rsp)
jmp 0x2af7a8
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2af7cf
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2af848
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2af82a
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
subq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x2af83c
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2af86b
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
subq $0x2, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2b00e2
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x2d7e4e(%rip), %rsi    # 0x587ef9
movl $0xd9, %edx
callq 0xe88c0
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x2d7e36(%rip), %rsi    # 0x587ef9
movl $0xda, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x2d7e21(%rip), %rsi    # 0x587ef9
movl $0xdb, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x2b00f0
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x2b0170
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2b00f0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2b0170
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x107390
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2b00f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2b00f0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x17(%rsp)
jne 0x2b0411
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2b0170
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2b0170
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
sete %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2b00f0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2b0170
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2af760
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2af7e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x2b06a7
movq 0x38b92a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x265993(%rip), %rsi    # 0x516013
leaq 0x2d7a9a(%rip), %rdx    # 0x588121
leaq 0x2d7aa7(%rip), %rcx    # 0x588135
leaq 0x2d7864(%rip), %r8     # 0x587ef9
movl $0x141, %r9d            # imm = 0x141
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b06a9
movq 0x8(%rsp), %rdi
subq 0x10(%rsp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x2d7837(%rip), %rsi    # 0x587ef9
movl $0x142, %edx            # imm = 0x142
callq 0xe80f0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0xac280
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movb $0x1, 0x24(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x25(%rax)
movq -0x8(%rsp), %rax
movq $-0x1, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)