LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_get
GtUword gt_intset_get(GtIntset *intset, GtUword idx)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->get_func != NULL)
    return intset->c_class->get_func(intset, idx);
  return intset->members->num_of_elems;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf3660
movq (%rdi), %rax
testq %rax, %rax
je 0xf368a
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xf3656
popq %rcx
jmpq *%rax
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rax
popq %rcx
retq
movq 0x344901(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f19a2(%rip), %rsi    # 0x2e5013
leaq 0x231ab9(%rip), %rdx    # 0x325131
leaq 0x231ae7(%rip), %rcx    # 0x325166
leaq 0x231a3f(%rip), %r8     # 0x3250c5
pushq $0x3d
jmp 0xf36b2
movq 0x3448d7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1978(%rip), %rsi    # 0x2e5013
leaq 0x231aac(%rip), %rdx    # 0x32514e
leaq 0x231abd(%rip), %rcx    # 0x325166
leaq 0x231a15(%rip), %r8     # 0x3250c5
pushq $0x3e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size
GtUword gt_intset_size(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->size_func != NULL)
    return intset->c_class->size_func(intset);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf36de
movq (%rdi), %rax
testq %rax, %rax
je 0xf3708
movq 0x40(%rax), %rax
testq %rax, %rax
je 0xf36da
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
movq 0x344883(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1924(%rip), %rsi    # 0x2e5013
leaq 0x231a3b(%rip), %rdx    # 0x325131
leaq 0x231a77(%rip), %rcx    # 0x325174
leaq 0x2319c1(%rip), %r8     # 0x3250c5
pushq $0x46
jmp 0xf3730
movq 0x344859(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f18fa(%rip), %rsi    # 0x2e5013
leaq 0x231a2e(%rip), %rdx    # 0x32514e
leaq 0x231a4d(%rip), %rcx    # 0x325174
leaq 0x231997(%rip), %r8     # 0x3250c5
pushq $0x47
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_is_member
bool gt_intset_is_member(GtIntset *intset, GtUword elem)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->is_member_func != NULL)
    return intset->c_class->is_member_func(intset, elem);
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf375c
movq (%rdi), %rax
testq %rax, %rax
je 0xf3786
movq 0x30(%rax), %rax
testq %rax, %rax
je 0xf3758
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
movq 0x344805(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f18a6(%rip), %rsi    # 0x2e5013
leaq 0x2319bd(%rip), %rdx    # 0x325131
leaq 0x231a08(%rip), %rcx    # 0x325183
leaq 0x231943(%rip), %r8     # 0x3250c5
pushq $0x4f
jmp 0xf37ae
movq 0x3447db(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f187c(%rip), %rsi    # 0x2e5013
leaq 0x2319b0(%rip), %rdx    # 0x32514e
leaq 0x2319de(%rip), %rcx    # 0x325183
leaq 0x231919(%rip), %r8     # 0x3250c5
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_get_idx_smallest_geq
GtUword gt_intset_get_idx_smallest_geq(GtIntset *intset, GtUword pos)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->idx_sm_geq_func != NULL)
    return intset->c_class->idx_sm_geq_func(intset, pos);
  return GT_UWORD_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf37db
movq (%rdi), %rax
testq %rax, %rax
je 0xf3805
movq 0x28(%rax), %rax
testq %rax, %rax
je 0xf37d6
popq %rcx
jmpq *%rax
pushq $-0x1
popq %rax
popq %rcx
retq
movq 0x344786(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1827(%rip), %rsi    # 0x2e5013
leaq 0x23193e(%rip), %rdx    # 0x325131
leaq 0x23199d(%rip), %rcx    # 0x325197
leaq 0x2318c4(%rip), %r8     # 0x3250c5
pushq $0x58
jmp 0xf382d
movq 0x34475c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f17fd(%rip), %rsi    # 0x2e5013
leaq 0x231931(%rip), %rdx    # 0x32514e
leaq 0x231973(%rip), %rcx    # 0x325197
leaq 0x23189a(%rip), %r8     # 0x3250c5
pushq $0x59
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_write
GtIntset *gt_intset_write(GtIntset *intset, FILE *fp, GtError *err)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->size_func != NULL)
    return intset->c_class->write_func(intset, fp, err);
  return intset;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf385c
movq (%rdi), %rax
testq %rax, %rax
je 0xf3886
cmpq $0x0, 0x40(%rax)
je 0xf3857
movq 0x50(%rax), %rax
popq %rcx
jmpq *%rax
movq %rdi, %rax
popq %rcx
retq
movq 0x344705(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f17a6(%rip), %rsi    # 0x2e5013
leaq 0x2318bd(%rip), %rdx    # 0x325131
leaq 0x23193b(%rip), %rcx    # 0x3251b6
leaq 0x231843(%rip), %r8     # 0x3250c5
pushq $0x61
jmp 0xf38ae
movq 0x3446db(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f177c(%rip), %rsi    # 0x2e5013
leaq 0x2318b0(%rip), %rdx    # 0x32514e
leaq 0x231911(%rip), %rcx    # 0x3251b6
leaq 0x231819(%rip), %r8     # 0x3250c5
pushq $0x62
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size_of_rep
size_t gt_intset_size_of_rep(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->rep_size_func != NULL)
    return intset->c_class->rep_size_func(intset->members->maxelement,
                                          intset->members->num_of_elems);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf38e6
movq (%rdi), %rax
testq %rax, %rax
je 0xf3910
movq 0x38(%rax), %rax
testq %rax, %rax
je 0xf38e2
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
movq 0x28(%rcx), %rsi
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
movq 0x34467b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f171c(%rip), %rsi    # 0x2e5013
leaq 0x231833(%rip), %rdx    # 0x325131
leaq 0x2318c1(%rip), %rcx    # 0x3251c6
leaq 0x2317b9(%rip), %r8     # 0x3250c5
pushq $0x6a
jmp 0xf3938
movq 0x344651(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f16f2(%rip), %rsi    # 0x2e5013
leaq 0x231826(%rip), %rdx    # 0x32514e
leaq 0x231897(%rip), %rcx    # 0x3251c6
leaq 0x23178f(%rip), %r8     # 0x3250c5
pushq $0x6b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size_of_struct
size_t gt_intset_size_of_struct(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->rep_size_func != NULL)
    return intset->c_class->struct_size_func();
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf3963
movq (%rdi), %rax
testq %rax, %rax
je 0xf398d
cmpq $0x0, 0x38(%rax)
je 0xf395f
popq %rcx
jmpq *0x48(%rax)
xorl %eax, %eax
popq %rcx
retq
movq 0x3445fe(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f169f(%rip), %rsi    # 0x2e5013
leaq 0x2317b6(%rip), %rdx    # 0x325131
leaq 0x23185a(%rip), %rcx    # 0x3251dc
leaq 0x23173c(%rip), %r8     # 0x3250c5
pushq $0x74
jmp 0xf39b5
movq 0x3445d4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1675(%rip), %rsi    # 0x2e5013
leaq 0x2317a9(%rip), %rdx    # 0x32514e
leaq 0x231830(%rip), %rcx    # 0x3251dc
leaq 0x231712(%rip), %r8     # 0x3250c5
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_delete
void gt_intset_delete(GtIntset *intset)
{
  if (intset != NULL) {
    if (intset->members->refcount) {
      intset->members->refcount--;
      return;
    }
    gt_assert(intset->c_class);
    if (intset->c_class->delete_func != NULL)
      intset->c_class->delete_func(intset);
    gt_free(intset->members->sectionstart);
    gt_free(intset->members);
    gt_free(intset);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf3a49
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0xf3a51
decq %rcx
movq %rcx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xf3aaa
movq 0x58(%rcx), %rcx
testq %rcx, %rcx
je 0xf3a6b
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq (%rax), %rdi
leaq 0x231650(%rip), %r14    # 0x3250c5
movq %r14, %rsi
movl $0xa3, %edx
callq 0x936f9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0xa4, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa5, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x3444b7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1558(%rip), %rsi    # 0x2e5013
leaq 0x231733(%rip), %rdx    # 0x3251f5
leaq 0x23173c(%rip), %rcx    # 0x325205
leaq 0x2315f5(%rip), %r8     # 0x3250c5
movl $0xa0, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_unit_test_notinset
int gt_intset_unit_test_notinset(GtIntset *intset, GtUword start,
                                 GtUword end, GtError *err)
{
  int had_err = 0;
  GtUword test;
  for (test = start; test <= end; ++test) {
    gt_ensure(gt_intset_is_member(intset, test) == false);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $-0x1
popq %r13
leaq 0x2315c1(%rip), %rbp    # 0x3250c5
xorl %eax, %eax
cmpq %r14, %r15
ja 0xf3b55
testl %eax, %eax
movl %r13d, %eax
jne 0xf3b50
movq %r12, %rdi
movq %r15, %rsi
callq 0xf373e
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xf3b50
movq %rbx, %rdi
leaq 0x20a8c3(%rip), %rsi    # 0x2fe3f2
leaq 0x2316e0(%rip), %rdx    # 0x325216
leaq 0x231704(%rip), %rcx    # 0x325241
movq %rbp, %r8
movl $0xaf, %r9d
xorl %eax, %eax
callq 0x89dbb
movl %r13d, %eax
incq %r15
jmp 0xf3b06
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/extended/intset.c
// Function: gt_intset_unit_test_check_seqnum
int gt_intset_unit_test_check_seqnum(GtIntset *intset, GtUword start,
                                     GtUword end, GtUword num, GtError *err)
{
  int had_err = 0;
  GtUword test;
  for (test = start; test <= end; ++test) {
    gt_ensure(gt_intset_get_idx_smallest_geq(intset, test) == num);
  }
  return had_err;
}

// 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, %r13
pushq $-0x1
popq %rbp
xorl %eax, %eax
cmpq %r15, %r12
ja 0xf3bd6
testl %eax, %eax
movl %ebp, %eax
jne 0xf3bd1
movq %r13, %rdi
movq %r12, %rsi
callq 0xf37bc
movq %rax, %rcx
xorl %eax, %eax
cmpq %r14, %rcx
je 0xf3bd1
movq %rbx, %rdi
leaq 0x20a845(%rip), %rsi    # 0x2fe3f2
leaq 0x2316aa(%rip), %rdx    # 0x32525e
leaq 0x2316d7(%rip), %rcx    # 0x325292
leaq 0x231503(%rip), %r8     # 0x3250c5
movl $0xba, %r9d
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %eax
incq %r12
jmp 0xf3b83
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset_combined.c
// Function: gt_intset_best_new
GtIntset *gt_intset_best_new(GtUword maxelement, GtUword num_of_elems)
{
  size_t s8, s16, s32;
  gt_assert(GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint8_t));
  s8 = gt_intset_8_size_of_rep(maxelement, num_of_elems);
  s16 = GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint16_t) ?
    gt_intset_16_size_of_rep(maxelement, num_of_elems) :
    s8;
  s32 = GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint32_t) ?
    gt_intset_32_size_of_rep(maxelement, num_of_elems) :
    s8;
  if (s8 <= s16) {
    if (s8 <= s32)
      return gt_intset_8_new(maxelement, num_of_elems);
  }
  else {
    if (s16 <= s32)
      return gt_intset_16_new(maxelement, num_of_elems);
  }
  return gt_intset_32_new(maxelement, num_of_elems);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x29f3ca
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29d1ab
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29e2cc
cmpq %r12, %r15
jbe 0xf3c37
cmpq %rax, %r12
ja 0xf3c3c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29c7a4
cmpq %rax, %r15
jbe 0xf3c52
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29d8c4
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29e9e4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset_combined.c
// Function: gt_intset_best_memory_size
size_t gt_intset_best_memory_size(GtUword maxelement, GtUword num_of_elems)
{
  size_t s8, s16, s32;
  gt_assert(GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint8_t));
  s8 = gt_intset_8_size_of_rep(maxelement, num_of_elems);
  s16 = GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint16_t) ?
    gt_intset_16_size_of_rep(maxelement, num_of_elems) :
    s8;
  s32 = GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint32_t) ?
    gt_intset_32_size_of_rep(maxelement, num_of_elems) :
    s8;
  if (s8 <= s16) {
    if (s8 <= s32)
      return s8;
  }
  else {
    if (s16 <= s32)
      return s16;
  }
  return s32;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
callq 0x29f3ca
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x29d1ab
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0x29e2cc
cmpq %r14, %rbx
jbe 0xf3ca6
cmpq %rax, %r14
ja 0xf3cae
movq %r14, %rax
jmp 0xf3cae
cmpq %rax, %rbx
ja 0xf3cae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset_combined.c
// Function: gt_intset_io
GtIntset *gt_intset_io(GtIntset *intset, FILE *fp, GtError *err)
{
  int had_err = 0;
  GtUword type;
  if (intset == NULL) {
    had_err = gt_intset_read_type_rewind(fp, &type, err);
    if (!had_err && gt_intset_8_file_is_type(type))
      intset = gt_intset_8_io(intset, fp, err);
    else {
      if (!had_err && gt_intset_16_file_is_type(type))
        intset = gt_intset_16_io(intset, fp, err);
      else {
        if (!had_err && gt_intset_32_file_is_type(type))
          intset = gt_intset_32_io(intset, fp, err);
        else {
          if (!gt_error_is_set(err))
            gt_error_set(err, "could not identify intset type from file");
        }
      }
    }
  }
  else {
    gt_assert(intset->c_class != NULL);
    gt_assert(intset->c_class->io_func != NULL);
    intset = intset->c_class->io_func(intset, fp, err);
  }
  return intset;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0xf3d01
movq (%rdi), %rax
testq %rax, %rax
je 0xf3de2
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xf3e0c
movq %r14, %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x17610
testl %eax, %eax
je 0xf3d25
leaq 0x231624(%rip), %rsi    # 0x32533d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
jmp 0xf3d3d
movq %rsp, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xf3eed
testl %eax, %eax
je 0xf3d6d
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
je 0xf3d4e
xorl %r14d, %r14d
jmp 0xf3d62
leaq 0x23155e(%rip), %rsi    # 0x3252b3
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x17400
testl %eax, %eax
je 0xf3d87
leaq 0x2315c7(%rip), %rsi    # 0x32534c
jmp 0xf3d19
movq (%rsp), %rdi
callq 0x29f3dd
testb %al, %al
je 0xf3da3
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x29ed8b
jmp 0xf3ddd
movq (%rsp), %rdi
callq 0x29d1c1
testb %al, %al
je 0xf3dbf
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x29cb4f
jmp 0xf3ddd
movq (%rsp), %rdi
callq 0x29e2e3
testb %al, %al
je 0xf3d3d
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x29dc74
movq %rax, %r14
jmp 0xf3d62
movq 0x34417f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1220(%rip), %rsi    # 0x2e5013
leaq 0x231354(%rip), %rdx    # 0x32514e
leaq 0x2314db(%rip), %rcx    # 0x3252dc
leaq 0x2314e1(%rip), %r8     # 0x3252e9
pushq $0x75
jmp 0xf3e34
movq 0x344155(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f11f6(%rip), %rsi    # 0x2e5013
leaq 0x2314e4(%rip), %rdx    # 0x325308
leaq 0x2314b1(%rip), %rcx    # 0x3252dc
leaq 0x2314b7(%rip), %r8     # 0x3252e9
pushq $0x76
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/intset_combined.c
// Function: gt_intset_unit_test
int gt_intset_unit_test(GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  if (GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint8_t))
    had_err = gt_intset_8_unit_test(err);
  if (!had_err && GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint16_t))
    had_err = gt_intset_16_unit_test(err);
  if (!had_err && GT_BITS_FOR_TYPE(GtUword) > GT_BITS_FOR_TYPE(uint32_t))
    had_err = gt_intset_32_unit_test(err);
  return had_err;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xf3e57
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xf3e7a
movq %rbx, %rdi
callq 0x29f3e5
testl %eax, %eax
jne 0xf3e6f
movq %rbx, %rdi
callq 0x29d1c9
testl %eax, %eax
je 0xf3e71
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x29e2eb
movq 0x3440e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1188(%rip), %rsi    # 0x2e5013
leaq 0x1f132d(%rip), %rdx    # 0x2e51bf
leaq 0x231490(%rip), %rcx    # 0x325329
leaq 0x231449(%rip), %r8     # 0x3252e9
pushq $0x7f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_delete
void gt_kmer_database_delete(GtKmerDatabase *kdb)
{
  if (kdb != NULL) {
    gt_free(kdb->offset);
    gt_free(kdb->seen_kmer_counts);
    gt_free(kdb->positions);
    gt_free(kdb->unique_ids);
    gt_free(kdb->sb.kmers);
    gt_bittab_delete(kdb->deleted_positions);
    GT_FREEARRAY(kdb->sb.intervals, GtRange);
    gt_free(kdb->sb.intervals);
    GT_FREEARRAY(kdb->sb.ids, GtUword);
    gt_free(kdb->sb.ids);
    gt_encseq_delete(kdb->sb.es);
    gt_kmercodeiterator_delete(kdb->sb.kmer_iter);
    gt_free(kdb);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xf4281
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x23128d(%rip), %r14    # 0x3253f3
movq %r14, %rsi
movl $0x86, %edx
callq 0x936f9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x87, %edx
callq 0x936f9
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x88, %edx
callq 0x936f9
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x89, %edx
callq 0x936f9
movq 0xa0(%rbx), %rdi
movq %r14, %rsi
movl $0x8a, %edx
callq 0x936f9
movq 0x20(%rbx), %rdi
callq 0x5ecf6
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0xf41f8
leaq 0x23121a(%rip), %rsi    # 0x3253f3
movq %rax, %rdi
movl $0x8c, %edx
callq 0x936f9
movq 0x80(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x2311f4(%rip), %rsi    # 0x3253f3
movl $0x8d, %edx
callq 0x936f9
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0xf423e
leaq 0x2311d4(%rip), %rsi    # 0x3253f3
movq %rax, %rdi
movl $0x8e, %edx
callq 0x936f9
movq 0x88(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x2311ae(%rip), %r14    # 0x3253f3
movq %r14, %rsi
movl $0x8f, %edx
callq 0x936f9
movq 0x90(%rbx), %rdi
callq 0x735fd
movq 0x98(%rbx), %rdi
callq 0x19f83e
movq %rbx, %rdi
movq %r14, %rsi
movl $0x92, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_add_kmer_to_sb
static void gt_kmer_database_add_kmer_to_sb(GtKmerDatabase *kdb,
                                            GtCodetype kmercode,
                                            GtUword startpos,
                                            GtUword id)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->sb.kmer_count <= kdb->sb.max_nu_kmers);

  startpos -= kdb->sb.offset;
  kdb->sb.kmers[kdb->sb.kmer_count].a = gt_kmer_database_encode_kmer(kmercode,
                                                                     startpos);
  kdb->sb.kmers[kdb->sb.kmer_count].b = id;
  kdb->sb.kmer_count++;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf448d
movq 0xb0(%rdi), %rax
cmpq 0xa8(%rdi), %rax
ja 0xf44bb
subq 0xc0(%rdi), %rdx
shlq $0x20, %rsi
orq %rdx, %rsi
movq 0xa0(%rdi), %rdx
movq %rax, %r8
shlq $0x4, %r8
movq %rsi, (%rdx,%r8)
movq %rcx, 0x8(%rdx,%r8)
incq %rax
movq %rax, 0xb0(%rdi)
popq %rax
retq
movq 0x343ad4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f0b75(%rip), %rsi    # 0x2e5013
leaq 0x230fb5(%rip), %rdx    # 0x32545a
leaq 0x2318e0(%rip), %rcx    # 0x325d8c
leaq 0x230f40(%rip), %r8     # 0x3253f3
movl $0x170, %r9d            # imm = 0x170
jmp 0xf44e7
movq 0x343aa6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f0b47(%rip), %rsi    # 0x2e5013
leaq 0x2318d9(%rip), %rdx    # 0x325dac
leaq 0x2318b2(%rip), %rcx    # 0x325d8c
leaq 0x230f12(%rip), %r8     # 0x3253f3
movl $0x171, %r9d            # imm = 0x171
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_startpos
GtKmerStartpos gt_kmer_database_get_startpos(GtKmerDatabase *kdb,
                                             GtCodetype kmercode)
{
  GtKmerStartpos sp;

  gt_assert(kdb != NULL);
  gt_assert(kmercode < kdb->nu_kmer_codes);
  gt_assert(kdb->positions != NULL);
  gt_assert(kdb->unique_ids != NULL);

  sp.startpos = kdb->positions + kdb->offset[kmercode];
  sp.unique_ids = kdb->unique_ids + kdb->offset[kmercode];
  sp.no_positions = kdb->offset[kmercode + 1] - kdb->offset[kmercode];
  if (kdb->mean_cutoff &&
      sp.no_positions > kdb->min_cutoff &&
      sp.no_positions > (kdb->cutoff / GT_KMER_DATABASE_DELETE_BUFFFER))
    sp.no_positions = 0;
  else if (kdb->cutoff_is_set && sp.no_positions > kdb->cutoff)
    sp.no_positions = 0;

  return sp;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0xf5161
cmpq %rdx, 0x28(%rsi)
jbe 0xf5192
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0xf51c0
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0xf51ee
movq (%rsi), %r8
movq (%r8,%rdx,8), %r9
leaq (%rax,%r9,8), %rax
movq %rax, (%rdi)
leaq (%rcx,%r9,8), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%r8,%rdx,8), %rax
subq %r9, %rax
movq %rax, 0x10(%rdi)
cmpb $0x1, 0x79(%rsi)
jne 0xf514b
cmpq 0x50(%rsi), %rax
jbe 0xf514b
cmpq 0x48(%rsi), %rax
ja 0xf5157
cmpb $0x1, 0x78(%rsi)
jne 0xf515c
cmpq 0x48(%rsi), %rax
jbe 0xf515c
andq $0x0, 0x10(%rdi)
movq %rdi, %rax
popq %rcx
retq
movq 0x342e00(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efea1(%rip), %rsi    # 0x2e5013
leaq 0x2302e1(%rip), %rdx    # 0x32545a
leaq 0x2304b9(%rip), %rcx    # 0x325639
leaq 0x23026c(%rip), %r8     # 0x3253f3
movl $0x20a, %r9d            # imm = 0x20A
jmp 0xf521a
movq 0x342dcf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efe70(%rip), %rsi    # 0x2e5013
leaq 0x23042f(%rip), %rdx    # 0x3255d9
leaq 0x230488(%rip), %rcx    # 0x325639
leaq 0x23023b(%rip), %r8     # 0x3253f3
movl $0x20b, %r9d            # imm = 0x20B
jmp 0xf521a
movq 0x342da1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efe42(%rip), %rsi    # 0x2e5013
leaq 0x23047f(%rip), %rdx    # 0x325657
leaq 0x23045a(%rip), %rcx    # 0x325639
leaq 0x23020d(%rip), %r8     # 0x3253f3
movl $0x20c, %r9d            # imm = 0x20C
jmp 0xf521a
movq 0x342d73(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efe14(%rip), %rsi    # 0x2e5013
leaq 0x230468(%rip), %rdx    # 0x32566e
leaq 0x23042c(%rip), %rcx    # 0x325639
leaq 0x2301df(%rip), %r8     # 0x3253f3
movl $0x20d, %r9d            # imm = 0x20D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_set_cutoff
void gt_kmer_database_set_cutoff(GtKmerDatabase *kdb, GtUword cutoff)
{
  gt_assert(kdb != NULL);
  gt_assert(cutoff != 0);

  kdb->cutoff = cutoff;
  kdb->cutoff_is_set = true;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf523b
testq %rsi, %rsi
je 0xf5269
movq %rsi, 0x48(%rdi)
movb $0x1, 0x78(%rdi)
popq %rax
retq
movq 0x342d26(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efdc7(%rip), %rsi    # 0x2e5013
leaq 0x230207(%rip), %rdx    # 0x32545a
leaq 0x23042c(%rip), %rcx    # 0x325686
leaq 0x230192(%rip), %r8     # 0x3253f3
movl $0x21e, %r9d            # imm = 0x21E
jmp 0xf5295
movq 0x342cf8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efd99(%rip), %rsi    # 0x2e5013
leaq 0x230479(%rip), %rdx    # 0x3256fa
leaq 0x2303fe(%rip), %rcx    # 0x325686
leaq 0x230164(%rip), %r8     # 0x3253f3
movl $0x21f, %r9d            # imm = 0x21F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_use_mean_cutoff
void gt_kmer_database_use_mean_cutoff(GtKmerDatabase *kdb,
                                      GtUword mean_fraction, GtUword min_cutoff)
{
  gt_assert(kdb != NULL);
  gt_assert(mean_fraction != 0);
  gt_assert(min_cutoff != 0);

  kdb->cutoff_is_set = true;
  kdb->mean_cutoff = true;
  kdb->mean_fraction = mean_fraction;
  kdb->min_cutoff = min_cutoff;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf5304
testq %rsi, %rsi
je 0xf5332
testq %rdx, %rdx
je 0xf5360
movw $0x101, 0x78(%rdi)      # imm = 0x101
movq %rsi, 0x58(%rdi)
movq %rdx, 0x50(%rdi)
popq %rax
retq
movq 0x342c5d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efcfe(%rip), %rsi    # 0x2e5013
leaq 0x23013e(%rip), %rdx    # 0x32545a
leaq 0x23039f(%rip), %rcx    # 0x3256c2
leaq 0x2300c9(%rip), %r8     # 0x3253f3
movl $0x22f, %r9d            # imm = 0x22F
jmp 0xf538c
movq 0x342c2f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efcd0(%rip), %rsi    # 0x2e5013
leaq 0x230399(%rip), %rdx    # 0x3256e3
leaq 0x230371(%rip), %rcx    # 0x3256c2
leaq 0x23009b(%rip), %r8     # 0x3253f3
movl $0x230, %r9d            # imm = 0x230
jmp 0xf538c
movq 0x342c01(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efca2(%rip), %rsi    # 0x2e5013
leaq 0x23037e(%rip), %rdx    # 0x3256f6
leaq 0x230343(%rip), %rcx    # 0x3256c2
leaq 0x23006d(%rip), %r8     # 0x3253f3
movl $0x231, %r9d            # imm = 0x231
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_mean_nu_of_occ
GtUword gt_kmer_database_get_mean_nu_of_occ(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->seen_kmers <= kdb->nu_kmer_codes);

  if (kdb->seen_kmers == 0)
    return 0;
  return kdb->seen_kmer_counts[kdb->nu_kmer_codes] / kdb->seen_kmers;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf54c8
movq 0x28(%rdi), %rax
movq 0x40(%rdi), %rcx
cmpq %rax, %rcx
ja 0xf54f6
testq %rcx, %rcx
je 0xf54c4
movq 0x8(%rdi), %rdx
movq (%rdx,%rax,8), %rax
xorl %edx, %edx
divq %rcx
jmp 0xf54c6
xorl %eax, %eax
popq %rcx
retq
movq 0x342a99(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efb3a(%rip), %rsi    # 0x2e5013
leaq 0x22ff7a(%rip), %rdx    # 0x32545a
leaq 0x23028c(%rip), %rcx    # 0x325773
leaq 0x22ff05(%rip), %r8     # 0x3253f3
movl $0x251, %r9d            # imm = 0x251
jmp 0xf5522
movq 0x342a6b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efb0c(%rip), %rsi    # 0x2e5013
leaq 0x230289(%rip), %rdx    # 0x325797
leaq 0x23025e(%rip), %rcx    # 0x325773
leaq 0x22fed7(%rip), %r8     # 0x3253f3
movl $0x252, %r9d            # imm = 0x252
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_min_nu_of_occ
GtUword gt_kmer_database_get_min_nu_of_occ(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->min_nu_occ <= kdb->seen_kmer_counts[kdb->nu_kmer_codes]);

  if (kdb->offset[kdb->nu_kmer_codes] == 0)
    return 0;
  return kdb->min_nu_occ;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf5556
movq 0x60(%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rcx
cmpq (%rdx,%rcx,8), %rax
ja 0xf5584
movq (%rdi), %rdx
movq (%rdx,%rcx,8), %rcx
testq %rcx, %rcx
cmoveq %rcx, %rax
popq %rcx
retq
movq 0x342a0b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efaac(%rip), %rsi    # 0x2e5013
leaq 0x22feec(%rip), %rdx    # 0x32545a
leaq 0x230248(%rip), %rcx    # 0x3257bd
leaq 0x22fe77(%rip), %r8     # 0x3253f3
movl $0x25b, %r9d            # imm = 0x25B
jmp 0xf55b0
movq 0x3429dd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1efa7e(%rip), %rsi    # 0x2e5013
leaq 0x230244(%rip), %rdx    # 0x3257e0
leaq 0x23021a(%rip), %rcx    # 0x3257bd
leaq 0x22fe49(%rip), %r8     # 0x3253f3
movl $0x25c, %r9d            # imm = 0x25C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_check_consistency
int gt_kmer_database_check_consistency(GtKmerDatabase *kdb, GtError *err)
{
  int had_err = 0;
  GtUword i,
          j,
          end,
          start = (GtUword) 0;

  gt_error_check(err);

  for (i = 0; !had_err && i < kdb->nu_kmer_codes; i++) {
    end = kdb->offset[i + 1];
    if (start > end) {
      gt_error_set(err, "Kmer Database is inconsistent in offset at kmer: "
          GT_WU ", start: " GT_WU ", end: " GT_WU, i, start, end);
      had_err = - 1;
    }
    for (j = start + 1; !had_err && j < end; j++) {
      if (kdb->positions[j - 1] >= kdb->positions[j]) {
        gt_error_set(err, "Kmer Database is inconsistent in positions at "
            "kmer: " GT_WU ", last startposition: " GT_WU
            ", current startposition " GT_WU, i, kdb->positions[j - 1],
            kdb->positions[j]);
        had_err = -1;
      }
      if (kdb->unique_ids[j - 1] > kdb->unique_ids[j]) {
        gt_error_set(err, "Kmer Database is inconsistent in unique_ids at "
            "kmer: " GT_WU ", last startposition: " GT_WU ", current "
            "startposition " GT_WU,
            i, kdb->unique_ids[j - 1], kdb->unique_ids[j]);
        had_err = -1;
      }
    }
    start = end;
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xf574d
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xf581c
pushq $-0x1
popq %rbp
xorl %r15d, %r15d
xorl %eax, %eax
xorl %r12d, %r12d
testl %eax, %eax
jne 0xf580b
cmpq 0x28(%r14), %r15
jae 0xf5809
movq (%r14), %rax
movq 0x8(%rax,%r15,8), %r13
xorl %eax, %eax
cmpq %r13, %r12
jbe 0xf5795
movq %rbx, %rdi
leaq 0x230211(%rip), %rsi    # 0x325994
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %eax
leaq 0x1(%r15), %rcx
movq %rcx, (%rsp)
incq %r12
testl %eax, %eax
jne 0xf57fd
cmpq %r13, %r12
jae 0xf57fd
movq 0x10(%r14), %rax
movq -0x8(%rax,%r12,8), %rcx
movq (%rax,%r12,8), %r8
xorl %eax, %eax
cmpq %r8, %rcx
jb 0xf57d3
movq %rbx, %rdi
leaq 0x230218(%rip), %rsi    # 0x3259df
movq %r15, %rdx
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %eax
movq 0x18(%r14), %rdx
movq -0x8(%rdx,%r12,8), %rcx
movq (%rdx,%r12,8), %r8
cmpq %r8, %rcx
jbe 0xf579d
movq %rbx, %rdi
leaq 0x23025c(%rip), %rsi    # 0x325a4b
movq %r15, %rdx
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %eax
jmp 0xf579d
movq (%rsp), %r15
movq %r13, %r12
jmp 0xf5758
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x342745(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ef7e6(%rip), %rsi    # 0x2e5013
leaq 0x1ef98b(%rip), %rdx    # 0x2e51bf
leaq 0x230136(%rip), %rcx    # 0x325971
leaq 0x22fbb1(%rip), %r8     # 0x3253f3
movl $0x299, %r9d            # imm = 0x299
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_byte_size
GtUword gt_kmer_database_get_byte_size(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);

  return ((GtUword) kdb->current_size * sizeof (*kdb->positions)) +
    ((GtUword) kdb->current_size * sizeof (*kdb->unique_ids)) +
   (2 * ((GtUword) sizeof (GtUword) * (kdb->nu_kmer_codes + 1)) - 1);
}

// Assembly:
testq %rdi, %rdi
je 0xf5871
movq 0x28(%rdi), %rax
movq 0x38(%rdi), %rcx
shlq $0x4, %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $0xf, %rax
retq
pushq %rax
movq 0x3426ef(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ef790(%rip), %rsi    # 0x2e5013
leaq 0x22fbd0(%rip), %rdx    # 0x32545a
leaq 0x230227(%rip), %rcx    # 0x325ab8
leaq 0x22fb5b(%rip), %r8     # 0x3253f3
movl $0x2ba, %r9d            # imm = 0x2BA
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_used_size
GtUword gt_kmer_database_get_used_size(GtKmerDatabase *kdb)
{
  GtUword size_positions;

  gt_assert(kdb != NULL);

  size_positions = (GtUword) sizeof (GtUword) * kdb->offset[kdb->nu_kmer_codes];

  return size_positions + 2 *
    ((GtUword) sizeof (GtUword) * (kdb->nu_kmer_codes + 1)) - 1;
}

// Assembly:
testq %rdi, %rdi
je 0xf58c7
movq (%rdi), %rax
movq 0x28(%rdi), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x4, %rcx
leaq (%rcx,%rax,8), %rax
addq $0xf, %rax
retq
pushq %rax
movq 0x342699(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ef73a(%rip), %rsi    # 0x2e5013
leaq 0x22fb7a(%rip), %rdx    # 0x32545a
leaq 0x2301f0(%rip), %rcx    # 0x325ad7
leaq 0x22fb05(%rip), %r8     # 0x3253f3
movl $0x2c5, %r9d            # imm = 0x2C5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_print_buffer
void gt_kmer_database_print_buffer(GtKmerDatabase *kdb, GtLogger *logger)
{
  GtUword i,
          kmercode,
          startpos;

  gt_assert(kdb != NULL && logger != NULL);

  if (!gt_logger_enabled(logger) || kdb->sb.printed)
    return;

  for (i = 0; i < kdb->sb.kmer_count; i++) {
    gt_kmer_database_decode_kmer(kdb->sb.kmers[i].a, kmercode, startpos);
    gt_logger_log(logger, "Kmer: " GT_WU ", Startpos: " GT_WU, kmercode,
           startpos + kdb->sb.offset);
  }
  kdb->sb.printed = true;
  gt_logger_log(logger, "number of kmers in sb: " GT_WU, kdb->sb.kmer_count);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xf5b83
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf5b83
movq %rdi, %r14
movq %rbx, %rdi
callq 0x92c18
testb %al, %al
je 0xf5b10
cmpb $0x0, 0xd4(%r14)
je 0xf5b1a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2300cd(%rip), %r15    # 0x325bee
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0xb0(%r14), %rdx
cmpq %rdx, %r13
jae 0xf5b61
movq 0xa0(%r14), %rax
movq (%rax,%r12), %rdx
movl %edx, %ecx
shrq $0x20, %rdx
addq 0xc0(%r14), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x92e71
incq %r13
addq $0x10, %r12
jmp 0xf5b27
movb $0x1, 0xd4(%r14)
leaq 0x230097(%rip), %rsi    # 0x325c07
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x92e71
movq 0x3423de(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ef47f(%rip), %rsi    # 0x2e5013
leaq 0x22ff5b(%rip), %rdx    # 0x325af6
leaq 0x23002e(%rip), %rcx    # 0x325bd0
leaq 0x22f84a(%rip), %r8     # 0x3253f3
movl $0x2fc, %r9d            # imm = 0x2FC
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign.c
// Function: gt_linearalign_compute_generic
GtUword gt_linearalign_compute_generic(GtLinspaceManagement *spacemanager,
                                       const GtScoreHandler *scorehandler,
                                       GtAlignment *align,
                                       const GtUchar *useq,
                                       GtUword ustart,
                                       GtUword ulen,
                                       const GtUchar *vseq,
                                       GtUword vstart,
                                       GtUword vlen)
{
  GtUword distance;
  gt_assert(spacemanager && scorehandler && align);

  gt_alignment_set_seqs(align, useq+ustart, ulen, vseq+vstart, vlen);
  distance = gt_calc_linearalign(spacemanager, scorehandler, align,
                                 useq, ustart, ulen,
                                 vseq, vstart, vlen);

  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf6cde
movq %rsi, %r13
testq %rsi, %rsi
je 0xf6cde
movq %rdx, %r12
testq %rdx, %rdx
je 0xf6cde
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbp
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %rcx
leaq (%r15,%r14), %rsi
addq 0x40(%rsp), %rcx
movq %r12, %rdi
movq %r9, %rdx
callq 0xb4f1f
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
jmp 0xf6440
movq 0x341283(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ee324(%rip), %rsi    # 0x2e5013
leaq 0x22463a(%rip), %rdx    # 0x31b330
leaq 0x22f272(%rip), %rcx    # 0x325f6f
leaq 0x22f250(%rip), %r8     # 0x325f54
movl $0x1bb, %r9d            # imm = 0x1BB
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign.c
// Function: gt_linearalign_compute
GtUword gt_linearalign_compute(GtLinspaceManagement *spacemanager,
                               GtAlignment *align,
                               const GtUchar *useq,
                               GtUword ustart,
                               GtUword ulen,
                               const GtUchar *vseq,
                               GtUword vstart,
                               GtUword vlen,
                               GtUword matchcost,
                               GtUword mismatchcost,
                               GtUword gapcost)
{
  GtUword distance;
  GtScoreHandler *scorehandler;
  gt_assert(spacemanager && align);

  scorehandler = gt_scorehandler_new(matchcost, mismatchcost, 0, gapcost);

  distance =  gt_linearalign_compute_generic(spacemanager, scorehandler, align,
                                             useq, ustart, ulen,
                                             vseq, vstart, vlen);
  gt_scorehandler_delete(scorehandler);
  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
testq %rdi, %rdi
je 0xf6d9f
movq %rsi, %r13
testq %rsi, %rsi
je 0xf6d9f
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbp
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0x1148f4
movq %rax, %rbx
subq $0x8, %rsp
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x18(%rsp)
callq 0xf6c6f
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x114a03
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3411c2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ee263(%rip), %rsi    # 0x2e5013
leaq 0x224230(%rip), %rdx    # 0x31afe7
leaq 0x22f1d0(%rip), %rcx    # 0x325f8e
leaq 0x22f18f(%rip), %r8     # 0x325f54
movl $0x1d5, %r9d            # imm = 0x1D5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign.c
// Function: gt_linearalign_compute_local
GtWord gt_linearalign_compute_local(GtLinspaceManagement *spacemanager,
                                    GtAlignment *align,
                                    const GtUchar *useq,
                                    GtUword ustart,
                                    GtUword ulen,
                                    const GtUchar *vseq,
                                    GtUword vstart,
                                    GtUword vlen,
                                    GtWord matchscore,
                                    GtWord mismatchscore,
                                    GtWord gapscore)
{
  GtWord score;
  gt_assert(align && spacemanager);
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchscore,
                                                     mismatchscore,
                                                     0, gapscore);

  score = gt_linearalign_compute_local_generic(spacemanager, scorehandler,
                                               align, useq, ustart, ulen,
                                               vseq, vstart, vlen);
  gt_scorehandler_delete(scorehandler);
  return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
testq %rdi, %rdi
je 0xf72fa
movq %rsi, %r13
testq %rsi, %rsi
je 0xf72fa
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbp
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0x1148f4
movq %rax, %rbx
subq $0x8, %rsp
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x18(%rsp)
callq 0xf6dd7
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x114a03
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x340c67(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1edd08(%rip), %rsi    # 0x2e5013
leaq 0x22ecb8(%rip), %rdx    # 0x325fca
leaq 0x22ecc7(%rip), %rcx    # 0x325fe0
leaq 0x22ec34(%rip), %r8     # 0x325f54
movl $0x2da, %r9d            # imm = 0x2DA
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign.c
// Function: evaluatelinearcrosspoints_thread_caller
static void *evaluatelinearcrosspoints_thread_caller(void *data)
{
  GtLinearCrosspointthreadinfo *threadinfo =
                                         (GtLinearCrosspointthreadinfo *) data;
  (void) evaluatelinearcrosspoints(threadinfo->spacemanager,
                                   threadinfo->scorehandler,
                                   threadinfo->useq,
                                   threadinfo->ustart,
                                   threadinfo-> ulen,
                                   threadinfo->vseq,
                                   threadinfo->vstart,
                                   threadinfo->vlen,
                                   threadinfo->Ctab,
                                   threadinfo->rowoffset,
                                   threadinfo->threadidx,
                                   threadinfo->threadcount);
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %r8
movq 0x18(%rdi), %r9
movups 0x30(%rdi), %xmm0
movups 0x40(%rdi), %xmm1
movups 0x50(%rdi), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0xf670d
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_set_edge
GtAffineAlignEdge gt_linearalign_affinegapcost_set_edge(GtWord Rdist,
                                                        GtWord Ddist,
                                                        GtWord Idist)
{
  GtUword minvalue = GT_MIN3(Rdist, Ddist, Idist);

  if (Rdist == minvalue)
    return Affine_R;
  else if (Ddist == minvalue)
    return Affine_D;
  else if (Idist == minvalue)
    return Affine_I;

  return Affine_X;
}

// Assembly:
cmpq %rsi, %rdi
movq %rsi, %rcx
cmovlq %rdi, %rcx
cmpq %rdx, %rcx
movq %rdx, %r8
cmovlq %rcx, %r8
xorl %eax, %eax
cmpq %rdi, %r8
je 0xf7883
cmpq %rsi, %r8
jne 0xf7878
pushq $0x1
popq %rax
retq
xorl %eax, %eax
cmpq %rdx, %rcx
setl %al
orl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_minAdditionalCosts
GtAffineAlignEdge gt_linearalign_affinegapcost_minAdditionalCosts(
                                              const GtAffinealignDPentry *entry,
                                              const GtAffineAlignEdge edge,
                                              GtUword gap_opening)
{
  GtUword rdist, ddist, idist;

  switch (edge) {
    case Affine_D:
      rdist = add_safe_max(entry->Rvalue, gap_opening);
      ddist = entry->Dvalue;
      idist = add_safe_max(entry->Ivalue, gap_opening);
     break;
    case Affine_I:
      rdist = add_safe_max(entry->Rvalue, gap_opening);
      ddist = add_safe_max(entry->Dvalue, gap_opening);
      idist = entry->Ivalue;
      break;
    default:
      rdist = entry->Rvalue;
      ddist = entry->Dvalue;
      idist = entry->Ivalue;
  }

  return gt_linearalign_affinegapcost_set_edge(rdist, ddist, idist);
}

// Assembly:
movq (%rdi), %rcx
cmpl $0x2, %esi
je 0xf78ba
cmpl $0x1, %esi
jne 0xf78e9
leaq (%rcx,%rdx), %rax
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
cmpq %r8, %rcx
cmovneq %rax, %rcx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rax
addq %rax, %rdx
cmpq %r8, %rax
cmoveq %rax, %rdx
jmp 0xf78f1
leaq (%rcx,%rdx), %rax
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rsi, %rcx
cmovneq %rax, %rcx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
addq %rax, %rdx
cmpq %rsi, %rax
cmoveq %rax, %rdx
movq %rdx, %rsi
movq %rdi, %rdx
jmp 0xf78f1
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
cmpq %rsi, %rcx
movq %rsi, %rdi
cmovlq %rcx, %rdi
cmpq %rdx, %rdi
movq %rdx, %r8
cmovlq %rdi, %r8
xorl %eax, %eax
cmpq %rcx, %r8
je 0xf7920
cmpq %rsi, %r8
jne 0xf7915
pushq $0x1
popq %rax
retq
xorl %eax, %eax
cmpq %rdx, %rdi
setl %al
orl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute_generic
GtUword gt_linearalign_affinegapcost_compute_generic(
                                            GtLinspaceManagement *spacemanager,
                                            const GtScoreHandler *scorehandler,
                                            GtAlignment *align,
                                            const GtUchar *useq,
                                            GtUword ustart,
                                            GtUword ulen,
                                            const GtUchar *vseq,
                                            GtUword vstart,
                                            GtUword vlen)
{
  GtUword distance;
  gt_assert(spacemanager && scorehandler && align);

  gt_alignment_set_seqs(align,useq+ustart, ulen, vseq+vstart, vlen);
  distance = gt_calc_affinealign_linear(spacemanager, scorehandler, align,
                                        useq, ustart, ulen,
                                        vseq, vstart, vlen);
  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf8708
movq %rsi, %r13
testq %rsi, %rsi
je 0xf8708
movq %rdx, %r12
testq %rdx, %rdx
je 0xf8708
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbp
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %rcx
leaq (%r15,%r14), %rsi
addq 0x40(%rsp), %rcx
movq %r12, %rdi
movq %r9, %rdx
callq 0xb4f1f
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
jmp 0xf7921
movq 0x33f859(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ec8fa(%rip), %rsi    # 0x2e5013
leaq 0x222c10(%rip), %rdx    # 0x31b330
leaq 0x22dbe1(%rip), %rcx    # 0x326308
leaq 0x22dc07(%rip), %r8     # 0x326335
movl $0x2bf, %r9d            # imm = 0x2BF
xorl %eax, %eax
callq 0x17a50
callq 0x17390