LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-front-prune.c
// Function: ft_sequenceobject_get_char
static GtUchar ft_sequenceobject_get_char(GtFtSequenceObject *seq,GtUword idx)
{
  GtUchar cc;
  GtUword accesspos;

  if (seq->twobitencoding != NULL)
  {
    gt_assert (seq->read_seq_left2right || seq->offset >= idx);
    accesspos = seq->read_seq_left2right ? seq->offset + idx
                                         : seq->offset - idx;
    gt_assert(accesspos < seq->seqstartpos + seq->totallength);
    cc = gt_twobitencoding_char_at_pos(seq->twobitencoding, accesspos);
    return seq->dir_is_complement ? GT_COMPLEMENTBASE(cc) : cc;
  }
  if (seq->encseqreader != NULL)
  {
    cc = gt_sequenceobject_esr_get(seq,idx);
  } else
  {
    gt_assert (seq->read_seq_left2right || seq->offset >= idx);
    accesspos = seq->read_seq_left2right ? seq->offset + idx
                                         : seq->offset - idx;
    if (seq->encseq != NULL)
    {
      cc = gt_encseq_get_encoded_char(seq->encseq,accesspos,
                                      GT_READMODE_FORWARD);
    } else
    {
      gt_assert(seq->bytesequenceptr != NULL);
      cc = seq->bytesequenceptr[accesspos];
    }
  }
  if (seq->dir_is_complement && cc != GT_WILDCARD)
  {
    return GT_COMPLEMENTBASE(cc);
  }
  return cc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x329417
movb 0x58(%rbx), %cl
testb %cl, %cl
jne 0x329411
cmpq %rsi, 0x48(%rbx)
jb 0x3294be
testb %cl, %cl
je 0x329428
addq 0x48(%rbx), %rsi
jmp 0x329432
cmpq $0x0, 0x18(%rbx)
je 0x32945f
movq %rbx, %rdi
callq 0x32933f
jmp 0x329490
movq 0x48(%rbx), %rcx
subq %rsi, %rcx
movq %rcx, %rsi
movq 0x38(%rbx), %rcx
addq 0x50(%rbx), %rcx
cmpq %rcx, %rsi
jae 0x3294b9
movq %rsi, %rcx
shrq $0x5, %rcx
movq (%rax,%rcx,8), %rax
notl %esi
addl %esi, %esi
movl %esi, %ecx
shrq %cl, %rax
andb $0x3, %al
movzbl %al, %ecx
xorb $0x3, %al
movzbl %al, %eax
jmp 0x3294a2
movb 0x58(%rbx), %al
testb %al, %al
jne 0x329470
cmpq %rsi, 0x48(%rbx)
jb 0x3294c3
testb %al, %al
je 0x329476
addq 0x48(%rbx), %rsi
jmp 0x329480
movq 0x48(%rbx), %rax
subq %rsi, %rax
movq %rax, %rsi
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3294ab
xorl %edx, %edx
callq 0xec1f8
movl %eax, %ecx
movb $0x3, %al
subb %cl, %al
cmpb $-0x2, %cl
movzbl %al, %eax
movzbl %cl, %ecx
cmovel %ecx, %eax
cmpb $0x0, 0x59(%rbx)
cmovel %ecx, %eax
popq %rbx
retq
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x3294c8
movb (%rax,%rsi), %cl
jmp 0x329492
callq 0x956ff
callq 0x956c6
callq 0x95738
callq 0x95771
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hashfirstcodes.c
// Function: gt_insertallcodeswithhashtable
static void gt_insertallcodeswithhashtable(void *processinfo,
                                           GT_UNUSED bool firstinrange,
                                           GtUword pos,
                                           GtCodetype code)
{
  GtHashfirstcodes *hashfirstcodes = (GtHashfirstcodes *) processinfo;

  GtUword idx = gt_uint64hashtable_insertionindex(hashfirstcodes->table,
                                                        (uint64_t) code);
  if (idx != ULONG_MAX)
  {
    gt_assert(idx < hashfirstcodes->finalpsum);
    hashfirstcodes->suftab[idx] = pos;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rcx, %rsi
callq 0x18bf68
cmpq $-0x1, %rax
je 0x3297a3
cmpq 0x20(%r14), %rax
jae 0x3297ab
movq 0x18(%r14), %rcx
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x9581a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_new
GtHplstore *gt_hplstore_new(GtUword nofelements)
{
  GtHplstore *hplstore;
  gt_assert(nofelements > 0);
  hplstore = gt_malloc(sizeof (GtHplstore));
  hplstore->nofelements = nofelements;
  hplstore->space = gt_malloc(sizeof (*hplstore->space) * nofelements);
  gt_log_log("initialized GtHplstore %p for " GT_WU " values", hplstore,
             nofelements);
  hplstore->finalized = false;
  return hplstore;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x329812
movq %rdi, %rbx
leaq 0xc40db(%rip), %r14     # 0x3ed89f
movl $0x18, %edi
movq %r14, %rsi
movl $0x23, %edx
callq 0x1092b2
movq %rax, %r15
movq %rbx, 0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x25, %edx
callq 0x1092b2
movq %rax, (%r15)
leaq 0xc40bd(%rip), %rdi     # 0x3ed8b4
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x108e02
movb $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x95851
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_finalize
void gt_hplstore_finalize(GtHplstore *hplstore, GtUword nofelements)
{
  gt_assert(hplstore != NULL);
  gt_assert(!hplstore->finalized);
  gt_assert(nofelements <= hplstore->nofelements);
  if (nofelements < hplstore->nofelements)
  {
    hplstore->nofelements = nofelements;
    hplstore->space = gt_realloc(hplstore->space,
       sizeof (*hplstore->space) * nofelements);
  }
  hplstore->finalized = true;
  gt_log_log("finalized GtHplstore %p to " GT_WU " values", hplstore,
             nofelements);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3298ad
movq %rdi, %r14
cmpb $0x1, 0x10(%rdi)
je 0x3298b2
movq %rsi, %rbx
cmpq %rsi, 0x8(%r14)
jb 0x3298b7
jbe 0x32988d
movq %rbx, 0x8(%r14)
movq (%r14), %rdi
leaq 0xc4022(%rip), %rdx     # 0x3ed89f
movq %rbx, %rsi
movl $0x3e, %ecx
callq 0x1094e6
movq %rax, (%r14)
movb $0x1, 0x10(%r14)
leaq 0xc40a4(%rip), %rdi     # 0x3ed93d
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x108e02
callq 0x958f6
callq 0x958bf
callq 0x95888
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_set
void gt_hplstore_set(GtHplstore *hplstore, GtUword pos, uint8_t value)
{
  gt_assert(hplstore != NULL);
  gt_assert(!hplstore->finalized);
  gt_assert(value <= GT_HPLSTORE_MAX);
  gt_assert(value != GT_HPLSTORE_UNDEF);
  hplstore->space[pos] = value;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3298d5
cmpb $0x1, 0x10(%rdi)
je 0x3298da
cmpb $-0x1, %dl
je 0x3298df
movq (%rdi), %rax
movb %dl, (%rax,%rsi)
popq %rax
retq
callq 0x9599b
callq 0x95964
callq 0x9592d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_get
uint8_t gt_hplstore_get(GtHplstore *hplstore, GtUword pos)
{
  gt_assert(hplstore != NULL);
  gt_assert(hplstore->finalized);
  return (pos < hplstore->nofelements) ? hplstore->space[pos] :
    hplstore->space[GT_MULT2(hplstore->nofelements) - pos - 1UL];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x329912
cmpb $0x0, 0x10(%rdi)
je 0x329917
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rsi, %rdx
notq %rdx
leaq (%rax,%rcx,2), %rdi
addq %rsi, %rax
addq %rdx, %rdi
cmpq %rsi, %rcx
cmovaq %rax, %rdi
movb (%rdi), %al
popq %rcx
retq
callq 0x95a09
callq 0x959d2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_get_range
void gt_hplstore_get_range(const GtHplstore *hplstore, uint8_t *hplengths,
    GtUword from, GtUword nofelements)
{
  GtUword i;
  gt_assert(hplstore != NULL);
  gt_assert(hplstore->finalized);
  gt_assert(from < GT_MULT2(hplstore->nofelements) - 1UL);
  if (from < hplstore->nofelements)
  {
    for (i = 0; i < nofelements; i++)
      hplengths[i] = hplstore->space[from + i];
  }
  else
  {
    from = GT_MULT2(hplstore->nofelements) - from;
    for (i = 0; i < nofelements; i++)
      hplengths[i] = hplstore->space[from--];
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x329982
cmpb $0x0, 0x10(%rdi)
je 0x329987
movq 0x8(%rdi), %rax
leaq -0x1(,%rax,2), %r8
cmpq %rdx, %r8
jbe 0x32998c
cmpq %rdx, %rax
jbe 0x32995d
testq %rcx, %rcx
je 0x329980
xorl %eax, %eax
movq (%rdi), %r8
addq %rdx, %r8
movb (%rax,%r8), %r8b
movb %r8b, (%rsi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x329945
jmp 0x329980
testq %rcx, %rcx
je 0x329980
addq %rax, %rax
subq %rdx, %rax
xorl %edx, %edx
movq (%rdi), %r8
movb (%r8,%rax), %r8b
decq %rax
movb %r8b, (%rsi,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x32996a
popq %rax
retq
callq 0x95aae
callq 0x95a40
callq 0x95a77
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_show_decoded_sequence_using_hplengths
void gt_hplstore_show_decoded_sequence_using_hplengths(GtFile *outfile,
    const uint8_t *hplengths, const GtEncseq *encseq, GtUword encseq_from,
    GtUword nofelements)
{
  GtUword i;
  uint8_t rep;
  gt_assert(encseq != NULL);
  gt_assert(hplengths != NULL);
  for (i = 0; i < nofelements; i++)
  {
    char c = gt_encseq_get_decoded_char(encseq, encseq_from + i,
         GT_READMODE_FORWARD);
    uint8_t value = hplengths[i];
    if (value != GT_HPLSTORE_UNDEF)
    {
      value++;
      for (rep = 0; rep < value; rep++)
        gt_file_xfputc(c, outfile);
    }
    else
    {
      gt_file_xfputc(c, outfile);
      gt_file_xfputc('+', outfile);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rdx, %rdx
je 0x329a28
movq %rsi, %r12
testq %rsi, %rsi
je 0x329a2d
cmpq $0x0, 0x8(%rsp)
je 0x329a19
movq %rdx, %r15
movq %rdi, %r13
xorl %r14d, %r14d
movq 0x10(%rsp), %rax
leaq (%r14,%rax), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0xec478
movb (%r12,%r14), %bl
movsbl %al, %ebp
cmpb $-0x1, %bl
je 0x3299f8
incb %bl
movl %ebp, %edi
movq %r13, %rsi
callq 0x103f7f
decb %bl
jne 0x3299e8
jmp 0x329a0f
movl %ebp, %edi
movq %r13, %rsi
callq 0x103f7f
movl $0x2b, %edi
movq %r13, %rsi
callq 0x103f7f
incq %r14
cmpq 0x8(%rsp), %r14
jne 0x3299c7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x95b1c
callq 0x95ae5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_show_decoded_sequence
void gt_hplstore_show_decoded_sequence(GtFile *outfile,
    const GtHplstore *hplstore, const GtEncseq *encseq, GtUword from,
    GtUword nofelements)
{
  uint8_t *hplengths;
  gt_assert(encseq != NULL);
  gt_assert(hplstore != NULL);
  gt_assert(hplstore->finalized);
  if (from > hplstore->nofelements)
  {
    hplengths = gt_malloc(sizeof (*hplengths) * nofelements);
    gt_hplstore_get_range(hplstore, hplengths, from, nofelements);
  }
  else
    hplengths = hplstore->space + from;
  gt_hplstore_show_decoded_sequence_using_hplengths(outfile, hplengths, encseq,
      from, nofelements);
  if (from > hplstore->nofelements)
    gt_free(hplengths);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x329aea
movq %rsi, %r14
testq %rsi, %rsi
je 0x329aef
cmpb $0x0, 0x10(%r14)
je 0x329af4
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r13
cmpq %rcx, 0x8(%r14)
jae 0x329a99
leaq 0xc3e29(%rip), %rsi     # 0x3ed89f
movq %r15, %rdi
movl $0x8f, %edx
callq 0x1092b2
movq %rax, %rbp
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x32991c
jmp 0x329a9f
movq (%r14), %rbp
addq %rbx, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x329991
cmpq %rbx, 0x8(%r14)
jae 0x329adb
leaq 0xc3ddf(%rip), %rsi     # 0x3ed89f
movq %rbp, %rdi
movl $0x97, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x109670
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x95bc5
callq 0x95b8c
callq 0x95b53
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_save
void gt_hplstore_save(const GtHplstore *hplstore, FILE *out_fp)
{
  gt_assert(hplstore != NULL);
  gt_assert(hplstore->space != NULL);
  gt_assert(hplstore->finalized);
  gt_assert(out_fp != NULL);
  gt_xfwrite(hplstore->space, sizeof (*hplstore->space),
      (size_t)hplstore->nofelements, out_fp);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x329b27
movq (%rdi), %rax
testq %rax, %rax
je 0x329b2c
cmpb $0x0, 0x10(%rdi)
je 0x329b31
movq %rsi, %rcx
testq %rsi, %rsi
je 0x329b36
movq 0x8(%rdi), %rdx
movl $0x1, %esi
movq %rax, %rdi
popq %rax
jmp 0x125658
callq 0x95ca9
callq 0x95c70
callq 0x95bfe
callq 0x95c37
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/hplstore.c
// Function: gt_hplstore_load
GtHplstore *gt_hplstore_load(FILE *in_fp, GtUword nofelements)
{
  GtHplstore *hplstore = gt_hplstore_new(nofelements);
  gt_assert(in_fp != NULL);
  (void)gt_xfread(hplstore->space, sizeof (*hplstore->space),
      (size_t)nofelements, in_fp);
  hplstore->finalized = true;
  return hplstore;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3297b0
testq %rbx, %rbx
je 0x329b77
movq %rax, %r15
movq (%rax), %rdi
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x125604
movb $0x1, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x95ce2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/initeqsvec.c
// Function: gt_initeqsvector
void gt_initeqsvector(GtUword *eqsvector,
                   GtUword eqslen,
                   const GtUchar *pattern,
                   GtUword patternlength)
{
  GtUword *eptr, shiftmask;
  const GtUchar *pptr;

  gt_assert(patternlength <=
            (GtUword) (CHAR_BIT * sizeof (GtUword)));
  for (eptr = eqsvector; eptr < eqsvector + eqslen; eptr++)
  {
    *eptr = 0;
  }
  for (pptr = pattern, shiftmask = 1UL;
       pptr < pattern + patternlength && shiftmask != 0;
       pptr++, shiftmask <<= 1)
  {
    gt_assert(*pptr != (GtUchar) GT_SEPARATOR);
    if (*pptr != (GtUchar) GT_WILDCARD)
    {
      eqsvector[(GtUword) *pptr] |= shiftmask;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x40, %rcx
ja 0x329c03
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
testq %rsi, %rsi
jle 0x329bbf
leaq (%r15,%rsi,8), %rax
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %r15, %rdx
notq %rdx
addq %rcx, %rdx
andq $-0x8, %rdx
addq $0x8, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x173a0
testq %rbx, %rbx
je 0x329bf8
addq %r14, %rbx
incq %r14
movl $0x1, %eax
movzbl -0x1(%r14), %ecx
cmpl $0xfe, %ecx
je 0x329be8
cmpl $0xff, %ecx
je 0x329bfe
orq %rax, (%r15,%rcx,8)
cmpq %rbx, %r14
jae 0x329bf8
addq %rax, %rax
incq %r14
testq %rax, %rax
jne 0x329bcf
popq %rbx
popq %r14
popq %r15
retq
callq 0x95d52
callq 0x95d1b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/initeqsvec.c
// Function: gt_initeqsvectorrev
void gt_initeqsvectorrev(GtUword *eqsvectorrev,
                      GtUword eqslen,
                      const GtUchar *pattern,
                      GtUword patternlength)
{
  GtUword *eptr, shiftmask;
  const GtUchar *pptr;

  gt_assert(patternlength <=
            (GtUword) (CHAR_BIT * sizeof (GtUword)));
  for (eptr = eqsvectorrev; eptr < eqsvectorrev + eqslen; eptr++)
  {
    *eptr = 0;
  }
  for (pptr = pattern+patternlength-1, shiftmask = 1UL;
       pptr >= pattern && shiftmask != 0;
       pptr--, shiftmask <<= 1)
  {
    gt_assert(*pptr != (GtUchar) GT_SEPARATOR);
    if (*pptr != (GtUchar) GT_WILDCARD)
    {
      eqsvectorrev[(GtUword) *pptr] |= shiftmask;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x40, %rcx
ja 0x329c9b
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jle 0x329c4f
leaq (%r14,%rsi,8), %rax
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %r14, %rdx
notq %rdx
addq %rcx, %rdx
andq $-0x8, %rdx
addq $0x8, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x173a0
leaq (%rbx,%r15), %rax
decq %rax
cmpq %rbx, %rax
jb 0x329c90
leaq (%r15,%rbx), %rax
addq $-0x2, %rax
movl $0x1, %ecx
movzbl 0x1(%rax), %edx
cmpl $0xfe, %edx
je 0x329c80
cmpl $0xff, %edx
je 0x329c96
orq %rcx, (%r14,%rdx,8)
cmpq %rbx, %rax
jb 0x329c90
addq %rcx, %rcx
decq %rax
testq %rcx, %rcx
jne 0x329c68
popq %rbx
popq %r14
popq %r15
retq
callq 0x95dc0
callq 0x95d89
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/merger-trie.c
// Function: getlcp
static GtUword getlcp(const GtEncseq *encseq1,
                            GtReadmode readmode1,
                            GtUword start1, GtUword end1,
                            const GtEncseq *encseq2,
                            GtReadmode readmode2,
                            GtUword start2, GtUword end2)
{
  GtUword i1, i2;
  GtUchar cc1;

  for (i1=start1, i2=start2; i1 <= end1 && i2 <= end2; i1++, i2++)
  {
    cc1 = gt_encseq_get_encoded_char(/*XXX*/ encseq1,i1,readmode1);
    if (cc1 != gt_encseq_get_encoded_char(/*XXX*/ encseq2,i2,readmode2)
          || GT_ISSPECIAL(cc1))
    {
      break;
    }
  }
  return i1 - start1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq 0x50(%rsp), %rbp
cmpq %rcx, %rdx
seta %al
cmpq 0x58(%rsp), %rbp
seta %cl
orb %al, %cl
movq %rdx, 0x8(%rsp)
jne 0x32a039
movl %esi, %r13d
movq %rdi, %rbx
movq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0xec1f8
movl %eax, %r14d
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movl 0x4(%rsp), %edx
callq 0xec1f8
cmpb $-0x3, %r14b
ja 0x32a039
cmpb %al, %r14b
jne 0x32a039
incq %r12
cmpq %r15, %r12
ja 0x32a039
incq %rbp
cmpq 0x58(%rsp), %rbp
jbe 0x329ffa
subq 0x8(%rsp), %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/merger-trie.c
// Function: mtrie_makenewbranch
static Mergertrienode *mtrie_makenewbranch(Mergertrierep *trierep,
                                     Suffixinfo *suffixinfo,
                                     GtUword currentdepth,
                                     Mergertrienode *oldnode)
{
  Mergertrienode *newbranch, *newleaf;
  GtUchar cc1, cc2;
  Encseqreadinfo *eri = trierep->encseqreadinfo + suffixinfo->idx;

#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
  printf("makenewbranch(ident=" Formatuint64_t ")\n",
          PRINTuint64_tcast(suffixinfo->ident));
#endif
#endif
  newbranch = newMergertrienode(trierep);
  newbranch->suffixinfo = *suffixinfo;
  newbranch->rightsibling = oldnode->rightsibling;
  cc1 = getfirstedgechar(trierep,oldnode,currentdepth);
  if (suffixinfo->startpos + currentdepth >=
      gt_encseq_total_length(eri->encseqptr))
  {
    cc2 = (GtUchar) GT_SEPARATOR;
  } else
  {
    cc2 = gt_encseq_get_encoded_char(eri->encseqptr,
                         suffixinfo->startpos + currentdepth,
                         eri->readmode);
  }
  newleaf = mtrie_makenewleaf(trierep,suffixinfo);
  if (mtrie_comparecharacters(cc1,oldnode->suffixinfo.idx,
                        cc2,suffixinfo->idx) <= 0)
  {
    makesuccs(newbranch,oldnode,newleaf);
  } else
  {
    makesuccs(newbranch,newleaf,oldnode);
  }
  newbranch->depth = currentdepth;
  return newbranch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rbp
movl (%rsi), %r14d
shlq $0x4, %r14
callq 0x32a30d
movups (%r12), %xmm0
movups %xmm0, (%rax)
movq 0x18(%r15), %rcx
movq %rax, 0x8(%rsp)
movq %rcx, 0x18(%rax)
movq %r13, %rdi
movq %r15, 0x10(%rsp)
movq %r15, %rsi
movq %rbx, %rdx
callq 0x32a343
movb %al, 0x7(%rsp)
movq 0x8(%r12), %r15
addq %rbx, %r15
movq (%rbp,%r14), %rdi
callq 0xec1d8
movb $-0x1, %cl
cmpq %rax, %r15
jae 0x32a0d7
addq %r14, %rbp
movq (%rbp), %rdi
movq 0x8(%r12), %rsi
addq %rbx, %rsi
movl 0x8(%rbp), %edx
callq 0xec1f8
movl %eax, %ecx
movl %ecx, %ebp
movq %r13, %rdi
callq 0x32a30d
movups (%r12), %xmm0
movups %xmm0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movb 0x7(%rsp), %dil
cmpb $-0x2, %dil
jb 0x32a11b
movl $0x1, %ecx
cmpb $-0x2, %bpl
movq 0x10(%rsp), %rsi
jb 0x32a13e
movl (%rsi), %edx
xorl %ecx, %ecx
cmpl %edx, (%r12)
adcl $-0x1, %ecx
orl $0x1, %ecx
jmp 0x32a13e
cmpb $-0x2, %bpl
setae %cl
cmpb %bpl, %dil
setb %dl
orb %cl, %dl
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rsi
jne 0x32a13e
xorl %ecx, %ecx
cmpb %bpl, %dil
seta %cl
testl %ecx, %ecx
jle 0x32a15e
movq $0x0, 0x18(%rsi)
movq %rsi, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
jne 0x32a176
jmp 0x32a17a
movq $0x0, 0x18(%rax)
movq %rax, 0x18(%rsi)
movq 0x8(%rsp), %rcx
movq %rsi, 0x10(%rcx)
movq %rsi, %rax
movq %rcx, 0x20(%rax)
movq %rbx, 0x28(%rcx)
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/merger-trie.c
// Function: gt_mergertrie_findsmallestnode
Mergertrienode *gt_mergertrie_findsmallestnode(const Mergertrierep *trierep)
{
  Mergertrienode *node;

  gt_assert(trierep->root != NULL);
  for (node = trierep->root; node->firstchild != NULL; node = node->firstchild)
    /* Nothing */ ;
  return node;
}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x32a1a8
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x32a19a
popq %rcx
retq
callq 0x95ea2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/merger-trie.c
// Function: gt_mergertrie_deletesmallestpath
void gt_mergertrie_deletesmallestpath(Mergertrienode *smallest,
                                   Mergertrierep *trierep)
{
  Mergertrienode *father, *son;

  for (son = smallest; son->parent != NULL; son = son->parent)
  {
    father = son->parent;
    if (son->firstchild == NULL)
    {
      SETFIRSTCHILD(father,son->rightsibling);
      SHOWNODERELATIONS(father);
      son->rightsibling = NULL;
    } else
    {
      if (son->firstchild->rightsibling != NULL)
      {
        break;
      }
      son->firstchild->rightsibling = father->firstchild->rightsibling;
      SETFIRSTCHILD(father,son->firstchild);
      SHOWNODERELATIONS(father);
      son->rightsibling = NULL;
      SETFIRSTCHILDNULL(son);
    }
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
    printf("delete %s " Formatuint64_t "\n",
             MTRIE_ISLEAF(son) ? "leaf" : "branch",
             PRINTuint64_tcast(son->suffixinfo.ident));
#endif
#endif
    trierep->unusedMergertrienodes[trierep->nextunused++] = son;
  }
  if (trierep->root->firstchild == NULL)
  {
    trierep->unusedMergertrienodes[trierep->nextunused++] = trierep->root;
    trierep->root = NULL;
  }
}

// Assembly:
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x32a22f
leaq 0x20(%rdi), %rax
xorps %xmm0, %xmm0
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x32a1f3
cmpq $0x0, 0x18(%rdx)
jne 0x32a22f
leaq 0x10(%rdi), %r8
movq 0x10(%rcx), %r9
movq 0x18(%r9), %r9
movq %r9, 0x18(%rdx)
movq %rdx, 0x10(%rcx)
movq (%r8), %rdx
testq %rdx, %rdx
je 0x32a1ed
movq %rcx, 0x20(%rdx)
movups %xmm0, (%r8)
jmp 0x32a20c
movq 0x18(%rdi), %rdx
movq %rdx, 0x10(%rcx)
testq %rdx, %rdx
je 0x32a204
movq %rcx, 0x20(%rdx)
movq $0x0, 0x18(%rdi)
movq 0x18(%rsi), %rcx
movl 0x24(%rsi), %edx
leal 0x1(%rdx), %r8d
movl %r8d, 0x24(%rsi)
movq %rdi, (%rcx,%rdx,8)
movq (%rax), %rdi
leaq 0x20(%rdi), %rax
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
jne 0x32a1bd
movq 0x10(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x32a23b
retq
movq 0x18(%rsi), %rcx
movl 0x24(%rsi), %edx
leal 0x1(%rdx), %edi
movl %edi, 0x24(%rsi)
movq %rax, (%rcx,%rdx,8)
movq $0x0, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/merger-trie.c
// Function: gt_mergertrie_initnodetable
void gt_mergertrie_initnodetable(Mergertrierep *trierep,
                              GtUword numofsuffixes,
                              unsigned int numofindexes)
{
  trierep->numofindexes = numofindexes;
  trierep->allocatedMergertrienode
    = (unsigned int) GT_MULT2(numofsuffixes + 1) + 1;
  trierep->nodetable = gt_malloc(sizeof *trierep->nodetable
                                 * trierep->allocatedMergertrienode);
  trierep->nextfreeMergertrienode = 0;
  trierep->root = NULL;
  trierep->nextunused = 0;
  trierep->unusedMergertrienodes
    = gt_malloc(sizeof *trierep->unusedMergertrienodes
                * trierep->allocatedMergertrienode);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, 0x20(%rdi)
leal 0x3(,%rsi,2), %eax
movl %eax, 0x28(%rdi)
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
leaq 0xc38c7(%rip), %r14     # 0x3edb3f
movq %r14, %rsi
movl $0x28f, %edx            # imm = 0x28F
callq 0x1092b2
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movl %eax, 0x2c(%rbx)
movq $0x0, 0x10(%rbx)
movl %eax, 0x24(%rbx)
movl 0x28(%rbx), %edi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x295, %edx            # imm = 0x295
callq 0x1092b2
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/merger-trie.c
// Function: gt_mergertrie_delete
void gt_mergertrie_delete(Mergertrierep *trierep)
{
  if (trierep != NULL)
  {
    gt_free(trierep->nodetable);
    gt_free(trierep->unusedMergertrienodes);
    gt_free(trierep->encseqreadinfo);
    trierep->encseqreadinfo = NULL;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x32a30c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xc386f(%rip), %r14     # 0x3edb3f
movq %r14, %rsi
movl $0x29c, %edx            # imm = 0x29C
callq 0x109670
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x29d, %edx            # imm = 0x29D
callq 0x109670
movq (%rbx), %rdi
movq %r14, %rsi
movl $0x29e, %edx            # imm = 0x29E
callq 0x109670
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/merger-trie.c
// Function: newMergertrienode
static Mergertrienode *newMergertrienode(Mergertrierep *trierep)
{
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
  printf("# available trie nodes: %u; ",
          trierep->allocatedMergertrienode - trierep->nextfreeMergertrienode);
  printf("unused trie nodes: %u\n",trierep->nextunused);
#endif
#endif
  if (trierep->nextfreeMergertrienode >= trierep->allocatedMergertrienode)
  {
    gt_assert(trierep->nextunused > 0);
    trierep->nextunused--;
    return trierep->unusedMergertrienodes[trierep->nextunused];
  }
  return trierep->nodetable + trierep->nextfreeMergertrienode++;
}

// Assembly:
movl 0x2c(%rdi), %eax
cmpl 0x28(%rdi), %eax
jae 0x32a328
leal 0x1(%rax), %ecx
movl %ecx, 0x2c(%rdi)
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq 0x8(%rdi), %rax
retq
movl 0x24(%rdi), %eax
testl %eax, %eax
je 0x32a33d
decl %eax
movl %eax, 0x24(%rdi)
movq 0x18(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
pushq %rax
callq 0x95edb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/merger-trie.c
// Function: getfirstedgechar
static GtUchar getfirstedgechar(const Mergertrierep *trierep,
                              const Mergertrienode *node,
                              GtUword prevdepth)
{
  Encseqreadinfo *eri = trierep->encseqreadinfo + node->suffixinfo.idx;

  if (MTRIE_ISLEAF(node) &&
      node->suffixinfo.startpos + prevdepth >=
      gt_encseq_total_length(eri->encseqptr))
  {
    return (GtUchar) GT_SEPARATOR;
  }
  return gt_encseq_get_encoded_char(eri->encseqptr, /* Random access */
                        node->suffixinfo.startpos + prevdepth,
                        eri->readmode);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl (%rsi), %r15d
shlq $0x4, %r15
addq (%rdi), %r15
cmpq $0x0, 0x10(%rsi)
jne 0x32a376
movq 0x8(%r14), %r12
addq %rbx, %r12
movq (%r15), %rdi
callq 0xec1d8
cmpq %rax, %r12
jae 0x32a394
movq (%r15), %rdi
addq 0x8(%r14), %rbx
movl 0x8(%r15), %edx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xec1f8
movb $-0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_initdfsconstinfo
static void pms_initdfsconstinfo(Limdfsconstinfo *mt,
                                 unsigned int alphasize,
                                 ...)
                                 /* Variable argument list is as follows:
                                    unsigned int alphasize
                                    const GtUchar *pattern,
                                    GtUword patternlength
                                 */
{
  va_list ap;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;
  const GtUchar *pattern;

  va_start(ap,alphasize);
  pattern = va_arg(ap, const GtUchar *);
  mti->patternlength = va_arg(ap, GtUword);
  va_end(ap);
  gt_initeqsvector(mti->eqsvector,(GtUword) alphasize,
                pattern,mti->patternlength);
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x32a449
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movl $0x10, %ecx
cmpq $0x28, %rcx
ja 0x32a486
movl $0x10, %eax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x32a494
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x32a4b0
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x32a4be
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x208(%rdi), %rdi
movl %esi, %esi
callq 0x329b7c
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_extractdfsconstinfo
static void pms_extractdfsconstinfo(Processresult processresult,
                                    void *processinfo,
                                    const void *patterninfo,
                                    Limdfsconstinfo *mt)
{
  GtUword idx;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;

  for (idx=0; idx<mti->patternlength; idx++)
  {
    processresult(processinfo,patterninfo,idx,mti->mstatlength[idx],
                                              mti->mstatwitnessleftbound[idx],
                                              mti->mstatwitnessrightbound[idx]);
  }
}

// Assembly:
cmpq $0x0, (%rcx)
je 0x32a52a
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq 0x8(%rbx,%r13,8), %rcx
movq 0x210(%rbx,%r13,8), %r8
movq 0x410(%rbx,%r13,8), %r9
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq *%r12
incq %r13
cmpq (%rbx), %r13
jb 0x32a4f8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_initLimdfsstate
static void pms_initLimdfsstate(DECLAREPTRDFSSTATE(aliascolumn),
                                Limdfsconstinfo *mt)
{
  GtMssufpatLimdfsstate *column = (GtMssufpatLimdfsstate *) aliascolumn;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;
  GtUword idx;

  column->prefixofsuffixbits = ~0UL;
  gt_assert(mti->patternlength <= (GtUword) GT_INTWORDSIZE);
  for (idx = 0; idx<mti->patternlength; idx++)
  {
    mti->mstatlength[idx] = 0;
    mti->mstatwitnessleftbound[idx] = 0;
    mti->mstatwitnessrightbound[idx] = 0;
  }
}

// Assembly:
movq $-0x1, (%rdi)
cmpq $0x40, (%rsi)
ja 0x32a5a4
cmpq $0x0, (%rsi)
je 0x32a5a3
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, 0x8(%rsi,%rcx,8)
movq %rax, 0x210(%rsi,%rcx,8)
movq %rax, 0x410(%rsi,%rcx,8)
incq %rcx
cmpq (%rsi), %rcx
jb 0x32a586
retq
pushq %rax
callq 0x95f14
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_fullmatchLimdfsstate
static void pms_fullmatchLimdfsstate(Limdfsresult *limdfsresult,
                                     DECLAREPTRDFSSTATE(aliascolumn),
                                     GtUword leftbound,
                                     GtUword rightbound,
                                     GT_UNUSED GtUword width,
                                     GtUword currentdepth,
                                     Limdfsconstinfo *mt)
{
  GtMssufpatLimdfsstate *limdfsstate = (GtMssufpatLimdfsstate *) aliascolumn;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;

  if (limdfsstate->prefixofsuffixbits > 0)
  {
    GtUword bitindex = 0,
                  first1,
                  tmp = limdfsstate->prefixofsuffixbits;
    do
    {
      first1 = zerosontheright(tmp);
      gt_assert(bitindex + first1 < mti->patternlength);
      if (mti->mstatlength[bitindex+first1] < currentdepth)
      {
        /*
        printf("set mstatlength["GT_WU"]="GT_WU"\n",
               bitindex+first1,currentdepth);
        printf("set mstatwitnessleftbound["GT_WU"]="GT_WU"\n",bitindex+first1,
                                                 (GtUword) leftbound);
        */
        mti->mstatlength[bitindex+first1] = currentdepth;
        mti->mstatwitnessleftbound[bitindex+first1] = leftbound;
        mti->mstatwitnessrightbound[bitindex+first1] = rightbound;
      }
      tmp >>= (first1+1);
      bitindex += (first1+1);
    } while (tmp != 0);
    limdfsresult->status = Limdfscontinue;
  } else
  {
    limdfsresult->status = Limdfsstop;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x32a695
movq %rcx, %rax
movq 0x20(%rsp), %r8
xorl %r10d, %r10d
testb $0x1, %sil
jne 0x32a650
movq %rsi, %rcx
shrq $0x20, %rcx
xorl %r11d, %r11d
testl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
sete %r11b
cmovneq %rsi, %rcx
shll $0x5, %r11d
leaq 0x1(%r11), %rbx
movq %rcx, %r14
shrq $0x10, %r14
orq $0x11, %r11
testw %cx, %cx
cmovneq %rcx, %r14
cmovneq %rbx, %r11
movq %r14, %rcx
shrq $0x8, %rcx
leaq 0x8(%r11), %rbx
testb %r14b, %r14b
cmovneq %r14, %rcx
cmovneq %r11, %rbx
movq %rcx, %r14
shrq $0x4, %r14
leaq 0x4(%rbx), %r15
testb $0xf, %cl
cmovneq %rcx, %r14
cmovneq %rbx, %r15
movl %r14d, %ecx
shrl $0x2, %ecx
leaq 0x2(%r15), %r11
testb $0x3, %r14b
cmovneq %r14, %rcx
cmovneq %r15, %r11
andl $0x1, %ecx
subq %rcx, %r11
jmp 0x32a653
xorl %r11d, %r11d
leaq (%r11,%r10), %rcx
cmpq (%r8), %rcx
jae 0x32a6a2
cmpq %r9, 0x8(%r8,%rcx,8)
jae 0x32a678
movq %r9, 0x8(%r8,%rcx,8)
movq %rdx, 0x210(%r8,%rcx,8)
movq %rax, 0x410(%r8,%rcx,8)
leaq 0x1(%r11), %rcx
shrq %cl, %rsi
addq %r11, %r10
incq %r10
testq %rsi, %rsi
jne 0x32a5c6
movl $0x1, %eax
jmp 0x32a69a
movl $0x2, %eax
movl %eax, (%rdi)
popq %rbx
popq %r14
popq %r15
retq
callq 0x95f4d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/myersapm.c
// Function: gt_newMyersonlineresources
Myersonlineresources *gt_newMyersonlineresources(unsigned int numofchars,
                                                 bool nowildcards,
                                                 const GtEncseq *encseq,
                                                 ProcessIdxMatch processmatch,
                                                 void *processmatchinfo)
{
  Myersonlineresources *mor;

  mor = gt_malloc(sizeof *mor);
  mor->eqsvectorrev = gt_malloc(sizeof *mor->eqsvectorrev * numofchars);
  mor->eqsvector = gt_malloc(sizeof *mor->eqsvector * numofchars);
  mor->encseq = encseq;
  mor->esr = gt_encseq_create_reader_with_readmode(encseq, GT_READMODE_REVERSE,
                                                   0);
  gt_assert(numofchars <= GT_MAXALPHABETCHARACTER);
  mor->alphasize = numofchars;
  mor->totallength = gt_encseq_total_length(encseq);
  mor->nowildcards = nowildcards;
  mor->processmatch = processmatch;
  mor->processmatchinfo = processmatchinfo;
  return mor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r13d
leaq 0xc3571(%rip), %rbx     # 0x3edcac
movl $0x40, %edi
movq %rbx, %rsi
movl $0x31, %edx
callq 0x1092b2
movq %rax, %r12
movl %r13d, %r14d
shlq $0x3, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x32, %edx
callq 0x1092b2
movq %rax, 0x18(%r12)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x33, %edx
callq 0x1092b2
movq %rax, 0x20(%r12)
movq %r15, 0x8(%r12)
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xed76d
movq %rax, (%r12)
cmpl $0x100, %r13d           # imm = 0x100
jae 0x32a7df
movl %r13d, 0x28(%r12)
movq %r15, %rdi
callq 0xec1d8
movq %rax, 0x10(%r12)
movb %bpl, 0x2c(%r12)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%r12)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%r12)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x96031
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/myersapm.c
// Function: gt_freeMyersonlineresources
void gt_freeMyersonlineresources(Myersonlineresources *ptrmyersonlineresources)
{
  if (ptrmyersonlineresources != NULL)
  {
    gt_free(ptrmyersonlineresources->eqsvectorrev);
    gt_free(ptrmyersonlineresources->eqsvector);
    gt_encseq_reader_delete(ptrmyersonlineresources->esr);
    gt_free(ptrmyersonlineresources);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x32a838
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xc34b1(%rip), %r14     # 0x3edcac
movq %r14, %rsi
movl $0x44, %edx
callq 0x109670
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x45, %edx
callq 0x109670
movq (%rbx), %rdi
callq 0xed7bf
movq %rbx, %rdi
movq %r14, %rsi
movl $0x47, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_new
GtRadixsortstringinfo *gt_radixsort_str_new(const GtTwobitencoding
                                             *twobitencoding,
                                            GtUword realtotallength,
                                            GtUword equallengthplus1,
                                            GtUword maxwidth)
{
  GtRadixsortstringinfo *rsi = gt_malloc(sizeof(*rsi));

  rsi->twobitencoding = twobitencoding;
  rsi->equallengthplus1 = equallengthplus1;
  rsi->realtotallength = realtotallength;
  rsi->maxwidth = maxwidth/2;
  rsi->bytesinsizesofbuckets = sizeof (*rsi->sizesofbuckets) *
                               GT_RADIXSORT_STR_NOFBUCKETS;
  rsi->sizesofbuckets = gt_malloc(rsi->bytesinsizesofbuckets);
  rsi->sorted = gt_malloc(sizeof (*rsi->sorted) * rsi->maxwidth);
  rsi->oracle = gt_malloc(sizeof (*rsi->oracle) * rsi->maxwidth);
  rsi->xorvalue2lcp = gt_radixsort_str_init_xorvalue2lcp();
  GT_STACK_INIT(&rsi->stack, 1024UL);
  return rsi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0xc32c8(%rip), %r14     # 0x3edd1e
movl $0x8080, %edi           # imm = 0x8080
movq %r14, %rsi
movl $0x88, %edx
callq 0x1092b2
movq %rax, %rbx
movq %rbp, (%rax)
movq %r12, 0x10(%rax)
movq %r13, 0x18(%rax)
shrq %r15
movq %r15, 0x20(%rax)
movq $0x2008, 0x8(%rax)      # imm = 0x2008
movl $0x2008, %edi           # imm = 0x2008
movq %r14, %rsi
movl $0x90, %edx
callq 0x1092b2
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rdi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x91, %edx
callq 0x1092b2
movq %rax, 0x30(%rbx)
movq 0x20(%rbx), %rdi
addq %rdi, %rdi
movq %r14, %rsi
movl $0x92, %edx
callq 0x1092b2
movq %rax, 0x38(%rbx)
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movl $0x6d, %edx
callq 0x1092b2
movq %rax, %r14
movb $0x4, %bpl
movl $0x1, %r12d
xorl %r15d, %r15d
xorl %edi, %edi
testq %r15, %r15
je 0x32ab0c
testb %bpl, %bpl
je 0x32ab95
movl $0x1, %r12d
movl %r15d, %ecx
shlq %cl, %r12
decb %bpl
movq %r12, %rdx
subq %rdi, %rdx
jbe 0x32ab23
addq %r14, %rdi
movzbl %bpl, %esi
callq 0x173a0
movq %r12, %rdi
addq $0x2, %r15
cmpq $0x8, %r15
jne 0x32aaef
cmpq $0xff, %rdi
ja 0x32ab4e
movq %r14, %rax
addq %rdi, %rax
movl $0x100, %edx            # imm = 0x100
subq %rdi, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x173a0
movq %r14, 0x40(%rbx)
movl $0x400, %eax            # imm = 0x400
movq %rax, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movq %rax, 0x48(%rbx)
movq %rbx, %rax
addq $0x70, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq %rax, 0x8070(%rbx)
movq $0x0, 0x8078(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x960da
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_delete
void gt_radixsort_str_delete(GtRadixsortstringinfo *rsi)
{
  if (rsi != NULL)
  {
    gt_free(rsi->sizesofbuckets);
    gt_free(rsi->sorted);
    gt_free(rsi->oracle);
    gt_free(rsi->xorvalue2lcp);
    GT_STACK_DELETE(&rsi->stack);
    gt_free(rsi);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x32ac3d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq 0xc3169(%rip), %r14     # 0x3edd1e
movq %r14, %rsi
movl $0x9c, %edx
callq 0x109670
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x9d, %edx
callq 0x109670
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x9e, %edx
callq 0x109670
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x9f, %edx
callq 0x109670
movq 0x48(%rbx), %rax
cmpq 0x60(%rbx), %rax
jbe 0x32ac22
movq 0x8070(%rbx), %rdi
leaq 0xc3111(%rip), %rsi     # 0x3edd1e
movl $0xa0, %edx
callq 0x109670
movq $0x0, 0x8070(%rbx)
leaq 0xc30f5(%rip), %rsi     # 0x3edd1e
movq %rbx, %rdi
movl $0xa1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/randomcodes-sfx-partssuf.c
// Function: gt_suftabparts_rc_variance
double gt_suftabparts_rc_variance(const GtSuftabparts_rc *suftabparts_rc)
{

  gt_assert(suftabparts_rc->numofparts > 0);
  if (suftabparts_rc->numofparts == 1U)
  {
    return 0.0;
  } else
  {
    double meanwidth, difference, sum = 0.0;
    unsigned int part;

    meanwidth = (double)
      suftabparts_rc->components[suftabparts_rc->numofparts-1].sumofwidth/
      suftabparts_rc->numofparts;
    for (part = 0; part < suftabparts_rc->numofparts; part++)
    {
      difference = (double) suftabparts_rc->components[part].widthofpart
                   - meanwidth;
      sum += difference * difference;
    }
    return sum/(double) (suftabparts_rc->numofparts-1);
  }
}

// Assembly:
pushq %rax
movl 0xc(%rdi), %eax
xorpd %xmm0, %xmm0
cmpq $0x1, %rax
je 0x32dd3d
testl %eax, %eax
je 0x32dd3f
movq (%rdi), %rcx
leal -0x1(%rax), %edx
leaq (%rdx,%rdx,2), %rsi
shlq $0x4, %rsi
movsd 0x18(%rcx,%rsi), %xmm0
unpcklps 0x22c15(%rip), %xmm0    # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x22c1d(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
addq $0x8, %rcx
xorpd %xmm0, %xmm0
movsd 0x22be5(%rip), %xmm2    # 0x3508e0
movapd 0x22bed(%rip), %xmm3    # 0x3508f0
movsd (%rcx), %xmm4
unpcklps %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
subsd %xmm1, %xmm5
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm0
addq $0x30, %rcx
decq %rax
jne 0x32dd03
movl %edx, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
popq %rax
retq
callq 0x967bc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_countocc_new
void gt_randomcodes_countocc_new(GtFirstcodesspacelog *fcsl,
                                       GtRandomcodestab *rct,
                                       GtUword numofsequences)
{
  rct->countocc_small = gt_calloc((size_t) (numofsequences+1),
                                  sizeof (*rct->countocc_small));
  GT_FCI_ADDWORKSPACE(fcsl,"countocc_small",
                      sizeof (*rct->countocc_small) *
                      (numofsequences+1));
  rct->countocc_exceptions = ul_u32_gt_hashmap_new();
  gt_assert(rct->countocc_exceptions != NULL);
  rct->outfilenameleftborder = NULL;
  rct->leftborder_samples = NULL;
#if defined (_LP64) || defined (_WIN64)
  rct->modvaluebits = 32U; /* XXX remove the following later */
  if (rct->modvaluebits == 32U)
  {
    rct->modvaluemask = UINT32_MAX;
  } else
  {
    rct->modvaluemask = (uint32_t) ((1UL << rct->modvaluebits) - 1);
  }
  GT_INITARRAY(&rct->bitchangepoints,GtUword);
#endif
  rct->differentcodes = numofsequences;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rdx), %r12
leaq 0xbfe01(%rip), %r13     # 0x3ee3b2
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
movl $0x27, %ecx
callq 0x1093ef
movq %rax, 0x48(%r14)
movq %r12, (%rsp)
leaq 0xbdb1d(%rip), %r8      # 0x3ec0f2
movq %r15, %rdi
movl $0x2a, %esi
movq %r13, %rdx
movl $0x1, %ecx
movl $0x1, %r9d
callq 0x320ca8
movups 0x19a239(%rip), %xmm0   # 0x4c8830
movups %xmm0, 0x20(%rsp)
movups 0x19a21d(%rip), %xmm0   # 0x4c8820
movups %xmm0, 0x10(%rsp)
movups 0x19a201(%rip), %xmm0   # 0x4c8810
movups %xmm0, (%rsp)
callq 0x1060b4
movq %rax, 0x50(%r14)
testq %rax, %rax
je 0x32e65b
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movabsq $0x20ffffffff, %rax     # imm = 0x20FFFFFFFF
movq %rax, 0x78(%r14)
movups %xmm0, 0x80(%r14)
movq $0x0, 0x90(%r14)
movq %rbx, (%r14)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x96c67
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_remdups
GtUword gt_randomcodes_remdups(GtUword *allrandomcodes,
    unsigned int codesize, GtUword numofcodes, GtLogger *logger)
{
  GtUword numofdifferentcodes = 0,
                shift = (GtUword)GT_MULT2(GT_UNITSIN2BITENC - codesize);
  if (numofcodes != 0)
  {
    GtUword *storeptr, *readptr;

    for (storeptr = allrandomcodes, readptr = allrandomcodes+1;
         readptr < allrandomcodes + numofcodes;
         readptr++)
    {
      if ((*storeptr ^ *readptr) << shift)
      {
        storeptr++;
        *storeptr = *readptr;
      }
    }
    numofdifferentcodes = (GtUword) (storeptr - allrandomcodes + 1);
    if (numofdifferentcodes < numofcodes)
    {
#ifdef SKDEBUG
      checkcodesorder(allrandomcodes,numofdifferentcodes,false);
#endif
    }
  }
  gt_logger_log(logger,"number of different bucket codes="GT_WU" (%.2f%%) "
                       "of "GT_WU" sampled codes",
                numofdifferentcodes,
                100.00 * (double) numofdifferentcodes/numofcodes,
                numofcodes);
  return numofdifferentcodes;
}

// Assembly:
pushq %rbx
movq %rcx, %r8
movq %rdx, %rax
testq %rdx, %rdx
je 0x32e719
movq %rdi, %rbx
cmpq $0x2, %rax
jl 0x32e70d
addl %esi, %esi
movl $0x40, %ecx
subl %esi, %ecx
leaq (%rdi,%rax,8), %rdx
leaq 0x8(%rdi), %rsi
movq %rdi, %rbx
movq (%rsi), %r9
movq (%rbx), %r10
xorq %r9, %r10
shlq %cl, %r10
testq %r10, %r10
je 0x32e704
movq %r9, 0x8(%rbx)
addq $0x8, %rbx
addq $0x8, %rsi
cmpq %rdx, %rsi
jb 0x32e6eb
subq %rdi, %rbx
sarq $0x3, %rbx
incq %rbx
jmp 0x32e71b
xorl %ebx, %ebx
movq %rbx, %xmm1
movq 0x221b8(%rip), %xmm2    # 0x3508e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x221bc(%rip), %xmm3    # 0x3508f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x240a4(%rip), %xmm0    # 0x3527f0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
leaq 0xbfc9b(%rip), %rsi     # 0x3ee40b
movq %r8, %rdi
movq %rbx, %rdx
movq %rax, %rcx
movb $0x1, %al
callq 0x10906e
movq %rbx, %rax
popq %rbx
retq