LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/marksubstring.c
// Function: gt_marksubstring_delete
void gt_marksubstring_delete(Gtmarksubstring *mark,bool withbits)
{
  if (mark != NULL)
  {
    if (withbits)
    {
      gt_free(mark->bits);
    }
    gt_free(mark);
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x261071
testb $0x1, 0xf(%rsp)
je 0x26105b
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x31b06f(%rip), %rsi    # 0x57c0c0
movl $0x35, %edx
callq 0xe88c0
movq 0x10(%rsp), %rdi
leaq 0x31b059(%rip), %rsi    # 0x57c0c0
movl $0x37, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/marksubstring.c
// Function: gt_marksubstring_mark
void gt_marksubstring_mark(Gtmarksubstring *mark,GtCodetype code)
{
  code = (code >> (GtCodetype) mark->shiftright) & mark->mask;

  gt_assert(code < mark->entries);
  if (!GT_ISIBITSET(mark->bits,code))
  {
    GT_SETIBIT(mark->bits,code);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
shrq %cl, %rax
movq 0x10(%rsp), %rcx
andq 0x18(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2610f4
movq 0x3daedd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b4f46(%rip), %rsi    # 0x516013
leaq 0x31b02d(%rip), %rdx    # 0x57c101
leaq 0x31b03b(%rip), %rcx    # 0x57c116
leaq 0x31afde(%rip), %r8     # 0x57c0c0
movl $0x3f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2610f6
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x26115e
movq 0x8(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/marksubstring.c
// Function: gt_marksubstring_bits_null
void gt_marksubstring_bits_null(GT_UNUSED const Gtmarksubstring *mark,bool null)
{
  if (null)
  {
    gt_assert(mark->bits == NULL);
  } else
  {
    gt_assert(mark->bits != NULL);
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x261273
jmp 0x26122b
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x26126f
movq 0x3dad62(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b4dcb(%rip), %rsi    # 0x516013
leaq 0x31aedd(%rip), %rdx    # 0x57c12c
leaq 0x31aee9(%rip), %rcx    # 0x57c13f
leaq 0x31ae63(%rip), %r8     # 0x57c0c0
movl $0x60, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x261271
jmp 0x2612bd
jmp 0x261275
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2612b9
movq 0x3dad18(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b4d81(%rip), %rsi    # 0x516013
leaq 0x31aec1(%rip), %rdx    # 0x57c15a
leaq 0x31ae9f(%rip), %rcx    # 0x57c13f
leaq 0x31ae19(%rip), %r8     # 0x57c0c0
movl $0x63, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2612bb
jmp 0x2612bd
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/optionargmode.c
// Function: gt_optionargaddbitmask
int gt_optionargaddbitmask(const Optionargmodedesc *modedesc,
                           size_t numberofentries,
                           unsigned int *mode,
                           const char *optname,
                           const char *optionargument,
                           GtError *err)
{
  size_t modecount;

  gt_error_check(err);
  for (modecount=0; modecount < numberofentries; modecount++)
  {
    if (strcmp(optionargument,modedesc[modecount].name) == 0)
    {
      if (*mode & modedesc[modecount].bitmask)
      {
        gt_error_set(err,"argument \"%s\" to option %s already specified",
                      modedesc[modecount].name,optname);
        return -1;
      }
      *mode |= modedesc[modecount].bitmask;
      return 0;
    }
  }
  gt_error_set(err,"illegal argument \"%s\" to option %s",
                optionargument,optname);
  return -2;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x261372
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x26133a
jmp 0x261372
movq 0x3dac5f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b4cc8(%rip), %rsi    # 0x516013
leaq 0x2b4e6d(%rip), %rdx    # 0x5161bf
leaq 0x31ae14(%rip), %rcx    # 0x57c16d
leaq 0x31ae24(%rip), %r8     # 0x57c184
movl $0x1f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x261374
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x261436
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
imulq $0x18, 0x8(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x19980
cmpl $0x0, %eax
jne 0x261421
movq 0x28(%rsp), %rax
movl (%rax), %eax
movq 0x38(%rsp), %rcx
imulq $0x18, 0x8(%rsp), %rdx
addq %rdx, %rcx
andl 0x10(%rcx), %eax
cmpl $0x0, %eax
je 0x2613fd
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
imulq $0x18, 0x8(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq 0x20(%rsp), %rcx
leaq 0x31adb2(%rip), %rsi    # 0x57c19e
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x26145b
movq 0x38(%rsp), %rax
imulq $0x18, 0x8(%rsp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
movq 0x28(%rsp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movl $0x0, 0x44(%rsp)
jmp 0x26145b
jmp 0x261423
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x26137d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
leaq 0x31ad7f(%rip), %rsi    # 0x57c1cb
movb $0x0, %al
callq 0xd88c0
movl $0xfffffffe, 0x44(%rsp) # imm = 0xFFFFFFFE
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/optionargmode.c
// Function: gt_optionargsetsingle
int gt_optionargsetsingle(const Optionargmodedesc *modedesc,
                          size_t numberofentries,
                          const char *optname,
                          const char *optionargument,
                          GtError *err)
{
  size_t modecount;

  gt_error_check(err);
  for (modecount=0; modecount < numberofentries; modecount++)
  {
    if (strcmp(optionargument,modedesc[modecount].name) == 0)
    {
      return (int) modedesc[modecount].bitmask;
    }
  }
  gt_error_set(err,"illegal argument \"%s\" to option %s",
                optionargument,optname);
  return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2614dd
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2614a5
jmp 0x2614dd
movq 0x3daaf4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b4b5d(%rip), %rsi    # 0x516013
leaq 0x2b4d02(%rip), %rdx    # 0x5161bf
leaq 0x31ad2a(%rip), %rcx    # 0x57c1ee
leaq 0x31acb9(%rip), %r8     # 0x57c184
movl $0x3b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2614df
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x261537
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
imulq $0x18, (%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x19980
cmpl $0x0, %eax
jne 0x261527
movq 0x28(%rsp), %rax
imulq $0x18, (%rsp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x26155c
jmp 0x261529
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2614e7
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x31ac7e(%rip), %rsi    # 0x57c1cb
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/optionargmode.c
// Function: gt_getsetargmodekeywords
void gt_getsetargmodekeywords(const Optionargmodedesc *modedesc,
                              size_t numberofentries,
                              unsigned int bitfield)
{
  size_t modecount;

  for (modecount=0; modecount < numberofentries; modecount++)
  {
    if (bitfield & modedesc[modecount].bitmask)
    {
      printf("%s ",modedesc[modecount].name);
    }
  }
  printf("\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2617a2
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
imulq $0x18, 0x8(%rsp), %rdx
addq %rdx, %rcx
andl 0x10(%rcx), %eax
cmpl $0x0, %eax
je 0x261790
movq 0x20(%rsp), %rax
imulq $0x18, 0x8(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x33bd13(%rip), %rdi    # 0x59d49c
movb $0x0, %al
callq 0x19070
jmp 0x261792
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x26174b
leaq 0x331aca(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pckbucket.c
// Function: gt_pckbuckettable_delete
void gt_pckbuckettable_delete(Pckbuckettable *pckbt)
{
  gt_assert(pckbt != NULL);
  if (pckbt->mapptr == NULL)
  {
    gt_free(pckbt->mbtab[0]);
  } else
  {
    gt_fa_xmunmap(pckbt->mapptr);
  }
  pckbt->mbtab[0] = NULL;
  gt_free(pckbt->mbtab);
  pckbt->mbtab = NULL;
  gt_free(pckbt->basepower);
  pckbt->basepower = NULL;
  gt_free(pckbt);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x261804
movq 0x3da7cd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b4836(%rip), %rsi    # 0x516013
leaq 0x31ac3d(%rip), %rdx    # 0x57c421
leaq 0x31aa55(%rip), %rcx    # 0x57c240
leaq 0x31aa67(%rip), %r8     # 0x57c259
movl $0x5f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x261806
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x26182f
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x31aa36(%rip), %rsi    # 0x57c259
movl $0x62, %edx
callq 0xe88c0
jmp 0x26183c
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xdb2a0
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x31a9ff(%rip), %rsi    # 0x57c259
movl $0x68, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x31a9da(%rip), %rsi    # 0x57c259
movl $0x6a, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rdi
leaq 0x31a9b9(%rip), %rsi    # 0x57c259
movl $0x6c, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pckbucket.c
// Function: pckbuckettable_allocandinittable
static Pckbuckettable *pckbuckettable_allocandinittable(unsigned int numofchars,
                                                        unsigned int maxdepth,
                                                        bool writemode)
{
  Mbtab *cptr;
  unsigned int idx;
  Pckbuckettable *pckbt;

  pckbt = gt_malloc(sizeof (Pckbuckettable));
  pckbt->basepower = gt_initbasepower(numofchars,maxdepth);
  pckbt->numofchars = numofchars;
  pckbt->maxdepth = maxdepth;
  pckbt->maxnumofvalues = pckbt->numofvalues = 0;
  for (idx=0; idx <= maxdepth; idx++)
  {
    /*printf("basepower[%u]="GT_WU"\n",idx,pckbt->basepower[idx]); */
    pckbt->maxnumofvalues += pckbt->basepower[idx];
  }
  pckbt->mbtab = gt_malloc(sizeof (Mbtab *) * (maxdepth+1));
  if (writemode)
  {
    pckbt->mapptr = NULL;
    pckbt->mbtab[0] = gt_malloc(sizeof (Mbtab) * pckbt->maxnumofvalues);
    /*
    printf("allocated = %u * "GT_WU"\n",sizeof (Mbtab),pckbt->maxnumofvalues);
    */
    for (cptr = pckbt->mbtab[0];
         cptr < pckbt->mbtab[0] + pckbt->maxnumofvalues; cptr++)
    {
      cptr->lowerbound = cptr->upperbound = 0;
    }
    pckbuckettable_settaboffsets(pckbt);
  }
  return pckbt;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movl $0x30, %edi
leaq 0x31a319(%rip), %rsi    # 0x57c259
movl $0x41, %edx
callq 0xe80f0
movq %rax, (%rsp)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x25d6c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movl 0x24(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movl 0x20(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x20(%rsp), %eax
ja 0x261fce
movq (%rsp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq (%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x261f9b
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x31a275(%rip), %rsi    # 0x57c259
movl $0x4b, %edx
callq 0xe80f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
testb $0x1, 0x1f(%rsp)
je 0x2620a1
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
shlq $0x4, %rdi
leaq 0x31a236(%rip), %rsi    # 0x57c259
movl $0x4f, %edx
callq 0xe80f0
movq %rax, %rcx
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rcx
movq (%rsp), %rdx
movq 0x10(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x262098
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x26204b
movq (%rsp), %rdi
callq 0x262700
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pckbucket.c
// Function: pckbuckettable_followleafedge
static void pckbuckettable_followleafedge(Pckbuckettable *pckbt,
                                          const FMindex *fmindex,
                                          const Pckbck_Boundsatdepth *bd)
{
  Bwtseqcontextiterator *bsci;
  GtUchar cc;
  Pckbck_Boundsatdepth bdleaf;

  gt_assert(bd != NULL);
  bdleaf.code = bd->code;
  bdleaf.depth = bd->depth;
  bdleaf.lowerbound = bd->lowerbound;
  bsci = gt_Bwtseqcontextiterator_new(fmindex,bdleaf.lowerbound);
  while (bdleaf.depth < pckbt->maxdepth)
  {
    bdleaf.depth++;
    cc = gt_Bwtseqcontextiterator_next(&bdleaf.lowerbound,bsci);
    if (GT_ISSPECIAL(cc))
    {
      break;
    }
    bdleaf.code = bdleaf.code * pckbt->numofchars + cc;
    bdleaf.upperbound = bdleaf.lowerbound+1;
    pckbuckettable_storeBoundsatdepth(pckbt,&bdleaf);
  }
  gt_Bwtseqcontextiterator_delete(bsci);
  bsci = NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x262363
movq 0x3d9c6e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b3cd7(%rip), %rsi    # 0x516013
leaq 0x307252(%rip), %rdx    # 0x569595
leaq 0x31a1de(%rip), %rcx    # 0x57c528
leaq 0x319f08(%rip), %r8     # 0x57c259
movl $0x88, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x262365
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movq (%rsp), %rsi
callq 0x22f720
movq %rax, 0x28(%rsp)
movl 0x10(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x26240f
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq %rsp, %rdi
movq 0x28(%rsp), %rsi
callq 0x22f7e0
movb %al, 0x27(%rsp)
movzbl 0x27(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2623d6
jmp 0x26240f
movq 0x18(%rsp), %rax
movq 0x40(%rsp), %rcx
movl (%rcx), %ecx
imulq %rcx, %rax
movzbl 0x27(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x2620b0
jmp 0x26239e
movq 0x28(%rsp), %rdi
callq 0x22fa60
movq $0x0, 0x28(%rsp)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pckbucket.c
// Function: gt_pckbuckettable_2file
int gt_pckbuckettable_2file(const char *indexname,
                            const Pckbuckettable *pckbuckettable,
                            GtError *err)
{
  FILE *fp;
  GtUword seqposmaxdepth;

  gt_error_check(err);
  fp = gt_fa_fopen_with_suffix(indexname,PCKBUCKETTABLE,"wb",err);
  if (fp == NULL)
  {
    return -1;
  }
  seqposmaxdepth = (GtUword) pckbuckettable->maxdepth;
  gt_xfwrite(&seqposmaxdepth,sizeof (GtUword),(size_t) 1,fp);
  gt_xfwrite(pckbuckettable->mbtab[0],sizeof (Mbtab),
             (size_t) pckbuckettable->maxnumofvalues,fp);
  gt_fa_fclose(fp);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x262493
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x26245b
jmp 0x262493
movq 0x3d9b3e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b3ba7(%rip), %rsi    # 0x516013
leaq 0x2b3d4c(%rip), %rdx    # 0x5161bf
leaq 0x319eab(%rip), %rcx    # 0x57c325
leaq 0x319dd8(%rip), %r8     # 0x57c259
movl $0xe1, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x262495
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %r9
leaq 0x319e97(%rip), %rsi    # 0x57c33d
leaq 0x2c46f0(%rip), %rdx    # 0x526b9d
leaq 0x319da5(%rip), %rcx    # 0x57c259
movl $0xe2, %r8d
callq 0xd92c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2624d6
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x262532
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x10, %esi
callq 0x126d30
movq 0x10(%rsp), %rdi
callq 0xd9390
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pckbucket.c
// Function: gt_pckbuckettable_exists
bool gt_pckbuckettable_exists(const char *indexname)
{
  GtStr *tmpfilename;
  bool retval;

  tmpfilename = gt_str_new_cstr(indexname);
  gt_str_append_cstr(tmpfilename,PCKBUCKETTABLE);
  retval = gt_file_exists(gt_str_get(tmpfilename));
  gt_str_delete(tmpfilename);
  return retval;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11d510
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x319dd9(%rip), %rsi    # 0x57c33d
callq 0x11d550
movq 0x8(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
callq 0xde820
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rdi
callq 0x11f560
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pckbucket.c
// Function: gt_pckbuckettable_map
Pckbuckettable *gt_pckbuckettable_map(const char *indexname,
                                      unsigned int numofchars,
                                      GtError *err)
{
  size_t numofbytes;
  void *mapptr;
  unsigned int maxdepth;
  Pckbuckettable *pckbt;

  gt_error_check(err);
  mapptr = gt_fa_mmap_read_with_suffix(indexname,PCKBUCKETTABLE,
                                       &numofbytes,err);
  if (mapptr == NULL)
  {
    return NULL;
  }
  maxdepth = (unsigned int) ((GtUword *) mapptr)[0];
  pckbt = pckbuckettable_allocandinittable(numofchars,maxdepth,false);
  pckbt->mapptr = mapptr;
  pckbt->mbtab[0] = (Mbtab *) (((GtUword *) mapptr) + 1);
  pckbuckettable_settaboffsets(pckbt);
  gt_assert(numofbytes ==
            sizeof (GtUword) + sizeof (Mbtab) * pckbt->maxnumofvalues);
  return pckbt;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x262602
movq 0x28(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2625ca
jmp 0x262602
movq 0x3d99cf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b3a38(%rip), %rsi    # 0x516013
leaq 0x2b3bdd(%rip), %rdx    # 0x5161bf
leaq 0x319d59(%rip), %rcx    # 0x57c342
leaq 0x319c69(%rip), %r8     # 0x57c259
movl $0x104, %r9d            # imm = 0x104
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x262604
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %r9
leaq 0x319d28(%rip), %rsi    # 0x57c33d
leaq 0x20(%rsp), %rdx
leaq 0x319c38(%rip), %rcx    # 0x57c259
movl $0x106, %r8d            # imm = 0x106
callq 0xdb430
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x262647
movq $0x0, 0x40(%rsp)
jmp 0x2626f3
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl %eax, 0x14(%rsp)
movl 0x34(%rsp), %edi
movl 0x14(%rsp), %esi
xorl %edx, %edx
callq 0x261f20
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
addq $0x8, %rcx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x262700
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x4, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x2626e7
movq 0x3d98ea(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b3953(%rip), %rsi    # 0x516013
leaq 0x319c91(%rip), %rdx    # 0x57c358
leaq 0x319c74(%rip), %rcx    # 0x57c342
leaq 0x319b84(%rip), %r8     # 0x57c259
movl $0x111, %r9d            # imm = 0x111
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2626e9
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pckbucket.c
// Function: pckbuckettable_settaboffsets
static void pckbuckettable_settaboffsets(Pckbuckettable *pckbt)
{
  unsigned int idx;

  gt_assert(pckbt != NULL);
  for (idx=0; idx<pckbt->maxdepth; idx++)
  {
    pckbt->mbtab[idx+1] = pckbt->mbtab[idx] + pckbt->basepower[idx];
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x262749
movq 0x3d9888(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b38f1(%rip), %rsi    # 0x516013
leaq 0x319cf8(%rip), %rdx    # 0x57c421
leaq 0x319e16(%rip), %rcx    # 0x57c546
leaq 0x319b22(%rip), %r8     # 0x57c259
movl $0x32, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26274b
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2627ad
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
shlq $0x4, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x262753
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pckdfs.c
// Function: dfsnonspecialwidth
static GtUword dfsnonspecialwidth(const GtArrayBoundswithchar *bwci)
{
  GtUword idx, addwidth = 0;

  for (idx = 0; idx < bwci->nextfreeBoundswithchar; idx++)
  {
    addwidth += bwci->spaceBoundswithchar[idx].rbound -
                bwci->spaceBoundswithchar[idx].lbound;
  }
  return addwidth;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x18(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x26351a
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x18, -0x10(%rsp), %rdx
addq %rdx, %rcx
subq (%rcx), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2634c7
movq -0x18(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-align.c
// Function: gt_querymatchoutoptions_reset
void gt_querymatchoutoptions_reset(GtQuerymatchoutoptions *querymatchoutoptions)
{
  if (querymatchoutoptions != NULL)
  {
    if (querymatchoutoptions->vseqbuffer_size == 0)
    {
      querymatchoutoptions->vseqbuffer = NULL;
    }
    if (querymatchoutoptions->useqbuffer_size == 0)
    {
      querymatchoutoptions->useqbuffer = NULL;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x263b80
movq -0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x263b66
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x263b7e
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x263b80
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-align.c
// Function: gt_querymatchoutoptions_for_align_only
void gt_querymatchoutoptions_for_align_only(
                  GtQuerymatchoutoptions *querymatchoutoptions,
                  GtUword errorpercentage,
                  double matchscore_bias,
                  GtUword history_size,
                  bool always_polished_ends,
                  GtExtendCharAccess a_extend_char_access,
                  GtExtendCharAccess b_extend_char_access,
                  const GtSeedExtendDisplayFlag *out_display_flag)
{
  const bool weakends = false;
  const bool cam_generic = false;
  const GtUword sensitivity = 100;
  const double evalue_threshold = DBL_MAX;

  gt_querymatchoutoptions_extend(querymatchoutoptions,
                                 errorpercentage,
                                 evalue_threshold,
                                 GT_MAX_ALI_LEN_DIFF,
                                 history_size,
                                 GT_MIN_PERC_MAT_HISTORY,
                                 a_extend_char_access,
                                 b_extend_char_access,
                                 cam_generic,
                                 weakends,
                                 sensitivity,
                                 matchscore_bias,
                                 always_polished_ends,
                                 out_display_flag);
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movb %cl, %al
movq 0x80(%rsp), %rcx
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movl %r8d, 0x48(%rsp)
movl %r9d, 0x44(%rsp)
movb $0x0, 0x43(%rsp)
movb $0x0, 0x42(%rsp)
movq $0x64, 0x38(%rsp)
movsd 0x2b4ec1(%rip), %xmm0   # 0x518d50
movsd %xmm0, 0x30(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x50(%rsp), %rcx
movl 0x48(%rsp), %r9d
movl 0x44(%rsp), %r11d
movsd 0x58(%rsp), %xmm1
movb 0x4f(%rsp), %r10b
movq 0x80(%rsp), %rax
movsd 0x2b4e87(%rip), %xmm0   # 0x518d50
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
xorl %ebx, %ebx
andb $0x1, %r10b
movl %r11d, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x64, 0x18(%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x263b90
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-align.c
// Function: gt_querymatchoutoptions_delete
void gt_querymatchoutoptions_delete(
        GtQuerymatchoutoptions *querymatchoutoptions)
{
  if (querymatchoutoptions != NULL)
  {
    front_trace_delete(querymatchoutoptions->front_trace);
    gt_greedy_extend_matchinfo_delete(querymatchoutoptions->ggemi);
    if (querymatchoutoptions->useqbuffer_size > 0)
    {
      gt_free(querymatchoutoptions->useqbuffer);
    }
    if (querymatchoutoptions->vseqbuffer_size > 0)
    {
      gt_free(querymatchoutoptions->vseqbuffer);
    }
    gt_eoplist_delete(querymatchoutoptions->eoplist);
    gt_eoplist_reader_delete(querymatchoutoptions->eoplist_reader);
    gt_eoplist_reader_delete(querymatchoutoptions->eoplist_reader_verify);
    gt_encseq_reader_delete(querymatchoutoptions->db_esr_for_align_show);
    gt_encseq_reader_delete(querymatchoutoptions->query_esr_for_align_show);
    polishing_info_delete(querymatchoutoptions->pol_info);
    gt_encseq_metadata_delete(querymatchoutoptions->emd);
    gt_free(querymatchoutoptions);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x263ff4
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x4c6940
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x2ac030
movq (%rsp), %rax
cmpq $0x0, (%rax)
jbe 0x263f5d
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x31887a(%rip), %rsi    # 0x57c7cd
movl $0xcf, %edx
callq 0xe88c0
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x263f81
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x318856(%rip), %rsi    # 0x57c7cd
movl $0xd3, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x4c2f40
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x4c2280
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x4c2280
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0xac3f0
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xac3f0
movq (%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x24f9e0
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0xd6ae0
movq (%rsp), %rdi
leaq 0x3187e3(%rip), %rsi    # 0x57c7cd
movl $0xdc, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-align.c
// Function: gt_querymtch_alignment_verification
static void gt_querymtch_alignment_verification(
            GtQuerymatchoutoptions *querymatchoutoptions,
            GtUword dbstart,
            GtUword dblen,
            GtUword abs_querystart,
            GtUword querylen,
            GtUword sumdist)
{
  if (querymatchoutoptions->eoplist_reader_verify == NULL)
  {
    querymatchoutoptions->eoplist_reader_verify = gt_eoplist_reader_new();
  }
  gt_eoplist_set_sequences(querymatchoutoptions->eoplist,NULL,
                           dbstart,
                           dblen,
                           NULL,
                           abs_querystart,
                           querylen);
  gt_eoplist_verify(querymatchoutoptions->eoplist,
                    querymatchoutoptions->eoplist_reader_verify,
                    sumdist);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x2648ef
callq 0x4c1a20
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %rax
xorl %esi, %esi
movl %esi, %r8d
movq %r8, %rsi
movq %rax, (%rsp)
callq 0x4c3e20
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x4c6210
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-align.c
// Function: gt_querymatchoutoptions_set_sequences
static void gt_querymatchoutoptions_set_sequences(GtQuerymatchoutoptions
                                             *querymatchoutoptions,
                                           GtUword dbstart_relative,
                                           GtUword dblen,
                                           GtUword querystart,
                                           GtUword querylen,
                                           bool withcorrection)
{
  gt_assert(querymatchoutoptions != NULL);

  if (withcorrection)
  {
    gt_eoplist_set_sequences(querymatchoutoptions->eoplist,
                             querymatchoutoptions->useqbuffer +
                               querymatchoutoptions->correction_info.uoffset,
                             dbstart_relative +
                               querymatchoutoptions->correction_info.uoffset,
                             querymatchoutoptions->correction_info.ulen,
                             querymatchoutoptions->vseqbuffer +
                               querymatchoutoptions->correction_info.voffset,
                             querystart +
                               querymatchoutoptions->correction_info.voffset,
                             querymatchoutoptions->correction_info.vlen);
  } else
  {
    gt_eoplist_set_sequences(querymatchoutoptions->eoplist,
                             querymatchoutoptions->useqbuffer,
                             dbstart_relative,
                             dblen,
                             querymatchoutoptions->vseqbuffer,
                             querystart,
                             querylen);
  }
}

// Assembly:
subq $0x38, %rsp
movb %r9b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x265126
movq 0x3d6eab(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b0f14(%rip), %rsi    # 0x516013
leaq 0x3190ff(%rip), %rdx    # 0x57e205
leaq 0x3179db(%rip), %rcx    # 0x57cae8
leaq 0x3176b9(%rip), %r8     # 0x57c7cd
movl $0x1d0, %r9d            # imm = 0x1D0
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x265128
testb $0x1, 0xf(%rsp)
je 0x2651a1
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x30(%rsp), %rax
addq 0x78(%rax), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rax
addq 0x78(%rax), %rdx
movq 0x30(%rsp), %rax
movq 0x88(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x20(%rax), %r8
movq 0x30(%rsp), %rax
addq 0x80(%rax), %r8
movq 0x18(%rsp), %r9
movq 0x30(%rsp), %rax
addq 0x80(%rax), %r9
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, (%rsp)
callq 0x4c3e20
jmp 0x2651d9
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x20(%rax), %r8
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x4c3e20
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-align.c
// Function: gt_querymatchoutoptions_cigar_show
void gt_querymatchoutoptions_cigar_show(const GtQuerymatchoutoptions
                                              *querymatchoutoptions,
                                        bool distinguish_mismatch_match,
                                        FILE *fp)
{
  gt_assert(querymatchoutoptions != NULL &&
            querymatchoutoptions->eoplist != NULL);
  gt_eoplist_reader_reset(querymatchoutoptions->eoplist_reader,
                          querymatchoutoptions->eoplist,true);
  gt_eoplist_show_cigar(querymatchoutoptions->eoplist_reader,
                        distinguish_mismatch_match,fp);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x26520a
movq 0x10(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x265242
movq 0x3d6d8f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b0df8(%rip), %rsi    # 0x516013
leaq 0x3177b8(%rip), %rdx    # 0x57c9da
leaq 0x3177f7(%rip), %rcx    # 0x57ca20
leaq 0x31759d(%rip), %r8     # 0x57c7cd
movl $0x260, %r9d            # imm = 0x260
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x265244
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
movl $0x1, %edx
callq 0x4c1b40
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movb 0xf(%rsp), %al
movq (%rsp), %rdx
andb $0x1, %al
movzbl %al, %esi
callq 0x4c3da0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-align.c
// Function: gt_querymatchoutoptions_trace_show
void gt_querymatchoutoptions_trace_show(const GtQuerymatchoutoptions
                                              *querymatchoutoptions,
                                        bool dtrace,
                                        FILE *fp)
{
  GtEoplistSegment segment;
  bool first = true;

  gt_assert(querymatchoutoptions != NULL);
  gt_eoplist_reader_reset(querymatchoutoptions->eoplist_reader,
                          querymatchoutoptions->eoplist,true);
  while (gt_eoplist_reader_next_segment(&segment,
                                        querymatchoutoptions->eoplist_reader,
                                        querymatchoutoptions->trace_delta))
  {
    if (!first)
    {
      fputc(',',fp);
    } else
    {
      first = false;
    }
    fprintf(fp,"%d",dtrace ? ((int) querymatchoutoptions->trace_delta -
                              (int) segment.aligned_v)
                           : (int) segment.aligned_v);
  }
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq %rdx, 0x30(%rsp)
movb $0x1, 0x1f(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x2652dc
movq 0x3d6cf5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b0d5e(%rip), %rsi    # 0x516013
leaq 0x318f49(%rip), %rdx    # 0x57e205
leaq 0x317780(%rip), %rcx    # 0x57ca43
leaq 0x317503(%rip), %r8     # 0x57c7cd
movl $0x26f, %r9d            # imm = 0x26F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2652de
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x40(%rsp), %rax
movq 0x28(%rax), %rsi
movl $0x1, %edx
callq 0x4c1b40
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x20(%rsp), %rdi
callq 0x4c3270
testb $0x1, %al
jne 0x26531c
jmp 0x265385
testb $0x1, 0x1f(%rsp)
jne 0x265334
movq 0x30(%rsp), %rsi
movl $0x2c, %edi
callq 0x198d0
jmp 0x265339
movb $0x0, 0x1f(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x3f(%rsp)
je 0x265360
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
subl %ecx, %eax
movl %eax, 0xc(%rsp)
jmp 0x265369
movq 0x28(%rsp), %rax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0x338129(%rip), %rsi    # 0x59d4a2
movb $0x0, %al
callq 0x199f0
jmp 0x2652fa
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-display.c
// Function: gt_querymatch_display_args_contain
static bool gt_querymatch_display_args_contain(const GtStrArray *display_args,
                                               const char *keyword)
{
  GtUword idx;

  for (idx = 0; idx < gt_str_array_size(display_args); idx++)
  {
    if (strcmp_ignore_ws(gt_str_array_get(display_args,idx),keyword) == 0)
    {
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x266450
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11f8c0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x266f60
cmpl $0x0, %eax
jne 0x26643e
movb $0x1, 0x27(%rsp)
jmp 0x266455
jmp 0x266440
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2663f7
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-display.c
// Function: gt_querymatch_Options_output
void gt_querymatch_Options_output(FILE *stream,int argc,const char **argv,
                                  bool idhistout,GtUword minidentity,
                                  GtUword historysize)
{
  int idx;
  bool minid_out = false, history_out = false;

  fprintf(stream,"# Options:");
  for (idx = 1; idx < argc; idx++) {
    if (strcmp(argv[idx],"-minidentity") == 0) {
      minid_out = true;
    }
    if (strcmp(argv[idx],"-history") == 0) {
      history_out = true;
    }
    fprintf(stream," %s", argv[idx]);
  }
  if (idhistout)
  {
    if (!minid_out)
    {
      fprintf(stream," -minidentity " GT_WU,minidentity);
    }
    if (!history_out)
    {
      fprintf(stream," -history " GT_WU,historysize);
    }
  }
  fputc('\n',stream);
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movb $0x0, 0x3(%rsp)
movb $0x0, 0x2(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x316f8c(%rip), %rsi    # 0x57d996
movb $0x0, %al
callq 0x199f0
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x266a99
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x316f69(%rip), %rsi    # 0x57d9a1
callq 0x19980
cmpl $0x0, %eax
jne 0x266a47
movb $0x1, 0x3(%rsp)
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x316f52(%rip), %rsi    # 0x57d9ae
callq 0x19980
cmpl $0x0, %eax
jne 0x266a6b
movb $0x1, 0x2(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x317046(%rip), %rsi    # 0x57dacb
movb $0x0, %al
callq 0x199f0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x266a19
testb $0x1, 0x1f(%rsp)
je 0x266ae0
testb $0x1, 0x3(%rsp)
jne 0x266abf
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x316eff(%rip), %rsi    # 0x57d9b7
movb $0x0, %al
callq 0x199f0
testb $0x1, 0x2(%rsp)
jne 0x266ade
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x316ef2(%rip), %rsi    # 0x57d9c9
movb $0x0, %al
callq 0x199f0
jmp 0x266ae0
movq 0x30(%rsp), %rsi
movl $0xa, %edi
callq 0x198d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-display.c
// Function: gt_querymatch_display_keyword_out
static void gt_querymatch_display_keyword_out(FILE *stream,const char *s)
{
  const char *sptr;

  for (sptr = s; *sptr != '\0'; sptr++)
  {
    if (*sptr == '.')
    {
      fprintf(stream,". ");
    } else
    {
      fputc(*sptr,stream);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x266dd5
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x266db4
movq 0x10(%rsp), %rdi
leaq 0x2c1576(%rip), %rsi    # 0x528321
movb $0x0, %al
callq 0x199f0
jmp 0x266dc5
movq (%rsp), %rax
movsbl (%rax), %edi
movq 0x10(%rsp), %rsi
callq 0x198d0
jmp 0x266dc7
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x266d87
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-display.c
// Function: gt_querymatch_read_Fields_line
GtStrArray *gt_querymatch_read_Fields_line(const char *line_ptr)
{
  const char *header = "# Fields:", *ptr, *last_start;
  const size_t header_len = strlen(header);
  GtStrArray *fields;

  if (strncmp(header,line_ptr,header_len) != 0)
  {
    return NULL;
  }
  fields = gt_str_array_new();
  for (last_start = ptr = line_ptr + header_len + 1; /* Nothing */; ptr++)
  {
    if (*ptr == ',' || *ptr == '\0')
    {
      GtUword len_arg;

      if (*last_start == '%')
      {
        last_start += 2;
      }
      len_arg = (size_t) (ptr - last_start);
      gt_str_array_add_cstr_nt(fields, last_start, len_arg);
      last_start = ptr + 2;
    }
    if (*ptr == '\0')
    {
      break;
    }
  }
  return fields;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
leaq 0x316ca7(%rip), %rax    # 0x57db07
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x192b0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x192f0
cmpl $0x0, %eax
je 0x266e9b
movq $0x0, 0x40(%rsp)
jmp 0x266f54
callq 0x11f5c0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
addq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x266ed7
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x266f26
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x266ef2
movq 0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x11f7a0
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x266f35
jmp 0x266f4a
jmp 0x266f37
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x266ebd
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-display.c
// Function: strcmp_ignore_ws
static int strcmp_ignore_ws(const char *s,const char *t)
{
  const char *sptr = s, *tptr = t;
  while (true)
  {
    if (isspace(*sptr))
    {
      sptr++;
    } else
    {
      if (isspace(*tptr))
      {
        tptr++;
      } else
      {
        if (*sptr < *tptr)
        {
          return -1;
        }
        if (*sptr > *tptr)
        {
          return 1;
        }
        if (*sptr == '\0')
        {
          return 0;
        }
        sptr++;
        tptr++;
      }
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x197c0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x266fb5
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x267050
callq 0x197c0
movq (%rax), %rax
movq (%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x266fe3
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x26704e
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
movq (%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x267000
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x267055
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
movq (%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x26701d
movl $0x1, 0x24(%rsp)
jmp 0x267055
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x267034
movl $0x0, 0x24(%rsp)
jmp 0x267055
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x267050
jmp 0x266f81
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/querymatch-display.c
// Function: gt_querymatch_display_flag_add
static void gt_querymatch_display_flag_add(GtSeedExtendDisplayFlag
                                            *display_flag,
                                           GtSeedExtendDisplay_enum flag)
{
  const uint64_t mask = gt_display_mask(flag);

  gt_assert(display_flag != NULL);
  if ((display_flag->flags & mask) == 0)
  {
    display_flag->flags |= mask;
    gt_assert(flag <= GT_DISPLAY_LARGEST_FLAG);
    if (gt_display_arguments_table[gt_display_flag2index[flag]].incolumn)
    {
      gt_assert(display_flag->nextfree <= GT_DISPLAY_LARGEST_FLAG);
      display_flag->order[display_flag->nextfree++] = flag;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x266380
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2670ba
movq 0x3d4f17(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2aef80(%rip), %rsi    # 0x516013
leaq 0x31f558(%rip), %rdx    # 0x5865f2
leaq 0x316a80(%rip), %rcx    # 0x57db21
leaq 0x3167ee(%rip), %r8     # 0x57d896
movl $0x95, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2670bc
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq (%rsp), %rax
cmpq $0x0, %rax
jne 0x2671bc
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
cmpl $0x26, 0xc(%rsp)
jbe 0x267120
movq 0x3d4eb1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2aef1a(%rip), %rsi    # 0x516013
leaq 0x3169cf(%rip), %rdx    # 0x57dacf
leaq 0x316a1a(%rip), %rcx    # 0x57db21
leaq 0x316788(%rip), %r8     # 0x57d896
movl $0x99, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x267122
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x3d71e1(%rip), %rax    # 0x63e310
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
leaq 0x3d7275(%rip), %rax    # 0x63e3b0
shlq $0x4, %rcx
addq %rcx, %rax
testb $0x1, 0xc(%rax)
je 0x2671ba
jmp 0x26714a
movq 0x10(%rsp), %rax
cmpq $0x26, 0xb8(%rax)
jbe 0x267191
movq 0x3d4e40(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2aeea9(%rip), %rsi    # 0x516013
leaq 0x3169cf(%rip), %rdx    # 0x57db40
leaq 0x3169a9(%rip), %rcx    # 0x57db21
leaq 0x316717(%rip), %r8     # 0x57d896
movl $0x9c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x267193
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rsi
movq 0xb8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0xb8(%rsi)
movl %edx, 0x8(%rax,%rcx,4)
jmp 0x2671bc
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)