LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-cntlist.c
// Function: gt_cntlist_show
int gt_cntlist_show(GtBitsequence *cntlist, GtUword nofreads,
    const char *path, bool binary, GtError *err)
{
  FILE *file;
  gt_assert(cntlist != NULL);
  if (path == NULL)
    file = stdout;
  else
  {
    file = gt_fa_fopen(path, binary ? "wb" : "w", err);
    if (file == NULL)
      return -1;
  }
  gt_assert(file != NULL);
  (binary ? gt_cntlist_show_bit : gt_cntlist_show_ascii)
    (cntlist, nofreads, file);
  if (path != NULL)
    gt_fa_fclose(file);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c2012
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1c1fd2
leaq 0x193b66(%rip), %rax    # 0x355ae1
leaq 0x1d1633(%rip), %rsi    # 0x3935b5
testb %bpl, %bpl
cmovneq %rax, %rsi
leaq 0x1eaad1(%rip), %rax    # 0x3aca61
movq %rdx, %rdi
movq %rax, %rdx
movl $0x45, %ecx
callq 0xfcdbb
testq %rax, %rax
je 0x1c2002
movq %rax, %r15
leaq 0x6d(%rip), %rax        # 0x1c201c
leaq 0xe9(%rip), %rcx        # 0x1c209f
testb %bpl, %bpl
cmovneq %rax, %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *%rcx
movq %r15, %rdi
callq 0xfd018
jmp 0x1c1ffe
movq 0x2f6eff(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdx
testq %rdx, %rdx
je 0x1c2017
leaq 0x34(%rip), %rax        # 0x1c201c
leaq 0xb0(%rip), %rcx        # 0x1c209f
testb %bpl, %bpl
cmovneq %rax, %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq *%rcx
xorl %eax, %eax
jmp 0x1c2007
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x69100
callq 0x690c9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-cntlist.c
// Function: gt_cntlist_show_bit
static inline void gt_cntlist_show_bit(GtBitsequence *cntlist,
    GtUword nofreads, FILE *file)
{
  gt_assert(file != NULL);
  gt_xfputc(GT_CNTLIST_BIT_HEADER, file);
  gt_xfputc((char)sizeof(GtUword), file);
  gt_xfwrite(&(nofreads), sizeof (GtUword), (size_t)1, file);
  gt_xfwrite(cntlist, sizeof (GtBitsequence), GT_NUMOFINTSFORBITS(nofreads),
      file);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rdx, %rdx
je 0x1c209a
movq %rdx, %rbx
movq %rdi, %r14
xorl %edi, %edi
movq %rdx, %rsi
callq 0x11f81a
movl $0x8, %edi
movq %rbx, %rsi
callq 0x11f81a
movq %rsp, %r15
movl $0x1, %r12d
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11f89c
movq (%r15), %rax
leaq -0x1(%rax), %rdx
shrq $0x6, %rdx
incq %rdx
cmpq $0x40, %rax
cmovbq %r12, %rdx
movl $0x8, %esi
movq %r14, %rdi
movq %rbx, %rcx
callq 0x11f89c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x69137
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-cntlist.c
// Function: gt_cntlist_show_ascii
static inline void gt_cntlist_show_ascii(GtBitsequence *cntlist,
    GtUword nofreads, FILE *file)
{
  GtUword i;
  gt_assert(file != NULL);
  fprintf(file, "[n: "GT_WU"]\n", nofreads);
  for (i = 0; i < nofreads; i++)
    if (GT_ISIBITSET(cntlist, i))
      fprintf(file, ""GT_WU"\n", i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x1c2112
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1eab98(%rip), %rsi    # 0x3acc55
movq %rdx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x17ab0
testq %r14, %r14
je 0x1c2108
leaq 0x18e952(%rip), %r12    # 0x350a28
xorl %r13d, %r13d
movq %r13, %rax
shrq $0x6, %rax
movq (%r15,%rax,8), %rax
movl %r13d, %ecx
shlq %cl, %rax
shrq $0x3f, %rax
je 0x1c2100
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x17ab0
incq %r13
cmpq %r13, %r14
jne 0x1c20d9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x6916e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-cntlist.c
// Function: gt_cntlist_count
GtUword gt_cntlist_count(const GtBitsequence *cntlist,
    GtUword nofreads)
{
  GtUword i, counter = 0;

  for (i = 0; i < nofreads; i++)
    if ((bool)GT_ISIBITSET(cntlist, i))
      counter++;
  return counter;
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x1c254a
xorl %ecx, %ecx
movq %rcx, %rdx
shrq $0x6, %rdx
movq (%rdi,%rdx,8), %rdx
shlq %cl, %rdx
shrq $0x3f, %rdx
addq %rdx, %rax
incq %rcx
cmpq %rcx, %rsi
jne 0x1c252d
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-cntlist.c
// Function: gt_cntlist_xload
GtUword gt_cntlist_xload(const char *filename, GtBitsequence **cntlist,
    GtUword expected_nofreads)
{
  int retval;
  GtUword found_nofreads;
  GtError *err;

  if (!gt_file_exists(filename))
  {
    fprintf(stderr, "FATAL: error by loading contained reads list: "
        "file %s does not exist\n", filename);
    exit(EXIT_FAILURE);
  }

  err = gt_error_new();
  retval = gt_cntlist_parse(filename, true, cntlist, &found_nofreads, err);
  if (retval != 0)
  {
    fprintf(stderr, "FATAL: error by parsing contained reads list: %s\n",
        gt_error_get(err));
    exit(EXIT_FAILURE);
  }
  gt_error_delete(err);

  if (found_nofreads != expected_nofreads)
  {
    fprintf(stderr, "FATAL: error by parsing contained reads list: "
        "file specifies a wrong number of reads\nexpected "GT_WU", found "
        GT_WU"\n", expected_nofreads, found_nofreads);
    exit(EXIT_FAILURE);
  }

  return gt_cntlist_count(*cntlist, found_nofreads);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0xff28c
testb %al, %al
je 0x1c25d1
callq 0xfcb4c
movq %rax, %r15
movq %rsp, %rcx
movq %r12, %rdi
movl $0x1, %esi
movq %r14, %rdx
movq %rax, %r8
callq 0x1c2117
movq %r15, %rdi
testl %eax, %eax
jne 0x1c25d9
callq 0xfcccd
movq (%rsp), %rsi
cmpq %rbx, %rsi
jne 0x1c25de
testq %rbx, %rbx
je 0x1c25c3
movq (%r14), %rdx
xorl %eax, %eax
xorl %ecx, %ecx
movq %rcx, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rsi
shlq %cl, %rsi
shrq $0x3f, %rsi
addq %rsi, %rax
incq %rcx
cmpq %rcx, %rbx
jne 0x1c25a4
jmp 0x1c25c5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x69287
callq 0x692ab
movq %rbx, %rdi
callq 0x692d7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-cntlist.c
// Function: gt_cntlist_parse_bin_or_bit_header
static int gt_cntlist_parse_bin_or_bit_header(FILE *infp,
    GtUword *nofreads, GtError *err)
{
  int c;
  size_t n;

  gt_assert(infp != NULL && nofreads != NULL);
  gt_error_check(err);
  c = gt_xfgetc(infp);
  if (c == EOF)
  {
    gt_error_set(err, "contained reads list: unexpected end of file");
    return -1;
  }
  else if (c != (char)sizeof(GtUword))
  {
    gt_error_set(err, "contained reads list: %dbit version "
        "of GenomeTools required to use this list", c * CHAR_BIT);
    return -1;
  }
  n = fread(nofreads, sizeof (GtUword), (size_t)1, infp);
  if (n != (size_t)1 || *nofreads == 0)
  {
    gt_error_set(err, "contained reads list: unrecognized format");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x1c2680
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1c260e
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1c2685
movq %r15, %rdi
callq 0x11f793
cmpl $0x8, %eax
je 0x1c2629
cmpl $-0x1, %eax
jne 0x1c265f
leaq 0x1ea6bb(%rip), %rsi    # 0x3acce2
jmp 0x1c2653
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rcx
callq 0x17b40
cmpq $0x1, %rax
jne 0x1c264c
xorl %eax, %eax
cmpq $0x0, (%r14)
jne 0x1c267a
leaq 0x1ea709(%rip), %rsi    # 0x3acd5c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
jmp 0x1c2675
shll $0x3, %eax
leaq 0x1ea6a6(%rip), %rsi    # 0x3acd0f
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
callq 0x69335
callq 0x692fe
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contfinder.c
// Function: gt_contfinder_write_seqnums
int gt_contfinder_write_seqnums(GtContfinder *contfinder, bool sorted,
    GtFile *outfp, GT_UNUSED GtError *err)
{
  int had_err = 0;
  gt_contfinder_seqnum_t i;
  if (sorted)
  {
    for (i = 0; i < contfinder->logicalnofseqs; i++)
      if (!GT_ISIBITSET(contfinder->contained,
            GT_READJOINER_CONTFINDER_GET_SEQNUM(contfinder->seqnums, i)))
        gt_file_xprintf(outfp, ""GT_WU"\n", (GtUword)
            GT_READJOINER_CONTFINDER_GET_SEQNUM(contfinder->seqnums, i));
  }
  else
  {
    for (i = 0; i < contfinder->nofseqs; i++)
      if (!GT_ISIBITSET(contfinder->contained, i))
        gt_file_xprintf(outfp, ""GT_WU"\n", (GtUword)i);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
testl %esi, %esi
je 0x1c3ddc
movl 0x8(%r14), %eax
testl %eax, %eax
je 0x1c3e30
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
leaq 0x18cc8c(%rip), %r15    # 0x350a28
xorl %r13d, %r13d
movq 0x10(%r14), %rdx
movq 0x48(%r14), %rcx
movl (%rcx,%r13,4), %ecx
movq %r12, %rsi
shrq %cl, %rsi
movl %ecx, %edi
shrl $0x6, %edi
testq %rsi, (%rdx,%rdi,8)
jne 0x1c3dd0
movq %rbx, %rdi
movq %r15, %rsi
movq %rcx, %rdx
xorl %eax, %eax
callq 0xfee51
movl 0x8(%r14), %eax
incq %r13
movl %eax, %ecx
cmpq %rcx, %r13
jb 0x1c3d9f
jmp 0x1c3e30
movl 0xc(%r14), %eax
testl %eax, %eax
je 0x1c3e30
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
leaq 0x18cc33(%rip), %r15    # 0x350a28
xorl %r12d, %r12d
movq 0x10(%r14), %rdx
movq %r13, %rsi
movl %r12d, %ecx
shrq %cl, %rsi
movq %r12, %rcx
shrq $0x6, %rcx
testq %rsi, (%rdx,%rcx,8)
jne 0x1c3e26
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0xfee51
movl 0xc(%r14), %eax
incq %r12
movl %eax, %ecx
cmpq %rcx, %r12
jb 0x1c3df8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contfinder.c
// Function: gt_contfinder_write_sorted_seqnums
int gt_contfinder_write_sorted_seqnums(GtContfinder *contfinder, char* path,
    GtError *err)
{
  int had_err = 0;
  GtFile *file;
  file = gt_file_new(path, "wb", err);
  if (file == NULL)
    had_err = -1;
  if (!had_err)
  {
    had_err = gt_contfinder_write_seqnums(contfinder, true, file, err);
  }
  gt_file_delete(file);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x191c94(%rip), %rsi    # 0x355ae1
movq %rax, %rdi
callq 0xfea8a
movq %rax, %rbx
testq %rax, %rax
je 0x1c3e71
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1c3d6c
xorl %ebp, %ebp
jmp 0x1c3e76
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0xff22c
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contfinder.c
// Function: gt_contfinder_write_copynum
int gt_contfinder_write_copynum(GtContfinder *contfinder, char* path,
    GtError *err)
{
  int had_err = 0;
  gt_contfinder_seqnum_t i;
  FILE *file;
  file = gt_fa_fopen(path, "wb", err);
  if (file == NULL)
    had_err = -1;
  else
  {
#ifndef NDEBUG
    gt_contfinder_seqnum_t n_noncontained = 0;
    GtUword cnsum = 0;
    bool had_overflow = false;
#endif
    gt_contfinder_copynum_t cn;
    for (i = 0; i < contfinder->nofseqs; i++)
    {
      cn = contfinder->copynum[i];
      if (cn > 0)
      {
        gt_xfwrite(contfinder->copynum + i, sizeof (*contfinder->copynum),
            (size_t)1, file);
#ifndef NDEBUG
        n_noncontained++;
        if (cn == GT_CONTFINDER_COPYNUM_MAX)
        {
          had_overflow = true;
        }
        cnsum += cn;
#endif
      }
    }
    gt_assert(n_noncontained == contfinder->nofseqs -
        gt_contfinder_nofcontained(contfinder));
    gt_assert(had_overflow || (cnsum == (GtUword)contfinder->nofseqs));
    gt_fa_fclose(file);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r8
movq %rsi, %rax
movq %rdi, %r14
leaq 0x191c27(%rip), %rsi    # 0x355ae1
leaq 0x1e90c4(%rip), %rdx    # 0x3acf85
movq %rax, %rdi
movl $0x32c, %ecx            # imm = 0x32C
callq 0xfcdbb
movq %rax, (%rsp)
testq %rax, %rax
je 0x1c3f33
movl 0xc(%r14), %eax
xorl %r15d, %r15d
testl %eax, %eax
je 0x1c3f3a
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x40(%r14), %rdi
movzbl (%rdi,%rbp), %ebx
testq %rbx, %rbx
je 0x1c3f24
addq %rbp, %rdi
movl $0x1, %esi
movl $0x1, %edx
movq (%rsp), %rcx
callq 0x11f89c
incl %r15d
cmpq $0xff, %rbx
sete %al
orb %al, %r12b
addq %rbx, %r13
movl 0xc(%r14), %eax
incq %rbp
movl %eax, %ebx
cmpq %rbx, %rbp
jb 0x1c3eea
movl %r15d, %r15d
jmp 0x1c3f42
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1c3f6f
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1c3f88
movq %rbx, %rcx
subq %rax, %rcx
cmpq %r15, %rcx
jne 0x1c3f7e
cmpq %rbx, %r13
sete %al
orb %al, %r12b
testb $0x1, %r12b
je 0x1c3f83
movq (%rsp), %rdi
callq 0xfd018
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x699bb
callq 0x699f4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contfinder.c
// Function: gt_contfinder_nofcontained
GtUword gt_contfinder_nofcontained(GtContfinder *contfinder)
{
  size_t i;
  GtBitsequence v;
  GtUword nofcontained;
  const size_t tabsize = GT_NUMOFINTSFORBITS(contfinder->nofseqs);
  if (contfinder->contained == NULL)
    return 0;
  nofcontained = 0;
  for (i = 0; i < tabsize; i++)
  {
    v = contfinder->contained[i];
    for (/**/; v; nofcontained++)
      v &= v - 1;
  }
  return nofcontained;
}

// Assembly:
movl 0xc(%rdi), %eax
leal -0x1(%rax), %edx
shrl $0x6, %edx
incl %edx
cmpl $0x40, %eax
movl $0x1, %ecx
cmovael %edx, %ecx
movq 0x10(%rdi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x1c3fc8
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x1c3fc0
leaq -0x1(%rdi), %r8
incq %rax
andq %r8, %rdi
jne 0x1c3fb4
incq %rsi
cmpq %rcx, %rsi
jne 0x1c3fab
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contfinder.c
// Function: gt_contfinder_delete
void gt_contfinder_delete(GtContfinder *contfinder)
{
  if (contfinder != NULL)
  {
    GT_READJOINER_CONTFINDER_FREE_SEQNUMS(contfinder->seqnums);
    gt_free(contfinder->contained);
    gt_free(contfinder->copynum);
    gt_free(contfinder);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1c5182
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x1e7e49(%rip), %r14    # 0x3acf85
movq %r14, %rsi
movl $0x387, %edx            # imm = 0x387
callq 0x1045eb
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x388, %edx            # imm = 0x388
callq 0x1045eb
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x389, %edx            # imm = 0x389
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x38a, %edx            # imm = 0x38A
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contfinder.c
// Function: gt_contfinder_new
GtContfinder* gt_contfinder_new(GtReads2Twobit *r2t)
{
  GtContfinder *contfinder;
  contfinder = gt_malloc(sizeof (*contfinder));
  contfinder->contained = NULL;
  contfinder->copynum = NULL;
  contfinder->seqnums = NULL;
  contfinder->twobitencoding = gt_reads2twobit_export_twobitencoding(r2t);
  contfinder->seppos = (size_t*)gt_reads2twobit_export_seppos(r2t);
  contfinder->nofseqs = (gt_contfinder_seqnum_t)gt_reads2twobit_nofseqs(r2t);
  contfinder->logicalnofseqs = contfinder->nofseqs;
  contfinder->len = (size_t)gt_reads2twobit_seqlen_eqlen(r2t);
  return contfinder;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1e7df4(%rip), %rsi    # 0x3acf85
movl $0x50, %edi
movl $0x3a3, %edx            # imm = 0x3A3
callq 0x104226
movq %rax, %r14
movq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rax)
movq %rbx, %rdi
callq 0x1de114
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x1de124
movq %rax, 0x20(%r14)
movq %rbx, %rdi
callq 0x1de154
movl %eax, 0xc(%r14)
movl %eax, 0x8(%r14)
movq %rbx, %rdi
callq 0x1de164
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contfinder.c
// Function: gt_contfinder_radixsort_str_eqlen_tester
void gt_contfinder_radixsort_str_eqlen_tester(GtContfinder *contfinder,
    bool mirrored, GtUword depth,
    GtUword maxdepth, bool print)
{
  GtUword *suffixes, totallength, width, i;
  GtRadixsortstringinfo *rsi;

  totallength = (GtUword) contfinder->nofseqs * contfinder->len - 1;
  width = mirrored ? GT_MULT2(totallength + 1) : (totallength + 1);
  rsi = gt_radixsort_str_new(contfinder->twobitencoding,
                             totallength,
                             (GtUword) contfinder->len,
                             GT_MULT2(width));
  suffixes = gt_malloc(sizeof (GtUword) * width);
  for (i = 0; i < width; i++)
  {
    suffixes[i] = i;
  }
  gt_radixsort_str_eqlen(rsi, suffixes, NULL, 0, depth, maxdepth, width);
  if (print)
  {
    for (i = 0; i < width; i++)
    {
      printf(""GT_WU"\n", suffixes[i]);
    }
  }
  gt_free(suffixes);
  gt_radixsort_str_delete(rsi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %esi, %ecx
movl 0xc(%rdi), %r13d
movq 0x18(%rdi), %rax
imulq %rax, %r13
leaq -0x1(%r13), %rsi
shlq %cl, %r13
movl %r8d, %ebp
movq %rdx, %r12
movq (%rdi), %rdi
leaq (,%r13,2), %rcx
movq %rax, %rdx
callq 0x3206f8
movq %rax, %rbx
leaq (,%r13,8), %rdi
leaq 0x1e7d47(%rip), %rsi    # 0x3acf85
movl $0x3c0, %edx            # imm = 0x3C0
callq 0x104226
movq %rax, %r15
testq %r13, %r13
je 0x1c5325
leaq 0x1(%r13), %rax
andq $-0x2, %rax
leaq -0x1(%r13), %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x1937ae(%rip), %xmm1   # 0x358a20
xorl %ecx, %ecx
movdqa 0x1937b4(%rip), %xmm2   # 0x358a30
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x1937b4(%rip), %xmm4   # 0x358a40
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x1c52c1
movq %rcx, (%r15,%rcx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x1c52d8
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r15,%rcx,8)
addq $0x2, %rcx
paddq %xmm4, %xmm1
cmpq %rcx, %rax
jne 0x1c528c
movq %r13, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
movq %r14, %r9
callq 0x320909
testb %bpl, %bpl
je 0x1c533e
leaq 0x18b71e(%rip), %r14    # 0x350a28
xorl %r12d, %r12d
movq (%r15,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
incq %r12
cmpq %r12, %r13
jne 0x1c530d
jmp 0x1c533e
movq %r13, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
movq %r14, %r9
callq 0x320909
leaq 0x1e7c40(%rip), %rsi    # 0x3acf85
movq %r15, %rdi
movl $0x3cd, %edx            # imm = 0x3CD
callq 0x1045eb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32085a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contfinder.c
// Function: gt_contfinder_mark_as_contained
static inline void gt_contfinder_mark_as_contained(
    GtContfinder contfinder, GtContfinderBucketInfo bucket,
    bool except_lowest_seqnum)
{
  size_t i, from = 0, to = bucket.nofseqs;
  gt_contfinder_seqnum_t container = 0;
  gt_assert(bucket.nofseqs > 0);
  if (except_lowest_seqnum)
  {
    gt_contfinder_seqnum_t first, last;
    if (bucket.nofseqs == (gt_contfinder_seqnum_t)1)
      return;
    first = GT_READJOINER_CONTFINDER_GET_SEQNUM(bucket.seqnums, 0 +
        bucket.seqnums_offset);
    last = GT_READJOINER_CONTFINDER_GET_SEQNUM(bucket.seqnums, bucket.nofseqs
        - 1 + bucket.seqnums_offset);
    from = (size_t)1;
    if (last >= contfinder.nofseqs)
      last = (contfinder.nofseqs << 1) - last - 1;
    if (first >= contfinder.nofseqs || last < first)
    {
      from--;
      to--;
      container = last;
    }
    else
    {
      container = first;
      if (first == last) /* palindromic */
        to--;
    }
  }
  for (i = from; i < to; i++)
  {
    gt_contfinder_seqnum_t corrected =
      GT_READJOINER_CONTFINDER_GET_SEQNUM(bucket.seqnums,
          i + bucket.seqnums_offset);
    if (corrected >= contfinder.nofseqs)
      corrected = (contfinder.nofseqs << 1) - corrected - 1;
    GT_CONTFINDER_CONTAINS(&contfinder, container, corrected);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xa0(%rsp), %eax
testq %rax, %rax
je 0x1c5625
leaq 0x90(%rsp), %r8
leaq 0x40(%rsp), %rsi
testb %dil, %dil
je 0x1c556d
cmpl $0x1, %eax
je 0x1c5607
movq (%r8), %rcx
movq 0x8(%r8), %rdx
leaq (%rcx,%rdx,4), %rcx
movl (%rcx), %edi
leal -0x1(%rax), %edx
movl (%rcx,%rdx,4), %edx
movl 0xc(%rsi), %r9d
cmpl %r9d, %edx
movl %edx, %ecx
notl %ecx
leal (%rcx,%r9,2), %ecx
cmovbl %edx, %ecx
cmpl %r9d, %edi
jae 0x1c5616
cmpl %edi, %ecx
jb 0x1c5616
sete %cl
movzbl %cl, %ecx
subq %rcx, %rax
movl $0x1, %edx
movl %edi, %ecx
jmp 0x1c5571
xorl %edx, %edx
xorl %ecx, %ecx
cmpq %rax, %rdx
jae 0x1c5607
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
movq 0x8(%r8), %r9
shlq $0x2, %r9
addq (%r8), %r9
movl 0xc(%rsi), %r8d
leal (%r8,%r8), %r10d
movq 0x10(%rsi), %r11
movq 0x40(%rsi), %rsi
movl %ecx, %ebx
shrl $0x6, %ebx
movq %rdi, %r14
shrq %cl, %r14
movl %ecx, %r15d
movl (%r9,%rdx,4), %ebp
movl %ebp, %ecx
notl %ecx
addl %r10d, %ecx
cmpl %r8d, %ebp
cmovbl %ebp, %ecx
movq %rdi, %r12
shrq %cl, %r12
movl %ecx, %r13d
shrl $0x6, %r13d
orq %r12, (%r11,%r13,8)
testq %rsi, %rsi
je 0x1c55ff
testq %r14, (%r11,%rbx,8)
jne 0x1c5620
movzbl (%rsi,%r15), %ebp
movl %ecx, %ecx
movzbl (%rsi,%rcx), %r12d
movl $0x100, %r13d           # imm = 0x100
subl %r12d, %r13d
cmpl %ebp, %r13d
jbe 0x1c55fb
addb %bpl, %r12b
movb %r12b, (%rsi,%r15)
movb $0x0, (%rsi,%rcx)
incq %rdx
cmpq %rdx, %rax
jne 0x1c55ad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
decq %rax
xorl %edx, %edx
jmp 0x1c5571
callq 0x69b83
callq 0x69bbc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contigpaths.c
// Function: gt_contigpaths_get_file
static GtFile* gt_contigpaths_get_file(const char *indexname,
    const char *suffix, const char* mode, GtError *err)
{
  GtStr *path;
  GtFile *file;

  path = gt_str_new_cstr(indexname);
  gt_str_append_cstr(path, suffix);
  file = gt_file_new(gt_str_get(path), mode, err);
  gt_str_delete(path);
  return file;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x11acc9
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x11acf3
movq %r12, %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xfea8a
movq %rax, %rbx
movq %r12, %rdi
callq 0x11bdbf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contigs-graph.c
// Function: gt_contigs_graph_delete
void gt_contigs_graph_delete(GtContigsGraph *cg)
{
  if (cg != NULL)
  {
    gt_free(cg->v_spm[0]);
    gt_free(cg->v_spm[1]);
    gt_free(cg->v_scf);
    gt_free(cg->v_d);
    gt_free(cg->v_m);
    gt_free(cg->e_spm[0]);
    gt_free(cg->e_spm[1]);
    gt_free(cg->e_scf);
    gt_free(cg->v_cmp);
    gt_free(cg->units);
    gt_reads_libraries_table_delete(cg->rlt);
    gt_free(cg);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1c6c93
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x1e6680(%rip), %r14    # 0x3ad241
movq %r14, %rsi
movl $0x4c3, %edx            # imm = 0x4C3
callq 0x1045eb
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x4c4, %edx            # imm = 0x4C4
callq 0x1045eb
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x4c5, %edx            # imm = 0x4C5
callq 0x1045eb
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x4c6, %edx            # imm = 0x4C6
callq 0x1045eb
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x4c7, %edx            # imm = 0x4C7
callq 0x1045eb
movq 0x80(%rbx), %rdi
movq %r14, %rsi
movl $0x4c8, %edx            # imm = 0x4C8
callq 0x1045eb
movq 0x88(%rbx), %rdi
movq %r14, %rsi
movl $0x4c9, %edx            # imm = 0x4C9
callq 0x1045eb
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x4ca, %edx            # imm = 0x4CA
callq 0x1045eb
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x4cb, %edx            # imm = 0x4CB
callq 0x1045eb
movq 0x58(%rbx), %rdi
movq %r14, %rsi
movl $0x4cc, %edx            # imm = 0x4CC
callq 0x1045eb
movq 0xa0(%rbx), %rdi
callq 0x1df427
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4ce, %edx            # imm = 0x4CE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contigs-graph.c
// Function: gt_contigs_graph_rm_vertex
void gt_contigs_graph_rm_vertex(GtContigsGraph *cg, GtUword cnum)
{
  GtContigsGraphSpmEdge *edge;
  unsigned int incoming;
  gt_log_log("rm vertex "GT_WU"", cnum);
  for (incoming = 0; incoming < 2U; incoming++)
  {
    for (GT_CONTIGS_GRAPH_EACH_SPM_EDGE(cg, cnum, incoming, edge))
    {
      if (edge->deleted)
        continue;
      gt_contigs_graph_rm_spm_edge(cg, cnum, incoming, edge);
    }
  }
  cg->v_m[cnum].deleted = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1e645e(%rip), %rdi    # 0x3ad56c
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x103d72
movb $0x1, %bpl
movq 0x18(%r14,%r15,8), %rax
movq (%rax,%rbx,8), %rdx
movq 0x8(%rax,%rbx,8), %rcx
shrq $0x10, %rdx
shrq $0x10, %rcx
cmpq %rcx, %rdx
jae 0x1c717e
movq 0x80(%r14,%r15,8), %rcx
leaq (%rcx,%rdx,8), %r12
testb $0x40, 0x7(%r12)
jne 0x1c7168
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movq %r12, %rcx
callq 0x1c6ff9
movq 0x18(%r14,%r15,8), %rax
movq 0x80(%r14,%r15,8), %rcx
addq $0x8, %r12
movq 0x8(%rax,%rbx,8), %rdx
shrq $0x10, %rdx
leaq (%rcx,%rdx,8), %rdx
cmpq %rdx, %r12
jb 0x1c7142
movl $0x1, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x1c711b
movq 0x38(%r14), %rax
orb $0x1, (%rax,%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contigs-graph.c
// Function: gt_contigs_graph_nof_optional_neighbours
uint64_t gt_contigs_graph_nof_optional_neighbours(GtContigsGraph *cg,
    GtUword cnum, unsigned int incoming)
{
  uint64_t n = 0;
  GtContigsGraphSpmEdge *edge;
  for (GT_CONTIGS_GRAPH_EACH_SPM_EDGE(cg, cnum, incoming, edge))
  {
    if (edge->deleted)
      continue;
    if (GT_CONTIGS_GRAPH_IS_OPTIONAL(cg, edge->dest))
      n++;
  }
  return n;
}

// Assembly:
movl %edx, %eax
movq 0x18(%rdi,%rax,8), %rcx
movq (%rcx,%rsi,8), %rdx
movq 0x8(%rcx,%rsi,8), %rcx
shrq $0x10, %rdx
shrq $0x10, %rcx
cmpq %rcx, %rdx
jae 0x1c71f3
movq 0x80(%rdi,%rax,8), %rax
leaq (%rax,%rcx,8), %rcx
leaq (%rax,%rdx,8), %rdx
xorl %eax, %eax
testb $0x40, 0x7(%rdx)
jne 0x1c71e9
movq 0x38(%rdi), %rsi
movl (%rdx), %r8d
movzbl (%rsi,%r8), %esi
btl $0x1, %esi
adcq $0x0, %rax
addq $0x8, %rdx
cmpq %rcx, %rdx
jb 0x1c71cf
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contigs-graph.c
// Function: gt_contigs_graph_rm_optional_neighbours
void gt_contigs_graph_rm_optional_neighbours(GtContigsGraph *cg,
    GtUword cnum, unsigned int incoming)
{
  GtContigsGraphSpmEdge *edge;
  for (GT_CONTIGS_GRAPH_EACH_SPM_EDGE(cg, cnum, incoming, edge))
  {
    if (edge->deleted)
      continue;
    if (GT_CONTIGS_GRAPH_IS_OPTIONAL(cg, edge->dest))
    {
      /*gt_log_log("rm edge "GT_WU" -- %u", cnum, edge->dest);*/
      gt_contigs_graph_rm_spm_edge(cg, cnum, incoming, edge);
      /* if optional is now untraversable, rm it */
      if (cg->v_spm[0][edge->dest].deg == 0 ||
          cg->v_spm[1][edge->dest].deg == 0)
      {
        gt_contigs_graph_rm_vertex(cg, (GtUword)edge->dest);
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r13d
movq 0x18(%rdi,%r13,8), %rax
movq (%rax,%rsi,8), %r12
movq 0x8(%rax,%rsi,8), %rax
shrq $0x10, %r12
shrq $0x10, %rax
cmpq %rax, %r12
jae 0x1c729c
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
shlq $0x3, %r12
addq 0x80(%rdi,%r13,8), %r12
testb $0x40, 0x7(%r12)
jne 0x1c7279
movq 0x38(%r15), %rax
movl (%r12), %ecx
testb $0x2, (%rax,%rcx)
je 0x1c7279
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x1c6ff9
movq 0x18(%r15), %rax
movl (%r12), %esi
cmpw $0x0, (%rax,%rsi,8)
je 0x1c7271
movq 0x20(%r15), %rax
cmpw $0x0, (%rax,%rsi,8)
jne 0x1c7279
movq %r15, %rdi
callq 0x1c70f9
addq $0x8, %r12
movq 0x18(%r15,%r13,8), %rax
movq 0x8(%rax,%r14,8), %rax
shrq $0xd, %rax
andq $-0x8, %rax
addq 0x80(%r15,%r13,8), %rax
cmpq %rax, %r12
jb 0x1c7231
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contigs-graph.c
// Function: gt_contigs_graph_simplify
void gt_contigs_graph_simplify(GtContigsGraph *cg, bool restrict_rm_optionals)
{
  GtUword cnum;
  gt_assert(cg != NULL);
  for (cnum = 0; cnum < cg->nof_v; cnum++)
  {
    cg->v_m[cnum].mark0 = false;
    cg->v_m[cnum].mark1 = false;
    cg->v_m[cnum].visited = false;
  }
  for (cnum = 0; cnum < cg->nof_v; cnum++)
  {
    if (!cg->v_m[cnum].deleted &&
        GT_CONTIGS_GRAPH_IS_SINGLE_COPY(cg, cnum))
    {
      if (!cg->v_m[cnum].mark0)
      {
        /*gt_log_log("simplify from contig "GT_WU" (incoming=0, deg=%u)", cnum,
              cg->v_spm[0U][cnum].deg);*/
        gt_contigs_graph_simplify_from_contig(cg, cnum, 0U,
            restrict_rm_optionals);
      }
      if (!cg->v_m[cnum].mark1)
      {
        /*gt_log_log("simplify from contig "GT_WU" (incoming=1, deg=%u)", cnum,
              cg->v_spm[1U][cnum].deg);*/
        gt_contigs_graph_simplify_from_contig(cg, cnum, 1U,
            restrict_rm_optionals);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c7510
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x1c7505
xorl %eax, %eax
movq 0x38(%rbx), %rcx
andb $-0x41, (%rcx,%rax)
movq 0x38(%rbx), %rcx
andb $0x7f, (%rcx,%rax)
movq 0x38(%rbx), %rcx
andb $-0x11, (%rcx,%rax)
incq %rax
movq (%rbx), %rcx
cmpq %rcx, %rax
jb 0x1c7474
testq %rcx, %rcx
je 0x1c7505
movl $0x1c, %r15d
xorl %r14d, %r14d
movzbl %sil, %ebp
movq 0x38(%rbx), %rax
movb (%rax,%r14), %al
testb $0x1, %al
jne 0x1c74f9
movq 0x30(%rbx), %rcx
movss (%rcx,%r15), %xmm0
ucomiss 0x1e5d4e(%rip), %xmm0   # 0x3ad214
jb 0x1c74f9
testb $0x40, %al
jne 0x1c74e3
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x1c72a6
movq 0x38(%rbx), %rax
movb (%rax,%r14), %al
testb %al, %al
js 0x1c74f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl %ebp, %ecx
callq 0x1c72a6
incq %r14
addq $0x20, %r15
cmpq (%rbx), %r14
jb 0x1c74a9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x6a29b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contigs-writer.c
// Function: gt_contigs_writer_new
GtContigsWriter *gt_contigs_writer_new(const GtEncseq *reads, GtFile *outfp)
{
  GtContigsWriter *contigs_writer;

  gt_assert(reads != NULL);

  contigs_writer = gt_malloc(sizeof (GtContigsWriter));
  contigs_writer->reads = reads;
  contigs_writer->outfp = outfp;
  contigs_writer->show_paths = false;
  contigs_writer->nofseqs = gt_encseq_num_of_sequences(contigs_writer->reads);
  contigs_writer->contignum = 0;
  contigs_writer->arrival_rate = (double)0;
  contigs_writer->depthinfo.firstread_copynum = (float)1;
  contigs_writer->depthinfo.internal_copynum = (float)0;
  contigs_writer->depthinfo.lastread_copynum = (float)1;
  contigs_writer->depthinfo.depth = 0;
  contigs_writer->depthinfo.length = 0;
  contigs_writer->depthinfo.astat = (float)0;
  contigs_writer->rlen = 0;
  contigs_writer->calculate_astat = false;
  GT_INITARRAY(&contigs_writer->contig, char);
  contigs_writer->contig_desc = gt_str_new();
  contigs_writer->path_desc = gt_str_new();
  contigs_writer->asc = gt_assembly_stats_calculator_new();
  contigs_writer->esr = gt_encseq_create_reader_with_readmode(reads,
      GT_READMODE_FORWARD, 0);
  contigs_writer->rcn = NULL;
  contigs_writer->depthinfo_fp = NULL;
  return contigs_writer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1c8067
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1e5efb(%rip), %rsi    # 0x3adeca
movl $0xa8, %edi
movl $0x34, %edx
callq 0x104226
movq %rax, %r14
movq %rbx, (%rax)
movq %r15, 0x8(%rax)
xorl %r15d, %r15d
movb %r15b, 0x10(%rax)
movq %rbx, %rdi
callq 0xe7bac
movq %rax, 0x60(%r14)
movq %r15, 0x50(%r14)
movaps 0x1e5e9a(%rip), %xmm0   # 0x3adea0
movups %xmm0, 0x88(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r14)
movb %r15b, 0x11(%r14)
movups %xmm0, 0x28(%r14)
movq %r15, 0x38(%r14)
movups %xmm0, 0x78(%r14)
callq 0x11ac6c
movq %rax, 0x40(%r14)
callq 0x11ac6c
movq %rax, 0x48(%r14)
callq 0x125aa8
movq %rax, 0x18(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe91b2
movq %rax, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6a50e
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movsd %xmm0, (%rsp)
movq %rdi, %r15
movb $0x1, 0x11(%rdi)
movq (%rdi), %rdi
callq 0xf64f6
movq (%r15), %rdi
cmpl $0x2, %eax
jne 0x1c80a2
callq 0xf64f9
jmp 0x1c80bd
callq 0xe7b9c
movq %rax, %r12
movq (%r15), %rdi
callq 0xe7bac
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %xmm0
punpckldq 0x17f816(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movq %rax, 0x68(%r15)
subpd 0x17f81a(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x70(%r15)
leaq 0x1e5df1(%rip), %rdi    # 0x3adee9
movb $0x1, %al
callq 0x103d72
movq %r14, 0x98(%r15)
movq %rbx, 0xa0(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1c8191
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1c8152
leaq 0x28(%rbx), %r14
leaq 0x1e5d91(%rip), %rsi    # 0x3adeca
movl $0x68, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x48(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x125af0
movq 0x20(%rbx), %rdi
callq 0xe9204
leaq 0x1e5d4d(%rip), %rsi    # 0x3adeca
movq %rbx, %rdi
movl $0x6d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-contigs-writer.c
// Function: gt_contigs_writer_start
void gt_contigs_writer_start(GtContigsWriter *contigs_writer,
    GtUword seqnum)
{
  GtUword pos, nofchars, i;
  gt_assert(contigs_writer != NULL);
  pos = gt_encseq_seqstartpos(contigs_writer->reads, seqnum);
  nofchars = gt_encseq_seqlength(contigs_writer->reads, seqnum);
  for (i = 0; i < nofchars; i++, pos++)
  {
    char *c;
    GT_GETNEXTFREEINARRAY(c, &contigs_writer->contig, char,
        GT_CONTIGS_WRITER_CONTIG_INC);
    *c = gt_encseq_get_encoded_char_nospecial(contigs_writer->reads, pos,
        GT_READMODE_FORWARD)["acgt"];
  }
  contigs_writer->depthinfo.depth++;
  gt_str_append_uword(contigs_writer->path_desc,
      GT_CONTIGS_WRITER_READNUM(seqnum, contigs_writer->nofseqs));
  gt_str_append_char(contigs_writer->path_desc,
      GT_CONTIGS_WRITER_LETTER(seqnum, contigs_writer->nofseqs));
  if (contigs_writer->rcn != NULL)
  {
    contigs_writer->depthinfo.firstread_copynum = (float)contigs_writer->rcn[
      GT_CONTIGS_WRITER_READNUM(seqnum, contigs_writer->nofseqs)];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c8799
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xeb6ee
movq %rax, %r15
movq (%rbx), %rdi
movq %r14, (%rsp)
movq %r14, %rsi
callq 0xeb9d2
testq %rax, %rax
je 0x1c870e
movq %rax, %r12
leaq 0x195bdf(%rip), %r14    # 0x35e280
movq 0x30(%rbx), %rsi
cmpq %rsi, 0x38(%rbx)
jae 0x1c86b1
movq 0x28(%rbx), %rbp
jmp 0x1c86d8
addq $0x4000, %rsi           # imm = 0x4000
movq %rsi, 0x30(%rbx)
movq 0x28(%rbx), %rdi
leaq 0x1e5803(%rip), %rdx    # 0x3adeca
movl $0x11f, %ecx            # imm = 0x11F
callq 0x104461
movq %rax, %rbp
movq %rax, 0x28(%rbx)
testq %rbp, %rbp
je 0x1c8794
movq (%rbx), %rdi
movq 0x38(%rbx), %r13
leaq 0x1(%r13), %rax
movq %rax, 0x38(%rbx)
movq %r15, %rsi
xorl %edx, %edx
callq 0xe7fcb
movzbl %al, %eax
movb (%rax,%r14), %al
movb %al, (%rbp,%r13)
incq %r15
decq %r12
jne 0x1c86a1
incq 0x78(%rbx)
movq 0x48(%rbx), %rdi
movq 0x60(%rbx), %rsi
movq %rsi, %rax
shrq %rax
movq (%rsp), %r15
movq %r15, %r14
notq %r14
addq %r14, %rsi
cmpq %r15, %rax
cmovaq %r15, %rsi
callq 0x11ae72
movq 0x48(%rbx), %rdi
movq 0x60(%rbx), %rax
shrq %rax
xorl %ecx, %ecx
cmpq %r15, %rax
seta %cl
leal (%rcx,%rcx,2), %esi
addl $0x42, %esi
callq 0x11af23
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0x1c8785
movq 0x60(%rbx), %rcx
addq %rcx, %r14
shrq %rcx
cmpq %r15, %rcx
cmovaq %r15, %r14
movzbl (%rax,%r14), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6a629
callq 0x6a662
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1c87c7
cmpq $0x0, 0x50(%rdi)
je 0x1c87b3
movq 0x18(%rdi), %rdi
jmp 0x125e25
leaq 0x1e583b(%rip), %rax    # 0x3adff5
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
jmp 0x103fe1
pushq %rax
callq 0x6a69b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq 0x20(%rdx), %rcx
decq %rcx
cmpq %rdi, %rcx
jbe 0x1c93de
movl $0x0, 0x1c(%rbx)
movl 0x18(%rbx), %edx
testq %rdx, %rdx
je 0x1c93d5
movq 0x38(%rbx), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x173a0
movb $0x0, 0x40(%rbx)
jmp 0x1c9488
movb 0x40(%rbx), %al
testb %al, %al
jne 0x1c9488
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdi, %rcx
jne 0x1c9421
leaq (%r15,%r14), %r12
movq 0x10(%rbx), %rdi
callq 0xe7b9c
cmpq %rax, %r12
je 0x1c9418
movq 0x10(%rbx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xe811c
testb %al, %al
je 0x1c941e
movb $0x1, 0x40(%rbx)
jmp 0x1c9488
movb 0x40(%rbx), %al
testb $0x1, %al
jne 0x1c9488
movl 0x1c(%rbx), %eax
cmpl 0x18(%rbx), %eax
jae 0x1c9488
movq 0x38(%rbx), %rcx
movq (%rcx,%rax,8), %r12
leaq 0x1(%r12), %rdx
movq %rdx, (%rcx,%rax,8)
cmpq 0x28(%rbx), %rdx
ja 0x1c9477
decq %r15
movq 0x20(%rbx), %r13
addq %r15, %r13
movq 0x10(%rbx), %rdi
callq 0xe7b9c
cmpq %rax, %r13
jae 0x1c9492
addq 0x20(%rbx), %r15
movl 0x1c(%rbx), %eax
movq %rax, %rcx
imulq 0x28(%rbx), %rcx
shlq $0x3, %rcx
addq 0x30(%rbx), %rcx
movq %r15, (%rcx,%r12,8)
movq 0x20(%rbx), %rcx
decq %rcx
cmpq %r14, %rcx
jne 0x1c9488
incl %eax
movl %eax, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x6a997
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-errfind.c
// Function: processlcpinterval_errfind
static int processlcpinterval_errfind(GtUword lcp,
    GT_UNUSED GtBUinfo_errfind *info, GtBUstate_errfind *state,
    GT_UNUSED GtError *err)
{
  if (lcp == state->k - 1 && !gt_errfind_are_all_trusted(state))
  {
    GtUchar trusted_char = gt_errfind_trusted_char(state);
    if (trusted_char != (GtUchar)GT_UNDEF_UCHAR)
    {
      unsigned int cnum;
      for (cnum = 0; cnum < state->alphasize && state->count[cnum] > 0; cnum++)
      {
        if (state->count[cnum] < state->c)
        {
          GtUword i;
          for (i = 0; i < state->count[cnum]; i++)
          {
            GtUword pos = state->kpositions[cnum * state->c + i];
            GtUchar newchar = trusted_char;
            if (pos >= state->firstmirrorpos)
            {
              pos = state->totallength - 1UL - pos;
              newchar = (GtUchar)3 - newchar;
            }
            if (state->editor != NULL)
            {
#ifdef RDJ_ERRFIND_DEBUG
              printf(""GT_WU":%u\n", pos, (unsigned int)newchar);
#endif
              gt_twobitenc_editor_edit(state->editor, pos, newchar);
            }
          }
        }
      }
    }
  }
  return 0;
}

// Assembly:
movq 0x20(%rsi), %rax
decq %rax
cmpq %rdi, %rax
jne 0x1c95d4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x18(%rsi), %eax
testq %rax, %rax
je 0x1c95c6
movq 0x28(%rbx), %rcx
movq 0x38(%rbx), %rdx
movl $0x1, %esi
movq -0x8(%rdx,%rsi,8), %rdi
cmpq %rax, %rsi
jae 0x1c94e0
incq %rsi
cmpq %rcx, %rdi
jae 0x1c94ce
cmpq %rcx, %rdi
jae 0x1c95c6
xorl %r14d, %r14d
movq 0x28(%rbx), %rcx
movq 0x38(%rbx), %rdx
movq (%rdx,%r14,8), %rdx
cmpq %rcx, %rdx
setb %sil
testq %rdx, %rdx
sete %dl
orb %sil, %dl
movb $-0x1, %bpl
jne 0x1c9529
movq 0x10(%rbx), %rdi
movq 0x30(%rbx), %rax
imulq %r14, %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0xe7fcb
movl %eax, %ebp
movl 0x18(%rbx), %eax
incq %r14
movl %eax, %ecx
cmpq %rcx, %r14
jae 0x1c9539
cmpb $-0x1, %bpl
je 0x1c94ec
cmpb $-0x1, %bpl
sete %cl
testl %eax, %eax
sete %dl
orb %cl, %dl
jne 0x1c95c6
movb $0x3, %r14b
subb %bpl, %r14b
movq 0x38(%rbx), %rcx
xorl %r15d, %r15d
xorl %r12d, %r12d
movl %r12d, %r12d
movq (%rcx,%r12,8), %rdx
testq %rdx, %rdx
je 0x1c95c6
cmpq 0x28(%rbx), %rdx
jae 0x1c95ba
cmpq $0x0, (%rcx,%r12,8)
je 0x1c95ba
xorl %r13d, %r13d
movq 0x28(%rbx), %rax
imulq %r15, %rax
addq 0x30(%rbx), %rax
movq (%rax,%r13,8), %rsi
cmpq 0x58(%rbx), %rsi
jae 0x1c958f
movl %ebp, %eax
jmp 0x1c9599
notq %rsi
addq 0x60(%rbx), %rsi
movl %r14d, %eax
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1c95ae
movzbl %al, %edx
callq 0x1daecd
movq 0x38(%rbx), %rcx
incq %r13
cmpq (%rcx,%r12,8), %r13
jb 0x1c9575
movl 0x18(%rbx), %eax
incl %r12d
addq $0x8, %r15
cmpl %eax, %r12d
jb 0x1c9559
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xe7b9c
cmpq %rbx, %rax
jb 0x1ca21a
movq 0x60(%r14), %rax
movzbl (%rax,%rbx), %eax
cmpq $0xff, %rax
jne 0x1ca20d
cmpb $0x0, 0x8(%r14)
je 0x1ca21f
movq 0x10(%r14), %rax
movq 0x68(%r14), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
cmpq %rax, %rcx
ja 0x1ca215
movq %rax, %rsi
subq %rcx, %rsi
sarq %rsi
andq $-0x10, %rsi
leaq (%rcx,%rsi), %rdx
cmpq %rbx, (%rcx,%rsi)
jbe 0x1ca1fe
addq $-0x10, %rdx
movq %rdx, %rax
jmp 0x1ca1d9
jae 0x1ca209
addq $0x10, %rdx
movq %rdx, %rcx
jmp 0x1ca1d9
movq 0x8(%rdx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x6ac00
callq 0x6ac39
callq 0x6abc9
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
movl %edi, %eax
subl $0x3, %eax
jae 0x1ca2f7
testq %rsi, %rsi
je 0x1ca2eb
testb $0x1, %dil
jne 0x1ca2fc
cmpl $-0x2, %eax
setb %al
testq %r8, %r8
setne %dl
orb %r9b, %dl
testq %rcx, %rcx
sete %cl
andb %al, %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x1ca2f5
callq 0x6ace4
cmpl $0x1, %edi
jne 0x1ca301
testq %rdx, %rdx
jne 0x1ca306
popq %rax
retq
callq 0x6ac72
callq 0x6acab
callq 0x6ad1d
callq 0x6ad56