LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-generation.c
// Function: stack_top_ptr_get
static GtBacktraceFrontStackelem *stack_top_ptr_get(
                          GtBacktraceFrontStack *stack)
{
  if (stack->nextfree >= stack->allocated)
  {
    stack->allocated = stack->allocated * 1.2 + 128UL;
    stack->space = gt_realloc(stack->space,
                              sizeof *stack->space * stack->allocated);
    gt_assert(stack->space != NULL);
  }
  return stack->space + stack->nextfree++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
cmpq %rdx, %rcx
jb 0x2bbb48
movq %rdx, %xmm0
punpckldq 0x2be03(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2be0b(%rip), %xmm0    # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2c21f(%rip), %xmm1    # 0x2e7d18
addsd 0x8b6af(%rip), %xmm1    # 0x3471b0
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2c20b(%rip), %xmm1    # 0x2e7d20
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
movq %rsi, 0x10(%rbx)
imulq $0x48, %rsi, %rsi
leaq 0xc7b72(%rip), %rdx     # 0x3836a1
movq %rax, %rdi
movl $0x19a, %ecx            # imm = 0x19A
callq 0x93472
movq %rax, (%rbx)
testq %rax, %rax
je 0x2bbb5c
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
imulq $0x48, %rcx, %rcx
addq %rax, %rcx
movq %rcx, %rax
popq %rbx
retq
movq 0x17c405(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x294a6(%rip), %rsi     # 0x2e5013
leaq 0xc8012(%rip), %rdx     # 0x383b86
leaq 0xc8020(%rip), %rcx     # 0x383b9b
leaq 0xc7b1f(%rip), %r8      # 0x3836a1
movl $0x19b, %r9d            # imm = 0x19B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-prune.c
// Function: ft_longest_common_all
static GtUword ft_longest_common_all(GtFtSequenceObject *useq,
                                     GtUword ustart,
                                     GtFtSequenceObject *vseq,
                                     GtUword vstart)
{
  GtUword upos, vpos;

  for (upos = ustart, vpos = vstart;
       ft_sequenceobject_symbol_match(useq,upos,vseq,vpos);
       upos++, vpos++)
    /* Nothing */ ;
  return upos - ustart;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
xorl %r12d, %r12d
leaq (%r15,%r12), %rsi
cmpq %rsi, 0x30(%r13)
jbe 0x2bf19a
movq (%rsp), %rax
leaq (%rax,%r12), %rbp
cmpq %rbp, 0x30(%r14)
jbe 0x2bf19a
movq %r13, %rdi
callq 0x2bfc92
cmpb $-0x2, %al
je 0x2bf19a
movl %eax, %ebx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2bfc92
cmpb %al, %bl
jne 0x2bf19a
incq %r12
jmp 0x2bf160
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-prune.c
// Function: front_prune_add_matches
static void inline front_prune_add_matches(
                                  GtLongestCommonFunc ft_longest_common,
                                  GtFtFrontvalue *midfront,
                                  GtFtFrontvalue *fv,
                                  GtUword max_history,
                                  GtFtSequenceObject *useq,
                                  GtFtSequenceObject *vseq,
                                  GtFtTrimstat *trimstat)
{
  fv->localmatch_count
    = (GtFtRowvaluetype)ft_longest_common(useq,fv->row,
                                          vseq,fv->row + GT_FRONT_DIAGONAL(fv));
  if (fv->localmatch_count > 0)
  {
    const uint64_t match_mask
      = (fv->localmatch_count >= max_history)
           ? ~((uint64_t) 0)
           : ((((uint64_t) 1) << fv->localmatch_count) - 1);
    fv->matchhistory_bits = (fv->matchhistory_bits << fv->localmatch_count) |
                            match_mask;
    if (fv->matchhistory_size < max_history)
    {
      fv->matchhistory_size = GT_MIN(fv->matchhistory_size
                                       + fv->localmatch_count,
                                     max_history);
    }
    fv->row += fv->localmatch_count;
  }
  if (trimstat != NULL)
  {
    gt_ft_trimstat_add_matchlength(trimstat,fv->localmatch_count);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r10
movq 0x20(%rsp), %rbx
movl 0x8(%rdx), %r11d
movq %rdx, %rax
subq %rsi, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq (%rax,%r11), %rcx
movq %r8, %rdi
movq %r11, %rsi
movq %r9, %rdx
callq *%r10
movq %rax, %rcx
movl %ecx, 0xc(%r14)
testl %ecx, %ecx
je 0x2bf22a
movl %ecx, %eax
pushq $-0x1
popq %rdx
movq %rdx, %rsi
shlq %cl, %rsi
cmpq %r15, %rax
notq %rsi
cmovaeq %rdx, %rsi
movq (%r14), %rax
shlq %cl, %rax
orq %rsi, %rax
movq %rax, (%r14)
movzbl 0x10(%r14), %eax
cmpq %r15, %rax
jae 0x2bf226
movl %ecx, %edx
addl %eax, %edx
cmpq %r15, %rdx
cmovbq %rdx, %r15
movb %r15b, 0x10(%r14)
addl %ecx, 0x8(%r14)
testq %rbx, %rbx
je 0x2bf23e
movq %rbx, %rdi
movl %ecx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x15d569
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_full_front_edist_trace_new
GtFullFrontEdistTrace *gt_full_front_edist_trace_new(void)
{
  GtFullFrontEdistTrace *fet = gt_malloc(sizeof *fet);

  gt_assert(fet != NULL);
  fet->spaceGtFtFrontvalue = NULL;
  fet->allocatedGtFtFrontvalue = 0;
  fet->front_trace = front_trace_new();
  return fet;
}

// Assembly:
pushq %rbx
leaq 0xc4abc(%rip), %rsi     # 0x383f12
pushq $0x18
popq %rdi
movl $0x3d3, %edx            # imm = 0x3D3
callq 0x93160
testq %rax, %rax
je 0x2bf47f
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
callq 0x2ba3a8
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq 0x178ae2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x25b83(%rip), %rsi     # 0x2e5013
leaq 0xc4ac8(%rip), %rdx     # 0x383f5f
leaq 0xc4acd(%rip), %rcx     # 0x383f6b
leaq 0xc4a6d(%rip), %r8      # 0x383f12
movl $0x3d5, %r9d            # imm = 0x3D5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_full_front_edist_trace_delete
void gt_full_front_edist_trace_delete(GtFullFrontEdistTrace *fet)
{
  if (fet != NULL)
  {
    gt_free(fet->spaceGtFtFrontvalue);
    front_trace_delete(fet->front_trace);
    gt_free(fet);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2bf4fa
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xc4a45(%rip), %r14     # 0x383f12
movq %r14, %rsi
movl $0x3e0, %edx            # imm = 0x3E0
callq 0x936f9
movq 0x10(%rbx), %rdi
callq 0x2ba467
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3e2, %edx            # imm = 0x3E2
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_full_front_prune_add_matches
static void inline gt_full_front_prune_add_matches(GtFtFrontvalue *midfront,
                                                   GtFtFrontvalue *fv,
                                                   const GtUchar *useq,
                                                   GtUword ulen,
                                                   const GtUchar *vseq,
                                                   GtUword vlen)
{
  GtUword upos, vpos;

  for (upos = fv->row, vpos = fv->row + GT_FRONT_DIAGONAL(fv);
       upos < ulen && vpos < vlen &&
       useq[upos] == vseq[vpos]
       && GT_ISNOTSPECIAL(useq[upos])
       ;
       upos++, vpos++)
       /* Nothing */;
  fv->localmatch_count = upos - fv->row;
  fv->row = upos;
}

// Assembly:
movq %rdx, %r10
movl 0x8(%rsi), %r11d
movq %rsi, %rax
subq %rdi, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
addq %rax, %r8
xorl %edx, %edx
cmpq %rcx, %r11
jae 0x2bfb7b
leaq (%rax,%r11), %rdi
cmpq %r9, %rdi
jae 0x2bfb7b
movb (%r10,%r11), %dil
cmpb $-0x3, %dil
ja 0x2bfb7b
cmpb (%r8,%r11), %dil
jne 0x2bfb7b
incq %r11
incl %edx
jmp 0x2bfb56
movl %edx, 0xc(%rsi)
movl %r11d, 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_sequenceobject_esr_get
static GtUchar gt_sequenceobject_esr_get(GtFtSequenceObject *seq,GtUword idx)
{
  gt_assert(idx < seq->substringlength);
  if (idx >= seq->cache_num_positions)
  {
    const GtUword addamount = 16UL;
    GtUword cidx, tostore = GT_MIN(seq->cache_num_positions + addamount,
                                seq->substringlength);

    if (tostore > seq->sequence_cache->allocated)
    {
      seq->sequence_cache->allocated += addamount;
      seq->sequence_cache->space
        = gt_realloc(seq->sequence_cache->space,
                     sizeof (GtUchar) * seq->sequence_cache->allocated);
      seq->cache_ptr = (GtUchar *) seq->sequence_cache->space;
    }
    for (cidx = seq->cache_num_positions; cidx < tostore; cidx++)
    {
      seq->cache_ptr[cidx]
        = gt_encseq_reader_next_encoded_char(seq->encseqreader);
    }
    seq->cache_num_positions = tostore;
  }
  gt_assert(seq->cache_ptr != NULL && idx < seq->cache_num_positions);
  return seq->cache_ptr[idx];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r15
cmpq %rsi, %r15
jbe 0x2bfc2c
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %r12
cmpq %rsi, %r12
jbe 0x2bfbac
movq %r12, %r15
jmp 0x2bfc0f
leaq 0x10(%r12), %rax
cmpq %r15, %rax
cmovbq %rax, %r15
movq 0x28(%r14), %rax
movq 0x10(%rax), %rsi
cmpq %rsi, %r15
jbe 0x2bfc06
addq $0x10, %rsi
movq %rsi, 0x10(%rax)
movq (%rax), %rdi
leaq 0xc433b(%rip), %rdx     # 0x383f12
movl $0x9f, %ecx
callq 0x93472
movq 0x28(%r14), %rcx
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
movq 0x40(%r14), %r12
jmp 0x2bfc06
movq 0x18(%r14), %rdi
callq 0x70f55
movq 0x20(%r14), %rcx
movb %al, (%rcx,%r12)
incq %r12
cmpq %r15, %r12
jb 0x2bfbf2
movq %r15, 0x40(%r14)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x2bfc5a
cmpq %rbx, %r15
jbe 0x2bfc5a
movb (%rax,%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x178335(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x253d6(%rip), %rsi     # 0x2e5013
leaq 0xc43ba(%rip), %rdx     # 0x383ffe
leaq 0xc43ce(%rip), %rcx     # 0x384019
leaq 0xc42c0(%rip), %r8      # 0x383f12
movl $0x93, %r9d
jmp 0x2bfc86
movq 0x178307(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x253a8(%rip), %rsi     # 0x2e5013
leaq 0xc43c1(%rip), %rdx     # 0x384033
leaq 0xc43a0(%rip), %rcx     # 0x384019
leaq 0xc4292(%rip), %r8      # 0x383f12
movl $0xa9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-prune.c
// Function: ft_sequenceobject2mode
static int ft_sequenceobject2mode(const GtFtSequenceObject *seq)
{
  if (seq->twobitencoding != NULL)
  {
    return 0;
  }
  if (seq->encseqreader != NULL)
  {
    return 1;
  }
  if (seq->encseq != NULL)
  {
    return 2;
  }
  gt_assert(seq->bytesequenceptr != NULL);
  return 3;
}

// Assembly:
xorl %eax, %eax
cmpq $0x0, (%rdi)
je 0x2bfe15
retq
cmpq $0x0, 0x18(%rdi)
je 0x2bfe20
pushq $0x1
jmp 0x2bfe34
cmpq $0x0, 0x8(%rdi)
je 0x2bfe2b
pushq $0x2
jmp 0x2bfe34
cmpq $0x0, 0x10(%rdi)
je 0x2bfe36
pushq $0x3
popq %rax
retq
pushq %rax
movq 0x17812a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x251cb(%rip), %rsi     # 0x2e5013
leaq 0xc4323(%rip), %rdx     # 0x384172
leaq 0xc43b3(%rip), %rcx     # 0x384209
leaq 0xc40b5(%rip), %r8      # 0x383f12
movl $0x109, %r9d            # imm = 0x109
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x12b2e1
cmpq $-0x1, %rax
je 0x2c0137
cmpq 0x20(%r14), %rax
jae 0x2c013f
movq 0x18(%r14), %rcx
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x177e22(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24ec3(%rip), %rsi     # 0x2e5013
leaq 0xc4319(%rip), %rdx     # 0x384470
leaq 0xc4332(%rip), %rcx     # 0x384490
leaq 0xc42ce(%rip), %r8      # 0x384433
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x2c01d4
movq %rdi, %rbx
leaq 0xc4343(%rip), %r14     # 0x3844cf
pushq $0x18
popq %rdi
pushq $0x23
popq %rdx
movq %r14, %rsi
callq 0x93160
movq %rax, %r15
movq %rbx, 0x8(%rax)
pushq $0x25
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x93160
movq %rax, (%r15)
leaq 0xc432b(%rip), %rdi     # 0x3844e4
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x92a82
movb $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x177d8d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24e2e(%rip), %rsi     # 0x2e5013
leaq 0xc42c3(%rip), %rdx     # 0x3844af
leaq 0xc42cc(%rip), %rcx     # 0x3844bf
leaq 0xc42d5(%rip), %r8      # 0x3844cf
pushq $0x22
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2c029e
movq %rdi, %r14
cmpb $0x1, 0x10(%rdi)
je 0x2c02c8
movq %rsi, %rbx
cmpq %rsi, 0x8(%r14)
jb 0x2c02f2
jbe 0x2c027e
movq %rbx, 0x8(%r14)
movq (%r14), %rdi
leaq 0xc425f(%rip), %rdx     # 0x3844cf
pushq $0x3e
popq %rcx
movq %rbx, %rsi
callq 0x93472
movq %rax, (%r14)
movb $0x1, 0x10(%r14)
leaq 0xc42e3(%rip), %rdi     # 0x38456d
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92a82
movq 0x177cc3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24d64(%rip), %rsi     # 0x2e5013
leaq 0xc4257(%rip), %rdx     # 0x38450d
leaq 0xc4261(%rip), %rcx     # 0x38451e
leaq 0xc420b(%rip), %r8      # 0x3844cf
pushq $0x37
jmp 0x2c031a
movq 0x177c99(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24d3a(%rip), %rsi     # 0x2e5013
leaq 0xc4253(%rip), %rdx     # 0x384533
leaq 0xc4237(%rip), %rcx     # 0x38451e
leaq 0xc41e1(%rip), %r8      # 0x3844cf
pushq $0x38
jmp 0x2c031a
movq 0x177c6f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24d10(%rip), %rsi     # 0x2e5013
leaq 0xc423e(%rip), %rdx     # 0x384548
leaq 0xc420d(%rip), %rcx     # 0x38451e
leaq 0xc41b7(%rip), %r8      # 0x3844cf
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2c0341
cmpb $0x1, 0x10(%rdi)
je 0x2c036b
cmpb $-0x1, %dl
je 0x2c0395
movq (%rdi), %rax
movb %dl, (%rax,%rsi)
popq %rax
retq
movq 0x177c20(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24cc1(%rip), %rsi     # 0x2e5013
leaq 0xc41b4(%rip), %rdx     # 0x38450d
leaq 0xc4233(%rip), %rcx     # 0x384593
leaq 0xc4168(%rip), %r8      # 0x3844cf
pushq $0x47
jmp 0x2c03bd
movq 0x177bf6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24c97(%rip), %rsi     # 0x2e5013
leaq 0xc41b0(%rip), %rdx     # 0x384533
leaq 0xc4209(%rip), %rcx     # 0x384593
leaq 0xc413e(%rip), %r8      # 0x3844cf
pushq $0x48
jmp 0x2c03bd
movq 0x177bcc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24c6d(%rip), %rsi     # 0x2e5013
leaq 0xc41f6(%rip), %rdx     # 0x3845a3
leaq 0xc41df(%rip), %rcx     # 0x384593
leaq 0xc4114(%rip), %r8      # 0x3844cf
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2c03f9
cmpb $0x0, 0x10(%rdi)
je 0x2c0423
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
movq 0x177b68(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24c09(%rip), %rsi     # 0x2e5013
leaq 0xc40fc(%rip), %rdx     # 0x38450d
leaq 0xc41a4(%rip), %rcx     # 0x3845bc
leaq 0xc40b0(%rip), %r8      # 0x3844cf
pushq $0x50
jmp 0x2c044b
movq 0x177b3e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24bdf(%rip), %rsi     # 0x2e5013
leaq 0xc40f9(%rip), %rdx     # 0x384534
leaq 0xc417a(%rip), %rcx     # 0x3845bc
leaq 0xc4086(%rip), %r8      # 0x3844cf
pushq $0x51
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2c04bf
cmpb $0x0, 0x10(%rdi)
je 0x2c04e9
movq 0x8(%rdi), %rax
leaq -0x1(,%rax,2), %r8
cmpq %rdx, %r8
jbe 0x2c0513
cmpq %rdx, %rax
jbe 0x2c049d
xorl %eax, %eax
cmpq %rax, %rcx
je 0x2c04bd
movq (%rdi), %r8
addq %rdx, %r8
movb (%rax,%r8), %r8b
movb %r8b, (%rsi,%rax)
incq %rax
jmp 0x2c0485
addq %rax, %rax
subq %rdx, %rax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2c04bd
movq (%rdi), %r8
movb (%r8,%rax), %r8b
decq %rax
movb %r8b, (%rsi,%rdx)
incq %rdx
jmp 0x2c04a5
popq %rax
retq
movq 0x177aa2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24b43(%rip), %rsi     # 0x2e5013
leaq 0xc4036(%rip), %rdx     # 0x38450d
leaq 0xc40ee(%rip), %rcx     # 0x3845cc
leaq 0xc3fea(%rip), %r8      # 0x3844cf
pushq $0x5a
jmp 0x2c053b
movq 0x177a78(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24b19(%rip), %rsi     # 0x2e5013
leaq 0xc4033(%rip), %rdx     # 0x384534
leaq 0xc40c4(%rip), %rcx     # 0x3845cc
leaq 0xc3fc0(%rip), %r8      # 0x3844cf
pushq $0x5b
jmp 0x2c053b
movq 0x177a4e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24aef(%rip), %rsi     # 0x2e5013
leaq 0xc40b7(%rip), %rdx     # 0x3845e2
leaq 0xc409a(%rip), %rcx     # 0x3845cc
leaq 0xc3f96(%rip), %r8      # 0x3844cf
pushq $0x5c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, (%rsp)
testq %rdx, %rdx
je 0x2c05e3
movq %rsi, %r12
testq %rsi, %rsi
je 0x2c060d
movq %rdi, %r13
xorl %r14d, %r14d
cmpq 0x10(%rsp), %r14
je 0x2c05d4
movq 0x8(%rsp), %rax
leaq (%r14,%rax), %rsi
movq (%rsp), %rdi
xorl %edx, %edx
callq 0x709bc
movb (%r12,%r14), %bl
movsbl %al, %ebp
cmpb $-0x1, %bl
je 0x2c05ba
xorl %r15d, %r15d
cmpb %bl, %r15b
ja 0x2c05cf
movl %ebp, %edi
movq %r13, %rsi
callq 0x8d771
incb %r15b
jmp 0x2c05a6
movl %ebp, %edi
movq %r13, %rsi
callq 0x8d771
pushq $0x2b
popq %rdi
movq %r13, %rsi
callq 0x8d771
incq %r14
jmp 0x2c057c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x17797e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24a1f(%rip), %rsi     # 0x2e5013
leaq 0x7fcb7(%rip), %rdx     # 0x3402b2
leaq 0xc400d(%rip), %rcx     # 0x38460f
leaq 0xc3ec6(%rip), %r8      # 0x3844cf
pushq $0x70
jmp 0x2c0635
movq 0x177954(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x249f5(%rip), %rsi     # 0x2e5013
leaq 0x92667(%rip), %rdx     # 0x352c8c
leaq 0xc3fe3(%rip), %rcx     # 0x38460f
leaq 0xc3e9c(%rip), %r8      # 0x3844cf
pushq $0x71
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2c06fb
movq %rsi, %r14
testq %rsi, %rsi
je 0x2c0729
cmpb $0x0, 0x10(%r14)
je 0x2c0757
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r13
cmpq %rcx, 0x8(%r14)
jae 0x2c06aa
leaq 0xc3e48(%rip), %rsi     # 0x3844cf
movq %r15, %rdi
movl $0x8f, %edx
callq 0x93160
movq %rax, %rbp
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2c0459
jmp 0x2c06b0
movq (%r14), %rbp
addq %rbx, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x2c0549
cmpq %rbx, 0x8(%r14)
jae 0x2c06ec
leaq 0xc3dfe(%rip), %rsi     # 0x3844cf
movq %rbp, %rdi
movl $0x97, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x936f9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x177866(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24907(%rip), %rsi     # 0x2e5013
leaq 0x7fb9f(%rip), %rdx     # 0x3402b2
leaq 0xc3f27(%rip), %rcx     # 0x384641
leaq 0xc3dae(%rip), %r8      # 0x3844cf
movl $0x8a, %r9d
jmp 0x2c0783
movq 0x177838(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x248d9(%rip), %rsi     # 0x2e5013
leaq 0xc3dcc(%rip), %rdx     # 0x38450d
leaq 0xc3ef9(%rip), %rcx     # 0x384641
leaq 0xc3d80(%rip), %r8      # 0x3844cf
movl $0x8b, %r9d
jmp 0x2c0783
movq 0x17780a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x248ab(%rip), %rsi     # 0x2e5013
leaq 0xc3dc5(%rip), %rdx     # 0x384534
leaq 0xc3ecb(%rip), %rcx     # 0x384641
leaq 0xc3d52(%rip), %r8      # 0x3844cf
movl $0x8c, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2c07bf
movq (%rdi), %rax
testq %rax, %rax
je 0x2c07f0
cmpb $0x0, 0x10(%rdi)
je 0x2c081e
movq %rsi, %rcx
testq %rsi, %rsi
je 0x2c084c
movq 0x8(%rdi), %rdx
pushq $0x1
popq %rsi
movq %rax, %rdi
popq %rax
jmp 0xb302c
movq 0x1777a2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24843(%rip), %rsi     # 0x2e5013
leaq 0xc3d36(%rip), %rdx     # 0x38450d
leaq 0xc3e85(%rip), %rcx     # 0x384663
leaq 0xc3cea(%rip), %r8      # 0x3844cf
movl $0x9c, %r9d
jmp 0x2c0878
movq 0x177771(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24812(%rip), %rsi     # 0x2e5013
leaq 0xc3e6c(%rip), %rdx     # 0x384674
leaq 0xc3e54(%rip), %rcx     # 0x384663
leaq 0xc3cb9(%rip), %r8      # 0x3844cf
movl $0x9d, %r9d
jmp 0x2c0878
movq 0x177743(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x247e4(%rip), %rsi     # 0x2e5013
leaq 0xc3cfe(%rip), %rdx     # 0x384534
leaq 0xc3e26(%rip), %rcx     # 0x384663
leaq 0xc3c8b(%rip), %r8      # 0x3844cf
movl $0x9e, %r9d
jmp 0x2c0878
movq 0x177715(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x247b6(%rip), %rsi     # 0x2e5013
leaq 0x9243a(%rip), %rdx     # 0x352c9e
leaq 0xc3df8(%rip), %rcx     # 0x384663
leaq 0xc3c5d(%rip), %r8      # 0x3844cf
movl $0x9f, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2c0178
testq %rbx, %rbx
je 0x2c08be
movq %rax, %r15
movq (%rax), %rdi
pushq $0x1
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb2fab
movb $0x1, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x1776a3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24744(%rip), %rsi     # 0x2e5013
leaq 0xc3db6(%rip), %rdx     # 0x38468c
leaq 0xc3dbd(%rip), %rcx     # 0x38469a
leaq 0xc3beb(%rip), %r8      # 0x3844cf
movl $0xa7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rax
cmpq $0x40, %rcx
ja 0x2c097c
leaq (%rdi,%rsi,8), %rax
movq %rdi, %rsi
cmpq %rax, %rsi
jae 0x2c0915
andq $0x0, (%rsi)
addq $0x8, %rsi
jmp 0x2c0906
addq %rdx, %rcx
pushq $0x1
popq %rax
cmpq %rcx, %rdx
jae 0x2c0944
testq %rax, %rax
je 0x2c0944
movzbl (%rdx), %esi
cmpl $0xfe, %esi
je 0x2c093c
cmpl $0xff, %esi
je 0x2c0946
orq %rax, (%rdi,%rsi,8)
incq %rdx
addq %rax, %rax
jmp 0x2c091b
popq %rax
retq
movq 0x17761b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x246bc(%rip), %rsi     # 0x2e5013
leaq 0xc3dae(%rip), %rdx     # 0x38470c
leaq 0xc3d7f(%rip), %rcx     # 0x3846e4
leaq 0xc3d89(%rip), %r8      # 0x3846f5
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x1775e5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24686(%rip), %rsi     # 0x2e5013
leaq 0xc3d17(%rip), %rdx     # 0x3846ab
leaq 0xc3d49(%rip), %rcx     # 0x3846e4
leaq 0xc3d53(%rip), %r8      # 0x3846f5
pushq $0x20
jmp 0x2c096e
// File: /workspace/github_c_makefile_star2_O2/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 %rax
cmpq $0x40, %rcx
ja 0x2c0a32
leaq (%rdi,%rsi,8), %rax
movq %rdi, %rsi
cmpq %rax, %rsi
jae 0x2c09c7
andq $0x0, (%rsi)
addq $0x8, %rsi
jmp 0x2c09b8
leaq (%rcx,%rdx), %rax
decq %rax
pushq $0x1
popq %rcx
cmpq %rdx, %rax
jb 0x2c09fa
testq %rcx, %rcx
je 0x2c09fa
movzbl (%rax), %esi
cmpl $0xfe, %esi
je 0x2c09f2
cmpl $0xff, %esi
je 0x2c09fc
orq %rcx, (%rdi,%rsi,8)
addq %rcx, %rcx
decq %rax
jmp 0x2c09d1
popq %rax
retq
movq 0x177565(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x24606(%rip), %rsi     # 0x2e5013
leaq 0xc3cf8(%rip), %rdx     # 0x38470c
leaq 0xc3d11(%rip), %rcx     # 0x38472c
leaq 0xc3cd3(%rip), %r8      # 0x3846f5
pushq $0x43
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x17752f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x245d0(%rip), %rsi     # 0x2e5013
leaq 0xc3c61(%rip), %rdx     # 0x3846ab
leaq 0xc3cdb(%rip), %rcx     # 0x38472c
leaq 0xc3c9d(%rip), %r8      # 0x3846f5
pushq $0x3a
jmp 0x2c0a24
// File: /workspace/github_c_makefile_star2_O2/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, 0xc(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, 0x8(%rsp)
movq %rdi, %r13
xorl %ebx, %ebx
leaq (%r12,%rbx), %rsi
cmpq %r15, %rsi
ja 0x2c0de4
movq 0x50(%rsp), %rax
leaq (%rax,%rbx), %r14
cmpq 0x58(%rsp), %r14
ja 0x2c0de4
movq %r13, %rdi
movl 0x8(%rsp), %edx
callq 0x705e4
movl %eax, %ebp
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
callq 0x705e4
cmpb $-0x3, %bpl
ja 0x2c0de4
cmpb %al, %bpl
jne 0x2c0de4
incq %rbx
jmp 0x2c0d9c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 $0x28, %rsp
movq %rcx, %rbp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rax
movq %rax, 0x18(%rsp)
movl (%rsi), %r14d
shlq $0x4, %r14
callq 0x2c1086
movq %rax, %r15
movups (%r12), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rbp), %rax
movq %rax, 0x18(%r15)
movq %r13, 0x20(%rsp)
movq %r13, %rdi
movq %rbp, 0x10(%rsp)
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x2c10eb
movb %al, 0xf(%rsp)
movq 0x8(%r12), %rbp
addq %rbx, %rbp
movq 0x18(%rsp), %rax
movq (%rax,%r14), %rdi
callq 0x7055e
movb $-0x1, %r13b
cmpq %rax, %rbp
jae 0x2c0e8f
movq 0x18(%rsp), %rax
addq %r14, %rax
movq (%rax), %rdi
movq 0x8(%r12), %rsi
addq %rbx, %rsi
movl 0x8(%rax), %edx
callq 0x705e4
movl %eax, %r13d
movq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x2c0d5d
movb 0xf(%rsp), %cl
cmpb $-0x2, %cl
jb 0x2c0ec6
cmpb $-0x2, %r13b
movq 0x10(%rsp), %rdx
jb 0x2c0ed0
movl (%r12), %ecx
cmpl %ecx, (%rdx)
ja 0x2c0ed0
andq $0x0, 0x18(%rax)
movq %rax, 0x18(%rdx)
movq %rdx, %rax
jmp 0x2c0ed9
cmpb %r13b, %cl
movq 0x10(%rsp), %rdx
jbe 0x2c0eb8
andq $0x0, 0x18(%rdx)
movq %rdx, 0x18(%rax)
movq %rax, 0x10(%r15)
movq %r15, 0x20(%rax)
movq %rbx, 0x28(%r15)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 0x2c0f0f
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x2c0f01
popq %rcx
retq
movq 0x177052(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x240f3(%rip), %rsi     # 0x2e5013
leaq 0xc387b(%rip), %rdx     # 0x3847a2
leaq 0xc388a(%rip), %rcx     # 0x3847b8
leaq 0xc383a(%rip), %r8      # 0x38476f
movl $0x258, %r9d            # imm = 0x258
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
xorps %xmm0, %xmm0
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x2c0fb5
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x2c0f88
cmpq $0x0, 0x18(%rcx)
jne 0x2c0fb5
leaq 0x10(%rdi), %rdx
movq 0x10(%rax), %r8
movq 0x18(%r8), %r8
movq %r8, 0x18(%rcx)
movq %rcx, 0x10(%rax)
movq (%rdx), %rcx
testq %rcx, %rcx
je 0x2c0f83
movq %rax, 0x20(%rcx)
movups %xmm0, (%rdx)
jmp 0x2c0f9e
movq 0x18(%rdi), %rcx
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
je 0x2c0f99
movq %rax, 0x20(%rcx)
andq $0x0, 0x18(%rdi)
movq 0x18(%rsi), %rax
movl 0x24(%rsi), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rsi)
movq %rdi, (%rax,%rcx,8)
movq 0x20(%rdi), %rdi
jmp 0x2c0f4a
movq 0x10(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x2c0fc1
retq
movq 0x18(%rsi), %rcx
movl 0x24(%rsi), %edx
leal 0x1(%rdx), %edi
movl %edi, 0x24(%rsi)
movq %rax, (%rcx,%rdx,8)
andq $0x0, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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)
imulq $0x30, %rax, %rdi
leaq 0xc3778(%rip), %r14     # 0x38476f
movq %r14, %rsi
movl $0x28f, %edx            # imm = 0x28F
callq 0x93160
movq %rax, 0x8(%rbx)
andl $0x0, 0x2c(%rbx)
andq $0x0, 0x10(%rbx)
andl $0x0, 0x24(%rbx)
movl 0x28(%rbx), %edi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x295, %edx            # imm = 0x295
callq 0x93160
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2c1085
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xc3723(%rip), %r14     # 0x38476f
movq %r14, %rsi
movl $0x29c, %edx            # imm = 0x29C
callq 0x936f9
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x29d, %edx            # imm = 0x29D
callq 0x936f9
movq (%rbx), %rdi
movq %r14, %rsi
movl $0x29e, %edx            # imm = 0x29E
callq 0x936f9
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2c109d
leal 0x1(%rax), %ecx
movl %ecx, 0x2c(%rdi)
imulq $0x30, %rax, %rax
addq 0x8(%rdi), %rax
retq
movl 0x24(%rdi), %eax
testl %eax, %eax
je 0x2c10b2
decl %eax
movl %eax, 0x24(%rdi)
movq 0x18(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
pushq %rax
movq 0x176eae(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x23f4f(%rip), %rsi     # 0x2e5013
leaq 0xc370c(%rip), %rdx     # 0x3847d7
leaq 0xc371d(%rip), %rcx     # 0x3847ef
leaq 0xc3696(%rip), %r8      # 0x38476f
movl $0x14d, %r9d            # imm = 0x14D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2c111e
movq 0x8(%r14), %r12
addq %rbx, %r12
movq (%r15), %rdi
callq 0x7055e
cmpq %rax, %r12
jae 0x2c113c
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 0x705e4
movb $-0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2c11ed
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)
pushq $0x10
popq %rcx
cmpq $0x29, %rcx
jae 0x2c123b
movq 0x10(%rsp), %rdx
movq %rcx, %rax
addq $0x8, %rax
movl %eax, (%rsp)
movq (%rdx,%rcx), %rdx
cmpl $0x20, %ecx
ja 0x2c124c
addq 0x10(%rsp), %rax
addl $0x10, %ecx
movl %ecx, (%rsp)
jmp 0x2c125a
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
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 0x2c08f8
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
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
cmpq (%rbx), %r13
jae 0x2c12b9
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
jmp 0x2c128e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
orq $-0x1, (%rdi)
movq (%rsi), %rcx
cmpq $0x40, %rcx
ja 0x2c1335
xorl %eax, %eax
cmpq %rcx, %rax
jae 0x2c1334
andq $0x0, 0x8(%rsi,%rax,8)
andq $0x0, 0x210(%rsi,%rax,8)
andq $0x0, 0x410(%rsi,%rax,8)
incq %rax
movq (%rsi), %rcx
jmp 0x2c130f
retq
pushq %rax
movq 0x176c2b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x23ccc(%rip), %rsi     # 0x2e5013
leaq 0xc34c8(%rip), %rdx     # 0x384816
leaq 0xc34f0(%rip), %rcx     # 0x384845
leaq 0xc34a5(%rip), %r8      # 0x384801
movl $0xb4, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390