LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-contigs-graph.c
// Function: gt_contigs_graph_show_dot_vertex
static void gt_contigs_graph_show_dot_vertex(GtContigsGraph *cg,
    GtUword cnum, GtFile *outfp)
{
  const char *shape = GT_CONTIGS_GRAPH_DOT_SELECT_V_SHAPE(cg, cnum),
             *style = GT_CONTIGS_GRAPH_DOT_SELECT_V_STYLE(cg, cnum),
             *color = GT_CONTIGS_GRAPH_DOT_SELECT_V_COLOR(cg, cnum);

  gt_file_xprintf(outfp, "  "GT_WU" [style=%s,color=%s,shape=%s];\n", cnum,
        style, color, shape);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x28(%rsp), %rcx
movb (%rax,%rcx), %dl
shrb %dl
andb $0x1, %dl
leaq 0x2ff01d(%rip), %rax    # 0x58096d
leaq 0x2ff00e(%rip), %rcx    # 0x580965
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x28(%rsp), %rcx
movb (%rax,%rcx), %dl
andb $0x1, %dl
leaq 0x2feff7(%rip), %rax    # 0x580975
leaq 0x2fefd9(%rip), %rcx    # 0x58095e
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2fe349(%rip), %xmm1   # 0x57fd00
leaq 0x2fefbd(%rip), %rax    # 0x58097b
leaq 0x2b9a36(%rip), %rcx    # 0x53b3fb
ucomisd %xmm1, %xmm0
cmovaeq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq 0x18(%rsp), %r9
leaq 0x2fef8f(%rip), %rsi    # 0x580981
movb $0x0, %al
callq 0xddca0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-contigs-writer.c
// Function: gt_contigs_writer_enable_astat_calculation
void gt_contigs_writer_enable_astat_calculation(GtContigsWriter *contigs_writer,
    double coverage, unsigned char *rcn, FILE *depthinfo_fp)
{
  contigs_writer->calculate_astat = true;
  if (gt_encseq_accesstype_get(contigs_writer->reads) ==
      GT_ACCESS_TYPE_EQUALLENGTH)
    contigs_writer->rlen = gt_encseq_equallength(contigs_writer->reads);
  else
    contigs_writer->rlen = gt_encseq_total_length(contigs_writer->reads) /
      gt_encseq_num_of_sequences(contigs_writer->reads);
  contigs_writer->arrival_rate = coverage / (double)contigs_writer->rlen;
  gt_log_log("arrival_rate = %.4f", contigs_writer->arrival_rate);
  contigs_writer->rcn = rcn;
  contigs_writer->depthinfo_fp = depthinfo_fp;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movb $0x1, 0x11(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0xc2d90
cmpl $0x2, %eax
jne 0x281c2f
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0xc2da0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x68(%rax)
jmp 0x281c65
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0xa9d00
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0xa9d50
movq %rax, %rcx
movq (%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x68(%rax)
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x68(%rax), %xmm1
movaps 0x296cb4(%rip), %xmm2   # 0x518930
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x296cb8(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x70(%rax)
movq 0x20(%rsp), %rax
movsd 0x70(%rax), %xmm0
leaq 0x2fed2b(%rip), %rdi    # 0x5809e1
movb $0x1, %al
callq 0xe7740
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xa0(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-contigs-writer.c
// Function: gt_contigs_writer_delete
void gt_contigs_writer_delete(GtContigsWriter *contigs_writer)
{
  if (contigs_writer == NULL)
    return;
  GT_FREEARRAY(&contigs_writer->contig, char);
  gt_str_delete(contigs_writer->contig_desc);
  gt_str_delete(contigs_writer->path_desc);
  gt_assembly_stats_calculator_delete(contigs_writer->asc);
  gt_encseq_reader_delete(contigs_writer->esr);
  gt_free(contigs_writer);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x281d01
jmp 0x281d96
jmp 0x281d03
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x281d4b
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x2feca5(%rip), %rsi    # 0x5809c2
movl $0x68, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
jmp 0x281d4d
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x133170
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xac3f0
movq (%rsp), %rdi
leaq 0x2fec36(%rip), %rsi    # 0x5809c2
movl $0x6d, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-contigs-writer.c
// Function: gt_contigs_writer_reset_buffers
static void gt_contigs_writer_reset_buffers(GtContigsWriter *contigs_writer)
{
  gt_assert(contigs_writer != NULL);
  contigs_writer->contig.nextfreechar = 0;
  gt_str_reset(contigs_writer->contig_desc);
  gt_str_reset(contigs_writer->path_desc);
  contigs_writer->depthinfo.firstread_copynum = (float)0;
  contigs_writer->depthinfo.internal_copynum = (float)0;
  contigs_writer->depthinfo.lastread_copynum = (float)0;
  contigs_writer->depthinfo.depth = 0;
  contigs_writer->depthinfo.length = 0;
  contigs_writer->depthinfo.astat = (float)0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x281e44
movq 0x3ba18d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2941f6(%rip), %rsi    # 0x516013
leaq 0x2febd1(%rip), %rdx    # 0x5809f5
leaq 0x2fecf1(%rip), %rcx    # 0x580b1c
leaq 0x2feb90(%rip), %r8     # 0x5809c2
movl $0x72, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x281e46
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11e110
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x11e110
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x88(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8c(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x90(%rax)
movq (%rsp), %rax
movq $0x0, 0x78(%rax)
movq (%rsp), %rax
movq $0x0, 0x80(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x94(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-contigs-writer.c
// Function: gt_contigs_writer_show_stats
void gt_contigs_writer_show_stats(GtContigsWriter *contigs_writer,
    GtLogger *logger)
{
  gt_assert(contigs_writer != NULL);
  if (contigs_writer->contignum > 0)
    gt_assembly_stats_calculator_show(contigs_writer->asc, logger);
  else
    gt_logger_log(logger, "no contigs respect the given cutoff parameters");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x282b5e
movq 0x3b9473(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2934dc(%rip), %rsi    # 0x516013
leaq 0x2fdeb7(%rip), %rdx    # 0x5809f5
leaq 0x2fdf8b(%rip), %rcx    # 0x580ad0
leaq 0x2fde76(%rip), %r8     # 0x5809c2
movl $0x132, %r9d            # imm = 0x132
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x282b60
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jbe 0x282b81
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x1338d0
jmp 0x282b94
movq 0x8(%rsp), %rdi
leaq 0x2fdf60(%rip), %rsi    # 0x580aed
movb $0x0, %al
callq 0xe7cd0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-errfind.c
// Function: gt_errfind_reset
static inline void gt_errfind_reset(GtBUstate_errfind *state)
{
  unsigned int i;
  state->currentchar = 0;
  for (i = 0; i < state->alphasize; i++)
    state->count[i] = 0;
  state->seprange = false;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x1c(%rax)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x282f39
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movl -0xc(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x282f09
movq -0x8(%rsp), %rax
movb $0x0, 0x40(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-errfind.c
// Function: processleafedge_errfind
static int processleafedge_errfind(GT_UNUSED bool firstsucc,
    GtUword fatherdepth,
    GT_UNUSED GtBUinfo_errfind *father, GtUword leafnumber,
    GtBUstate_errfind *state, GT_UNUSED GtError *err)
{
#ifdef RDJ_ERRFIND_DEBUG
  if (leafnumber == state->debug_value)
    gt_log_enable();
  RDJ_ERRFIND_SHOW_KMER;
#endif
  if (fatherdepth < state->k - 1)
  {
    gt_errfind_reset(state);
  }
  else if (!state->seprange)
  {
    if (fatherdepth == state->k - 1 &&
        RDJ_ERRFIND_IS_SEPRANGE(state->encseq, leafnumber + fatherdepth))
    {
      state->seprange = true;
    }
    if (!state->seprange && state->currentchar < state->alphasize)
    {
      gt_errfind_process_kmer(leafnumber, state);
      if (fatherdepth == state->k - 1)
      {
        state->currentchar++;
#ifdef RDJ_ERRFIND_DEBUG
        gt_log_log("currentchar incremented, now is %u", state->currentchar);
#endif
      }
    }
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x37(%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 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2843ec
movq 0x10(%rsp), %rdi
callq 0x282ef0
jmp 0x2844ba
movq 0x10(%rsp), %rax
testb $0x1, 0x40(%rax)
jne 0x2844b8
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x284463
movq 0x18(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa9d00
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
je 0x28445a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
addq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0xaaca0
testb $0x1, %al
jne 0x28445a
jmp 0x284463
movq 0x10(%rsp), %rax
movb $0x1, 0x40(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x40(%rax)
jne 0x2844b6
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x2844b6
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x284720
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2844b4
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2844b6
jmp 0x2844b8
jmp 0x2844ba
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-errfind.c
// Function: processbranchingedge_errfind
static int processbranchingedge_errfind(GT_UNUSED bool firstsucc,
    GT_UNUSED GtUword fatherdepth,
    GT_UNUSED GtBUinfo_errfind *father, GT_UNUSED GtUword sondepth,
    GT_UNUSED GtUword sonwidth,
    GT_UNUSED GtBUinfo_errfind *son, GT_UNUSED GtBUstate_errfind *state,
    GT_UNUSED GtError *err)
{
  if (fatherdepth < state->k - 1)
    gt_errfind_reset(state);
  else if (fatherdepth == state->k - 1)
  {
      state->currentchar++;
#ifdef RDJ_ERRFIND_DEBUG
      gt_log_log("currentchar incremented, now is %u", state->currentchar);
#endif
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rdi
andb $0x1, %al
movb %al, 0x37(%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 0x40(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2846d3
movq 0x40(%rsp), %rdi
callq 0x282ef0
jmp 0x2846fa
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2846f8
movq 0x40(%rsp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2846fa
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-errfind.c
// Function: gt_errfind_process_kmer
static inline void gt_errfind_process_kmer(GtUword leafnumber,
    GtBUstate_errfind *state)
{
  GtUword current_count = ++state->count[state->currentchar];
  if (current_count <= state->c)
  {
    gt_assert(leafnumber + state->k - 1 <
        gt_encseq_total_length(state->encseq));
    state->kpositions[state->currentchar * state->c + current_count - 1] =
      leafnumber + state->k - 1;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, %edx
movq (%rcx,%rdx,8), %rax
addq $0x1, %rax
movq %rax, (%rcx,%rdx,8)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x28(%rcx), %rax
ja 0x28480e
jmp 0x284768
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
addq 0x20(%rcx), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa9d00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x2847d2
movq 0x3b77ff(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x291868(%rip), %rsi    # 0x516013
leaq 0x2fc435(%rip), %rdx    # 0x580be7
leaq 0x2fc470(%rip), %rcx    # 0x580c29
leaq 0x2fc3df(%rip), %r8     # 0x580b9f
movl $0x56, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2847d4
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rax
addq 0x20(%rax), %rdx
subq $0x1, %rdx
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rsp), %rcx
movl 0x1c(%rcx), %ecx
movq 0x18(%rsp), %rsi
imulq 0x28(%rsi), %rcx
addq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-errfind.c
// Function: gt_errfind_are_all_trusted
static inline bool gt_errfind_are_all_trusted(const GtBUstate_errfind *state)
{
  unsigned int cnum;
  bool alltrusted = true;
  for (cnum = 0; cnum < state->alphasize && alltrusted; cnum++)
    if (state->count[cnum] < state->c)
      alltrusted = false;
#ifdef RDJ_ERRFIND_DEBUG
  for (cnum = 0; cnum < state->alphasize; cnum++)
    gt_log_log("cnum %u count: "GT_WU"", cnum, state->count[cnum]);
#endif
  return alltrusted;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movb $0x1, -0xd(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpl 0x18(%rdx), %ecx
movb %al, -0xe(%rsp)
jae 0x28484e
movb -0xd(%rsp), %al
movb %al, -0xe(%rsp)
movb -0xe(%rsp), %al
testb $0x1, %al
jne 0x284858
jmp 0x284888
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x284879
movb $0x0, -0xd(%rsp)
jmp 0x28487b
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x284832
movb -0xd(%rsp), %al
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-errfind.c
// Function: gt_errfind_trusted_char
static inline GtUchar gt_errfind_trusted_char(const GtBUstate_errfind *state)
{
  unsigned int cnum;
  GtUchar trusted_char = (GtUchar)GT_UNDEF_UCHAR;
  GtUword trusted_count = 0;
  for (cnum = 0; cnum < state->alphasize &&
      trusted_char == (GtUchar)GT_UNDEF_UCHAR; cnum++)
  {
    if (state->count[cnum] >= state->c && state->count[cnum] > trusted_count)
    {
      trusted_char = gt_encseq_get_encoded_char_nospecial(state->encseq,
         state->kpositions[cnum * state->c], GT_READMODE_FORWARD);
#ifdef RDJ_ERRFIND_DEBUG
      gt_log_log("trusted_char: %c (cnum: %u), count: "GT_WU", pos: "GT_WU"",
          "acgt"[trusted_char], cnum, state->count[cnum],
          state->kpositions[cnum * state->c]);
#endif
    }
  }
  return trusted_char;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movb $-0x1, 0x1b(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rdx
xorl %eax, %eax
cmpl 0x18(%rdx), %ecx
movb %al, 0xf(%rsp)
jae 0x2848d4
movzbl 0x1b(%rsp), %eax
cmpl $0xff, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2848de
jmp 0x284953
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x284941
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
cmpq 0x10(%rsp), %rax
jbe 0x284941
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rdx
imulq 0x28(%rdx), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0xaa7f0
movb %al, 0x1b(%rsp)
jmp 0x284943
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2848af
movb 0x1b(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-gusfield.c
// Function: maximize_child_offset
static inline
void maximize_child_offset(RdjGusfieldIndexBounds *child,
                           const Suffixarray *sarr)
{
  GtUword idx, lcp;
  child->offset = lcptable_get(sarr, child->leftbound+1);
  for (idx = child->leftbound+2; idx <= child->rightbound; idx++)
  {
    lcp = lcptable_get(sarr, idx);
    if (lcp < child->offset)
    {
      child->offset = lcp;
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
addq $0x1, %rsi
callq 0x2860c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x2, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x2860b4
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2860c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2860a2
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2860a4
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x286062
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sarr-def.h
// Function: lcptable_get
static inline GtUword lcptable_get(
                       const Suffixarray *suffixarray,
                       GtUword pos)
{
  GtUchar smalllcpvalue;
  const Largelcpvalue *largelcpvalue;

  gt_assert(pos <= gt_encseq_total_length(suffixarray->encseq));
  smalllcpvalue = suffixarray->lcptab[pos];
  if (smalllcpvalue != (GtUchar) LCPOVERFLOW)
  {
    return (GtUword) smalllcpvalue;
  }
  largelcpvalue = getlargelcpvalue(suffixarray,pos);
  gt_assert(largelcpvalue != NULL);
  return largelcpvalue->value;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0xa9d00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x28612a
movq 0x3b5ea7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28ff10(%rip), %rsi    # 0x516013
leaq 0x2fac9d(%rip), %rdx    # 0x580da7
leaq 0x2facc9(%rip), %rcx    # 0x580dda
leaq 0x2faccf(%rip), %r8     # 0x580de7
movl $0x83, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28612c
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x20(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0xff, %eax
je 0x286159
movzbl 0x1f(%rsp), %eax
movq %rax, 0x30(%rsp)
jmp 0x2861bd
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2861d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2861ad
movq 0x3b5e24(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28fe8d(%rip), %rsi    # 0x516013
leaq 0x2facaf(%rip), %rdx    # 0x580e3c
leaq 0x2fac46(%rip), %rcx    # 0x580dda
leaq 0x2fac4c(%rip), %r8     # 0x580de7
movl $0x8a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2861af
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sarr-def.h
// Function: getlargelcpvalue
static inline const Largelcpvalue *getlargelcpvalue(
                       const Suffixarray *suffixarray,
                       GtUword pos)
{
  const Largelcpvalue *leftptr, *rightptr, *midptr;
  GtUword len;

  gt_assert(suffixarray->numoflargelcpvalues.defined);

  leftptr = suffixarray->llvtab;
  rightptr = suffixarray->llvtab +
             suffixarray->numoflargelcpvalues.valueunsignedlong - 1;

  while (leftptr<=rightptr)
  {
    len = (GtUword) (rightptr-leftptr);
    midptr = leftptr + GT_DIV2(len);
    if (pos < midptr->position)
    {
      rightptr = midptr - 1;
    } else
    {
      if (pos > midptr->position)
      {
        leftptr = midptr + 1;
      } else
      {
        return midptr;
      }
    }
  }
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
testb $0x1, 0x8(%rax)
jne 0x286221
movq 0x3b5db0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28fe19(%rip), %rsi    # 0x516013
leaq 0x2fac51(%rip), %rdx    # 0x580e52
leaq 0x2fac73(%rip), %rcx    # 0x580e7b
leaq 0x2fabd8(%rip), %r8     # 0x580de7
movl $0x61, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x286223
movq 0x28(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x2862dd
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
shrq %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2862ab
movq 0x8(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x2862d8
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x2862ca
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
jmp 0x2862d6
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2862e6
jmp 0x2862d8
jmp 0x286253
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: gt_rdj_pairwise_exact
void gt_rdj_pairwise_exact(GtOvlfindMode m, GtEncseq *encseq,
    bool revcompl, bool show_progressbar, bool use_kmp,
    GtUword min_length, bool find_nonmaximal, GtSpmproc proc,
    void *procdata, bool cntfilter, GtBitsequence *cntreads_in,
    GtBitsequence **cntreads_out, GtUword *nofreads)
{
  gt_assert(rdj_pairwise_check_arguments(m, proc, procdata, cntreads_in,
                            cntreads_out, cntfilter));
  rdj_pairwise_generic(false, m, encseq, revcompl, show_progressbar, use_kmp,
      0.0, min_length, find_nonmaximal, proc, NULL, procdata, cntfilter,
      cntreads_in, cntreads_out, nofreads);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, 0x50(%rsp)
movl %edx, %eax
movl 0x50(%rsp), %edx
movq %rsi, %r8
movl %edi, %r10d
movb %cl, %sil
movb %al, %dil
movq 0xe0(%rsp), %rax
movq 0xd8(%rsp), %rax
movq 0xd0(%rsp), %rax
movb 0xc8(%rsp), %al
movq 0xc0(%rsp), %rcx
movq 0xb8(%rsp), %rcx
movb 0xb0(%rsp), %cl
movl %r10d, 0x74(%rsp)
movq %r8, 0x68(%rsp)
andb $0x1, %dil
movb %dil, 0x67(%rsp)
andb $0x1, %sil
movb %sil, 0x66(%rsp)
andb $0x1, %dl
movb %dl, 0x65(%rsp)
movq %r9, 0x58(%rsp)
andb $0x1, %cl
movb %cl, 0x57(%rsp)
andb $0x1, %al
movb %al, 0x56(%rsp)
movl 0x74(%rsp), %edi
movq 0xb8(%rsp), %rsi
movq 0xc0(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq 0xd8(%rsp), %r8
movb 0x56(%rsp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x2864b0
testb $0x1, %al
jne 0x2863ef
movq 0x3b5be2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28fc4b(%rip), %rsi    # 0x516013
leaq 0x2faabd(%rip), %rdx    # 0x580e8c
leaq 0x2fab0c(%rip), %rcx    # 0x580ee2
leaq 0x2fab1b(%rip), %r8     # 0x580ef8
movl $0x14b, %r9d            # imm = 0x14B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2863f1
movl 0x74(%rsp), %esi
movq 0x68(%rsp), %rdx
movb 0x67(%rsp), %cl
movb 0x66(%rsp), %r8b
movb 0x65(%rsp), %r9b
movq 0x58(%rsp), %r12
movb 0x57(%rsp), %bpl
movq 0xb8(%rsp), %r15
movq 0xc0(%rsp), %r14
movb 0x56(%rsp), %bl
movq 0xd0(%rsp), %r11
movq 0xd8(%rsp), %r10
movq 0xe0(%rsp), %rax
xorl %edi, %edi
xorps %xmm0, %xmm0
xorl %r13d, %r13d
andb $0x1, %cl
andb $0x1, %r8b
andb $0x1, %r9b
andb $0x1, %bpl
andb $0x1, %bl
movzbl %cl, %ecx
movzbl %r8b, %r8d
movzbl %r9b, %r9d
movq %r12, (%rsp)
movzbl %bpl, %ebp
movl %ebp, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %r14, 0x20(%rsp)
movzbl %bl, %ebx
movl %ebx, 0x28(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
callq 0x286680
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: rdj_pairwise_check_arguments
static inline bool rdj_pairwise_check_arguments(GtOvlfindMode m, void *proc,
    void *procdata, GtBitsequence *cntreads_in, GtBitsequence **cntreads_out,
    bool cntfilter)
{
  gt_assert(m == GT_OVLFIND_CNT || m == GT_OVLFIND_ALL || m == GT_OVLFIND_SPM);
  if (proc == NULL)
  {
    gt_assert(m == GT_OVLFIND_CNT);
    gt_assert(procdata == NULL);
  }
  else
    gt_assert(m == GT_OVLFIND_SPM || m == GT_OVLFIND_ALL);
  if (cntfilter || (cntreads_out != NULL))
    gt_assert((m == GT_OVLFIND_CNT) ||
              (m == GT_OVLFIND_ALL) ||
              (cntreads_in != NULL));
  return true; /* allow to wrap in gt_assert() */
}

// Assembly:
subq $0x38, %rsp
movb %r9b, %al
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpl $0x1, 0x34(%rsp)
je 0x286522
cmpl $0x2, 0x34(%rsp)
je 0x286522
cmpl $0x0, 0x34(%rsp)
je 0x286522
movq 0x3b5aaf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28fb18(%rip), %rsi    # 0x516013
leaq 0x2faa26(%rip), %rdx    # 0x580f28
leaq 0x2faa61(%rip), %rcx    # 0x580f6a
leaq 0x2fa9e8(%rip), %r8     # 0x580ef8
movl $0x134, %r9d            # imm = 0x134
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x286524
cmpq $0x0, 0x28(%rsp)
jne 0x2865b9
jmp 0x286532
cmpl $0x1, 0x34(%rsp)
je 0x286571
movq 0x3b5a60(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28fac9(%rip), %rsi    # 0x516013
leaq 0x2faa36(%rip), %rdx    # 0x580f87
leaq 0x2faa12(%rip), %rcx    # 0x580f6a
leaq 0x2fa999(%rip), %r8     # 0x580ef8
movl $0x137, %r9d            # imm = 0x137
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x286573
jmp 0x286575
cmpq $0x0, 0x20(%rsp)
je 0x2865b5
movq 0x3b5a1c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28fa85(%rip), %rsi    # 0x516013
leaq 0x2faa06(%rip), %rdx    # 0x580f9b
leaq 0x2fa9ce(%rip), %rcx    # 0x580f6a
leaq 0x2fa955(%rip), %r8     # 0x580ef8
movl $0x138, %r9d            # imm = 0x138
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2865b7
jmp 0x286605
jmp 0x2865bb
cmpl $0x0, 0x34(%rsp)
je 0x286601
cmpl $0x2, 0x34(%rsp)
je 0x286601
movq 0x3b59d0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28fa39(%rip), %rsi    # 0x516013
leaq 0x3342ee(%rip), %rdx    # 0x5ba8cf
leaq 0x2fa982(%rip), %rcx    # 0x580f6a
leaq 0x2fa909(%rip), %r8     # 0x580ef8
movl $0x13b, %r9d            # imm = 0x13B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x286603
jmp 0x286605
testb $0x1, 0xf(%rsp)
jne 0x286614
cmpq $0x0, 0x10(%rsp)
je 0x286668
jmp 0x286616
cmpl $0x1, 0x34(%rsp)
je 0x286664
cmpl $0x2, 0x34(%rsp)
je 0x286664
cmpq $0x0, 0x18(%rsp)
jne 0x286664
movq 0x3b596d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28f9d6(%rip), %rsi    # 0x516013
leaq 0x2fa968(%rip), %rdx    # 0x580fac
leaq 0x2fa91f(%rip), %rcx    # 0x580f6a
leaq 0x2fa8a6(%rip), %r8     # 0x580ef8
movl $0x13f, %r9d            # imm = 0x13F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x286666
jmp 0x286668
movb $0x1, %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: gt_rdj_pairwise_approx
void gt_rdj_pairwise_approx(GtOvlfindMode m,  GtEncseq *encseq, bool revcompl,
    bool show_progressbar, double max_error, GtUword min_length,
    bool find_nonmaximal, GtSpmprocA proc, void* procdata, bool cntfilter,
    GtBitsequence *cntreads_in, GtBitsequence **cntreads_out,
    GtUword *nofreads)
{
  gt_assert(rdj_pairwise_check_arguments(m, proc, procdata, cntreads_in,
                            cntreads_out, cntfilter));
  rdj_pairwise_generic(true, m, encseq, revcompl, show_progressbar, false,
      max_error, min_length, find_nonmaximal, NULL, proc, procdata,
      cntfilter, cntreads_in, cntreads_out, nofreads);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, 0x48(%rsp)
movl %ecx, %eax
movl 0x48(%rsp), %ecx
movl %eax, 0x4c(%rsp)
movl %edx, %eax
movl 0x4c(%rsp), %edx
movq %rsi, 0x50(%rsp)
movl %edi, %r9d
movq 0x50(%rsp), %rdi
movb %al, %sil
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movq 0xd8(%rsp), %rax
movb 0xd0(%rsp), %al
movq 0xc8(%rsp), %r10
movq 0xc0(%rsp), %r10
movl %r9d, 0x84(%rsp)
movq %rdi, 0x78(%rsp)
andb $0x1, %sil
movb %sil, 0x77(%rsp)
andb $0x1, %dl
movb %dl, 0x76(%rsp)
movsd %xmm0, 0x68(%rsp)
movq %r8, 0x60(%rsp)
andb $0x1, %cl
movb %cl, 0x5f(%rsp)
andb $0x1, %al
movb %al, 0x5e(%rsp)
movl 0x84(%rsp), %edi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0xd8(%rsp), %rcx
movq 0xe0(%rsp), %r8
movb 0x5e(%rsp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x2864b0
testb $0x1, %al
jne 0x2871bc
movq 0x3b4e15(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28ee7e(%rip), %rsi    # 0x516013
leaq 0x2f9cf0(%rip), %rdx    # 0x580e8c
leaq 0x2f9d6e(%rip), %rcx    # 0x580f11
leaq 0x2f9d4e(%rip), %r8     # 0x580ef8
movl $0x158, %r9d            # imm = 0x158
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2871be
movl 0x84(%rsp), %esi
movq 0x78(%rsp), %rdx
movb 0x77(%rsp), %cl
movb 0x76(%rsp), %r8b
movsd 0x68(%rsp), %xmm0
movq 0x60(%rsp), %r12
movb 0x5f(%rsp), %bpl
movq 0xc0(%rsp), %r15
movq 0xc8(%rsp), %r14
movb 0x5e(%rsp), %bl
movq 0xd8(%rsp), %r11
movq 0xe0(%rsp), %r10
movq 0xe8(%rsp), %rax
movl $0x1, %edi
xorl %r9d, %r9d
xorl %r13d, %r13d
andb $0x1, %cl
andb $0x1, %r8b
andb $0x1, %bpl
andb $0x1, %bl
movzbl %cl, %ecx
movzbl %r8b, %r8d
movq %r12, (%rsp)
movzbl %bpl, %ebp
movl %ebp, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movq %r14, 0x20(%rsp)
movzbl %bl, %ebx
movl %ebx, 0x28(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
callq 0x286680
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: prepare_kmp_values
static gt_kmp_t** prepare_kmp_values(const GtEncseq *encseq, GtUword n)
{
  GtUword i, len, startpos;
  char *seq;
  gt_kmp_t **kmp_values;

  kmp_values = gt_malloc(sizeof (gt_kmp_t*) * n);
  gt_assert(encseq != NULL);
  for (i = 0; i < n; i++)
  {
    len = gt_encseq_seqlength(encseq, i);
    seq = gt_malloc(sizeof (char) * (len + 1));
    startpos = gt_encseq_seqstartpos(encseq, i);
    gt_encseq_extract_decoded(encseq, seq, startpos, startpos + len - 1);
    seq[len] = '\0';

    kmp_values[i] = gt_kmp_preproc(seq, len);
    gt_free(seq);
  }
  return kmp_values;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
shlq $0x3, %rdi
leaq 0x2f9c5a(%rip), %rsi    # 0x580ef8
movl $0x88, %edx
callq 0xe80f0
movq %rax, (%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x2872ec
movq 0x3b4ce5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28ed4e(%rip), %rsi    # 0x516013
leaq 0x2eb116(%rip), %rdx    # 0x5723e2
leaq 0x2f9da2(%rip), %rcx    # 0x581075
leaq 0x2f9c1e(%rip), %r8     # 0x580ef8
movl $0x89, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2872ee
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2873ca
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb09f0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x2f9bc9(%rip), %rsi    # 0x580ef8
movl $0x8d, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb0530
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
addq 0x18(%rsp), %rcx
subq $0x1, %rcx
callq 0xac570
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4e1340
movq %rax, %rdx
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rdi
leaq 0x2f9b4b(%rip), %rsi    # 0x580ef8
movl $0x93, %edx
callq 0xe88c0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2872f7
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: find_approx_overlaps
static inline GtContfind find_approx_overlaps(struct Data *d, double max_error,
    GtUword min_length, bool find_nonmaximal)
{
  GtContfind retval;

  if (d->u->seqnum == d->v->seqnum && d->v->direct)
  {
    if (!(d->mode == GT_OVLFIND_SPM || d->mode == GT_OVLFIND_ALL))
      return GT_CONTFIND_EQ;
    retval = gt_ovlfind_dp(d->u->seq, d->u->len, NULL, 0, max_error, d->mode,
        min_length, find_nonmaximal, call_spmproc_a, d);
  }
  else
  {
    retval = gt_ovlfind_dp(d->u->seq, d->u->len, d->v->seq, d->v->len,
        max_error, d->mode, min_length, find_nonmaximal, call_spmproc_a, d);
  }
  return retval;
}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0x2874b6
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x2874b6
movq 0x38(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0x287452
movq 0x38(%rsp), %rax
cmpl $0x2, 0x28(%rax)
je 0x287452
movl $0x2, 0x44(%rsp)
jmp 0x287534
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
movsd 0x30(%rsp), %xmm0
movq 0x38(%rsp), %rax
movl 0x28(%rax), %r8d
movq 0x28(%rsp), %r9
movb 0x27(%rsp), %r11b
movq 0x38(%rsp), %rax
xorl %ecx, %ecx
leaq 0x4fe(%rip), %r10       # 0x287990
andb $0x1, %r11b
movq %rcx, %rdx
movzbl %r11b, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x4de190
movl %eax, 0x20(%rsp)
jmp 0x28752c
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
movsd 0x30(%rsp), %xmm0
movq 0x38(%rsp), %rax
movl 0x28(%rax), %r8d
movq 0x28(%rsp), %r9
movb 0x27(%rsp), %r11b
movq 0x38(%rsp), %rax
leaq 0x483(%rip), %r10       # 0x287990
andb $0x1, %r11b
movzbl %r11b, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x4de190
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: mark_contained
static inline void mark_contained(GtContfind c, GtUword u_seqnum,
    GtUword v_seqnum, GtBitsequence *cntreads)
{
  gt_assert(cntreads != NULL);
  switch (c)
  {
    case GT_CONTFIND_U:
      GT_SETIBIT(cntreads, u_seqnum);
      break;
    case GT_CONTFIND_EQ:
      /* convention: skip one with higher seqnum (which is v) */
      if (v_seqnum != u_seqnum)
        GT_SETIBIT(cntreads, v_seqnum);
      break;
    case GT_CONTFIND_V:
      GT_SETIBIT(cntreads, v_seqnum);
      break;
    default:
      /* nothing to do */
      break;
  }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x287817
movq 0x3b47ba(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28e823(%rip), %rsi    # 0x516013
leaq 0x2f9825(%rip), %rdx    # 0x58101c
leaq 0x2f988a(%rip), %rcx    # 0x581088
leaq 0x2f96f3(%rip), %r8     # 0x580ef8
movl $0xa3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x287819
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x2, %eax
je 0x28786f
jmp 0x287828
movl 0x4(%rsp), %eax
subl $0x3, %eax
je 0x287841
jmp 0x287833
movl 0x4(%rsp), %eax
subl $0x4, %eax
je 0x2878a9
jmp 0x2878d7
movq 0x18(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x2878d9
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x2878a7
movq 0x10(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x2878d9
movq 0x10(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x2878d9
jmp 0x2878d9
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: call_spmproc_a
static void call_spmproc_a(GtUword length_on_u, GtUword length_on_v,
    GtUword unit_edist, bool suffix_of_u, void *data)
{
  struct Data *d = data;
  if (suffix_of_u)
    d->proc_a(d->u->seqnum, d->v->seqnum, length_on_u, length_on_v,
              unit_edist, d->u->direct, d->v->direct, d->procdata);
  else
    d->proc_a(d->v->seqnum, d->u->seqnum, length_on_v, length_on_u,
              unit_edist, d->v->direct, d->u->direct, d->procdata);
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %r8, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x287a33
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x18(%r9), %r9
movb 0x18(%r9), %r9b
movq 0x18(%rsp), %r10
movq 0x20(%r10), %r10
movb 0x18(%r10), %r11b
movq 0x18(%rsp), %r10
movq 0x10(%r10), %r10
andb $0x1, %r9b
andb $0x1, %r11b
movzbl %r9b, %r9d
movzbl %r11b, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
jmp 0x287aa3
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rsi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x20(%r9), %r9
movb 0x18(%r9), %r9b
movq 0x18(%rsp), %r10
movq 0x18(%r10), %r10
movb 0x18(%r10), %r11b
movq 0x18(%rsp), %r10
movq 0x10(%r10), %r10
andb $0x1, %r9b
andb $0x1, %r11b
movzbl %r9b, %r9d
movzbl %r11b, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: call_spmproc
static void call_spmproc(GtUword length, bool suffix_of_u, void *data)
{
  struct Data *d = data;
  if (suffix_of_u)
    d->proc(d->u->seqnum, d->v->seqnum, length,
        d->u->direct, d->v->direct, d->procdata);
  else
    d->proc(d->v->seqnum, d->u->seqnum, length, d->v->direct,
            d->u->direct, d->procdata);
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x287b33
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rsi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movb 0x18(%rcx), %cl
movq 0x8(%rsp), %r8
movq 0x20(%r8), %r8
movb 0x18(%r8), %r8b
movq 0x8(%rsp), %r9
movq 0x10(%r9), %r9
andb $0x1, %cl
andb $0x1, %r8b
movzbl %cl, %ecx
movzbl %r8b, %r8d
callq *%rax
jmp 0x287b8c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rsi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movb 0x18(%rcx), %cl
movq 0x8(%rsp), %r8
movq 0x18(%r8), %r8
movb 0x18(%r8), %r8b
movq 0x8(%rsp), %r9
movq 0x10(%r9), %r9
andb $0x1, %cl
andb $0x1, %r8b
movzbl %cl, %ecx
movzbl %r8b, %r8d
callq *%rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: processleafedge_spmeq
static inline int processleafedge_spmeq(bool firstsucc,
    GtUword fatherdepth,
    GtBUinfo_spmeq *father, GtUword seqnum, GtUword relpos,
    GtBUstate_spmeq *state, GT_UNUSED GtError *err)
{
  if (fatherdepth >= state->minmatchlength)
  {
    if (firstsucc)
    {
      gt_assert(father != NULL);
      father->w_left = state->w_nextfree;
    }
    if (relpos == 0)
      appendtowset_spm(seqnum, state);
    gt_assert(fatherdepth != state->read_length);
    if (relpos + fatherdepth == state->read_length)
      combine_terminal_with_wset(seqnum, seqnum * (state->read_length + 1),
         state->read_length, father->w_left, fatherdepth, state);
  }
  else
  {
#ifdef GT_READJOINER_STATISTICS
    reset_subtree_stats(state);
#endif
    state->w_nextfree = 0;
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
movq 0x40(%rsp), %rdi
andb $0x1, %al
movb %al, 0x37(%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 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x287cf3
testb $0x1, 0x37(%rsp)
je 0x287c3e
jmp 0x287be8
cmpq $0x0, 0x20(%rsp)
jne 0x287c28
movq 0x3b43a9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28e412(%rip), %rsi    # 0x516013
leaq 0x2efdf3(%rip), %rdx    # 0x5779fb
leaq 0x2f9526(%rip), %rcx    # 0x581135
leaq 0x2f94ed(%rip), %r8     # 0x581103
movl $0x192, %r9d            # imm = 0x192
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x287c2a
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x10(%rsp)
jne 0x287c55
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x28aca0
jmp 0x287c57
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x287c9f
movq 0x3b4332(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28e39b(%rip), %rsi    # 0x516013
leaq 0x2f94cc(%rip), %rdx    # 0x58114b
leaq 0x2f94af(%rip), %rcx    # 0x581135
leaq 0x2f9476(%rip), %r8     # 0x581103
movl $0x197, %r9d            # imm = 0x197
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x287ca1
movq 0x10(%rsp), %rax
addq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x287cf1
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
addq $0x1, %rax
imulq %rax, %rsi
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x28adf0
jmp 0x287d03
movq 0x8(%rsp), %rax
movq $0x0, 0x80(%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: processleafedge_spmvar
static inline int processleafedge_spmvar(bool firstsucc,
    GtUword fatherdepth,
    GtBUinfo_spmeq *father, GtUword seqnum, GtUword relpos,
    GtBUstate_spmeq *state, GT_UNUSED GtError *err)
{
  if (fatherdepth >= state->minmatchlength)
  {
    GtUword seqlen = gt_encseq_seqlength(state->encseq, seqnum);
    if (firstsucc)
    {
      gt_assert(father != NULL);
      father->w_left = state->w_nextfree;
    }
    if (relpos == 0)
    {
      appendtowset_spm(seqnum, state);
      if (fatherdepth == seqlen)
      {
        GtUword readnum = GT_READJOINER_READNUM(seqnum,
            state->first_revcompl, state->nofreads);
        (void)fwrite(&(readnum), sizeof (GtUword), (size_t)1,
            state->cntfile);
        state->nof_contained++;
      }
    }
    if (relpos + fatherdepth == seqlen)
      appendtolset_spm(seqnum, state);
  }
  else
  {
#ifdef GT_READJOINER_STATISTICS
    reset_subtree_stats(state);
#endif
    state->w_nextfree = 0;
  }
  return 0;
}

// Assembly:
subq $0x48, %rsp
movb %dil, %al
movq 0x50(%rsp), %rdi
andb $0x1, %al
movb %al, 0x47(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x287fce
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xb09f0
movq %rax, 0x10(%rsp)
testb $0x1, 0x47(%rsp)
je 0x287f06
jmp 0x287eb0
cmpq $0x0, 0x30(%rsp)
jne 0x287ef0
movq 0x3b40e1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28e14a(%rip), %rsi    # 0x516013
leaq 0x2efb2b(%rip), %rdx    # 0x5779fb
leaq 0x2f933b(%rip), %rcx    # 0x581212
leaq 0x2f9225(%rip), %r8     # 0x581103
movl $0x1b0, %r9d            # imm = 0x1B0
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x287ef2
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x20(%rsp)
jne 0x287fac
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x28aca0
movq 0x38(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x287faa
movq 0x18(%rsp), %rax
cmpq $0x0, 0x58(%rax)
jbe 0x287f61
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jb 0x287f61
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
subq $0x1, %rax
subq 0x28(%rsp), %rax
movq %rax, (%rsp)
jmp 0x287f6a
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0xe0(%rax), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x19ea0
movq 0x18(%rsp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
jmp 0x287fac
movq 0x20(%rsp), %rax
addq 0x38(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x287fcc
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x28b1f0
jmp 0x287fde
movq 0x18(%rsp), %rax
movq $0x0, 0x80(%rax)
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)