LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace_add_trace
void front_trace_add_trace(GtFrontTrace *front_trace,
                           uint8_t backreference,
                           uint32_t localmatch_count)
{
  gt_assert (front_trace != NULL);
  if (front_trace->backref_nextfree >= front_trace->backref_allocated)
  {
    front_trace->backref_allocated
      = front_trace->backref_allocated * 1.2 + 128UL;
    front_trace->backref_table
      = gt_realloc(front_trace->backref_table,
                   sizeof *front_trace->backref_table
                   * front_trace->backref_allocated);
    gt_assert(front_trace->backref_table != NULL);
  }
  gt_assert(front_trace->backref_nextfree < front_trace->backref_allocated);
  front_trace->backref_table[front_trace->backref_nextfree].bits
    = backreference;
  gt_assert(localmatch_count <= front_trace->maxlcs);
  front_trace->backref_table[front_trace->backref_nextfree++].lcs
    = localmatch_count;
#ifdef WITHDISTRIBUTION
  distribution_add(front_trace->lcs_dist,lcs);
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x31a337
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
jb 0x31a2f4
movq %rcx, %xmm0
punpckldq 0x2d65b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2d663(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2da77(%rip), %xmm1    # 0x347d18
addsd 0x8cb87(%rip), %xmm1    # 0x3a6e30
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x2da67(%rip), %xmm1    # 0x347d20
sarq $0x3f, %rcx
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %rsi, 0x18(%r14)
movq (%r14), %rdi
shlq $0x2, %rsi
leaq 0xc8fe7(%rip), %rdx     # 0x3e32c1
movl $0xd1, %ecx
callq 0x104461
movq %rax, (%r14)
testq %rax, %rax
je 0x31a346
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
cmpq %rcx, %rax
jae 0x31a33c
movq (%r14), %rcx
movl (%rcx,%rax,4), %edx
andb $0x7, %bpl
movzbl %bpl, %esi
andl $-0x8, %edx
orl %esi, %edx
movl %edx, (%rcx,%rax,4)
movl %ebx, %eax
cmpq %rax, 0x8(%r14)
jb 0x31a341
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movl (%rax,%rcx,4), %edx
andl $0x7, %edx
leal (%rdx,%rbx,8), %edx
movl %edx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x92897
callq 0x92825
callq 0x9285e
callq 0x927ec
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-front-generation.c
// Function: gt_check_diagonal_run
static void gt_check_diagonal_run(GT_UNUSED const GtUchar *useq,
                                  GT_UNUSED const GtUchar *vseq,
                                  GT_UNUSED GtWord diagonal,
                                  unsigned int firstrow,
                                  unsigned int nextrow)
{
  GtUword idx;

  gt_assert(useq != NULL && vseq != NULL && firstrow <= nextrow);
  for (idx = firstrow; idx < nextrow; idx++)
  {
    gt_assert (useq[idx] == vseq[idx+diagonal]);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x31ae77
testq %rsi, %rsi
je 0x31ae77
cmpl %r8d, %ecx
ja 0x31ae77
jae 0x31ae70
movl %r8d, %eax
addq %rdx, %rsi
movl %ecx, %ecx
movb (%rdi,%rcx), %dl
cmpb (%rsi,%rcx), %dl
jne 0x31ae72
incq %rcx
cmpq %rcx, %rax
jne 0x31ae60
popq %rax
retq
callq 0x92ff0
callq 0x93029
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-front-generation.c
// Function: polished_point2offset
static GtUword polished_point2offset(GT_UNUSED const GtFrontTrace *front_trace,
                                     const GtFtPolished_point *pp)
{
  GtWord base_diagonal, pp_diagonal;

  gt_assert(pp != NULL);
  pp_diagonal = (GtWord) pp->alignedlen - (GtWord) GT_MULT2(pp->row);
  gt_assert(pp->distance < front_trace->gen_nextfree);
  base_diagonal = (GtWord) pp->trimleft - (GtWord) pp->distance;
  gt_assert(base_diagonal <= pp_diagonal);
  gt_assert(pp_diagonal < base_diagonal +
                          (GtWord) front_trace->gen_table[pp->distance].valid);
  return (GtUword) (pp_diagonal - base_diagonal);
}

// Assembly:
pushq %rax
movq 0x10(%rsi), %rcx
cmpq 0x50(%rdi), %rcx
jae 0x31aeb6
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
addq %rax, %rax
subq %rax, %rdx
movq 0x18(%rsi), %rsi
subq %rcx, %rsi
movq %rdx, %rax
subq %rsi, %rax
jl 0x31aebb
movq 0x20(%rdi), %rdi
movzwl 0x2(%rdi,%rcx,4), %ecx
addq %rcx, %rsi
cmpq %rsi, %rdx
jge 0x31aec0
popq %rcx
retq
callq 0x93062
callq 0x930d4
callq 0x9309b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-front-generation.c
// Function: valid_total_fronts
static GtUword valid_total_fronts(const GtFrontGeneration *gen_table,
                                  GtUword start,GtUword end)
{
  GtUword idx, valid_total = 0;

  gt_assert(gen_table);
  for (idx = start; idx < end; idx++)
  {
    valid_total += gen_table[idx].valid;
  }
  return valid_total;
}

// Assembly:
testq %rdi, %rdi
je 0x31aee2
xorl %eax, %eax
cmpq %rdx, %rsi
jae 0x31aee1
movzwl 0x2(%rdi,%rsi,4), %ecx
addq %rcx, %rax
incq %rsi
cmpq %rsi, %rdx
jne 0x31aed1
retq
pushq %rax
callq 0x9310d
// File: /workspace/github_c_makefile_star2_O3/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 0x31af78
movq %rdx, %xmm0
punpckldq 0x2c9d7(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2c9df(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2cdf3(%rip), %xmm1    # 0x347d18
addsd 0x8bf03(%rip), %xmm1    # 0x3a6e30
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
subsd 0x2cde3(%rip), %xmm1    # 0x347d20
sarq $0x3f, %rdx
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
movq %rsi, 0x10(%rbx)
shlq $0x3, %rsi
leaq (%rsi,%rsi,8), %rsi
leaq 0xc8362(%rip), %rdx     # 0x3e32c1
movq %rax, %rdi
movl $0x19a, %ecx            # imm = 0x19A
callq 0x104461
movq %rax, (%rbx)
testq %rax, %rax
je 0x31af8a
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
leaq (%rcx,%rcx,8), %rcx
leaq (%rax,%rcx,8), %rax
popq %rbx
retq
callq 0x93146
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %rbx
movq %rsi, %r14
cmpq %rsi, 0x30(%rdi)
jbe 0x31e546
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq %rbx, %r14
cmpq %r15, 0x30(%r12)
jbe 0x31e546
movq %r13, %rdi
movq %r14, %rsi
callq 0x31f170
cmpb $-0x2, %al
je 0x31e546
movl %eax, %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x31f170
cmpb %al, %bpl
jne 0x31e546
incq %r14
incq %r15
cmpq %r14, 0x30(%r13)
ja 0x31e512
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/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 0xc52af(%rip), %rsi     # 0x3e3b32
movl $0x18, %edi
movl $0x3d3, %edx            # imm = 0x3D3
callq 0x104226
testq %rax, %rax
je 0x31e8ae
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
callq 0x31a07c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x935eb
// File: /workspace/github_c_makefile_star2_O3/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 0x31e8f6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xc5269(%rip), %r14     # 0x3e3b32
movq %r14, %rsi
movl $0x3e0, %edx            # imm = 0x3E0
callq 0x1045eb
movq 0x10(%rbx), %rdi
callq 0x31a0dd
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3e2, %edx            # imm = 0x3E2
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x31f166
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %r12
cmpq %rsi, %r12
jbe 0x31f0e3
movq %r12, %r15
jmp 0x31f149
leaq 0x10(%r12), %rax
cmpq %r15, %rax
cmovbq %rax, %r15
movq 0x28(%r14), %rax
movq 0x10(%rax), %rsi
cmpq %rsi, %r15
jbe 0x31f127
addq $0x10, %rsi
movq %rsi, 0x10(%rax)
movq (%rax), %rdi
leaq 0xc4a24(%rip), %rdx     # 0x3e3b32
movl $0x9f, %ecx
callq 0x104461
movq 0x28(%r14), %rcx
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
movq 0x40(%r14), %r12
cmpq %r15, %r12
jae 0x31f145
movq 0x18(%r14), %rdi
callq 0xe8186
movq 0x20(%r14), %rcx
movb %al, (%rcx,%r12)
incq %r12
cmpq %r12, %r15
jne 0x31f12c
movq %r15, 0x40(%r14)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x31f16b
cmpq %rbx, %r15
jbe 0x31f16b
movb (%rax,%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x936cf
callq 0x93708
// File: /workspace/github_c_makefile_star2_O3/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 0x31f18b
movq 0x48(%rbx), %rcx
cmpb $0x0, 0x58(%rbx)
je 0x31f19c
addq %rsi, %rcx
jmp 0x31f1a5
cmpq $0x0, 0x18(%rbx)
je 0x31f1d0
movq %rbx, %rdi
callq 0x31f0ba
jmp 0x31f1f7
subq %rsi, %rcx
jb 0x31f225
movq 0x38(%rbx), %rdx
addq 0x50(%rbx), %rdx
cmpq %rdx, %rcx
jae 0x31f220
movq %rcx, %rdx
shrq $0x5, %rdx
movq (%rax,%rdx,8), %rax
notl %ecx
addl %ecx, %ecx
shrq %cl, %rax
andb $0x3, %al
movzbl %al, %ecx
xorb $0x3, %al
movzbl %al, %eax
jmp 0x31f209
movq 0x48(%rbx), %rax
cmpb $0x0, 0x58(%rbx)
je 0x31f1df
addq %rsi, %rax
jmp 0x31f1e4
subq %rsi, %rax
jb 0x31f22a
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x31f212
movq %rax, %rsi
xorl %edx, %edx
callq 0xe7bbc
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), %rcx
testq %rcx, %rcx
je 0x31f22f
movb (%rcx,%rax), %cl
jmp 0x31f1f9
callq 0x9377a
callq 0x93741
callq 0x937b3
callq 0x937ec
// File: /workspace/github_c_makefile_star2_O3/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)
jne 0x31f260
movl $0x1, %eax
cmpq $0x0, 0x18(%rdi)
jne 0x31f260
movl $0x2, %eax
cmpq $0x0, 0x8(%rdi)
jne 0x31f260
movl $0x3, %eax
cmpq $0x0, 0x10(%rdi)
je 0x31f261
retq
pushq %rax
callq 0x93825
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x183850
cmpq $-0x1, %rax
je 0x31f50b
cmpq 0x20(%r14), %rax
jae 0x31f513
movq 0x18(%r14), %rcx
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x93895
// File: /workspace/github_c_makefile_star2_O3/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 0x31f57a
movq %rdi, %rbx
leaq 0xc4bc3(%rip), %r14     # 0x3e40ef
movl $0x18, %edi
movq %r14, %rsi
movl $0x23, %edx
callq 0x104226
movq %rax, %r15
movq %rbx, 0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x25, %edx
callq 0x104226
movq %rax, (%r15)
leaq 0xc4ba5(%rip), %rdi     # 0x3e4104
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x103d72
movb $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x938cc
// File: /workspace/github_c_makefile_star2_O3/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 0x31f615
movq %rdi, %r14
cmpb $0x1, 0x10(%rdi)
je 0x31f61a
movq %rsi, %rbx
cmpq %rsi, 0x8(%r14)
jb 0x31f61f
jbe 0x31f5f5
movq %rbx, 0x8(%r14)
movq (%r14), %rdi
leaq 0xc4b0a(%rip), %rdx     # 0x3e40ef
movq %rbx, %rsi
movl $0x3e, %ecx
callq 0x104461
movq %rax, (%r14)
movb $0x1, 0x10(%r14)
leaq 0xc4b8c(%rip), %rdi     # 0x3e418d
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x103d72
callq 0x93971
callq 0x9393a
callq 0x93903
// File: /workspace/github_c_makefile_star2_O3/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 0x31f63d
cmpb $0x1, 0x10(%rdi)
je 0x31f642
cmpb $-0x1, %dl
je 0x31f647
movq (%rdi), %rax
movb %dl, (%rax,%rsi)
popq %rax
retq
callq 0x93a16
callq 0x939df
callq 0x939a8
// File: /workspace/github_c_makefile_star2_O3/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 0x31f67a
cmpb $0x0, 0x10(%rdi)
je 0x31f67f
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 0x93a84
callq 0x93a4d
// File: /workspace/github_c_makefile_star2_O3/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 0x31f6ea
cmpb $0x0, 0x10(%rdi)
je 0x31f6ef
movq 0x8(%rdi), %rax
leaq -0x1(,%rax,2), %r8
cmpq %rdx, %r8
jbe 0x31f6f4
cmpq %rdx, %rax
jbe 0x31f6c5
testq %rcx, %rcx
je 0x31f6e8
xorl %eax, %eax
movq (%rdi), %r8
addq %rdx, %r8
movb (%rax,%r8), %r8b
movb %r8b, (%rsi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x31f6ad
jmp 0x31f6e8
testq %rcx, %rcx
je 0x31f6e8
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 0x31f6d2
popq %rax
retq
callq 0x93b29
callq 0x93abb
callq 0x93af2
// File: /workspace/github_c_makefile_star2_O3/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 0x31f790
movq %rsi, %r12
testq %rsi, %rsi
je 0x31f795
cmpq $0x0, 0x8(%rsp)
je 0x31f781
movq %rdx, %r15
movq %rdi, %r13
xorl %r14d, %r14d
movq 0x10(%rsp), %rax
leaq (%r14,%rax), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0xe7e3c
movb (%r12,%r14), %bl
movsbl %al, %ebp
cmpb $-0x1, %bl
je 0x31f760
incb %bl
movl %ebp, %edi
movq %r13, %rsi
callq 0xff0af
decb %bl
jne 0x31f750
jmp 0x31f777
movl %ebp, %edi
movq %r13, %rsi
callq 0xff0af
movl $0x2b, %edi
movq %r13, %rsi
callq 0xff0af
incq %r14
cmpq 0x8(%rsp), %r14
jne 0x31f72f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x93b97
callq 0x93b60
// File: /workspace/github_c_makefile_star2_O3/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 0x31f852
movq %rsi, %r14
testq %rsi, %rsi
je 0x31f857
cmpb $0x0, 0x10(%r14)
je 0x31f85c
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r13
cmpq %rcx, 0x8(%r14)
jae 0x31f801
leaq 0xc4911(%rip), %rsi     # 0x3e40ef
movq %r15, %rdi
movl $0x8f, %edx
callq 0x104226
movq %rax, %rbp
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x31f684
jmp 0x31f807
movq (%r14), %rbp
addq %rbx, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x31f6f9
cmpq %rbx, 0x8(%r14)
jae 0x31f843
leaq 0xc48c7(%rip), %rsi     # 0x3e40ef
movq %rbp, %rdi
movl $0x97, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1045eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x93c40
callq 0x93c07
callq 0x93bce
// File: /workspace/github_c_makefile_star2_O3/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 0x31f88f
movq (%rdi), %rax
testq %rax, %rax
je 0x31f894
cmpb $0x0, 0x10(%rdi)
je 0x31f899
movq %rsi, %rcx
testq %rsi, %rsi
je 0x31f89e
movq 0x8(%rdi), %rdx
movl $0x1, %esi
movq %rax, %rdi
popq %rax
jmp 0x11f89c
callq 0x93d24
callq 0x93ceb
callq 0x93c79
callq 0x93cb2
// File: /workspace/github_c_makefile_star2_O3/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 0x31f518
testq %rbx, %rbx
je 0x31f8df
movq %rax, %r15
movq (%rax), %rdi
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x11f848
movb $0x1, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x93d5d
// File: /workspace/github_c_makefile_star2_O3/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 0x31f96b
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
testq %rsi, %rsi
jle 0x31f927
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 0x31f960
addq %r14, %rbx
incq %r14
movl $0x1, %eax
movzbl -0x1(%r14), %ecx
cmpl $0xfe, %ecx
je 0x31f950
cmpl $0xff, %ecx
je 0x31f966
orq %rax, (%r15,%rcx,8)
cmpq %rbx, %r14
jae 0x31f960
addq %rax, %rax
incq %r14
testq %rax, %rax
jne 0x31f937
popq %rbx
popq %r14
popq %r15
retq
callq 0x93dcd
callq 0x93d96
// File: /workspace/github_c_makefile_star2_O3/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 0x31fa03
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jle 0x31f9b7
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 0x31f9f8
leaq (%r15,%rbx), %rax
addq $-0x2, %rax
movl $0x1, %ecx
movzbl 0x1(%rax), %edx
cmpl $0xfe, %edx
je 0x31f9e8
cmpl $0xff, %edx
je 0x31f9fe
orq %rcx, (%r14,%rdx,8)
cmpq %rbx, %rax
jb 0x31f9f8
addq %rcx, %rcx
decq %rax
testq %rcx, %rcx
jne 0x31f9d0
popq %rbx
popq %r14
popq %r15
retq
callq 0x93e3b
callq 0x93e04
// File: /workspace/github_c_makefile_star2_O3/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 0x31fd3c
movl %esi, %r13d
movq %rdi, %rbx
movq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0xe7bbc
movl %eax, %r14d
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movl 0x4(%rsp), %edx
callq 0xe7bbc
cmpb $-0x3, %r14b
ja 0x31fd3c
cmpb %al, %r14b
jne 0x31fd3c
incq %r12
cmpq %r15, %r12
ja 0x31fd3c
incq %rbp
cmpq 0x58(%rsp), %rbp
jbe 0x31fcfd
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_O3/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, %rbp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movl (%rsi), %r14d
shlq $0x4, %r14
callq 0x31ffcd
movq %rax, %r15
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rbp), %rax
movq %rax, 0x18(%r15)
movq (%r13), %rdi
movq %rbp, 0x8(%rsp)
movq %rbp, %rsi
movq %r12, %rdx
callq 0x320003
movb %al, 0x7(%rsp)
movq 0x8(%rbx), %rbp
addq %r12, %rbp
movq 0x10(%rsp), %rax
movq (%rax,%r14), %rdi
callq 0xe7b9c
movb $-0x1, %cl
cmpq %rax, %rbp
jae 0x31fde2
movq 0x10(%rsp), %rax
addq %r14, %rax
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
addq %r12, %rsi
movl 0x8(%rax), %edx
callq 0xe7bbc
movl %eax, %ecx
movl %ecx, %ebp
movq %r13, %rdi
callq 0x31ffcd
movups (%rbx), %xmm0
movups %xmm0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movb 0x7(%rsp), %cl
cmpb $-0x2, %cl
jb 0x31fe1c
cmpb $-0x2, %bpl
movq 0x8(%rsp), %rdx
jb 0x31fe26
movl (%rbx), %ecx
cmpl %ecx, (%rdx)
ja 0x31fe26
movq %rax, 0x18(%rdx)
movq %rdx, %rax
jmp 0x31fe32
cmpb %bpl, %cl
movq 0x8(%rsp), %rdx
jbe 0x31fe13
movq $0x0, 0x18(%rdx)
movq %rdx, 0x18(%rax)
movq %rax, 0x10(%r15)
movq %r15, 0x20(%rax)
movq %r12, 0x28(%r15)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/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 0x31fe68
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x31fe5a
popq %rcx
retq
callq 0x93ee4
// File: /workspace/github_c_makefile_star2_O3/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 0x31feef
leaq 0x20(%rdi), %rax
xorps %xmm0, %xmm0
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x31feb3
cmpq $0x0, 0x18(%rdx)
jne 0x31feef
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 0x31fead
movq %rcx, 0x20(%rdx)
movups %xmm0, (%r8)
jmp 0x31fecc
movq 0x18(%rdi), %rdx
movq %rdx, 0x10(%rcx)
testq %rdx, %rdx
je 0x31fec4
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 0x31fe7d
movq 0x10(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x31fefb
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_O3/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 0xc4457(%rip), %r14     # 0x3e438f
movq %r14, %rsi
movl $0x28f, %edx            # imm = 0x28F
callq 0x104226
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 0x104226
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x31ffcc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xc43ff(%rip), %r14     # 0x3e438f
movq %r14, %rsi
movl $0x29c, %edx            # imm = 0x29C
callq 0x1045eb
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x29d, %edx            # imm = 0x29D
callq 0x1045eb
movq (%rbx), %rdi
movq %r14, %rsi
movl $0x29e, %edx            # imm = 0x29E
callq 0x1045eb
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x31ffe8
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 0x31fffd
decl %eax
movl %eax, 0x24(%rdi)
movq 0x18(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
pushq %rax
callq 0x93f1d
// File: /workspace/github_c_makefile_star2_O3/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 0x320036
movq 0x8(%r14), %r12
addq %rbx, %r12
movq (%r15), %rdi
callq 0xe7b9c
cmpq %rax, %r12
jae 0x320054
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 0xe7bbc
movb $-0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x320109
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 $0x29, %rcx
jae 0x32015b
movq 0x10(%rsp), %rdx
movl $0x10, %eax
addq $0x8, %rax
movl %eax, (%rsp)
movq (%rdx,%rcx), %rdx
cmpl $0x20, %ecx
ja 0x32016c
addq 0x10(%rsp), %rax
addl $0x10, %ecx
movl %ecx, (%rsp)
jmp 0x32017a
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 0x31f8e4
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3201e6
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 0x3201b4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movq (%rsi), %rax
cmpq $0x40, %rax
ja 0x320262
testq %rax, %rax
je 0x320261
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 0x320244
retq
pushq %rax
callq 0x93f56
// File: /workspace/github_c_makefile_star2_O3/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 0x320353
movq %rcx, %rax
movq 0x20(%rsp), %r8
xorl %r10d, %r10d
testb $0x1, %sil
jne 0x32030e
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 0x320311
xorl %r11d, %r11d
leaq (%r11,%r10), %rcx
cmpq (%r8), %rcx
jae 0x320360
cmpq %r9, 0x8(%r8,%rcx,8)
jae 0x320336
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 0x320284
movl $0x1, %eax
jmp 0x320358
movl $0x2, %eax
movl %eax, (%rdi)
popq %rbx
popq %r14
popq %r15
retq
callq 0x93f8f
// File: /workspace/github_c_makefile_star2_O3/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 0xc40ed(%rip), %rbx     # 0x3e44e8
movl $0x40, %edi
movq %rbx, %rsi
movl $0x31, %edx
callq 0x104226
movq %rax, %r12
movl %r13d, %r14d
shlq $0x3, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x32, %edx
callq 0x104226
movq %rax, 0x18(%r12)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x33, %edx
callq 0x104226
movq %rax, 0x20(%r12)
movq %r15, 0x8(%r12)
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xe91b2
movq %rax, (%r12)
cmpl $0x100, %r13d           # imm = 0x100
jae 0x32049f
movl %r13d, 0x28(%r12)
movq %r15, %rdi
callq 0xe7b9c
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 0x94073