LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_retrace_previousinchain
static void gt_chain2dim_retrace_previousinchain(GtChain2Dim *chain,
                                   const GtChain2Dimmatchtable *matchtable,
                                   GtUword retracestart)
{
  GtUword matchnum, lengthofchain;

  chain->storedinreverseorder = false;
  for (lengthofchain = 0, matchnum = retracestart;
       matchnum != GT_CHAIN2DIM_UNDEFPREVIOUS; lengthofchain++)
  {
    /* Use previousinchain */
    matchnum = matchtable->matches[matchnum].previousinchain;
  }
  MINARRAYSPACE(&chain->chainedmatches,GtChain2Dimref,lengthofchain);
  chain->chainedmatches.nextfreeGtChain2Dimref = lengthofchain;
  for (matchnum = retracestart;
       matchnum != GT_CHAIN2DIM_UNDEFPREVIOUS;
       /* Use previousinchain */
       matchnum = matchtable->matches[matchnum].previousinchain)
  {
    gt_assert(lengthofchain > 0);
    lengthofchain--;
    chain->chainedmatches.spaceGtChain2Dimref[lengthofchain] = matchnum;
  }
  gt_assert(lengthofchain == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb $0x0, 0x20(%rdi)
movq 0x18(%rsi), %rax
cmpq %rdx, %rax
jne 0x18e878
xorl %r12d, %r12d
jmp 0x18e896
movq (%rbx), %rcx
xorl %r12d, %r12d
movq %r14, %rdx
leaq (%rdx,%rdx,4), %rdx
shlq $0x4, %rdx
movq 0x28(%rcx,%rdx), %rdx
incq %r12
cmpq %rax, %rdx
jne 0x18e881
cmpq 0x8(%r15), %r12
jae 0x18e8a1
movq (%r15), %rax
jmp 0x18e8c4
movq %r12, 0x8(%r15)
movq (%r15), %rdi
leaq (,%r12,8), %rsi
leaq 0x2101c1(%rip), %rdx    # 0x39ea78
movl $0x1a7, %ecx            # imm = 0x1A7
callq 0x104461
movq %rax, (%r15)
testq %rax, %rax
je 0x18e909
movq %r12, 0x10(%r15)
cmpq %r14, 0x18(%rbx)
je 0x18e8f3
subq $0x1, %r12
jb 0x18e904
movq %r14, (%rax,%r12,8)
movq (%rbx), %rcx
leaq (%r14,%r14,4), %rdx
shlq $0x4, %rdx
movq 0x28(%rcx,%rdx), %r14
cmpq 0x18(%rbx), %r14
jne 0x18e8d3
testq %r12, %r12
jne 0x18e90e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5c65e
callq 0x5c6d0
callq 0x5c697
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/cutendpfx.c
// Function: gt_newbucketenumerator
Bucketenumerator *gt_newbucketenumerator(const GtBcktab *bcktab,
                                      unsigned int prefixlength,
                                      const GtUchar *demandprefix,
                                      unsigned int demandprefixlength)
{
  Bucketenumerator *bucketenumerator;
  GT_UNUSED unsigned int firstspecial;

  bucketenumerator = gt_malloc(sizeof *bucketenumerator);
  bucketenumerator->bcktab = bcktab;
  bucketenumerator->prefixlength = prefixlength;
  bucketenumerator->demandprefixlength = demandprefixlength;
  firstspecial = prefixqgram2code(&bucketenumerator->currentcode,
                                  gt_bcktab_multimappower(bcktab),
                                  prefixlength,
                                  demandprefixlength,
                                  demandprefix);
  gt_assert(firstspecial == prefixlength);
  bucketenumerator->lastcode
    = bucketenumerator->currentcode
      + gt_bcktab_filltable(bcktab,demandprefixlength);
  return bucketenumerator;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
leaq 0x2105db(%rip), %rsi    # 0x39f147
movl $0x38, %edi
movl $0x46, %edx
callq 0x104226
movq %rax, %r14
movq %r15, (%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
movq %r15, %rdi
callq 0x18c2e1
testl %ebx, %ebx
je 0x18ebf0
cmpl %ebx, %ebp
jbe 0x18ebf5
movl %ebx, %ecx
xorl %r13d, %r13d
decl %ecx
js 0x18ebbf
movl %ecx, %edx
movzbl (%r12,%rdx), %ecx
cmpq $0xfd, %rcx
ja 0x18ebc5
movq (%rax,%rdx,8), %rsi
addq (%rsi,%rcx,8), %r13
leal -0x1(%rdx), %ecx
testl %edx, %edx
jg 0x18eba0
movq %r13, 0x28(%r14)
jmp 0x18ebcd
cmpl %edx, %ebp
jne 0x18ebfa
movq 0x28(%r14), %r13
movq %r15, %rdi
movl %ebx, %esi
callq 0x18c2e6
addq %r13, %rax
movq %rax, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5c777
callq 0x5c709
callq 0x5c740
// File: /workspace/github_c_makefile_star2_O3/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 0x18ec5f
movq (%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x18bf15
movq 0x28(%r14), %rax
incq %rax
movq %rax, 0x28(%r14)
cmpq $0x0, 0x18(%r14)
je 0x18ec16
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_O3/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_weight
int gt_spaced_seed_weight(GtCodetype spaced_seed)
{
  int weight = 0;

  for (/* Nothing */; spaced_seed > 0; spaced_seed >>= 1)
  {
    if (spaced_seed & (GtCodetype) 1)
    {
      weight++;
    }
  }
  return weight;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x18ecb0
movq %rdi, %rcx
movl %edi, %edx
andl $0x1, %edx
addl %edx, %eax
shrq %rcx
cmpq $0x1, %rdi
movq %rcx, %rdi
ja 0x18ec9d
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18ecf5
movl %r8d, %eax
leaq 0x21077b(%rip), %rcx    # 0x39f440
movl (%rcx,%rax,4), %ecx
movl %ecx, (%rdi)
movl $0xc5, %edi
cmpl $0x11, %r8d
je 0x18ece2
addl $-0xe, %edx
leaq 0x2107b1(%rip), %rdi    # 0x39f490
movl (%rdi,%rdx,4), %edi
leaq 0x2107a7(%rip), %rdx    # 0x39f490
movl (%rdx,%rax,4), %eax
addl %ecx, %edi
notl %eax
addl %edi, %eax
movl %eax, (%rsi)
retq
pushq %rax
callq 0x5c7ae
// File: /workspace/github_c_makefile_star2_O3/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 0x18ecb1
cmpl %ebp, (%r14)
jg 0x18ef1c
cmpl %ebp, 0x8(%rsp)
jl 0x18ef1c
cmpl $0xe, %ebx
jle 0x18ef21
addl $-0xf, %ebx
leaq 0x21054e(%rip), %rax    # 0x39f440
subl (%rax,%rbx,4), %ebp
jl 0x18ef26
leaq 0x210592(%rip), %rax    # 0x39f490
addl (%rax,%rbx,4), %ebp
movslq %ebp, %rax
leaq 0x2105d5(%rip), %rcx    # 0x39f4e0
movq (%rcx,%rax,8), %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x18ecfb
callq 0x5c9af
callq 0x5c93d
callq 0x5c976
// File: /workspace/github_c_makefile_star2_O3/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 0x18ef64
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
jle 0x18ef60
movq (%rdi), %rdi
shlq $0x4, %rdx
addq %rdi, %rdx
xorl %eax, %eax
movq (%rdi), %r8
andq %rsi, %r8
movb 0x8(%rdi), %cl
shrq %cl, %r8
orq %r8, %rax
addq $0x10, %rdi
cmpq %rdx, %rdi
jb 0x18ef46
jmp 0x18ef62
xorl %eax, %eax
popq %rcx
retq
callq 0x5c9e8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x325438(%rip), %r12    # 0x4b4690
xorl %r14d, %r14d
movq (%r12), %rsi
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0x18f2b6
incq %r14
addq $0x8, %r12
cmpq $0x4, %r14
jne 0x18f25b
leaq 0x1c72ae(%rip), %rax    # 0x35652d
leaq 0x1c72ac(%rip), %rdx    # 0x356532
testb %bpl, %bpl
cmovneq %rax, %rdx
leaq 0x210998(%rip), %rax    # 0x39fc2c
leaq 0x2109dd(%rip), %rcx    # 0x39fc78
cmovneq %rax, %rcx
leaq 0x210a10(%rip), %rsi    # 0x39fcb6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe8e24
movq %rax, %rdi
callq 0x11acc9
movq %rax, %rbx
cmpl %r12d, %r13d
jae 0x190761
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x11af23
movq %rbx, %rdi
movl %r13d, %esi
callq 0x11b054
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x11af23
movq %rbx, %rdi
movl %r12d, %esi
callq 0x11b054
testb %r15b, %r15b
movl $0x66, %eax
movl $0x72, %esi
cmovnel %eax, %esi
movq %rbx, %rdi
callq 0x11af23
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11b054
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x11af23
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11b054
movl 0x40(%rsp), %eax
testl %eax, %eax
je 0x1907cf
cmpl $0x1, %eax
jne 0x19080b
movq %rbx, %rdi
movl $0x55, %esi
callq 0x11af23
leaq 0x20f6c1(%rip), %rsi    # 0x39fe97
movq %rbx, %rdi
callq 0x11acf3
movq %rbx, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xe4290
movq %rax, %r14
movq %rbx, %rdi
callq 0x11bdbf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5cbe9
// File: /workspace/github_c_makefile_star2_O3/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 0xff28c
movb $0x1, %bpl
testb %al, %al
je 0x190869
movq %r14, %rdi
callq 0xe8e24
movq %rax, %rdi
callq 0x11acc9
movq %rax, %r14
leaq 0x1b61db(%rip), %rsi    # 0x346a1b
movq %rax, %rdi
callq 0x11acf3
movq %r14, %rdi
callq 0x11b0a1
movq %rbx, %rdi
movq %rax, %rsi
callq 0xff33f
movl %eax, %ebp
movq %r14, %rdi
callq 0x11bdbf
xorb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x190f39
testq %rbx, %rbx
je 0x190fb6
movl %ecx, %r12d
movl %edx, %ebp
movq 0x18(%rbx), %rsi
leaq 0x20f3a7(%rip), %rdi    # 0x3a02b1
movl %ecx, %edx
xorl %eax, %eax
callq 0x17070
cmpl %r12d, %ebp
jae 0x190f28
leaq 0x20f3a7(%rip), %rdi    # 0x3a02c6
movl %ebp, %esi
xorl %eax, %eax
callq 0x17070
leaq 0x20f3a7(%rip), %rdi    # 0x3a02d6
movq %r15, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1c4ba1(%rip), %rsi    # 0x355ae1
leaq 0x20ec95(%rip), %rdx    # 0x39fbdc
movq %r15, %rdi
movl $0x1209, %ecx           # imm = 0x1209
movq %r14, %r8
callq 0xfcdbb
testq %rax, %rax
je 0x190fa8
movq %rax, %r14
leaq 0x20(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x11f89c
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 0x11f89c
movq %r14, %rdi
callq 0xfd018
xorl %eax, %eax
jmp 0x190fad
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5cd3f
// File: /workspace/github_c_makefile_star2_O3/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 0x191006
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x20ec0b(%rip), %r14    # 0x39fbdc
movq %r14, %rsi
movl $0x1ae, %edx            # imm = 0x1AE
callq 0x1045eb
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x1af, %edx            # imm = 0x1AF
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1b0, %edx            # imm = 0x1B0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x192674
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 0xd217b
movq %rax, 0x40(%rbx)
movl $0x0, 0x48(%rbx)
movq %r14, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5cf40
// File: /workspace/github_c_makefile_star2_O3/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 0xd24e0
testq %rax, %rax
je 0x192713
movq 0x40(%rbx), %rdi
callq 0xd222b
movq %rax, %r14
movq 0x40(%rbx), %rdi
callq 0xd2224
cmpq %r14, %rax
ja 0x192713
movq %rax, %r15
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 0x191007
movl %eax, 0x48(%rbx)
testl %eax, %eax
jne 0x192713
addq $0x10, %r15
cmpq %r14, %r15
jbe 0x1926b4
movq 0x40(%rbx), %rdi
callq 0xd2938
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19284a
movq %rdx, %rbp
movq %rsi, %r14
movl %edi, %ebx
movq %rbp, %rdi
callq 0xd6fbe
movq %rax, %r15
movq %r14, %rdi
callq 0xebd5d
leaq 0x20d477(%rip), %rsi    # 0x39fbdc
movq %rax, %rdi
movl $0x123a, %edx           # imm = 0x123A
callq 0x104226
movq %rax, %r12
movq %rbp, %rdi
callq 0xd6f20
testq %r15, %r15
je 0x192828
movq %rax, %r13
movzbl %bl, %eax
movl %eax, 0xc(%rsp)
movq %rbp, 0x10(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0xeb6ee
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0xeb9d2
movq %rax, %rbp
leaq (%rbx,%rax), %rcx
decq %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq 0x10(%rsp), %rbx
callq 0xe92be
leaq 0x20f48a(%rip), %rdi    # 0x3a1c5c
movl 0xc(%rsp), %esi
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x17070
movq 0x3266ee(%rip), %rax    # 0x4b8ed8
movq (%rax), %rcx
movl $0x1, %esi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x17fa0
movq 0x3266d4(%rip), %rax    # 0x4b8ed8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x17980
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd6f77
movq %rax, %r13
decq %r15
jne 0x192795
leaq 0x20d3ad(%rip), %rsi    # 0x39fbdc
movq %r12, %rdi
movl $0x1247, %edx           # imm = 0x1247
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1045eb
callq 0x5cf79
// File: /workspace/github_c_makefile_star2_O3/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 0x1928c4
movq %rsi, %r12
testq %rsi, %rsi
je 0x1928c4
movq %rdx, %r15
testq %rdx, %rdx
je 0x1928c4
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdi, %r14
movq (%r14), %r13
cmpq 0x8(%r14), %r13
jae 0x192897
movq %r15, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0xe811c
testb %al, %al
jne 0x1928ab
incq %r13
jmp 0x19287b
movq %r12, %rdi
movq %r14, %rsi
callq 0xeae9a
testb %al, %al
jne 0x192878
movq %rbx, %r13
jmp 0x1928b2
leaq 0x1(%r13), %rax
movq %rax, (%r14)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5cfb2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_longest_code_run
static GtUword gt_diagbandseed_longest_code_run(const GtKmerPosList
                                                   *kmerpos_list)
{
  GtUword idx;
  GtLongestCodeRunType longest_code_run = 1, current_code_run = 1;
  GtCodetype previouscode;

  gt_assert(kmerpos_list != NULL);
  if (kmerpos_list->encode_info != NULL)
  {
    gt_assert(kmerpos_list->spaceGtUword != NULL);
    previouscode = gt_kmerpos_entry_code(kmerpos_list->encode_info,
                                         kmerpos_list->spaceGtUword[0]);
    for (idx = 1; idx < kmerpos_list->nextfree; idx++)
    {
      const GtCodetype currentcode
        = gt_kmerpos_entry_code(kmerpos_list->encode_info,
                                kmerpos_list->spaceGtUword[idx]);

      if (previouscode == currentcode)
      {
        current_code_run++;
      } else
      {
        if (current_code_run > longest_code_run)
        {
          longest_code_run = current_code_run;
        }
        current_code_run = 1;
        previouscode = currentcode;
      }
    }
  } else
  {
    gt_assert(kmerpos_list->spaceGtDiagbandseedKmerPos != NULL);
    previouscode = kmerpos_list->spaceGtDiagbandseedKmerPos[0].code;
    for (idx = 1; idx < kmerpos_list->nextfree; idx++)
    {
      const GtCodetype currentcode
        = kmerpos_list->spaceGtDiagbandseedKmerPos[idx].code;

      if (previouscode == currentcode)
      {
        current_code_run++;
      } else
      {
        if (current_code_run > longest_code_run)
        {
          longest_code_run = current_code_run;
        }
        current_code_run = 1;
        previouscode = currentcode;
      }
    }
  }
  if (current_code_run > longest_code_run)
  {
    longest_code_run = current_code_run;
  }
  return longest_code_run;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x19464b
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x1945e9
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x194650
movq 0x18(%rdi), %rdi
movl $0x1, %edx
movl $0x1, %eax
cmpq $0x2, %rdi
jb 0x194642
movl 0x20(%rcx), %ecx
movq (%rsi), %r10
shrq %cl, %r10
movl $0x1, %r8d
movl $0x1, %r9d
movl $0x1, %r11d
movq (%rsi,%r9,8), %rbx
shrq %cl, %rbx
leaq 0x1(%r11), %rdx
cmpq %rax, %r11
cmovbeq %rax, %r11
cmpq %rbx, %r10
cmovneq %r8, %rdx
cmovneq %r11, %rax
incq %r9
movq %rbx, %r10
movq %rdx, %r11
cmpq %r9, %rdi
jne 0x1945bc
jmp 0x194642
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x194655
movq 0x18(%rdi), %rsi
movl $0x1, %edx
movl $0x1, %eax
cmpq $0x2, %rsi
jb 0x194642
movq (%rcx), %r8
decq %rsi
addq $0x10, %rcx
movl $0x1, %edi
movl $0x1, %r9d
movq (%rcx), %r10
leaq 0x1(%r9), %rdx
cmpq %rax, %r9
cmovbeq %rax, %r9
cmpq %r10, %r8
cmovneq %rdi, %rdx
cmovneq %r9, %rax
addq $0x10, %rcx
movq %r10, %r8
movq %rdx, %r9
decq %rsi
jne 0x19461a
cmpq %rax, %rdx
cmovaq %rdx, %rax
popq %rbx
retq
callq 0x5d20f
callq 0x5d19d
callq 0x5d1d6
// File: /workspace/github_c_makefile_star2_O3/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 0x19468f
testq %rsi, %rsi
je 0x19468f
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
callq 0x5d248
// File: /workspace/github_c_makefile_star2_O3/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 0x1946b9
cmpq 0x8(%rdi), %rsi
jae 0x1946b9
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
callq 0x5d281
// File: /workspace/github_c_makefile_star2_O3/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 0xff72f
cmpq $0x8, %rax
jb 0x1946f0
xorl %ecx, %ecx
testl %ebx, %ebx
sete %cl
addq $-0x8, %rax
leal 0x7(,%rcx,8), %ecx
testl %ecx, %eax
jne 0x1946f0
xorl %ecx, %ecx
cmpl $0x1, %ebx
adcb $0x3, %cl
shrq %cl, %rax
popq %rbx
retq
callq 0x5d2ba
// File: /workspace/github_c_makefile_star2_O3/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 0x20b4d1(%rip), %rsi    # 0x39fbdc
movl $0x98, %edi
movl $0x41a, %edx            # imm = 0x41A
callq 0x104226
movq %rax, %r14
movq $0x0, 0x38(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x11f848
testq %rbx, %rbx
je 0x19477b
movq %r15, 0x88(%r14)
leaq 0x20b486(%rip), %rsi    # 0x39fbdc
movl $0x8000, %edi           # imm = 0x8000
movl $0x426, %edx            # imm = 0x426
callq 0x104226
movq %rax, 0x80(%r14)
movq $0x0, 0x8(%r14)
movq 0x8(%rsp), %rdi
jmp 0x1947a1
movq %r15, 0x70(%r14)
leaq 0x20b456(%rip), %rsi    # 0x39fbdc
movl $0x10000, %edi          # imm = 0x10000
movl $0x42e, %edx            # imm = 0x42E
callq 0x104226
movq %rax, 0x68(%r14)
movq 0x8(%rsp), %rdi
incq %rdi
movq %rdi, 0x10(%r14)
shlq $0x4, %rdi
leaq 0x20b42c(%rip), %rsi    # 0x39fbdc
movl $0x434, %edx            # imm = 0x434
callq 0x104226
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 0x194d0a
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20b3e5(%rip), %rsi    # 0x39fbdc
movl $0x98, %edi
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x104226
testq %r14, %r14
je 0x19489b
movq %rax, %rbx
movq %r14, 0x38(%rax)
cmpq $0x0, 0x28(%r14)
je 0x194863
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x1948a0
movq 0x18(%r14), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x50(%rbx)
movq 0x20(%r14), %rdi
shlq $0x4, %rdi
leaq 0x20b39b(%rip), %rsi    # 0x39fbdc
movl $0x408, %edx            # imm = 0x408
callq 0x104226
movq %rax, (%rbx)
movq 0x20(%r14), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x40(%rbx)
movq 0x28(%r14), %rax
jmp 0x194884
movq (%r14), %rax
testq %rax, %rax
je 0x1948a5
movq $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 0x194d0a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5d365
callq 0x5d2f3
callq 0x5d32c
// File: /workspace/github_c_makefile_star2_O3/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 0x1948e0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
movq 0x28(%rdi), %rax
je 0x1948e1
testq %rax, %rax
je 0x19495a
movq (%rbx), %rdi
leaq 0x20b308(%rip), %rsi    # 0x39fbdc
movl $0x452, %edx            # imm = 0x452
callq 0x1045eb
jmp 0x19495a
retq
testq %rax, %rax
je 0x194920
movq 0x80(%rbx), %rdi
leaq 0x20b2e8(%rip), %r14    # 0x39fbdc
movq %r14, %rsi
movl $0x444, %edx            # imm = 0x444
callq 0x1045eb
movq 0x88(%rbx), %rdi
callq 0xfd018
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x446, %edx            # imm = 0x446
callq 0x1045eb
jmp 0x19493e
movq 0x68(%rbx), %rdi
leaq 0x20b2b1(%rip), %rsi    # 0x39fbdc
movl $0x449, %edx            # imm = 0x449
callq 0x1045eb
movq 0x70(%rbx), %rdi
callq 0xfd018
movq (%rbx), %rdi
leaq 0x20b294(%rip), %rsi    # 0x39fbdc
movl $0x44c, %edx            # imm = 0x44C
callq 0x1045eb
movq $0x0, 0x10(%rbx)
leaq 0x20b27b(%rip), %rsi    # 0x39fbdc
movq %rbx, %rdi
movl $0x455, %edx            # imm = 0x455
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/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 0x194dc4
movq %rdi, %rbx
movb $0x0, 0x30(%rdi)
movq 0x28(%rdi), %rax
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x194d41
testq %rax, %rax
je 0x194d76
movq 0x8(%rdi), %rax
movq %rax, 0x58(%rbx)
movq %rax, 0x8(%rbx)
movq (%rbx), %rax
jmp 0x194d7c
testq %rax, %rax
je 0x194d96
leaq 0x78(%rbx), %r14
movq $0x0, 0x78(%rbx)
movq 0x88(%rbx), %rdi
movl $0x8, %esi
xorl %edx, %edx
callq 0x17890
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x1978b4
jmp 0x194dbe
movq (%rdi), %rax
movq %rax, (%rbx)
movq %rax, 0x48(%rbx)
callq 0x194533
testq %rax, %rax
jne 0x194d8e
movb $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x60(%rbx), %r14
movq $0x0, 0x60(%rbx)
movq 0x70(%rbx), %rdi
movl $0x8, %esi
xorl %edx, %edx
callq 0x17890
movq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0x197923
testl %eax, %eax
jne 0x194d8e
jmp 0x194d8a
callq 0x5d3d7
// File: /workspace/github_c_makefile_star2_O3/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 0x19531d
movl 0x18(%rdi), %eax
cmpl $0x1, %eax
je 0x1952f1
testl %eax, %eax
jne 0x195300
movq (%rdi), %rax
testq %rax, %rax
jne 0x1952fa
callq 0x5d5d8
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x195327
movq 0x10(%rax), %rax
jmp 0x19531b
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x195322
movq 0x10(%rax), %rax
xorl %edx, %edx
divq 0x90(%rdi)
testq %rdx, %rdx
jne 0x195322
popq %rcx
retq
callq 0x5d64a
callq 0x5d611
callq 0x5d59f
// File: /workspace/github_c_makefile_star2_O3/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 0x1957d8
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x195733
movq (%rdi), %rax
testq %rax, %rax
je 0x195722
leaq 0x20a4d8(%rip), %rsi    # 0x39fbdc
movq %rax, %rdi
movl $0x60b, %edx            # imm = 0x60B
callq 0x1045eb
movq (%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20a4b3(%rip), %rsi    # 0x39fbdc
movl $0x60c, %edx            # imm = 0x60C
callq 0x1045eb
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x19577b
movq (%rdi), %rax
testq %rax, %rax
je 0x19576a
leaq 0x20a491(%rip), %rsi    # 0x39fbdc
movq %rax, %rdi
movl $0x610, %edx            # imm = 0x610
callq 0x1045eb
movq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20a46b(%rip), %rsi    # 0x39fbdc
movl $0x611, %edx            # imm = 0x611
callq 0x1045eb
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1957c3
movq (%rdi), %rax
testq %rax, %rax
je 0x1957b2
leaq 0x20a449(%rip), %rsi    # 0x39fbdc
movq %rax, %rdi
movl $0x615, %edx            # imm = 0x615
callq 0x1045eb
movq 0x10(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20a423(%rip), %rsi    # 0x39fbdc
movl $0x616, %edx            # imm = 0x616
callq 0x1045eb
leaq 0x20a412(%rip), %rsi    # 0x39fbdc
movq %rbx, %rdi
movl $0x618, %edx            # imm = 0x618
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1952d2
testq %rax, %rax
je 0x1979cd
movl 0x18(%rbx), %ecx
cmpl $0x1, %ecx
je 0x1979d5
testl %ecx, %ecx
jne 0x1979f0
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x197a1d
movq (%rcx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10fdcd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x197a22
movq (%rcx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10f85a
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x197a27
movq (%rax), %r14
movq %rbx, %rdi
callq 0x1952d2
movq 0x90(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10fe0f
callq 0x5de2c
callq 0x5ddf3
callq 0x5de65
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_seedpairlist_at
static void gt_seedpairlist_at(GtDiagbandseedSeedPair *seedpair,
                               const GtSeedpairlist *seedpairlist,
                               GtUword spidx)
{
  if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_STRUCT)
  {
    *seedpair = seedpairlist->mlist_struct->spaceGtDiagbandseedSeedPair[spidx];
  } else
  {
    if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
    {
      GtDiagbandseedPosition apos, bpos;

      seedpair->aseqnum
        = gt_seedpairlist_extract_ulong_at(seedpairlist,spidx,idx_aseqnum);
      seedpair->bseqnum
        = gt_seedpairlist_extract_ulong_at(seedpairlist,spidx,idx_bseqnum);
      apos = gt_seedpairlist_extract_ulong_at(seedpairlist,spidx,idx_apos),
      bpos = gt_seedpairlist_extract_ulong_at(seedpairlist,spidx,idx_bpos);
      GT_DIAGBANDSEED_SETPOS(seedpair,apos,bpos); /* set for ulong */
    } else
    {
      gt_diagbandseed_decode_seedpair(seedpair,seedpairlist,
                                      spidx * seedpairlist->bytes_seedpair);
    }
  }
}

// Assembly:
movl 0x18(%rsi), %eax
cmpl $0x1, %eax
je 0x197a4a
testl %eax, %eax
jne 0x197a9a
movq (%rsi), %rax
movq (%rax), %rax
shlq $0x4, %rdx
movups (%rax,%rdx), %xmm0
movups %xmm0, (%rdi)
retq
movq 0x8(%rsi), %rax
movq (%rax), %rax
movq (%rax,%rdx,8), %rax
movb 0x98(%rsi), %cl
movq %rax, %rdx
shrq %cl, %rdx
andl 0x20(%rsi), %edx
movl %edx, 0x4(%rdi)
movb 0x9c(%rsi), %cl
movq %rax, %rdx
shrq %cl, %rdx
andl 0x28(%rsi), %edx
movl %edx, (%rdi)
movb 0xa4(%rsi), %cl
movq %rax, %rdx
shrq %cl, %rdx
movb 0xa0(%rsi), %cl
andl 0x38(%rsi), %edx
shrq %cl, %rax
andl 0x30(%rsi), %eax
movl %eax, 0xc(%rdi)
movl %edx, 0x8(%rdi)
retq
imulq 0x90(%rsi), %rdx
jmp 0x197aa4