LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
cmpq %rdx, %rsi
ja 0x15e59d
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
leaq 0x22fcc2(%rip), %r13    # 0x38e1f9
leaq 0x22fb3f(%rip), %rbp    # 0x38e07d
xorl %eax, %eax
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x15e587
movq %r12, %rdi
movq %r15, %rsi
callq 0x15e345
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x15e587
movq %rbx, %rdi
leaq 0x208fd2(%rip), %rsi    # 0x36753a
leaq 0x22fc5f(%rip), %rdx    # 0x38e1ce
movq %r13, %rcx
movq %rbp, %r8
movl $0xaf, %r9d
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq %r15
cmpq %r14, %r15
jbe 0x15e540
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
cmpq %rdx, %rsi
ja 0x15e62f
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
leaq 0x22fab3(%rip), %rbp    # 0x38e07d
xorl %eax, %eax
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x15e619
movq %r13, %rdi
movq %r12, %rsi
callq 0x15e36d
movq %rax, %rcx
xorl %eax, %eax
cmpq %r14, %rcx
je 0x15e619
movq %rbx, %rdi
leaq 0x208f44(%rip), %rsi    # 0x36753a
leaq 0x22fc19(%rip), %rdx    # 0x38e216
leaq 0x22fc46(%rip), %rcx    # 0x38e24a
movq %rbp, %r8
movl $0xba, %r9d
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq %r12
cmpq %r15, %r12
jbe 0x15e5cc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30c147
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x309c3f
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30aeda
cmpq %r12, %r15
jbe 0x15e67f
cmpq %rax, %r12
ja 0x15e684
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3090c8
cmpq %rax, %r15
jbe 0x15e69a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30a360
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30b5f8
// File: /workspace/github_c_makefile_star2_O1/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 0x30c147
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x309c3f
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0x30aeda
cmpq %r14, %rbx
jbe 0x15e6ee
cmpq %rax, %r14
ja 0x15e6f6
movq %r14, %rax
jmp 0x15e6f6
cmpq %rax, %rbx
ja 0x15e6f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15e749
movq (%rdi), %rax
testq %rax, %rax
je 0x15e82e
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x15e833
movq %r14, %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x17640
testl %eax, %eax
je 0x15e76d
leaq 0x22fb94(%rip), %rsi    # 0x38e2f5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
jmp 0x15e789
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x15e8b7
testl %eax, %eax
je 0x15e7b9
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
je 0x15e79a
xorl %r14d, %r14d
jmp 0x15e7ae
leaq 0x22faca(%rip), %rsi    # 0x38e26b
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x17420
testl %eax, %eax
je 0x15e7d3
leaq 0x22fb33(%rip), %rsi    # 0x38e304
jmp 0x15e761
movq (%rsp), %rdi
callq 0x30c15a
testb %al, %al
je 0x15e7ef
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30b995
jmp 0x15e829
movq (%rsp), %rdi
callq 0x309c55
testb %al, %al
je 0x15e80b
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x309469
jmp 0x15e829
movq (%rsp), %rdi
callq 0x30aef1
testb %al, %al
je 0x15e789
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30a706
movq %rax, %r14
jmp 0x15e7ae
callq 0x4ab12
callq 0x4aadb
// File: /workspace/github_c_makefile_star2_O1/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 0x15e84d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x15e870
movq %rbx, %rdi
callq 0x30c162
testl %eax, %eax
jne 0x15e861
movq %rbx, %rdi
callq 0x309c5d
testl %eax, %eax
je 0x15e867
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x30aef9
callq 0x4ab49
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x15ec21
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x22f8c0(%rip), %r14    # 0x38e3b8
movq %r14, %rsi
movl $0x86, %edx
callq 0x109670
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x87, %edx
callq 0x109670
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x88, %edx
callq 0x109670
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x89, %edx
callq 0x109670
movq 0xa0(%rbx), %rdi
movq %r14, %rsi
movl $0x8a, %edx
callq 0x109670
movq 0x20(%rbx), %rdi
callq 0xd97e0
movq 0x80(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x15eb8a
leaq 0x22f84d(%rip), %rsi    # 0x38e3b8
movl $0x8c, %edx
callq 0x109670
movq 0x80(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x80(%rbx), %rdi
leaq 0x22f820(%rip), %rsi    # 0x38e3b8
movl $0x8d, %edx
callq 0x109670
movq 0x88(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x15ebd7
leaq 0x22f800(%rip), %rsi    # 0x38e3b8
movl $0x8e, %edx
callq 0x109670
movq 0x88(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x88(%rbx), %rdi
leaq 0x22f7d3(%rip), %r14    # 0x38e3b8
movq %r14, %rsi
movl $0x8f, %edx
callq 0x109670
movq 0x90(%rbx), %rdi
callq 0xee90c
movq 0x98(%rbx), %rdi
callq 0x1f827b
movq %rbx, %rdi
movq %r14, %rsi
movl $0x92, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_flush
void gt_kmer_database_flush(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->sb.intervals->nextfreeGtRange ==
            kdb->sb.ids->nextfreeGtUword);

  if (kdb->sb.intervals->nextfreeGtRange != 0) {
    GtUword interval_idx;
    kdb->sb.kmer_count = 0;
    kdb->sb.offset = kdb->sb.intervals->spaceGtRange[0].start;

    for (interval_idx = 0;
         interval_idx < kdb->sb.intervals->nextfreeGtRange;
         interval_idx++) {
      GtUword startpos = kdb->sb.intervals->spaceGtRange[interval_idx].start,
              endpos = kdb->sb.intervals->spaceGtRange[interval_idx].end,
              id = kdb->sb.ids->spaceGtUword[interval_idx];
      const GtKmercode *kmercode = NULL;

      gt_kmercodeiterator_reset(kdb->sb.kmer_iter, GT_READMODE_FORWARD,
                                startpos);
      gt_assert(!gt_kmercodeiterator_inputexhausted(kdb->sb.kmer_iter));

      while ((kmercode =
              gt_kmercodeiterator_encseq_next(kdb->sb.kmer_iter)) != NULL &&
             startpos <= endpos - (kdb->sb.kmer_size - 1)) {
        if (!kmercode->definedspecialposition) {
          gt_kmer_database_add_kmer_to_sb(kdb, kmercode->code, startpos, id);
        }
        startpos++;
      }
    }
    gt_kmer_database_intervals_reset(kdb);
    gt_kmer_database_sort_sb(kdb);
    gt_kmer_database_merge(kdb);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x15ed6b
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq 0x88(%rdi), %rdx
movq 0x10(%rax), %rcx
cmpq 0x10(%rdx), %rcx
jne 0x15ed70
testq %rcx, %rcx
je 0x15ed5c
movq $0x0, 0xb0(%rbx)
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0xc0(%rbx)
movq 0x80(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x15ed23
xorl %r12d, %r12d
movq (%rax), %rax
movq %r12, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %r13
movq 0x88(%rbx), %rax
movq 0x98(%rbx), %rdi
movq (%rax), %rax
movq (%rax,%r12,8), %r15
xorl %esi, %esi
movq %r14, %rdx
callq 0x1f7b10
movq 0x98(%rbx), %rdi
callq 0x1f838f
testb %al, %al
jne 0x15ed66
movq 0x98(%rbx), %rdi
callq 0x1f7f9f
testq %rax, %rax
je 0x15ed0f
movl 0xd0(%rbx), %ecx
decl %ecx
movq %r13, %rdx
subq %rcx, %rdx
cmpq %rdx, %r14
ja 0x15ed0f
cmpb $0x0, (%rax)
jne 0x15ed0a
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x15ed75
incq %r14
jmp 0x15eccf
incq %r12
movq 0x80(%rbx), %rax
cmpq 0x10(%rax), %r12
jb 0x15ec89
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq 0x88(%rbx), %rax
movq %rcx, 0x10(%rax)
movq %rcx, 0xc8(%rbx)
movq 0xa0(%rbx), %rdi
movq 0xb0(%rbx), %rsi
callq 0x11534f
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x15edc6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4ac27
callq 0x4ac60
callq 0x4abee
// File: /workspace/github_c_makefile_star2_O1/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 0x15edbc
movq 0xb0(%rdi), %rax
cmpq 0xa8(%rdi), %rax
ja 0x15edc1
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
callq 0x4acd2
callq 0x4ac99
// File: /workspace/github_c_makefile_star2_O1/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 0x15f7d9
cmpq %rdx, 0x28(%rsi)
jbe 0x15f7de
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x15f7e3
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x15f7e8
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 0x15f7c0
cmpq 0x50(%rsi), %rax
jbe 0x15f7c0
cmpq 0x48(%rsi), %rax
ja 0x15f7cc
cmpb $0x1, 0x78(%rsi)
jne 0x15f7d4
cmpq 0x48(%rsi), %rax
jbe 0x15f7d4
movq $0x0, 0x10(%rdi)
movq %rdi, %rax
popq %rcx
retq
callq 0x4b09b
callq 0x4aff0
callq 0x4b062
callq 0x4b029
// File: /workspace/github_c_makefile_star2_O1/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 0x15f802
testq %rsi, %rsi
je 0x15f807
movq %rsi, 0x48(%rdi)
movb $0x1, 0x78(%rdi)
popq %rax
retq
callq 0x4b10d
callq 0x4b0d4
// File: /workspace/github_c_makefile_star2_O1/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 0x15f83c
testq %rsi, %rsi
je 0x15f841
testq %rdx, %rdx
je 0x15f846
movw $0x101, 0x78(%rdi)      # imm = 0x101
movq %rsi, 0x58(%rdi)
movq %rdx, 0x50(%rdi)
popq %rax
retq
callq 0x4b1f1
callq 0x4b1b8
callq 0x4b17f
// File: /workspace/github_c_makefile_star2_O1/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 0x15f8b9
movq 0x28(%rdi), %rax
movq 0x40(%rdi), %rcx
cmpq %rax, %rcx
ja 0x15f8be
testq %rcx, %rcx
je 0x15f8b5
movq 0x8(%rdi), %rdx
movq (%rdx,%rax,8), %rax
xorl %edx, %edx
divq %rcx
jmp 0x15f8b7
xorl %eax, %eax
popq %rcx
retq
callq 0x4b347
callq 0x4b30e
// File: /workspace/github_c_makefile_star2_O1/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 0x15f8eb
movq 0x60(%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rcx
cmpq (%rdx,%rcx,8), %rax
ja 0x15f8f0
movq (%rdi), %rdx
movq (%rdx,%rcx,8), %rcx
testq %rcx, %rcx
cmoveq %rcx, %rax
popq %rcx
retq
callq 0x4b3b9
callq 0x4b380
// File: /workspace/github_c_makefile_star2_O1/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 0x15fa7f
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x15fb6a
cmpq $0x0, 0x28(%r14)
je 0x15fb59
leaq 0x22ef13(%rip), %r12    # 0x38e9a4
xorl %ebp, %ebp
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x8(%rax,%rbp,8), %r15
movl $0x0, %eax
cmpq %r15, %r13
jbe 0x15fac7
movq %rbx, %rdi
leaq 0x22eea7(%rip), %rsi    # 0x38e959
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, %r13
seta %cl
leaq 0x1(%r13), %rdx
cmpq %r15, %rdx
setae %dl
orb %cl, %dl
jne 0x15fb43
addq $0x2, %r13
movq 0x10(%r14), %rdx
movq -0x10(%rdx,%r13,8), %rcx
movq -0x8(%rdx,%r13,8), %r8
cmpq %r8, %rcx
jb 0x15fb07
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x18(%r14), %rdx
movq -0x10(%rdx,%r13,8), %rcx
movq -0x8(%rdx,%r13,8), %r8
cmpq %r8, %rcx
jbe 0x15fb33
movq %rbx, %rdi
leaq 0x22eeec(%rip), %rsi    # 0x38ea10
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x15fb43
leaq 0x1(%r13), %rcx
cmpq %r15, %r13
movq %rcx, %r13
jb 0x15fadf
testl %eax, %eax
jne 0x15fb5b
incq %rbp
movq %r15, %r13
cmpq 0x28(%r14), %rbp
jb 0x15fa96
jmp 0x15fb5b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4b42b
// File: /workspace/github_c_makefile_star2_O1/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 0x15fb8c
movq 0x28(%rdi), %rax
movq 0x38(%rdi), %rcx
shlq $0x4, %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $0xf, %rax
retq
pushq %rax
callq 0x4b464
// File: /workspace/github_c_makefile_star2_O1/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 0x15fbaf
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
callq 0x4b49d
// File: /workspace/github_c_makefile_star2_O1/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 0x15fe01
movq %rsi, %rbx
testq %rsi, %rsi
je 0x15fe01
movq %rdi, %r14
movq %rbx, %rdi
callq 0x108f3c
testb %al, %al
je 0x15fd84
cmpb $0x0, 0xd4(%r14)
je 0x15fd8e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xb0(%r14), %rdx
testq %rdx, %rdx
je 0x15fddf
leaq 0x22ee12(%rip), %r15    # 0x38ebb3
xorl %r12d, %r12d
xorl %r13d, %r13d
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 0x10906e
incq %r13
movq 0xb0(%r14), %rdx
addq $0x10, %r12
cmpq %rdx, %r13
jb 0x15fda7
movb $0x1, 0xd4(%r14)
leaq 0x22edde(%rip), %rsi    # 0x38ebcc
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10906e
callq 0x4b50f
// File: /workspace/github_c_makefile_star2_O1/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 0x160fc5
movq %rsi, %r13
testq %rsi, %rsi
je 0x160fc5
movq %rdx, %r12
testq %rdx, %rdx
je 0x160fc5
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 0x126bf9
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 0x160748
callq 0x4b62c
// File: /workspace/github_c_makefile_star2_O1/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 0x161053
movq %rsi, %r13
testq %rsi, %rsi
je 0x161053
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 0x179740
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 0x160f56
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x1797c3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4b665
// File: /workspace/github_c_makefile_star2_O1/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 0x161519
movq %rsi, %r13
testq %rsi, %rsi
je 0x161519
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 0x179740
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 0x161058
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x1797c3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4b749
// File: /workspace/github_c_makefile_star2_O1/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 0x1609ee
xorl %eax, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x161ab8
movl $0x1, %eax
cmpq %rsi, %r8
je 0x161ab8
xorl %eax, %eax
cmpq %rdx, %rcx
setl %al
orl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x161aef
cmpl $0x1, %esi
jne 0x161b1e
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 0x161b26
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 0x161b26
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 0x161b56
movl $0x1, %eax
cmpq %rsi, %r8
je 0x161b56
xorl %eax, %eax
cmpq %rdi, %rdx
setg %al
orl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x162b56
movq %rsi, %r13
testq %rsi, %rsi
je 0x162b56
movq %rdx, %r12
testq %rdx, %rdx
je 0x162b56
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 0x126bf9
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 0x161b57
callq 0x4ba23
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute
GtUword gt_linearalign_affinegapcost_compute(GtLinspaceManagement *spacemanager,
                                             GtAlignment *align,
                                             const GtUchar *useq,
                                             GtUword ustart,
                                             GtUword ulen,
                                             const GtUchar *vseq,
                                             GtUword vstart,
                                             GtUword vlen,
                                             GtUword matchcost,
                                             GtUword mismatchcost,
                                             GtUword gap_opening,
                                             GtUword gap_extension)
{
  GtUword distance;
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchcost,
                                                     mismatchcost,
                                                     gap_opening,
                                                     gap_extension);

  gt_alignment_set_seqs(align,useq+ustart, ulen, vseq+vstart, vlen);
  distance = gt_linearalign_affinegapcost_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, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, (%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0x179740
movq %rax, %r13
leaq (%r12,%r15), %rsi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax), %rcx
movq %rbp, %rdi
movq %r14, %rdx
movq 0x48(%rsp), %r8
callq 0x126bf9
subq $0x8, %rsp
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq %rbx
callq 0x162ae7
addq $0x20, %rsp
movq %rax, %rbx
movq %r13, %rdi
callq 0x1797c3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute_local
GtWord gt_linearalign_affinegapcost_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 gap_opening,
                                             GtWord gap_extension)
{
  GtWord score;

  GtScoreHandler *scorehandler = gt_scorehandler_new(matchscore,
                                                     mismatchscore,
                                                     gap_opening,
                                                     gap_extension);

  score = gt_linearalign_affinegapcost_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
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rcx
callq 0x179740
movq %rax, %r14
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq %rbx, (%rsp)
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x20(%rsp), %r9
callq 0x162bf9
movq %rax, %rbx
movq %r14, %rdi
callq 0x1797c3
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: evaluateaffinecrosspoints_thread_caller
static void *evaluateaffinecrosspoints_thread_caller(void *data)
{
  GtAffineCrosspointthreadinfo *threadinfo =
                                         (GtAffineCrosspointthreadinfo *) data;
  (void) evaluateaffinecrosspoints(threadinfo->spacemanager,
                                   threadinfo->scorehandler,
                                   threadinfo->useq,
                                   threadinfo->ustart,
                                   threadinfo-> ulen,
                                   threadinfo->vseq,
                                   threadinfo->vstart,
                                   threadinfo->vlen,
                                   threadinfo->Ctab,
                                   threadinfo->rowoffset,
                                   threadinfo->from_edge,
                                   threadinfo->to_edge,
                                   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
movl 0x58(%rdi), %r10d
movl 0x5c(%rdi), %r11d
movq 0x50(%rdi), %rdi
movq %rdi, 0x30(%rsp)
movl %r11d, 0x28(%rsp)
movl %r10d, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0x161de1
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_delete
void gt_linspace_management_delete(GtLinspaceManagement *spacemanager)
{
  if (spacemanager != NULL)
  {
    gt_free(spacemanager->valueTabspace);
    gt_free(spacemanager->rTabspace);
    if (spacemanager->crosspointTabspace != NULL)
      gt_free(spacemanager->crosspointTabspace);
    gt_maxcoordvalue_delete(spacemanager->maxscoordvaluespace);
    gt_free(spacemanager);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x163999
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x22bbe7(%rip), %r14    # 0x38f524
movq %r14, %rsi
movl $0x3a, %edx
callq 0x109670
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x3b, %edx
callq 0x109670
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x163975
leaq 0x22bbb9(%rip), %rsi    # 0x38f524
movl $0x3d, %edx
callq 0x109670
movq 0x48(%rbx), %rdi
callq 0x168380
leaq 0x22bb9f(%rip), %rsi    # 0x38f524
movq %rbx, %rdi
movl $0x3f, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/linspace_management.c
// Function: checksquare
static bool checksquare(GtLinspaceManagement *spacemanager,
                        GtUword ulen, GtUword vlen,
                        size_t valuesize, size_t rsize,
                        bool local)
{
  GtUword TSfactor;
  gt_assert(spacemanager);

  TSfactor = spacemanager->timesquarefactor;
  if ((ulen+1)*(vlen+1)*valuesize <= spacemanager->valueTabsize)
  {
    if (local)
      gt_maxcoordvalue_reset(spacemanager->maxscoordvaluespace);
    return true;
  }
  else if ((ulen+1)*(vlen+1) <= (spacemanager->ulen+1)*TSfactor)
  {
    if (!local)
    {
      gt_linspace_management_check_generic(spacemanager,(ulen+1)*(vlen+1)-1,
                                           vlen,valuesize,rsize,0,false);
    }
    else
    {
       gt_linspace_management_check_generic(spacemanager,(ulen+1)*(vlen+1)-1,
                                            vlen,valuesize,rsize,0,true);
    }
    return true;
  }
  return false;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x163b74
movq %rsi, %rax
incq %rax
leaq 0x1(%rdx), %rsi
imulq %rax, %rsi
movq %rsi, %rax
imulq %rcx, %rax
cmpq 0x28(%rdi), %rax
jbe 0x163b38
movq 0x18(%rdi), %rax
incq %rax
imulq 0x20(%rdi), %rax
cmpq %rax, %rsi
jbe 0x163b4a
xorl %ebx, %ebx
jmp 0x163b6c
movb $0x1, %bl
testb %r9b, %r9b
je 0x163b6c
movq 0x48(%rdi), %rdi
callq 0x1684a6
jmp 0x163b6c
decq %rsi
testb %r9b, %r9b
je 0x163b5b
movl $0x1, (%rsp)
jmp 0x163b62
movl $0x0, (%rsp)
xorl %r9d, %r9d
callq 0x1639cc
movb $0x1, %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x4bc9f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_change_to_square
GtUword **gt_linspace_management_change_to_square(GtLinspaceManagement
                                                 *spacemanager,
                                                 GtUword ulen, GtUword vlen)
{
  GtUword **E;
  GtUword idx;
  gt_assert(gt_linspace_management_check_space(spacemanager, ulen, vlen));

  E = gt_linspace_management_get_rTabspace(spacemanager);
  *E = gt_linspace_management_get_valueTabspace(spacemanager);

  for (idx=1;idx<ulen+1;idx++)
    E[idx]=E[idx-1]+vlen+1;

  return E;
}

// Assembly:
pushq %rax
leaq 0x1(%rdx), %rax
leaq 0x8(,%rsi,8), %rcx
imulq %rax, %rcx
cmpq 0x28(%rdi), %rcx
ja 0x163c36
testq %rdi, %rdi
je 0x163bf9
movq 0x8(%rdi), %rax
jmp 0x163bfb
xorl %eax, %eax
testq %rdi, %rdi
je 0x163c05
movq (%rdi), %rcx
jmp 0x163c07
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq -0x1(%rsi), %rcx
cmpq $-0x3, %rcx
ja 0x163c34
leaq 0x8(,%rdx,8), %rcx
movq (%rax), %rdx
addq %rcx, %rdx
xorl %edi, %edi
movq %rdx, 0x8(%rax,%rdi,8)
addq %rcx, %rdx
incq %rdi
cmpq %rdi, %rsi
jne 0x163c24
popq %rcx
retq
callq 0x4bd4a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_class
const GtNodeStreamClass* gt_load_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtLoadStream),
                                   gt_load_stream_free,
                                   gt_load_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x365b2e(%rip)    # 0x4c9788
jne 0x163c7b
leaq 0x26(%rip), %rsi        # 0x163c89
leaq 0x81(%rip), %rdx        # 0x163ceb
movl $0x30, %edi
callq 0x16abb4
movq %rax, 0x365b0d(%rip)    # 0x4c9788
callq 0xe6a19
movq 0x365b01(%rip), %rax    # 0x4c9788
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_free
static void gt_load_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtLoadStream *load_stream = gt_load_stream_cast(ns);
  for (i = load_stream->idx; i < gt_array_size(load_stream->nodes); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                          gt_array_get(load_stream->nodes, i));
  }
  gt_array_delete(load_stream->nodes);
  gt_node_stream_delete(load_stream->in_stream);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x163c4c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x18(%rax), %r14
movq 0x20(%rax), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jae 0x163cd2
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x14c43a
incq %r14
movq 0x20(%rbx), %rdi
jmp 0x163cab
movq 0x20(%rbx), %rdi
callq 0xd4ef4
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16ac6e