LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_fillthegapvalues
void gt_chain_fillthegapvalues(GtChain2Dimmatchtable *matchtable)
{
  Matchchaininfo *fiptr;

  for (fiptr = matchtable->matches;
       fiptr < matchtable->matches + matchtable->nextfree;
       fiptr++)
  {
    fiptr->initialgap
      = (GtChain2Dimscoretype) (fiptr->startpos[0] + fiptr->startpos[1]);
    fiptr->terminalgap
      = (GtChain2Dimscoretype) (matchtable->largestdim0 - fiptr->endpos[0] +
                                matchtable->largestdim1 - fiptr->endpos[1]);
  }
}

// Assembly:
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x1950c5
movq (%rdi), %rax
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq 0x8(%rdi), %rdx
addq 0x10(%rdi), %rdx
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdi
addq (%rax), %rsi
movq %rsi, 0x38(%rax)
addq 0x18(%rax), %rdi
movq %rdx, %rsi
subq %rdi, %rsi
movq %rsi, 0x40(%rax)
addq $0x50, %rax
cmpq %rcx, %rax
jb 0x19509f
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_applyweight
void gt_chain_applyweight(double weightfactor,
                          GtChain2Dimmatchtable *matchtable)
{
  if (!gt_double_equals_double(weightfactor, 1.0))
  {
    Matchchaininfo *fiptr;

    for (fiptr = matchtable->matches;
         fiptr < matchtable->matches + matchtable->nextfree;
         fiptr++)
    {
      fiptr->weight *= weightfactor;
    }
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movsd 0x1ba14c(%rip), %xmm1   # 0x34f228
callq 0x10ac6f
movsd 0x8(%rsp), %xmm1
testb %al, %al
jne 0x195121
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
jle 0x195121
movq (%rbx), %rax
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2sdq 0x30(%rax), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, 0x30(%rax)
addq $0x50, %rax
cmpq %rcx, %rax
jb 0x195102
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_possiblysortmatches
void gt_chain_possiblysortmatches(GtLogger *logger,
                                    GtChain2Dimmatchtable *matchtable,
                                    unsigned int presortdim)
{
  if (matchtable->nextfree > 1UL)
  {
    Qsortcomparefunction qsortcomparefunction;
    Matchchaininfo *fptr;
    bool matchesaresorted = true;

    gt_assert(presortdim <= 1U);
    qsortcomparefunction
      = (presortdim == 0) ? cmpMatchchaininfo0 : cmpMatchchaininfo1;
    for (fptr = matchtable->matches;
         fptr < matchtable->matches + matchtable->nextfree - 1;
         fptr++)
    {
      if (qsortcomparefunction((const void *) fptr,
                               (const void *) (fptr+1)) == 1)
      {
        matchesaresorted = false;
        break;
      }
    }
    if (!matchesaresorted)
    {
      gt_logger_log(logger,"input matches are not yet sorted => sort them");
      qsort(matchtable->matches,(size_t) matchtable->nextfree,
            sizeof (*matchtable->matches),qsortcomparefunction);
    } else
    {
      gt_logger_log(logger,"matches are already sorted w.r.t. dimension %u",
                    presortdim);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x2, 0x18(%rsi)
jb 0x1966b1
movl %edx, %ebp
cmpl $0x2, %edx
jae 0x1966d5
movq %rsi, %rbx
movq %rdi, %r14
testl %ebp, %ebp
leaq 0x91(%rip), %rax        # 0x1966da
leaq 0x9e(%rip), %r15        # 0x1966ee
cmoveq %rax, %r15
movq (%rsi), %rdi
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x50, %rax
cmpq %rax, %rdi
jae 0x1966ba
leaq 0x50(%rdi), %r12
movq %r12, %rsi
callq *%r15
movq %r12, %rdi
cmpl $0x1, %eax
jne 0x196657
leaq 0x211a0c(%rip), %rsi    # 0x3a8097
movq %r14, %rdi
xorl %eax, %eax
callq 0x10906e
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
movl $0x50, %edx
movq %r15, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17f60
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x211a04(%rip), %rsi    # 0x3a80c5
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10906e
callq 0x5d7d4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_extractchainelem
void gt_chain_extractchainelem(GtChain2Dimmatchvalues *value,
                               const GtChain2Dimmatchtable *matchtable,
                               const GtChain2Dim *chain,GtUword idx)
{
  const Matchchaininfo *fiptr;

  gt_assert(idx <  gt_chain_chainlength(chain) &&
            chain->chainedmatches.spaceGtChain2Dimref[idx] <
            matchtable->nextfree);
  fiptr = matchtable->matches +
          chain->chainedmatches.spaceGtChain2Dimref[idx];
  value->startpos[0] = fiptr->startpos[0];
  value->startpos[1] = fiptr->startpos[1];
  value->endpos[0] = fiptr->endpos[0];
  value->endpos[1] = fiptr->endpos[1];
  value->weight = fiptr->weight;
}

// Assembly:
cmpq %rcx, 0x10(%rdx)
jbe 0x196971
movq (%rdx), %rax
movq (%rax,%rcx,8), %rax
cmpq 0x18(%rsi), %rax
jae 0x196971
movq (%rsi), %rcx
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq (%rcx,%rax), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx,%rax), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rcx,%rax), %rdx
movq %rdx, 0x10(%rdi)
movq 0x18(%rcx,%rax), %rdx
movq %rdx, 0x18(%rdi)
movq 0x30(%rcx,%rax), %rax
movq %rax, 0x20(%rdi)
retq
pushq %rax
callq 0x5d873
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_printchainelem
void gt_chain_printchainelem(FILE *outfp,const GtChain2Dimmatchvalues *value)
{
  fprintf(outfp,GT_WU " " GT_WU " " GT_WU " " GT_WU " " GT_WD "\n",
          value->startpos[0],
          value->endpos[0],
          value->startpos[1],
          value->endpos[1],
          value->weight);
}

// Assembly:
pushq %rax
movq 0x10(%rsi), %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %r8
movq 0x18(%rsi), %r9
movq 0x20(%rsi), %rax
movq %rax, (%rsp)
leaq 0x211813(%rip), %rsi    # 0x3a81a9
xorl %eax, %eax
callq 0x17ab0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/chain2dim.c
// Function: gapcostCc
static GtChain2Dimscoretype gapcostCc(const GtChain2Dimmatchtable *matchtable,
                                  GtUword i,GtUword j)
{
  GtChain2Dimpostype value1, value2;

  gt_assert(GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0,j)
              > GT_CHAIN2DIM_GETSTOREDENDPOINT(0,i) &&
            GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1,j)
              > GT_CHAIN2DIM_GETSTOREDENDPOINT(1,i));
  value1 = GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0,j)
             - GT_CHAIN2DIM_GETSTOREDENDPOINT(0,i) - 1,
  value2 = GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1,j)
             - GT_CHAIN2DIM_GETSTOREDENDPOINT(1,i) - 1;
  return (GtChain2Dimscoretype) GT_MAX(value1,value2);
}

// Assembly:
movq (%rdi), %rdi
leaq (%rdx,%rdx,4), %rax
shlq $0x4, %rax
movq (%rdi,%rax), %rcx
leaq (%rsi,%rsi,4), %rsi
shlq $0x4, %rsi
movq 0x10(%rdi,%rsi), %rdx
cmpq %rdx, %rcx
jbe 0x196a51
addq %rdi, %rax
addq %rdi, %rsi
addq $0x10, %rsi
movq 0x8(%rax), %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, %rax
jbe 0x196a51
notq %rdx
addq %rdx, %rcx
notq %rsi
addq %rsi, %rax
cmpq %rax, %rcx
cmovaq %rcx, %rax
retq
pushq %rax
callq 0x5d8ac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/chain2dim.c
// Function: makeactivationpoint
static GtChain2DimMatchpoint *makeactivationpoint(
                                       const GtChain2Dimmatchtable *matchtable,
                                       GtUword fpident,
                                       unsigned int postsortdim)
{
  GtChain2DimMatchpoint *fpptr;

  fpptr = gt_malloc(sizeof (*fpptr));
  gt_assert(fpptr != NULL);
  fpptr->fpident = MAKEENDPOINT(fpident);
  fpptr->fpposition = GT_CHAIN2DIM_GETSTOREDENDPOINT(postsortdim,fpident);
  return fpptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x211169(%rip), %rsi    # 0x3a7f48
movl $0x10, %edi
movl $0x4cf, %edx            # imm = 0x4CF
callq 0x1092b2
testq %rax, %rax
je 0x196e12
movq %r15, (%rax)
leaq (%r15,%r15,4), %rcx
shlq $0x4, %rcx
addq (%r14), %rcx
movl %ebx, %edx
movq 0x10(%rcx,%rdx,8), %rcx
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x5d97c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_retrievemaximalscore
static bool gt_chain2dim_retrievemaximalscore(GtChain2Dimscoretype *maxscore,
                                              const GtChain2Dimmode *chainmode,
                                              const GtChain2Dimmatchtable
                                                *matchtable)
{
  GtUword matchnum;
  GtChain2Dimscoretype tgap;
  bool maxscoredefined = false;

  *maxscore = 0;
  for (matchnum=0; matchnum<matchtable->nextfree; matchnum++)
  {
    if (gt_chain2dim_isrightmaximal_chain(matchtable,matchnum))
    {
      if (chainmode->chainkind == GLOBALCHAININGWITHGAPCOST)
      {
        tgap = GT_CHAIN2DIM_TERMINALGAP(matchnum);
      } else
      {
        tgap = 0;
      }
      if (!maxscoredefined ||
          *maxscore < matchtable->matches[matchnum].score - tgap)
      {
        *maxscore = matchtable->matches[matchnum].score - tgap;
        maxscoredefined = true;
      }
    }
  }
  return maxscoredefined;
}

// Assembly:
movq $0x0, (%rdi)
movq 0x18(%rdx), %r9
testq %r9, %r9
je 0x196e97
xorl %ecx, %ecx
xorl %eax, %eax
xorl %r8d, %r8d
decq %r9
cmpq %r9, %r8
je 0x196e4f
movq (%rdx), %r9
cmpq 0x78(%r9,%rcx), %r8
jne 0x196e4f
movq 0x98(%r9,%rcx), %r10
cmpq 0x48(%r9,%rcx), %r10
jge 0x196e85
cmpl $0x1, (%rsi)
jne 0x196e5e
movq (%rdx), %r9
movq 0x40(%r9,%rcx), %r9
jmp 0x196e61
xorl %r9d, %r9d
testb $0x1, %al
je 0x196e75
movq (%rdx), %r10
movq 0x48(%r10,%rcx), %r10
subq %r9, %r10
cmpq %r10, (%rdi)
jge 0x196e85
movq (%rdx), %rax
movq 0x48(%rax,%rcx), %rax
subq %r9, %rax
movq %rax, (%rdi)
movb $0x1, %al
incq %r8
movq 0x18(%rdx), %r9
addq $0x50, %rcx
cmpq %r9, %r8
jb 0x196e2e
jmp 0x196e99
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x196ed3
xorl %r12d, %r12d
jmp 0x196ef1
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 0x196edc
cmpq 0x8(%r15), %r12
jb 0x196f1a
movq %r12, 0x8(%r15)
movq (%r15), %rdi
leaq (,%r12,8), %rsi
leaq 0x21103b(%rip), %rdx    # 0x3a7f48
movl $0x1a7, %ecx            # imm = 0x1A7
callq 0x1094e6
movq %rax, (%r15)
movq (%r15), %rax
testq %rax, %rax
je 0x196f62
movq %r12, 0x10(%r15)
cmpq %r14, 0x18(%rbx)
je 0x196f4c
subq $0x1, %r12
jb 0x196f5d
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 0x196f2c
testq %r12, %r12
jne 0x196f67
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5d9b5
callq 0x5da27
callq 0x5d9ee
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
leaq 0x211463(%rip), %rsi    # 0x3a8640
movl $0x38, %edi
movl $0x46, %edx
callq 0x1092b2
movq %rax, %r14
movq %r15, (%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
movq %r15, %rdi
callq 0x194994
testl %ebx, %ebx
je 0x197264
cmpl %ebx, %ebp
jbe 0x197269
movl %ebx, %ecx
decl %ecx
js 0x197233
xorl %ecx, %ecx
movl %ebx, %edx
leal -0x1(%rdx), %esi
movzbl (%r12,%rsi), %edi
cmpq $0xfd, %rdi
ja 0x19723d
movq (%rax,%rsi,8), %rdx
addq (%rdx,%rdi,8), %rcx
movl %esi, %edx
testl %esi, %esi
jg 0x197212
jmp 0x197235
xorl %ecx, %ecx
movq %rcx, 0x28(%r14)
movl %ebp, %edx
jmp 0x19723f
decl %edx
cmpl %ebp, %edx
jne 0x19726e
movq 0x28(%r14), %r12
movq %r15, %rdi
movl %ebx, %esi
callq 0x194999
addq %r12, %rax
movq %rax, 0x30(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5dace
callq 0x5da60
callq 0x5da97
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rdi, %rbx
leaq 0x10(%rsi), %r12
movq 0x28(%r15), %r14
movq 0x30(%r15), %r13
cmpq %r13, %r14
ja 0x1972c9
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x194590
incq 0x28(%r15)
cmpq $0x0, 0x18(%r15)
je 0x197286
movq 0x10(%r15), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%r15), %rcx
addq %rcx, %rax
decq %rax
movq %rax, 0x10(%rbx)
movl 0xc(%r15), %eax
movq %rax, (%rbx)
cmpq %r13, %r14
setbe %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19731c
movq %rdi, %rcx
movl %edi, %edx
andl $0x1, %edx
addl %edx, %eax
shrq %rcx
cmpq $0x1, %rdi
movq %rcx, %rdi
ja 0x197309
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19731d
cmpl %ebp, (%r14)
jg 0x19757f
cmpl %ebp, 0x8(%rsp)
jl 0x19757f
cmpl $0xe, %ebx
jle 0x197584
addl $-0xf, %ebx
leaq 0x2113db(%rip), %rax    # 0x3a8930
subl (%rax,%rbx,4), %ebp
jl 0x197589
leaq 0x21141f(%rip), %rax    # 0x3a8980
addl (%rax,%rbx,4), %ebp
movslq %ebp, %rax
leaq 0x211462(%rip), %rcx    # 0x3a89d0
movq (%rcx,%rax,8), %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x197361
callq 0x5dd06
callq 0x5dc94
callq 0x5dccd
// File: /workspace/github_c_makefile_star2_O1/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 0x1975c7
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
jle 0x1975c3
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 0x1975a9
jmp 0x1975c5
xorl %eax, %eax
popq %rcx
retq
callq 0x5dd3f
// File: /workspace/github_c_makefile_star2_O1/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 0x327de8(%rip), %r12    # 0x4bf6a0
xorl %r14d, %r14d
movq (%r12), %rsi
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0x197916
incq %r14
addq $0x8, %r12
cmpq $0x4, %r14
jne 0x1978bb
leaq 0x1c7c7e(%rip), %rax    # 0x35f55d
leaq 0x1c7c7c(%rip), %rdx    # 0x35f562
testb %bpl, %bpl
cmovneq %rax, %rdx
leaq 0x211828(%rip), %rax    # 0x3a911c
leaq 0x21186d(%rip), %rcx    # 0x3a9168
cmovneq %rax, %rcx
leaq 0x2118a0(%rip), %rsi    # 0x3a91a6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
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_O1/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 0xed3c3
movq %rax, %rdi
callq 0x120955
movq %rax, %rbx
cmpl %r12d, %r13d
jae 0x198d53
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x120ba5
movq %rbx, %rdi
movl %r13d, %esi
callq 0x120cd6
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x120ba5
movq %rbx, %rdi
movl %r12d, %esi
callq 0x120cd6
testb %r15b, %r15b
movl $0x66, %eax
movl $0x72, %esi
cmovnel %eax, %esi
movq %rbx, %rdi
callq 0x120ba5
movq %rbx, %rdi
movl %r14d, %esi
callq 0x120cd6
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x120ba5
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x120cd6
movl 0x40(%rsp), %eax
testl %eax, %eax
je 0x198dc1
cmpl $0x1, %eax
jne 0x198dfd
movq %rbx, %rdi
movl $0x55, %esi
callq 0x120ba5
leaq 0x2105bf(%rip), %rsi    # 0x3a9387
movq %rbx, %rdi
callq 0x12097f
movq %rbx, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0xe8760
movq %rax, %r14
movq %rbx, %rdi
callq 0x121b03
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5df40
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x10415c
testb %al, %al
je 0x198e5c
movq %r14, %rdi
callq 0xed3c3
movq %rax, %rdi
callq 0x120955
movq %rax, %r14
leaq 0x1b6bec(%rip), %rsi    # 0x34fa1b
movq %rax, %rdi
callq 0x12097f
movq %r14, %rdi
callq 0x120d23
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10420f
movl %eax, %ebx
movq %r14, %rdi
callq 0x121b03
testb %bl, %bl
je 0x198e5c
xorl %eax, %eax
jmp 0x198e5e
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19950a
testq %rbx, %rbx
je 0x199587
movl %ecx, %r12d
movl %edx, %ebp
movq 0x18(%rbx), %rsi
leaq 0x2102c6(%rip), %rdi    # 0x3a97a1
movl %ecx, %edx
xorl %eax, %eax
callq 0x17070
cmpl %r12d, %ebp
jae 0x1994f9
leaq 0x2102c6(%rip), %rdi    # 0x3a97b6
movl %ebp, %esi
xorl %eax, %eax
callq 0x17070
leaq 0x2102c6(%rip), %rdi    # 0x3a97c6
movq %r15, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1c55fc(%rip), %rsi    # 0x35eb0d
leaq 0x20fbb4(%rip), %rdx    # 0x3a90cc
movq %r15, %rdi
movl $0x1209, %ecx           # imm = 0x1209
movq %r14, %r8
callq 0x101c23
testq %rax, %rax
je 0x199579
movq %rax, %r14
leaq 0x20(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x125658
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 0x125658
movq %r14, %rdi
callq 0x101e80
xorl %eax, %eax
jmp 0x19957e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e096
// File: /workspace/github_c_makefile_star2_O1/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 0x1995d7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x20fb2a(%rip), %r14    # 0x3a90cc
movq %r14, %rsi
movl $0x1ae, %edx            # imm = 0x1AE
callq 0x109670
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x1af, %edx            # imm = 0x1AF
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1b0, %edx            # imm = 0x1B0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19ac67
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 0xd472b
movq %rax, 0x40(%rbx)
movl $0x0, 0x48(%rbx)
movq %r14, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5e37b
// File: /workspace/github_c_makefile_star2_O1/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 0xd4a9a
testq %rax, %rax
je 0x19ad06
movq 0x40(%rbx), %rdi
callq 0xd47de
movq %rax, %r14
movq 0x40(%rbx), %rdi
callq 0xd47d7
cmpq %r14, %rax
ja 0x19ad06
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 0x1995d8
movl %eax, 0x48(%rbx)
testl %eax, %eax
jne 0x19ad06
addq $0x10, %r15
cmpq %r14, %r15
jbe 0x19aca7
movq 0x40(%rbx), %rdi
callq 0xd4ef4
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19ae3d
movq %rdx, %rbp
movq %rsi, %r14
movl %edi, %ebx
movq %rbp, %rdi
callq 0xd964d
movq %rax, %r15
movq %r14, %rdi
callq 0xf035e
leaq 0x20e374(%rip), %rsi    # 0x3a90cc
movq %rax, %rdi
movl $0x123a, %edx           # imm = 0x123A
callq 0x1092b2
movq %rax, %r12
movq %rbp, %rdi
callq 0xd9595
testq %r15, %r15
je 0x19ae1b
movq %rax, %r13
movzbl %bl, %eax
movl %eax, 0xc(%rsp)
movq %rbp, 0x10(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0xefce0
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0xeffd3
movq %rax, %rbp
leaq (%rbx,%rax), %rcx
decq %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq 0x10(%rsp), %rbx
callq 0xed87b
leaq 0x2103f4(%rip), %rdi    # 0x3ab1b9
movl 0xc(%rsp), %esi
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x17070
movq 0x32910b(%rip), %rax    # 0x4c3ee8
movq (%rax), %rcx
movl $0x1, %esi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x17fa0
movq 0x3290f1(%rip), %rax    # 0x4c3ee8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x17980
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd95f8
movq %rax, %r13
decq %r15
jne 0x19ad88
leaq 0x20e2aa(%rip), %rsi    # 0x3a90cc
movq %r12, %rdi
movl $0x1247, %edx           # imm = 0x1247
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x109670
callq 0x5e3b4
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
testq %rdi, %rdi
je 0x19aecf
movq %rsi, %r15
testq %rsi, %rsi
je 0x19aecf
movq %rdx, %r14
testq %rdx, %rdx
je 0x19aecf
movl %r8d, %ebp
movq %rdi, %r12
movq (%r12), %r13
cmpq 0x8(%r12), %r13
setb %bl
jae 0x19aea1
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0xec754
testb %al, %al
jne 0x19ae94
incq %r13
jmp 0x19ae74
leaq 0x1(%r13), %rax
movq %rax, (%r12)
movq %r13, 0x10(%rsp)
testb %bl, %bl
jne 0x19aebb
movq %r15, %rdi
movq %r12, %rsi
callq 0xef451
testb %al, %al
jne 0x19ae70
movq 0x8(%rsp), %rax
jmp 0x19aec0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e3ed
// File: /workspace/github_c_makefile_star2_O1/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 0x19cc4e
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x19cbec
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x19cc53
movq 0x18(%rdi), %rdi
movl $0x1, %edx
movl $0x1, %eax
cmpq $0x2, %rdi
jb 0x19cc45
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 0x19cbbf
jmp 0x19cc45
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x19cc58
movq 0x18(%rdi), %rsi
movl $0x1, %edx
movl $0x1, %eax
cmpq $0x2, %rsi
jb 0x19cc45
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 0x19cc1d
cmpq %rax, %rdx
cmovaq %rdx, %rax
popq %rbx
retq
callq 0x5e64a
callq 0x5e5d8
callq 0x5e611
// File: /workspace/github_c_makefile_star2_O1/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 0x19cc92
testq %rsi, %rsi
je 0x19cc92
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 0x5e683
// File: /workspace/github_c_makefile_star2_O1/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 0x19ccbc
cmpq 0x8(%rdi), %rsi
jae 0x19ccbc
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 0x5e6bc
// File: /workspace/github_c_makefile_star2_O1/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 0x104631
cmpq $0x8, %rax
jb 0x19ccf3
xorl %ecx, %ecx
testl %ebx, %ebx
sete %cl
addq $-0x8, %rax
leal 0x7(,%rcx,8), %ecx
testl %ecx, %eax
jne 0x19ccf3
xorl %ecx, %ecx
cmpl $0x1, %ebx
adcb $0x3, %cl
shrq %cl, %rax
popq %rbx
retq
callq 0x5e6f5
// File: /workspace/github_c_makefile_star2_O1/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 0x20c3be(%rip), %rsi    # 0x3a90cc
movl $0x98, %edi
movl $0x41a, %edx            # imm = 0x41A
callq 0x1092b2
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 0x125604
testq %rbx, %rbx
je 0x19cd7e
movq %r15, 0x88(%r14)
leaq 0x20c373(%rip), %rsi    # 0x3a90cc
movl $0x8000, %edi           # imm = 0x8000
movl $0x426, %edx            # imm = 0x426
callq 0x1092b2
movq %rax, 0x80(%r14)
movq $0x0, 0x8(%r14)
movq 0x8(%rsp), %rdi
jmp 0x19cda4
movq %r15, 0x70(%r14)
leaq 0x20c343(%rip), %rsi    # 0x3a90cc
movl $0x10000, %edi          # imm = 0x10000
movl $0x42e, %edx            # imm = 0x42E
callq 0x1092b2
movq %rax, 0x68(%r14)
movq 0x8(%rsp), %rdi
incq %rdi
movq %rdi, 0x10(%r14)
shlq $0x4, %rdi
leaq 0x20c319(%rip), %rsi    # 0x3a90cc
movl $0x434, %edx            # imm = 0x434
callq 0x1092b2
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 0x19d2a2
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x20c2d1(%rip), %rsi    # 0x3a90cc
movl $0x98, %edi
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x1092b2
testq %rbx, %rbx
je 0x19ce93
movq %rax, %r14
movq %rbx, 0x38(%rax)
cmpq $0x0, 0x28(%rbx)
je 0x19ce58
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x19ce98
movq 0x18(%rbx), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x50(%r14)
leaq 0x20(%rbx), %r15
movq 0x20(%rbx), %rdi
shlq $0x4, %rdi
leaq 0x20c283(%rip), %rsi    # 0x3a90cc
movl $0x408, %edx            # imm = 0x408
callq 0x1092b2
movq %rax, (%r14)
jmp 0x19ce6c
movq (%rbx), %rax
testq %rax, %rax
je 0x19ce9d
movq $0x0, 0x50(%r14)
leaq 0x18(%rbx), %r15
movq (%r15), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x40(%r14)
movq 0x28(%rbx), %rax
movq %rax, 0x28(%r14)
movq %r14, %rdi
callq 0x19d2a2
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5e7a0
callq 0x5e72e
callq 0x5e767
// File: /workspace/github_c_makefile_star2_O1/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 0x19ced8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
movq 0x28(%rdi), %rax
je 0x19ced9
testq %rax, %rax
je 0x19cf52
movq (%rbx), %rdi
leaq 0x20c200(%rip), %rsi    # 0x3a90cc
movl $0x452, %edx            # imm = 0x452
callq 0x109670
jmp 0x19cf52
retq
testq %rax, %rax
je 0x19cf18
movq 0x80(%rbx), %rdi
leaq 0x20c1e0(%rip), %r14    # 0x3a90cc
movq %r14, %rsi
movl $0x444, %edx            # imm = 0x444
callq 0x109670
movq 0x88(%rbx), %rdi
callq 0x101e80
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x446, %edx            # imm = 0x446
callq 0x109670
jmp 0x19cf36
movq 0x68(%rbx), %rdi
leaq 0x20c1a9(%rip), %rsi    # 0x3a90cc
movl $0x449, %edx            # imm = 0x449
callq 0x109670
movq 0x70(%rbx), %rdi
callq 0x101e80
movq (%rbx), %rdi
leaq 0x20c18c(%rip), %rsi    # 0x3a90cc
movl $0x44c, %edx            # imm = 0x44C
callq 0x109670
movq $0x0, 0x10(%rbx)
leaq 0x20c173(%rip), %rsi    # 0x3a90cc
movq %rbx, %rdi
movl $0x455, %edx            # imm = 0x455
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670