LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_copyLimdfsstate
static void locali_copyLimdfsstate (DECLAREPTRDFSSTATE(deststate),
                                    const DECLAREPTRDFSSTATE(srcstate),
                                    Limdfsconstinfo *lci)
{
  LocaliColumn *destcol = (LocaliColumn *) deststate;
  const LocaliColumn *srccol = (const LocaliColumn *) srcstate;

  if (srccol->colvalues != NULL)
  {
    GtUword idx;

    if (destcol->lenval < lci->maxcollen)
    {
      REALLOCMSG(destcol);
      destcol->colvalues = gt_realloc(destcol->colvalues,
                                      sizeof (LocaliMatrixvalue)
                                        * lci->maxcollen);
      destcol->lenval = lci->maxcollen;
      ATADDRESS("",destcol);
    }
#ifndef NDEBUG
    if (destcol->lenval < lci->querylength+1)
    {
      fprintf(stderr,"destcol->lenval = "GT_WU" < "GT_WU" lci->querylength+1\n",
                      destcol->lenval,lci->querylength+1);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (srccol->lenval < lci->querylength+1)
    {
      fprintf(stderr,"srccol->lenval = "GT_WU" < "GT_WU" lci->querylength+1\n",
                      srccol->lenval,lci->querylength+1);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    for (idx = 0; idx<=lci->querylength; idx++)
    {
      destcol->colvalues[idx] = srccol->colvalues[idx];
    }
  }
  destcol->maxvalue = srccol->maxvalue;
  destcol->pprefixlen = srccol->pprefixlen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rsi)
je 0x1b475c
movq %rdx, %r15
movq 0x8(%rbx), %rdi
movq 0x28(%rdx), %rsi
cmpq %rsi, %rdi
jae 0x1b4728
movq (%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1f384e(%rip), %rdx    # 0x3a7f61
movl $0x245, %ecx            # imm = 0x245
callq 0x104461
movq %rax, (%rbx)
movq 0x28(%r15), %rdi
movq %rdi, 0x8(%rbx)
movq 0x30(%r15), %rsi
incq %rsi
cmpq %rsi, %rdi
jb 0x1b476b
movq 0x8(%r14), %rdi
cmpq %rsi, %rdi
jb 0x1b4770
xorl %eax, %eax
xorl %ecx, %ecx
movq (%rbx), %rdx
movq (%r14), %rsi
movups (%rsi,%rax), %xmm0
movups %xmm0, (%rdx,%rax)
incq %rcx
addq $0x10, %rax
cmpq 0x30(%r15), %rcx
jbe 0x1b4741
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x65baf
callq 0x65b88
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocalisw.c
// Function: gt_newSWdpresource
SWdpresource *gt_newSWdpresource(Scoretype matchscore,
                              Scoretype mismatchscore,
                              Scoretype gapextend,
                              GtUword scorethreshold,
                              bool showalignment,
                              ProcessIdxMatch processmatch,
                              void *processmatchinfo)
{
  SWdpresource *swdpresource;

  swdpresource = gt_malloc(sizeof *swdpresource);
  swdpresource->showalignment = showalignment;
  swdpresource->scorevalues.matchscore = matchscore;
  swdpresource->scorevalues.mismatchscore = mismatchscore;
  swdpresource->scorevalues.gapextend = gapextend;
  swdpresource->scorethreshold = scorethreshold;
  swdpresource->alignment = gt_alignment_new();
  swdpresource->swcol = NULL;
  swdpresource->swentrycol = NULL;
  swdpresource->maxedges = NULL;
  swdpresource->allocatedswcol = 0;
  swdpresource->allocatedmaxedges = 0;
  swdpresource->processmatch = processmatch;
  swdpresource->processmatchinfo = processmatchinfo;
  swdpresource->dbsubstring = NULL;
  swdpresource->allocateddbsubstring = 0;
  return swdpresource;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x1f2daf(%rip), %rsi    # 0x3a819d
movl $0x80, %edi
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x104226
movq %rax, %rbx
movb %bpl, (%rax)
movq %r13, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x38(%rax)
callq 0x120d2c
movq %rax, 0x8(%rbx)
movq $0x0, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movq (%rsp), %rax
movq %rax, 0x70(%rbx)
movq 0x40(%rsp), %rax
movq %rax, 0x78(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocalisw.c
// Function: gt_freeSWdpresource
void gt_freeSWdpresource(SWdpresource *swdpresource)
{
  gt_alignment_delete(swdpresource->alignment);
  swdpresource->alignment = NULL;
  gt_free(swdpresource->swcol);
  gt_free(swdpresource->swentrycol);
  gt_free(swdpresource->maxedges);
  gt_free(swdpresource->dbsubstring);
  swdpresource->allocatedswcol = 0;
  swdpresource->allocatedmaxedges = 0;
  gt_free(swdpresource);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x121e3c
movq $0x0, 0x8(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x1f2d24(%rip), %r14    # 0x3a819d
movq %r14, %rsi
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x1045eb
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x1e4, %edx            # imm = 0x1E4
callq 0x1045eb
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movl $0x1e5, %edx            # imm = 0x1E5
callq 0x1045eb
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movl $0x1e6, %edx            # imm = 0x1E6
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1e9, %edx            # imm = 0x1E9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/index_options.c
// Function: gt_parse_algbounds
int gt_parse_algbounds(Sfxstrategy *sfxstrategy,
                       const GtStrArray *algbounds,
                       GtError *err)
{
  bool haserr = false;
  const char *arg;
  GtWord readint;

  if (gt_str_array_size(algbounds) != 3UL)
  {
    gt_error_set(err,"option -algbds must have exactly 3 arguments");
    haserr = true;
  }
  GT_IDXOPTS_READMAXBOUND(maxinsertionsort, 0);
  GT_IDXOPTS_READMAXBOUND(maxbltriesort, 1UL);
  if (sfxstrategy->maxinsertionsort > sfxstrategy->maxbltriesort)
  {
    gt_error_set(err,"first argument of option -algbds must not be larger "
                     "than second argument");
    haserr = true;
  }
  GT_IDXOPTS_READMAXBOUND(maxcountingsort, 2UL);
  if (sfxstrategy->maxbltriesort > sfxstrategy->maxcountingsort)
  {
    gt_error_set(err,"second argument of option -algbds must not be larger "
                     "than third argument");
    haserr = true;
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x11c131
cmpq $0x3, %rax
jne 0x1b5551
movq %r15, %rdi
xorl %esi, %esi
callq 0x11bfb3
leaq 0x1c6db8(%rip), %rsi    # 0x37c2c4
leaq 0x8(%rsp), %r12
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x177f0
cmpl $0x1, %eax
setne %cl
movq (%r12), %rax
testq %rax, %rax
setle %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1b5567
leaq 0x1f2d8e(%rip), %rsi    # 0x3a82ca
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
jmp 0x1b5562
leaq 0x1f2d45(%rip), %rsi    # 0x3a829d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movb $0x1, %bpl
jmp 0x1b55c7
movq %rax, 0x8(%r14)
movl $0x1, %esi
movq %r15, %rdi
callq 0x11bfb3
leaq 0x1c6d45(%rip), %rsi    # 0x37c2c4
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x177f0
cmpl $0x1, %eax
setne %cl
movq (%r12), %rax
testq %rax, %rax
setle %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1b55c3
leaq 0x1f2d19(%rip), %rsi    # 0x3a82ca
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movb $0x1, %bpl
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r14)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jbe 0x1b55e7
leaq 0x1f2d29(%rip), %rsi    # 0x3a8301
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movb $0x1, %bpl
jmp 0x1b5645
testb %bpl, %bpl
jne 0x1b5645
movl $0x2, %esi
movq %r15, %rdi
callq 0x11bfb3
leaq 0x1c6cc4(%rip), %rsi    # 0x37c2c4
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x177f0
cmpl $0x1, %eax
setne %cl
movq (%r15), %rax
testq %rax, %rax
setle %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1b5641
leaq 0x1f2c9b(%rip), %rsi    # 0x3a82ca
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movb $0x1, %bpl
movq 0x8(%rsp), %rax
movq %rax, 0x18(%r14)
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jbe 0x1b5663
leaq 0x1f2cf4(%rip), %rsi    # 0x3a834a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movb $0x1, %bpl
movzbl %bpl, %eax
negl %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_register_esa
GtIndexOptions* gt_index_options_register_esa(GtOptionParser *op,
                                              GtEncseqOptions *encopts)
{
  GtIndexOptions *idxo;
  gt_assert(op != NULL);

  idxo = gt_index_options_register_generic_create(op,
                                                  GT_INDEX_OPTIONS_ESA);
  return gt_index_options_register_generic_output(op, idxo, NULL, encopts);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b56a6
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0x1b56ab
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b5beb
callq 0x65edb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_register_packedidx
GtIndexOptions* gt_index_options_register_packedidx(GtOptionParser *op,
                                                    GtStr *indexname,
                                                    GtEncseqOptions *encopts)
{
  GtIndexOptions *idxo;
  gt_assert(op != NULL);
  idxo = gt_index_options_register_generic_create(op,
                                                  GT_INDEX_OPTIONS_PACKED);
  return gt_index_options_register_generic_output(op, idxo, indexname, encopts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b5e87
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x2, %esi
callq 0x1b56ab
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1b5beb
callq 0x65fbf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_delete
void gt_index_options_delete(GtIndexOptions *oi)
{
  if (oi == NULL) return;
  gt_str_delete(oi->kysargumentstring);
  gt_str_delete(oi->indexname);
  gt_str_delete(oi->dir);
  gt_str_delete(oi->memlimit);
  gt_str_array_delete(oi->algbounds);
  gt_free(oi);
}

// Assembly:
testq %rdi, %rdi
je 0x1b5ed7
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x11bdbf
movq 0x30(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11c144
leaq 0x1f24e8(%rip), %rsi    # 0x3a83b1
movq %rbx, %rdi
movl $0x231, %edx            # imm = 0x231
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_check_set_out_opts
static int gt_index_options_check_set_out_opts(void *oip, GtError *err)
{
  int had_err = 0;
  GtIndexOptions *oi = (GtIndexOptions*) oip;
  gt_assert(oi != NULL && oi->type != GT_INDEX_OPTIONS_UNDEFINED);
  gt_error_check(err);

  if (!had_err) {
    int retval;
    retval = gt_readmode_parse(gt_str_get(oi->dir), err);
    if (retval < 0) {
      had_err = -1;
    } else {
      oi->readmode = (GtReadmode) retval;
      if (oi->type == GT_INDEX_OPTIONS_PACKED
            && (oi->readmode == GT_READMODE_COMPL
                  || oi->readmode == GT_READMODE_REVCOMPL)) {
        gt_error_set(err,"construction of packed index not possible for "
                         "complemented and for reverse complemented sequences");
        had_err = -1;
      }
    }
  }
  if (!had_err && oi->type == GT_INDEX_OPTIONS_PACKED) {
#ifndef S_SPLINT_S
    gt_computePackedIndexDefaults(&oi->bwtIdxParams, BWTBaseFeatures);
#endif
  }
  if (!had_err && gt_option_is_set(oi->optionkys)) {
    oi->outkystab = true;
    if (strcmp(gt_str_get(oi->kysargumentstring), "sort") == 0) {
      oi->outkyssort = true;
    } else {
      if (strcmp(gt_str_get(oi->kysargumentstring),"nosort") != 0) {
        gt_error_set(err,"illegal argument to option -kys: either use no "
                         "argument or argument \"sort\"");
        had_err = -1;
      }
    }
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b629a
movq %rdi, %r14
cmpl $0x0, 0x88(%rdi)
je 0x1b629a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b61ce
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1b629f
movq 0x38(%r14), %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x113107
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x1b6293
movl %eax, 0x18(%r14)
movl 0x88(%r14), %ecx
movl %ecx, %edx
xorl $0x2, %edx
andl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
xorl $0x2, %eax
orl %edx, %eax
jne 0x1b6223
leaq 0x1f2b4f(%rip), %rsi    # 0x3a8d61
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1b6293
cmpl $0x2, %ecx
jne 0x1b6236
leaq 0x118(%r14), %rdi
xorl %esi, %esi
callq 0x19b6a3
movq 0x110(%r14), %rdi
callq 0x10ac3f
xorl %ebp, %ebp
testb %al, %al
je 0x1b6293
movb $0x1, 0x20(%r14)
movq 0x28(%r14), %rdi
callq 0x11b0a1
leaq 0x1f25b7(%rip), %rsi    # 0x3a8814
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1b628e
movq 0x28(%r14), %rdi
callq 0x11b0a1
leaq 0x1f29b5(%rip), %rsi    # 0x3a8c2e
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1b6293
leaq 0x1f2b37(%rip), %rsi    # 0x3a8dc3
jmp 0x1b6212
movb $0x1, 0x21(%r14)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x66589
callq 0x66550
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_maxbasepower
unsigned int gt_maxbasepower(unsigned int numofchars)
{
  GtCodetype minfailure, thepower = (GtCodetype) 1;
  unsigned int i;

  minfailure = GT_CODETYPE_MAX/(GtCodetype) numofchars;
  for (i=0; thepower < minfailure; i++)
  {
    thepower *= numofchars;
  }
  return i;
}

// Assembly:
movl %edi, %esi
xorl %ecx, %ecx
movq $-0x1, %rax
xorl %edx, %edx
divq %rsi
movl $0x1, %edx
imulq %rsi, %rdx
incl %ecx
cmpq %rax, %rdx
jb 0x1b62b9
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_initbasepower
GtCodetype *gt_initbasepower(unsigned int numofchars,unsigned int prefixlength)
{
  GtCodetype thepower = (GtCodetype) 1, *basepower;
  unsigned int i;

  basepower = gt_malloc(sizeof *basepower * (prefixlength+1));
  for (i=0; /* Nothing */; i++)
  {
    basepower[i] = thepower;
    if (i == prefixlength)
    {
      break;
    }
    gt_assert(thepower < GT_CODETYPE_MAX/(GtCodetype) numofchars);
    thepower *= numofchars;
  }
  return basepower;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leal 0x1(%rbx), %edi
shlq $0x3, %rdi
leaq 0x1f2b32(%rip), %rsi    # 0x3a8e0e
movl $0x29, %edx
callq 0x104226
movq %rax, %rcx
movq $0x1, (%rax)
testl %ebx, %ebx
je 0x1b6322
movl %ebp, %esi
xorl %edi, %edi
movq $-0x1, %rax
xorl %edx, %edx
divq %rsi
movl %ebx, %edx
movl $0x1, %r8d
cmpq %rax, %r8
jae 0x1b632c
imulq %rsi, %r8
movq %r8, 0x8(%rcx,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x1b630c
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x665c2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_filllargestchartable
GtCodetype *gt_filllargestchartable(unsigned int numofchars,
                                    unsigned int kmersize)
{
  GtCodetype code, *ptr, *filltable;

  filltable = gt_malloc(sizeof *filltable * kmersize);
  code = (GtCodetype) numofchars;
  for (ptr = filltable + kmersize - 1; ptr >= filltable; ptr--)
  {
    *ptr = code-1;
    gt_assert(code <= GT_CODETYPE_MAX/(GtCodetype) numofchars);
    code *= numofchars;
  }
  return filltable;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %esi, %r14d
leaq (,%r14,8), %rdi
leaq 0x1f2ac5(%rip), %rsi    # 0x3a8e0e
movl $0x3c, %edx
callq 0x104226
movq %rax, %rcx
leaq (%rax,%r14,8), %rdi
addq $-0x8, %rdi
cmpq %rax, %rdi
jb 0x1b6384
movl %ebx, %esi
movq %rsi, %r8
leaq -0x1(%r8), %rax
movq %rax, (%rdi)
movq %rsi, %rax
mulq %r8
jo 0x1b638f
imulq %rsi, %r8
addq $-0x8, %rdi
cmpq %rcx, %rdi
jae 0x1b6368
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x665f9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_initfilltable
GtCodetype *gt_initfilltable(unsigned int numofchars,unsigned int prefixlength)
{
  unsigned int i;
  GtCodetype *filltable, *basepower;

  basepower = gt_initbasepower(numofchars,prefixlength);
  filltable = gt_malloc(sizeof *filltable * prefixlength);
  for (i=0; i<prefixlength; i++)
  {
    filltable[i] = basepower[prefixlength-i]-1;
  }
  gt_free(basepower);
  return filltable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
callq 0x1b62c7
movq %rax, %rbx
movl %ebp, %r15d
leaq (,%r15,8), %rdi
leaq 0x1f2a57(%rip), %rsi    # 0x3a8e0e
movl $0x4d, %edx
callq 0x104226
movq %rax, %r14
testl %ebp, %ebp
je 0x1b63e1
movq %r14, %rax
movl %r15d, %ecx
movq (%rbx,%rcx,8), %rcx
decq %rcx
movq %rcx, (%rax)
addq $0x8, %rax
decq %r15
jne 0x1b63cb
leaq 0x1f2a26(%rip), %rsi    # 0x3a8e0e
movq %rbx, %rdi
movl $0x52, %edx
callq 0x1045eb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_initmultimappower
GtCodetype **gt_initmultimappower(unsigned int numofchars,unsigned int qvalue)
{
  int offset;
  unsigned int mapindex;
  GtCodetype thepower = (GtCodetype) 1, *mmptr, **multimappower;

  gt_array2dim_malloc(multimappower,(GtUword) qvalue,numofchars);
  for (offset = (int) (qvalue - 1); offset>=0; offset--)
  {
    mmptr = multimappower[offset];
    mmptr[0] = 0;
    for (mapindex = 1U; mapindex < numofchars; mapindex++)
    {
      gt_assert(mmptr[mapindex-1] <= GT_CODETYPE_MAX - thepower);
      mmptr[mapindex] = mmptr[mapindex-1] + thepower;
    }
    gt_assert(thepower <= GT_CODETYPE_MAX/(GtUword) numofchars);
    thepower *= numofchars;
  }
  return multimappower;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl %esi, %r13d
leaq (,%r13,8), %r12
leaq 0x1f29ea(%rip), %rsi    # 0x3a8e0e
movq %r12, %rdi
movl $0x5c, %edx
callq 0x104226
movq %rax, %r14
movl %ebx, %r15d
imulq %r15, %r12
movq %r12, %rdi
leaq 0x1f29c9(%rip), %rsi    # 0x3a8e0e
movl $0x5c, %edx
callq 0x104226
movq %rax, (%r14)
cmpl $0x2, %ebp
jb 0x1b6479
leaq (,%r15,8), %rax
movq (%r14), %rcx
addq %rax, %rcx
movl $0x1, %edx
movq %rcx, (%r14,%rdx,8)
incq %rdx
addq %rax, %rcx
cmpq %rdx, %r13
jne 0x1b646a
decl %ebp
js 0x1b64ce
movl %ebp, %ecx
movl $0x1, %esi
movq (%r14,%rcx,8), %rax
movq $0x0, (%rax)
cmpl $0x2, %ebx
jb 0x1b64b6
movq %rsi, %rdx
notq %rdx
movl $0x1, %edi
xorl %r8d, %r8d
cmpq %rdx, %r8
ja 0x1b64e0
addq %rsi, %r8
movq %r8, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %r15
jne 0x1b64a2
movq %r15, %rax
mulq %rsi
jo 0x1b64e5
imulq %r15, %rsi
leaq -0x1(%rcx), %rax
testq %rcx, %rcx
movq %rax, %rcx
jg 0x1b6484
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x66667
callq 0x66630
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_raw_score
GtWord gt_evalue_raw_score(const GtKarlinAltschulStat *ka,
                           GtUword matches,
                           GtUword mismatches,
                           GtUword indels)
{
  GtWord matchscore, mismatchscore, gapscore;

  gt_assert(ka != NULL);
  matchscore = gt_karlin_altschul_stat_matchscore(ka);
  mismatchscore = gt_karlin_altschul_stat_mismatchscore(ka);
  gapscore = gt_karlin_altschul_stat_gapscore(ka);
  gt_assert(matchscore > 0 && mismatchscore < 0 && gapscore < 0);
  return (GtWord) matches * matchscore +
         (GtWord) mismatches * mismatchscore +
         (GtWord) indels * gapscore;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1b785f
movq 0x38(%rdi), %r8
testq %r8, %r8
jle 0x1b7864
movq 0x40(%rdi), %r9
testq %r9, %r9
jns 0x1b7864
movq 0x48(%rdi), %rax
testq %rax, %rax
jns 0x1b7864
imulq %rsi, %r8
imulq %rdx, %r9
addq %r8, %r9
imulq %rcx, %rax
addq %r9, %rax
popq %rcx
retq
callq 0x66b1d
callq 0x66ae4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_bit_score2raw_score
GtWord gt_evalue_bit_score2raw_score(const GtKarlinAltschulStat *ka,
                                     double bit_score)
{
  double raw_score, lambda, logK;

  gt_assert(ka != NULL);
  lambda = gt_karlin_altschul_stat_get_lambda(ka);
  logK = gt_karlin_altschul_stat_get_logK(ka);

  raw_score = (bit_score * ka->log2 + logK)/lambda;
  return (GtWord) round(raw_score);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1b78a8
mulsd 0x30(%rdi), %xmm0
addsd 0x10(%rdi), %xmm0
divsd (%rdi), %xmm0
callq 0x172e0
cvttsd2si %xmm0, %rax
popq %rcx
retq
callq 0x66b8f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_from_bitscore
double gt_evalue_from_bitscore(const GtKarlinAltschulStat *ka,
                               double bit_score,
                               GtUword searchspace)
{
  GtWord raw_score;

  gt_assert(ka != NULL);
  raw_score = gt_evalue_bit_score2raw_score(ka, bit_score);
  return gt_evalue_from_raw_score(ka,raw_score,searchspace);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x1b798c
movq %rsi, %rbx
movsd (%rdi), %xmm2
movsd %xmm2, (%rsp)
movsd 0x10(%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0x30(%rdi), %xmm0
addsd %xmm1, %xmm0
divsd %xmm2, %xmm0
callq 0x172e0
cvttsd2si %xmm0, %rax
movq %rbx, %xmm0
punpckldq 0x18ff96(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x18ff9e(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
mulsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
callq 0x17e30
mulsd 0x10(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
callq 0x66c01
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_from_eop_count
double gt_evalue_from_eop_count(const GtKarlinAltschulStat *ka,
                                GtUword matches,
                                GtUword mismatches,
                                GtUword indels,
                                GtUword searchspace)
{
  GtWord raw_score;

  gt_assert(ka != NULL);
  raw_score = gt_evalue_raw_score(ka, matches, mismatches, indels);
  return gt_evalue_from_raw_score(ka,raw_score,searchspace);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1b79f5
movq %r8, %r14
movq %rdi, %rbx
callq 0x1b782a
movq %r14, %xmm0
punpckldq 0x18ff2b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x18ff33(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x10(%rbx), %xmm0
mulsd (%rbx), %xmm1
subsd %xmm1, %xmm0
callq 0x17e30
mulsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x66c3a
// File: /workspace/github_c_makefile_star2_O3/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 0x1f19be(%rip), %rsi    # 0x3a9690
movl $0x28, %edi
movl $0x1d, %edx
callq 0x104226
subl %r14d, %ebp
jb 0x1b7d8b
movq %rax, %rbx
movl %r14d, 0x8(%rax)
movl %r12d, %edi
movl %r14d, %esi
callq 0x105ed6
movq %rax, 0x10(%rbx)
addl %ebp, %ebp
leaq -0x1(%rax), %r14
xorl %ecx, %ecx
testb %r15b, %r15b
cmovnel %ecx, %ebp
movq $-0x1, %rcx
cmovneq %r14, %rcx
movl %ebp, 0xc(%rbx)
movq %rcx, 0x18(%rbx)
shrq $0x3, %r14
andq $-0x8, %r14
movl $0x8, %r15d
addq %r15, %r14
cmpq $0x40, %rax
cmovbq %r15, %r14
leaq 0x1f1950(%rip), %rdx    # 0x3a9690
xorl %edi, %edi
movq %r14, %rsi
movl $0x2a, %ecx
callq 0x104461
movq %rax, 0x20(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x173a0
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
callq 0x66c73
// File: /workspace/github_c_makefile_star2_O3/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 0x1b7dc8
pushq %rbx
movq %rdi, %rbx
testb %sil, %sil
je 0x1b7db3
movq 0x20(%rbx), %rdi
leaq 0x1f18e7(%rip), %rsi    # 0x3a9690
movl $0x35, %edx
callq 0x1045eb
leaq 0x1f18d6(%rip), %rsi    # 0x3a9690
movq %rbx, %rdi
movl $0x37, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b7e05
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 0x1b7dfd
retq
orq %r8, %rdi
movq %rdi, (%rax,%rdx,8)
retq
pushq %rax
callq 0x66caa
// File: /workspace/github_c_makefile_star2_O3/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 0x1b7e4e
testq %rax, %rax
je 0x1b7e53
callq 0x66d18
testq %rax, %rax
je 0x1b7e55
popq %rax
retq
callq 0x66ce1
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdx, (%rsp)
movq %rsi, %rbp
movq %rdi, %r13
testq %r9, %r9
je 0x1b7e97
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1b7f1b
testq %rbp, %rbp
je 0x1b7ebc
addq $0x10, %r13
movq -0x10(%r13), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x17a40
testl %eax, %eax
je 0x1b7eda
addq $0x18, %r13
decq %rbp
jne 0x1b7ea0
leaq 0x1f18d8(%rip), %rsi    # 0x3a979b
movq %r14, %rdi
movq %r12, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x1b7f0c
movq (%rsp), %rdx
movl (%rdx), %eax
movl (%r13), %ecx
testl %eax, %ecx
je 0x1b7f06
leaq 0x1f187f(%rip), %rsi    # 0x3a976e
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1b7f0c
orl %eax, %ecx
movl %ecx, (%rdx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x66d4f
// File: /workspace/github_c_makefile_star2_O3/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 0x1b7f49
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1b7f98
testq %r13, %r13
je 0x1b7f6c
addq $0x10, %r12
movq -0x10(%r12), %rsi
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x1b7f8a
addq $0x18, %r12
decq %r13
jne 0x1b7f52
leaq 0x1f1828(%rip), %rsi    # 0x3a979b
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1b7f8e
movl (%r12), %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x66d86
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
movq %rdi, 0x8(%rsp)
je 0x1b7fde
xorl %r14d, %r14d
movq %rdi, %rbx
movq %rsi, %r13
movq %rsi, %r15
movq (%rbx), %rdi
callq 0x172f0
cmpq %rax, %r14
cmovbeq %rax, %r14
addq $0x18, %rbx
decq %r15
jne 0x1b7fc4
jmp 0x1b7fe4
movq %rsi, %r13
xorl %r14d, %r14d
leaq 0x1f17e9(%rip), %rdi    # 0x3a97d4
callq 0x11acc9
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x11acf3
leaq 0x20809a(%rip), %rsi    # 0x3c009f
movq %r15, %rdi
callq 0x11acf3
movq %r13, %rax
testq %r13, %r13
movq 0x8(%rsp), %r13
je 0x1b80c0
xorl %ebp, %ebp
leaq 0x20a0f9(%rip), %r12    # 0x3c2120
movq %rax, 0x10(%rsp)
leaq (,%rbp,2), %rbx
addq %rbp, %rbx
movq (%r13,%rbx,8), %rsi
movq %r15, %rdi
callq 0x11acf3
movq %r15, %rdi
leaq 0x1cb766(%rip), %rsi    # 0x3837b4
callq 0x11acf3
movq (%r13,%rbx,8), %rdi
callq 0x172f0
movq %r14, %r13
subq %rax, %r13
je 0x1b8075
movq %r15, %rdi
movq %r12, %rsi
callq 0x11acf3
decq %r13
jne 0x1b8065
movq 0x8(%rsp), %r13
leaq (,%rbx,8), %rbx
addq %r13, %rbx
movq %r15, %rdi
leaq 0x1f177b(%rip), %rsi    # 0x3a980a
callq 0x11acf3
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x11acf3
movq %r15, %rdi
leaq 0x207ff5(%rip), %rsi    # 0x3c009f
callq 0x11acf3
incq %rbp
movq 0x10(%rsp), %rax
cmpq %rax, %rbp
jne 0x1b802c
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_O3/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:
testq %rsi, %rsi
je 0x1b8119
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %r15
leaq 0x211e92(%rip), %r12    # 0x3c9f84
testl %ebx, (%r15)
je 0x1b8105
movq -0x10(%r15), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x17070
addq $0x18, %r15
decq %r14
jne 0x1b80f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xa, %edi
jmp 0x17a20
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b81a9
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x1b8141
callq 0xfdc54
jmp 0x1b8159
movq 0x18(%rbx), %rax
movq (%rax), %rdi
leaq 0x1f16da(%rip), %rsi    # 0x3a9829
movl $0x62, %edx
callq 0x1045eb
movq 0x18(%rbx), %rax
xorl %r15d, %r15d
movq %r15, (%rax)
movq 0x18(%rbx), %rdi
leaq 0x1f16bb(%rip), %r14    # 0x3a9829
movq %r14, %rsi
movl $0x68, %edx
callq 0x1045eb
movq %r15, 0x18(%rbx)
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x6a, %edx
callq 0x1045eb
movq %r15, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6c, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1045eb
callq 0x66dbd
// File: /workspace/github_c_makefile_star2_O3/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 0x1f12d7(%rip), %rsi    # 0x3a9829
movl $0x30, %edi
movl $0x41, %edx
callq 0x104226
movq %rax, %rbx
movl %r15d, %edi
movl %r14d, %esi
callq 0x1b62c7
movq %rax, 0x28(%rbx)
movl %r15d, (%rbx)
movl %r14d, 0x4(%rbx)
leal 0x1(%r14), %ecx
cmpl $0x1, %ecx
adcl $0x1, %r14d
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %edx, %edx
xorl %esi, %esi
addq (%rax,%rdx,8), %rsi
movq %rsi, 0x10(%rbx)
incq %rdx
cmpq %rdx, %r14
jne 0x1b8590
movl %ecx, %edi
shlq $0x3, %rdi
leaq 0x1f127c(%rip), %rsi    # 0x3a9829
movl $0x4b, %edx
callq 0x104226
movq %rax, 0x18(%rbx)
testb %bpl, %bpl
je 0x1b8651
movq $0x0, 0x20(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x4, %rdi
leaq 0x1f124e(%rip), %rsi    # 0x3a9829
movl $0x4f, %edx
callq 0x104226
movq 0x18(%rbx), %rcx
movq %rax, (%rcx)
movq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x1b8626
movq 0x18(%rbx), %rcx
movq (%rcx), %rdi
shlq $0x4, %rax
addq %rdi, %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
cmovbeq %rcx, %rax
movq %rdi, %rdx
notq %rdx
addq %rax, %rdx
andq $-0x10, %rdx
addq $0x10, %rdx
xorl %esi, %esi
callq 0x173a0
movl 0x4(%rbx), %eax
testq %rax, %rax
je 0x1b8651
xorl %ecx, %ecx
movq 0x18(%rbx), %rdx
movq 0x28(%rbx), %rsi
movq (%rsi,%rcx,8), %rsi
shlq $0x4, %rsi
addq (%rdx,%rcx,8), %rsi
movq %rsi, 0x8(%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1b8630
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b86bb
testq %rsi, %rsi
je 0x1b86bb
movl 0x10(%rsi), %eax
cmpl 0x4(%rdi), %eax
ja 0x1b86c0
movq 0x18(%rsi), %rcx
movq 0x28(%rdi), %rdx
cmpq (%rdx,%rax,8), %rcx
ja 0x1b86c5
movq 0x18(%rdi), %rdx
movq (%rdx,%rax,8), %rax
shlq $0x4, %rcx
cmpq $0x0, (%rax,%rcx)
jne 0x1b86b6
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0x1b86b6
movq 0x8(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
jae 0x1b86ca
incq %rcx
movq %rcx, 0x8(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rax)
popq %rax
retq
callq 0x66f48
callq 0x66f11
callq 0x66fed
callq 0x66fb6
callq 0x66f7f
// File: /workspace/github_c_makefile_star2_O3/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 0x1b86f2
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1b8770
leaq 0x1f1214(%rip), %rsi    # 0x3a990d
leaq 0x19d3e1(%rip), %rdx    # 0x355ae1
leaq 0x1f1122(%rip), %rcx    # 0x3a9829
movq %r15, %rdi
movl $0xe2, %r8d
movq %r14, %r9
callq 0xfcf97
testq %rax, %rax
je 0x1b8761
movq %rax, %r14
movl 0x4(%rbx), %eax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x11f89c
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movl $0x10, %esi
movq %r14, %rcx
callq 0x11f89c
movq %r14, %rdi
callq 0xfd018
xorl %eax, %eax
jmp 0x1b8766
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x67024
// File: /workspace/github_c_makefile_star2_O3/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 0x11acc9
movq %rax, %rbx
leaq 0x1f1186(%rip), %rsi    # 0x3a990d
movq %rax, %rdi
callq 0x11acf3
movq %rbx, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff28c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11bdbf
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b87d8
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1b886d
leaq 0x1f112e(%rip), %rsi    # 0x3a990d
leaq 0x1f1043(%rip), %rcx    # 0x3a9829
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movl $0x106, %r8d            # imm = 0x106
movq %r14, %r9
callq 0xfdd02
testq %rax, %rax
je 0x1b8861
movq %rax, %r14
movl (%rax), %esi
movl %ebx, %edi
xorl %edx, %edx
callq 0x1b853c
movq %r14, 0x20(%rax)
addq $0x8, %r14
movq 0x18(%rax), %rcx
movq %r14, (%rcx)
movl 0x4(%rax), %ecx
testq %rcx, %rcx
je 0x1b8849
xorl %edx, %edx
movq 0x18(%rax), %rsi
movq 0x28(%rax), %rdi
movq (%rdi,%rdx,8), %rdi
shlq $0x4, %rdi
addq (%rsi,%rdx,8), %rdi
movq %rdi, 0x8(%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x1b8828
movq 0x10(%rax), %rcx
shlq $0x4, %rcx
orq $0x8, %rcx
cmpq %rcx, 0x8(%rsp)
je 0x1b8863
callq 0x67096
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x6705d
// File: /workspace/github_c_makefile_star2_O3/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 0x1b93fb
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x31a0dd
movq 0x48(%rbx), %rdi
callq 0x1e0bbb
cmpq $0x0, (%rbx)
je 0x1b9388
movq 0x18(%rbx), %rdi
leaq 0x1f09d1(%rip), %rsi    # 0x3a9d4f
movl $0xcf, %edx
callq 0x1045eb
cmpq $0x0, 0x8(%rbx)
je 0x1b93a4
movq 0x20(%rbx), %rdi
leaq 0x1f09b5(%rip), %rsi    # 0x3a9d4f
movl $0xd3, %edx
callq 0x1045eb
movq 0x28(%rbx), %rdi
callq 0x3186ac
movq 0x30(%rbx), %rdi
callq 0x3181fe
movq 0x38(%rbx), %rdi
callq 0x3181fe
movq 0x58(%rbx), %rdi
callq 0xe9204
movq 0x60(%rbx), %rdi
callq 0xe9204
movq 0xb0(%rbx), %rdi
callq 0x1afabf
movq 0x68(%rbx), %rdi
callq 0xfbf9f
leaq 0x1f0962(%rip), %rsi    # 0x3a9d4f
movq %rbx, %rdi
movl $0xdc, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b97fe
callq 0x317f5a
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 0x318d89
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 0x319e41