LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x3, %rcx
je 0x18d360
movq 0x20(%rbx,%rcx,8), %rdx
incq %rcx
cmpq %rax, %rdx
cmovbq %rcx, %r14
cmovbq %rdx, %rax
jmp 0x18d345
leaq 0x1c60f8(%rip), %rdi    # 0x35345f
movq %r14, %rsi
xorl %eax, %eax
callq 0x92a82
movq 0x68(%rbx), %rsi
cmpq %rsi, %r14
je 0x18d417
cmpq $0x2, 0x40(%rbx)
jb 0x18d417
leaq 0x1c6037(%rip), %rdi    # 0x3533c7
movq %r14, %rdx
xorl %eax, %eax
callq 0x92a82
xorl %eax, %eax
cmpq $0x0, 0x48(%rbx)
setne %al
movq 0x40(%rbx), %rcx
leaq -0x2(%rcx,%rax), %rdx
pushq $0x3
popq %rsi
cmpq %rdx, %rax
ja 0x18d413
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
je 0x18d3c7
imulq %rax, %rcx
decq %rcx
jmp 0x18d3cf
movq 0x38(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, %rdi
shrq $0x5, %rdi
movq 0x10(%rbx), %r8
movq (%r8,%rdi,8), %r9
notl %ecx
addl %ecx, %ecx
andl $0x3e, %ecx
movq %r9, %r10
shrq %cl, %r10
andl $0x3, %r10d
cmpq 0x68(%rbx), %r10
jne 0x18d41f
movq %rsi, %r10
shlq %cl, %r10
notq %r10
movq %r14, %r11
shlq %cl, %r11
andq %r10, %r9
orq %r9, %r11
movq %r11, (%r8,%rdi,8)
incq %rax
jmp 0x18d3b0
movq %r14, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2aab42(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157be3(%rip), %rsi    # 0x2e5013
leaq 0x1c5fb1(%rip), %rdx    # 0x3533e8
leaq 0x1c5fec(%rip), %rcx    # 0x35342a
leaq 0x1c5211(%rip), %r8     # 0x352656
movl $0x7b8, %r9d            # imm = 0x7B8
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_zeropad_tbe
static void gt_reads2twobit_zeropad_tbe(GtReads2Twobit *r2t)
{
  GtUword pos, codenum, posincode, shift;
  pos = r2t->total_seqlength - 1UL;
  codenum = GT_DIVBYUNITSIN2BITENC(pos);
  posincode = GT_MODBYUNITSIN2BITENC(pos);
  if (posincode < (GtUword)GT_UNITSIN2BITENC - 1UL)
  {
    shift = GT_MULT2(GT_UNITSIN2BITENC - 1UL - posincode);
    r2t->twobitencoding[codenum] =
      (GtTwobitencoding)((r2t->twobitencoding[codenum] >> shift) << shift);
  }
  r2t->twobitencoding[codenum + 1UL] = 0;
}

// Assembly:
movq 0x60(%rdi), %rcx
decq %rcx
movq %rcx, %rax
shrq $0x5, %rax
andl $0x1f, %ecx
cmpq $0x1f, %rcx
jne 0x18d474
movq 0x10(%rdi), %rdx
jmp 0x18d48b
addl %ecx, %ecx
movq 0x10(%rdi), %rdx
movq (%rdx,%rax,8), %rsi
xorb $0x3e, %cl
shrq %cl, %rsi
shlq %cl, %rsi
movq %rsi, (%rdx,%rax,8)
andq $0x0, 0x8(%rdx,%rax,8)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x18d4e2
movq %rdi, %rbx
leaq 0x1c6029(%rip), %r14    # 0x3534d1
pushq $0x20
popq %rdi
pushq $0x29
popq %rdx
movq %r14, %rsi
callq 0x93160
movq %rax, %r15
imulq $0x18, %rbx, %rdi
pushq $0x2a
popq %rdx
movq %r14, %rsi
callq 0x93160
movq %rax, 0x10(%r15)
movq %rbx, (%r15)
andq $0x0, 0x18(%r15)
orq $-0x1, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2aaa7f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157b20(%rip), %rsi    # 0x2e5013
leaq 0x1c6142(%rip), %rdx    # 0x35363c
leaq 0x1c5fb3(%rip), %rcx    # 0x3534b4
leaq 0x1c5fc9(%rip), %r8     # 0x3534d1
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18d5fb
movq 0x18(%rdi), %rax
cmpq (%rdi), %rax
jae 0x18d625
movq 0x8(%rdi), %r9
testb %r8b, %r8b
je 0x18d5a3
cmpq $-0x1, %r9
je 0x18d5dc
movq 0x2aa9eb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157a8c(%rip), %rsi    # 0x2e5013
leaq 0x1c5fd9(%rip), %rdx    # 0x353567
leaq 0x1c5f6a(%rip), %rcx    # 0x3534ff
leaq 0x1c5f35(%rip), %r8     # 0x3534d1
pushq $0x4d
jmp 0x18d64d
cmpq $-0x1, %r9
je 0x18d5d8
cmpq %rsi, %r9
jb 0x18d5dc
movq 0x2aa9b3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157a54(%rip), %rsi    # 0x2e5013
leaq 0x1c5f7f(%rip), %rdx    # 0x353545
leaq 0x1c5f32(%rip), %rcx    # 0x3534ff
leaq 0x1c5efd(%rip), %r8     # 0x3534d1
pushq $0x48
jmp 0x18d64d
movq %rsi, 0x8(%rdi)
movq 0x10(%rdi), %r8
imulq $0x18, %rax, %r9
movq %rsi, (%r8,%r9)
movq %rdx, 0x8(%r8,%r9)
movq %rcx, 0x10(%r8,%r9)
incq %rax
movq %rax, 0x18(%rdi)
popq %rax
retq
movq 0x2aa966(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157a07(%rip), %rsi    # 0x2e5013
leaq 0x1c5ee0(%rip), %rdx    # 0x3534f3
leaq 0x1c5ee5(%rip), %rcx    # 0x3534ff
leaq 0x1c5eb0(%rip), %r8     # 0x3534d1
pushq $0x3e
jmp 0x18d64d
movq 0x2aa93c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1579dd(%rip), %rsi    # 0x2e5013
leaq 0x1c5edf(%rip), %rdx    # 0x35351c
leaq 0x1c5ebb(%rip), %rcx    # 0x3534ff
leaq 0x1c5e86(%rip), %r8     # 0x3534d1
pushq $0x3f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18d6a6
cmpq %rsi, (%rdi)
jbe 0x18d6d0
testq %rdx, %rdx
je 0x18d67a
movq 0x10(%rdi), %rax
imulq $0x18, %rsi, %r9
movq (%rax,%r9), %rax
movq %rax, (%rdx)
testq %rcx, %rcx
je 0x18d68f
movq 0x10(%rdi), %rax
imulq $0x18, %rsi, %rdx
movq 0x8(%rax,%rdx), %rax
movq %rax, (%rcx)
testq %r8, %r8
je 0x18d6a4
movq 0x10(%rdi), %rax
imulq $0x18, %rsi, %rcx
movq 0x10(%rax,%rcx), %rax
movq %rax, (%r8)
popq %rax
retq
movq 0x2aa8bb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15795c(%rip), %rsi    # 0x2e5013
leaq 0x1c5e35(%rip), %rdx    # 0x3534f3
leaq 0x1c5ec7(%rip), %rcx    # 0x35358c
leaq 0x1c5e05(%rip), %r8     # 0x3534d1
pushq $0x59
jmp 0x18d6f8
movq 0x2aa891(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157932(%rip), %rsi    # 0x2e5013
leaq 0x1c5ec9(%rip), %rdx    # 0x3535b1
leaq 0x1c5e9d(%rip), %rcx    # 0x35358c
leaq 0x1c5ddb(%rip), %r8     # 0x3534d1
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18d7ec
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18d816
movq %rdi, %r14
pushq $0x8
popq %r15
pushq $0x1
popq %r12
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xb302c
leaq 0x8(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xb302c
movq (%r14), %rdx
testq %rdx, %rdx
je 0x18d840
addq $0x10, %r14
pushq $0x18
popq %rsi
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb302c
movq 0x2aa775(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157816(%rip), %rsi    # 0x2e5013
leaq 0x1c5cef(%rip), %rdx    # 0x3534f3
leaq 0x1c5e0e(%rip), %rcx    # 0x353619
leaq 0x1c5cbf(%rip), %r8     # 0x3534d1
pushq $0x71
jmp 0x18d868
movq 0x2aa74b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1577ec(%rip), %rsi    # 0x2e5013
leaq 0x1c0573(%rip), %rdx    # 0x34dda1
leaq 0x1c5de4(%rip), %rcx    # 0x353619
leaq 0x1c5c95(%rip), %r8     # 0x3534d1
pushq $0x72
jmp 0x18d868
movq 0x2aa721(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1577c2(%rip), %rsi    # 0x2e5013
leaq 0x1c5ddf(%rip), %rdx    # 0x353637
leaq 0x1c5dba(%rip), %rcx    # 0x353619
leaq 0x1c5c6b(%rip), %r8     # 0x3534d1
pushq $0x77
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18d970
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x18d89f
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x18d99e
leaq 0x1c5c2b(%rip), %rsi    # 0x3534d1
pushq $0x20
popq %rdi
movl $0x83, %edx
callq 0x93160
movq %rax, %rbx
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r15, %rcx
callq 0x17ad0
cmpq $0x1, %rax
jne 0x18d940
movq (%rbx), %rax
testq %rax, %rax
je 0x18d940
imulq $0x18, %rax, %rdi
leaq 0x1c5bf1(%rip), %rsi    # 0x3534d1
movl $0x8e, %edx
callq 0x93160
movq %rax, 0x10(%rbx)
movq (%rbx), %rdx
pushq $0x18
popq %rsi
movq %rax, %rdi
movq %r15, %rcx
callq 0x17ad0
movq (%rbx), %rdx
cmpq %rdx, %rax
je 0x18d967
leaq 0x1c5d93(%rip), %rsi    # 0x3536a1
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
movq 0x10(%rbx), %rdi
leaq 0x1c5bab(%rip), %r14    # 0x3534d1
movq %r14, %rsi
movl $0x95, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x96, %edx
jmp 0x18d960
leaq 0x1c5d24(%rip), %rsi    # 0x35366b
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
leaq 0x1c5b79(%rip), %rsi    # 0x3534d1
movq %rbx, %rdi
movl $0x89, %edx
callq 0x936f9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2aa5f1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157692(%rip), %rsi    # 0x2e5013
leaq 0x1c0419(%rip), %rdx    # 0x34dda1
leaq 0x1c5cbe(%rip), %rcx    # 0x35364d
leaq 0x1c5b3b(%rip), %r8     # 0x3534d1
movl $0x81, %r9d
jmp 0x18d9ca
movq 0x2aa5c3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157664(%rip), %rsi    # 0x2e5013
leaq 0x157809(%rip), %rdx    # 0x2e51bf
leaq 0x1c5c90(%rip), %rcx    # 0x35364d
leaq 0x1c5b0d(%rip), %r8     # 0x3534d1
movl $0x82, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jae 0x18da54
movq (%rbx), %rax
jmp 0x18dac4
movq %rax, %xmm0
punpckldq 0x159e7f(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x159e87(%rip), %xmm0   # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x1b239b(%rip), %xmm1   # 0x33fe18
addsd 0x1b2383(%rip), %xmm1   # 0x33fe08
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x15a287(%rip), %xmm1   # 0x2e7d20
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rax, %rsi
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1c5c19(%rip), %rdx    # 0x3536d2
pushq $0x3f
popq %rcx
callq 0x93472
movq %rax, (%rbx)
testq %rax, %rax
je 0x18db19
movq 0x10(%rbx), %r12
shlq $0x4, %r12
addq %rax, %r12
cmpq %rax, %r12
jbe 0x18db00
leaq -0x10(%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x18db4f
testl %eax, %eax
jle 0x18db00
movupd (%r15), %xmm0
movupd %xmm0, (%r12)
movq (%rbx), %rax
movq %r15, %r12
jmp 0x18dad4
movups (%r14), %xmm0
movups %xmm0, (%r12)
incq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x2aa448(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1574e9(%rip), %rsi    # 0x2e5013
leaq 0x1c5bd4(%rip), %rdx    # 0x353705
leaq 0x1c5bb6(%rip), %rcx    # 0x3536ee
leaq 0x1c5b93(%rip), %r8     # 0x3536d2
pushq $0x3f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_previous_equal
const GtDiagbandseedRectangle *gt_rectangle_previous_equal(
                   const GtArrayGtDiagbandseedRectangle *rectangle_store,
                   const GtDiagbandseedRectangle *key)
{
  const GtDiagbandseedRectangle
    *midptr,
    *found = NULL,
    *leftptr = rectangle_store->spaceGtDiagbandseedRectangle,
    *rightptr = leftptr + rectangle_store->nextfreeGtDiagbandseedRectangle - 1;

  while (leftptr <= rightptr)
  {
    midptr = leftptr + (GtUword) (rightptr-leftptr)/2;
    if (gt_rectangle_cmp(key,midptr) < 0)
    {
      rightptr = midptr - 1;
    } else
    {
      /* Now key *midptr <= key. Hence *midptr satisfies the
         requirement, but it may not be the largest element <= key. */
      found = midptr;
      /* if *midptr < key, then there may be a larger element and
         therefore we search for it in the range
         midptr+1 .. rightptr. if *midptr == key, then we have found
         the largest element and we can stop the search. */
      if (gt_rectangle_cmp(key,midptr) > 0)
      {
        leftptr = midptr + 1;
      } else
      {
        break;
      }
    }
  }
  /* if found == NULL, then we have never seen an element <= key and
     so we return NULL. Otherwise found has been set in the else case
     of the loop */
  return found;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r12
movq 0x10(%rdi), %rax
shlq $0x4, %rax
leaq (%r12,%rax), %r13
addq $-0x10, %r13
xorl %r14d, %r14d
cmpq %r13, %r12
ja 0x18dbcd
movq %r13, %r15
subq %r12, %r15
sarq %r15
andq $-0x10, %r15
addq %r12, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18db4f
testl %eax, %eax
jns 0x18dbbf
addq $-0x10, %r15
movq %r15, %r13
jmp 0x18db92
je 0x18dbca
leaq 0x10(%r15), %r12
movq %r15, %r14
jmp 0x18db92
movq %r15, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c5b16(%rip), %rdi    # 0x35373d
leaq 0x1c5b15(%rip), %rsi    # 0x353743
xorl %eax, %eax
callq 0x17070
movq (%rbx), %rax
leaq 0x1c5b1c(%rip), %r14    # 0x35375b
movq %rax, %r15
movq 0x10(%rbx), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
cmpq %rcx, %r15
jae 0x18dc74
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 (%rbx), %rax
jmp 0x18dc42
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 (%rsi,%rdi), %rax
decq %rax
cmpq %rax, %rdi
ja 0x18dcd9
movb (%rdi), %cl
movzbl (%rax), %edx
cmpl $0x4, %edx
jb 0x18dc9e
leal -0xfe(%rdx), %esi
cmpl $0x1, %esi
ja 0x18dcdb
leal 0x2(%rcx), %esi
cmpb $0x6, %sil
jae 0x18dcdb
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
movzbl %sil, %esi
movzbl %cl, %ecx
cmovbl %esi, %ecx
movb %dl, (%rdi)
movb %cl, (%rax)
incq %rdi
decq %rax
jmp 0x18dc84
popq %rax
retq
movq 0x2aa286(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x157327(%rip), %rsi    # 0x2e5013
leaq 0x1c5a77(%rip), %rdx    # 0x35376a
leaq 0x1c5abb(%rip), %rcx    # 0x3537b5
leaq 0x1c5ad2(%rip), %r8     # 0x3537d3
pushq $0x20
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 (%rsi,%rdi), %rax
decq %rax
cmpq %rax, %rdi
jae 0x18dd2d
movb (%rdi), %cl
movb (%rax), %dl
movb %dl, (%rdi)
movb %cl, (%rax)
incq %rdi
decq %rax
jmp 0x18dd18
retq
// File: /workspace/github_c_makefile_star2_O2/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
addq %rdi, %rsi
cmpq %rsi, %rdi
jae 0x18dd55
movzbl (%rdi), %eax
cmpl $0x4, %eax
jb 0x18dd4a
leal -0xfe(%rax), %ecx
cmpl $0x2, %ecx
jae 0x18dd57
movb $0x3, %cl
subb %al, %cl
movb %cl, (%rdi)
incq %rdi
jmp 0x18dd32
popq %rax
retq
movq 0x2aa20a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1572ab(%rip), %rsi    # 0x2e5013
leaq 0x1c5a79(%rip), %rdx    # 0x3537e8
leaq 0x1c5a91(%rip), %rcx    # 0x353807
leaq 0x1c5a56(%rip), %r8     # 0x3537d3
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
leaq (%rdi,%rdx), %rax
leaq (%rdx,%rsi), %rcx
decq %rcx
cmpq %rax, %rdi
jae 0x18ddab
movb $0x3, %dl
subb (%rcx), %dl
movb %dl, (%rdi)
incq %rdi
decq %rcx
jmp 0x18dd98
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18de6a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0x735fd
movq 0x20(%rbx), %rdi
callq 0x735fd
movq 0x40(%rbx), %rdi
callq 0xae103
movq 0x78(%rbx), %rdi
callq 0x16a2a1
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x18de1f
leaq 0x88(%rbx), %r14
leaq 0x1c5a25(%rip), %rsi    # 0x353830
pushq $0x3b
popq %rdx
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x80(%rbx), %rdi
callq 0x16833c
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x18de39
callq 0x177c0
movq 0xa0(%rbx), %rdi
callq 0x16924a
movq 0xa8(%rbx), %rdi
callq 0xae103
leaq 0x1c59d8(%rip), %rsi    # 0x353830
pushq $0x43
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18e847
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
callq 0x1690e6
testb %al, %al
jne 0x18e83a
movq 0xa0(%rbx), %rdi
callq 0x1690eb
testb %al, %al
je 0x18e843
movq 0xb0(%rbx), %rax
jmp 0x18e845
xorl %eax, %eax
popq %rbx
retq
movq 0x2a971a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1567bb(%rip), %rsi    # 0x2e5013
leaq 0x1b59cf(%rip), %rdx    # 0x34422e
leaq 0x1c526f(%rip), %rcx    # 0x353ad5
leaq 0x1c4fc3(%rip), %r8     # 0x353830
movl $0x1b1, %r9d            # imm = 0x1B1
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18e96a
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x88(%rdi), %r14
movq %rbx, %rdi
callq 0x18e4c7
testq %rax, %rax
je 0x18e94b
movq %r14, %rdi
movq %rax, %rsi
callq 0x169ec8
jmp 0x18e931
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x16bb42
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq 0x98(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2a95f7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x156698(%rip), %rsi    # 0x2e5013
leaq 0x1b58ac(%rip), %rdx    # 0x34422e
leaq 0x1c51bf(%rip), %rcx    # 0x353b48
leaq 0x1c4ea0(%rip), %r8     # 0x353830
movl $0x1d5, %r9d            # imm = 0x1D5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xad1fa
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x16807c
movq %rax, 0x80(%rbx)
pushq $-0x1
popq %rbp
testq %rax, %rax
je 0x18eacf
testq %r15, %r15
je 0x18eae0
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x18eae0
callq 0x1690dc
testb %al, %al
je 0x18ea80
movq %r15, %rdi
callq 0x1690e1
testb %al, %al
je 0x18ea80
leaq 0x1c51cf(%rip), %rsi    # 0x353c43
movq %r13, %rdi
xorl %eax, %eax
callq 0x89dbb
jmp 0x18eacf
cmpb $0x1, 0x11(%rbx)
jne 0x18ea91
movq 0x18(%rbx), %rdi
callq 0x18eff6
jmp 0x18ea99
movsd 0x15778f(%rip), %xmm0   # 0x2e6228
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 0x168303
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rsi
callq 0x169fbc
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2a9481(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x156522(%rip), %rsi    # 0x2e5013
leaq 0x1c50db(%rip), %rdx    # 0x353bd3
leaq 0x1c510e(%rip), %rcx    # 0x353c0d
leaq 0x1c4d2a(%rip), %r8     # 0x353830
movl $0x1fa, %r9d            # imm = 0x1FA
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1c60ec(%rip), %rsi    # 0x354ce4
pushq $0x43
popq %rdx
movl $0x98, %edi
callq 0x93160
movq %rax, %r15
callq 0x1916d4
movq %rax, 0x70(%r15)
callq 0x1916d4
movq %rax, 0x78(%r15)
movaps 0x1c50cf(%rip), %xmm0   # 0x353cf0
movups %xmm0, (%r15)
movq %r15, %rdi
callq 0x1b7511
movq %rax, 0x10(%r15)
movq %r13, 0x80(%r15)
movq %r12, 0x88(%r15)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x90(%r15)
testq %rbx, %rbx
jne 0x18ec61
movq %r12, %rdi
movq %r14, %rsi
callq 0x18eb68
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_O2/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 0x18ecca
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
callq 0x191a01
movq 0x78(%rbx), %rdi
callq 0x191a01
movq 0x10(%rbx), %rdi
callq 0x1b7634
leaq 0x1c6026(%rip), %rsi    # 0x354ce4
pushq $0x69
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18ed34
movq %rax, %r14
movq %rbx, %rdi
callq 0x18ed75
movq 0x40(%rbx), %rcx
leaq 0x1c600f(%rip), %rdi    # 0x354cfc
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq 0x10(%rbx), %rdx
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
leaq 0x1c6021(%rip), %rdi    # 0x354d2d
xorl %eax, %eax
callq 0x17070
movq 0x30(%rbx), %rdx
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rcx
leaq 0x1c6035(%rip), %rdi    # 0x354d5b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2c
popq %rsi
movq %rdx, %rdi
callq 0x17260
testq %rax, %rax
je 0x18ee71
movq %rax, %r13
movq %rbp, %rdi
callq 0x17df0
movq %rax, %r15
movq %r13, %rax
subq %rbp, %rax
movb $0x0, (%r15,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x18eeaa
movl %eax, (%r12)
cmpl $-0x1, %eax
je 0x18ee8e
incq %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x18eeaa
movl %eax, (%rbx)
xorl %ebx, %ebx
cmpl $-0x1, %eax
sete %bl
negl %ebx
jmp 0x18ee91
movq %rbp, %rdi
movq %r14, %rsi
callq 0x18eeaa
movl %eax, (%r12)
movl %eax, (%rbx)
xorl %ebx, %ebx
cmpl $-0x1, %eax
sete %bl
negl %ebx
jmp 0x18ee99
pushq $-0x1
popq %rbx
movq %r15, %rdi
callq 0x17f48
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_O2/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 0x198737(%rip), %rsi    # 0x3275f2
callq 0x179e0
testl %eax, %eax
je 0x18ef19
leaq 0x1f0d98(%rip), %rsi    # 0x37fc63
movq %r14, %rdi
callq 0x179e0
testl %eax, %eax
je 0x18ef1d
leaq 0x1b56c9(%rip), %rsi    # 0x3445a7
movq %r14, %rdi
callq 0x179e0
testl %eax, %eax
je 0x18ef21
leaq 0x1c5f79(%rip), %rsi    # 0x354e6a
movq %r14, %rdi
callq 0x179e0
testl %eax, %eax
je 0x18ef25
leaq 0x1c6287(%rip), %rsi    # 0x35518b
leaq 0x1c5ea0(%rip), %rdx    # 0x354dab
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
jmp 0x18ef27
xorl %eax, %eax
jmp 0x18ef28
pushq $0x1
jmp 0x18ef27
pushq $0x2
jmp 0x18ef27
pushq $0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_optimal_maxalilendiff_perc_mat_history
void gt_optimal_maxalilendiff_perc_mat_history(
                GtUword *maxalignedlendifference,
                GtUword *perc_mat_history,
                GtUword arg_maxalignedlendifference,
                GtUword arg_perc_mat_history,
                GtUword errorpercentage,
                GtUword sensitivity)
{
  gt_assert(perc_mat_history != NULL);
  if (arg_maxalignedlendifference == 0)
  {
    if (arg_perc_mat_history == 0)
    {
      const GtGreedyparams *best_value;

      gt_assert(errorpercentage <= 100 - GT_EXTEND_MIN_IDENTITY_PERCENTAGE &&
                sensitivity >= 90 && sensitivity - 90 <= 10);
      best_value = best_percmathistory_maxalilendiff[GT_MIN(sensitivity
                                                               - 90,9)];
      *maxalignedlendifference = best_value[errorpercentage].maxalilendiff;
      *perc_mat_history = best_value[errorpercentage].percmathistory;
    } else
    {
      *maxalignedlendifference = 0; /* case to be implemented */
      *perc_mat_history = arg_perc_mat_history;
    }
  } else
  {
    if (perc_mat_history == 0)
    {
      *maxalignedlendifference = arg_maxalignedlendifference;
      *perc_mat_history = 0; /* case to be implemented */
    } else
    {
      *perc_mat_history = arg_perc_mat_history;
      *maxalignedlendifference = arg_maxalignedlendifference;
    }
  }
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x18ef90
testq %rdx, %rdx
je 0x18ef43
movq %rcx, (%rsi)
movq %rdx, (%rdi)
jmp 0x18ef8e
testq %rcx, %rcx
je 0x18ef51
andq $0x0, (%rdi)
movq %rcx, (%rsi)
jmp 0x18ef8e
cmpq $0x1e, %r8
ja 0x18efbe
cmpq $0x5a, %r9
jb 0x18efbe
addq $-0x5a, %r9
cmpq $0xb, %r9
jae 0x18efbe
cmpq $0x9, %r9
pushq $0x9
popq %rax
cmovbq %r9, %rax
movl %eax, %eax
leaq 0x2aa605(%rip), %rcx    # 0x439580
movq (%rcx,%rax,8), %rax
movslq 0x4(%rax,%r8,8), %rcx
movq %rcx, (%rdi)
movslq (%rax,%r8,8), %rax
movq %rax, (%rsi)
popq %rax
retq
movq 0x2a8fd1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x156072(%rip), %rsi    # 0x2e5013
leaq 0x1c5ec6(%rip), %rdx    # 0x354e6e
leaq 0x1c5ed8(%rip), %rcx    # 0x354e87
leaq 0x1c5d2e(%rip), %r8     # 0x354ce4
movl $0x17e, %r9d            # imm = 0x17E
jmp 0x18efea
movq 0x2a8fa3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x156044(%rip), %rsi    # 0x2e5013
leaq 0x1c5c8a(%rip), %rdx    # 0x354c60
leaq 0x1c5eaa(%rip), %rcx    # 0x354e87
leaq 0x1c5d00(%rip), %r8     # 0x354ce4
movl $0x186, %r9d            # imm = 0x186
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x754dd
movq %rax, %r14
movq %rbx, %rdi
callq 0x7055e
testq %rax, %rax
je 0x18f104
movq %r14, %rdi
callq 0x5741b
testb %al, %al
je 0x18f05f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x754fd
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x754fd
movq %rax, %r14
addq %r15, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x754fd
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x754fd
addq %r15, %rax
jmp 0x18f064
xorl %r14d, %r14d
xorl %eax, %eax
movq %rax, %rcx
addq %r14, %rcx
je 0x18f0f6
cmpq %rax, %r14
cmovbq %r14, %rax
movq %rax, %xmm0
movq 0x15885c(%rip), %xmm1   # 0x2e78e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x158860(%rip), %xmm2   # 0x2e78f0
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 0x1c4c3b(%rip), %xmm3   # 0x353d00
mulsd 0x1b7ed3(%rip), %xmm3   # 0x346fa0
addsd 0x17cc1b(%rip), %xmm3   # 0x30bcf0
xorpd %xmm0, %xmm0
maxsd %xmm3, %xmm0
cvttsd2si %xmm0, %eax
cmpl $0xa, %eax
jae 0x18f132
movl %eax, %eax
leaq 0x1c5b21(%rip), %rcx    # 0x354c10
movsd (%rcx,%rax,8), %xmm0
jmp 0x18f0fe
movsd 0x15712a(%rip), %xmm0   # 0x2e6228
popq %rbx
popq %r14
popq %r15
retq
movq 0x2a8e5d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x155efe(%rip), %rsi    # 0x2e5013
leaq 0x1c6095(%rip), %rdx    # 0x3551b1
leaq 0x1c60b1(%rip), %rcx    # 0x3551d4
leaq 0x1c5bba(%rip), %r8     # 0x354ce4
movl $0x1bd, %r9d            # imm = 0x1BD
jmp 0x18f15e
movq 0x2a8e2f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x155ed0(%rip), %rsi    # 0x2e5013
leaq 0x1c5d67(%rip), %rdx    # 0x354eb1
leaq 0x1c5d96(%rip), %rcx    # 0x354ee7
leaq 0x1c5b8c(%rip), %r8     # 0x354ce4
movl $0x1db, %r9d            # imm = 0x1DB
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18f4bb
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2ba467
movq 0x8(%rbx), %rdi
callq 0x2ba467
movq 0x58(%rbx), %rdi
callq 0x722ae
movq 0x60(%rbx), %rdi
callq 0x722ae
movq 0x68(%rbx), %rdi
leaq 0x1c5875(%rip), %r14    # 0x354ce4
movq %r14, %rsi
movl $0x241, %edx            # imm = 0x241
callq 0x936f9
movq 0x80(%rbx), %rdi
movq %r14, %rsi
movl $0x242, %edx            # imm = 0x242
callq 0x936f9
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x243, %edx            # imm = 0x243
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x244, %edx            # imm = 0x244
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18fa25
cmpq $0x45, %rdi
jbe 0x18fa29
pushq $0x64
popq %rax
subq %rdi, %rax
movq %rax, %rdi
movq %rdi, %rax
retq
pushq %rax
movq 0x2a8537(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1555d8(%rip), %rsi    # 0x2e5013
leaq 0x1c5636(%rip), %rdx    # 0x355078
leaq 0x1c5660(%rip), %rcx    # 0x3550a9
leaq 0x1c5294(%rip), %r8     # 0x354ce4
movl $0x35c, %r9d            # imm = 0x35C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18fe6e
movq 0x18(%rdx), %rax
jmp 0x18fe70
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 0x18febd
movq 0x18(%r9), %r15
jmp 0x18fec0
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 0x19044b
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq