LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/spmsuftab.c
// Function: gt_spmsuftab_new
GtSpmsuftab *gt_spmsuftab_new(GtUword numofentries,
                              GtUword maxvalue,
                              unsigned int bitsforseqnumrelpos,
                              GtLogger *logger)
{
  GtSpmsuftab *spmsuftab;
  unsigned int bitsforpositions;
  GtUword required;

  spmsuftab = gt_malloc(sizeof (*spmsuftab));
  required = (GtUword) gt_spmsuftab_requiredspace(numofentries,
                                                        maxvalue,
                                                        bitsforseqnumrelpos);
  bitsforpositions = gt_determinebitspervalue(maxvalue);
  if (bitsforpositions < bitsforseqnumrelpos)
  {
    gt_logger_log(logger,"use "GT_WU" bitpackarray-entries for all positions "
                         "(%u bits each,"GT_WU" bytes total)",
                         numofentries,bitsforpositions,required);
    spmsuftab->bitpackarray
      = gt_compact_ulong_store_new(numofentries,bitsforpositions);
    spmsuftab->usebitsforpositions = true;
    spmsuftab->maxvalue = maxvalue;
  } else
  {
    gt_logger_log(logger,"use "GT_WU" bitpackarray-entries for all "
                  "seqnum/relpos-pairs (%u bits each,"GT_WU" bytes total)",
                  numofentries,bitsforseqnumrelpos,required);
    spmsuftab->bitpackarray
      = gt_compact_ulong_store_new(numofentries,bitsforseqnumrelpos);
    spmsuftab->usebitsforpositions = false;
    spmsuftab->maxvalue = (1UL << bitsforseqnumrelpos) - 1;
  }
  spmsuftab->partoffset = 0;
  spmsuftab->numofentries = numofentries;
  return spmsuftab;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x28, %edi
leaq 0x2a020b(%rip), %rsi    # 0x58edce
movl $0x20, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0x2eece0
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xec660
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x2eec54
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rdx
movl 0xc(%rsp), %ecx
movq (%rsp), %r8
leaq 0x2a01ca(%rip), %rsi    # 0x58ede4
movb $0x0, %al
callq 0xe7cd0
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xa1e30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2eecb5
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rdx
movl 0x24(%rsp), %ecx
movq (%rsp), %r8
leaq 0x2a01c5(%rip), %rsi    # 0x58ee32
movb $0x0, %al
callq 0xe7cd0
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xa1e30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x18(%rax)
movl 0x24(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
subq $0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/spmsuftab.c
// Function: gt_spmsuftab_requiredspace
size_t gt_spmsuftab_requiredspace(GtUword numofentries,
                                  GtUword maxvalue,
                                  unsigned int bitsforseqnumrelpos)
{
  unsigned int bitsforpositions = gt_determinebitspervalue(maxvalue);

  return sizeof (GtSpmsuftab) +
         gt_compact_ulong_store_size(numofentries,
                                     GT_MIN(bitsforpositions,
                                            bitsforseqnumrelpos));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0xec660
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x2eed1e
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x2eed26
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0xa1fc0
addq $0x28, %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tagerator.c
// Function: tgr_storematch
static void tgr_storematch(void *processinfo,const GtIdxMatch *match)
{
  ArrayTgrSimplematch *storetab = (ArrayTgrSimplematch *) processinfo;
  TgrSimplematch *simplematch;

  GT_GETNEXTFREEINARRAY(simplematch,storetab,TgrSimplematch,32);
  simplematch->dbstartpos = match->dbstartpos;
  simplematch->matchlength = match->dblen;
  simplematch->rcmatch = ISRCDIR(storetab->twlptr);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2ef83a
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x0, %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2ef8df
movq $0x20, (%rsp)
xorl %eax, %eax
cmpq (%rsp), %rax
jbe 0x2ef89e
movq 0x34c733(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22679c(%rip), %rsi    # 0x516013
leaq 0x229929(%rip), %rdx    # 0x5191a7
leaq 0x29f713(%rip), %rcx    # 0x58ef98
leaq 0x29f5fe(%rip), %r8     # 0x58ee8a
movl $0xcb, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ef8a0
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
imulq $0x18, 0x10(%rax), %rsi
leaq 0x29f5c0(%rip), %rdx    # 0x58ee8a
movl $0xcb, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2ef8e1
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2ef924
movq 0x34c6ad(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x226716(%rip), %rsi    # 0x516013
leaq 0x29f6a3(%rip), %rdx    # 0x58efa7
leaq 0x29f68d(%rip), %rcx    # 0x58ef98
leaq 0x29f578(%rip), %r8     # 0x58ee8a
movl $0xcb, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ef926
jmp 0x2ef928
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
addq $0x8, %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
cmpl $0x0, %eax
setne %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tagerator.c
// Function: showmstats
static void showmstats(void *processinfo,
                       const void *patterninfo,
                       GT_UNUSED GtUword patternstartpos,
                       GtUword mstatlength,
                       GtUword leftbound,
                       GtUword rightbound)
{
  TgrTagwithlength *twl = (TgrTagwithlength *) patterninfo;

  printf(""GT_WU" %c",mstatlength,ISRCDIR(twl) ? '-' : '+');
  if (gt_intervalwidthleq((const Limdfsresources *) processinfo,leftbound,
                       rightbound))
  {
    GtUword idx;
    GtArrayGtUword *mstatspos = gt_fromitv2sortedmatchpositions(
                                  (Limdfsresources *) processinfo,
                                  leftbound,
                                  rightbound,
                                  mstatlength);
    for (idx = 0; idx<mstatspos->nextfreeGtUword; idx++)
    {
      printf(" "GT_WU"",mstatspos->spaceGtUword[idx]);
    }
  }
  printf("\n");
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %ecx
xorl %eax, %eax
cmpq %rdi, %rdx
cmovel %eax, %ecx
movl $0x2b, %edx
movl $0x2d, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
leaq 0x27ffff(%rip), %rdi    # 0x5701b5
movb $0x0, %al
callq 0x19070
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2560d0
testb $0x1, %al
jne 0x2f01d7
jmp 0x2f023c
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x2552f0
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2f023a
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x293001(%rip), %rdi    # 0x583224
movb $0x0, %al
callq 0x19070
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2f01fd
jmp 0x2f023c
leaq 0x2a3030(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tagerator.c
// Function: dotransformtag
static int dotransformtag(GtUchar *transformedtag,
                          const GtUchar *symbolmap,
                          const GtUchar *currenttag,
                          GtUword taglen,
                          uint64_t tagnumber,
                          bool replacewildcard,
                          GtError *err)
{
  GtUword idx;
  GtUchar charcode;

  if (taglen > (GtUword) MAXTAGSIZE)
  {
    gt_error_set(err,"tag \"%*.*s\" of length "GT_WU"; "
                  "tags must not be longer than "GT_WU"",
                   (int) taglen,(int) taglen,currenttag,taglen,
                   (GtUword) MAXTAGSIZE);
    return -1;
  }
  for (idx = 0; idx < taglen; idx++)
  {
    charcode = symbolmap[currenttag[idx]];
    if (charcode == (GtUchar) GT_UNDEFCHAR)
    {
      gt_error_set(err,"undefined character '%c' in tag number " Formatuint64_t,
                currenttag[idx],
                PRINTuint64_tcast(tagnumber));
      return -1;
    }
    if (charcode == (GtUchar) GT_WILDCARD)
    {
      if (replacewildcard)
      {
        charcode = 0;
      } else
      {
        gt_error_set(err,"wildcard in tag number " Formatuint64_t,
                  PRINTuint64_tcast(tagnumber));
        return -1;
      }
    }
    transformedtag[idx] = charcode;
  }
  return 0;
}

// Assembly:
subq $0x58, %rsp
movb %r9b, %al
movq 0x60(%rsp), %r9
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
cmpq $0x40, 0x30(%rsp)
jbe 0x2f02c3
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rax
movl %eax, %edx
movq 0x30(%rsp), %rax
movl %eax, %ecx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
leaq 0x29ee25(%rip), %rsi    # 0x58f0cc
movq $0x40, (%rsp)
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f039c
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x2f0394
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x18(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0xfd, %eax
jne 0x2f0332
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %edx
movq 0x28(%rsp), %rcx
leaq 0x29ede7(%rip), %rsi    # 0x58f108
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f039c
movzbl 0x17(%rsp), %eax
cmpl $0xfe, %eax
jne 0x2f0370
testb $0x1, 0x27(%rsp)
je 0x2f034c
movb $0x0, 0x17(%rsp)
jmp 0x2f036e
movq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x29edd6(%rip), %rsi    # 0x58f133
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f039c
jmp 0x2f0370
movb 0x17(%rsp), %dl
movq 0x48(%rsp), %rax
movq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2f02cc
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tagerator.c
// Function: cmpdescend
static int cmpdescend(const void *a,const void *b)
{
  TgrSimplematch *valuea = (TgrSimplematch *) a;
  TgrSimplematch *valueb = (TgrSimplematch *) b;

  if (!valuea->rcmatch && valueb->rcmatch)
  {
    return -1;
  }
  if (valuea->rcmatch && !valueb->rcmatch)
  {
    return 1;
  }
  if (valuea->dbstartpos < valueb->dbstartpos)
  {
    return 1;
  }
  if (valuea->dbstartpos > valueb->dbstartpos)
  {
    return -1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x2f0b0e
movq -0x28(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x2f0b0e
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f0b6e
movq -0x20(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x2f0b2e
movq -0x28(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x2f0b2e
movl $0x1, -0x4(%rsp)
jmp 0x2f0b6e
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2f0b4a
movl $0x1, -0x4(%rsp)
jmp 0x2f0b6e
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x2f0b66
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f0b6e
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-mappedstr.c
// Function: gt_verifymappedstr
int gt_verifymappedstr(const GtEncseq *encseq,
                       unsigned int prefixlength,
                       GtError *err)
{
  unsigned int numofchars;
  GtArrayGtCodetype codeliststream;
  bool haserr = false;

  gt_error_check(err);
  numofchars = gt_alphabet_num_of_chars(gt_encseq_alphabet(encseq));
  GT_INITARRAY(&codeliststream,GtCodetype);
  if (getfastastreamkmers(gt_encseq_filenames(encseq),
                          numofchars,
                          prefixlength,
                          gt_alphabet_symbolmap(
                                gt_encseq_alphabet(encseq)),
                          false,
                          &codeliststream,
                          err) != 0)
  {
    haserr = true;
  }
  if (!haserr)
  {
    if (verifycodelists(encseq,
                        prefixlength,
                        numofchars,
                        &codeliststream,
                        err) != 0)
    {
      haserr = true;
    }
  }
  GT_FREEARRAY(&codeliststream,GtCodetype);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x1f(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x2f0be7
movq 0x40(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2f0baf
jmp 0x2f0be7
movq 0x34b3ea(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x225453(%rip), %rsi    # 0x516013
leaq 0x2255f8(%rip), %rdx    # 0x5161bf
leaq 0x29e7c0(%rip), %rcx    # 0x58f38e
leaq 0x29e7cc(%rip), %r8     # 0x58f3a1
movl $0x107, %r9d            # imm = 0x107
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f0be9
movq 0x50(%rsp), %rdi
callq 0xb0f00
movq %rax, %rdi
callq 0x7e8c0
movl %eax, 0x3c(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0xb1f80
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0xb0f00
movq %rax, %rdi
callq 0x7e870
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x18(%rsp), %edx
movq %rax, %rcx
movq 0x40(%rsp), %rax
xorl %r8d, %r8d
leaq 0x20(%rsp), %r9
movq %rax, (%rsp)
callq 0x2f0d00
cmpl $0x0, %eax
je 0x2f0c7b
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x2f0caa
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl 0x3c(%rsp), %edx
movq 0x40(%rsp), %r8
leaq 0x20(%rsp), %rcx
callq 0x2f0de0
cmpl $0x0, %eax
je 0x2f0ca8
movb $0x1, 0x1f(%rsp)
jmp 0x2f0caa
jmp 0x2f0cac
cmpq $0x0, 0x20(%rsp)
je 0x2f0ce5
movq 0x20(%rsp), %rdi
leaq 0x29e6e1(%rip), %rsi    # 0x58f3a1
movl $0x120, %edx            # imm = 0x120
callq 0xe88c0
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
jmp 0x2f0ce7
movb 0x1f(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-mappedstr.c
// Function: getfastastreamkmers
static int getfastastreamkmers(const GtStrArray *filenametab,
                               unsigned int numofchars,
                               unsigned int kmersize,
                               const GtUchar *symbolmap,
                               bool plainformat,
                               GtArrayGtCodetype *codeliststream,
                               GtError *err)
{
  GtKmercodeiterator *kmercodeiterator;
  const GtKmercode *kmercodeptr;
  bool haserr = false;

  kmercodeiterator = gt_kmercodeiterator_filetab_new(
                                filenametab,
                                numofchars,
                                kmersize,
                                symbolmap,
                                plainformat,
                                err);
  if (!gt_kmercodeiterator_inputexhausted(kmercodeiterator))
  {
    while (!haserr)
    {
      int retval = gt_kmercodeiterator_filetab_next(&kmercodeptr,
                                                    kmercodeiterator,
                                                    err);
      if (retval < 0)
      {
        haserr = true;
      } else
      {
        if (kmercodeptr != NULL)
        {
          outkmeroccurrence(codeliststream,kmercodeptr);
        } else
        {
          break;
        }
      }
    }
  }
  gt_kmercodeiterator_delete(kmercodeiterator);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x48, %rsp
movb %r8b, %al
movq 0x50(%rsp), %r8
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %r9, 0x20(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movq 0x30(%rsp), %rcx
movb 0x2f(%rsp), %al
movq 0x50(%rsp), %r9
andb $0x1, %al
movzbl %al, %r8d
callq 0x2cb0c0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2cb510
testb $0x1, %al
jne 0x2f0dbc
jmp 0x2f0d69
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f0d75
jmp 0x2f0dba
movq 0x18(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0x2cb350
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x2f0d9b
movb $0x1, 0xf(%rsp)
jmp 0x2f0db8
cmpq $0x0, 0x10(%rsp)
je 0x2f0db4
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f0f30
jmp 0x2f0db6
jmp 0x2f0dba
jmp 0x2f0db8
jmp 0x2f0d69
jmp 0x2f0dbc
movq 0x18(%rsp), %rdi
callq 0x2cb300
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-mappedstr.c
// Function: verifycodelists
static int verifycodelists(const GtEncseq *encseq,
                           unsigned int kmersize,
                           unsigned int numofchars,
                           const GtArrayGtCodetype *codeliststream,
                           GtError *err)
{
  bool haserr = false;
  GtArrayGtCodetype codeliststring;
  const GtUchar *characters;
  GtUword stringtotallength;

  gt_error_check(err);
  stringtotallength = gt_encseq_total_length(encseq);
  characters = gt_alphabet_characters(gt_encseq_alphabet(encseq));
  GT_INITARRAY(&codeliststring,GtCodetype);
  collectkmercode(&codeliststring,
                  encseq,
                  kmersize,
                  numofchars,
                  stringtotallength);
  if (comparecodelists(codeliststream,
                       &codeliststring,
                       kmersize,
                       numofchars,
                       (const char *) characters,
                       err) != 0)
  {
    haserr = true;
  }
  GT_FREEARRAY(&codeliststring,GtCodetype);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x2f0e50
movq 0x38(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2f0e18
jmp 0x2f0e50
movq 0x34b181(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2251ea(%rip), %rsi    # 0x516013
leaq 0x22538f(%rip), %rdx    # 0x5161bf
leaq 0x29e5bb(%rip), %rcx    # 0x58f3f2
leaq 0x29e563(%rip), %r8     # 0x58f3a1
movl $0xe9, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f0e52
movq 0x50(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0xb0f00
movq %rax, %rdi
callq 0x7e970
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x50(%rsp), %rsi
movl 0x4c(%rsp), %edx
movl 0x48(%rsp), %ecx
movq 0x8(%rsp), %r8
leaq 0x18(%rsp), %rdi
callq 0x2f1070
movq 0x40(%rsp), %rdi
movl 0x4c(%rsp), %edx
movl 0x48(%rsp), %ecx
movq 0x10(%rsp), %r8
movq 0x38(%rsp), %r9
leaq 0x18(%rsp), %rsi
callq 0x2f1200
cmpl $0x0, %eax
je 0x2f0eda
movb $0x1, 0x37(%rsp)
jmp 0x2f0edc
cmpq $0x0, 0x18(%rsp)
je 0x2f0f15
movq 0x18(%rsp), %rdi
leaq 0x29e4b1(%rip), %rsi    # 0x58f3a1
movl $0xfb, %edx
callq 0xe88c0
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
jmp 0x2f0f17
movb 0x37(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-mappedstr.c
// Function: collectkmercode
static void collectkmercode(GtArrayGtCodetype *codelist,
                            const GtEncseq *encseq,
                            unsigned int kmersize,
                            unsigned int numofchars,
                            GtUword stringtotallength)
{
  GtUword offset;
  GtCodetype code;

  for (offset=0; offset<=stringtotallength; offset++)
  {
    code = qgram2codefillspecial(numofchars,
                                 kmersize,
                                 encseq,
                                 GT_READMODE_FORWARD,
                                 offset,
                                 stringtotallength);
    GT_STOREINARRAY(codelist,GtCodetype,1024,code);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x2f11f4
movl 0x20(%rsp), %edi
movl 0x24(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
xorl %ecx, %ecx
callq 0x2f1460
movq %rax, 0x8(%rsp)
jmp 0x2f10c9
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x0, %rax
movq 0x30(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x2f1171
movq $0x400, (%rsp)          # imm = 0x400
xorl %eax, %eax
cmpq (%rsp), %rax
jbe 0x2f112d
movq 0x34aea4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x224f0d(%rip), %rsi    # 0x516013
leaq 0x22809a(%rip), %rdx    # 0x5191a7
leaq 0x29e2ee(%rip), %rcx    # 0x58f402
leaq 0x29e286(%rip), %r8     # 0x58f3a1
movl $0x7d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f112f
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
leaq 0x29e245(%rip), %rdx    # 0x58f3a1
movl $0x7d, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2f1173
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2f11b6
movq 0x34ae1b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x224e84(%rip), %rsi    # 0x516013
leaq 0x29e238(%rip), %rdx    # 0x58f3ce
leaq 0x29e265(%rip), %rcx    # 0x58f402
leaq 0x29e1fd(%rip), %r8     # 0x58f3a1
movl $0x7d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f11b8
jmp 0x2f11ba
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rsi
movq 0x10(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x2f11e1
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2f1094
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_samplesubstring
static GtUword gt_samplesubstring(bool replacespecialchars,
                                  GtUchar *seqspace,
                                  const GtEncseq *encseq,
                                  GtUword substringlength)
{
  GtUword start, totallength = gt_encseq_total_length(encseq);

  start = (GtUword) (random() % totallength);
  if (start + substringlength > totallength)
  {
    substringlength = totallength - start;
  }
  gt_assert(substringlength > 0);
  gt_encseq_extract_encoded(encseq,seqspace,start,start+substringlength-1);
  if (replacespecialchars)
  {
    GtUword idx;
    const unsigned int numofchars = gt_encseq_alphabetnumofchars(encseq);

    for (idx = 0; idx < substringlength; idx++)
    {
      if (GT_ISSPECIAL(seqspace[idx]))
      {
        seqspace[idx] = (GtUchar) (random() % numofchars);
      }
    }
  }
  return substringlength;
}

// Assembly:
subq $0x48, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x18(%rsp)
callq 0x127e80
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq 0x28(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x2f1dc5
movq 0x18(%rsp), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x2f1dc7
cmpq $0x0, 0x28(%rsp)
ja 0x2f1e07
movq 0x34a1ca(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x224233(%rip), %rsi    # 0x516013
leaq 0x29d7c8(%rip), %rdx    # 0x58f5af
leaq 0x29d7d5(%rip), %rcx    # 0x58f5c3
leaq 0x29d6b8(%rip), %r8     # 0x58f4ad
movl $0x53, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f1e09
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x20(%rsp), %rcx
addq 0x28(%rsp), %rcx
subq $0x1, %rcx
callq 0xac280
testb $0x1, 0x47(%rsp)
je 0x2f1ea0
movq 0x30(%rsp), %rdi
callq 0xb0e80
movl %eax, 0xc(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2f1e9e
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xfe, %eax
jl 0x2f1e8c
callq 0x127e80
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl 0xc(%rsp), %ecx
cqto
idivq %rcx
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x2f1e8e
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2f1e49
jmp 0x2f1ea0
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_storemaxmatchquery
static void gt_storemaxmatchquery(void *info, const GtQuerymatch *querymatch)
{
  GtArray *tab = (GtArray *) info;
  Substringmatch subm;
  GtUword query_seqlen, query_seqstart;

  subm.len = gt_querymatch_querylen(querymatch);
  subm.dbstart = gt_querymatch_dbstart(querymatch);
  subm.querystart = gt_querymatch_querystart(querymatch);
  gt_querymatch_query_coordinates(&subm.queryseqnum,&query_seqstart,
                                  &query_seqlen, querymatch);
  gt_array_add(tab,subm);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2676a0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2676b0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2676f0
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x38(%rsp), %rcx
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
callq 0x267750
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x20, %edx
callq 0x81100
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_sequence2markpositions
static GtUword *gt_sequence2markpositions(GtUword *numofsequences,
                                          const GtUchar *seq,
                                          GtUword seqlen)
{
  GtUword *spacemarkpos, idx, allocatedmarkpos, nextfreemarkpos;

  *numofsequences = 1UL;
  for (idx=0; idx<seqlen; idx++)
  {
    if (seq[idx] == (GtUchar) GT_SEPARATOR)
    {
      (*numofsequences)++;
    }
  }
  if (*numofsequences == 1UL)
  {
    return NULL;
  }
  allocatedmarkpos = (*numofsequences)-1;
  spacemarkpos = gt_malloc(sizeof *spacemarkpos * allocatedmarkpos);
  for (idx=0, nextfreemarkpos = 0; idx<seqlen; idx++)
  {
    if (seq[idx] == (GtUchar) GT_SEPARATOR)
    {
      spacemarkpos[nextfreemarkpos++] = idx;
    }
  }
  return spacemarkpos;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq $0x1, (%rax)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2f1f9a
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jne 0x2f1f88
movq 0x38(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2f1f8a
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2f1f58
movq 0x38(%rsp), %rax
cmpq $0x1, (%rax)
jne 0x2f1fb3
movq $0x0, 0x40(%rsp)
jmp 0x2f2051
movq 0x38(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
shlq $0x3, %rdi
leaq 0x29d4d9(%rip), %rsi    # 0x58f4ad
movl $0x103, %edx            # imm = 0x103
callq 0xe80f0
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2f2047
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jne 0x2f2035
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rsp)
movq %rdx, (%rax,%rcx,8)
jmp 0x2f2037
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2f1ff5
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_constructsarrandrunmaxpairs
static int gt_constructsarrandrunmaxpairs(GtUchar *dbseqquery,
                                          GtUword dbseqquerylen,
                                          GtReadmode readmode,
                                          unsigned int searchlength,
                                          unsigned int numofchars,
                                          GtProcessmaxpairs processmaxpairs,
                                          void *processmaxpairsinfo,
                                          GtError *err)
{
  bool haserr = false;
  GtSainSufLcpIterator *suflcpiterator;

  suflcpiterator = gt_sain_suf_lcp_iterator_new(true,
                                                dbseqquery,
                                                dbseqquerylen,
                                                readmode,
                                                (GtUword) numofchars,
                                                err);
  if (suflcpiterator == NULL)
  {
    haserr = true;
  } else
  {
    if (gt_enumeratemaxpairs_sain(suflcpiterator,
                                  searchlength,
                                  processmaxpairs,
                                  processmaxpairsinfo,
                                  err) != 0)
    {
      haserr = true;
    }
  }
  gt_sain_suf_lcp_iterator_delete(suflcpiterator);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movq %r9, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
movl 0x1c(%rsp), %eax
movl %eax, %r8d
movq 0x48(%rsp), %r9
movl $0x1, %edi
callq 0x2d1b70
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2f20c5
movb $0x1, 0xf(%rsp)
jmp 0x2f20ed
movq (%rsp), %rdi
movl 0x20(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
callq 0x235f70
cmpl $0x0, %eax
je 0x2f20eb
movb $0x1, 0xf(%rsp)
jmp 0x2f20ed
movq (%rsp), %rdi
callq 0x2d1df0
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_orderSubstringmatch
static int gt_orderSubstringmatch(const void *a,const void *b)
{
  Substringmatch *m1 = (Substringmatch *) a,
                 *m2 = (Substringmatch *) b;

  if (m1->queryseqnum < m2->queryseqnum)
  {
    return -1;
  }
  if (m1->queryseqnum > m2->queryseqnum)
  {
    return 1;
  }
  if (m1->querystart < m2->querystart)
  {
    return -1;
  }
  if (m1->querystart > m2->querystart)
  {
    return 1;
  }
  if (m1->dbstart < m2->dbstart)
  {
    return -1;
  }
  if (m1->dbstart > m2->dbstart)
  {
    return 1;
  }
  if (m1->len < m2->len)
  {
    return -1;
  }
  if (m1->len > m2->len)
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x2f22ef
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f23cb
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x2f2310
movl $0x1, -0x4(%rsp)
jmp 0x2f23cb
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2f2331
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f23cb
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2f234f
movl $0x1, -0x4(%rsp)
jmp 0x2f23cb
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2f236d
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f23cb
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x2f238b
movl $0x1, -0x4(%rsp)
jmp 0x2f23cb
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2f23a7
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f23cb
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x2f23c3
movl $0x1, -0x4(%rsp)
jmp 0x2f23cb
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_showSubstringmatch
static int gt_showSubstringmatch(void *a, GT_UNUSED void *info,
                                 GT_UNUSED GtError *err)
{
  Substringmatch *m = (Substringmatch *) a;

  printf(GT_WU " " GT_WU " " GT_WU " " GT_WU "\n",
         m->len,
         m->dbstart,
         m->queryseqnum,
         m->querystart);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %r8
leaq 0x284500(%rip), %rdi    # 0x576917
movb $0x0, %al
callq 0x19070
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-mergeesa.c
// Function: gt_performtheindexmerging
int gt_performtheindexmerging(const GtStr *storeindex,
                           const GtStrArray *indexnametab,
                           GtLogger *logger,
                           GtError *err)
{
  Emissionmergedesa emmesa;
  unsigned int demand = SARR_ESQTAB | SARR_SUFTAB | SARR_LCPTAB;
  bool haserr = false;

  gt_error_check(err);
  if (gt_emissionmergedesa_init(&emmesa,
                             indexnametab,
                             demand,
                             logger,
                             err) != 0)
  {
    haserr = true;
  }
  if (!haserr)
  {
    if (gt_str_array_size(indexnametab) > 1UL)
    {
      if (mergeandstoreindex(storeindex,&emmesa,err) != 0)
      {
        haserr = true;
      }
    } else
    {
      gt_error_set(err,"merging requires more than one index");
      haserr = true;
    }
  }
  gt_emissionmergedesa_wrap(&emmesa);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x30098, %rsp          # imm = 0x30098
movq %rdi, 0x30090(%rsp)
movq %rsi, 0x30088(%rsp)
movq %rdx, 0x30080(%rsp)
movq %rcx, 0x30078(%rsp)
movl $0x7, 0xc(%rsp)
movb $0x0, 0xb(%rsp)
cmpq $0x0, 0x30078(%rsp)
je 0x2f24ba
movq 0x30078(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2f2482
jmp 0x2f24ba
movq 0x349b17(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x223b80(%rip), %rsi    # 0x516013
leaq 0x223d25(%rip), %rdx    # 0x5161bf
leaq 0x29d135(%rip), %rcx    # 0x58f5d6
leaq 0x29d148(%rip), %r8     # 0x58f5f0
movl $0xd0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f24bc
movq 0x30088(%rsp), %rsi
movl 0xc(%rsp), %edx
movq 0x30080(%rsp), %rcx
movq 0x30078(%rsp), %r8
leaq 0x10(%rsp), %rdi
callq 0x4b6b50
cmpl $0x0, %eax
je 0x2f24ec
movb $0x1, 0xb(%rsp)
testb $0x1, 0xb(%rsp)
jne 0x2f2549
movq 0x30088(%rsp), %rdi
callq 0x11fcc0
cmpq $0x1, %rax
jbe 0x2f252c
movq 0x30090(%rsp), %rdi
movq 0x30078(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x2f2570
cmpl $0x0, %eax
je 0x2f252a
movb $0x1, 0xb(%rsp)
jmp 0x2f2547
movq 0x30078(%rsp), %rdi
leaq 0x29d0cf(%rip), %rsi    # 0x58f60a
movb $0x0, %al
callq 0xd88c0
movb $0x1, 0xb(%rsp)
jmp 0x2f2549
leaq 0x10(%rsp), %rdi
callq 0x4b70b0
movb 0xb(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x30098, %rsp          # imm = 0x30098
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-mergeesa.c
// Function: initNameandFILE
static int initNameandFILE(NameandFILE *nf,
                            const GtStr *outindex,
                            const char *suffix,
                            GtError *err)
{
  gt_error_check(err);
  nf->outfilename = gt_str_clone(outindex);
  gt_str_append_cstr(nf->outfilename,suffix);
  nf->fp = gt_fa_fopen(gt_str_get(nf->outfilename),"wb",err);
  if (nf->fp == NULL)
  {
    return -1;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, (%rsp)
je 0x2f28b5
movq (%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2f287d
jmp 0x2f28b5
movq 0x34971c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x223785(%rip), %rsi    # 0x516013
leaq 0x22392a(%rip), %rdx    # 0x5161bf
leaq 0x29cdc2(%rip), %rcx    # 0x58f65e
leaq 0x29cd4d(%rip), %r8     # 0x58f5f0
movl $0x36, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f28b7
movq 0x10(%rsp), %rdi
callq 0x11e280
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11d550
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
movq (%rsp), %r8
leaq 0x2342a4(%rip), %rsi    # 0x526b9d
leaq 0x29ccf0(%rip), %rdx    # 0x58f5f0
movl $0x39, %ecx
callq 0xd8df0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2f292c
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f2934
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-mtrieins.c
// Function: successivelydeletesmallest
static void successivelydeletesmallest(Mergertrierep *trierep,
                                       GT_UNUSED GtUword seqlen,
                                       GT_UNUSED const GtUchar *characters,
                                       GT_UNUSED GtError *err)
{
  Mergertrienode *smallest;
#ifdef WITHTRIEIDENT
  unsigned int numberofleaves = (unsigned int) seqlen+1;
  unsigned int maxleafnum = (unsigned int) seqlen;
#endif

  while (trierep->root != NULL && trierep->root->firstchild != NULL)
  {
    smallest = gt_mergertrie_findsmallestnode(trierep);
    gt_mergertrie_deletesmallestpath(smallest,trierep);
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
    showtrie(trierep,characters);
#endif
    numberofleaves--;
    checktrie(trierep,numberofleaves,maxleafnum,err);
#endif
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, 0xf(%rsp)
je 0x2f2daf
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2f2db9
jmp 0x2f2dd9
movq 0x30(%rsp), %rdi
callq 0x4d2b20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x4d2bb0
jmp 0x2f2d88
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctionontwofiles
void gt_runcheckfunctionontwofiles(Checkcmppairfuntype checkfunction,
                                   const char *file1,
                                   const char *file2)
{
  const GtUchar *useq = NULL, *vseq = NULL;
  size_t ulen, vlen;
  bool forward = true;
  GtError *err;

  err = gt_error_new();
  useq = (const GtUchar *) gt_fa_mmap_read(file1,&ulen,err);
  if (useq == NULL)
  {
    fprintf(stderr, "error: %s\n", gt_error_get(err));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  vseq = (const GtUchar *) gt_fa_mmap_read(file2,&vlen,err);
  if (vseq == NULL)
  {
    fprintf(stderr, "error: %s\n", gt_error_get(err));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_error_delete(err);
  while (true)
  {
    checkfunction(forward,useq,(GtUword) ulen,
                          vseq,(GtUword) vlen);
    if (!forward)
    {
      break;
    }
    forward = false;
  }
  gt_fa_xmunmap((void *) useq);
  gt_fa_xmunmap((void *) vseq);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x1, 0x1f(%rsp)
callq 0xd88a0
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %r8
leaq 0x28(%rsp), %rsi
leaq 0x29c87e(%rip), %rdx    # 0x58f6a8
movl $0x27, %ecx
callq 0xda4d0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x2f2e7a
movq 0x349158(%rip), %rax    # 0x63bfa0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xd8b20
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x22319f(%rip), %rsi    # 0x516008
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %r8
leaq 0x20(%rsp), %rsi
leaq 0x29c818(%rip), %rdx    # 0x58f6a8
movl $0x2d, %ecx
callq 0xda4d0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x2f2ede
movq 0x3490f2(%rip), %rax    # 0x63bfa0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xd8b20
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x22313b(%rip), %rsi    # 0x516008
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x10(%rsp), %rdi
callq 0xd8c80
movq 0x50(%rsp), %rax
movb 0x1f(%rsp), %dil
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %r8
andb $0x1, %dil
movzbl %dil, %edi
callq *%rax
testb $0x1, 0x1f(%rsp)
jne 0x2f2f19
jmp 0x2f2f20
movb $0x0, 0x1f(%rsp)
jmp 0x2f2ee8
movq 0x38(%rsp), %rdi
callq 0xdb2a0
movq 0x30(%rsp), %rdi
callq 0xdb2a0
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctionontext
GtUword gt_runcheckfunctionontext(Checkcmppairfuntype checkfunction,
                                     const char *text)
{
  GtUword i, len;

  len = (GtUword) strlen(text);
  for (i=1UL; i<=len/2; i++)
  {
    checkfunction(true,
                  (const GtUchar *) text,
                  i,
                  (const GtUchar *) (text+i),
                  len-i);
  }
  return len/2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x192b0
movq %rax, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
shrq %rcx
cmpq %rcx, %rax
ja 0x2f2fb2
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
subq 0x10(%rsp), %r8
movl $0x1, %edi
callq *%rax
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2f2f66
movq 0x8(%rsp), %rax
shrq %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_applycheckfunctiontotext
GtUword gt_applycheckfunctiontotext(const GtUchar *text,
                                       GtUword textlen,
                                       void *info)
{
  GtUword i;
  Checkcmppairfuntype checkfunction = (Checkcmppairfuntype) info;

#ifdef SKDEBUG
  printf("%s\n",(char *) text);
#endif
  for (i=0; i<=textlen/2; i++)
  {
    checkfunction(true,text,i,text+i,textlen-i);
  }
  return textlen/2+1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq %rcx
cmpq %rcx, %rax
ja 0x2f3030
movq (%rsp), %rax
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
addq 0x8(%rsp), %rcx
movq 0x18(%rsp), %r8
subq 0x8(%rsp), %r8
movl $0x1, %edi
callq *%rax
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2f2fe5
movq 0x18(%rsp), %rax
shrq %rax
addq $0x1, %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctiononalphalen
GtUword gt_runcheckfunctiononalphalen(Checkcmppairfuntype checkfunction,
                                         const char *charlist,
                                         GtUword len)
{
  return applyall(charlist,
                  len,
                  (void *) checkfunction,
                  gt_applycheckfunctiontotext);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq -0xb7(%rip), %rcx       # 0x2f2fc0
callq 0x2f3090
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_computegreedyunitedist
GtUword gt_computegreedyunitedist(const GtUchar *useq,
                                        GtUword ulen,
                                        const GtUchar *vseq,
                                        GtUword vlen)
{
  GtUword edist;
  bool rightextension = true;
  GtFrontResource *frontresource = gt_frontresource_new(10UL);
  GtSeqabstract *greedyedistuseq, *greedyedistvseq;

  greedyedistuseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 useq,ulen,0,ulen);
  greedyedistvseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 vseq,vlen,0,vlen);
  edist = greedyunitedist(frontresource,greedyedistuseq,greedyedistvseq);
  gt_seqabstract_delete(greedyedistuseq);
  gt_seqabstract_delete(greedyedistvseq);
  gt_frontresource_delete(frontresource);
  return edist;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movb $0x1, 0x1f(%rsp)
movl $0xa, %edi
callq 0x253810
movq %rax, 0x10(%rsp)
movb 0x1f(%rsp), %al
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x38(%rsp), %r9
xorl %esi, %esi
xorl %edi, %edi
movl %edi, %r8d
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0b50
movq %rax, 0x8(%rsp)
movb 0x1f(%rsp), %al
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x28(%rsp), %r9
xorl %esi, %esi
xorl %edi, %edi
movl %edi, %r8d
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0b50
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2538e0
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2b0d20
movq (%rsp), %rdi
callq 0x2b0d20
movq 0x10(%rsp), %rdi
callq 0x2538a0
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)