LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/marksubstring.c
// Function: gt_marksubstring_new
Gtmarksubstring *gt_marksubstring_new(unsigned int numofchars,
                                      unsigned int kmersize,
                                      bool usesuffix,
                                      unsigned int units)
{
  Gtmarksubstring *mark;

  mark = gt_malloc(sizeof (*mark));
  gt_assert(kmersize >= units);
  mark->units = units;
  mark->entries = gt_power_for_small_exponents(numofchars,units);
  if (usesuffix)
  {
    mark->shiftright = 0;
    mark->mask = (GtCodetype) (mark->entries-1);
  } else
  {
    mark->shiftright = GT_MULT2(kmersize - units);
    mark->mask = ~(GtCodetype) 0;
  }
  GT_INITBITTAB(mark->bits,mark->entries);
  mark->size = sizeof (GtBitsequence) * GT_NUMOFINTSFORBITS(mark->entries);
  return mark;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %ebp
movl %edi, %r12d
leaq 0x1e32d2(%rip), %rsi    # 0x349a20
pushq $0x28
popq %rdi
pushq $0x1d
popq %rdx
callq 0x93160
subl %r14d, %ebp
jb 0x1667fb
movq %rax, %rbx
movl %r14d, 0x8(%rax)
movl %r12d, %edi
movl %r14d, %esi
callq 0x95871
movq %rax, 0x10(%rbx)
addl %ebp, %ebp
leaq -0x1(%rax), %r14
xorl %ecx, %ecx
testb %r15b, %r15b
cmovnel %ecx, %ebp
pushq $-0x1
popq %rcx
cmovneq %r14, %rcx
movl %ebp, 0xc(%rbx)
movq %rcx, 0x18(%rbx)
shrq $0x3, %r14
andq $-0x8, %r14
pushq $0x8
popq %r15
addq %r15, %r14
cmpq $0x40, %rax
cmovbq %r15, %r14
leaq 0x1e326e(%rip), %rdx    # 0x349a20
pushq $0x2a
popq %rcx
xorl %edi, %edi
movq %r14, %rsi
callq 0x93472
movq %rax, 0x20(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x17380
movq 0x10(%rbx), %rax
leaq -0x1(%rax), %rcx
shrq $0x6, %rcx
cmpq $0x40, %rax
leaq 0x8(,%rcx,8), %rax
cmovbq %r15, %rax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d1766(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17e807(%rip), %rsi    # 0x2e5013
leaq 0x1e3227(%rip), %rdx    # 0x349a3a
leaq 0x1e3232(%rip), %rcx    # 0x349a4c
leaq 0x1e31ff(%rip), %r8     # 0x349a20
pushq $0x1e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x166865
pushq %rbx
movq %rdi, %rbx
testb %sil, %sil
je 0x166852
movq 0x20(%rbx), %rdi
leaq 0x1e31d6(%rip), %rsi    # 0x349a20
pushq $0x35
popq %rdx
callq 0x936f9
leaq 0x1e31c7(%rip), %rsi    # 0x349a20
pushq $0x37
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb 0xc(%rdi), %cl
shrq %cl, %rsi
andq 0x18(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
jae 0x1668a2
movq 0x20(%rdi), %rax
movq %rsi, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %rdi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movl %esi, %ecx
shrq %cl, %r8
testq %r8, %rdi
je 0x16689a
retq
orq %r8, %rdi
movq %rdi, (%rax,%rdx,8)
retq
pushq %rax
movq 0x2d16be(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17e75f(%rip), %rsi    # 0x2e5013
leaq 0x1e31a6(%rip), %rdx    # 0x349a61
leaq 0x1e31b4(%rip), %rcx    # 0x349a76
leaq 0x1e3157(%rip), %r8     # 0x349a20
pushq $0x3f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rax
movq 0x20(%rdi), %rax
testl %esi, %esi
je 0x166941
testq %rax, %rax
je 0x166946
movq 0x2d164a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17e6eb(%rip), %rsi    # 0x2e5013
leaq 0x1e315d(%rip), %rdx    # 0x349a8c
leaq 0x1e3169(%rip), %rcx    # 0x349a9f
leaq 0x1e30e3(%rip), %r8     # 0x349a20
pushq $0x60
jmp 0x166970
testq %rax, %rax
je 0x166948
popq %rax
retq
movq 0x2d1619(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17e6ba(%rip), %rsi    # 0x2e5013
leaq 0x1e315a(%rip), %rdx    # 0x349aba
leaq 0x1e3138(%rip), %rcx    # 0x349a9f
leaq 0x1e30b2(%rip), %r8     # 0x349a20
pushq $0x63
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r12
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r13
testq %r9, %r9
je 0x1669b7
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x166a30
incq %rbp
decq %rbp
je 0x1669fd
movq (%r13), %rbx
addq $0x18, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x179e0
testl %eax, %eax
jne 0x1669ba
movl (%r15), %eax
movl -0x8(%r13), %ecx
testl %eax, %ecx
je 0x166a27
leaq 0x1e3116(%rip), %rsi    # 0x349afe
movq %r14, %rdi
movq %rbx, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
jmp 0x166a17
leaq 0x1e3127(%rip), %rsi    # 0x349b2b
movq %r14, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
orl %eax, %ecx
movl %ecx, (%r15)
xorl %eax, %eax
jmp 0x166a18
movq 0x2d1531(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17e5d2(%rip), %rsi    # 0x2e5013
leaq 0x17e777(%rip), %rdx    # 0x2e51bf
leaq 0x1e307e(%rip), %rcx    # 0x349acd
leaq 0x1e308e(%rip), %r8     # 0x349ae4
pushq $0x1f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
testq %r8, %r8
je 0x166a8f
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x166ad6
incq %r13
decq %r13
je 0x166ab2
movq (%r12), %rsi
addq $0x18, %r12
movq %r14, %rdi
callq 0x179e0
testl %eax, %eax
jne 0x166a92
movl -0x8(%r12), %eax
jmp 0x166acc
leaq 0x1e3072(%rip), %rsi    # 0x349b2b
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2d148b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17e52c(%rip), %rsi    # 0x2e5013
leaq 0x17e6d1(%rip), %rdx    # 0x2e51bf
leaq 0x1e3059(%rip), %rcx    # 0x349b4e
leaq 0x1e2fe8(%rip), %r8     # 0x349ae4
pushq $0x3b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/optionargmode.c
// Function: gt_getargmodekeywords
GtStr *gt_getargmodekeywords(const Optionargmodedesc *modedesc,
                             size_t numberofentries,
                             const char *what)
{
  GtStr *helpstring;
  size_t idx, modecount, len, maxlen = 0;
  GT_UNUSED size_t spacelen;
  const char *space = "    ";

  for (modecount=0; modecount < numberofentries; modecount++)
  {
    len = strlen(modedesc[modecount].name);
    if (maxlen < len)
    {
      maxlen = len;
    }
  }
  helpstring = gt_str_new_cstr("use combination of the following keywords "
                               "to specify ");
  gt_str_append_cstr(helpstring,what);
  gt_str_append_cstr(helpstring,"\n");
  spacelen = strlen(space);
  for (modecount=0; modecount < numberofentries; modecount++)
  {
    gt_str_append_cstr(helpstring,modedesc[modecount].name);
    gt_str_append_cstr(helpstring,space);
    len = strlen(modedesc[modecount].name);
    for (idx=0; idx<maxlen+-len; idx++)
    {
      gt_str_append_cstr(helpstring," ");
    }
    gt_str_append_cstr(helpstring,"show ");
    gt_str_append_cstr(helpstring,modedesc[modecount].desc);
    gt_str_append_cstr(helpstring,"\n");
  }
  return helpstring;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
xorl %r14d, %r14d
movq %rdi, (%rsp)
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rsi, %r15
subq $0x1, %r15
jb 0x166b4a
movq (%rbx), %rdi
callq 0x172d0
cmpq %rax, %r14
cmovbeq %rax, %r14
addq $0x18, %rbx
jmp 0x166b2f
leaq 0x1e3013(%rip), %rdi    # 0x349b64
callq 0xacbd1
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xacbfb
leaq 0x1f9984(%rip), %rsi    # 0x3604ef
movq %r15, %rdi
callq 0xacbfb
xorl %ebp, %ebp
leaq 0x1fb9b4(%rip), %r12    # 0x362530
cmpq 0x8(%rsp), %rbp
je 0x166c0f
imulq $0x18, %rbp, %r13
movq %r14, %rbx
movq (%rsp), %r14
leaq (%r14,%r13), %rax
movq %rax, 0x10(%rsp)
movq (%r14,%r13), %rsi
movq %r15, %rdi
callq 0xacbfb
movq %r15, %rdi
leaq 0x1bd00b(%rip), %rsi    # 0x323bbc
callq 0xacbfb
movq (%r14,%r13), %rdi
movq %rbx, %r14
callq 0x172d0
movq %rbx, %r13
subq %rax, %r13
movq %r15, %rdi
subq $0x1, %r13
jb 0x166bdb
movq %r12, %rsi
callq 0xacbfb
jmp 0x166bc8
leaq 0x1e2fb8(%rip), %rsi    # 0x349b9a
callq 0xacbfb
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0xacbfb
movq %r15, %rdi
leaq 0x1f98ed(%rip), %rsi    # 0x3604ef
callq 0xacbfb
incq %rbp
jmp 0x166b7c
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %r15
leaq 0x203748(%rip), %r12    # 0x36a384
subq $0x1, %r14
jb 0x166c5b
testl %ebx, (%r15)
je 0x166c55
movq -0x10(%r15), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x17070
addq $0x18, %r15
jmp 0x166c3c
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x179c0
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x166cee
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x166c8c
callq 0x8b9fa
jmp 0x166ca2
movq 0x18(%rbx), %rax
movq (%rax), %rdi
leaq 0x1e2f1f(%rip), %rsi    # 0x349bb9
pushq $0x62
popq %rdx
callq 0x936f9
movq 0x18(%rbx), %rax
andq $0x0, (%rax)
movq 0x18(%rbx), %rdi
leaq 0x1e2f04(%rip), %r14    # 0x349bb9
pushq $0x68
popq %rdx
movq %r14, %rsi
callq 0x936f9
andq $0x0, 0x18(%rbx)
movq 0x28(%rbx), %rdi
pushq $0x6a
popq %rdx
movq %r14, %rsi
callq 0x936f9
andq $0x0, 0x28(%rbx)
pushq $0x6c
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x2d1273(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17e314(%rip), %rsi    # 0x2e5013
leaq 0x1e307b(%rip), %rdx    # 0x349d81
leaq 0x1e2e93(%rip), %rcx    # 0x349ba0
leaq 0x1e2ea5(%rip), %r8     # 0x349bb9
pushq $0x5f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leaq 0x1e2a13(%rip), %rsi    # 0x349bb9
pushq $0x30
popq %rdi
pushq $0x41
popq %rdx
callq 0x93160
movq %rax, %rbx
movl %r15d, %edi
movl %r14d, %esi
callq 0x1649cf
movq %rax, 0x28(%rbx)
movl %r15d, (%rbx)
movl %r14d, 0x4(%rbx)
incl %r14d
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rcx, %r14
je 0x1671ea
addq (%rax,%rcx,8), %rdx
movq %rdx, 0x10(%rbx)
incq %rcx
jmp 0x1671d8
shlq $0x3, %r14
leaq 0x1e29c4(%rip), %rsi    # 0x349bb9
pushq $0x4b
popq %rdx
movq %r14, %rdi
callq 0x93160
movq %rax, 0x18(%rbx)
testb %bpl, %bpl
je 0x167257
andq $0x0, 0x20(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x4, %rdi
leaq 0x1e299c(%rip), %rsi    # 0x349bb9
pushq $0x4f
popq %rdx
callq 0x93160
movq 0x18(%rbx), %rcx
movq %rax, (%rcx)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
xorps %xmm0, %xmm0
cmpq %rax, %rcx
jae 0x16724f
movups %xmm0, (%rcx)
addq $0x10, %rcx
jmp 0x167241
movq %rbx, %rdi
callq 0x1675be
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/pckbucket.c
// Function: pckbuckettable_storeBoundsatdepth
static void pckbuckettable_storeBoundsatdepth(Pckbuckettable *pckbt,
                                              const Pckbck_Boundsatdepth *bd)
{
  gt_assert(bd != NULL && pckbt != NULL);
  gt_assert(bd->depth <= pckbt->maxdepth);
  gt_assert(bd->code <= pckbt->basepower[bd->depth]);
  /*
  printf("bd->depth=%u,bd->code="GT_WU"\n",bd->depth,bd->code);
  */
  gt_assert(pckbt->mbtab[bd->depth][bd->code].lowerbound == 0 &&
            pckbt->mbtab[bd->depth][bd->code].upperbound == 0);
  gt_assert(pckbt->numofvalues < pckbt->maxnumofvalues);
  pckbt->numofvalues++;
  pckbt->mbtab[bd->depth][bd->code].lowerbound = bd->lowerbound;
  pckbt->mbtab[bd->depth][bd->code].upperbound = bd->upperbound;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1672fd
testq %rsi, %rsi
je 0x1672fd
movl 0x10(%rsi), %eax
cmpl 0x4(%rdi), %eax
ja 0x167327
movq 0x18(%rsi), %rcx
movq 0x28(%rdi), %rdx
cmpq (%rdx,%rax,8), %rcx
ja 0x167351
movq 0x18(%rdi), %rdx
movq (%rdx,%rax,8), %rax
shlq $0x4, %rcx
cmpq $0x0, (%rax,%rcx)
jne 0x1672d0
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0x1672d0
movq 0x8(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
jae 0x16737b
incq %rcx
movq %rcx, 0x8(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rax)
popq %rax
retq
movq 0x2d0c91(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17dd32(%rip), %rsi    # 0x2e5013
leaq 0x1e2b0e(%rip), %rdx    # 0x349df6
leaq 0x1e2aa0(%rip), %rcx    # 0x349d8f
leaq 0x1e28c3(%rip), %r8     # 0x349bb9
pushq $0x79
jmp 0x1673a3
movq 0x2d0c64(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17dd05(%rip), %rsi    # 0x2e5013
leaq 0x1e2a5e(%rip), %rdx    # 0x349d73
leaq 0x1e2a73(%rip), %rcx    # 0x349d8f
leaq 0x1e2896(%rip), %r8     # 0x349bb9
pushq $0x72
jmp 0x1673a3
movq 0x2d0c3a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17dcdb(%rip), %rsi    # 0x2e5013
leaq 0x1e2a72(%rip), %rdx    # 0x349db1
leaq 0x1e2a49(%rip), %rcx    # 0x349d8f
leaq 0x1e286c(%rip), %r8     # 0x349bb9
pushq $0x73
jmp 0x1673a3
movq 0x2d0c10(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17dcb1(%rip), %rsi    # 0x2e5013
leaq 0x1e2a65(%rip), %rdx    # 0x349dce
leaq 0x1e2a1f(%rip), %rcx    # 0x349d8f
leaq 0x1e2842(%rip), %r8     # 0x349bb9
pushq $0x74
jmp 0x1673a3
movq 0x2d0be6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17dc87(%rip), %rsi    # 0x2e5013
leaq 0x1e2aca(%rip), %rdx    # 0x349e5d
leaq 0x1e29f5(%rip), %rcx    # 0x349d8f
leaq 0x1e2818(%rip), %r8     # 0x349bb9
pushq $0x7a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x1673d4
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x16744a
leaq 0x1e28c2(%rip), %rsi    # 0x349c9d
leaq 0x18e70f(%rip), %rdx    # 0x2f5af1
leaq 0x1e27d0(%rip), %rcx    # 0x349bb9
movq %r15, %rdi
movl $0xe2, %r8d
movq %r14, %r9
callq 0x8a449
testq %rax, %rax
je 0x16743d
movq %rax, %r14
movl 0x4(%rbx), %eax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0xb302c
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
movq (%rax), %rdi
pushq $0x10
popq %rsi
movq %r14, %rcx
callq 0xb302c
movq %r14, %rdi
callq 0x8a4fd
xorl %eax, %eax
jmp 0x167440
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x2d0b17(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17dbb8(%rip), %rsi    # 0x2e5013
leaq 0x17dd5d(%rip), %rdx    # 0x2e51bf
leaq 0x1e281c(%rip), %rcx    # 0x349c85
leaq 0x1e2749(%rip), %r8     # 0x349bb9
movl $0xe1, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
callq 0xacbd1
movq %rax, %rbx
leaq 0x1e2809(%rip), %rsi    # 0x349c9d
movq %rax, %rdi
callq 0xacbfb
movq %rbx, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x8da98
movl %eax, %ebp
movq %rbx, %rdi
callq 0xae103
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
testq %rdx, %rdx
je 0x1674e5
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x167586
leaq 0x1e27b1(%rip), %rsi    # 0x349c9d
leaq 0x1e26c6(%rip), %rcx    # 0x349bb9
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movl $0x106, %r8d            # imm = 0x106
movq %r14, %r9
callq 0x8bb39
testq %rax, %rax
je 0x167577
movq %rax, %r14
movl (%rax), %esi
movl %ebx, %edi
xorl %edx, %edx
callq 0x167190
movq %rax, %rbx
movq %r14, 0x20(%rax)
addq $0x8, %r14
movq 0x18(%rax), %rax
movq %r14, (%rax)
movq %rbx, %rdi
callq 0x1675be
movq 0x10(%rbx), %rax
shlq $0x4, %rax
orq $0x8, %rax
cmpq %rax, 0x8(%rsp)
je 0x167579
movq 0x2d0a18(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17dab9(%rip), %rsi    # 0x2e5013
leaq 0x1e2757(%rip), %rdx    # 0x349cb8
leaq 0x1e273a(%rip), %rcx    # 0x349ca2
leaq 0x1e264a(%rip), %r8     # 0x349bb9
movl $0x111, %r9d            # imm = 0x111
jmp 0x1675b2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x2d09db(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17da7c(%rip), %rsi    # 0x2e5013
leaq 0x17dc21(%rip), %rdx    # 0x2e51bf
leaq 0x1e26fd(%rip), %rcx    # 0x349ca2
leaq 0x1e260d(%rip), %r8     # 0x349bb9
movl $0x104, %r9d            # imm = 0x104
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rax
testq %rdi, %rdi
je 0x1675ee
movl 0x4(%rdi), %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1675ec
movq 0x18(%rdi), %rdx
movq 0x28(%rdi), %rsi
movq (%rsi,%rcx,8), %rsi
shlq $0x4, %rsi
addq (%rdx,%rcx,8), %rsi
movq %rsi, 0x8(%rdx,%rcx,8)
incq %rcx
jmp 0x1675c9
popq %rax
retq
movq 0x2d0973(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17da14(%rip), %rsi    # 0x2e5013
leaq 0x1e277b(%rip), %rdx    # 0x349d81
leaq 0x1e287b(%rip), %rcx    # 0x349e88
leaq 0x1e25a5(%rip), %r8     # 0x349bb9
pushq $0x32
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x1683e9
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x2ba467
movq 0x48(%rbx), %rdi
callq 0x18f431
cmpq $0x0, (%rbx)
je 0x168376
movq 0x18(%rbx), %rdi
leaq 0x1e1d90(%rip), %rsi    # 0x34a0fc
movl $0xcf, %edx
callq 0x936f9
cmpq $0x0, 0x8(%rbx)
je 0x168392
movq 0x20(%rbx), %rdi
leaq 0x1e1d74(%rip), %rsi    # 0x34a0fc
movl $0xd3, %edx
callq 0x936f9
movq 0x28(%rbx), %rdi
callq 0x2b8506
movq 0x30(%rbx), %rdi
callq 0x2b7ee0
movq 0x38(%rbx), %rdi
callq 0x2b7ee0
movq 0x58(%rbx), %rdi
callq 0x722ae
movq 0x60(%rbx), %rdi
callq 0x722ae
movq 0xb0(%rbx), %rdi
callq 0x15d13c
movq 0x68(%rbx), %rdi
callq 0x888b5
leaq 0x1e1d21(%rip), %rsi    # 0x34a0fc
movq %rbx, %rdi
movl $0xdc, %edx
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
cmpq $0x0, 0x38(%rdi)
jne 0x1688ab
callq 0x2b7b71
movq %rax, 0x38(%r14)
movq 0x28(%r14), %rdi
movq %rbp, (%rsp)
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2b8d6d
movq 0x28(%r14), %rdi
movq 0x38(%r14), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ba023
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x168de0
movl %esi, %ebp
movq %rdi, %r14
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x168de0
movq %rdx, %rbx
movq 0x30(%r14), %rdi
pushq $0x1
popq %rdx
callq 0x2b7c06
movq 0x30(%r14), %rdi
movzbl %bpl, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2b8d04
movq 0x2cf181(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17c222(%rip), %rsi    # 0x2e5013
leaq 0x1e1511(%rip), %rdx    # 0x34a309
leaq 0x1e1550(%rip), %rcx    # 0x34a34f
leaq 0x1e12f6(%rip), %r8     # 0x34a0fc
movl $0x260, %r9d            # imm = 0x260
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x168eaf
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdi
pushq $0x1
popq %rdx
callq 0x2b7c06
movb $0x1, %r13b
leaq 0x8(%rsp), %r15
leaq 0x201534(%rip), %r12    # 0x36a38a
movq 0x10(%r14), %rdx
movq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x2b86eb
testb %al, %al
je 0x168ea0
testb $0x1, %r13b
jne 0x168e7b
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x17930
testb %bpl, %bpl
je 0x168e8a
movl 0x10(%r14), %edx
subl 0x10(%rsp), %edx
jmp 0x168e8e
movl 0x10(%rsp), %edx
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x17a50
jmp 0x168e56
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2cf0b2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17c153(%rip), %rsi    # 0x2e5013
leaq 0x1e2c56(%rip), %rdx    # 0x34bb1d
leaq 0x1e14a4(%rip), %rcx    # 0x34a372
leaq 0x1e1227(%rip), %r8     # 0x34a0fc
movl $0x26f, %r9d            # imm = 0x26F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ecx, %ecx
movq %rcx, %r15
movq %r14, %rdi
callq 0xae61c
movq %rax, %r12
cmpq %rax, %r15
jae 0x169855
movq %r14, %rdi
movq %r15, %rsi
callq 0xae386
movq %rax, %rdi
movq %rbx, %rsi
callq 0x169c50
leaq 0x1(%r15), %rcx
testl %eax, %eax
jne 0x169824
cmpq %r12, %r15
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rcx
leaq 0x1e19d7(%rip), %rdi    # 0x34b29f
pushq $0xa
popq %rsi
pushq $0x1
popq %r13
movq %r13, %rdx
movq %rcx, 0x8(%rsp)
callq 0x17f00
movslq %ebp, %rbx
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq %rbx, %r13
jge 0x169936
movq (%r12,%r13,8), %r14
movq %r14, %rdi
leaq 0x1e19b3(%rip), %rsi    # 0x34b2aa
callq 0x179e0
testl %eax, %eax
sete %al
orb %al, %bpl
movq %r14, %rdi
leaq 0x1e19a9(%rip), %rsi    # 0x34b2b7
callq 0x179e0
testl %eax, %eax
sete %al
orb %al, %r15b
movq 0x8(%rsp), %rdi
leaq 0x1e1a5c(%rip), %rsi    # 0x34b383
movq %r14, %rdx
xorl %eax, %eax
callq 0x17a50
incq %r13
jmp 0x1698e4
cmpb $0x0, 0x14(%rsp)
je 0x169979
testb $0x1, %bpl
jne 0x16995b
leaq 0x1e1976(%rip), %rsi    # 0x34b2c0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
xorl %eax, %eax
callq 0x17a50
testb $0x1, %r15b
jne 0x169979
leaq 0x1e196a(%rip), %rsi    # 0x34b2d2
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rdx
xorl %eax, %eax
callq 0x17a50
pushq $0xa
popq %rdi
movq 0x8(%rsp), %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17930
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1e17d5(%rip), %rdi    # 0x34b3bf
pushq $0x9
popq %rdx
movq %rbx, %rsi
callq 0x17310
testl %eax, %eax
je 0x169c05
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xae154
movq %rax, %r14
leaq 0xa(%rbx), %r15
addq $0xc, %rbx
movq %r15, %rax
movzbl -0x2(%rbx), %ecx
cmpl $0x2c, %ecx
je 0x169c25
testl %ecx, %ecx
jne 0x169c48
xorl %ecx, %ecx
cmpb $0x25, (%rax)
sete %cl
leaq (%rax,%rcx,2), %rsi
movq %r15, %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0xae298
cmpb $0x0, -0x2(%rbx)
movq %rbx, %rax
je 0x169bfc
incq %rbx
incq %r15
jmp 0x169c18
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17820
movq (%rax), %rcx
pushq $-0x1
popq %rax
pushq $0x1
popq %rdx
movsbq (%r14), %rsi
movzwl (%rcx,%rsi,2), %edi
btl $0xd, %edi
jb 0x169c96
movsbq (%rbx), %r8
testb $0x20, 0x1(%rcx,%r8,2)
je 0x169c87
incq %rbx
jmp 0x169c70
cmpb %r8b, %sil
jl 0x169ca1
jg 0x169c9b
testb %sil, %sil
je 0x169c9f
incq %rbx
incq %r14
jmp 0x169c68
movl %edx, %eax
jmp 0x169ca1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x1697cf
testq %r14, %r14
je 0x169d14
movq (%r14), %rcx
testq %rax, %rcx
jne 0x169d0c
orq %rax, %rcx
movq %rcx, (%r14)
cmpl $0x27, %ebx
jae 0x169d42
movl %ebx, %eax
leaq 0x1e1c26(%rip), %rcx    # 0x34b900
movl (%rcx,%rax,4), %eax
shlq $0x4, %rax
leaq 0x2cf5a8(%rip), %rcx    # 0x439290
cmpb $0x1, 0xc(%rax,%rcx)
jne 0x169d0c
movq 0xb8(%r14), %rax
cmpq $0x27, %rax
jae 0x169d70
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r14)
movl %ebx, 0x8(%r14,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2ce24d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17b2ee(%rip), %rsi    # 0x2e5013
leaq 0x1e9ecc(%rip), %rdx    # 0x353bf8
leaq 0x1e16a6(%rip), %rcx    # 0x34b3d9
leaq 0x1e1465(%rip), %r8     # 0x34b19f
movl $0x95, %r9d
jmp 0x169d9c
movq 0x2ce21f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17b2c0(%rip), %rsi    # 0x2e5013
leaq 0x1e162d(%rip), %rdx    # 0x34b387
leaq 0x1e1678(%rip), %rcx    # 0x34b3d9
leaq 0x1e1437(%rip), %r8     # 0x34b19f
movl $0x99, %r9d
jmp 0x169d9c
movq 0x2ce1f1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17b292(%rip), %rsi    # 0x2e5013
leaq 0x1e1670(%rip), %rdx    # 0x34b3f8
leaq 0x1e164a(%rip), %rcx    # 0x34b3d9
leaq 0x1e1409(%rip), %r8     # 0x34b19f
movl $0x9c, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/querymatch-display.c
// Function: gt_display_arg_get
static const GtSEdisplayStruct *gt_display_arg_get(char *copyspace,
                                                   const char *str,
                                                   size_t cmplen)
{
  char *copy = NULL;
  const GtSEdisplayStruct *left = gt_display_arguments_table,
                          *right = gt_display_arguments_table +
                                   sizeof gt_display_arguments_table/
                                   sizeof gt_display_arguments_table[0] - 1;

  if (cmplen > 0)
  {
    copy = copyspace;
    memcpy(copy,str,sizeof *copy * cmplen);
    copy[cmplen] = '\0';
  }
  while (left <= right)
  {
    const GtSEdisplayStruct *mid = left + (right - left + 1)/2;
    const int cmp = strcmp_ignore_ws(copy == NULL ? str : copy,mid->name);

    if (cmp < 0)
    {
      right = mid - 1;
    } else
    {
      if (cmp > 0)
      {
        left = mid + 1;
      } else
      {
        return mid;
      }
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0x169dce
movq %rdx, %r15
movq %rdi, %r14
movq %rbx, %rsi
callq 0x17630
movb $0x0, (%r14,%r15)
jmp 0x169dd1
xorl %r14d, %r14d
testq %r14, %r14
cmovneq %r14, %rbx
leaq 0x2cf711(%rip), %r12    # 0x4394f0
leaq 0x2cf4aa(%rip), %r13    # 0x439290
pushq $0x2
popq %r15
cmpq %r12, %r13
ja 0x169e2e
movq %r12, %rax
subq %r13, %rax
sarq $0x4, %rax
incq %rax
cqto
idivq %r15
shlq $0x4, %rax
leaq (%rax,%r13), %r14
movq (%r13,%rax), %rsi
movq %rbx, %rdi
callq 0x169c50
testl %eax, %eax
jns 0x169e23
addq $-0x10, %r14
movq %r14, %r12
jmp 0x169dea
je 0x169e31
addq $0x10, %r14
movq %r14, %r13
jmp 0x169dea
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_new
GtQuerymatch *gt_querymatch_new(void)
{
  GtQuerymatch *querymatch = gt_malloc(sizeof *querymatch);

  gt_assert(querymatch != NULL);
  querymatch->ref_querymatchoutoptions = NULL;
  querymatch->verify_alignment = false;
  querymatch->query_readmode = GT_READMODE_FORWARD;
  querymatch->fp = stdout;
  querymatch->queryseqnum = GT_UWORD_MAX;
  querymatch->db_desc = NULL;
  querymatch->query_desc = NULL;
  return querymatch;
}

// Assembly:
pushq %rax
leaq 0x1e1c50(%rip), %rsi    # 0x34ba98
pushq $0x3f
popq %rdx
movl $0xb8, %edi
callq 0x93160
testq %rax, %rax
je 0x169e92
andq $0x0, 0x90(%rax)
movb $0x0, 0x8d(%rax)
andl $0x0, 0x88(%rax)
movq 0x2ce039(%rip), %rcx    # 0x437eb0
movq (%rcx), %rcx
movq %rcx, 0x98(%rax)
orq $-0x1, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rax)
popq %rcx
retq
movq 0x2ce0cf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17b170(%rip), %rsi    # 0x2e5013
leaq 0x1eb5b1(%rip), %rdx    # 0x35545b
leaq 0x1e1bfe(%rip), %rcx    # 0x34baaf
leaq 0x1e1be0(%rip), %r8     # 0x34ba98
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_outoptions_set
void gt_querymatch_outoptions_set(GtQuerymatch *querymatch,
                GtQuerymatchoutoptions *querymatchoutoptions)
{
  gt_assert(querymatch != NULL && querymatchoutoptions != NULL);
  querymatch->ref_querymatchoutoptions = querymatchoutoptions;
  querymatch->ref_eoplist
    = gt_querymatchoutoptions_eoplist(querymatchoutoptions);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x169fe2
testq %rsi, %rsi
je 0x169fe2
movq %rdi, %rbx
movq %rsi, 0x90(%rdi)
movq %rsi, %rdi
callq 0x16907d
movq %rax, 0xb0(%rbx)
popq %rbx
retq
movq 0x2cdf7f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17b020(%rip), %rsi    # 0x2e5013
leaq 0x1e1b0d(%rip), %rdx    # 0x34bb07
leaq 0x1e1b39(%rip), %rcx    # 0x34bb3a
leaq 0x1e1a90(%rip), %r8     # 0x34ba98
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_description_out
static int gt_non_white_space_prefix_length(const char *s)
{
  const char *sptr;

  gt_assert(s != NULL);
  for (sptr = s; !isspace(*sptr); sptr++)
  {
    /* Nothing */ ;
  }
  return (int) (sptr - s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x16ac24
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17820
movq (%rax), %rax
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %r14, %rsi
addq %rcx, %rdx
movsbq (%rsi), %rdi
incq %rsi
testb $0x20, 0x1(%rax,%rdi,2)
je 0x16abfa
sarq $0x20, %rdx
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17f00
movq 0x2cd33d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17a3de(%rip), %rsi    # 0x2e5013
leaq 0x1ff46f(%rip), %rdx    # 0x36a0ab
leaq 0x1e1341(%rip), %rcx    # 0x34bf84
leaq 0x1e0e4e(%rip), %r8     # 0x34ba98
movl $0x16d, %r9d            # imm = 0x16D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_show_failed_seed
void gt_querymatch_show_failed_seed(const GtSeedExtendDisplayFlag
                                       *out_display_flag,
                                    const GtQuerymatch *querymatch)
{
  if (gt_querymatch_failed_seed_display(out_display_flag))
  {
    const char separator
      = (gt_querymatch_blast_display(out_display_flag) ||
         gt_querymatch_tabsep_display(out_display_flag)) ? '\t' : ' ';
    fprintf(querymatch->fp, "# failed_seed:%c" GT_WU "%c" GT_WU "%c"  GT_WU
                                   "%c%c%c" GT_WU "%c" GT_WU "\n",
            separator,
            querymatch->seedlen,
            separator,
            querymatch->dbseqnum,
            separator,
            querymatch->db_seedpos_rel,
            separator,
            gt_seed_extend_outflag[querymatch->query_readmode],
            separator,
            querymatch->queryseqnum,
            separator,
            querymatch->query_seedpos_rel);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1690be
testb %al, %al
je 0x16ac90
movq %r14, %rdi
callq 0x1690cd
testb %al, %al
je 0x16ac96
pushq $0x9
popq %rdx
jmp 0x16aca9
addq $0x8, %rsp
jmp 0x16aced
movq %r14, %rdi
callq 0x1690c8
testb %al, %al
pushq $0x9
popq %rax
pushq $0x20
popq %rdx
cmovnel %eax, %edx
movq 0x98(%rbx), %rdi
movq 0x68(%rbx), %rcx
movl 0x88(%rbx), %eax
leaq 0x1e12e4(%rip), %rsi    # 0x34bfa5
movsbl (%rax,%rsi), %r10d
movq (%rbx), %r9
leaq 0x1e1038(%rip), %rsi    # 0x34bd08
movl %edx, %r8d
xorl %eax, %eax
pushq 0x60(%rbx)
pushq %rdx
pushq 0x28(%rbx)
pushq %rdx
pushq %r10
pushq %rdx
pushq 0x58(%rbx)
pushq %rdx
callq 0x17a50
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/querymatch.c
// Function: gt_querymatch_evalue_bit_score_generic
static void gt_querymatch_evalue_bit_score_generic(double *evalue_ptr,
                                                   double *bit_score_ptr,
                                                   const GtKarlinAltschulStat
                                                     *karlin_altschul_stat,
                                                   GtUword query_seqlen,
                                                   GtUword matches,
                                                   GtUword mismatches,
                                                   GtUword indels)
{
  if (karlin_altschul_stat != NULL)
  {
    GtUword evalue_searchspace
      = gt_evalue_searchspace(karlin_altschul_stat,query_seqlen);
    GtWord raw_score = gt_evalue_raw_score(karlin_altschul_stat,
                                           matches,
                                           mismatches,
                                           indels);
    *evalue_ptr = gt_evalue_from_raw_score(karlin_altschul_stat,
                                           raw_score,
                                           evalue_searchspace);
    *bit_score_ptr = gt_evalue_raw_score2bit_score(karlin_altschul_stat,
                                                   raw_score);
    gt_assert(*evalue_ptr != DBL_MAX && *bit_score_ptr != DBL_MAX);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x165bbe
movq %rax, %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x40(%rsp), %rcx
callq 0x166212
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x166357
movsd %xmm0, (%rbx)
movq %r13, %rdi
movq %r15, %rsi
callq 0x1662ad
movsd %xmm0, (%r14)
movsd (%rbx), %xmm1
ucomisd 0x17ce22(%rip), %xmm1   # 0x2e7d10
jne 0x16aef2
jnp 0x16af0d
ucomisd 0x17ce16(%rip), %xmm0   # 0x2e7d10
jne 0x16aefe
jnp 0x16af0d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2cd054(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17a0f5(%rip), %rsi    # 0x2e5013
leaq 0x1e10fc(%rip), %rdx    # 0x34c021
leaq 0x1e1129(%rip), %rcx    # 0x34c055
leaq 0x1e0b65(%rip), %r8     # 0x34ba98
movl $0x111, %r9d            # imm = 0x111
xorl %eax, %eax
callq 0x17a50
callq 0x17390