LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/cutendpfx.c
// Function: gt_nextbucketenumerator
bool gt_nextbucketenumerator(Lcpinterval *itv,
                             Bucketenumerator *bucketenumerator)
{
  while (true)
  {
    if (bucketenumerator->currentcode > bucketenumerator->lastcode)
    {
      break;
    }
    gt_bcktab_calcboundaries(&bucketenumerator->bucketspec,
                             bucketenumerator->bcktab,
                             bucketenumerator->currentcode);
    bucketenumerator->currentcode++;
    if (bucketenumerator->bucketspec.nonspecialsinbucket > 0)
    {
      itv->left = bucketenumerator->bucketspec.left;
      itv->right = itv->left +
                   bucketenumerator->bucketspec.nonspecialsinbucket - 1;
      itv->offset = (GtUword) bucketenumerator->demandprefixlength;
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsi), %r12
movq 0x28(%rsi), %rax
movq %rax, %r15
movq 0x30(%r14), %r13
cmpq %r13, %rax
ja 0x138274
movq (%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x135534
movq 0x28(%r14), %rax
incq %rax
movq %rax, 0x28(%r14)
cmpq $0x0, 0x18(%r14)
je 0x13822b
movq 0x10(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%r14), %rcx
addq %rcx, %rax
decq %rax
movq %rax, 0x10(%rbx)
movl 0xc(%r14), %eax
movq %rax, (%rbx)
cmpq %r13, %r15
setbe %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_weight_range
void gt_spaced_seed_weight_range(int *min_weight,int *max_weight, int span)
{
  const int size_table = sizeof gt_spaced_seed_spec_tab/
                         sizeof gt_spaced_seed_spec_tab[0];
  const int num_spans = sizeof gt_spaced_seed_span_start_tab/
                        sizeof gt_spaced_seed_span_start_tab[0];
  int span_offset, end_of_span;

  gt_assert(GT_SPACED_SEED_FIRST_SPAN <= span &&
            span - GT_SPACED_SEED_FIRST_SPAN <= num_spans - 1);
  *min_weight
    = gt_spaced_seed_first_weight_tab[span - GT_SPACED_SEED_FIRST_SPAN];
  if (span - GT_SPACED_SEED_FIRST_SPAN == num_spans - 1)
  {
    end_of_span = size_table;
  } else
  {
    end_of_span
      = gt_spaced_seed_span_start_tab[span + 1 - GT_SPACED_SEED_FIRST_SPAN];
  }
  span_offset = gt_spaced_seed_span_start_tab[span - GT_SPACED_SEED_FIRST_SPAN];
  *max_weight = *min_weight + end_of_span - span_offset - 1;
}

// Assembly:
leal -0xf(%rdx), %r8d
cmpl $0x12, %r8d
jae 0x1382fb
movl %r8d, %eax
leaq 0x207475(%rip), %rcx    # 0x33f740
movl (%rcx,%rax,4), %ecx
movl %ecx, (%rdi)
movl $0xc5, %edi
cmpl $0x11, %r8d
je 0x1382e8
addl $-0xe, %edx
leaq 0x2074ab(%rip), %rdi    # 0x33f790
movl (%rdi,%rdx,4), %edi
leaq 0x2074a1(%rip), %rdx    # 0x33f790
movl (%rdx,%rax,4), %eax
addl %ecx, %edi
notl %eax
addl %edi, %eax
movl %eax, (%rsi)
retq
pushq %rax
movq 0x2ffc65(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1acd06(%rip), %rsi    # 0x2e5013
leaq 0x2071b5(%rip), %rdx    # 0x33f4c9
leaq 0x207205(%rip), %rcx    # 0x33f520
leaq 0x20721a(%rip), %r8     # 0x33f53c
movl $0x10b, %r9d            # imm = 0x10B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_spec_new_from_ws
GtSpacedSeedSpec *gt_spaced_seed_spec_new_from_ws(int weight,int span)
{
  int min_weight, max_weight, seed_num;;

  gt_spaced_seed_weight_range(&min_weight,&max_weight, span);
  gt_assert(min_weight <= weight && weight <= max_weight);
  seed_num = gt_spaced_seed_tab_num_extract(weight,span);
  return gt_spaced_seed_spec_new(gt_spaced_seed_spec_tab[seed_num]);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x1382b7
cmpl %ebp, (%r14)
jg 0x138657
cmpl %ebp, 0x8(%rsp)
jl 0x138657
cmpl $0xe, %ebx
jle 0x138685
addl $-0xf, %ebx
leaq 0x207117(%rip), %rax    # 0x33f740
subl (%rax,%rbx,4), %ebp
jl 0x1386b3
leaq 0x207157(%rip), %rax    # 0x33f790
addl (%rax,%rbx,4), %ebp
movslq %ebp, %rax
leaq 0x20719a(%rip), %rcx    # 0x33f7e0
movq (%rcx,%rax,8), %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x138334
movq 0x2ff90a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ac9ab(%rip), %rsi    # 0x2e5013
leaq 0x206fee(%rip), %rdx    # 0x33f65d
leaq 0x207014(%rip), %rcx    # 0x33f68a
leaq 0x206ebf(%rip), %r8     # 0x33f53c
movl $0x173, %r9d            # imm = 0x173
jmp 0x1386df
movq 0x2ff8dc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ac97d(%rip), %rsi    # 0x2e5013
leaq 0x20703e(%rip), %rdx    # 0x33f6db
leaq 0x207059(%rip), %rcx    # 0x33f6fd
leaq 0x206e91(%rip), %r8     # 0x33f53c
movl $0x166, %r9d            # imm = 0x166
jmp 0x1386df
movq 0x2ff8ae(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ac94f(%rip), %rsi    # 0x2e5013
leaq 0x207051(%rip), %rdx    # 0x33f71c
leaq 0x20702b(%rip), %rcx    # 0x33f6fd
leaq 0x206e63(%rip), %r8     # 0x33f53c
movl $0x16a, %r9d            # imm = 0x16A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_extract_generic
GtCodetype gt_spaced_seed_extract_generic(const GtSpacedSeedSpec *seed_spec,
                                          GtCodetype kmer)
{
  GtCodetype ext = 0;
  const GtSpacedSeedSpecValue *seed_spec_ptr;

  gt_assert(seed_spec != NULL);
  for (seed_spec_ptr = seed_spec->spec_tab;
       seed_spec_ptr < seed_spec->spec_tab + seed_spec->num_specs;
       seed_spec_ptr++)
  {
    ext |= ((kmer & seed_spec_ptr->extract) >> seed_spec_ptr->shiftright);
  }
  return ext;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x13871d
movq (%rdi), %rdx
movq 0x8(%rdi), %rdi
shlq $0x4, %rdi
addq %rdx, %rdi
xorl %eax, %eax
cmpq %rdi, %rdx
jae 0x13871b
movq (%rdx), %r8
andq %rsi, %r8
movb 0x8(%rdx), %cl
shrq %cl, %r8
orq %r8, %rax
addq $0x10, %rdx
jmp 0x138701
popq %rcx
retq
movq 0x2ff844(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ac8e5(%rip), %rsi    # 0x2e5013
leaq 0x206f75(%rip), %rdx    # 0x33f6aa
leaq 0x206f80(%rip), %rcx    # 0x33f6bc
leaq 0x206df9(%rip), %r8     # 0x33f53c
movl $0x17e, %r9d            # imm = 0x17E
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_base_list_get
GtDiagbandseedBaseListType gt_diagbandseed_base_list_get(
                                   bool with_splt,
                                   const char *base_list_string,GtError *err)
{
  size_t idx;
  for (idx = 0; idx < sizeof gt_base_list_arguments/
                      sizeof gt_base_list_arguments[0]; idx++)
  {
    if (strcmp(base_list_string,gt_base_list_arguments[idx]) == 0)
    {
      return (GtDiagbandseedBaseListType) idx;
    }
  }
  gt_error_set(err,"illegal parameter for option -%s: %s",
                    with_splt ? "splt" : "kmplt",
                    with_splt ? gt_diagbandseed_splt_comment()
                              : gt_diagbandseed_kmplt_comment());
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
leaq 0x2fac3b(%rip), %r12    # 0x4336b0
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x138a97
movq (%r12), %rsi
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x138ad3
incq %r14
addq $0x8, %r12
jmp 0x138a78
leaq 0x1bda9f(%rip), %rax    # 0x2f653d
leaq 0x1bda9d(%rip), %rdx    # 0x2f6542
testb %bpl, %bpl
cmovneq %rax, %rdx
leaq 0x207459(%rip), %rax    # 0x33ff0c
leaq 0x20749e(%rip), %rcx    # 0x33ff58
cmovneq %rax, %rcx
leaq 0x2074d1(%rip), %rsi    # 0x33ff96
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %r14
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_kmer_filename
static char *gt_diagbandseed_kmer_filename(const GtEncseq *encseq,
                                           unsigned int spacedseedweight,
                                           unsigned int seedlength,
                                           bool forward,
                                           unsigned int numparts,
                                           unsigned int partindex,
                                           GtDiagbandseedBaseListType kmplt)
{
  char *filename;
  GtStr *str = gt_str_new_cstr(gt_encseq_indexname(encseq));
  if (spacedseedweight < seedlength)
  {
    gt_str_append_char(str, '.');
    gt_str_append_uint(str, spacedseedweight);
  }
  gt_str_append_char(str, '.');
  gt_str_append_uint(str, seedlength);
  gt_str_append_char(str, forward ? 'f' : 'r');
  gt_str_append_uint(str, numparts);
  gt_str_append_char(str, '-');
  gt_str_append_uint(str, partindex + 1);
  if (kmplt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
  {
    gt_str_append_char(str, 'U');
  } else
  {
    gt_assert(kmplt == GT_DIAGBANDSEED_BASE_LIST_STRUCT);
  }
  gt_str_append_cstr(str, ".kmer");
  filename = gt_cstr_dup(gt_str_get(str));
  gt_str_delete(str);
  return filename;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
callq 0x71dd6
movq %rax, %rdi
callq 0xacbd1
movq %rax, %rbx
cmpl %r12d, %r13d
jae 0x139e55
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0xaced9
movq %rbx, %rdi
movl %r13d, %esi
callq 0xad151
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0xaced9
movq %rbx, %rdi
movl %r12d, %esi
callq 0xad151
testb %r15b, %r15b
pushq $0x66
popq %rax
pushq $0x72
popq %rsi
cmovnel %eax, %esi
movq %rbx, %rdi
callq 0xaced9
movq %rbx, %rdi
movl %r14d, %esi
callq 0xad151
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0xaced9
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xad151
movl 0x40(%rsp), %eax
testl %eax, %eax
je 0x139eb9
cmpl $0x1, %eax
jne 0x139ef5
pushq $0x55
popq %rsi
movq %rbx, %rdi
callq 0xaced9
leaq 0x2062b7(%rip), %rsi    # 0x340177
movq %rbx, %rdi
callq 0xacbfb
movq %rbx, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x6c2be
movq %rax, %r14
movq %rbx, %rdi
callq 0xae103
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2fe06c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ab10d(%rip), %rsi    # 0x2e5013
leaq 0x206222(%rip), %rdx    # 0x34012f
leaq 0x206245(%rip), %rcx    # 0x340159
leaq 0x205fa1(%rip), %r8     # 0x33febc
movl $0xf92, %r9d            # imm = 0xF92
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_create_or_update_file
static bool gt_create_or_update_file(const char *path,const GtEncseq *encseq)
{
  if (gt_file_exists(path))
  {
    GtStr *esqfile = gt_str_new_cstr(gt_encseq_indexname(encseq));

    gt_str_append_cstr(esqfile, ".esq");
    if (gt_file_is_newer(path,gt_str_get(esqfile)))
    {
      gt_str_delete(esqfile);
      return false;
    }
    gt_str_delete(esqfile);
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8da98
movb $0x1, %bpl
testb %al, %al
je 0x139f86
movq %r14, %rdi
callq 0x71dd6
movq %rax, %rdi
callq 0xacbd1
movq %rax, %r14
leaq 0x1acabe(%rip), %rsi    # 0x2e6a1b
movq %rax, %rdi
callq 0xacbfb
movq %r14, %rdi
callq 0xad1fa
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8db7c
movl %eax, %ebp
movq %r14, %rdi
callq 0xae103
xorb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_write_kmers
static int gt_diagbandseed_write_kmers(const GtKmerPosList *kmerpos_list,
                                       const char *path,
                                       unsigned int spacedseedweight,
                                       unsigned int seedlength,
                                       bool verbose,
                                       GtError *err)
{
  FILE *stream;
  GtUword longest_code_run;

  if (verbose) {
    gt_assert(kmerpos_list != NULL);
    printf("# write " GT_WU " %u-mers ",kmerpos_list->nextfree, seedlength);
    if (spacedseedweight < seedlength)
    {
      printf("with weight %u ",spacedseedweight);
    }
    printf("to file %s\n",path);
  }

  stream = gt_fa_fopen(path, "wb", err);
  if (stream == NULL)
  {
    return -1;
  }
  gt_xfwrite(&kmerpos_list->longest_code_run,sizeof longest_code_run,1,stream);
  if (kmerpos_list->encode_info != NULL)
  {
    gt_xfwrite(kmerpos_list->spaceGtUword,
               sizeof *kmerpos_list->spaceGtUword,
               kmerpos_list->nextfree, stream);
  } else
  {
    gt_xfwrite(kmerpos_list->spaceGtDiagbandseedKmerPos,
               sizeof *kmerpos_list->spaceGtDiagbandseedKmerPos,
               kmerpos_list->nextfree, stream);
  }
  gt_fa_fclose(stream);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movq %rsi, %r15
movq %rdi, %rbx
testl %r8d, %r8d
je 0x13a6fc
testq %rbx, %rbx
je 0x13a773
movl %ecx, %r12d
movl %edx, %ebp
movq 0x18(%rbx), %rsi
leaq 0x205ec4(%rip), %rdi    # 0x340591
movl %ecx, %edx
xorl %eax, %eax
callq 0x17070
cmpl %r12d, %ebp
jae 0x13a6eb
leaq 0x205ec4(%rip), %rdi    # 0x3405a6
movl %ebp, %esi
xorl %eax, %eax
callq 0x17070
leaq 0x205ec4(%rip), %rdi    # 0x3405b6
movq %r15, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1bb3ee(%rip), %rsi    # 0x2f5af1
leaq 0x2057b2(%rip), %rdx    # 0x33febc
movq %r15, %rdi
movl $0x1209, %ecx           # imm = 0x1209
movq %r14, %r8
callq 0x8a156
testq %rax, %rax
je 0x13a767
movq %rax, %r14
leaq 0x20(%rbx), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rcx
callq 0xb302c
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x0, 0x28(%rbx)
setne %al
sete %cl
leaq 0x8(,%rcx,8), %rsi
movq (%rbx,%rax,8), %rdi
movq 0x18(%rbx), %rdx
movq %r14, %rcx
callq 0xb302c
movq %r14, %rdi
callq 0x8a4fd
xorl %eax, %eax
jmp 0x13a76a
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2fd7ee(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1aa88f(%rip), %rsi    # 0x2e5013
leaq 0x205c48(%rip), %rdx    # 0x3403d3
leaq 0x205de3(%rip), %rcx    # 0x340575
leaq 0x205723(%rip), %r8     # 0x33febc
movl $0x1200, %r9d           # imm = 0x1200
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_kmerpos_list_delete
static void gt_kmerpos_list_delete(GtKmerPosList *kmerpos_list)
{
  if (kmerpos_list != NULL)
  {
    gt_free(kmerpos_list->spaceGtDiagbandseedKmerPos);
    gt_free(kmerpos_list->spaceGtUword);
    gt_free(kmerpos_list);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x13a7f6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x2056fb(%rip), %r14    # 0x33febc
movq %r14, %rsi
movl $0x1ae, %edx            # imm = 0x1AE
callq 0x936f9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x1af, %edx            # imm = 0x1AF
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1b0, %edx            # imm = 0x1B0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_thread_info_set
static void gt_diagbandseed_thread_info_set(GtDiagbandseedThreadInfo *ti,
                                     const GtDiagbandseedInfo *arg,
                                     const GtKmerPosList *alist,
                                     FILE *stream,
                                     const GtEncseq *aencseq,
                                     const GtSequencePartsInfo *aseqranges,
                                     const GtEncseq *bencseq,
                                     const GtSequencePartsInfo *bseqranges,
                                     const GtKarlinAltschulStat
                                       *karlin_altschul_stat,
                                     GtArray *combinations,
                                     GtError *err)
{
  gt_assert(ti != NULL);
  ti->arg = arg;
  ti->alist = alist;
  ti->stream = stream;
  ti->aencseq = aencseq;
  ti->aseqranges = aseqranges;
  ti->bencseq = bencseq;
  ti->bseqranges = bseqranges;
  ti->karlin_altschul_stat = karlin_altschul_stat;
  ti->combinations = gt_array_clone(combinations);
  ti->had_err = 0;
  ti->err = err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13bec9
movq %rdi, %rbx
movq 0x40(%rsp), %r14
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %r10
movq 0x20(%rsp), %r11
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movq %r8, 0x18(%rbx)
movq %r9, 0x28(%rbx)
movq %r11, 0x20(%rbx)
movq %r10, 0x30(%rbx)
movq %rax, 0x58(%rbx)
callq 0x580f6
movq %rax, 0x40(%rbx)
andl $0x0, 0x48(%rbx)
movq %r14, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2fc098(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a9139(%rip), %rsi    # 0x2e5013
leaq 0x205d90(%rip), %rdx    # 0x341c71
leaq 0x205d94(%rip), %rcx    # 0x341c7c
leaq 0x203fcd(%rip), %r8     # 0x33febc
movl $0x11c9, %r9d           # imm = 0x11C9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_thread_algorithm
static void *gt_diagbandseed_thread_algorithm(void *thread_info)
{
  GtDiagbandseedThreadInfo *info = (GtDiagbandseedThreadInfo *)thread_info;
  if (gt_array_size(info->combinations) > 0) {
    const GtUwordPair *last = gt_array_get_last(info->combinations),
                      *comb;

    for (comb = gt_array_get_first(info->combinations); comb <= last; comb++) {
      info->had_err = gt_diagbandseed_algorithm(
                           info->arg,
                           info->alist,
                           info->stream,
                           info->aencseq,
                           info->aseqranges,
                           comb->a,
                           info->bencseq,
                           info->bseqranges,
                           comb->b,
                           info->karlin_altschul_stat,
                           NULL,
                           NULL,
                           info->err);
      if (info->had_err) break;
    }
  }
  gt_array_delete(info->combinations);
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x586a4
testq %rax, %rax
je 0x13bf96
movq 0x40(%rbx), %rdi
callq 0x581ff
movq %rax, %r14
movq 0x40(%rbx), %rdi
callq 0x581f8
movq %rax, %r15
cmpq %r14, %r15
ja 0x13bf96
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
movq 0x28(%rbx), %r8
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %r10
movq (%r15), %r9
movq 0x8(%r15), %r11
movq 0x58(%rbx), %r12
movq 0x50(%rbx), %r13
movq %r13, 0x30(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movq %r12, 0x18(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x8(%rsp)
movq %rax, (%rsp)
callq 0x13a80e
movl %eax, 0x48(%rbx)
addq $0x10, %r15
testl %eax, %eax
je 0x13bf37
movq 0x40(%rbx), %rdi
callq 0x58eb9
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_out_sequences_with_matches
static void gt_diagbandseed_out_sequences_with_matches(
                char seqtype,
                const GtEncseq *encseq,
                const GtBittab *used_sequences)
{
  GtUword seqnum, idx, numbits, max_seq_length;
  char *string_buffer;

  gt_assert(encseq != NULL && used_sequences != NULL);
  numbits = gt_bittab_count_set_bits(used_sequences);
  max_seq_length = gt_encseq_max_seq_length(encseq);
  string_buffer = gt_malloc(sizeof *string_buffer * max_seq_length);
  for (idx = 0, seqnum = gt_bittab_get_first_bitnum(used_sequences);
       idx < numbits;
       idx++, seqnum = gt_bittab_get_next_bitnum(used_sequences,seqnum))
  {
    const GtUword seqstartpos = gt_encseq_seqstartpos(encseq,seqnum),
                  seqlength = gt_encseq_seqlength(encseq,seqnum);
    gt_encseq_extract_decoded(encseq,string_buffer,seqstartpos,
                              seqstartpos + seqlength - 1);
    printf("S\t%c" GT_WU "\t" GT_WU "\t",seqtype,seqnum,seqlength);
    fwrite(string_buffer,sizeof *string_buffer,seqlength,stdout);
    fputc('\n',stdout);
  }
  gt_free(string_buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x13c0d1
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq %rdx, %rdi
callq 0x5eb04
movq %rax, %r15
movq %r14, 0x10(%rsp)
movq %r14, %rdi
callq 0x755c5
leaq 0x203ecf(%rip), %rsi    # 0x33febc
movq %rax, %rdi
movl $0x123a, %edx           # imm = 0x123A
callq 0x93160
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x5e9af
movq %rax, %r13
movzbl %bpl, %eax
movl %eax, 0x4(%rsp)
subq $0x1, %r15
jb 0x13c0ad
movq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x74d9c
movq %rbx, %r12
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0x75173
movq %rax, %rbp
leaq (%rbx,%rax), %rcx
decq %rcx
movq %r14, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rbx
callq 0x7239d
leaq 0x205ee7(%rip), %rdi    # 0x341f4b
movl 0x4(%rsp), %esi
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x17070
movq 0x2fbe34(%rip), %r12    # 0x437eb0
movq (%r12), %rcx
movq %r14, %rdi
pushq $0x1
popq %rsi
movq %rbp, %rdx
callq 0x17f00
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x17930
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5ea61
movq %rax, %r13
jmp 0x13c012
leaq 0x203e08(%rip), %rsi    # 0x33febc
movq 0x8(%rsp), %rdi
movl $0x1247, %edx           # imm = 0x1247
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x936f9
movq 0x2fbe90(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a8f31(%rip), %rsi    # 0x2e5013
leaq 0x205e0e(%rip), %rdx    # 0x341ef7
leaq 0x205e30(%rip), %rcx    # 0x341f20
leaq 0x203dc5(%rip), %r8     # 0x33febc
movl $0x1237, %r9d           # imm = 0x1237
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_update_separatorpos
static GtUword gt_diagbandseed_update_separatorpos(GtRange *specialrange,
                                                   GtSpecialrangeiterator *sri,
                                                   const GtEncseq *encseq,
                                                   GtUword totallength,
                                                   GtReadmode readmode)
{
  gt_assert(sri != NULL && specialrange != NULL && encseq != NULL);
  do {
    GtUword idx;
    for (idx = specialrange->start; idx < specialrange->end; idx++) {
      if (gt_encseq_position_is_separator(encseq, idx, readmode)) {
        specialrange->start = idx + 1;
        return idx;
      }
    }
  } while (gt_specialrangeiterator_next(sri, specialrange));
  return totallength;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13c17d
movq %rsi, %r12
testq %rsi, %rsi
je 0x13c17d
movq %rdx, %r14
testq %rdx, %rdx
je 0x13c17d
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdi, %r15
movq (%r15), %r13
cmpq 0x8(%r15), %r13
jae 0x13c151
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x70e8f
incq %r13
testb %al, %al
je 0x13c135
jmp 0x13c162
movq %r12, %rdi
movq %r15, %rsi
callq 0x7428b
testb %al, %al
jne 0x13c132
jmp 0x13c16b
movq %r13, (%r15)
decq %r13
movq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2fbde4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a8e85(%rip), %rsi    # 0x2e5013
leaq 0x2040f6(%rip), %rdx    # 0x34028b
leaq 0x204125(%rip), %rcx    # 0x3402c1
leaq 0x203d19(%rip), %r8     # 0x33febc
movl $0x240, %r9d            # imm = 0x240
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_kmerpos_entry_decode
static void gt_kmerpos_entry_decode(GtDiagbandseedKmerPos *dec,
                      const GtKmerPosListEncodeInfo *encode_info,
                      GtUword value)
{
  gt_assert(dec != NULL && encode_info != NULL);
  dec->code = gt_kmerpos_entry_code(encode_info,value);
  dec->seqnum = encode_info->first_seqnum +
                ((value >> encode_info->shift_seqnum) &
                encode_info->mask_seqnum);
  dec->endpos = (value >> encode_info->shift_endpos) & encode_info->mask_endpos;
}

// Assembly:
testq %rdi, %rdi
je 0x13e13f
testq %rsi, %rsi
je 0x13e13f
movb 0x20(%rsi), %cl
movq %rdx, %rax
shrq %cl, %rax
movq %rax, (%rdi)
movb 0x24(%rsi), %cl
movq %rdx, %rax
shrq %cl, %rax
andl 0x10(%rsi), %eax
addl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movb 0x28(%rsi), %cl
shrq %cl, %rdx
andl 0x18(%rsi), %edx
movl %edx, 0xc(%rdi)
retq
pushq %rax
movq 0x2f9e21(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a6ec2(%rip), %rsi    # 0x2e5013
leaq 0x202351(%rip), %rdx    # 0x3404a9
leaq 0x20236d(%rip), %rcx    # 0x3404cc
leaq 0x201d56(%rip), %r8     # 0x33febc
movl $0x1bf, %r9d            # imm = 0x1BF
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_segment_reject_check
static bool gt_segment_reject_check(const GtSegmentRejectInfo
                                      *segment_reject_info,
                                       GtUword bseqnum)
{
  const GtUword idx = bseqnum - segment_reject_info->b_firstseq;

  gt_assert(bseqnum >= segment_reject_info->b_firstseq &&
            idx < segment_reject_info->b_numsequences);
  return GT_ISIBITSET(segment_reject_info->b_bitsequence,idx) ? true : false;
}

// Assembly:
subq (%rdi), %rsi
jb 0x13e19c
cmpq 0x8(%rdi), %rsi
jae 0x13e19c
movq 0x10(%rdi), %rax
movq %rsi, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movl %esi, %ecx
shlq %cl, %rax
shrq $0x3f, %rax
retq
pushq %rax
movq 0x2f9dc4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a6e65(%rip), %rsi    # 0x2e5013
leaq 0x2024a9(%rip), %rdx    # 0x34065e
leaq 0x2024fa(%rip), %rcx    # 0x3406b6
leaq 0x201cf9(%rip), %r8     # 0x33febc
movl $0xed, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_numof_kmerpos_in_file
static GtUword gt_numof_kmerpos_in_file(const char *filename,
                                        GtDiagbandseedBaseListType kmplt)
{
  off_t file_size = gt_file_size(filename);
  size_t base_type_size = kmplt == GT_DIAGBANDSEED_BASE_LIST_STRUCT
                            ? sizeof (GtDiagbandseedKmerPos)
                            : sizeof (GtUword);

  gt_assert(file_size >= sizeof (GtLongestCodeRunType) &&
            (file_size - sizeof (GtLongestCodeRunType)) % base_type_size == 0);
  return (GtUword) ((file_size - sizeof (GtLongestCodeRunType))/base_type_size);
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x8e0a6
cmpq $0x8, %rax
jb 0x13e206
xorl %ecx, %ecx
testl %ebx, %ebx
sete %cl
addq $-0x8, %rax
leal 0x7(,%rcx,8), %ecx
testl %ecx, %eax
jne 0x13e206
xorl %ecx, %ecx
cmpl $0x1, %ebx
adcb $0x3, %cl
shrq %cl, %rax
popq %rbx
retq
movq 0x2f9d5b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a6dfc(%rip), %rsi    # 0x2e5013
leaq 0x2024de(%rip), %rdx    # 0x3406fc
leaq 0x202547(%rip), %rcx    # 0x34076c
leaq 0x201c90(%rip), %r8     # 0x33febc
movl $0xfa3, %r9d            # imm = 0xFA3
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_kmer_iter_new_file
static GtDiagbandseedKmerIterator *gt_diagbandseed_kmer_iter_new_file(FILE *fp,
                                   const GtKmerPosListEncodeInfo *encode_info)
{
  GtDiagbandseedKmerIterator *ki = gt_malloc(sizeof *ki);
  GtLongestCodeRunType longest_code_run;

  ki->original = NULL;
  ki->listend_uword = ki->listptr_uword = NULL;
  gt_assert(fp != NULL);
  gt_xfread(&longest_code_run,sizeof longest_code_run,1,fp);
  if (encode_info != NULL)
  {
    ki->kmerstream_uword.fp = fp;
    ki->kmerstream_uword.bufferedfilespace
      = gt_malloc(GT_FILEBUFFERSIZE *
                  sizeof *ki->kmerstream_uword.bufferedfilespace);
    ki->section.spaceGtUword = NULL;
    ki->section.allocated = longest_code_run;
  } else
  {
    ki->kmerstream_struct.fp = fp;
    ki->kmerstream_struct.bufferedfilespace
      = gt_malloc(GT_FILEBUFFERSIZE *
                  sizeof *ki->kmerstream_struct.bufferedfilespace);
    ki->section.allocated = longest_code_run + 1; /* one larger for reading
                                                     first of next run */
  }
  ki->section.spaceGtDiagbandseedKmerPos
    = gt_malloc(sizeof *ki->section.spaceGtDiagbandseedKmerPos *
                ki->section.allocated);
  ki->listptr_struct = ki->section.spaceGtDiagbandseedKmerPos;
  ki->listend_struct = ki->section.spaceGtDiagbandseedKmerPos +
                       ki->section.allocated;
  ki->section.encode_info = encode_info;
  gt_diagbandseed_kmer_iter_reset(ki);
  return ki;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x201c68(%rip), %rsi    # 0x33febc
movl $0x98, %edi
movl $0x41a, %edx            # imm = 0x41A
callq 0x93160
movq %rax, %r14
andq $0x0, 0x38(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0xb2fab
testq %rbx, %rbx
je 0x13e2ba
movq %r15, 0x88(%r14)
leaq 0x201c24(%rip), %rsi    # 0x33febc
movl $0x8000, %edi           # imm = 0x8000
movl $0x426, %edx            # imm = 0x426
callq 0x93160
movq %rax, 0x80(%r14)
andq $0x0, 0x8(%r14)
movq 0x8(%rsp), %rdi
jmp 0x13e2e0
movq %r15, 0x70(%r14)
leaq 0x201bf7(%rip), %rsi    # 0x33febc
movl $0x10000, %edi          # imm = 0x10000
movl $0x42e, %edx            # imm = 0x42E
callq 0x93160
movq %rax, 0x68(%r14)
movq 0x8(%rsp), %rdi
incq %rdi
movq %rdi, 0x10(%r14)
shlq $0x4, %rdi
leaq 0x201bcd(%rip), %rsi    # 0x33febc
movl $0x434, %edx            # imm = 0x434
callq 0x93160
movq %rax, (%r14)
movq %rax, 0x48(%r14)
movq 0x10(%r14), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x40(%r14)
movq %rbx, 0x28(%r14)
movq %r14, %rdi
callq 0x13e92b
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_kmer_iter_new_list
static GtDiagbandseedKmerIterator *gt_diagbandseed_kmer_iter_new_list(
                               const GtKmerPosList *original)
{
  GtDiagbandseedKmerIterator *ki = gt_malloc(sizeof *ki);

  gt_assert(original != NULL);
  ki->original = original;
  if (original->encode_info != NULL)
  {
    gt_assert(original->spaceGtUword != NULL);
    ki->listend_uword = original->spaceGtUword + original->nextfree;
    ki->section.spaceGtDiagbandseedKmerPos
      = gt_malloc(sizeof *ki->section.spaceGtDiagbandseedKmerPos
                  * original->longest_code_run);
    ki->listend_struct = ki->section.spaceGtDiagbandseedKmerPos +
                         original->longest_code_run;
  } else
  {
    gt_assert(original->spaceGtDiagbandseedKmerPos != NULL);
    ki->listend_uword = NULL;
    ki->listend_struct = original->spaceGtDiagbandseedKmerPos +
                         original->nextfree;
  }
  ki->section.encode_info = original->encode_info;
  gt_diagbandseed_kmer_iter_reset(ki);
  return ki;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x201b86(%rip), %rsi    # 0x33febc
movl $0x98, %edi
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x93160
testq %r14, %r14
je 0x13e3df
movq %rax, %rbx
movq %r14, 0x38(%rax)
cmpq $0x0, 0x28(%r14)
je 0x13e3a6
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x13e40d
movq 0x18(%r14), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x50(%rbx)
movq 0x20(%r14), %rdi
shlq $0x4, %rdi
leaq 0x201b38(%rip), %rsi    # 0x33febc
movl $0x408, %edx            # imm = 0x408
callq 0x93160
movq %rax, (%rbx)
movq 0x20(%r14), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x40(%rbx)
movq 0x28(%r14), %rax
jmp 0x13e3c8
movq (%r14), %rax
testq %rax, %rax
je 0x13e43b
andq $0x0, 0x50(%rbx)
movq 0x18(%r14), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rbx)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x13e92b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2f9b82(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a6c23(%rip), %rsi    # 0x2e5013
leaq 0x20238e(%rip), %rdx    # 0x340785
leaq 0x202398(%rip), %rcx    # 0x340796
leaq 0x201ab7(%rip), %r8     # 0x33febc
movl $0x400, %r9d            # imm = 0x400
jmp 0x13e467
movq 0x2f9b54(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a6bf5(%rip), %rsi    # 0x2e5013
leaq 0x202394(%rip), %rdx    # 0x3407b9
leaq 0x20236a(%rip), %rcx    # 0x340796
leaq 0x201a89(%rip), %r8     # 0x33febc
movl $0x404, %r9d            # imm = 0x404
jmp 0x13e467
movq 0x2f9b26(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a6bc7(%rip), %rsi    # 0x2e5013
leaq 0x202385(%rip), %rdx    # 0x3407d8
leaq 0x20233c(%rip), %rcx    # 0x340796
leaq 0x201a5b(%rip), %r8     # 0x33febc
movl $0x40d, %r9d            # imm = 0x40D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_kmer_iter_delete
static void gt_diagbandseed_kmer_iter_delete(GtDiagbandseedKmerIterator *ki)
{
  if (ki != NULL) {
    if (ki->original == NULL)
    { /* file based */
      if (ki->section.encode_info != NULL)
      {
        gt_free(ki->kmerstream_uword.bufferedfilespace);
        gt_fa_fclose(ki->kmerstream_uword.fp);
        gt_free(ki->section.spaceGtUword);
      } else
      {
        gt_free(ki->kmerstream_struct.bufferedfilespace);
        gt_fa_fclose(ki->kmerstream_struct.fp);
      }
      gt_free(ki->section.spaceGtDiagbandseedKmerPos);
      ki->section.allocated = 0;
    } else
    {
      if (ki->section.encode_info != NULL)
      {
        gt_free(ki->section.spaceGtDiagbandseedKmerPos);
      }
    }
    gt_free(ki);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x13e4a9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
movq 0x28(%rdi), %rax
je 0x13e4aa
testq %rax, %rax
je 0x13e520
movq (%rbx), %rdi
leaq 0x201a1f(%rip), %rsi    # 0x33febc
movl $0x452, %edx            # imm = 0x452
callq 0x936f9
jmp 0x13e520
retq
testq %rax, %rax
je 0x13e4e9
movq 0x80(%rbx), %rdi
leaq 0x2019ff(%rip), %r14    # 0x33febc
movq %r14, %rsi
movl $0x444, %edx            # imm = 0x444
callq 0x936f9
movq 0x88(%rbx), %rdi
callq 0x8a4fd
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x446, %edx            # imm = 0x446
callq 0x936f9
jmp 0x13e507
movq 0x68(%rbx), %rdi
leaq 0x2019c8(%rip), %rsi    # 0x33febc
movl $0x449, %edx            # imm = 0x449
callq 0x936f9
movq 0x70(%rbx), %rdi
callq 0x8a4fd
movq (%rbx), %rdi
leaq 0x2019ab(%rip), %rsi    # 0x33febc
movl $0x44c, %edx            # imm = 0x44C
callq 0x936f9
andq $0x0, 0x10(%rbx)
leaq 0x201995(%rip), %rsi    # 0x33febc
movq %rbx, %rdi
movl $0x455, %edx            # imm = 0x455
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_kmer_iter_reset
static void gt_diagbandseed_kmer_iter_reset(GtDiagbandseedKmerIterator *ki)
{
  gt_assert(ki != NULL);
  ki->at_list_end = false;
  if (ki->original != NULL) /* list based */
  {
    if (ki->section.encode_info != NULL)
    {
      ki->listptr_uword = ki->original->spaceGtUword;
      ki->section.spaceGtUword = ki->original->spaceGtUword;
      ki->listptr_struct = ki->section.spaceGtDiagbandseedKmerPos;
    } else
    {
      ki->listptr_struct = ki->original->spaceGtDiagbandseedKmerPos;
      ki->section.spaceGtDiagbandseedKmerPos
        = ki->original->spaceGtDiagbandseedKmerPos;
    }
    if (gt_kmerpos_list_num_entries(ki->original) == 0)
    {
      ki->at_list_end = true;
    }
  } else /* file based */
  {
    if (ki->section.encode_info != NULL)
    {
      ki->kmerstream_uword.nextread = ki->kmerstream_uword.nextfree = 0;
      fseek(ki->kmerstream_uword.fp,sizeof (GtLongestCodeRunType),SEEK_SET);
      if (gt_readnextfromstream_GtUword(&ki->buffer_uword,
                                        &ki->kmerstream_uword) != 1)
      {
        ki->at_list_end = true;
      }
    } else
    {
      ki->kmerstream_struct.nextread = ki->kmerstream_struct.nextfree = 0;
      fseek(ki->kmerstream_struct.fp,sizeof (GtLongestCodeRunType),SEEK_SET);
      if (gt_readnextfromstream_GtDiagbandseedKmerPos(ki->listptr_struct,
                                                      &ki->kmerstream_struct)
                                                      != 1)
      {
        ki->at_list_end = true;
      }
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13e9db
movq %rdi, %rbx
movb $0x0, 0x30(%rdi)
movq 0x28(%rdi), %rax
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x13e962
testq %rax, %rax
je 0x13e992
movq 0x8(%rdi), %rax
movq %rax, 0x58(%rbx)
movq %rax, 0x8(%rbx)
movq (%rbx), %rax
jmp 0x13e998
testq %rax, %rax
je 0x13e9b2
leaq 0x78(%rbx), %r14
andq $0x0, 0x78(%rbx)
movq 0x88(%rbx), %rdi
pushq $0x8
popq %rsi
xorl %edx, %edx
callq 0x17840
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x1416c8
jmp 0x13e9d5
movq (%rdi), %rax
movq %rax, (%rbx)
movq %rax, 0x48(%rbx)
callq 0x13df4d
testq %rax, %rax
jne 0x13e9aa
movb $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x60(%rbx), %r14
andq $0x0, 0x60(%rbx)
movq 0x70(%rbx), %rdi
pushq $0x8
popq %rsi
xorl %edx, %edx
callq 0x17840
movq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0x141752
testl %eax, %eax
jne 0x13e9aa
jmp 0x13e9a6
movq 0x2f9586(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a6627(%rip), %rsi    # 0x2e5013
leaq 0x2024f6(%rip), %rdx    # 0x340ee9
leaq 0x2024fa(%rip), %rcx    # 0x340ef4
leaq 0x2014bb(%rip), %r8     # 0x33febc
movl $0x3cf, %r9d            # imm = 0x3CF
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_seedpairlist_length
static GtUword gt_seedpairlist_length(const GtSeedpairlist *seedpairlist)
{
  gt_assert(seedpairlist != NULL);
  if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_STRUCT)
  {
    gt_assert(seedpairlist->mlist_struct != NULL);
    return seedpairlist->mlist_struct->nextfreeGtDiagbandseedSeedPair;
  } else
  {
    if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
    {
      gt_assert(seedpairlist->mlist_ulong != NULL);
      return seedpairlist->mlist_ulong->nextfreeGtUword;
    } else
    {
      gt_assert(seedpairlist->mlist_bytestring != NULL &&
                (seedpairlist->mlist_bytestring->nextfreeuint8_t %
                 seedpairlist->bytes_seedpair == 0));
      return seedpairlist->mlist_bytestring->nextfreeuint8_t/
             seedpairlist->bytes_seedpair;
    }
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x13f09e
movl 0x18(%rdi), %eax
cmpl $0x1, %eax
je 0x13f072
testl %eax, %eax
jne 0x13f081
movq (%rdi), %rax
testq %rax, %rax
jne 0x13f07b
movq 0x2f8f20(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a5fc1(%rip), %rsi    # 0x2e5013
leaq 0x20275b(%rip), %rdx    # 0x3417b4
leaq 0x202063(%rip), %rcx    # 0x3410c3
leaq 0x200e55(%rip), %r8     # 0x33febc
movl $0x621, %r9d            # imm = 0x621
jmp 0x13f126
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x13f0fa
movq 0x10(%rax), %rax
jmp 0x13f09c
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x13f0cc
movq 0x10(%rax), %rax
xorl %edx, %edx
divq 0x90(%rdi)
testq %rdx, %rdx
jne 0x13f0cc
popq %rcx
retq
movq 0x2f8ec3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a5f64(%rip), %rsi    # 0x2e5013
leaq 0x201593(%rip), %rdx    # 0x340649
leaq 0x202006(%rip), %rcx    # 0x3410c3
leaq 0x200df8(%rip), %r8     # 0x33febc
movl $0x61e, %r9d            # imm = 0x61E
jmp 0x13f126
movq 0x2f8e95(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a5f36(%rip), %rsi    # 0x2e5013
leaq 0x201ff6(%rip), %rdx    # 0x3410da
leaq 0x201fd8(%rip), %rcx    # 0x3410c3
leaq 0x200dca(%rip), %r8     # 0x33febc
movl $0x62d, %r9d            # imm = 0x62D
jmp 0x13f126
movq 0x2f8e67(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a5f08(%rip), %rsi    # 0x2e5013
leaq 0x202b21(%rip), %rdx    # 0x341c33
leaq 0x201faa(%rip), %rcx    # 0x3410c3
leaq 0x200d9c(%rip), %r8     # 0x33febc
movl $0x627, %r9d            # imm = 0x627
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_seedpairlist_delete
static void gt_seedpairlist_delete(GtSeedpairlist *seedpairlist)
{
  if (seedpairlist != NULL)
  {
    if (seedpairlist->mlist_struct != NULL)
    {
      GT_FREEARRAY(seedpairlist->mlist_struct, GtDiagbandseedSeedPair);
      gt_free(seedpairlist->mlist_struct);
    }
    if (seedpairlist->mlist_ulong != NULL)
    {
      GT_FREEARRAY(seedpairlist->mlist_ulong, GtUword);
      gt_free(seedpairlist->mlist_ulong);
    }
    if (seedpairlist->mlist_bytestring != NULL)
    {
      GT_FREEARRAY(seedpairlist->mlist_bytestring, uint8_t);
      gt_free(seedpairlist->mlist_bytestring);
    }
    gt_free(seedpairlist);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x13f5d3
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x13f534
movq (%rdi), %rax
testq %rax, %rax
je 0x13f523
leaq 0x2009b4(%rip), %rsi    # 0x33febc
movq %rax, %rdi
movl $0x60b, %edx            # imm = 0x60B
callq 0x936f9
movq (%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x200992(%rip), %rsi    # 0x33febc
movl $0x60c, %edx            # imm = 0x60C
callq 0x936f9
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x13f579
movq (%rdi), %rax
testq %rax, %rax
je 0x13f568
leaq 0x200970(%rip), %rsi    # 0x33febc
movq %rax, %rdi
movl $0x610, %edx            # imm = 0x610
callq 0x936f9
movq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x20094d(%rip), %rsi    # 0x33febc
movl $0x611, %edx            # imm = 0x611
callq 0x936f9
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x13f5be
movq (%rdi), %rax
testq %rax, %rax
je 0x13f5ad
leaq 0x20092b(%rip), %rsi    # 0x33febc
movq %rax, %rdi
movl $0x615, %edx            # imm = 0x615
callq 0x936f9
movq 0x10(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x200908(%rip), %rsi    # 0x33febc
movl $0x616, %edx            # imm = 0x616
callq 0x936f9
leaq 0x2008f7(%rip), %rsi    # 0x33febc
movq %rbx, %rdi
movl $0x618, %edx            # imm = 0x618
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_one_GtUword2bytestring
static void gt_diagbandseed_one_GtUword2bytestring(uint8_t *bytestring,
                                                   GtUword bytestring_length,
                                                   GtUword value)
{
  int idx, shift;

  for (idx = 0, shift = (sizeof (GtUword) - 1) * CHAR_BIT;
       idx < bytestring_length; idx++, shift -= CHAR_BIT)
  {
    bytestring[idx] = (uint8_t) (value >> shift);
  }
}

// Assembly:
pushq $0x38
popq %rcx
xorl %eax, %eax
cmpq %rax, %rsi
je 0x1417fc
movq %rdx, %r8
shrq %cl, %r8
movb %r8b, (%rdi,%rax)
incq %rax
addl $-0x8, %ecx
jmp 0x1417e5
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_seedpairlist_sort
static void gt_diagbandseed_seedpairlist_sort(GtSeedpairlist *seedpairlist)
{
  GtUword mlistlen = gt_seedpairlist_length(seedpairlist);

  if (mlistlen > 0)
  {
    if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_STRUCT)
    {
      gt_assert(seedpairlist->mlist_struct != NULL);
      gt_radixsort_inplace_Gtuint64keyPair(
            (Gtuint64keyPair *) seedpairlist->mlist_struct
                                            ->spaceGtDiagbandseedSeedPair,
            mlistlen);
    } else
    {
      if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
      {
        gt_assert(seedpairlist->mlist_ulong != NULL);
        gt_radixsort_inplace_ulong(seedpairlist->mlist_ulong->spaceGtUword,
                                   mlistlen);
      } else
      {
        gt_assert(seedpairlist->mlist_bytestring != NULL);
        gt_radixsort_inplace_flba(seedpairlist->mlist_bytestring->spaceuint8_t,
                                  gt_seedpairlist_length(seedpairlist),
                                  seedpairlist->bytes_seedpair);
      }
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13f027
testq %rax, %rax
je 0x141834
movl 0x18(%rbx), %ecx
cmpl $0x1, %ecx
je 0x14183c
testl %ecx, %ecx
jne 0x141857
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x141888
movq (%rcx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa0e27
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x1418b6
movq (%rcx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa07dd
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1418e4
movq (%rax), %r14
movq %rbx, %rdi
callq 0x13f027
movq 0x90(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa0e64
movq 0x2f66d9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a377a(%rip), %rsi    # 0x2e5013
leaq 0x1fff14(%rip), %rdx    # 0x3417b4
leaq 0x1ff77a(%rip), %rcx    # 0x341021
leaq 0x1fe60e(%rip), %r8     # 0x33febc
movl $0x6da, %r9d            # imm = 0x6DA
jmp 0x141910
movq 0x2f66ab(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a374c(%rip), %rsi    # 0x2e5013
leaq 0x200365(%rip), %rdx    # 0x341c33
leaq 0x1ff74c(%rip), %rcx    # 0x341021
leaq 0x1fe5e0(%rip), %r8     # 0x33febc
movl $0x6e3, %r9d            # imm = 0x6E3
jmp 0x141910
movq 0x2f667d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a371e(%rip), %rsi    # 0x2e5013
leaq 0x1fe6d7(%rip), %rdx    # 0x33ffd3
leaq 0x1ff71e(%rip), %rcx    # 0x341021
leaq 0x1fe5b2(%rip), %r8     # 0x33febc
movl $0x6e8, %r9d            # imm = 0x6E8
xorl %eax, %eax
callq 0x17a50
callq 0x17390