LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/compact_ulong_store.c
// Function: gt_compact_ulong_store_get
GtUword gt_compact_ulong_store_get(const GtCompactUlongStore *cus,
                                         GtUword idx)
{
  unsigned int unitoffset;
  GtUword unitindex;

  gt_assert(idx < cus->numofentries);
  idx *= cus->bitsperentry;
  unitoffset = (unsigned int) GT_MODWORDSIZE(idx);
  unitindex = GT_DIVWORDSIZE(idx);
  if (unitoffset <= (unsigned int) cus->bitsleft) {
    return (GtUword) (cus->tab[unitindex] >>
                             (cus->bitsleft - unitoffset))
           & cus->maskright;
  } else {
    return (GtUword)
           ((cus->tab[unitindex] <<
                (unitoffset + cus->bitsperentry - GT_INTWORDSIZE)) |
              (cus->tab[unitindex+1] >>
                (GT_INTWORDSIZE + cus->bitsleft - unitoffset))) &
           cus->maskright;
  }
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
jbe 0x6bbd3
movl 0x18(%rdi), %ecx
imulq %rcx, %rsi
movl %esi, %r8d
andl $0x3f, %r8d
shrq $0x6, %rsi
movl 0x1c(%rdi), %edx
movq (%rdi), %r9
movq (%r9,%rsi,8), %rax
subl %r8d, %edx
jae 0x6bbc9
addl %r8d, %ecx
shlq %cl, %rax
movq 0x8(%r9,%rsi,8), %rsi
movl %edx, %ecx
shrq %cl, %rsi
orq %rsi, %rax
jmp 0x6bbce
movl %edx, %ecx
shrq %cl, %rax
andq 0x10(%rdi), %rax
retq
pushq %rax
movq 0x3cc38d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27942e(%rip), %rsi    # 0x2e5013
leaq 0x296c41(%rip), %rdx    # 0x30282d
leaq 0x296c52(%rip), %rcx    # 0x302845
leaq 0x296bca(%rip), %r8     # 0x3027c4
pushq $0x5c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/compact_ulong_store.c
// Function: gt_compact_ulong_store_update
void gt_compact_ulong_store_update(GtCompactUlongStore *cus,
                                   GtUword idx, GtUword value)
{
  unsigned int unitoffset;
  GtUword unitindex;

  gt_assert(idx < cus->numofentries && value <= cus->maskright);
  idx *= cus->bitsperentry;
  unitoffset = (unsigned int) GT_MODWORDSIZE(idx);
  unitindex = GT_DIVWORDSIZE(idx);
  if (unitoffset <= (unsigned int) cus->bitsleft) {
    unsigned int shiftleft = cus->bitsleft - unitoffset;

    cus->tab[unitindex]
      = (GtUword) (cus->tab[unitindex] & ~(cus->maskright << shiftleft)) |
        (GtUword) (value << shiftleft);
  } else {
    unsigned int shift = unitoffset - cus->bitsleft;

    cus->tab[unitindex]
      = (GtUword) (cus->tab[unitindex] & ~(cus->maskright >> shift)) |
        (GtUword)(value >> shift);
    shift = (unsigned int) GT_INTWORDSIZE - shift;
    cus->tab[unitindex+1]
      = (GtUword) (cus->tab[unitindex+1] & ~(cus->maskright << shift)) |
        (GtUword) (value << shift);
  }
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
jbe 0x6bc80
movq 0x10(%rdi), %r8
cmpq %rdx, %r8
jb 0x6bc80
movl 0x18(%rdi), %r9d
imulq %rsi, %r9
movl %r9d, %r10d
andl $0x3f, %r10d
movl 0x1c(%rdi), %ecx
shrq $0x6, %r9
movl %r10d, %eax
movq (%rdi), %rsi
leaq (%rsi,%r9,8), %rsi
movq (%rsi), %r9
subl %ecx, %eax
jbe 0x6bc6a
movl %eax, %ecx
shrq %cl, %r8
notq %r8
movq %rdx, %r10
shrq %cl, %r10
andq %r8, %r9
orq %r9, %r10
movq %r10, (%rsi)
pushq $0x40
popq %rcx
subl %eax, %ecx
movq 0x8(%rsi), %r9
addq $0x8, %rsi
movq 0x10(%rdi), %r8
jmp 0x6bc6d
subl %r10d, %ecx
shlq %cl, %r8
shlq %cl, %rdx
notq %r8
andq %r9, %r8
orq %r8, %rdx
movq %rdx, (%rsi)
retq
pushq %rax
movq 0x3cc2e0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x279381(%rip), %rsi    # 0x2e5013
leaq 0x296bc7(%rip), %rdx    # 0x302860
leaq 0x296bf3(%rip), %rcx    # 0x302893
leaq 0x296b1d(%rip), %r8     # 0x3027c4
pushq $0x74
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/compact_ulong_store.c
// Function: gt_compact_ulong_store_unit_test
int gt_compact_ulong_store_unit_test(GtError *err)
{
  GtCompactUlongStore *cus;
  const GtUword constnums = 100000UL;
  unsigned int bits;
  GtUword value, nums, idx, numforbits, *checknumbers;
  int had_err = 0;

  checknumbers = gt_malloc(sizeof (*checknumbers) * constnums);
  for (bits = 1U; bits <= (unsigned int) GT_INTWORDSIZE-1; bits++) {
    numforbits = 1UL << bits;
    nums = numforbits < constnums ? numforbits : constnums;
    cus = gt_compact_ulong_store_new(nums,bits);
    for (idx = 0; idx < nums; idx++) {
      checknumbers[idx] = nums == constnums ? gt_rand_max(numforbits-1) : idx;
      gt_compact_ulong_store_update(cus,idx,checknumbers[idx]);
      value = gt_compact_ulong_store_get(cus,idx);
      gt_ensure(checknumbers[idx] == value);
    }
    for (idx = 0; had_err == 0 && idx < nums; idx++) {
      value = gt_compact_ulong_store_get(cus,idx);
      gt_ensure(checknumbers[idx] == value);
    }
    gt_compact_ulong_store_delete(cus);
  }
  gt_free(checknumbers);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbp
leaq 0x296af5(%rip), %rsi    # 0x3027c4
movl $0xc3500, %edi          # imm = 0xC3500
movl $0x93, %edx
callq 0x93160
movq %rax, %r15
pushq $0x1
popq %rcx
xorl %r12d, %r12d
movq %rbp, 0x8(%rsp)
cmpq $0x40, %rcx
je 0x6be14
pushq $0x1
popq %rbp
shlq %cl, %rbp
movl $0x186a0, %eax          # imm = 0x186A0
cmpq %rax, %rbp
movl $0x186a0, %r14d         # imm = 0x186A0
cmovbq %rbp, %r14
movq %r14, %rdi
movq %rcx, 0x10(%rsp)
movq %rcx, %rsi
callq 0x6ba08
movq %rax, %r13
decq %rbp
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x6bda5
movq %rbx, %rdx
cmpq $0x186a0, %r14          # imm = 0x186A0
jne 0x6bd42
movq %rbp, %rdi
callq 0x955fa
movq %rax, %rdx
movq %rdx, (%r15,%rbx,8)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6bc0a
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6bb8d
testl %r12d, %r12d
pushq $-0x1
popq %r12
jne 0x6bda0
xorl %r12d, %r12d
cmpq %rax, (%r15,%rbx,8)
je 0x6bda0
movq 0x8(%rsp), %rdi
leaq 0x292678(%rip), %rsi    # 0x2fe3f2
leaq 0x296b30(%rip), %rdx    # 0x3028b1
leaq 0x296b44(%rip), %rcx    # 0x3028cc
leaq 0x296a35(%rip), %r8     # 0x3027c4
movl $0x9c, %r9d
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %r12
incq %rbx
jmp 0x6bd26
xorl %ebx, %ebx
movq 0x8(%rsp), %rbp
testl %r12d, %r12d
jne 0x6bdff
cmpq %r14, %rbx
jae 0x6bdff
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6bb8d
xorl %r12d, %r12d
cmpq %rax, (%r15,%rbx,8)
je 0x6bdfa
movq %rbp, %rdi
leaq 0x29261e(%rip), %rsi    # 0x2fe3f2
leaq 0x296ad6(%rip), %rdx    # 0x3028b1
leaq 0x296aea(%rip), %rcx    # 0x3028cc
leaq 0x2969db(%rip), %r8     # 0x3027c4
movl $0xa0, %r9d
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %r12
incq %rbx
jmp 0x6bdac
movq %r13, %rdi
callq 0x6bb56
movq 0x10(%rsp), %rcx
incq %rcx
jmp 0x6bcec
leaq 0x2969a9(%rip), %rsi    # 0x3027c4
movq %r15, %rdi
movl $0xa4, %edx
callq 0x936f9
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/countingsort.c
// Function: gt_countingsort
void gt_countingsort(void *out, const void *in, size_t elem_size,
                     GtUword size, GtUword max_elemvalue,
                     void *data, GtGetElemvalue get_elemvalue)
{
  GtUword i, k, *c;
  gt_assert(out && in && elem_size && size && max_elemvalue && get_elemvalue);

  /* allocate count array */
  c = gt_calloc(sizeof (GtUword), max_elemvalue + 1);

  /* count number of elements of a given value */
  for (i = 0; i < size; i++) {
    k = get_elemvalue((const char*) in + elem_size * i, data);
    gt_assert(k <= max_elemvalue);
    c[k]++;
  }

  /* compute running sum of the count array */
  for (i = 1; i <= max_elemvalue; i++)
    c[i] += c[i-1];

  /* sorting (stable) */
  for (i = size; i > 0; i--) {
    k = get_elemvalue((const char*) in + elem_size * (i-1), data);
    memcpy((char*) out + elem_size * (c[k] - 1),
           (const char*) in + elem_size * (i-1), elem_size);
    c[k]--;
  }

  gt_free(c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
testq %rdi, %rdi
je 0x6bfb6
movq %rsi, %rbx
testq %rsi, %rsi
je 0x6bfb6
movq %rdx, %r15
testq %rdx, %rdx
je 0x6bfb6
movq %rcx, %r13
testq %rcx, %rcx
je 0x6bfb6
testq %r8, %r8
je 0x6bfb6
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x6bfb6
movq %r8, 0x8(%rsp)
leaq 0x1(%r8), %rsi
leaq 0x296a81(%rip), %rdx    # 0x30293e
pushq $0x8
popq %rdi
pushq $0x20
popq %rcx
callq 0x9334a
movq %rax, %rbp
movq %rbx, %r12
movq %r13, %r14
subq $0x1, %r14
jb 0x6bef8
movq %r12, %rdi
movq 0x18(%rsp), %rsi
callq *0x10(%rsp)
cmpq 0x8(%rsp), %rax
ja 0x6bf80
incq (%rbp,%rax,8)
addq %r15, %r12
jmp 0x6bed1
pushq $0x1
popq %rax
movq 0x8(%rsp), %rdx
cmpq %rdx, %rax
ja 0x6bf14
movq -0x8(%rbp,%rax,8), %rcx
addq %rcx, (%rbp,%rax,8)
incq %rax
jmp 0x6bf00
leaq -0x1(%r13), %rax
imulq %r15, %rax
addq %rax, %rbx
movq %r15, %r14
negq %r14
subq $0x1, %r13
jb 0x6bf60
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq *0x10(%rsp)
movq %rax, %r12
movq (%rbp,%rax,8), %rdi
decq %rdi
imulq %r15, %rdi
addq 0x20(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x17630
decq (%rbp,%r12,8)
addq %r14, %rbx
jmp 0x6bf25
leaq 0x2969d7(%rip), %rsi    # 0x30293e
pushq $0x35
popq %rdx
movq %rbp, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x936f9
movq 0x3cbfe1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x279082(%rip), %rsi    # 0x2e5013
leaq 0x2969be(%rip), %rdx    # 0x302956
leaq 0x29698f(%rip), %rcx    # 0x30292e
leaq 0x296998(%rip), %r8     # 0x30293e
pushq $0x25
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3cbfab(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27904c(%rip), %rsi    # 0x2e5013
leaq 0x29691f(%rip), %rdx    # 0x3028ed
leaq 0x296959(%rip), %rcx    # 0x30292e
leaq 0x296962(%rip), %r8     # 0x30293e
pushq $0x1d
jmp 0x6bfa8
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/countingsort.c
// Function: gt_countingsort_get_max
GtUword gt_countingsort_get_max(const void *in, size_t elem_size,
                                      GtUword size, void *data,
                                      GtGetElemvalue get_elemvalue)
{
  GtUword i, value, max_value = 0;
  for (i = 0; i < size; i++) {
    value = get_elemvalue((const char*) in + elem_size * i, data);
    if (value > max_value)
      max_value = value;
  }
  return max_value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
xorl %r13d, %r13d
subq $0x1, %r15
jb 0x6c017
movq %rbp, %rdi
movq %r14, %rsi
callq *%rbx
cmpq %r13, %rax
cmovaq %rax, %r13
addq %r12, %rbp
jmp 0x6bffd
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/countingsort.c
// Function: gt_countingsort_unit_test
int gt_countingsort_unit_test(GtError *err)
{
  unsigned int numbers[]        = { 1, 2, 1, 2, 0 }, numbers_out[5],
               sorted_numbers[] = { 0, 1, 1, 2, 2 };
  int had_err = 0;
  gt_error_check(err);
  gt_countingsort(numbers_out, numbers, sizeof (unsigned int), 5,
                  gt_countingsort_get_max(numbers, sizeof (unsigned int), 5,
                                          NULL, get_int),
                  NULL,  get_int);
  gt_ensure(
         !memcmp(sorted_numbers, numbers_out, sizeof (unsigned int) * 5));
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movaps 0x29698f(%rip), %xmm0   # 0x3029d0
movaps %xmm0, 0x10(%rsp)
andl $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x6c060
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x6c0ff
leaq 0xce(%rip), %r15        # 0x6c135
xorl %r14d, %r14d
leaq 0x10(%rsp), %r12
pushq $0x4
popq %r13
pushq $0x5
popq %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x6bfe0
movq %r15, (%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x6be4c
leaq 0x296940(%rip), %rdi    # 0x3029f0
pushq $0x14
popq %rdx
movq %r15, %rsi
callq 0x177e0
testl %eax, %eax
je 0x6c0ed
leaq 0x29232c(%rip), %rsi    # 0x2fe3f2
leaq 0x2968b6(%rip), %rdx    # 0x302983
leaq 0x296895(%rip), %rcx    # 0x302969
leaq 0x296863(%rip), %r8     # 0x30293e
pushq $0x56
popq %r9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3cbe62(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x278f03(%rip), %rsi    # 0x2e5013
leaq 0x2790a8(%rip), %rdx    # 0x2e51bf
leaq 0x29684b(%rip), %rcx    # 0x302969
leaq 0x296819(%rip), %r8     # 0x30293e
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/dual-pivot-qsort.c
// Function: gt_dual_insertion_sort
static void gt_dual_insertion_sort(GtUword *input,GtUword lowindex,
                                   GtUword highindex)
{
  GtUword pm;

  for (pm = lowindex + 1; pm <= highindex; pm++)
  {
    GtUword pl;

    for (pl = pm; pl > lowindex && input[pl-1] > input[pl]; pl--)
    {
      gt_dpqs_exchange(input, pl, pl-1);
    }
  }
}

// Assembly:
movq %rsi, %rax
incq %rax
cmpq %rdx, %rax
ja 0x6f568
movq %rax, %rcx
cmpq %rsi, %rcx
jbe 0x6f53c
movq -0x8(%rdi,%rcx,8), %r8
movq (%rdi,%rcx,8), %r9
cmpq %r9, %r8
jbe 0x6f53c
movq %r8, (%rdi,%rcx,8)
movq %r9, -0x8(%rdi,%rcx,8)
decq %rcx
jmp 0x6f547
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_set_bit
void gt_dyn_bittab_set_bit(GtDynBittab *b, GtUword bit)
{
  GtUword new_tabsize;
  gt_assert(b);
  /* make sure tab is large enough */
  if (bit >= b->num_of_bits) {
    if ((new_tabsize = determine_tabsize(bit + 1)) > b->tabsize) {
      b->tabptr = gt_realloc(b->tabptr, new_tabsize * sizeof (GtUword));
      memset(b->tabptr + b->tabsize, 0,
             (new_tabsize - b->tabsize) * sizeof (GtUword));
      b->tabsize = new_tabsize;
    }
    b->num_of_bits = bit + 1;
  }
  /* set bit */
  b->tabptr[(bit >> 3) / sizeof (GtUword)] |=
    1UL << (bit & (8UL * sizeof (GtUword) - 1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f7ba
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %r15
cmpq %rsi, 0x10(%rdi)
jbe 0x6f742
movq %r14, %r12
shrq $0x6, %r12
jmp 0x6f79e
leaq 0x1(%r14), %r13
movq %r14, %r12
shrq $0x6, %r12
leaq 0x1(%r12), %rbp
cmpq $0x40, %r13
cmovbq %r15, %rbp
cmpq 0x8(%rbx), %rbp
jbe 0x6f79a
movq (%rbx), %rdi
leaq (,%rbp,8), %rsi
leaq 0x293e1e(%rip), %rdx    # 0x303590
pushq $0x31
popq %rcx
callq 0x93472
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq (%rax,%rcx,8), %rdi
movq %rbp, %rdx
subq %rcx, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x17380
movq %rbp, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movl %r14d, %ecx
shlq %cl, %r15
movq (%rbx), %rax
orq %r15, (%rax,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3c87a7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x275848(%rip), %rsi    # 0x2e5013
leaq 0x28e831(%rip), %rdx    # 0x2fe003
leaq 0x293dcd(%rip), %rcx    # 0x3035a6
leaq 0x293db0(%rip), %r8     # 0x303590
pushq $0x2d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_unset_bit
void gt_dyn_bittab_unset_bit(GtDynBittab *b, GtUword bit)
{
  gt_assert(b);
  if (bit < b->num_of_bits) {
    b->tabptr[(bit >> 3) / sizeof (GtUword)] &=
      ~(1UL << (bit & (8UL * sizeof (GtUword) - 1)));
  }
}

// Assembly:
testq %rdi, %rdi
je 0x6f80f
cmpq %rsi, 0x10(%rdi)
jbe 0x6f80e
pushq $-0x2
popq %rax
movl %esi, %ecx
rolq %cl, %rax
movq (%rdi), %rcx
shrq $0x6, %rsi
andq %rax, (%rcx,%rsi,8)
retq
pushq %rax
movq 0x3c8751(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2757f2(%rip), %rsi    # 0x2e5013
leaq 0x28e7db(%rip), %rdx    # 0x2fe003
leaq 0x293d8d(%rip), %rcx    # 0x3035bc
leaq 0x293d5a(%rip), %r8     # 0x303590
pushq $0x3f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_bit_is_set
bool gt_dyn_bittab_bit_is_set(const GtDynBittab *b, GtUword bit)
{
  gt_assert(b);
  if (bit < b->num_of_bits &&
      (b->tabptr[(bit >> 3) / sizeof (GtUword)] &
       1UL << (bit & (8UL * sizeof (GtUword) - 1)))) {
    return true;
  }
  return false;
}

// Assembly:
testq %rdi, %rdi
je 0x6f86b
cmpq %rsi, 0x10(%rdi)
jbe 0x6f868
movq (%rdi), %rax
movq %rsi, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rcx
movb $0x1, %al
btq %rsi, %rcx
jae 0x6f868
retq
xorl %eax, %eax
retq
pushq %rax
movq 0x3c86f5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x275796(%rip), %rsi    # 0x2e5013
leaq 0x28e77f(%rip), %rdx    # 0x2fe003
leaq 0x293d49(%rip), %rcx    # 0x3035d4
leaq 0x293cfe(%rip), %r8     # 0x303590
pushq $0x48
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_get_first_bitnum
GtUword gt_dyn_bittab_get_first_bitnum(const GtDynBittab *b)
{
  GtUword i, rval = GT_UNDEF_UWORD;
  gt_assert(b);
  for (i = 0; i < b->num_of_bits; i++)
    if (gt_dyn_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f8d9
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
cmpq %rax, %r14
jae 0x6f8d1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f846
testb %al, %al
jne 0x6f8ce
incq %r14
jmp 0x6f8b1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3c8688(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x275729(%rip), %rsi    # 0x2e5013
leaq 0x28e712(%rip), %rdx    # 0x2fe003
leaq 0x293cf5(%rip), %rcx    # 0x3035ed
leaq 0x293c91(%rip), %r8     # 0x303590
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_get_next_bitnum
GtUword gt_dyn_bittab_get_next_bitnum(const GtDynBittab *b,
                                            GtUword curnum)
{
  GtUword i, rval = GT_UNDEF_UWORD;

  gt_assert(b);
  gt_assert(curnum < b->num_of_bits);
  for (i = curnum + 1; i < b->num_of_bits; i++)
    if (gt_dyn_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f98d
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x10(%rdi)
jbe 0x6f9b7
incq %rbx
movq 0x10(%r14), %rax
cmpq %rax, %rbx
jae 0x6f985
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6f846
movl %eax, %ecx
movq %rbx, %rax
testb %cl, %cl
je 0x6f965
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3c85d4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x275675(%rip), %rsi    # 0x2e5013
leaq 0x28e65e(%rip), %rdx    # 0x2fe003
leaq 0x293c7e(%rip), %rcx    # 0x30362a
leaq 0x293bdd(%rip), %r8     # 0x303590
pushq $0x6a
jmp 0x6f9df
movq 0x3c85aa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27564b(%rip), %rsi    # 0x2e5013
leaq 0x2908c9(%rip), %rdx    # 0x300298
leaq 0x293c54(%rip), %rcx    # 0x30362a
leaq 0x293bb3(%rip), %r8     # 0x303590
pushq $0x6b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_create
GtFastaReader* gt_fasta_reader_create(const GtFastaReaderClass *frc)
{
  GtFastaReader *fr;
  gt_assert(frc && frc->size);
  fr = gt_calloc(1, frc->size);
  fr->c_class = frc;
  return fr;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x8c49c
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x8c49c
leaq 0x27e032(%rip), %rdx    # 0x30a4be
pushq $0x1
popq %rdi
pushq $0x1a
popq %rcx
callq 0x9334a
movq %rbx, (%rax)
popq %rbx
retq
movq 0x3abac5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x258b66(%rip), %rsi    # 0x2e5013
leaq 0x27dfe2(%rip), %rdx    # 0x30a496
leaq 0x27dfec(%rip), %rcx    # 0x30a4a7
leaq 0x27dffc(%rip), %r8     # 0x30a4be
pushq $0x19
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_delete
void gt_fasta_reader_delete(GtFastaReader *fr)
{
  if (!fr) return;
  gt_assert(fr->c_class && fr->c_class->free);
  fr->c_class->free(fr);
  gt_free(fr);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x8c504
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x8c506
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x8c506
movq %rbx, %rdi
callq *%rax
leaq 0x27dfc6(%rip), %rsi    # 0x30a4be
pushq $0x24
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
popq %rbx
retq
movq 0x3aba5b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x258afc(%rip), %rsi    # 0x2e5013
leaq 0x27dfb8(%rip), %rdx    # 0x30a4d6
leaq 0x27dfd2(%rip), %rcx    # 0x30a4f7
leaq 0x27df92(%rip), %r8     # 0x30a4be
pushq $0x22
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_run
int gt_fasta_reader_run(GtFastaReader *fr,
                     GtFastaReaderProcDescription proc_description,
                     GtFastaReaderProcSequencePart proc_sequence_part,
                     GtFastaReaderProcSequenceLength proc_sequence_length,
                     void *data, GtError *err)
{
  gt_error_check(err);
  gt_assert(fr && fr->c_class && fr->c_class->run);
  return fr->c_class->run(fr, proc_description, proc_sequence_part,
                          proc_sequence_length, data, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
testq %r9, %r9
je 0x8c56a
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x8c5d9
testq %rbp, %rbp
je 0x8c5a3
movq (%rbp), %rax
testq %rax, %rax
je 0x8c5a3
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x8c5a3
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x3ab9be(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x258a5f(%rip), %rsi    # 0x2e5013
leaq 0x27df67(%rip), %rdx    # 0x30a522
leaq 0x27df4c(%rip), %rcx    # 0x30a50e
leaq 0x27def5(%rip), %r8     # 0x30a4be
pushq $0x2e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3ab988(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x258a29(%rip), %rsi    # 0x2e5013
leaq 0x258bce(%rip), %rdx    # 0x2e51bf
leaq 0x27df16(%rip), %rcx    # 0x30a50e
leaq 0x27debf(%rip), %r8     # 0x30a4be
pushq $0x2d
jmp 0x8c5cb
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fasta_reader_rec.c
// Function: gt_fasta_reader_rec_new
GtFastaReader* gt_fasta_reader_rec_new(const GtStr *sequence_filename)
{
  GtFastaReader *fr = gt_fasta_reader_create(gt_fasta_reader_rec_class());
  GtFastaReaderRec *gt_fasta_reader_rec = gt_fasta_reader_rec_cast(fr);
  gt_fasta_reader_rec->seqio = gt_io_new(sequence_filename
                                   ? gt_str_get(sequence_filename) : NULL,
                                   "r");
  return fr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x3a6060(%rip), %r14    # 0x432b70
movq %r14, %rdi
callq 0x8c474
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x8c603
movq %rax, %r14
testq %r15, %r15
je 0x8cb3b
movq %r15, %rdi
callq 0xad1fa
movq %rax, %rdi
jmp 0x8cb3d
xorl %edi, %edi
leaq 0x26e2e9(%rip), %rsi    # 0x2fae2d
callq 0x924fc
movq %rax, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fastq.c
// Function: gt_fastq_show_entry
void gt_fastq_show_entry(const char *description, const char *sequence,
                         const char *qualities, GtUword sequence_length,
                         GtUword width, bool repeat_description,
                         GtFile *outfp)
{
  gt_assert(sequence);
  gt_assert(qualities);
  gt_fastq_show_buffer(GT_FASTQ_SEPARATOR_SEQ, description, sequence,
      sequence_length, width, outfp);
  gt_fastq_show_buffer(GT_FASTQ_SEPARATOR_QUAL,
      repeat_description ? description : NULL, qualities,
      sequence_length, width, outfp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x8cbba
movq %rdx, %r15
testq %rdx, %rdx
je 0x8cbe4
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %rdx
movq %rdi, %r12
movq 0x40(%rsp), %r13
pushq $0x40
popq %rdi
movq %r12, %rsi
movq %r13, %r9
callq 0x8cc1a
xorl %esi, %esi
testb %bpl, %bpl
cmovneq %r12, %rsi
pushq $0x2b
popq %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %r13, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cc1a
movq 0x3ab3a7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x258448(%rip), %rsi    # 0x2e5013
leaq 0x2a653d(%rip), %rdx    # 0x33310f
leaq 0x27daf1(%rip), %rcx    # 0x30a6ca
leaq 0x27dafe(%rip), %r8     # 0x30a6de
pushq $0x2f
jmp 0x8cc0c
movq 0x3ab37d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x25841e(%rip), %rsi    # 0x2e5013
leaq 0x2960f1(%rip), %rdx    # 0x322ced
leaq 0x27dac7(%rip), %rcx    # 0x30a6ca
leaq 0x27dad4(%rip), %r8     # 0x30a6de
pushq $0x30
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fastq.c
// Function: gt_fastq_show_buffer
static void gt_fastq_show_buffer(char separator, const char *description,
    const char *buffer, GtUword buffer_length, GtUword width,
    GtFile *outfp)
{
  GtUword i, current_length;
  gt_file_xfputc(separator, outfp);
  if (description != NULL)
    gt_file_xfputs(description, outfp);
  gt_file_xfputc('\n', outfp);
  for (i = 0, current_length = 0; i < buffer_length;
       i++, current_length++) {
    if (width && current_length == width) {
      gt_file_xfputc('\n', outfp);
      current_length = 0;
    }
    gt_file_xfputc(buffer[i], outfp);
  }
  gt_file_xfputc('\n', outfp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %r9, %rsi
callq 0x8d771
testq %r13, %r13
je 0x8cc4c
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8d7e9
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x8d771
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %r13, %r15
je 0x8cc96
testq %r14, %r14
setne %al
cmpq %r14, %rbp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8cc81
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x8d771
xorl %ebp, %ebp
movsbl (%r12,%r13), %edi
movq %rbx, %rsi
callq 0x8d771
incq %r13
incq %rbp
jmp 0x8cc5c
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8d771
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/output_file.c
// Function: gt_output_file_info_register_options
void gt_output_file_info_register_options(GtOutputFileInfo *ofi,
                                          GtOptionParser *op, GtFile **outfp)
{
  GtOption *opto, *optgzip, *optbzip2, *optforce;
  gt_assert(outfp && ofi);
  ofi->outfp = outfp;
  /* register option -o */
  opto = gt_option_new_filename("o", "redirect output to specified file",
                                ofi->output_filename);
  gt_option_parser_add_option(op, opto);
  /* register option -gzip */
  optgzip = gt_option_new_bool("gzip", "write gzip compressed output file",
                               &ofi->gzip, false);
  gt_option_parser_add_option(op, optgzip);
  /* register option -bzip2 */
  optbzip2 = gt_option_new_bool("bzip2", "write bzip2 compressed output file",
                                &ofi->bzip2, false);
  gt_option_parser_add_option(op, optbzip2);
  /* register option -force */
  optforce = gt_option_new_bool(GT_FORCE_OPT_CSTR,
                                "force writing to output file",
                                &ofi->force, false);
  gt_option_parser_add_option(op, optforce);
  /* options -gzip and -bzip2 exclude each other */
  gt_option_exclude(optgzip, optbzip2);
  /* option implications */
  gt_option_imply(optgzip, opto);
  gt_option_imply(optbzip2, opto);
  gt_option_imply(optforce, opto);
  /* set hook function to determine <outfp> */
  gt_option_parser_register_hook(op, determine_outfp, ofi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9b7e3
testq %rdx, %rdx
je 0x9b7e3
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x10(%rdi)
movq (%rdi), %rdx
leaq 0x282854(%rip), %rdi    # 0x31df5c
leaq 0x2723e2(%rip), %rsi    # 0x30daf1
callq 0x9ad51
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x8(%rbx), %rdx
leaq 0x2723e6(%rip), %rdi    # 0x30db13
leaq 0x2723e4(%rip), %rsi    # 0x30db18
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x9(%rbx), %rdx
leaq 0x2723e6(%rip), %rdi    # 0x30db3a
leaq 0x2723e5(%rip), %rsi    # 0x30db40
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xa(%rbx), %rdx
leaq 0x26fe80(%rip), %rdi    # 0x30b5fb
leaq 0x2558fa(%rip), %rsi    # 0x2f107c
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %rbp
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r12, %rdi
movq %r13, %rsi
callq 0x9b38d
movq %r12, %rdi
movq %r15, %rsi
callq 0x9b14d
movq %r13, %rdi
movq %r15, %rsi
callq 0x9b14d
movq %rbp, %rdi
movq %r15, %rsi
callq 0x9b14d
leaq 0x4f(%rip), %rsi        # 0x9b819
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x980d4
movq 0x39c77e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24981f(%rip), %rsi    # 0x2e5013
leaq 0x2722c4(%rip), %rdx    # 0x30dabf
leaq 0x2722ca(%rip), %rcx    # 0x30dacc
leaq 0x27229f(%rip), %r8     # 0x30daa8
pushq $0x57
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/output_file.c
// Function: gt_output_file_xopen_forcecheck
GtFile* gt_output_file_xopen_forcecheck(const char *path, const char *mode,
                                       bool force, GtError *err)
{
  gt_error_check(err);
  gt_assert(path && mode);
  if (!force && gt_file_exists(path)) {
    gt_error_set(err, "file \"%s\" exists already, use option -%s to overwrite",
                 path, GT_FORCE_OPT_CSTR);
    return NULL;
  }
  return gt_file_xopen(path, mode);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
testq %rcx, %rcx
je 0x9ba70
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x9baf2
testq %rbx, %rbx
je 0x9bac8
testq %r15, %r15
je 0x9bac8
testb %bpl, %bpl
jne 0x9bab3
movq %rbx, %rdi
callq 0x8da98
testb %al, %al
je 0x9bab3
leaq 0x2720f1(%rip), %rsi    # 0x30db83
leaq 0x26fb62(%rip), %rcx    # 0x30b5fb
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x89dbb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8d244
movq 0x39c499(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24953a(%rip), %rsi    # 0x2e5013
leaq 0x26e36c(%rip), %rdx    # 0x309e4c
leaq 0x27207c(%rip), %rcx    # 0x30db63
leaq 0x271fba(%rip), %r8     # 0x30daa8
pushq $0x7f
jmp 0x9bb1a
movq 0x39c46f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x249510(%rip), %rsi    # 0x2e5013
leaq 0x2496b5(%rip), %rdx    # 0x2e51bf
leaq 0x272052(%rip), %rcx    # 0x30db63
leaq 0x271f90(%rip), %r8     # 0x30daa8
pushq $0x7e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/quality.c
// Function: gt_quality_phred_to_errorprob
double gt_quality_phred_to_errorprob(double phredscore)
{
  double rval;
  rval = pow(10.0, (double)(-0.1*phredscore));
  gt_assert(rval >= 0.0 && rval <= 1.0);
  return rval;
}

// Assembly:
pushq %rax
movapd %xmm0, %xmm1
mulsd 0x270945(%rip), %xmm1   # 0x30e520
movsd 0x2573cd(%rip), %xmm0   # 0x2f4fb0
callq 0x17d10
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9dc02
movsd 0x24862e(%rip), %xmm1   # 0x2e6228
ucomisd %xmm0, %xmm1
jb 0x9dc02
popq %rax
retq
movq 0x39a35f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x247400(%rip), %rsi    # 0x2e5013
leaq 0x2709cf(%rip), %rdx    # 0x30e5e9
leaq 0x2709e3(%rip), %rcx    # 0x30e604
leaq 0x270993(%rip), %r8     # 0x30e5bb
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/quality.c
// Function: gt_quality_solexa_to_errorprob
double gt_quality_solexa_to_errorprob(double solexascore)
{
  double rval;
  rval = 1.0/(1.0 + pow(10.0, (solexascore/10.0)));
  gt_assert(rval >= 0.0 && rval <= 1.0);
  return rval;
}

// Assembly:
pushq %rax
movapd %xmm0, %xmm1
movsd 0x25736b(%rip), %xmm0   # 0x2f4fb0
divsd %xmm0, %xmm1
callq 0x17d10
movapd %xmm0, %xmm1
movsd 0x2485ce(%rip), %xmm2   # 0x2e6228
addsd %xmm2, %xmm1
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9dc78
ucomisd %xmm0, %xmm2
jb 0x9dc78
popq %rax
retq
movq 0x39a2e9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24738a(%rip), %rsi    # 0x2e5013
leaq 0x270959(%rip), %rdx    # 0x30e5e9
leaq 0x27098b(%rip), %rcx    # 0x30e622
leaq 0x27091d(%rip), %r8     # 0x30e5bb
pushq $0x3b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_lsb_linear
void gt_radixsort_lsb_linear(GtUword *source,GtUword len)
{
  GtUword *dest = gt_malloc(sizeof (*dest) * len);

  gt_radixsort_lsb_linear_generic(sizeof (GtUword) - 1,
                                  source,
                                  dest,
                                  len);
  gt_free(dest);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rsi, %r12
movq %rdi, %r14
leaq (,%rsi,8), %rbx
leaq 0x26ec81(%rip), %rsi    # 0x30ede8
movq %rbx, %rdi
movl $0x8e, %edx
callq 0x93160
movq %rax, %r15
leaq -0x8(,%r12,8), %rax
xorl %edx, %edx
pushq $0x8
popq %rsi
movq %r15, %rcx
movq %rcx, %rdi
cmpq $0x8, %rdx
je 0xa0228
xorl %ecx, %ecx
cmpq $0x7f9, %rcx            # imm = 0x7F9
jae 0xa01aa
andq $0x0, (%rsp,%rcx)
addq $0x8, %rcx
jmp 0xa0196
leaq (,%rdx,8), %rcx
leaq (%r14,%r12,8), %r8
movq %r14, %r9
cmpq %r8, %r9
jae 0xa01d2
movq (%r9), %r10
shrq %cl, %r10
movzbl %r10b, %r10d
incq (%rsp,%r10,8)
addq $0x8, %r9
jmp 0xa01b9
movq %rsi, %r8
cmpq $0x7f9, %r8             # imm = 0x7F9
jae 0xa01ed
movq -0x8(%rsp,%r8), %r9
addq %r9, (%rsp,%r8)
addq $0x8, %r8
jmp 0xa01d5
leaq (%r14,%rax), %r8
cmpq %r14, %r8
jb 0xa021a
movq (%r8), %r9
shrq %cl, %r9
movzbl %r9b, %r9d
movq (%rsp,%r9,8), %r10
leaq -0x1(%r10), %r11
movq %r11, (%rsp,%r9,8)
movq (%r8), %r9
movq %r9, -0x8(%rdi,%r10,8)
addq $-0x8, %r8
jmp 0xa01f1
incq %rdx
movq %r14, %rcx
movq %rdi, %r14
jmp 0xa0187
cmpq %r15, %r14
jne 0xa023d
cmpq %r15, %rdi
je 0xa025f
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17630
leaq 0x26eba4(%rip), %rsi    # 0x30ede8
movq %r15, %rdi
movl $0x94, %edx
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x936f9
movq 0x397d02(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x244da3(%rip), %rsi    # 0x2e5013
leaq 0x26ec81(%rip), %rdx    # 0x30eef8
leaq 0x26ec8b(%rip), %rcx    # 0x30ef09
leaq 0x26eb63(%rip), %r8     # 0x30ede8
movl $0x87, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_delete
void gt_radixsort_delete(GtRadixsortinfo *radixsortinfo)
{
  if (radixsortinfo != NULL)
  {
#ifdef GT_THREADS_ENABLED
    const unsigned int threads = GT_THREADS_JOBS;

    if (threads > 1U)
    {
      unsigned int t;
      gt_free(radixsortinfo->lentab);
      gt_free(radixsortinfo->endindexes);
      for (t = 0; t < threads; t++)
      {
        GT_STACK_DELETE(&radixsortinfo->threadinfo[t].stack);
        gt_radixbuffer_delete(radixsortinfo->threadinfo[t].rbuf);
      }
      gt_free(radixsortinfo->threadinfo);
    }
#endif
    if (radixsortinfo->maxlen > 0)
    {
      if (radixsortinfo->elemtype == GtRadixelemtypeGtUwordPair)
      {
        gt_free(radixsortinfo->sortspace.ulongpairptr);
      } else
      {
        if (radixsortinfo->elemtype == GtRadixelemtypeGtUword)
        {
          gt_free(radixsortinfo->sortspace.ulongptr);
        } else
        {
          if (radixsortinfo->elemtype == GtRadixelemtypeGtuint64keyPair)
          {
            gt_free(radixsortinfo->sortspace.uint64keypairptr);
          } else
          {
            gt_free(radixsortinfo->sortspace.flbaptr);
          }
        }
      }
    }
    gt_radixbuffer_delete(radixsortinfo->rbuf);
    GT_STACK_DELETE(&radixsortinfo->stack);
    gt_free(radixsortinfo);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xa05f8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x398868(%rip), %rax    # 0x438dc8
movl (%rax), %r15d
cmpq $0x2, %r15
jb 0xa060a
movq 0x3060(%rbx), %rdi
leaq 0x26e86d(%rip), %r14    # 0x30ede8
movq %r14, %rsi
movl $0x211, %edx            # imm = 0x211
callq 0x936f9
movq 0x3068(%rbx), %rdi
movq %r14, %rsi
movl $0x212, %edx            # imm = 0x212
callq 0x936f9
imulq $0x3048, %r15, %r15     # imm = 0x3048
xorl %r12d, %r12d
movq 0x3070(%rbx), %rdi
cmpq %r12, %r15
je 0xa05f9
movq (%rdi,%r12), %rax
cmpq 0x18(%rdi,%r12), %rax
jbe 0xa05e2
movq 0x3028(%rdi,%r12), %rdi
movq %r14, %rsi
movl $0x215, %edx            # imm = 0x215
callq 0x936f9
movq 0x3070(%rbx), %rdi
andq $0x0, 0x3028(%rdi,%r12)
movq 0x3038(%rdi,%r12), %rdi
callq 0xa0696
addq $0x3048, %r12           # imm = 0x3048
jmp 0xa05a6
retq
leaq 0x26e7e8(%rip), %rsi    # 0x30ede8
movl $0x218, %edx            # imm = 0x218
callq 0x936f9
cmpq $0x0, 0x3048(%rbx)
je 0xa0642
movl 0x3050(%rbx), %eax
movq 0x3040(%rbx), %rdi
movl $0x22c, %edx            # imm = 0x22C
cmpq $0x2, %rax
ja 0xa0636
leaq 0x26ecad(%rip), %rcx    # 0x30f2e0
movl (%rcx,%rax,4), %edx
leaq 0x26e7ab(%rip), %rsi    # 0x30ede8
callq 0x936f9
movq 0x3038(%rbx), %rdi
callq 0xa0696
movq (%rbx), %rax
cmpq 0x18(%rbx), %rax
jbe 0xa0677
movq 0x3028(%rbx), %rdi
leaq 0x26e783(%rip), %rsi    # 0x30ede8
movl $0x232, %edx            # imm = 0x232
callq 0x936f9
andq $0x0, 0x3028(%rbx)
leaq 0x26e76a(%rip), %rsi    # 0x30ede8
movq %rbx, %rdi
movl $0x233, %edx            # imm = 0x233
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixbuffer_delete
static void gt_radixbuffer_delete(GtRadixbuffer *rbuf)
{
  gt_assert(rbuf != NULL);
  if (rbuf->elemtype == GtRadixelemtypeGtUwordPair)
  {
    gt_free(rbuf->values.ulongpairptr);
  } else
  {
    if (rbuf->elemtype == GtRadixelemtypeGtUword)
    {
      gt_free(rbuf->values.ulongptr);
    } else
    {
      if (rbuf->elemtype == GtRadixelemtypeGtuint64keyPair)
      {
        gt_free(rbuf->values.uint64keypairptr);
      } else
      {
        gt_free(rbuf->tmpvalue_ptr);
        gt_free(rbuf->tmpswap_ptr);
        gt_free(rbuf->values.flbaptr);
      }
    }
  }
  gt_free(rbuf->nextidx);
  gt_free(rbuf->startofbin);
  gt_free(rbuf->endofbin);
  gt_free(rbuf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa0746
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpq $0x3, %rax
jae 0xa06bb
leaq 0x26ec36(%rip), %rcx    # 0x30f2ec
movl (%rcx,%rax,4), %edx
jmp 0xa06e9
movq 0x60(%rbx), %rdi
leaq 0x26e722(%rip), %r14    # 0x30ede8
movq %r14, %rsi
movl $0x159, %edx            # imm = 0x159
callq 0x936f9
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movl $0x15a, %edx            # imm = 0x15A
callq 0x936f9
movl $0x15b, %edx            # imm = 0x15B
movq 0x48(%rbx), %rdi
leaq 0x26e6f4(%rip), %r14    # 0x30ede8
movq %r14, %rsi
callq 0x936f9
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x15f, %edx            # imm = 0x15F
callq 0x936f9
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x160, %edx            # imm = 0x160
callq 0x936f9
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x161, %edx            # imm = 0x161
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x162, %edx            # imm = 0x162
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x39781b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2448bc(%rip), %rsi    # 0x2e5013
leaq 0x26e7cb(%rip), %rdx    # 0x30ef29
leaq 0x26e7d1(%rip), %rcx    # 0x30ef36
leaq 0x26e67c(%rip), %r8     # 0x30ede8
movl $0x149, %r9d            # imm = 0x149
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_inplace_ulong
void gt_radixsort_inplace_ulong(GtUword *source, GtUword len)
{
  GtRadixvalues radixvalues;
  GtRadixsortinfo *radixsortinfo;

  radixsortinfo = gt_radixsort_new_ulong(0);
  radixvalues.ulongptr = source;
  gt_radixsort_inplace(radixsortinfo,&radixvalues,len);
  gt_radixsort_delete(radixsortinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0xa0297
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0xa081a
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xa0545
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_inplace_flba
void gt_radixsort_inplace_flba(uint8_t *source,GtUword len,size_t unitsize)
{
  GtRadixvalues radixvalues;
  GtRadixsortinfo *radixsortinfo;

  radixsortinfo = gt_radixsort_new_flba(0,unitsize);
  radixvalues.flbaptr = source;
  gt_radixsort_inplace(radixsortinfo,&radixvalues,len);
  gt_radixsort_delete(radixsortinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
movq %rdx, %rsi
callq 0xa04ef
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0xa081a
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xa0545
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/score_function.c
// Function: gt_score_function_new
GtScoreFunction* gt_score_function_new(GtScoreMatrix *sm, int deletion_score,
                                 int insertion_score)
{
  GtScoreFunction *sf;
  gt_assert(sm);
  sf = gt_malloc(sizeof (GtScoreFunction));
  sf->sm = sm;
  sf->deletion_score = deletion_score;
  sf->insertion_score = insertion_score;
  sf->reference_count = 0;
  return sf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa4879
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x26b462(%rip), %rsi    # 0x30fcbd
pushq $0x18
popq %rdi
pushq $0x21
popq %rdx
callq 0x93160
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
andq $0x0, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3936e8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x240789(%rip), %rsi    # 0x2e5013
leaq 0x299a0f(%rip), %rdx    # 0x33e2a0
leaq 0x26b40f(%rip), %rcx    # 0x30fca7
leaq 0x26b41e(%rip), %r8     # 0x30fcbd
pushq $0x20
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/score_function.c
// Function: gt_score_function_delete
void gt_score_function_delete(GtScoreFunction *sf)
{
  if (!sf) return;
  if (sf->reference_count) {
    sf->reference_count--;
    return;
  }
  gt_score_matrix_delete(sf->sm);
  gt_free(sf);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa49dd
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xa49df
decq %rax
movq %rax, 0x10(%rbx)
popq %rbx
retq
movq (%rbx), %rdi
callq 0xa51c9
leaq 0x26b2cf(%rip), %rsi    # 0x30fcbd
pushq $0x51
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_new
GtSeqIterator* gt_seq_iterator_sequence_buffer_new(const GtStrArray
                                                                   *filenametab,
                                                  GtError *err)
{
  GtSeqIterator *si;
  GtSequenceBuffer *sb = gt_sequence_buffer_new_guess_type(filenametab, err);
  if (!sb)
    return NULL;
  si = gt_seq_iterator_sequence_buffer_new_with_buffer(sb);
  gt_sequence_buffer_delete(sb); /* drop this reference */
  return si;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0xa77c3
testq %rax, %rax
je 0xa70f9
movq %rax, %rbx
movq %rax, %rdi
callq 0xa7103
movq %rax, %r14
movq %rbx, %rdi
callq 0xa76dc
movq %r14, %rax
jmp 0xa70fb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_new_with_buffer
GtSeqIterator* gt_seq_iterator_sequence_buffer_new_with_buffer(
                                                       GtSequenceBuffer *buffer)
{
  GtSeqIterator *si;
  GtSeqIteratorSequenceBuffer *seqit;
  si = gt_seq_iterator_create(gt_seq_iterator_sequence_buffer_class());
  seqit = gt_seq_iterator_sequence_buffer_cast(si);
  GT_INITARRAY(&seqit->sequencebuffer, GtUchar);
  seqit->descptr = gt_desc_buffer_new();
  seqit->fb = gt_sequence_buffer_ref(buffer);
  gt_sequence_buffer_set_desc_buffer(seqit->fb, seqit->descptr);
  seqit->exhausted = false;
  seqit->unitnum = 0;
  seqit->withsequence = true;
  seqit->currentread = 0;
  seqit->maxread = 0;
  return si;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xa7178
movq %rax, %rdi
callq 0xa6100
movq %rax, %rbx
callq 0xa7178
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa615e
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
andq $0x0, 0x38(%rax)
callq 0x6cf90
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0xa777b
movq %rax, 0x8(%r15)
movq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0xa7a5d
andq $0x0, 0x40(%r15)
movw $0x1, 0x48(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_class
const GtSeqIteratorClass* gt_seq_iterator_sequence_buffer_class(void)
{
  static const GtSeqIteratorClass *sic = NULL;
  gt_class_alloc_lock_enter();
  if (!sic) {
    sic = gt_seq_iterator_class_new(sizeof (GtSeqIteratorSequenceBuffer),
                            gt_seq_iterator_sequence_buffer_set_symbolmap,
                            gt_seq_iterator_sequence_buffer_set_sequence_output,
                            gt_seq_iterator_sequence_buffer_next,
                            gt_seq_iterator_sequence_buffer_getcurrentcounter,
                            NULL,
                            gt_seq_iterator_sequence_buffer_delete);
  }
  gt_class_alloc_lock_leave();
  return sic;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x39637a(%rip)    # 0x43d500
jne 0xa71c1
leaq 0x44a(%rip), %rax       # 0xa75d9
movq %rax, (%rsp)
leaq 0x35(%rip), %rsi        # 0xa71cf
leaq 0x96(%rip), %rdx        # 0xa7237
leaq 0xee(%rip), %rcx        # 0xa7296
leaq 0x3c3(%rip), %r8        # 0xa7572
pushq $0x60
popq %rdi
xorl %r9d, %r9d
callq 0xa60ac
movq %rax, 0x39633f(%rip)    # 0x43d500
callq 0x69ede
movq 0x396333(%rip), %rax    # 0x43d500
popq %rcx
retq