LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace_new
GtFrontTrace *front_trace_new(void)
{
  GtFrontTrace *front_trace = gt_malloc(sizeof *front_trace);

  gt_assert(front_trace != NULL);
  /*printf("sizeof *backref_table=" GT_WU " bytes\n",
          sizeof *front_trace->backref_table);*/
  front_trace->backref_table = NULL;
  front_trace->backref_nextfree = 0;
  front_trace->backref_allocated = 0;
  front_trace->gen_table = NULL;
  front_trace->maxlcs = (1 << (32 - GT_FT_BACKTRACEBITS)) - 1;
  front_trace->gen_allocated = 0;
  front_trace->gen_nextfree = 0;
  front_trace->previoustrimleft = 0;
#ifdef WITHDISTRIBUTION
  front_trace->lcs_dist = distribution_new();
  front_trace->valid_dist = distribution_new();
  front_trace->trimleft_diff_dist = distribution_new();
  front_trace->space_per_pos_dist = distribution_new();
#endif
  front_trace->backtracepath = NULL;
  front_trace->backtracepath_allocated = 0;
  front_trace->backtracestack.nextfree = front_trace->backtracestack.allocated
                                       = 0;
  front_trace->backtracestack.space = NULL;
  return front_trace;
}

// Assembly:
pushq %rax
movl $0x68, %edi
leaq 0xf22d6(%rip), %rsi     # 0x5b8ab3
movl $0x53, %edx
callq 0xe80f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4c682a
movq 0x1757a7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4f810(%rip), %rsi     # 0x516013
leaq 0xb6172(%rip), %rdx     # 0x57c97c
leaq 0xf22c2(%rip), %rcx     # 0x5b8ad3
leaq 0xf229b(%rip), %r8      # 0x5b8ab3
movl $0x55, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c682c
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x1fffffff, 0x8(%rax)  # imm = 0x1FFFFFFF
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace_delete
void front_trace_delete(GtFrontTrace *front_trace)
{
  if (front_trace != NULL)
  {
    /*
    distribution_show("lcs",1,front_trace->lcs_dist);
    distribution_show("valid",1,front_trace->valid_dist);
    distribution_show("trimleft_diff",1,front_trace->trimleft_diff_dist);
    distribution_show("space_per_pos",100,front_trace->space_per_pos_dist);
    */
#ifdef WITHDISTRIBUTION
    distribution_delete(front_trace->lcs_dist);
    distribution_delete(front_trace->valid_dist);
    distribution_delete(front_trace->trimleft_diff_dist);
    distribution_delete(front_trace->space_per_pos_dist);
#endif
    gt_free(front_trace->backref_table);
    gt_free(front_trace->gen_table);
    gt_free(front_trace->backtracepath);
    gt_free(front_trace->backtracestack.space);
    gt_free(front_trace);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4c69c4
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0xf2159(%rip), %rsi     # 0x5b8ab3
movl $0x97, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0xf2140(%rip), %rsi     # 0x5b8ab3
movl $0x98, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0xf2127(%rip), %rsi     # 0x5b8ab3
movl $0x99, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0xf210e(%rip), %rsi     # 0x5b8ab3
movl $0x9a, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0xf20f9(%rip), %rsi     # 0x5b8ab3
movl $0x9b, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace2eoplist
void front_trace2eoplist(bool polished,
                         GtEoplist *eoplist,
                         GtFrontTrace *front_trace,
                         const GtFtPolished_point *pp,
                         GtUword pol_size,
                         GtWord match_score,
                         GtWord difference_score,
                         const GtUchar *useq,
                         GtUword ulen,
                         const GtUchar *vseq,
                         GtUword vlen)
{
  if (polished)
  {
    front_trace2polished_eoplist(eoplist,
                                 front_trace,
                                 pp,
                                 pol_size,
                                 match_score,
                                 difference_score,
                                 useq,
                                 ulen,
                                 vseq,
                                 vlen);
  } else
  {
    front_trace2eoplist_directed(eoplist,
                                 front_trace,
                                 useq,
                                 ulen,
                                 vseq,
                                 vlen,
                                 pp);
  }
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movb %dil, %al
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rdi
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
testb $0x1, 0x4f(%rsp)
je 0x4c6fd9
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x60(%rsp), %r9
movq 0x68(%rsp), %rbx
movq 0x70(%rsp), %r11
movq 0x78(%rsp), %r10
movq 0x80(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x4c7010
jmp 0x4c7008
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x70(%rsp), %rcx
movq 0x78(%rsp), %r8
movq 0x80(%rsp), %r9
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x4c75f0
addq $0x50, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x4c8496
cmpq $0x0, 0x18(%rsp)
je 0x4c8496
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jbe 0x4c84ce
movq 0x173b03(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4db6c(%rip), %rsi     # 0x516013
leaq 0xf0def(%rip), %rdx     # 0x5b929d
leaq 0xf0e1c(%rip), %rcx     # 0x5b92d1
leaq 0xf05f7(%rip), %r8      # 0x5b8ab3
movl $0x105, %r9d            # imm = 0x105
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c84d0
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x8(%rsp), %ecx
cmpq %rcx, %rax
jae 0x4c8554
jmp 0x4c84e7
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x18(%rsp), %rcx
movq (%rsp), %rdx
addq 0x10(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4c8542
movq 0x173a8f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4daf8(%rip), %rsi     # 0x516013
leaq 0xf0dc5(%rip), %rdx     # 0x5b92e7
leaq 0xf0da8(%rip), %rcx     # 0x5b92d1
leaq 0xf0583(%rip), %r8      # 0x5b8ab3
movl $0x108, %r9d            # imm = 0x108
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c8544
jmp 0x4c8546
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4c84d8
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x4c85ae
movq 0x173a23(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4da8c(%rip), %rsi     # 0x516013
leaq 0xf08b3(%rip), %rdx     # 0x5b8e41
leaq 0xf094e(%rip), %rcx     # 0x5b8ee3
leaq 0xf0517(%rip), %r8      # 0x5b8ab3
movl $0xe6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c85b0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq %rcx
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jb 0x4c8618
movq 0x1739b9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4da22(%rip), %rsi     # 0x516013
leaq 0xf0901(%rip), %rdx     # 0x5b8ef9
leaq 0xf08e4(%rip), %rcx     # 0x5b8ee3
leaq 0xf04ad(%rip), %r8      # 0x5b8ab3
movl $0xe8, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c861a
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
subq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jle 0x4c8675
movq 0x17395c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d9c5(%rip), %rsi     # 0x516013
leaq 0xf08cd(%rip), %rdx     # 0x5b8f22
leaq 0xf0887(%rip), %rcx     # 0x5b8ee3
leaq 0xf0450(%rip), %r8      # 0x5b8ab3
movl $0xea, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c8677
jmp 0x4c8679
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq 0x20(%rdx), %rdx
movq 0x18(%rsp), %rsi
movq 0x10(%rsi), %rsi
movzwl 0x2(%rdx,%rsi,4), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jl 0x4c86da
movq 0x1738f7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d960(%rip), %rsi     # 0x516013
leaq 0xf0885(%rip), %rdx     # 0x5b8f3f
leaq 0xf0822(%rip), %rcx     # 0x5b8ee3
leaq 0xf03eb(%rip), %r8      # 0x5b8ab3
movl $0xec, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c86dc
movq 0x8(%rsp), %rax
subq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4c874b
movq 0x173886(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d8ef(%rip), %rsi     # 0x516013
leaq 0xf0866(%rip), %rdx     # 0x5b8f91
leaq 0xf0869(%rip), %rcx     # 0x5b8f9b
leaq 0xf037a(%rip), %r8      # 0x5b8ab3
movl $0xf5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c874d
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x4c878a
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movzwl 0x2(%rax,%rcx,4), %eax
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4c8757
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x4c889d
movq (%rsp), %rax
movq 0x10(%rax), %xmm0
movaps 0x50165(%rip), %xmm1    # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x50169(%rip), %xmm1    # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x5057a(%rip), %xmm1    # 0x518d68
mulsd %xmm1, %xmm0
movsd 0xb0e16(%rip), %xmm1    # 0x579610
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x5055b(%rip), %xmm1    # 0x518d70
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
imulq $0x48, 0x10(%rax), %rsi
leaq 0xf0270(%rip), %rdx     # 0x5b8ab3
movl $0x19a, %ecx            # imm = 0x19A
callq 0xe8540
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x4c8899
movq 0x173738(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d7a1(%rip), %rsi     # 0x516013
leaq 0xf0735(%rip), %rdx     # 0x5b8fae
leaq 0xf0743(%rip), %rcx     # 0x5b8fc3
leaq 0xf022c(%rip), %r8      # 0x5b8ab3
movl $0x19b, %r9d            # imm = 0x19B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4c889b
jmp 0x4c889d
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x4d0850
testb $0x1, %al
jne 0x4ce6bb
jmp 0x4ce6db
jmp 0x4ce6bd
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4ce69c
movq 0x10(%rsp), %rax
subq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_sequenceobject_longest_func_index
static int gt_sequenceobject_longest_func_index(const GtFtSequenceObject *useq,
                                                const GtFtSequenceObject *vseq,
                                                bool haswildcards)
{
  const int u_mode = ft_sequenceobject2mode(useq);
  const int v_mode = ft_sequenceobject2mode(vseq);
  return u_mode * ft_longest_common_num_modes + v_mode +
         (haswildcards ? ft_longest_common_func_first_wildcard : 0);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4d0be0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4d0be0
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
shll $0x2, %eax
addl 0xc(%rsp), %eax
movb 0x17(%rsp), %sil
xorl %ecx, %ecx
movl $0x10, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
addl %ecx, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x18, %edi
leaq 0xe9785(%rip), %rsi     # 0x5b9352
movl $0x3d3, %edx            # imm = 0x3D3
callq 0xe80f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4cfc1a
movq 0x16c3b7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x46420(%rip), %rsi     # 0x516013
leaq 0xe97a5(%rip), %rdx     # 0x5b939f
leaq 0xe97aa(%rip), %rcx     # 0x5b93ab
leaq 0xe974a(%rip), %r8      # 0x5b9352
movl $0x3d5, %r9d            # imm = 0x3D5
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4cfc1c
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
callq 0x4c67d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4cfc96
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0xe96e8(%rip), %rsi     # 0x5b9352
movl $0x3e0, %edx            # imm = 0x3E0
callq 0xe88c0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x4c6940
movq (%rsp), %rdi
leaq 0xe96c6(%rip), %rsi     # 0x5b9352
movl $0x3e2, %edx            # imm = 0x3E2
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x38(%rsp)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x48(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x48(%rsp), %rax
addq %rcx, %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rcx
xorl %eax, %eax
cmpq -0x20(%rsp), %rcx
movb %al, -0x49(%rsp)
jae 0x4d00d3
movq -0x40(%rsp), %rcx
xorl %eax, %eax
cmpq -0x30(%rsp), %rcx
movb %al, -0x49(%rsp)
jae 0x4d00d3
movq -0x18(%rsp), %rax
movq -0x38(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x28(%rsp), %rax
movq -0x40(%rsp), %rdx
movzbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x49(%rsp)
jne 0x4d00d3
movq -0x18(%rsp), %rax
movq -0x38(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xfe, %eax
setl %al
movb %al, -0x49(%rsp)
movb -0x49(%rsp), %al
testb $0x1, %al
jne 0x4d00dd
jmp 0x4d0100
jmp 0x4d00df
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
movq -0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rsp)
jmp 0x4d006f
movq -0x38(%rsp), %rax
movq -0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq -0x38(%rsp), %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_full_front_second_inplace
static void gt_full_front_second_inplace(GtFtFrontvalue *midfront,
                                         GtFtFrontvalue *lowfront,
                                         const GtUchar *useq,
                                         GtUword ulen,
                                         const GtUchar *vseq,
                                         GtUword vlen)
{
  *(lowfront+1) = *(lowfront+2) = *lowfront;
  lowfront->row++;
  lowfront->backreference = FT_EOP_DELETION;
  gt_full_front_prune_add_matches(midfront,lowfront,useq,ulen,vseq,vlen);

  (lowfront+1)->row++;
  (lowfront+1)->backreference = FT_EOP_MISMATCH;
  gt_full_front_prune_add_matches(midfront,lowfront + 1,useq,ulen,vseq,vlen);

  (lowfront+2)->backreference = FT_EOP_INSERTION;
  gt_full_front_prune_add_matches(midfront,lowfront + 2,useq,ulen,vseq,vlen);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x28(%rsp), %rdx
movq (%rdx), %rsi
movq %rsi, 0x30(%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x38(%rcx)
movq 0x10(%rdx), %rdx
movq %rdx, 0x40(%rcx)
movq 0x30(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x38(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x40(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movb $0x4, 0x11(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x4d0010
movq 0x28(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0x28(%rsp), %rax
movb $0x1, 0x29(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x4d0010
movq 0x28(%rsp), %rax
movb $0x2, 0x41(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x30, %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x4d0010
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-front-prune.c
// Function: ft_sequenceobject_symbol_match
static inline bool ft_sequenceobject_symbol_match(
                                           GtFtSequenceObject *useq,
                                           GtUword upos,
                                           GtFtSequenceObject *vseq,
                                           GtUword vpos)
{
  if (upos >= useq->substringlength || vpos >= vseq->substringlength)
  {
    return false;
  } else
  {
    const GtUchar cu = ft_sequenceobject_get_char(useq,upos);
    return (cu != GT_WILDCARD && cu == ft_sequenceobject_get_char(vseq,vpos))
             ? true
             : false;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x4d0888
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x4d088f
movb $0x0, 0x37(%rsp)
jmp 0x4d08fc
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4d0910
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %ecx
xorl %eax, %eax
cmpl $0xfe, %ecx
movb %al, 0xe(%rsp)
je 0x4d08df
movzbl 0xf(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4d0910
movb %al, %cl
movl 0x8(%rsp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x4d0bfe
movl $0x0, 0x14(%rsp)
jmp 0x4d0c7a
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4d0c14
movl $0x1, 0x14(%rsp)
jmp 0x4d0c7a
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4d0c2a
movl $0x2, 0x14(%rsp)
jmp 0x4d0c7a
jmp 0x4d0c2c
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4d0c70
movq 0x16b361(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x453ca(%rip), %rsi     # 0x516013
leaq 0xe8962(%rip), %rdx     # 0x5b95b2
leaq 0xe89f2(%rip), %rcx     # 0x5b9649
leaq 0xe86f4(%rip), %r8      # 0x5b9352
movl $0x109, %r9d            # imm = 0x109
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d0c72
movl $0x3, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/ft-front-prune.c
// Function: trimthisentry
static bool trimthisentry(GtFtRowvaluetype row,
                          GtWord diagonal,
                          const GtFtFrontvalue *fv,
                          GtUword minmatchpercentage128,
                          GtUword minlenfrommaxdiff,
                          uint64_t max_history_mask,
                          GT_UNUSED GtUword distance,
                          GT_UNUSED bool showfrontinfo)
{
  if (GT_MULT2(row) + diagonal < minlenfrommaxdiff)
  {
    return true;
  }
  if (bitCountUInt64(fv->matchhistory_bits & max_history_mask)
      < ((fv->matchhistory_size * minmatchpercentage128) >> 7))
  {
    return true;
  }
  return false;
}

// Assembly:
subq $0x38, %rsp
movb 0x48(%rsp), %al
movq 0x40(%rsp), %r10
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movl 0x30(%rsp), %eax
shll %eax
movl %eax, %eax
addq 0x28(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x4d0cdb
movb $0x1, 0x37(%rsp)
jmp 0x4d0d13
movq 0x20(%rsp), %rax
movq (%rax), %rdi
andq 0x8(%rsp), %rdi
callq 0x4d0d20
movl %eax, %eax
movq 0x20(%rsp), %rcx
movzbl 0x10(%rcx), %ecx
imulq 0x18(%rsp), %rcx
shrq $0x7, %rcx
cmpq %rcx, %rax
jae 0x4d0d0e
movb $0x1, 0x37(%rsp)
jmp 0x4d0d13
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/hashfirstcodes.c
// Function: gt_hashfirstcodes
static void gt_hashfirstcodes(void *processinfo,
                              GT_UNUSED bool firstinrange,
                              GT_UNUSED GtUword pos,
                              GtCodetype code)
{
  GtHashfirstcodes *hashfirstcodes = (GtHashfirstcodes *) processinfo;

  if (!gt_uint64hashtable_search(hashfirstcodes->table,
                                 (uint64_t) code,
                                 true))
  {
    hashfirstcodes->differentcodes++;
  }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x1f5150
testb $0x1, %al
jne 0x4d10bf
movq (%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f55c0
movq %rax, 0x8(%rsp)
cmpq $-0x1, 0x8(%rsp)
je 0x4d11c8
jmp 0x4d1167
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x4d11af
movq 0x16ae22(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44e8b(%rip), %rsi     # 0x516013
leaq 0xe87ff(%rip), %rdx     # 0x5b998e
leaq 0xe8818(%rip), %rcx     # 0x5b99ae
leaq 0xe87b4(%rip), %r8      # 0x5b9951
movl $0x4a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d11b1
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x4d1219
movq 0x16adb8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44e21(%rip), %rsi     # 0x516013
leaq 0xe87d4(%rip), %rdx     # 0x5b99cd
leaq 0xe87dd(%rip), %rcx     # 0x5b99dd
leaq 0xe87e6(%rip), %r8      # 0x5b99ed
movl $0x22, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d121b
movl $0x18, %edi
leaq 0xe87c6(%rip), %rsi     # 0x5b99ed
movl $0x23, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
shlq $0x0, %rdi
leaq 0xe8799(%rip), %rsi     # 0x5b99ed
movl $0x25, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xe8788(%rip), %rdi     # 0x5b9a02
movb $0x0, %al
callq 0xe7740
movq 0x8(%rsp), %rax
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4d132e
movq 0x16aca3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44d0c(%rip), %rsi     # 0x516013
leaq 0xe871d(%rip), %rdx     # 0x5b9a2b
leaq 0xe8727(%rip), %rcx     # 0x5b9a3c
leaq 0xe86d1(%rip), %r8      # 0x5b99ed
movl $0x37, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1330
jmp 0x4d1332
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x4d1375
movq 0x16ac5c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44cc5(%rip), %rsi     # 0x516013
leaq 0xe86fc(%rip), %rdx     # 0x5b9a51
leaq 0xe86e0(%rip), %rcx     # 0x5b9a3c
leaq 0xe868a(%rip), %r8      # 0x5b99ed
movl $0x38, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1377
jmp 0x4d1379
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4d13c1
movq 0x16ac10(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44c79(%rip), %rsi     # 0x516013
leaq 0xe86c5(%rip), %rdx     # 0x5b9a66
leaq 0xe8694(%rip), %rcx     # 0x5b9a3c
leaq 0xe863e(%rip), %r8      # 0x5b99ed
movl $0x39, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d13c3
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4d140e
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
shlq $0x0, %rsi
leaq 0xe85f4(%rip), %rdx     # 0x5b99ed
movl $0x3e, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xe8663(%rip), %rdi     # 0x5b9a8b
movb $0x0, %al
callq 0xe7740
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movb %al, 0x7(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4d1494
movq 0x16ab3d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44ba6(%rip), %rsi     # 0x516013
leaq 0xe85b7(%rip), %rdx     # 0x5b9a2b
leaq 0xe8636(%rip), %rcx     # 0x5b9ab1
leaq 0xe856b(%rip), %r8      # 0x5b99ed
movl $0x47, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1496
jmp 0x4d1498
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x4d14db
movq 0x16aaf6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44b5f(%rip), %rsi     # 0x516013
leaq 0xe8596(%rip), %rdx     # 0x5b9a51
leaq 0xe85ef(%rip), %rcx     # 0x5b9ab1
leaq 0xe8524(%rip), %r8      # 0x5b99ed
movl $0x48, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d14dd
jmp 0x4d14df
movzbl 0x7(%rsp), %eax
cmpl $0xfe, %eax
jle 0x4d1523
movq 0x16aaae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44b17(%rip), %rsi     # 0x516013
leaq 0xe85be(%rip), %rdx     # 0x5b9ac1
leaq 0xe85a7(%rip), %rcx     # 0x5b9ab1
leaq 0xe84dc(%rip), %r8      # 0x5b99ed
movl $0x49, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1525
jmp 0x4d1527
movzbl 0x7(%rsp), %eax
cmpl $0xff, %eax
jne 0x4d156b
movq 0x16aa66(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44acf(%rip), %rsi     # 0x516013
leaq 0xe858f(%rip), %rdx     # 0x5b9ada
leaq 0xe855f(%rip), %rcx     # 0x5b9ab1
leaq 0xe8494(%rip), %r8      # 0x5b99ed
movl $0x4a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d156d
movb 0x7(%rsp), %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4d15de
movq 0x16a9f3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44a5c(%rip), %rsi     # 0x516013
leaq 0xe846d(%rip), %rdx     # 0x5b9a2b
leaq 0xe8530(%rip), %rcx     # 0x5b9af5
leaq 0xe8421(%rip), %r8      # 0x5b99ed
movl $0x50, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d15e0
jmp 0x4d15e2
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x4d1625
movq 0x16a9ac(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44a15(%rip), %rsi     # 0x516013
leaq 0xe844d(%rip), %rdx     # 0x5b9a52
leaq 0xe84e9(%rip), %rcx     # 0x5b9af5
leaq 0xe83da(%rip), %r8      # 0x5b99ed
movl $0x51, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1627
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4d164e
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
jmp 0x4d1673
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq %rcx
subq 0x8(%rsp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4d16d8
movq 0x16a8f9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44962(%rip), %rsi     # 0x516013
leaq 0xe8373(%rip), %rdx     # 0x5b9a2b
leaq 0xe8446(%rip), %rcx     # 0x5b9b05
leaq 0xe8327(%rip), %r8      # 0x5b99ed
movl $0x5a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d16da
jmp 0x4d16dc
movq 0x20(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x4d171f
movq 0x16a8b2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4491b(%rip), %rsi     # 0x516013
leaq 0xe8353(%rip), %rdx     # 0x5b9a52
leaq 0xe83ff(%rip), %rcx     # 0x5b9b05
leaq 0xe82e0(%rip), %r8      # 0x5b99ed
movl $0x5b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1721
jmp 0x4d1723
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0x4d1775
movq 0x16a85c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x448c5(%rip), %rsi     # 0x516013
leaq 0xe83c6(%rip), %rdx     # 0x5b9b1b
leaq 0xe83a9(%rip), %rcx     # 0x5b9b05
leaq 0xe828a(%rip), %r8      # 0x5b99ed
movl $0x5c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1777
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4d17ca
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x4d17c8
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
addq (%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4d178f
jmp 0x4d182b
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
shlq %rax
subq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x4d1829
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, 0x10(%rsp)
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4d17e8
jmp 0x4d182b
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4d188d
movq 0x16a744(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x447ad(%rip), %rsi     # 0x516013
leaq 0xa0b75(%rip), %rdx     # 0x5723e2
leaq 0xe82d4(%rip), %rcx     # 0x5b9b48
leaq 0xe8172(%rip), %r8      # 0x5b99ed
movl $0x70, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d188f
jmp 0x4d1891
cmpq $0x0, 0x28(%rsp)
jne 0x4d18d1
movq 0x16a700(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44769(%rip), %rsi     # 0x516013
leaq 0xb3d39(%rip), %rdx     # 0x5855ea
leaq 0xe8290(%rip), %rcx     # 0x5b9b48
leaq 0xe812e(%rip), %r8      # 0x5b99ed
movl $0x71, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d18d3
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x4d1990
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xaa4b0
movb %al, 0x6(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x5(%rsp)
movzbl 0x5(%rsp), %eax
cmpl $0xff, %eax
je 0x4d195d
movb 0x5(%rsp), %al
addb $0x1, %al
movb %al, 0x5(%rsp)
movb $0x0, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
movzbl 0x5(%rsp), %ecx
cmpl %ecx, %eax
jge 0x4d195b
movsbl 0x6(%rsp), %edi
movq 0x30(%rsp), %rsi
callq 0xddf60
movb 0x7(%rsp), %al
addb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0x4d1932
jmp 0x4d197b
movsbl 0x6(%rsp), %edi
movq 0x30(%rsp), %rsi
callq 0xddf60
movq 0x30(%rsp), %rsi
movl $0x2b, %edi
callq 0xddf60
jmp 0x4d197d
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4d18dc
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4d19fd
movq 0x16a5d4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4463d(%rip), %rsi     # 0x516013
leaq 0xa0a05(%rip), %rdx     # 0x5723e2
leaq 0xe8196(%rip), %rcx     # 0x5b9b7a
leaq 0xe8002(%rip), %r8      # 0x5b99ed
movl $0x8a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d19ff
jmp 0x4d1a01
cmpq $0x0, 0x28(%rsp)
jne 0x4d1a41
movq 0x16a590(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x445f9(%rip), %rsi     # 0x516013
leaq 0xe800a(%rip), %rdx     # 0x5b9a2b
leaq 0xe8152(%rip), %rcx     # 0x5b9b7a
leaq 0xe7fbe(%rip), %r8      # 0x5b99ed
movl $0x8b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1a43
jmp 0x4d1a45
movq 0x28(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x4d1a88
movq 0x16a549(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x445b2(%rip), %rsi     # 0x516013
leaq 0xe7fea(%rip), %rdx     # 0x5b9a52
leaq 0xe810b(%rip), %rcx     # 0x5b9b7a
leaq 0xe7f77(%rip), %r8      # 0x5b99ed
movl $0x8c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1a8a
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4d1ad4
movq 0x10(%rsp), %rdi
shlq $0x0, %rdi
leaq 0xe7f43(%rip), %rsi     # 0x5b99ed
movl $0x8f, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x4d1680
jmp 0x4d1ae6
movq 0x28(%rsp), %rax
movq (%rax), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x4d1830
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4d1b2a
movq 0x8(%rsp), %rdi
leaq 0xe7ecd(%rip), %rsi     # 0x5b99ed
movl $0x97, %edx
callq 0xe88c0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4d1b7e
movq 0x16a453(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x444bc(%rip), %rsi     # 0x516013
leaq 0xe7ecd(%rip), %rdx     # 0x5b9a2b
leaq 0xe8037(%rip), %rcx     # 0x5b9b9c
leaq 0xe7e81(%rip), %r8      # 0x5b99ed
movl $0x9c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1b80
jmp 0x4d1b82
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x4d1bc5
movq 0x16a40c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44475(%rip), %rsi     # 0x516013
leaq 0xe8008(%rip), %rdx     # 0x5b9bad
leaq 0xe7ff0(%rip), %rcx     # 0x5b9b9c
leaq 0xe7e3a(%rip), %r8      # 0x5b99ed
movl $0x9d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1bc7
jmp 0x4d1bc9
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x4d1c0c
movq 0x16a3c5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4442e(%rip), %rsi     # 0x516013
leaq 0xe7e66(%rip), %rdx     # 0x5b9a52
leaq 0xe7fa9(%rip), %rcx     # 0x5b9b9c
leaq 0xe7df3(%rip), %r8      # 0x5b99ed
movl $0x9e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1c0e
jmp 0x4d1c10
cmpq $0x0, 0x8(%rsp)
jne 0x4d1c50
movq 0x16a381(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x443ea(%rip), %rsi     # 0x516013
leaq 0xb39cc(%rip), %rdx     # 0x5855fc
leaq 0xe7f65(%rip), %rcx     # 0x5b9b9c
leaq 0xe7daf(%rip), %r8      # 0x5b99ed
movl $0x9f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1c52
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x126d30
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x4d11d0
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4d1cdc
movq 0x16a2f5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4435e(%rip), %rsi     # 0x516013
leaq 0xe7f09(%rip), %rdx     # 0x5b9bc5
leaq 0xe7f10(%rip), %rcx     # 0x5b9bd3
leaq 0xe7d23(%rip), %r8      # 0x5b99ed
movl $0xa7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1cde
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x126c30
movq (%rsp), %rax
movb $0x1, 0x10(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)