LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_collect_fileinfo
static void gt_reads2twobit_collect_fileinfo(const GtReads2Twobit *r2t,
    GtFilelengthvalues **filelengthtab, GtStrArray **filenametab)
{
  GtUword i, noflibraries;
  noflibraries = gt_array_size(r2t->collection);
  *filenametab = gt_str_array_new();
  if (filelengthtab != NULL)
  {
    *filelengthtab = gt_malloc(sizeof (**filelengthtab) * noflibraries);
  }
  for (i = 0; i < noflibraries; i++)
  {
    GtStr *libname;
    GtReadsLibraryInfo *rli;
    rli = gt_array_get(r2t->collection, i);
    if (filelengthtab != NULL)
    {
      (*filelengthtab)[i].effectivelength =
        (uint64_t)rli->total_seqlength - 1UL;
      if (r2t->seqlen_eqlen == 0 && i == noflibraries - 1UL)
        (*filelengthtab)[i].effectivelength--;
      (*filelengthtab)[i].length = (uint64_t)rli->total_filelength;
    }
    libname = gt_str_clone(rli->filename1);
    if (rli->filename2 != NULL)
    {
      gt_str_append_char(libname, GT_READS2TWOBIT_LIBSPECSEP);
      gt_str_append_str(libname, rli->filename2);
    }
    if (rli->paired)
    {
      gt_str_append_char(libname, GT_READS2TWOBIT_LIBSPECSEP);
      gt_str_append_uword(libname, rli->insertlength);
      if (rli->stdev > 0)
      {
        gt_str_append_char(libname, GT_READS2TWOBIT_INSERTSEP);
        gt_str_append_uword(libname, rli->stdev);
      }
    }
    gt_str_array_add(*filenametab, libname);
    gt_str_delete(libname);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x8(%rdi), %rdi
callq 0xd24e0
movq %rax, %r15
callq 0x11be10
movq %rbx, 0x10(%rsp)
movq %rax, (%rbx)
testq %r14, %r14
je 0x1df1c5
movq %r15, %rdi
shlq $0x4, %rdi
leaq 0x1d303c(%rip), %rsi    # 0x3b21f4
movl $0x5be, %edx            # imm = 0x5BE
callq 0x104226
movq %rax, (%r14)
testq %r15, %r15
je 0x1df2bd
leaq -0x1(%r15), %rax
movq %rax, 0x8(%rsp)
movl $0x8, %r12d
xorl %r13d, %r13d
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0xd2207
movq %rax, %rbp
testq %r14, %r14
je 0x1df22a
movq 0x30(%rbp), %rcx
leaq -0x1(%rcx), %rdx
movq (%r14), %rax
movq %rdx, (%rax,%r12)
movq 0x8(%rsp), %rdx
xorq %r13, %rdx
movq (%rsp), %rsi
orq 0x48(%rsi), %rdx
jne 0x1df221
addq $-0x2, %rcx
movq %rcx, (%rax,%r12)
movq 0x28(%rbp), %rcx
movq %rcx, -0x8(%rax,%r12)
movq 0x8(%rbp), %rdi
callq 0x11b191
movq %rax, %rbx
cmpq $0x0, 0x10(%rbp)
je 0x1df256
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x11af23
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
callq 0x11adc1
cmpb $0x1, (%rbp)
jne 0x1df295
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x11af23
movq 0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x11ae72
cmpq $0x0, 0x20(%rbp)
je 0x1df295
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x11af23
movq 0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x11ae72
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x11bf79
movq %rbx, %rdi
callq 0x11bdbf
incq %r13
addq $0x10, %r12
cmpq %r13, %r15
jne 0x1df1e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_set_separators_to_less_frequent_char
static void gt_reads2twobit_set_separators_to_less_frequent_char(
    GtReads2Twobit *r2t)
{
  GtUword seqnum, pos, codenum, posincode;
  GtTwobitencoding sepcode, code, mask, shift;
  sepcode = gt_reads2twobit_less_frequent_char(r2t);
  if (sepcode != r2t->current_sepcode && r2t->nofseqs > 1UL)
  {
    GtUword from, to;
    gt_log_log("changing sepcode from "GT_WU" to "GT_WU"",
                (GtUword) r2t->current_sepcode,
                (GtUword) sepcode);
    from = r2t->seqlen_eqlen > 0 ? 1UL : 0;
    to = r2t->seqlen_eqlen > 0 ? r2t->nofseqs - 1UL : r2t->nofseqs - 2UL;
    for (seqnum = from; seqnum <= to; seqnum++)
    {
      pos = r2t->seqlen_eqlen > 0
        ? seqnum * r2t->seqlen_eqlen - 1UL
        : r2t->seppos[seqnum];
      codenum = GT_DIVBYUNITSIN2BITENC(pos);
      posincode = GT_MODBYUNITSIN2BITENC(pos);
      code = r2t->twobitencoding[codenum];
      shift = (GtTwobitencoding)GT_MULT2(GT_UNITSIN2BITENC - 1UL - posincode);
      mask = ~((GtTwobitencoding)(3UL) << shift);
      gt_assert((code & ~mask) >> shift ==
          (GtTwobitencoding)r2t->current_sepcode);
      code = (code & mask) | ((GtTwobitencoding)sepcode << shift);
      r2t->twobitencoding[codenum] = code;
    }
    r2t->current_sepcode = sepcode;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
xorl %ecx, %ecx
xorl %r14d, %r14d
movq 0x20(%rbx,%rcx,8), %rdx
incq %rcx
cmpq %rax, %rdx
cmovbq %rcx, %r14
cmovbq %rdx, %rax
cmpq $0x3, %rcx
jne 0x1df2dc
leaq 0x1d3d01(%rip), %rdi    # 0x3b2ffd
movq %r14, %rsi
xorl %eax, %eax
callq 0x103d72
movq 0x68(%rbx), %rsi
cmpq %rsi, %r14
je 0x1df3b2
cmpq $0x2, 0x40(%rbx)
jb 0x1df3b2
leaq 0x1d3c40(%rip), %rdi    # 0x3b2f65
movq %r14, %rdx
xorl %eax, %eax
callq 0x103d72
xorl %eax, %eax
cmpq $0x0, 0x48(%rbx)
setne %al
movq 0x40(%rbx), %rcx
leaq (%rcx,%rax), %rdx
addq $-0x2, %rdx
cmpq %rax, %rdx
jb 0x1df3ae
movq 0x10(%rbx), %rsi
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
je 0x1df360
imulq %rax, %rcx
decq %rcx
jmp 0x1df368
movq 0x38(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, %rdi
shrq $0x5, %rdi
movq (%rsi,%rdi,8), %r8
notl %ecx
addl %ecx, %ecx
andl $0x3e, %ecx
movq %r8, %r9
shrq %cl, %r9
andl $0x3, %r9d
cmpq 0x68(%rbx), %r9
jne 0x1df3ba
movl $0x3, %r9d
shlq %cl, %r9
notq %r9
andq %r9, %r8
movq %r14, %r9
shlq %cl, %r9
orq %r8, %r9
movq %r9, (%rsi,%rdi,8)
incq %rax
cmpq %rdx, %rax
jbe 0x1df34e
movq %r14, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x73f91
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_new
GtReadsLibrariesTable* gt_reads_libraries_table_new(GtUword noflibraries)
{
  GtReadsLibrariesTable *rlt;
  gt_assert(noflibraries > 0);
  rlt = gt_malloc(sizeof (*rlt));
  rlt->library = gt_malloc(sizeof (*rlt->library) * noflibraries);
  rlt->noflibraries = noflibraries;
  rlt->nextfreelibrary = 0;
  rlt->firstunpaired = GT_UNDEF_UWORD;
  return rlt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1df422
movq %rdi, %rbx
leaq 0x1d3c9b(%rip), %r14    # 0x3b306f
movl $0x20, %edi
movq %r14, %rsi
movl $0x29, %edx
callq 0x104226
movq %rax, %r15
leaq (,%rbx,8), %rax
leaq (%rax,%rax,2), %rdi
movq %r14, %rsi
movl $0x2a, %edx
callq 0x104226
movq %rax, 0x10(%r15)
movq %rbx, (%r15)
movq $0x0, 0x18(%r15)
movq $-0x1, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x73fca
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_add
void gt_reads_libraries_table_add(GtReadsLibrariesTable *rlt,
    GtUword first_seqnum, GtUword insertlength,
    GtUword stdev, bool paired)
{
  gt_assert(rlt != NULL);
  gt_assert(rlt->nextfreelibrary < rlt->noflibraries);
  if (!paired)
  {
    if (rlt->firstunpaired == GT_UNDEF_UWORD)
    {
      rlt->firstunpaired = first_seqnum;
    }
    else
    {
      gt_assert(rlt->firstunpaired < first_seqnum);
    }
  }
  else
  {
    gt_assert(rlt->firstunpaired == GT_UNDEF_UWORD);
  }
  rlt->library[rlt->nextfreelibrary].first_seqnum = first_seqnum;
  rlt->library[rlt->nextfreelibrary].insertlength = insertlength;
  rlt->library[rlt->nextfreelibrary].stdev = stdev;
  rlt->nextfreelibrary++;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1df4b9
movq 0x18(%rdi), %rax
cmpq (%rdi), %rax
jae 0x1df4be
movq 0x8(%rdi), %r9
testb %r8b, %r8b
je 0x1df486
cmpq $-0x1, %r9
je 0x1df49a
callq 0x7406f
cmpq $-0x1, %r9
je 0x1df496
cmpq %rsi, %r9
jb 0x1df49a
callq 0x74038
movq %rsi, 0x8(%rdi)
movq 0x10(%rdi), %r8
leaq (%rax,%rax,2), %r9
movq %rsi, (%r8,%r9,8)
movq %rdx, 0x8(%r8,%r9,8)
movq %rcx, 0x10(%r8,%r9,8)
incq %rax
movq %rax, 0x18(%rdi)
popq %rax
retq
callq 0x740a6
callq 0x74001
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_get_library
void gt_reads_libraries_table_get_library(GtReadsLibrariesTable *rlt,
    GtUword libnum, GtUword *first_seqnum,
    GtUword *insertlength, GtUword *stdev)
{
  gt_assert(rlt != NULL);
  gt_assert(libnum < rlt->noflibraries);
  if (first_seqnum != NULL)
    *first_seqnum = rlt->library[libnum].first_seqnum;
  if (insertlength != NULL)
    *insertlength = rlt->library[libnum].insertlength;
  if (stdev != NULL)
    *stdev = rlt->library[libnum].stdev;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1df50e
cmpq %rsi, (%rdi)
jbe 0x1df513
testq %rdx, %rdx
je 0x1df4e2
movq 0x10(%rdi), %rax
leaq (%rsi,%rsi,2), %r9
movq (%rax,%r9,8), %rax
movq %rax, (%rdx)
testq %rcx, %rcx
je 0x1df4f7
movq 0x10(%rdi), %rax
leaq (%rsi,%rsi,2), %rdx
movq 0x8(%rax,%rdx,8), %rax
movq %rax, (%rcx)
testq %r8, %r8
je 0x1df50c
movq 0x10(%rdi), %rax
leaq (%rsi,%rsi,2), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, (%r8)
popq %rax
retq
callq 0x74114
callq 0x740dd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_save
void gt_reads_libraries_table_save(GtReadsLibrariesTable *rlt, FILE *rlt_fp)
{
  gt_assert(rlt != NULL);
  gt_assert(rlt_fp != NULL);
  gt_xfwrite(&(rlt->noflibraries), sizeof (rlt->noflibraries), (size_t)1,
      rlt_fp);
  gt_xfwrite(&(rlt->firstunpaired), sizeof (rlt->firstunpaired), (size_t)1,
      rlt_fp);
  gt_assert(rlt->noflibraries > 0);
  gt_xfwrite(&(rlt->library), sizeof (*(rlt->library)),
      (size_t)rlt->noflibraries, rlt_fp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1df596
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1df59b
movq %rdi, %r14
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11f89c
leaq 0x8(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11f89c
movq (%r14), %rdx
testq %rdx, %rdx
je 0x1df5a0
addq $0x10, %r14
movl $0x18, %esi
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f89c
callq 0x74227
callq 0x741f0
callq 0x741b9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_load
GtReadsLibrariesTable* gt_reads_libraries_table_load(FILE *rlt_fp,
                                                     GtError *err)
{
  GtReadsLibrariesTable *rlt;
  size_t count;
  gt_assert(rlt_fp != NULL);
  gt_error_check(err);
  rlt = gt_malloc(sizeof (*rlt));
  count = fread(&(rlt->noflibraries), sizeof (rlt->noflibraries), (size_t)1,
      rlt_fp);
  if (count != (size_t)1 || rlt->noflibraries == 0)
  {
    gt_error_set(err, "libraries table: error by reading number of libraries");
    gt_free(rlt);
    return NULL;
  }
  else
  {
    rlt->library = gt_malloc(sizeof (*(rlt->library)) * rlt->noflibraries);
    count = fread(rlt->library, sizeof (*(rlt->library)),
        (size_t)rlt->noflibraries, rlt_fp);
    if (count != (size_t)rlt->noflibraries)
    {
      gt_error_set(err, "library table: "GT_WU" libraries expected, "GT_WU
                   " found", rlt->noflibraries, (GtUword)count);
      gt_free(rlt->library);
      gt_free(rlt);
      return NULL;
    }
  }
  return rlt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1df6ab
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x1df5ce
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1df6b0
leaq 0x1d3a9a(%rip), %rsi    # 0x3b306f
movl $0x20, %edi
movl $0x83, %edx
callq 0x104226
movq %rax, %rbx
movl $0x8, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rcx
callq 0x17b40
cmpq $0x1, %rax
jne 0x1df67b
movq (%rbx), %rax
testq %rax, %rax
je 0x1df67b
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
leaq 0x1d3a56(%rip), %rsi    # 0x3b306f
movl $0x8e, %edx
callq 0x104226
movq %rax, 0x10(%rbx)
movq (%rbx), %rdx
movl $0x18, %esi
movq %rax, %rdi
movq %r15, %rcx
callq 0x17b40
movq (%rbx), %rdx
cmpq %rdx, %rax
je 0x1df6a2
leaq 0x1d3bf6(%rip), %rsi    # 0x3b323f
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movq 0x10(%rbx), %rdi
leaq 0x1d3a0e(%rip), %r14    # 0x3b306f
movq %r14, %rsi
movl $0x95, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x96, %edx
jmp 0x1df69b
leaq 0x1d3b87(%rip), %rsi    # 0x3b3209
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
leaq 0x1d39dc(%rip), %rsi    # 0x3b306f
movq %rbx, %rdi
movl $0x89, %edx
callq 0x1045eb
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x74297
callq 0x7425e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_store_add
void gt_rectangle_store_add(GtArrayGtDiagbandseedRectangle *rectangle_store,
                            const GtDiagbandseedRectangle *key)
{
  GtDiagbandseedRectangle *ptr;

  GT_CHECKARRAYSPACE(rectangle_store,GtDiagbandseedRectangle,
                     256UL +
                     rectangle_store->allocatedGtDiagbandseedRectangle * 0.2);
  for (ptr = rectangle_store->spaceGtDiagbandseedRectangle +
             rectangle_store->nextfreeGtDiagbandseedRectangle;
       ptr > rectangle_store->spaceGtDiagbandseedRectangle &&
       gt_rectangle_cmp(ptr-1,key) > 0; ptr--)
  {
    *ptr = *(ptr-1);
  }
  *ptr = *key;
  rectangle_store->nextfreeGtDiagbandseedRectangle++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jae 0x1df73e
movq (%rbx), %rax
jmp 0x1df7b0
movq %rax, %xmm0
punpckldq 0x168195(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x16819d(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x1c03b1(%rip), %xmm1   # 0x39fb18
addsd 0x1c0399(%rip), %xmm1   # 0x39fb08
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x16859d(%rip), %xmm1   # 0x347d20
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rax, %rsi
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1d3acd(%rip), %rdx    # 0x3b3270
movl $0x3f, %ecx
callq 0x104461
movq %rax, (%rbx)
testq %rax, %rax
je 0x1df808
movq 0x10(%rbx), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
testq %rcx, %rcx
jle 0x1df7f2
leaq -0x10(%rax), %rcx
movl 0x4(%r14), %edx
cmpl %edx, -0xc(%rax)
jb 0x1df7f2
ja 0x1df7e0
movl -0x4(%rax), %edx
cmpl 0xc(%r14), %edx
jbe 0x1df7f2
movupd (%rcx), %xmm0
movupd %xmm0, (%rax)
movq %rcx, %rax
cmpq (%rbx), %rcx
ja 0x1df7c8
jmp 0x1df7f5
movq %rax, %rcx
movups (%r14), %xmm0
movups %xmm0, (%rcx)
incq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x742d0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_store_show
void gt_rectangle_store_show(const GtArrayGtDiagbandseedRectangle
                                *rectangle_store)
{
  const GtDiagbandseedRectangle *key;

  printf("# %s\n",__func__);
  for (key = rectangle_store->spaceGtDiagbandseedRectangle;
       key < rectangle_store->spaceGtDiagbandseedRectangle +
             rectangle_store->nextfreeGtDiagbandseedRectangle; key++)
  {
     printf("# %u %u %u %u\n",key->a_start,key->a_end,
                              key->b_start,key->b_end);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1d3a18(%rip), %rdi    # 0x3b32db
leaq 0x1d3a17(%rip), %rsi    # 0x3b32e1
xorl %eax, %eax
callq 0x17070
cmpq $0x0, 0x10(%rbx)
jle 0x1df90f
movq (%rbx), %r15
leaq 0x1d3a17(%rip), %r14    # 0x3b32f9
movl (%r15), %esi
movl 0x4(%r15), %edx
movl 0x8(%r15), %ecx
movl 0xc(%r15), %r8d
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
addq $0x10, %r15
movq 0x10(%rbx), %rax
shlq $0x4, %rax
addq (%rbx), %rax
cmpq %rax, %r15
jb 0x1df8e2
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_reverse_complement
void gt_inplace_reverse_complement(GtUchar *seq,GtUword len)
{
  GtUchar tmp, *frontptr, *backptr;

  for (frontptr = seq, backptr = seq + len - 1;
       frontptr <= backptr; frontptr++, backptr--)
  {
    tmp = *frontptr;
    gt_assert((GT_ISSPECIAL(*backptr) || *backptr < 4) &&
              (GT_ISSPECIAL(tmp) || tmp < 4));
    *frontptr = GT_ISSPECIAL(*backptr) ? *backptr : GT_COMPLEMENTBASE(*backptr);
    *backptr = GT_ISSPECIAL(tmp) ? tmp : GT_COMPLEMENTBASE(tmp);
  }
}

// Assembly:
pushq %rax
leaq (%rdi,%rsi), %rax
decq %rax
cmpq %rdi, %rax
jb 0x1df981
incq %rdi
movb -0x1(%rdi), %cl
movzbl (%rax), %edx
cmpl $0x4, %edx
jb 0x1df93e
leal -0xfe(%rdx), %esi
cmpl $0x1, %esi
ja 0x1df983
leal 0x2(%rcx), %esi
cmpb $0x6, %sil
jae 0x1df983
movb $0x3, %sil
subb %dl, %sil
cmpb $-0x2, %dl
movzbl %sil, %esi
movzbl %dl, %edx
cmovbl %esi, %edx
movb $0x3, %sil
subb %cl, %sil
cmpb $-0x2, %cl
movb %dl, -0x1(%rdi)
movzbl %sil, %edx
movzbl %cl, %ecx
cmovbl %edx, %ecx
movb %cl, (%rax)
decq %rax
leaq 0x1(%rdi), %rcx
cmpq %rax, %rdi
movq %rcx, %rdi
jbe 0x1df928
popq %rax
retq
callq 0x74307
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_reverse
void gt_inplace_reverse(GtUchar *seq,GtUword len)
{
  GtUchar tmp, *frontptr, *backptr;

  for (frontptr = seq, backptr = seq + len - 1;
       frontptr < backptr; frontptr++, backptr--)
  {
    tmp = *frontptr;
    *frontptr = *backptr;
    *backptr = tmp;
  }
}

// Assembly:
leaq (%rdi,%rsi), %rax
decq %rax
cmpq %rdi, %rax
jbe 0x1df9b0
incq %rdi
movb -0x1(%rdi), %cl
movb (%rax), %dl
movb %dl, -0x1(%rdi)
movb %cl, (%rax)
decq %rax
leaq 0x1(%rdi), %rcx
cmpq %rax, %rdi
movq %rcx, %rdi
jb 0x1df997
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_complement
void gt_inplace_complement(GtUchar *seq,GtUword len)
{
  GtUchar *ptr;

  for (ptr = seq; ptr < seq + len; ptr++)
  {
    gt_assert(GT_ISSPECIAL(*ptr) || *ptr < 4);
    *ptr = GT_COMPLEMENTBASE(*ptr);
  }
}

// Assembly:
pushq %rax
testq %rsi, %rsi
jle 0x1df9db
addq %rdi, %rsi
movzbl (%rdi), %eax
cmpl $0x4, %eax
jb 0x1df9cd
leal -0xfe(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1df9dd
movb $0x3, %cl
subb %al, %cl
movb %cl, (%rdi)
incq %rdi
cmpq %rsi, %rdi
jb 0x1df9ba
popq %rax
retq
callq 0x7433e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/revcompl.c
// Function: gt_copy_reverse_complement
void gt_copy_reverse_complement(GtUchar *dest,const GtUchar *src,
                               GtUword len)
{
  GtUchar *destptr;
  const GtUchar *srcptr;

  for (destptr = dest, srcptr = src + len - 1;
       destptr < dest + len; destptr++, srcptr--)
  {
    *destptr = GT_COMPLEMENTBASE(*srcptr);
  }
}

// Assembly:
testq %rdx, %rdx
jle 0x1dfa03
leaq (%rdi,%rdx), %rax
leaq (%rdx,%rsi), %rcx
decq %rcx
movb $0x3, %dl
subb (%rcx), %dl
movb %dl, (%rdi)
incq %rdi
decq %rcx
cmpq %rax, %rdi
jb 0x1df9f2
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_delete
void gt_seedextend_match_iterator_delete(GtSeedextendMatchIterator *semi)
{
  if (semi == NULL)
  {
    return;
  }
  gt_str_delete(semi->ii);
  gt_str_delete(semi->qii);
  gt_encseq_delete(semi->aencseq);
  gt_encseq_delete(semi->bencseq);
  gt_str_delete(semi->line_buffer);
  gt_querymatch_delete(semi->querymatchptr);
  GT_FREEARRAY(&semi->querymatch_table,GtQuerymatch);
  gt_querymatchoutoptions_delete(semi->querymatchoutoptions);
  if (semi->inputfileptr != NULL)
  {
    fclose(semi->inputfileptr);
  }
  gt_querymatch_display_flag_delete(semi->in_display_flag);
  gt_str_delete(semi->saved_options_line);
  gt_free(semi);
}

// Assembly:
testq %rdi, %rdi
je 0x1dfac9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0xea375
movq 0x20(%rbx), %rdi
callq 0xea375
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x78(%rbx), %rdi
callq 0x1badd6
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x1dfa7c
leaq 0x88(%rbx), %r14
leaq 0x1d396d(%rip), %rsi    # 0x3b33d0
movl $0x3b, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x80(%rbx), %rdi
callq 0x1b934e
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1dfa96
callq 0x17800
movq 0xa0(%rbx), %rdi
callq 0x1ba107
movq 0xa8(%rbx), %rdi
callq 0x11bdbf
leaq 0x1d391b(%rip), %rsi    # 0x3b33d0
movq %rbx, %rdi
movl $0x43, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_next
GtQuerymatch *gt_seedextend_match_iterator_next(GtSeedextendMatchIterator *semi)
{
  bool selfmatch;

  gt_assert(semi != NULL);
  if (semi->currentmatchindex < GT_UWORD_MAX)
  {
    if (semi->currentmatchindex == semi->querymatch_table.nextfreeGtQuerymatch)
    {
      semi->currentmatch = NULL;
    } else
    {
      semi->currentmatch = gt_querymatch_table_get(&semi->querymatch_table,
                                                   semi->currentmatchindex++);
    }
    return semi->currentmatch;
  }
  selfmatch = semi->aencseq == semi->bencseq ? true : false;
  while (true)
  {
    const char *line_ptr;

    semi->linenum++;
    if (gt_str_read_next_line(semi->line_buffer, semi->inputfileptr) == EOF)
    {
      break;
    }
    line_ptr = gt_str_get(semi->line_buffer);
    gt_assert(line_ptr != NULL);
    if (line_ptr[0] != '\n' && line_ptr[0] != '#')
    {
      if (semi->in_display_flag == NULL)
      {
        return NULL;
      }
      gt_querymatch_read_line(semi->querymatchptr,
                              &semi->evalue,
                              &semi->bitscore,
                              line_ptr,
                              semi->in_display_flag,
                              selfmatch,
                              semi->aencseq,
                              semi->bencseq);
      gt_str_reset(semi->line_buffer);
      return semi->querymatchptr;
    }
    gt_str_reset(semi->line_buffer);
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1e01ec
movq %rdi, %rbx
movq 0x68(%rdi), %rsi
cmpq $-0x1, %rsi
je 0x1e0112
cmpq 0x98(%rbx), %rsi
jne 0x1e0177
xorl %r14d, %r14d
jmp 0x1e018e
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
incq 0x48(%rbx)
movq 0x40(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x11b1ff
cmpl $-0x1, %eax
je 0x1e01d5
xorl %r14d, %r14d
movq 0x40(%rbx), %rdi
callq 0x11b0a1
testq %rax, %rax
je 0x1e01e7
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x1e0156
cmpl $0x23, %ecx
jne 0x1e0194
movq 0x40(%rbx), %rdi
callq 0x11b132
incq 0x48(%rbx)
movq 0x40(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x11b1ff
cmpl $-0x1, %eax
jne 0x1e0137
jmp 0x1e01d8
leaq 0x88(%rbx), %rdi
leaq 0x1(%rsi), %rax
movq %rax, 0x68(%rbx)
callq 0x1bc2a1
movq %rax, %r14
movq %r14, 0x70(%rbx)
jmp 0x1e01d8
movq 0xa0(%rbx), %r8
testq %r8, %r8
je 0x1e01d5
xorl %r9d, %r9d
cmpq %r12, %r15
sete %r9b
movq 0x78(%rbx), %rdi
leaq 0x58(%rbx), %rsi
leaq 0x60(%rbx), %rdx
movups 0x18(%rbx), %xmm0
movups %xmm0, (%rsp)
movq %rax, %rcx
callq 0x1bb943
movq 0x40(%rbx), %rdi
callq 0x11b132
movq 0x78(%rbx), %r14
jmp 0x1e01d8
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x743ae
callq 0x743e7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_trace_delta
GtUword gt_seedextend_match_iterator_trace_delta(
                        const GtSeedextendMatchIterator *semi)
{
  gt_assert(semi != NULL);
  return (gt_querymatch_trace_display(semi->in_display_flag) ||
          gt_querymatch_dtrace_display(semi->in_display_flag))
           ? semi->trace_delta : 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1e02bc
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
callq 0x1b9ed5
testb %al, %al
jne 0x1e02af
movq 0xa0(%rbx), %rdi
callq 0x1b9ee6
testb %al, %al
je 0x1e02b8
movq 0xb0(%rbx), %rax
jmp 0x1e02ba
xorl %eax, %eax
popq %rbx
retq
callq 0x745af
// File: /workspace/github_c_makefile_star2_O3/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 0x1e0352
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1e00e3
testq %rax, %rax
je 0x1e032f
leaq 0x88(%rbx), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1bab1e
movq %rbx, %rdi
callq 0x1e00e3
testq %rax, %rax
jne 0x1e0317
leaq 0x88(%rbx), %rdi
movzbl %bpl, %esi
callq 0x1bc1fb
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq 0x98(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x7465a
// File: /workspace/github_c_makefile_star2_O3/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 0x11b0a1
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1b90b0
movq %rax, 0x80(%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1e0453
testq %r15, %r15
je 0x1e0464
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x1e0464
callq 0x1b9eb3
testb %al, %al
je 0x1e0404
movq %r15, %rdi
callq 0x1b9ec4
testb %al, %al
je 0x1e0404
leaq 0x1d33eb(%rip), %rsi    # 0x3b37e3
movq %r13, %rdi
xorl %eax, %eax
callq 0xfcb67
jmp 0x1e0453
cmpb $0x1, 0x11(%rbx)
jne 0x1e0415
movq 0x18(%rbx), %rdi
callq 0x1e080a
jmp 0x1e041d
movsd 0x165e0b(%rip), %xmm0   # 0x346228
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 0x1b9310
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rsi
callq 0x1babe3
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x746cc
// File: /workspace/github_c_makefile_star2_O3/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 0x1d439f(%rip), %rsi    # 0x3b4884
movl $0x98, %edi
movl $0x43, %edx
callq 0x104226
movq %rax, %r15
callq 0x1e279e
movq %rax, 0x70(%r15)
callq 0x1e279e
movq %rax, 0x78(%r15)
movaps 0x1d3380(%rip), %xmm0   # 0x3b3890
movups %xmm0, (%r15)
movq %r15, %rdi
callq 0x2033eb
movq %rax, 0x10(%r15)
movq %r13, 0x80(%r15)
movq %r12, 0x88(%r15)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x90(%r15)
testq %rbx, %rbx
jne 0x1e0550
movq %r12, %rdi
movq %r14, %rsi
callq 0x1e0484
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_O3/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 0x1e05bb
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
callq 0x1e2a17
movq 0x78(%rbx), %rdi
callq 0x1e2a17
movq 0x10(%rbx), %rdi
callq 0x2034b4
leaq 0x1d42d7(%rip), %rsi    # 0x3b4884
movq %rbx, %rdi
movl $0x69, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e0625
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e0635
movq 0x40(%rbx), %rcx
leaq 0x1d42be(%rip), %rdi    # 0x3b489c
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq 0x10(%rbx), %rdx
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
leaq 0x1d42d0(%rip), %rdi    # 0x3b48cd
xorl %eax, %eax
callq 0x17070
movq 0x30(%rbx), %rdx
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rcx
leaq 0x1d42e4(%rip), %rdi    # 0x3b48fb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O3/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 0x1e06cf
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 0x1e070a
movl %eax, (%r12)
cmpl $-0x1, %eax
je 0x1e06ec
incq %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x1e070a
movl %eax, (%rbx)
xorl %ebx, %ebx
cmpl $-0x1, %eax
sete %bl
negl %ebx
jmp 0x1e06f1
movq %rbp, %rdi
movq %r14, %rsi
callq 0x1e070a
movl %eax, (%r12)
movl %eax, (%rbx)
xorl %ebx, %ebx
cmpl $-0x1, %eax
sete %bl
negl %ebx
jmp 0x1e06f9
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_O3/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 0x1a6ae2(%rip), %rsi    # 0x3871fd
callq 0x17a40
testl %eax, %eax
je 0x1e077c
leaq 0x1ff188(%rip), %rsi    # 0x3df8b3
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1e0780
leaq 0x1c3af9(%rip), %rsi    # 0x3a4237
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1e0787
leaq 0x1d42b9(%rip), %rsi    # 0x3b4a0a
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1e078e
leaq 0x1d45c7(%rip), %rsi    # 0x3b4d2b
leaq 0x1d41e0(%rip), %rdx    # 0x3b494b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1e0793
xorl %eax, %eax
jmp 0x1e0793
movl $0x1, %eax
jmp 0x1e0793
movl $0x2, %eax
jmp 0x1e0793
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xebcd9
movq %rax, %r14
movq %rbx, %rdi
callq 0xe7b9c
testq %rax, %rax
je 0x1e091e
movq %r14, %rdi
callq 0xd1749
testb %al, %al
je 0x1e0879
movq %rbx, %rdi
xorl %esi, %esi
callq 0xebcf9
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0xebcf9
movq %rax, %r14
addq %r15, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0xebcf9
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0xebcf9
addq %r15, %rax
jmp 0x1e087e
xorl %r14d, %r14d
xorl %eax, %eax
movq %rax, %rcx
addq %r14, %rcx
je 0x1e0910
cmpq %rax, %r14
cmovbq %r14, %rax
movq %rax, %xmm0
movq 0x167042(%rip), %xmm1   # 0x3478e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x167046(%rip), %xmm2   # 0x3478f0
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 0x1d2fc1(%rip), %xmm3   # 0x3b38a0
mulsd 0x1c6339(%rip), %xmm3   # 0x3a6c20
addsd 0x18b479(%rip), %xmm3   # 0x36bd68
xorpd %xmm0, %xmm0
maxsd %xmm3, %xmm0
cvttsd2si %xmm0, %eax
cmpl $0xa, %eax
jae 0x1e0923
movl %eax, %eax
leaq 0x1d3ea7(%rip), %rcx    # 0x3b47b0
movsd (%rcx,%rax,8), %xmm0
jmp 0x1e0918
movsd 0x165910(%rip), %xmm0   # 0x346228
popq %rbx
popq %r14
popq %r15
retq
callq 0x748c7
callq 0x7488e
// File: /workspace/github_c_makefile_star2_O3/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
movsd 0x1658e7(%rip), %xmm4   # 0x346228
movsd 0x1a3967(%rip), %xmm3   # 0x3842b0
movsd 0x1673cf(%rip), %xmm5   # 0x347d20
leaq 0x1d416f(%rip), %rbx    # 0x3b4ac7
leaq 0x1d3e51(%rip), %r15    # 0x3b47b0
movapd %xmm4, %xmm1
cmpq $0x9, %r14
je 0x1e097e
movsd (%r15,%r14,8), %xmm1
ucomisd 0x8(%r15,%r14,8), %xmm1
jne 0x1e097e
jnp 0x1e0a99
movapd %xmm1, %xmm0
xorpd 0x16f0c6(%rip), %xmm0   # 0x34fa50
movapd %xmm0, (%rsp)
movl $0x46, %r12d
movapd %xmm1, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
divsd 0x168e35(%rip), %xmm0   # 0x3497e0
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 0x1e0aaf
xorps %xmm2, %xmm2
cvtsi2sd %rsi, %xmm2
movsd 0x1a38b9(%rip), %xmm3   # 0x3842b0
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 0x1d2e84(%rip), %xmm6   # 0x3b38a8
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
movapd 0x10(%rsp), %xmm1
movsd 0x1672c6(%rip), %xmm5   # 0x347d20
movsd 0x1a384e(%rip), %xmm3   # 0x3842b0
movsd 0x1657be(%rip), %xmm4   # 0x346228
incq %r12
cmpq $0x64, %r12
jne 0x1e099b
movl $0xa, %edi
callq 0x17a20
movsd 0x167297(%rip), %xmm5   # 0x347d20
movsd 0x1a381f(%rip), %xmm3   # 0x3842b0
movsd 0x16578f(%rip), %xmm4   # 0x346228
subq $0x1, %r14
jae 0x1e095f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x74900
// File: /workspace/github_c_makefile_star2_O3/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 0x1e0c45
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x31a0dd
movq 0x8(%rbx), %rdi
callq 0x31a0dd
movq 0x58(%rbx), %rdi
callq 0xe9204
movq 0x60(%rbx), %rdi
callq 0xe9204
movq 0x68(%rbx), %rdi
leaq 0x1d3c8b(%rip), %r14    # 0x3b4884
movq %r14, %rsi
movl $0x241, %edx            # imm = 0x241
callq 0x1045eb
movq 0x80(%rbx), %rdi
movq %r14, %rsi
movl $0x242, %edx            # imm = 0x242
callq 0x1045eb
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x243, %edx            # imm = 0x243
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x244, %edx            # imm = 0x244
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e10c0
cmpq $0x45, %rdi
jbe 0x1e10c4
movl $0x64, %eax
subq %rdi, %rax
movq %rax, %rdi
movq %rdi, %rax
retq
pushq %rax
callq 0x74a8f
// File: /workspace/github_c_makefile_star2_O3/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 0x1e13a1
movq 0x18(%rdx), %rax
jmp 0x1e13a3
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 0x1e13f0
movq 0x18(%r9), %r15
jmp 0x1e13f3
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 0x1e17e2
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x8(%rsp)
cmpq %r9, %r8
jae 0x1e15de
movq %r9, %r15
movq %r8, %r12
movq %rdx, %r14
movl %edi, %ebx
movb $0x1, 0x5c(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, %rdi
movq %r8, %rsi
callq 0xeb655
movq %rax, %rbp
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %rax, %rsi
callq 0xeb6ee
movq %rax, %r13
movq %rax, 0x20(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0xeb9d2
movq %rax, 0x18(%rsp)
leaq (%rax,%r13), %rcx
cmpq %r15, %rcx
jbe 0x1e151d
movq %rbp, 0x30(%rsp)
movq %r13, 0x40(%rsp)
movq %r13, %rbp
jmp 0x1e155f
movl %ebx, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xeb655
movq %rax, 0x30(%rsp)
cmpq %rax, %rbp
jae 0x1e15ed
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0xeb6ee
movq %rax, %rbp
movq %rax, 0x40(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeb9d2
movl 0x4(%rsp), %ebx
movq %rax, 0x38(%rsp)
subq %r13, %r12
jb 0x1e15e3
movq %r12, 0x28(%rsp)
subq %rbp, %r15
jb 0x1e15e8
leaq 0x10(%rsp), %r8
movq %r15, 0x38(%r8)
movl $0x0, 0x48(%r8)
leaq 0x60(%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 %bl, %ebx
movl %ebx, %edi
movq 0x8(%rsp), %r14
movq %r14, %rsi
movq %rcx, %rdx
callq 0x1e17e2
testb %al, %al
je 0x1e15cc
movl %ebx, %edi
movq %r14, %rsi
callq 0x1e1ee1
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x74c57
callq 0x74d02
callq 0x74cc9
callq 0x74c90