LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_map_sections
static void gt_randomcodes_map_sections(GtRandomcodesinfo *fci,
                                       GtSfxmappedrangelist *sfxmrlist)
{
  if (fci->differentcodes > 0)
  {
    fci->mappedallrandomcodes = gt_Sfxmappedrange_new("allrandomcodes",
                                                    fci->differentcodes,
                                                    GtSfxunsignedlong,
                                                    NULL,
                                                    NULL);
    gt_Sfxmappedrangelist_add(sfxmrlist, fci->mappedallrandomcodes);
    fci->mappedleftborder = gt_Sfxmappedrange_new("leftborder",
                                                 fci->differentcodes+1,
                                                 GtSfxuint32_t,
                                                 NULL,
                                                 NULL);
    gt_Sfxmappedrangelist_add(sfxmrlist, fci->mappedleftborder);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jbe 0x26f220
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
leaq 0x2b9fe6(%rip), %rdi    # 0x529184
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2cbb80
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rsi
callq 0x2ccb80
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
addq $0x1, %rsi
leaq 0x2d1b1b(%rip), %rdi    # 0x540d04
movl $0x2, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2cbb80
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x2ccb80
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_insertsuffixes_flush
static void gt_randomcodes_insertsuffixes_flush(void *data)
{
  GtRandomcodesinfo *fci = (GtRandomcodesinfo *) data;

  if (fci->buf.nextfree > 0)
  {
    const GtUword *ptr;

    gt_assert(fci->allrandomcodes != NULL);
    fci->codebuffer_total += fci->buf.nextfree;
    gt_radixsort_inplace_sort(fci->radixsort_codepos, fci->buf.nextfree);
    ptr = gt_randomcodes_find_insert(fci, fci->buf.spaceGtUwordPair[0].a);
    gt_assert(ptr != NULL);
    fci->total_inserted += gt_randomcodes_insertsuffixes_merge(fci,
        fci->buf.spaceGtUwordPair, ptr);
    gt_assert(fci->total_inserted == fci->codebuffer_total);
    fci->flushcount++;
    fci->buf.nextfree = 0;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0xc0(%rax)
jbe 0x26f65b
jmp 0x26f4e8
movq 0x8(%rsp), %rax
cmpq $0x0, 0xa0(%rax)
jne 0x26f52f
movq 0x3ccaa2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a6b0b(%rip), %rsi    # 0x516013
leaq 0x30f87d(%rip), %rdx    # 0x57ed8c
leaq 0x30fcda(%rip), %rcx    # 0x57f1f0
leaq 0x30f5b8(%rip), %r8     # 0x57ead5
movl $0x183, %r9d            # imm = 0x183
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26f531
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rcx
movq 0x8(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rsi
callq 0x101870
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rax
movq (%rax), %rsi
callq 0x26c810
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x26f5c3
movq 0x3cca0e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a6a77(%rip), %rsi    # 0x516013
leaq 0x30f56f(%rip), %rdx    # 0x57eb12
leaq 0x30fc46(%rip), %rcx    # 0x57f1f0
leaq 0x30f524(%rip), %r8     # 0x57ead5
movl $0x187, %r9d            # imm = 0x187
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26f5c5
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rsi
movq (%rsp), %rdx
callq 0x273500
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0x26f63b
movq 0x3cc996(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a69ff(%rip), %rsi    # 0x516013
leaq 0x30fbf9(%rip), %rdx    # 0x57f214
leaq 0x30fbce(%rip), %rcx    # 0x57f1f0
leaq 0x30f4ac(%rip), %r8     # 0x57ead5
movl $0x18a, %r9d            # imm = 0x18A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26f63d
movq 0x8(%rsp), %rax
movl 0x70(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x70(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0xc0(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_allocsize_for_insertion
static void gt_randomcodes_allocsize_for_insertion(GtRandomcodesinfo *fci,
                                                  GtUword maximumspace,
                                                  const GtSuftabparts_rc
                                                    *suftabparts_rc,
                                                  GtUword phase2extra)
{
  if (maximumspace > 0)
  {
    const GtUword maxrounds = 400UL;
    size_t used = gt_firstcodes_spacelog_workspace(fci->fcsl) +
                  phase2extra +
                  gt_suftabparts_rc_largestsizemappedpartwise(suftabparts_rc);

    if ((GtUword) used < maximumspace)
    {
      fci->buf.allocated = gt_radixsort_max_num_of_entries_ulongpair(
                                                (size_t) maximumspace - used);
    } else
    {
      fci->buf.allocated /= 4UL;
    }
    if ((GtUword) (fci->codebuffer_total+fci->numofcodes)/
                        fci->buf.allocated > maxrounds)
    {
      fci->buf.allocated
        = (fci->codebuffer_total+fci->numofcodes)/maxrounds;
    }
  } else
  {
    fci->buf.allocated /= 2UL;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
jbe 0x26f758
movq $0x190, 0x10(%rsp)      # imm = 0x190
movq 0x30(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x4be8d0
addq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x4da640
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x26f6ec
movq 0x28(%rsp), %rdi
subq 0x8(%rsp), %rdi
callq 0x100d00
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xc8(%rax)
jmp 0x26f703
movq 0x30(%rsp), %rax
movq 0xc8(%rax), %rcx
shrq $0x2, %rcx
movq %rcx, 0xc8(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
addq 0x18(%rcx), %rax
movq 0x30(%rsp), %rcx
xorl %edx, %edx
divq 0xc8(%rcx)
cmpq $0x190, %rax            # imm = 0x190
jbe 0x26f756
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
addq 0x18(%rcx), %rax
movl $0x190, %ecx            # imm = 0x190
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xc8(%rax)
jmp 0x26f76e
movq 0x30(%rsp), %rax
movq 0xc8(%rax), %rcx
shrq %rcx
movq %rcx, 0xc8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_delete_before_end
static void gt_randomcodes_delete_before_end(GtRandomcodesinfo *fci)
{
  if (fci->binsearchcache.spaceGtIndexwithcodeRC != NULL)
  {
    GT_FCI_SUBTRACTWORKSPACE(fci->fcsl, "binsearchcache");
    GT_FREEARRAY(&fci->binsearchcache, GtIndexwithcodeRC);
  }
  if (fci->radixsort_codepos != NULL)
  {
    gt_radixsort_delete(fci->radixsort_codepos);
    GT_FCI_SUBTRACTWORKSPACE(fci->fcsl, "radixsort_codepos");
    fci->radixsort_codepos = NULL;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x270320
movq 0x10(%rsp), %rax
movq 0xa8(%rax), %rdi
movl $0x31f, %esi            # imm = 0x31F
leaq 0x30e824(%rip), %rdx    # 0x57ead5
xorl %ecx, %ecx
leaq 0x30ed0e(%rip), %r8     # 0x57efc8
movl $0x1, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x4bea60
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x27031c
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x30e7ea(%rip), %rsi    # 0x57ead5
movl $0x320, %edx            # imm = 0x320
callq 0xe88c0
movq 0x10(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x48(%rax)
jmp 0x27031e
jmp 0x270320
movq 0x10(%rsp), %rax
cmpq $0x0, 0x80(%rax)
je 0x270386
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x1008f0
movq 0x10(%rsp), %rax
movq 0xa8(%rax), %rdi
movl $0x325, %esi            # imm = 0x325
leaq 0x30e77d(%rip), %rdx    # 0x57ead5
xorl %ecx, %ecx
leaq 0x307fc9(%rip), %r8     # 0x57832a
movl $0x1, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x4bea60
movq 0x10(%rsp), %rax
movq $0x0, 0x80(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_calculate_nofsamples
static inline GtUword gt_randomcodes_calculate_nofsamples(
    GT_UNUSED const GtEncseq *encseq, GtUword nofsequences,
    GtUword totallength, unsigned int bucketkeysize,
    unsigned int sampling_factor)
{
  GtUword nofkmers = totallength,
                nofnonkmers = (bucketkeysize + 1) * nofsequences - 1,
                nofsamples;
  gt_log_log("totallength = " GT_WU "", nofkmers);
  gt_log_log("nofsequences = " GT_WU "", nofsequences);
  if (nofnonkmers < nofkmers)
  {
    nofkmers -= nofnonkmers;
    gt_log_log("nofkmers = " GT_WU "", nofkmers);
  }
  else
  {
    gt_assert(gt_encseq_min_seq_length(encseq) <= (GtUword)bucketkeysize);
  }
  nofsamples = nofkmers / sampling_factor;
  return GT_MAX(GT_RANDOMCODES_NOFSAMPLES_MIN, nofsamples);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl %r8d, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
imulq 0x38(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x30e9ea(%rip), %rdi    # 0x57edc4
movb $0x0, %al
callq 0xe7740
movq 0x38(%rsp), %rsi
leaq 0x30e9e9(%rip), %rdi    # 0x57edd6
movb $0x0, %al
callq 0xe7740
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x270427
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x30e9cb(%rip), %rdi    # 0x57ede9
movb $0x0, %al
callq 0xe7740
jmp 0x270478
jmp 0x270429
movq 0x40(%rsp), %rdi
callq 0xb1050
movl 0x2c(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x270474
movq 0x3cbb5d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a5bc6(%rip), %rsi    # 0x516013
leaq 0x30e9a4(%rip), %rdx    # 0x57edf8
leaq 0x30e9d8(%rip), %rcx    # 0x57ee33
leaq 0x30e673(%rip), %r8     # 0x57ead5
movl $0x3be, %r9d            # imm = 0x3BE
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x270476
jmp 0x270478
movq 0x20(%rsp), %rax
movl 0x28(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x10(%rsp)
movl $0x2, %eax
cmpq 0x10(%rsp), %rax
jbe 0x2704a3
movl $0x2, %eax
movq %rax, 0x8(%rsp)
jmp 0x2704ad
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_accumulatecounts_flush
static void gt_randomcodes_accumulatecounts_flush(void *data)
{
  GtRandomcodesinfo *fci = (GtRandomcodesinfo *) data;

  if (fci->buf.nextfree > 0)
  {
    GtUword foundindex;

    gt_assert(fci->allrandomcodes != NULL);
    fci->codebuffer_total += fci->buf.nextfree;
    gt_radixsort_inplace_sort(fci->radixsort_code, fci->buf.nextfree);
    foundindex = gt_randomcodes_find_accu(fci, fci->buf.spaceGtUword[0]);
    gt_assert(foundindex != ULONG_MAX);
    fci->total_count += gt_randomcodes_accumulatecounts_merge(fci,
        fci->buf.spaceGtUword, fci->allrandomcodes + foundindex);
    gt_assert(fci->total_count == fci->codebuffer_total);
    fci->flushcount++;
    fci->buf.nextfree = 0;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0xc0(%rax)
jbe 0x2730d8
jmp 0x272f58
movq 0x8(%rsp), %rax
cmpq $0x0, 0xa0(%rax)
jne 0x272f9f
movq 0x3c9032(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a309b(%rip), %rsi    # 0x516013
leaq 0x30be0d(%rip), %rdx    # 0x57ed8c
leaq 0x30c109(%rip), %rcx    # 0x57f08f
leaq 0x30bb48(%rip), %r8     # 0x57ead5
movl $0x14d, %r9d            # imm = 0x14D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x272fa1
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rcx
movq 0x8(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rsi
callq 0x101870
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xf0(%rax), %rax
movq (%rax), %rsi
callq 0x26c270
movq %rax, (%rsp)
cmpq $-0x1, (%rsp)
jne 0x273030
movq 0x3c8fa1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a300a(%rip), %rsi    # 0x516013
leaq 0x30c0a5(%rip), %rdx    # 0x57f0b5
leaq 0x30c078(%rip), %rcx    # 0x57f08f
leaq 0x30bab7(%rip), %r8     # 0x57ead5
movl $0x151, %r9d            # imm = 0x151
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x273032
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xf0(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdx
movq (%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
callq 0x2730e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0x2730b8
movq 0x3c8f19(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a2f82(%rip), %rsi    # 0x516013
leaq 0x30bf88(%rip), %rdx    # 0x57f020
leaq 0x30bff0(%rip), %rcx    # 0x57f08f
leaq 0x30ba2f(%rip), %r8     # 0x57ead5
movl $0x154, %r9d            # imm = 0x154
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2730ba
movq 0x8(%rsp), %rax
movl 0x70(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x70(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0xc0(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_accumulatecounts_merge
static GtUword gt_randomcodes_accumulatecounts_merge(
                                        GtRandomcodesinfo *fci,
                                        const GtUword *querystream_fst,
                                        const GtUword *subjectstream_fst)
{
  GtUword found = 0;
  const GtUword *query = querystream_fst,
                      *subject = subjectstream_fst,
                      *querystream_lst = fci->buf.spaceGtUword
                                         + fci->buf.nextfree - 1,
                      *subjectstream_lst = fci->allrandomcodes
                                           + fci->differentcodes - 1;

  while (query <= querystream_lst && subject <= subjectstream_lst)
  {
    if (*query <= *subject)
    {
      gt_randomcodes_countocc_increment(&fci->tab, (GtUword)
          (subject - fci->allrandomcodes));
      found++;
      query++;
    } else
    {
      subject++;
    }
  }
  return found;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0xf0(%rax), %rax
movq 0x40(%rsp), %rcx
movq 0xc0(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0xa0(%rax), %rax
movq 0x40(%rsp), %rcx
movq 0x38(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpq 0x10(%rsp), %rcx
movb %al, 0x7(%rsp)
ja 0x273180
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
setbe %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x27318a
jmp 0x2731f6
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
ja 0x2731e3
movq 0x40(%rsp), %rdi
addq $0x110, %rdi            # imm = 0x110
movq 0x18(%rsp), %rsi
movq 0x40(%rsp), %rax
movq 0xa0(%rax), %rax
subq %rax, %rsi
sarq $0x3, %rsi
callq 0x273200
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x2731f1
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x27315d
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_insertsuffixes_merge
static GtUword gt_randomcodes_insertsuffixes_merge(
                                        GtRandomcodesinfo *fci,
                                        const GtUwordPair *querystream_fst,
                                        const GtUword *subjectstream_fst)
{
  GtUword found = 0, idx;
  const GtUwordPair *query = querystream_fst,
                    *querystream_lst = fci->buf.spaceGtUwordPair +
                                       fci->buf.nextfree - 1;
  const GtUword *subject = subjectstream_fst,
                      *subjectstream_lst = fci->allrandomcodes +
                                           fci->currentmaxindex;

  while (query <= querystream_lst && subject <= subjectstream_lst)
  {
    if (query->a <= *subject)
    {
      idx = gt_randomcodes_insertionindex(&fci->tab,
          (GtUword)(subject - fci->allrandomcodes));
      gt_spmsuftab_set(fci->spmsuftab, idx,
          gt_spmsuftab_usebitsforpositions(fci->spmsuftab)
          ? gt_seqnumrelpos_decode_pos(fci->buf.snrp, query->b)
          : query->b);
      found++;
      query++;
    } else
    {
      subject++;
    }
  }
  return found;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x60(%rsp), %rcx
movq 0xc0(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq 0xa0(%rax), %rax
movq 0x60(%rsp), %rcx
movq 0x30(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpq 0x30(%rsp), %rcx
movb %al, 0x1f(%rsp)
ja 0x27359c
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
setbe %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x2735a9
jmp 0x273690
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
ja 0x27367d
movq 0x60(%rsp), %rdi
addq $0x110, %rdi            # imm = 0x110
movq 0x28(%rsp), %rsi
movq 0x60(%rsp), %rax
movq 0xa0(%rax), %rax
subq %rax, %rsi
sarq $0x3, %rsi
callq 0x2736a0
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x2eed70
testb $0x1, %al
jne 0x27361f
jmp 0x27363f
movq 0x60(%rsp), %rax
movq 0xf8(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x2b11d0
movq %rax, (%rsp)
jmp 0x27364c
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
callq 0x273870
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
jmp 0x27368b
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
jmp 0x273579
movq 0x48(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-tab.h
// Function: gt_randomcodes_insertionindex
GT_UNUSED
static inline GtUword gt_randomcodes_insertionindex(GtRandomcodestab *rct,
                                                         GtUword idx)
{
#if defined (_LP64) || defined (_WIN64)
  GT_CHANGEPOINT_GET_RCT(changepoint);
  gt_assert(idx < rct->differentcodes);
  if (rct->leftborder[idx] > 0)
  {
    return (GtUword) --rct->leftborder[idx]
                           + (changepoint << rct->modvaluebits);
  } else
  {
    gt_assert(changepoint > 0);
    changepoint--;
    rct->bitchangepoints.spaceGtUword[changepoint]++;
    rct->leftborder[idx] = rct->modvaluemask;
    return (GtUword)
           rct->leftborder[idx] + (changepoint << rct->modvaluebits);
  }
#else
  gt_assert(idx < rct->differentcodes && rct->leftborder[idx] > 0);
  return (GtUword) --rct->leftborder[idx];
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpq 0x90(%rdx), %rcx
movb %al, 0x7(%rsp)
jae 0x2736f1
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x80(%rcx), %rcx
movq 0x8(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
seta %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2736fb
jmp 0x27370b
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2736b7
jmp 0x27370d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x273754
movq 0x3c887d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a28e6(%rip), %rsi    # 0x516013
leaq 0x30bb0d(%rip), %rdx    # 0x57f241
leaq 0x30bb20(%rip), %rcx    # 0x57f25b
leaq 0x30b9e1(%rip), %r8     # 0x57f123
movl $0x73, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x273756
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jbe 0x2737a3
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x10(%rsp), %rdx
movl (%rcx,%rdx,4), %eax
addl $-0x1, %eax
movl %eax, (%rcx,%rdx,4)
movl %eax, %eax
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x7c(%rcx), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x273857
jmp 0x2737a5
cmpq $0x0, 0x8(%rsp)
ja 0x2737e5
movq 0x3c87ec(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a2855(%rip), %rsi    # 0x516013
leaq 0x30518c(%rip), %rdx    # 0x578951
leaq 0x30ba8f(%rip), %rcx    # 0x57f25b
leaq 0x30b950(%rip), %r8     # 0x57f123
movl $0x7a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2737e7
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movl 0x78(%rax), %edx
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x7c(%rcx), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_idx2mincode
static GtUword gt_randomcodes_idx2mincode(const GtRandomcodesinfo *fci,
                                            GtUword idx)
{
  gt_assert(idx <= fci->differentcodes);
  if (idx == 0)
  {
    return 0;
  }
  else
  {
    return fci->allrandomcodes[idx-1];
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x2739f4
movq 0x3c85dd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a2646(%rip), %rsi    # 0x516013
leaq 0x304df3(%rip), %rdx    # 0x5787c7
leaq 0x30b936(%rip), %rcx    # 0x57f311
leaq 0x30b0f3(%rip), %r8     # 0x57ead5
movl $0x32d, %r9d            # imm = 0x32D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2739f6
cmpq $0x0, (%rsp)
jne 0x273a08
movq $0x0, 0x10(%rsp)
jmp 0x273a25
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_idx2maxcode
static GtUword gt_randomcodes_idx2maxcode(const GtRandomcodesinfo *fci,
                                            GtUword idx)
{
  gt_assert(idx <= fci->differentcodes);
  if (idx == fci->differentcodes)
  {
    return fci->allrandomcodes[idx-1];
  }
  return fci->allrandomcodes[idx];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x273a84
movq 0x3c854d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a25b6(%rip), %rsi    # 0x516013
leaq 0x304d63(%rip), %rdx    # 0x5787c7
leaq 0x30b8c1(%rip), %rcx    # 0x57f32c
leaq 0x30b063(%rip), %r8     # 0x57ead5
movl $0x33b, %r9d            # imm = 0x33B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x273a86
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x273ab4
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x273acd
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_thread_caller_sortremaining
static void *gt_randomcodes_thread_caller_sortremaining(void *data)
{
  GtRandomcodesSortRemainingThreadinfo *threadinfo =
    (GtRandomcodesSortRemainingThreadinfo *) data;

  if (gt_randomcodes_sortremaining(threadinfo->srsw,
                                  threadinfo->encseq,
                                  threadinfo->readmode,
                                  threadinfo->spmsuftab,
                                  threadinfo->snrp,
                                  threadinfo->rct,
                                  threadinfo->allrandomcodes,
                                  threadinfo->minindex,
                                  threadinfo->maxindex,
                                  threadinfo->sumofwidth,
                                  threadinfo->sortingdepth,
                                  threadinfo->bucketkeysize,
                                  threadinfo->itvprocess,
                                  threadinfo->itvprocess_end,
                                  threadinfo->itvprocessdata,
                                  threadinfo->withsuftabcheck,
                                  threadinfo->err) != 0)
  {
    gt_assert(false);
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq (%rax), %rdi
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x78(%rsp), %rax
movl 0x10(%rax), %edx
movq 0x78(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x78(%rsp), %rax
movq 0x20(%rax), %r8
movq 0x78(%rsp), %rax
movq 0x28(%rax), %r9
movq 0x78(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x78(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq 0x40(%rax), %r13
movq 0x78(%rsp), %rax
movq 0x48(%rax), %r12
movq 0x78(%rsp), %rax
movl 0x50(%rax), %r15d
movq 0x78(%rsp), %rax
movl 0x54(%rax), %ebp
movq 0x78(%rsp), %rax
movq 0x60(%rax), %r14
movq 0x78(%rsp), %rax
movq 0x68(%rax), %rbx
movq 0x78(%rsp), %rax
movq 0x70(%rax), %r11
movq 0x78(%rsp), %rax
movb 0x58(%rax), %r10b
movq 0x78(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x60(%rsp), %rax
andb $0x1, %r10b
movq %rax, (%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movl %r15d, 0x20(%rsp)
movl %ebp, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
movq %r11, 0x40(%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x48(%rsp)
movq %rax, 0x50(%rsp)
callq 0x274190
cmpl $0x0, %eax
je 0x274bab
jmp 0x274b73
movq 0x3c7426(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a148f(%rip), %rsi    # 0x516013
leaq 0x2e41d8(%rip), %rdx    # 0x558d63
leaq 0x30a831(%rip), %rcx    # 0x57f3c3
leaq 0x309f3c(%rip), %r8     # 0x57ead5
movl $0x2b6, %r9d            # imm = 0x2B6
movb $0x0, %al
callq 0x199f0
callq 0x19370
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_findfirstlarger
static GtUword gt_randomcodes_findfirstlarger(const GtRandomcodestab *rct,
                                                   GtUword start,
                                                   GtUword end,
                                                   GtUword offset)
{
  GtUword left = start, right = end, found = end, mid, midval;

  while (left+1 < right)
  {
    mid = GT_DIV2(left+right);
    midval = gt_randomcodes_get_leftborder(rct, mid);
    if (offset == midval)
    {
      return mid;
    }
    if (offset < midval)
    {
      found = mid;
      right = mid - 1;
    } else
    {
      left = mid + 1;
    }
  }
  return found;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
cmpq 0x20(%rsp), %rax
jae 0x274c7d
movq 0x28(%rsp), %rax
addq 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4dbbd0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x274c44
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x274c87
movq 0x30(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x274c6a
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x274c78
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x274bf6
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes.c
// Function: gt_randomcodes_codelcp
static GtUword gt_randomcodes_codelcp(GtUword a, GtUword b)
{
  GtUword lcpvalue = 0;
  GtUword mask;
  const GtUword xorvalue = a ^ b;
  for (mask = (GtUword) 3 << GT_MULT2(GT_UNITSIN2BITENC - 1);
      mask > 0; mask >>= 2, lcpvalue++)
    if (xorvalue & mask)
      return lcpvalue;
  return lcpvalue;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x10(%rsp), %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
jbe 0x274d15
movq -0x30(%rsp), %rax
andq -0x28(%rsp), %rax
cmpq $0x0, %rax
je 0x274cf5
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x274d1f
jmp 0x274cf7
movq -0x28(%rsp), %rax
shrq $0x2, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x274cd1
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/spmsuftab.h
// Function: gt_spmsuftab_get
GT_UNUSED static inline GtUword gt_spmsuftab_get(
                                      const GtSpmsuftab *spmsuftab,
                                      GtUword idx)
{
  gt_assert(idx >= spmsuftab->partoffset);
  idx -= spmsuftab->partoffset;
  gt_assert(idx < spmsuftab->numofentries);
  return gt_compact_ulong_store_get(spmsuftab->bitpackarray,idx);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x274ff5
movq 0x3c6fdc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a1045(%rip), %rsi    # 0x516013
leaq 0x30398c(%rip), %rdx    # 0x578961
leaq 0x30a507(%rip), %rcx    # 0x57f4e3
leaq 0x30a296(%rip), %r8     # 0x57f279
movl $0x2f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x274ff7
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x275054
movq 0x3c6f7d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a0fe6(%rip), %rsi    # 0x516013
leaq 0x30a4c0(%rip), %rdx    # 0x57f4f4
leaq 0x30a4a8(%rip), %rcx    # 0x57f4e3
leaq 0x30a237(%rip), %r8     # 0x57f279
movl $0x31, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x275056
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xa20c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-cntlist.c
// Function: gt_cntlist_write_bin_header
void gt_cntlist_write_bin_header(GtUword nofreads, FILE *file)
{
  gt_assert(file != NULL);
  gt_xfputc(GT_CNTLIST_BIN_HEADER, file);
  gt_xfputc((char)sizeof(GtUword), file);
  gt_xfwrite(&(nofreads), sizeof (GtUword), (size_t)1, file);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2750be
movq 0x3c6f13(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a0f7c(%rip), %rsi    # 0x516013
leaq 0x3159ce(%rip), %rdx    # 0x58aa6c
leaq 0x30a46d(%rip), %rcx    # 0x57f512
leaq 0x30a482(%rip), %r8     # 0x57f52e
movl $0x2b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2750c0
movq 0x8(%rsp), %rsi
movl $0x1, %edi
callq 0x126b70
movq 0x8(%rsp), %rsi
movl $0x8, %edi
callq 0x126b70
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x275160
movq 0x3c6e71(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a0eda(%rip), %rsi    # 0x516013
leaq 0x30a74c(%rip), %rdx    # 0x57f88c
leaq 0x30a3ff(%rip), %rcx    # 0x57f546
leaq 0x30a3e0(%rip), %r8     # 0x57f52e
movl $0x40, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x275162
cmpq $0x0, 0x18(%rsp)
jne 0x27517a
movq 0x3c6dc7(%rip), %rax    # 0x63bf38
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x2751c8
movq 0x18(%rsp), %rdi
movb 0x17(%rsp), %cl
leaq 0x2f0d3b(%rip), %rsi    # 0x565ec5
leaq 0x2b1a0c(%rip), %rax    # 0x526b9d
testb $0x1, %cl
cmovneq %rax, %rsi
movq 0x8(%rsp), %r8
leaq 0x30a38a(%rip), %rdx    # 0x57f52e
movl $0x45, %ecx
callq 0xd8df0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2751c6
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x27524d
jmp 0x2751c8
jmp 0x2751ca
cmpq $0x0, (%rsp)
jne 0x275209
movq 0x3c6dc8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a0e31(%rip), %rsi    # 0x516013
leaq 0x315883(%rip), %rdx    # 0x58aa6c
leaq 0x30a356(%rip), %rcx    # 0x57f546
leaq 0x30a337(%rip), %r8     # 0x57f52e
movl $0x49, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x27520b
movb 0x17(%rsp), %dl
leaq 0x12a(%rip), %rax       # 0x275340
leaq 0x43(%rip), %rcx        # 0x275260
testb $0x1, %dl
cmovneq %rcx, %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
cmpq $0x0, 0x18(%rsp)
je 0x275245
movq (%rsp), %rdi
callq 0xd9390
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2752b3
movq 0x3c6d1e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a0d87(%rip), %rsi    # 0x516013
leaq 0x3157d9(%rip), %rdx    # 0x58aa6c
leaq 0x30a45e(%rip), %rcx    # 0x57f6f8
leaq 0x30a28d(%rip), %r8     # 0x57f52e
movl $0x34, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2752b5
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x126b70
movq 0x10(%rsp), %rsi
movl $0x8, %edi
callq 0x126b70
movq 0x10(%rsp), %rcx
leaq 0x18(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x27530d
movl $0x1, %eax
movq %rax, (%rsp)
jmp 0x275322
movq 0x18(%rsp), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x8, %esi
callq 0x126d30
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x275393
movq 0x3c6c3e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a0ca7(%rip), %rsi    # 0x516013
leaq 0x3156f9(%rip), %rdx    # 0x58aa6c
leaq 0x30a392(%rip), %rcx    # 0x57f70c
leaq 0x30a1ad(%rip), %r8     # 0x57f52e
movl $0x22, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x275395
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x30a37c(%rip), %rsi    # 0x57f722
movb $0x0, %al
callq 0x199f0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x275420
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x27540e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x2ac69f(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0x199f0
jmp 0x275410
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2753b6
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-cntlist.c
// Function: gt_cntlist_parse_bin
static int gt_cntlist_parse_bin(FILE *infp, bool alloc_cntlist,
    GtBitsequence **cntlist, GtUword *nofreads, GtError *err)
{
  int had_err = gt_cntlist_parse_bin_or_bit_header(infp, nofreads, err);
  if (had_err == 0)
  {
    size_t n;
    GtUword seqnum;
    gt_assert(cntlist != NULL);
    if (alloc_cntlist)
      GT_INITBITTAB(*cntlist, *nofreads);
    while (true)
    {
      n = fread(&seqnum, sizeof (GtUword), (size_t)1, infp);
      if (n != (size_t)1)
      {
        if (!feof(infp))
        {
          gt_error_set(err, "contained reads file: unrecognized format");
          had_err = -1;
        }
        break;
      }
      GT_SETIBIT(*cntlist, seqnum);
    }
  }
  return had_err;
}

// Assembly:
subq $0x58, %rsp
movb %sil, %al
movq %rdi, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x275e60
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x27579f
jmp 0x275646
cmpq $0x0, 0x40(%rsp)
jne 0x275686
movq 0x3c694b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a09b4(%rip), %rsi    # 0x516013
leaq 0x30a226(%rip), %rdx    # 0x57f88c
leaq 0x30a0bf(%rip), %rcx    # 0x57f72c
leaq 0x309eba(%rip), %r8     # 0x57f52e
movl $0x9e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x275688
testb $0x1, 0x4f(%rsp)
je 0x275715
movq 0x38(%rsp), %rax
movq (%rax), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x2756b1
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x2756ca
movq 0x38(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
shlq $0x3, %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0x309e46(%rip), %rdx    # 0x57f52e
movl $0xa0, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x19360
jmp 0x275717
movq 0x50(%rsp), %rcx
leaq 0x18(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x19a70
movq %rax, 0x20(%rsp)
cmpq $0x1, 0x20(%rsp)
je 0x275769
movq 0x50(%rsp), %rdi
callq 0x19b10
cmpl $0x0, %eax
jne 0x275767
movq 0x30(%rsp), %rdi
leaq 0x309fe9(%rip), %rsi    # 0x57f741
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
jmp 0x27579d
movq 0x18(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x275717
jmp 0x27579f
movl 0x2c(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x20(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x275d3c
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x275d2a
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x275d2c
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x275cdc
movq -0x20(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0xde820
testb $0x1, %al
jne 0x275d98
movq 0x3c6228(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
leaq 0x30988b(%rip), %rsi    # 0x57f612
movb $0x0, %al
callq 0x199f0
movl $0x1, %edi
callq 0x19890
callq 0xd88a0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x8(%rsp), %r8
movl $0x1, %esi
leaq 0x10(%rsp), %rcx
callq 0x275430
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x275e02
movq 0x3c61ce(%rip), %rax    # 0x63bfa0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xd8b20
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x309867(%rip), %rsi    # 0x57f658
movb $0x0, %al
callq 0x199f0
movl $0x1, %edi
callq 0x19890
movq 0x8(%rsp), %rdi
callq 0xd8c80
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x275e44
movq 0x3c6181(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x309857(%rip), %rsi    # 0x57f68a
movb $0x0, %al
callq 0x199f0
movl $0x1, %edi
callq 0x19890
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x275cc0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x275e83
cmpq $0x0, 0x20(%rsp)
jne 0x275ebb
movq 0x3c6116(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a017f(%rip), %rsi    # 0x516013
leaq 0x3098d0(%rip), %rdx    # 0x57f76b
leaq 0x3098ea(%rip), %rcx    # 0x57f78c
leaq 0x309685(%rip), %r8     # 0x57f52e
movl $0x57, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x275ebd
jmp 0x275ebf
cmpq $0x0, 0x18(%rsp)
je 0x275f0f
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x275ed7
jmp 0x275f0f
movq 0x3c60c2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2a012b(%rip), %rsi    # 0x516013
leaq 0x2a02d0(%rip), %rdx    # 0x5161bf
leaq 0x309896(%rip), %rcx    # 0x57f78c
leaq 0x309631(%rip), %r8     # 0x57f52e
movl $0x58, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x275f11
movq 0x28(%rsp), %rdi
callq 0x1269f0
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x275f46
movq 0x18(%rsp), %rdi
leaq 0x30987d(%rip), %rsi    # 0x57f7af
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x275fc9
cmpl $0x8, 0x14(%rsp)
je 0x275f71
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
shll $0x3, %edx
leaq 0x30987c(%rip), %rsi    # 0x57f7dc
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x275fc9
jmp 0x275f73
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x19a70
movq %rax, 0x8(%rsp)
cmpq $0x1, 0x8(%rsp)
jne 0x275fa4
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x275fc1
movq 0x18(%rsp), %rdi
leaq 0x309879(%rip), %rsi    # 0x57f829
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x275fc9
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)