LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_enable_aligned_segments_refregionscheck
void gt_hpol_processor_enable_aligned_segments_refregionscheck(
    GtHpolProcessor *hpp, GtAlignedSegmentsPile *asp)
{
  gt_assert(hpp != NULL);
  gt_assert(asp != NULL);
  gt_assert(hpp->asp == NULL);
  hpp->asp = asp;
  gt_aligned_segments_pile_register_process_complete(hpp->asp,
      gt_hpol_processor_refregioncheck, hpp);
  gt_aligned_segments_pile_register_process_skipped(hpp->asp,
      gt_hpol_processor_refregioncheck, hpp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x159d98
testq %rsi, %rsi
je 0x159d9d
movq %rdi, %rbx
cmpq $0x0, 0x68(%rdi)
jne 0x159da2
movq %rsi, 0x68(%rbx)
leaq 0x33(%rip), %r14        # 0x159da7
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x126732
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x126746
callq 0x49457
callq 0x4941e
callq 0x493e5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_enable_segments_hlen_adjustment
void gt_hpol_processor_enable_segments_hlen_adjustment(GtHpolProcessor *hpp,
    GtAlignedSegmentsPile *asp, GtUword read_hmin, GtUword qmax,
    double altmax, double refmin, GtUword mapqmin, GtUword covmin,
    bool allow_partial, bool allow_multiple, GtUword clenmax)
{
  gt_assert(hpp != NULL);
  gt_assert(asp != NULL);
  gt_assert(hpp->asp == NULL);
  hpp->adjust_s_hlen = true;
  hpp->asp = asp;
  hpp->read_hmin = read_hmin;
  hpp->qmax = qmax;
  hpp->altmax = altmax;
  hpp->refmin = refmin;
  hpp->mapqmin = mapqmin;
  hpp->covmin = covmin;
  hpp->allow_partial = allow_partial;
  hpp->allow_multiple = allow_multiple;
  hpp->clenmax = clenmax;
  gt_aligned_segments_pile_register_process_complete(hpp->asp,
      gt_hpol_processor_process_complete_segment, hpp);
  gt_aligned_segments_pile_register_process_skipped(hpp->asp,
      gt_hpol_processor_process_skipped_segment, hpp);
  gt_aligned_segments_pile_register_process_unmapped(hpp->asp,
      gt_hpol_processor_process_unmapped_segment, hpp);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x15a00a
testq %rsi, %rsi
je 0x15a00f
movq %rdi, %rbx
cmpq $0x0, 0x68(%rdi)
jne 0x15a014
movq 0x20(%rsp), %rax
movb 0x18(%rsp), %dil
movb 0x10(%rsp), %r10b
movb $0x1, 0xb8(%rbx)
movq %rsi, 0x68(%rbx)
movq %rdx, 0x18(%rbx)
movq %rcx, 0x30(%rbx)
movsd %xmm0, 0x40(%rbx)
movsd %xmm1, 0x48(%rbx)
movq %r8, 0x20(%rbx)
movq %r9, 0x28(%rbx)
movb %r10b, 0x38(%rbx)
movb %dil, 0x39(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x44(%rip), %rax        # 0x15a019
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x126732
movq 0x68(%rbx), %rdi
leaq 0xdd(%rip), %rsi        # 0x15a0cb
movq %rbx, %rdx
callq 0x126746
movq 0x68(%rbx), %rdi
leaq 0x148(%rip), %rsi       # 0x15a149
movq %rbx, %rdx
popq %rbx
jmp 0x12675a
callq 0x4953b
callq 0x49502
callq 0x494c9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_process_complete_segment
static void gt_hpol_processor_process_complete_segment(
    GtAlignedSegment *as, void *data)
{
  GtHpolProcessorAddToHashResult multihit = GT_HPOL_PROCESSOR_NEW_RECORD;
  GtHpolProcessor *hpp = data;
  gt_assert(hpp != NULL);
  if (hpp->output_segments)
    gt_hpol_processor_output_segment(as, gt_aligned_segment_has_indels(as),
        hpp->outfp_segments, NULL);
  if (hpp->processed_segments != NULL)
    multihit = gt_hpol_processor_add_segment_to_hashmap(hpp, as);
  if (multihit == GT_HPOL_PROCESSOR_NEW_RECORD)
  {
    if (gt_aligned_segment_seq_edited(as))
      (hpp->nof_complete_edited)++;
    else
      (hpp->nof_complete_not_edited)++;
  }
  else if (multihit == GT_HPOL_PROCESSOR_REPLACED)
  {
    gt_assert(gt_aligned_segment_seq_edited(as));
    (hpp->nof_complete_edited)++;
    gt_assert(hpp->nof_complete_not_edited > 0);
    (hpp->nof_complete_not_edited)--;
  }
  else if (multihit == GT_HPOL_PROCESSOR_NOT_REPLACED)
  {
    gt_aligned_segment_delete(as);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x15a0bc
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0xf8(%rsi)
jne 0x15a051
movq %r14, %rdi
callq 0x3046ed
movq 0xc0(%rbx), %rdx
movzbl %al, %esi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x15b2a0
cmpq $0x0, 0xe8(%rbx)
je 0x15a068
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15b3cf
jmp 0x15a06a
xorl %eax, %eax
movq %r14, %rdi
cmpl $0x1, %eax
je 0x15a085
testl %eax, %eax
jne 0x15a0a4
callq 0x3046bf
testb %al, %al
je 0x15a0b0
incq 0x70(%rbx)
jmp 0x15a0b4
callq 0x3046bf
testb %al, %al
je 0x15a0c1
incq 0x70(%rbx)
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x15a0c6
decq %rax
movq %rax, 0x78(%rbx)
jmp 0x15a0b4
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3046fc
incq 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x495e6
callq 0x49574
callq 0x495ad
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_process_skipped_segment
static void gt_hpol_processor_process_skipped_segment(
    GtAlignedSegment *as, void *data)
{
  GtHpolProcessorAddToHashResult multihit = GT_HPOL_PROCESSOR_NEW_RECORD;
  GtHpolProcessor *hpp = data;
  gt_assert(hpp != NULL);
  if (hpp->output_segments)
    gt_hpol_processor_output_segment(as, gt_aligned_segment_has_indels(as),
        hpp->outfp_segments, NULL);
  if (hpp->processed_segments != NULL)
    multihit = gt_hpol_processor_add_segment_to_hashmap(hpp, as);
  gt_assert(multihit != GT_HPOL_PROCESSOR_REPLACED);
  if (multihit == GT_HPOL_PROCESSOR_NEW_RECORD)
    hpp->nof_skipped++;
  else if (multihit == GT_HPOL_PROCESSOR_NOT_REPLACED)
    gt_aligned_segment_delete(as);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x15a13f
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xf8(%rsi)
jne 0x15a0ff
movq %rbx, %rdi
callq 0x3046ed
movq 0xc0(%r14), %rdx
movzbl %al, %esi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x15b2a0
cmpq $0x0, 0xe8(%r14)
je 0x15a116
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15b3cf
jmp 0x15a118
xorl %eax, %eax
testl %eax, %eax
je 0x15a130
cmpl $0x2, %eax
jne 0x15a144
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3046fc
incq 0x80(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x49658
callq 0x4961f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_process_unmapped_segment
static void gt_hpol_processor_process_unmapped_segment(
    GtAlignedSegment *as, void *data)
{
  GT_UNUSED GtHpolProcessorAddToHashResult multihit =
    GT_HPOL_PROCESSOR_NEW_RECORD;
  GtHpolProcessor *hpp = data;
  gt_assert(hpp != NULL);
  if (hpp->output_segments)
    gt_hpol_processor_output_segment(as, false, hpp->outfp_segments, NULL);
  if (hpp->processed_segments != NULL)
    multihit = gt_hpol_processor_add_segment_to_hashmap(hpp, as);
  gt_assert(multihit == GT_HPOL_PROCESSOR_NEW_RECORD);
  hpp->nof_unmapped++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x15a19c
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0xf8(%rsi)
jne 0x15a174
movq 0xc0(%rbx), %rdx
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x15b2a0
cmpq $0x0, 0xe8(%rbx)
je 0x15a18d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15b3cf
testl %eax, %eax
jne 0x15a1a1
incq 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x496ca
callq 0x49691
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_enable_sorted_segments_output
void gt_hpol_processor_enable_sorted_segments_output(GtHpolProcessor *hpp,
    GtUword nfiles, GtSeqIterator **reads_iters, GtFile **outfiles)
{
  gt_assert(hpp != NULL);
  gt_aligned_segments_pile_disable_segment_deletion(hpp->asp);
  hpp->processed_segments = gt_hashmap_new(GT_HASH_STRING, NULL,
      (GtFree)gt_aligned_segment_delete);
  hpp->reads_iters = reads_iters;
  hpp->outfiles = outfiles;
  hpp->nfiles = nfiles;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15a21d
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%rdi), %rdi
callq 0x12676e
leaq 0x1aa513(%rip), %rdx    # 0x3046fc
movl $0x1, %edi
xorl %esi, %esi
callq 0x105830
movq %rax, 0xe8(%r15)
movq %r12, 0xd8(%r15)
movq %rbx, 0xd0(%r15)
movq %r14, 0xe0(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4973c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_delete
void gt_hpol_processor_delete(GtHpolProcessor *hpp)
{
  if (hpp != NULL)
  {
    gt_disc_distri_delete(hpp->hdist);
    gt_disc_distri_delete(hpp->hdist_e);
    gt_hashmap_delete(hpp->processed_segments);
    gt_alphabet_delete(hpp->alpha);
    gt_free(hpp);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x15b29f
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0xe9ff6
movq 0x58(%rbx), %rdi
callq 0xe9ff6
movq 0xe8(%rbx), %rdi
callq 0x105f7d
movq 0xf0(%rbx), %rdi
callq 0xd335d
leaq 0x2316e8(%rip), %rsi    # 0x38c979
movq %rbx, %rdi
movl $0x3e9, %edx            # imm = 0x3E9
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_output_segment
static void gt_hpol_processor_output_segment(GtAlignedSegment *as,
    bool may_be_gapped, GtFile *outfp, const char *desc)
{
  GtUword slen;
  if (may_be_gapped)
    gt_aligned_segment_ungap_seq_and_qual(as);
  slen = (GtUword)strlen(gt_aligned_segment_seq(as));
  gt_assert(slen == (GtUword)strlen(gt_aligned_segment_qual(as)));
  if (gt_aligned_segment_is_reverse(as))
  {
    GtError *err = gt_error_new();
    char *q = gt_aligned_segment_qual(as), tmp;
    GtUword i;
    for (i = 0; i < (slen + 1UL) >> 1; i++)
    {
      tmp = q[i];
      q[i] = q[slen - i - 1UL];
      q[slen - i - 1UL] = tmp;
    }
    gt_assert((GtUword)strlen(gt_aligned_segment_qual(as)) == slen);
    if (gt_reverse_complement(gt_aligned_segment_seq(as), slen, err) != 0)
    {
      fprintf(stderr, "error: %s", gt_error_get(err));
      exit(EXIT_FAILURE);
    }
    gt_error_delete(err);
  }
  gt_fastq_show_entry((desc != NULL) ? desc :
      gt_aligned_segment_description(as), gt_aligned_segment_seq(as),
      gt_aligned_segment_qual(as), slen, 0, false, outfp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
testl %esi, %esi
je 0x15b2c2
movq %r15, %rdi
callq 0x30461c
movq %r15, %rdi
callq 0x304453
movq %rax, %rdi
callq 0x172f0
movq %rax, %r12
movq %r15, %rdi
callq 0x304462
movq %rax, %rdi
callq 0x172f0
cmpq %rax, %r12
jne 0x15b3c0
movq %r15, %rdi
callq 0x3044b2
testb %al, %al
je 0x15b374
callq 0x1019b4
movq %rax, %r13
movq %r15, %rdi
callq 0x304462
leaq 0x1(%r12), %rcx
cmpq $0x2, %rcx
jb 0x15b33d
shrq %rcx
negq %rcx
leaq (%r12,%rax), %rdx
decq %rdx
xorl %esi, %esi
movb (%rax), %dil
movb (%rdx,%rsi), %r8b
movb %r8b, (%rax)
movb %dil, (%rdx,%rsi)
decq %rsi
incq %rax
cmpq %rsi, %rcx
jne 0x15b324
movq %r15, %rdi
callq 0x304462
movq %rax, %rdi
callq 0x172f0
cmpq %r12, %rax
jne 0x15b3c5
movq %r15, %rdi
callq 0x304453
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x177290
movq %r13, %rdi
testl %eax, %eax
jne 0x15b3ca
callq 0x101b35
testq %r14, %r14
jne 0x15b384
movq %r15, %rdi
callq 0x30469f
movq %rax, %r14
movq %r15, %rdi
callq 0x304453
movq %rax, %r13
movq %r15, %rdi
callq 0x304462
movq %rbx, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x103758
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4993d
callq 0x49974
callq 0x499ab
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_add_segment_to_hashmap
static GtHpolProcessorAddToHashResult gt_hpol_processor_add_segment_to_hashmap(
    GtHpolProcessor *hpp, GtAlignedSegment *as)
{
  GtAlignedSegment *stored_as;
  if ((stored_as = gt_hashmap_get(hpp->processed_segments,
          gt_aligned_segment_description(as))) != NULL)
  {
    hpp->nof_multihits++;
    if (!gt_aligned_segment_seq_edited(stored_as) &&
        gt_aligned_segment_seq_edited(as))
    {
      hpp->nof_replaced++;
      /* change with newly edited as */
      gt_hashmap_remove(hpp->processed_segments,
          (void*)gt_aligned_segment_description(as));
      gt_hashmap_add(hpp->processed_segments,
          (void*)gt_aligned_segment_description(as), as);
      return GT_HPOL_PROCESSOR_REPLACED;
    }
    /* otherwise discard (todo: implement combination of edits) */
    else
    {
      return GT_HPOL_PROCESSOR_NOT_REPLACED;
    }
  }
  else
  {
    gt_hashmap_add(hpp->processed_segments,
        (void*)gt_aligned_segment_description(as), as);
    return GT_HPOL_PROCESSOR_NEW_RECORD;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xe8(%rdi), %r15
movq %rsi, %rdi
callq 0x30469f
movq %r15, %rdi
movq %rax, %rsi
callq 0x105a11
testq %rax, %rax
je 0x15b447
incq 0xa8(%r14)
movq %rax, %rdi
callq 0x3046bf
movl $0x2, %ebp
testb %al, %al
jne 0x15b466
movq %rbx, %rdi
callq 0x3046bf
testb %al, %al
je 0x15b466
incq 0xb0(%r14)
movq 0xe8(%r14), %r15
movq %rbx, %rdi
callq 0x30469f
movq %r15, %rdi
movq %rax, %rsi
callq 0x105a8a
movl $0x1, %ebp
jmp 0x15b449
xorl %ebp, %ebp
movq 0xe8(%r14), %r14
movq %rbx, %rdi
callq 0x30469f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x105a4c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_subst_in_range
static void gt_hpol_processor_subst_in_range(char *s, char *q,
    GtUword left, GtUword right, GtUword length, char old,
    char new, char qual)
{
  GtUword pos;
  for (pos = right + 1UL; pos > left && length > 0; /**/)
  {
    pos--;
    if (s[pos] == old)
    {
      s[pos] = new;
      q[pos] = qual;
      length--;
    }
  }
  gt_assert(length == 0);
}

// Assembly:
pushq %rax
leaq 0x1(%rcx), %rax
cmpq %rdx, %rax
setbe %al
testq %r8, %r8
sete %r10b
orb %al, %r10b
jne 0x15b8b4
movb 0x18(%rsp), %al
movb 0x10(%rsp), %r10b
cmpb %r9b, (%rdi,%rcx)
jne 0x15b8a7
movb %r10b, (%rdi,%rcx)
movb %al, (%rsi,%rcx)
decq %r8
cmpq %rdx, %rcx
jbe 0x15b8b4
decq %rcx
testq %r8, %r8
jne 0x15b897
testq %r8, %r8
jne 0x15b8bb
popq %rax
retq
callq 0x49b2d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_tree_set_codes_rec
static void huffman_tree_set_codes_rec(GtHuffmanTree *h_tree)
{
  const char leftbit = 0, rightbit = 1;
  if (h_tree != NULL) {
    if (h_tree->leftchild != NULL) {
        h_tree->leftchild->code.code = h_tree->code.code<< 1 | leftbit;
        h_tree->rightchild->code.code = h_tree->code.code<< 1 | rightbit;
        h_tree->leftchild->code.numofbits =
          h_tree->rightchild->code.numofbits = h_tree->code.numofbits + 1;
        huffman_tree_set_codes_rec(h_tree->leftchild);
        huffman_tree_set_codes_rec(h_tree->rightchild);
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x15bc2d
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x15bc2d
movq (%rbx), %rax
addq %rax, %rax
movq %rax, (%rdi)
movq (%rbx), %rax
movq 0x28(%rbx), %rcx
leaq 0x1(,%rax,2), %rax
movq %rax, (%rcx)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rcx)
movl %eax, 0x8(%rdi)
callq 0x15bbea
movq 0x28(%rbx), %rbx
jmp 0x15bbee
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_iterate
int gt_huffman_iterate(const GtHuffman *huffman,
                       GtHuffmanActFunc action_func,
                       void *action_info)
{
  gt_assert(huffman != NULL);
  gt_assert(action_func != NULL);

  if (huffman->root_huffman_tree != NULL) {
    return visit_huffman_leaves_rec(huffman->root_huffman_tree,
                                    action_info,
                                    action_func);
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15bc53
movq %rsi, %rax
testq %rsi, %rsi
je 0x15bc58
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x15bc4f
movq %rdx, %rsi
movq %rax, %rdx
popq %rax
jmp 0x15bcbc
xorl %eax, %eax
popq %rcx
retq
callq 0x49da0
callq 0x49d67
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_delete
void gt_huffman_delete(GtHuffman *huffman)
{
  if (huffman != NULL) {
    gt_rbtree_delete(huffman->rbt_root);
    gt_free(huffman->code_tab);
  }
  gt_free(huffman);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x15bca7
movq 0x18(%rbx), %rdi
callq 0x16df09
movq 0x20(%rbx), %rdi
leaq 0x231a0d(%rip), %rsi    # 0x38d6aa
movl $0x16f, %edx            # imm = 0x16F
callq 0x109670
leaq 0x2319fc(%rip), %rsi    # 0x38d6aa
movq %rbx, %rdi
movl $0x171, %edx            # imm = 0x171
popq %rbx
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: visit_huffman_leaves_rec
static int visit_huffman_leaves_rec(GtHuffmanTree *h_tree,
                                    void *actinfo,
                                    GtHuffmanActFunc actfun)
{
  int had_err = 0;

  if (h_tree->leftchild == NULL) {
      had_err = huffman_leaf_call_actfunc(h_tree,
                                          actinfo,
                                          actfun);
  } else {
    had_err =  visit_huffman_leaves_rec(h_tree->leftchild,
                                        actinfo,
                                        actfun);
    if (!had_err) {
      had_err =  visit_huffman_leaves_rec(h_tree->rightchild,
                                          actinfo,
                                          actfun);
    }
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x15bce8
movq %rbx, %rsi
movq %r15, %rdx
callq 0x15bcbc
testl %eax, %eax
jne 0x15bd04
movq 0x28(%r14), %r14
jmp 0x15bcca
movq 0x18(%r14), %rdi
movq 0x10(%r14), %rsi
movq (%r14), %rdx
movl 0x8(%r14), %ecx
movq %rbx, %r8
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_size
void gt_huffman_size(const GtHuffman *huffman, uint64_t *bits,
                     uint64_t *chars)
{
  gt_assert(huffman != NULL);
  if (bits != NULL)
    *bits = huffman->num_of_text_bits;
  if (chars != NULL)
    *chars = huffman->num_of_text_symbols;
}

// Assembly:
testq %rdi, %rdi
je 0x15bd27
testq %rsi, %rsi
je 0x15bd1a
movq (%rdi), %rax
movq %rax, (%rsi)
testq %rdx, %rdx
je 0x15bd26
movq 0x8(%rdi), %rax
movq %rax, (%rdx)
retq
pushq %rax
callq 0x49dd9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: print_codes
static int print_codes(GtUword symbol,
                       GtUint64 freq,
                       const GtBitsequence code,
                       unsigned int code_len,
                       GT_UNUSED void *unused)
{
#ifndef S_SPLINT_S /* for GT_LLU which splint does not know */
  printf("control symbol " GT_WU ", freq "GT_LLU ", codelength %u: ",
         symbol,
         freq,
         code_len);
#else
  printf("control symbol " GT_WU ", freq " GT_WU ", codelength %u: ",
         symbol,
         (GtUword) freq,
         code_len);
#endif /* S_SPLINT_S */
  print_huff_code(code_len, code);

  printf("\n");
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x231e9d(%rip), %rdi    # 0x38dc03
xorl %eax, %eax
callq 0x17070
testl %ebp, %ebp
je 0x15bda2
decb %bpl
movl $0x1, %r14d
movl %ebp, %ecx
shll %cl, %r14d
movl %r14d, %ebp
movl %r14d, %eax
andl %ebx, %eax
cmpl $0x1, %eax
movl $0x31, %edi
sbbl $0x0, %edi
callq 0x17a20
shrl %ebp
cmpl $0x1, %r14d
movl %ebp, %r14d
ja 0x15bd82
movl $0xa, %edi
callq 0x17a20
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_encode
void gt_huffman_encode(const GtHuffman *huffman,
                       GtUword symbol,
                       GtBitsequence *code,
                       unsigned int *codelength)
{
  gt_assert(huffman != NULL);
  gt_assert(symbol < huffman->num_of_symbols);
  *code = huffman->code_tab[symbol].code;
  *codelength = huffman->code_tab[symbol].numofbits;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15bdd6
cmpq %rsi, 0x30(%rdi)
jbe 0x15bddb
movq 0x20(%rdi), %rax
shlq $0x4, %rsi
movq (%rax,%rsi), %rdi
movq %rdi, (%rdx)
movl 0x8(%rax,%rsi), %eax
movl %eax, (%rcx)
popq %rax
retq
callq 0x49e84
callq 0x49e4b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_decoder_new
GtHuffmanDecoder *gt_huffman_decoder_new(GtHuffman *huffman,
                                         GtBitsequence *bitsequence,
                                         GtUword length,
                                         GtUword bit_offset,
                                         GtUword pad_length)
{
  GtHuffmanDecoder *huff_decoder = gt_malloc(sizeof (*huff_decoder));

  gt_assert(huffman != NULL);

  huff_decoder->huffman = huffman;
  huff_decoder->cur_node = huff_decoder->huffman->root_huffman_tree;
  huff_decoder->bitsequence = bitsequence;
  huff_decoder->cur_bit = bit_offset;
  huff_decoder->pad_length = pad_length;
  huff_decoder->length = length;
  huff_decoder->mem_func = NULL;
  huff_decoder->info = NULL;
  huff_decoder->cur_bitseq = 0;
  huff_decoder->mem_func_stat = 0;
  return huff_decoder;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq 0x23188b(%rip), %rsi    # 0x38d6aa
movl $0x50, %edi
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x1092b2
testq %r13, %r13
je 0x15be6e
movq %r13, 0x8(%rax)
movq 0x10(%r13), %rcx
movq %rcx, 0x18(%rax)
movq %r12, (%rax)
movq %r15, 0x30(%rax)
movq %rbx, 0x38(%rax)
movq %r14, 0x40(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x49f2f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_decoder_new_from_memory
GtHuffmanDecoder *gt_huffman_decoder_new_from_memory(
                                     GtHuffman *huffman,
                                     GtHuffmanDecoderGetMemFunc mem_func,
                                     void *info,
                                     GtError *err)
{
  GtHuffmanDecoder *huff_decoder = gt_malloc(sizeof (*huff_decoder));

  gt_assert(huffman != NULL);

  huff_decoder->huffman = huffman;
  huff_decoder->cur_node = huff_decoder->huffman->root_huffman_tree;
  huff_decoder->mem_func = mem_func;
  huff_decoder->info = info;
  huff_decoder->cur_bitseq = 0;
  huff_decoder->mem_func_stat =
    huff_decoder->mem_func(&huff_decoder->bitsequence,
                           &huff_decoder->length,
                           &huff_decoder->cur_bit,
                           &huff_decoder->pad_length,
                           huff_decoder->info);
  if (huff_decoder->mem_func_stat == -1) {
    gt_error_set(err, "error calling mem_func");
    return NULL;
  }
  gt_assert(huff_decoder->mem_func_stat == 1);
  return huff_decoder;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
leaq 0x23181b(%rip), %rsi    # 0x38d6aa
movl $0x50, %edi
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x1092b2
testq %r13, %r13
je 0x15bf09
movq %rax, %r14
movq %r13, 0x8(%rax)
movq 0x10(%r13), %rax
movq %rax, 0x18(%r14)
movq %r15, 0x10(%r14)
movq %r12, 0x20(%r14)
movq $0x0, 0x28(%r14)
leaq 0x40(%r14), %rsi
leaq 0x30(%r14), %rdx
movq %r14, %rcx
addq $0x38, %rcx
movq %r14, %rdi
movq %r12, %r8
callq *%r15
movl %eax, 0x48(%r14)
cmpl $0x1, %eax
je 0x15befc
cmpl $-0x1, %eax
jne 0x15bf0e
leaq 0x2318d6(%rip), %rsi    # 0x38d7c5
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x49fa1
callq 0x49f68
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_decoder_get_new_mem_chunk
int gt_huffman_decoder_get_new_mem_chunk(GtHuffmanDecoder *huff_decoder,
                                         GtError *err)
{
  int had_err = 0;
  gt_assert(huff_decoder != NULL);
  gt_assert(huff_decoder->mem_func != NULL);

  huff_decoder->mem_func_stat =
    huff_decoder->mem_func(&huff_decoder->bitsequence,
                           &huff_decoder->length,
                           &huff_decoder->cur_bit,
                           &huff_decoder->pad_length,
                           huff_decoder->info);
  if (huff_decoder->mem_func_stat == -1) {
    gt_error_set(err, "GtHuffmanDecoder error: error calling callback "
                      "function to get new memory chunk!");
    return huff_decoder->mem_func_stat;
  }
  huff_decoder->cur_bitseq = 0;
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15bf70
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x15bf75
movq %rsi, %r14
leaq 0x40(%rbx), %rsi
leaq 0x30(%rbx), %rdx
leaq 0x38(%rbx), %rcx
movq 0x20(%rbx), %r8
movq %rbx, %rdi
callq *%rax
movl %eax, 0x48(%rbx)
cmpl $-0x1, %eax
je 0x15bf54
movq $0x0, 0x28(%rbx)
xorl %eax, %eax
jmp 0x15bf68
leaq 0x2318fb(%rip), %rsi    # 0x38d856
movq %r14, %rdi
xorl %eax, %eax
callq 0x1019cf
movl 0x48(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4a013
callq 0x49fda
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_bitwise_decoder_new
GtHuffmanBitwiseDecoder *gt_huffman_bitwise_decoder_new(GtHuffman *huffman,
                                                        GT_UNUSED GtError *err)
{
  GtHuffmanBitwiseDecoder *hbwd;
  gt_assert(huffman != NULL);
  hbwd = gt_calloc((size_t) 1, sizeof (*hbwd));
  hbwd->huffman = huffman;
  hbwd->cur_node = huffman->root_huffman_tree;
  return hbwd;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x15c27a
movq %rdi, %rbx
leaq 0x231451(%rip), %rdx    # 0x38d6aa
movl $0x1, %edi
movl $0x10, %esi
movl $0x25e, %ecx            # imm = 0x25E
callq 0x1093ef
movq %rbx, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
popq %rbx
retq
callq 0x4a118
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_bitwise_decoder_next
int gt_huffman_bitwise_decoder_next(GtHuffmanBitwiseDecoder *hbwd,
                                    bool bit, GtUword *symbol,
                                    GT_UNUSED GtError *err)
{
  int status = 0;
  gt_assert(hbwd != NULL);

  gt_assert(hbwd->cur_node != NULL);
  if (hbwd->cur_node->leftchild == NULL) {
    *symbol = hbwd->cur_node->symbol.symbol;
    hbwd->cur_node = hbwd->huffman->root_huffman_tree;
  }
  else {
    if (bit)
      hbwd->cur_node = hbwd->cur_node->rightchild;
    else
      hbwd->cur_node = hbwd->cur_node->leftchild;

    if (hbwd->cur_node->leftchild == NULL) {
      *symbol = hbwd->cur_node->symbol.symbol;
      hbwd->cur_node = hbwd->huffman->root_huffman_tree;
    }
    else
      status = 1;
  }
  return status;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15c2c9
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x15c2ce
movq 0x20(%rcx), %r8
testq %r8, %r8
je 0x15c2b3
testb %sil, %sil
je 0x15c2a0
movq 0x28(%rcx), %r8
movq %r8, 0x8(%rdi)
movl $0x1, %eax
cmpq $0x0, 0x20(%r8)
movq %r8, %rcx
jne 0x15c2c7
movq 0x18(%rcx), %rax
movq %rax, (%rdx)
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
popq %rcx
retq
callq 0x4a18a
callq 0x4a151
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_unit_get_next_block
static int huffman_unit_get_next_block(GtBitsequence **bits,
                                       GtUword *length,
                                       GtUword *offset,
                                       GtUword *pad_length,
                                       void *meminfo)
{
  HuffmanUnitTestMeminfo *info = (HuffmanUnitTestMeminfo*) meminfo;
  if (info->chunk == info->chunks)
    return 0;
  *offset = 0;
  if (info->chunk == info->chunks - 1) {
    *bits = info->data + (info->chunk * info->size);
    *length = info->lastchunk_size;
    *pad_length = info->padding;
  }
  else {
    *bits = info->data + (info->chunk * info->size);
    *length = info->size;
    *pad_length = 0;
  }
  info->chunk++;
  return 1;
}

// Assembly:
movq 0x8(%r8), %r9
xorl %eax, %eax
cmpq 0x10(%r8), %r9
je 0x15cf30
movq $0x0, (%rdx)
movq 0x8(%r8), %rdx
movq 0x10(%r8), %r9
decq %r9
movq 0x18(%r8), %rax
movq %rax, %r10
imulq %rdx, %r10
shlq $0x3, %r10
addq (%r8), %r10
movq %r10, (%rdi)
cmpq %r9, %rdx
jne 0x15cf1f
movq 0x20(%r8), %rax
movq %rax, (%rsi)
movq 0x28(%r8), %rax
jmp 0x15cf24
movq %rax, (%rsi)
xorl %eax, %eax
movq %rax, (%rcx)
incq 0x8(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_tree_cmp
static int huffman_tree_cmp(const void *tree1, const void *tree2,
                            GT_UNUSED void *unused)
{
  GtHuffmanTree *h1 = (GtHuffmanTree*) tree1,
                *h2 = (GtHuffmanTree*) tree2;

  gt_assert(h1 && h2);

  if (h1->symbol.freq < h2->symbol.freq)
     return (int) -1;
  if (h1->symbol.freq > h2->symbol.freq)
    return (int) 1;
  if (h1->symbol.symbol < h2->symbol.symbol)
    return (int) -1;
  if (h1->symbol.symbol > h2->symbol.symbol)
    return (int) 1;

  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x15d875
testq %rsi, %rsi
je 0x15d875
movq 0x10(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, 0x10(%rdi)
jb 0x15d874
movl $0x1, %eax
ja 0x15d874
movq 0x18(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, 0x18(%rdi)
jb 0x15d874
seta %al
movzbl %al, %eax
retq
pushq %rax
callq 0x4a1c3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_tree_delete
static void huffman_tree_delete(void *tree)
{
  if (tree != NULL) {
    GtHuffmanTree *h_tree = (GtHuffmanTree*) tree;
    if (h_tree->reference_count > 0) {
      h_tree->reference_count--;
    }
    else {
      if (h_tree->leftchild != NULL)
        huffman_tree_delete(h_tree->leftchild);
      if (h_tree->rightchild != NULL)
        huffman_tree_delete(h_tree->rightchild);
      gt_free(h_tree);
    }
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x15d890
movq %rdi, %rbx
movl 0x30(%rdi), %eax
testl %eax, %eax
je 0x15d892
decl %eax
movl %eax, 0x30(%rbx)
popq %rbx
retq
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x15d8a0
callq 0x15d87b
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x15d8ae
callq 0x15d87b
leaq 0x22fdf5(%rip), %rsi    # 0x38d6aa
movq %rbx, %rdi
movl $0x71, %edx
popq %rbx
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/id_to_md5_stream.c
// Function: gt_id_to_md5_stream_new
GtNodeStream* gt_id_to_md5_stream_new(GtNodeStream *in_stream,
                                      GtRegionMapping *rm,
                                      bool substitute_target_ids)
{
  gt_assert(in_stream && rm);
  return gt_visitor_stream_new(in_stream,
                               gt_id_to_md5_visitor_new(rm,
                                                        substitute_target_ids));
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x15d8ff
testq %rsi, %rsi
je 0x15d8ff
movq %rdi, %rbx
movzbl %dl, %eax
movq %rsi, %rdi
movl %eax, %esi
callq 0x15da1a
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x18c917
callq 0x4a233
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: gt_id_to_md5_visitor_class
const GtNodeVisitorClass* gt_id_to_md5_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSeqidsToMD5Visitor),
                                    id_to_md5_visitor_free,
                                    NULL,
                                    id_to_md5_visitor_feature_node,
                                    id_to_md5_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x36be66(%rip)    # 0x4c9778
jne 0x15d947
movq $0x0, (%rsp)
leaq 0x32(%rip), %rsi        # 0x15d955
leaq 0x53(%rip), %rcx        # 0x15d97d
leaq 0x9c(%rip), %r8         # 0x15d9cd
movl $0x20, %edi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x36be31(%rip)    # 0x4c9778
callq 0xe6a19
movq 0x36be25(%rip), %rax    # 0x4c9778
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: id_to_md5_visitor_free
static void id_to_md5_visitor_free(GtNodeVisitor *nv)
{
  GtSeqidsToMD5Visitor *id_to_md5_visitor =
    id_to_md5_visitor_cast(nv);
  gt_assert(id_to_md5_visitor);
  gt_region_mapping_delete(id_to_md5_visitor->region_mapping);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x15d904
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
testq %rax, %rax
je 0x15d978
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x1758da
callq 0x4a26a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: id_to_md5_visitor_feature_node
static int id_to_md5_visitor_feature_node(GtNodeVisitor *nv,
                                              GtFeatureNode *fn,
                                              GtError *err)
{
  GtSeqidsToMD5Visitor *v = id_to_md5_visitor_cast(nv);
  gt_error_check(err);
  return seqid_to_md5((GtGenomeNode*) fn, v->region_mapping,
                      v->substitute_target_ids, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x15d904
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %rax, %r15
testq %rbx, %rbx
je 0x15d9af
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x15d9c8
movq 0x10(%r15), %rsi
movzbl 0x18(%r15), %edx
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x15da54
callq 0x4a2a1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: id_to_md5_visitor_region_node
static int id_to_md5_visitor_region_node(GtNodeVisitor *nv,
                                             GtRegionNode *rn,
                                             GtError *err)
{
  GtSeqidsToMD5Visitor *v = id_to_md5_visitor_cast(nv);
  gt_error_check(err);
  return seqid_to_md5((GtGenomeNode*) rn, v->region_mapping,
                      v->substitute_target_ids, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x15d904
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %rax, %r15
testq %rbx, %rbx
je 0x15d9ff
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x15da15
movq 0x10(%r15), %rsi
movzbl 0x18(%r15), %edx
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x15da54
callq 0x4a2da
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/id_to_md5_visitor.c
// Function: gt_id_to_md5_visitor_new
GtNodeVisitor* gt_id_to_md5_visitor_new(GtRegionMapping *region_mapping,
                                        bool substitute_target_ids)
{
  GtNodeVisitor *nv;
  GtSeqidsToMD5Visitor *id_to_md5_visitor;
  nv = gt_node_visitor_create(gt_id_to_md5_visitor_class());
  id_to_md5_visitor = id_to_md5_visitor_cast(nv);
  id_to_md5_visitor->region_mapping = region_mapping;
  id_to_md5_visitor->substitute_target_ids = substitute_target_ids;
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x15d904
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r15
callq 0x15d904
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %r14, 0x10(%rax)
movb %bl, 0x18(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/inter_feature_visitor.c
// Function: gt_inter_feature_visitor_class
const GtNodeVisitorClass* gt_inter_feature_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtInterFeatureVisitor),
                                    inter_feature_visitor_free,
                                    NULL,
                                    inter_feature_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x36b8d2(%rip)    # 0x4c9780
jne 0x15dedf
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x15deed
leaq 0x71(%rip), %rcx        # 0x15df37
movl $0x30, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x36b8a1(%rip)    # 0x4c9780
callq 0xe6a19
movq 0x36b895(%rip), %rax    # 0x4c9780
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/inter_feature_visitor.c
// Function: inter_feature_visitor_feature_node
static int inter_feature_visitor_feature_node(GtNodeVisitor *nv,
                                              GtFeatureNode *fn, GtError *err)
{
  GtInterFeatureVisitor *v;
  gt_error_check(err);
  int had_err = 0;
  v = gt_inter_feature_visitor_cast(nv);
  /* gt_feature_node_traverse_children() ignores pseudo-nodes, therefore we have
     to process the direct children of a pseudo-node separately. */
  if (gt_feature_node_is_pseudo(fn)) {
    v->parent_feature = fn;
    v->previous_feature = NULL;
    had_err = gt_feature_node_traverse_direct_children(fn, v,
                                                      inter_feature_in_children,
                                                       err);
  }
  if (!had_err) {
    had_err = gt_feature_node_traverse_children(fn, v,
                                                inter_feature_if_necessary,
                                                false, err);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x15df56
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x15dfc0
callq 0x15dea0
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %rax, %r15
movq %r14, %rdi
callq 0x149d95
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x15df9a
movq %r14, 0x20(%r15)
movq $0x0, 0x28(%r15)
leaq 0xa2(%rip), %rdx        # 0x15e02e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x14aaf6
testl %eax, %eax
je 0x15dfa4
popq %rbx
popq %r14
popq %r15
retq
leaq 0x23b(%rip), %rdx       # 0x15e1e6
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x149fca
callq 0x4a4d1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/inter_feature_visitor.c
// Function: gt_inter_feature_visitor_new
GtNodeVisitor* gt_inter_feature_visitor_new(const char *outside_type,
                                            const char *inter_type)
{
  GtInterFeatureVisitor *aiv;
  GtNodeVisitor *nv;
  gt_assert(outside_type && inter_type);
  nv = gt_node_visitor_create(gt_inter_feature_visitor_class());
  aiv = gt_inter_feature_visitor_cast(nv);
  aiv->outside_type = gt_cstr_dup(outside_type);
  aiv->inter_type = gt_cstr_dup(inter_type);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15e029
movq %rsi, %rbx
testq %rsi, %rsi
je 0x15e029
movq %rdi, %r14
callq 0x15dea0
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r15
callq 0x15dea0
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %rax, %r12
movq %r14, %rdi
callq 0xe8760
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0xe8760
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4a50a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/inter_feature_visitor.c
// Function: inter_feature_if_necessary
static int inter_feature_if_necessary(GtFeatureNode *fn, void *data,
                                      GtError *err)
{
  GtInterFeatureVisitor *aiv = (GtInterFeatureVisitor*) data;
  gt_error_check(err);
  gt_assert(fn);
  aiv->parent_feature = fn;
  aiv->previous_feature = NULL;
  return gt_feature_node_traverse_direct_children(fn, aiv,
                                                  inter_feature_in_children,
                                                  err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x15e205
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x15e235
testq %r15, %r15
je 0x15e230
movq %r15, 0x20(%r14)
movq $0x0, 0x28(%r14)
leaq -0x1ef(%rip), %rdx      # 0x15e02e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x14aaf6
callq 0x4a656
callq 0x4a61f
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_create
GtIntset *gt_intset_create(const GtIntsetClass *intset_c)
{
  GtIntset *intset;
  gt_assert(intset_c && intset_c->size);
  intset = gt_calloc((size_t) 1, intset_c->size);
  intset->c_class = intset_c;
  intset->members = gt_calloc((size_t) 1, sizeof (GtIntsetMembers));
  return intset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15e294
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x15e294
leaq 0x22fe25(%rip), %r14    # 0x38e07d
movl $0x1, %edi
movq %r14, %rdx
movl $0x1e, %ecx
callq 0x1093ef
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x48, %esi
movq %r14, %rdx
movl $0x20, %ecx
callq 0x1093ef
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x4a68d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_add
void gt_intset_add(GtIntset *intset, GtUword elem)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->add_func != NULL)
    intset->c_class->add_func(intset, elem);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15e2e5
movq (%rdi), %rax
testq %rax, %rax
je 0x15e2ea
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x15e2e3
popq %rcx
jmpq *%rax
popq %rax
retq
callq 0x4a769
callq 0x4a732
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_get
GtUword gt_intset_get(GtIntset *intset, GtUword idx)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->get_func != NULL)
    return intset->c_class->get_func(intset, idx);
  return intset->members->num_of_elems;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15e313
movq (%rdi), %rax
testq %rax, %rax
je 0x15e318
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x15e309
popq %rcx
jmpq *%rax
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rax
popq %rcx
retq
callq 0x4a7d7
callq 0x4a7a0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size
GtUword gt_intset_size(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->size_func != NULL)
    return intset->c_class->size_func(intset);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15e33b
movq (%rdi), %rax
testq %rax, %rax
je 0x15e340
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x15e337
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
callq 0x4a845
callq 0x4a80e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_is_member
bool gt_intset_is_member(GtIntset *intset, GtUword elem)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->is_member_func != NULL)
    return intset->c_class->is_member_func(intset, elem);
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15e363
movq (%rdi), %rax
testq %rax, %rax
je 0x15e368
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x15e35f
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
callq 0x4a8b3
callq 0x4a87c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_get_idx_smallest_geq
GtUword gt_intset_get_idx_smallest_geq(GtIntset *intset, GtUword pos)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->idx_sm_geq_func != NULL)
    return intset->c_class->idx_sm_geq_func(intset, pos);
  return GT_UWORD_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15e390
movq (%rdi), %rax
testq %rax, %rax
je 0x15e395
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x15e387
popq %rcx
jmpq *%rax
movq $-0x1, %rax
popq %rcx
retq
callq 0x4a921
callq 0x4a8ea
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_write
GtIntset *gt_intset_write(GtIntset *intset, FILE *fp, GtError *err)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->size_func != NULL)
    return intset->c_class->write_func(intset, fp, err);
  return intset;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15e3bb
movq (%rdi), %rax
testq %rax, %rax
je 0x15e3c0
cmpq $0x0, 0x40(%rax)
je 0x15e3b6
movq 0x50(%rax), %rax
popq %rcx
jmpq *%rax
movq %rdi, %rax
popq %rcx
retq
callq 0x4a98f
callq 0x4a958
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size_of_rep
size_t gt_intset_size_of_rep(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->rep_size_func != NULL)
    return intset->c_class->rep_size_func(intset->members->maxelement,
                                          intset->members->num_of_elems);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15e3ef
movq (%rdi), %rax
testq %rax, %rax
je 0x15e3f4
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x15e3eb
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
movq 0x28(%rcx), %rsi
popq %rcx
jmpq *%rax
xorl %eax, %eax
popq %rcx
retq
callq 0x4a9fd
callq 0x4a9c6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_size_of_struct
size_t gt_intset_size_of_struct(GtIntset *intset)
{
  gt_assert(intset != NULL);
  gt_assert(intset->c_class != NULL);
  if (intset->c_class->rep_size_func != NULL)
    return intset->c_class->struct_size_func();
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15e416
movq (%rdi), %rax
testq %rax, %rax
je 0x15e41b
cmpq $0x0, 0x38(%rax)
je 0x15e412
popq %rcx
jmpq *0x48(%rax)
xorl %eax, %eax
popq %rcx
retq
callq 0x4aa6b
callq 0x4aa34
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset.c
// Function: gt_intset_delete
void gt_intset_delete(GtIntset *intset)
{
  if (intset != NULL) {
    if (intset->members->refcount) {
      intset->members->refcount--;
      return;
    }
    gt_assert(intset->c_class);
    if (intset->c_class->delete_func != NULL)
      intset->c_class->delete_func(intset);
    gt_free(intset->members->sectionstart);
    gt_free(intset->members);
    gt_free(intset);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15e4a8
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x15e4b0
decq %rcx
movq %rcx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x15e509
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x15e4c6
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rax
movq (%rax), %rdi
leaq 0x22fba9(%rip), %r14    # 0x38e07d
movq %r14, %rsi
movl $0xa3, %edx
callq 0x109670
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0xa4, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa5, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
callq 0x4aaa2