LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xee81d
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0xf8(%rsi)
jne 0xee7ac
movq %r14, %rdi
callq 0x296a89
movq 0xc0(%rbx), %rdx
movzbl %al, %esi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xefcc3
cmpq $0x0, 0xe8(%rbx)
je 0xee7ca
movq %rbx, %rdi
movq %r14, %rsi
callq 0xefe72
cmpl $0x1, %eax
je 0xee7e2
testl %eax, %eax
jne 0xee80e
movq %r14, %rdi
callq 0x2969c2
testb %al, %al
je 0xee7dc
incq 0x70(%rbx)
jmp 0xee806
incq 0x78(%rbx)
jmp 0xee806
movq %r14, %rdi
callq 0x2969c2
testb %al, %al
je 0xee855
incq 0x70(%rbx)
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0xee883
decq %rax
movq %rax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x296acb
movq 0x349744(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f67e5(%rip), %rsi    # 0x2e5013
leaq 0x2351c9(%rip), %rdx    # 0x3239fe
leaq 0x2353a2(%rip), %rcx    # 0x323bde
leaq 0x23517e(%rip), %r8     # 0x3239c1
movl $0xb6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x34970c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f67ad(%rip), %rsi    # 0x2e5013
leaq 0x23539c(%rip), %rdx    # 0x323c09
leaq 0x23536a(%rip), %rcx    # 0x323bde
leaq 0x235146(%rip), %r8     # 0x3239c1
movl $0xc5, %r9d
jmp 0xee849
movq 0x3496de(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f677f(%rip), %rsi    # 0x2e5013
leaq 0x235390(%rip), %rdx    # 0x323c2b
leaq 0x23533c(%rip), %rcx    # 0x323bde
leaq 0x235118(%rip), %r8     # 0x3239c1
movl $0xc7, %r9d
jmp 0xee849
// File: /workspace/github_c_makefile_star2_O2/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 0xee921
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xf8(%rsi)
jne 0xee8e5
movq %rbx, %rdi
callq 0x296a89
movq 0xc0(%r14), %rdx
movzbl %al, %esi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xefcc3
cmpq $0x0, 0xe8(%r14)
je 0xee912
movq %r14, %rdi
movq %rbx, %rsi
callq 0xefe72
testl %eax, %eax
je 0xee912
cmpl $0x2, %eax
jne 0xee94f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x296acb
incq 0x80(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x349640(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f66e1(%rip), %rsi    # 0x2e5013
leaq 0x2350c5(%rip), %rdx    # 0x3239fe
leaq 0x235397(%rip), %rcx    # 0x323cd7
leaq 0x23507a(%rip), %r8     # 0x3239c1
movl $0xd5, %r9d
jmp 0xee97b
movq 0x349612(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f66b3(%rip), %rsi    # 0x2e5013
leaq 0x23539a(%rip), %rdx    # 0x323d01
leaq 0x235369(%rip), %rcx    # 0x323cd7
leaq 0x23504c(%rip), %r8     # 0x3239c1
movl $0xdb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xee9da
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0xf8(%rsi)
jne 0xee9b2
movq 0xc0(%rbx), %rdx
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0xefcc3
cmpq $0x0, 0xe8(%rbx)
je 0xee9cb
movq %rbx, %rdi
movq %r14, %rsi
callq 0xefe72
testl %eax, %eax
jne 0xeea08
incq 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x349587(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f6628(%rip), %rsi    # 0x2e5013
leaq 0x23500c(%rip), %rdx    # 0x3239fe
leaq 0x23532f(%rip), %rcx    # 0x323d28
leaq 0x234fc1(%rip), %r8     # 0x3239c1
movl $0xe8, %r9d
jmp 0xeea34
movq 0x349559(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f65fa(%rip), %rsi    # 0x2e5013
leaq 0x235333(%rip), %rdx    # 0x323d53
leaq 0x235301(%rip), %rcx    # 0x323d28
leaq 0x234f93(%rip), %r8     # 0x3239c1
movl $0xed, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xeeae8
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%rdi), %rdi
callq 0xb48dd
leaq 0x1a8015(%rip), %rdx    # 0x296acb
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x8f330
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
movq 0x349479(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f651a(%rip), %rsi    # 0x2e5013
leaq 0x234efe(%rip), %rdx    # 0x3239fe
leaq 0x234fe7(%rip), %rcx    # 0x323aee
leaq 0x234eb3(%rip), %r8     # 0x3239c1
movl $0x156, %r9d            # imm = 0x156
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xefcc2
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0x6e064
movq 0x58(%rbx), %rdi
callq 0x6e064
movq 0xe8(%rbx), %rdi
callq 0x8f933
movq 0xf0(%rbx), %rdi
callq 0x568b5
leaq 0x233d0d(%rip), %rsi    # 0x3239c1
movq %rbx, %rdi
movl $0x3e9, %edx            # imm = 0x3E9
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x29693c
movq %r15, %rdi
movq %rax, %rsi
callq 0x8f482
testq %rax, %rax
je 0xefee6
incq 0xa8(%r14)
movq %rax, %rdi
callq 0x2969c2
pushq $0x2
popq %rbp
testb %al, %al
jne 0xeff05
movq %rbx, %rdi
callq 0x2969c2
testb %al, %al
je 0xeff05
incq 0xb0(%r14)
movq 0xe8(%r14), %r15
movq %rbx, %rdi
callq 0x29693c
movq %r15, %rdi
movq %rax, %rsi
callq 0x8f4fb
pushq $0x1
popq %rbp
jmp 0xefee8
xorl %ebp, %ebp
movq 0xe8(%r14), %r14
movq %rbx, %rdi
callq 0x29693c
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x8f4bd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_determine_hlen_forwards
static GtUword gt_hpol_processor_determine_hlen_forwards(char *s, char *q,
    GtUword pos, GtUword maxpos, char c, GtUword *q_sum,
    GtUword *gaps)
{
  GtUword s_hlen = 0;
  while (pos <= maxpos)
  {
    if (s[pos] == c)
    {
      s_hlen++;
      if (q_sum != NULL)
        *q_sum += q[pos];
    }
    else if (s[pos] == '-')
    {
      if (gaps != NULL)
        (*gaps)++;
    }
    else
      break;
    pos++;
  }
  return s_hlen;
}

// Assembly:
pushq %r14
pushq %rbx
movq 0x18(%rsp), %r10
xorl %eax, %eax
movabsq $0x1, %r11
cmpq %rcx, %rdx
ja 0xeff5d
movb (%rdi,%rdx), %bl
cmpb %r8b, %bl
jne 0xeff45
incq %rax
testq %r9, %r9
je 0xeff58
movsbq (%rsi,%rdx), %r14
movq %r9, %rbx
jmp 0xeff55
cmpb $0x2d, %bl
jne 0xeff5d
movq %r10, %rbx
movq %r11, %r14
testq %r10, %r10
je 0xeff58
addq %r14, (%rbx)
incq %rdx
jmp 0xeff26
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movb 0x18(%rsp), %al
movb 0x10(%rsp), %r10b
incq %rcx
movq %rcx, %r11
cmpq %rdx, %r11
jbe 0xf0474
testq %r8, %r8
je 0xf0474
leaq -0x1(%r11), %rcx
cmpb %r9b, -0x1(%rdi,%r11)
movq %rcx, %r11
jne 0xf0450
movb %r10b, (%rdi,%rcx)
movb %al, (%rsi,%rcx)
decq %r8
jmp 0xf044d
testq %r8, %r8
jne 0xf047b
popq %rax
retq
movq 0x347ae6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f4b87(%rip), %rsi    # 0x2e5013
leaq 0x26aa85(%rip), %rdx    # 0x35af18
leaq 0x233f76(%rip), %rcx    # 0x324410
leaq 0x233520(%rip), %r8     # 0x3239c1
movl $0x258, %r9d            # imm = 0x258
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xf094a
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xf094a
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 0xf0907
movq 0x28(%rbx), %rbx
jmp 0xf090b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf0973
movq %rsi, %rax
testq %rsi, %rsi
je 0xf09a1
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xf096f
movq %rdx, %rsi
movq %rax, %rdx
popq %rax
jmp 0xf0a38
xorl %eax, %eax
popq %rcx
retq
movq 0x3475ee(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f468f(%rip), %rsi    # 0x2e5013
leaq 0x22c0f2(%rip), %rdx    # 0x31ca7d
leaq 0x233d8b(%rip), %rcx    # 0x32471d
leaq 0x233d59(%rip), %r8     # 0x3246f2
movl $0x178, %r9d            # imm = 0x178
jmp 0xf09cd
movq 0x3475c0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f4661(%rip), %rsi    # 0x2e5013
leaq 0x233d77(%rip), %rdx    # 0x324730
leaq 0x233d5d(%rip), %rcx    # 0x32471d
leaq 0x233d2b(%rip), %r8     # 0x3246f2
movl $0x179, %r9d            # imm = 0x179
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf0a23
movq 0x18(%rbx), %rdi
callq 0x10660a
movq 0x20(%rbx), %rdi
leaq 0x233cd9(%rip), %rsi    # 0x3246f2
movl $0x16f, %edx            # imm = 0x16F
callq 0x936f9
leaq 0x233cc8(%rip), %rsi    # 0x3246f2
movq %rbx, %rdi
movl $0x171, %edx            # imm = 0x171
popq %rbx
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/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 0xf0a64
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf0a38
testl %eax, %eax
jne 0xf0a80
movq 0x28(%r14), %r14
jmp 0xf0a46
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_O2/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 0xf0aa3
testq %rsi, %rsi
je 0xf0a96
movq (%rdi), %rax
movq %rax, (%rsi)
testq %rdx, %rdx
je 0xf0aa2
movq 0x8(%rdi), %rax
movq %rax, (%rdx)
retq
pushq %rax
movq 0x3474bd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f455e(%rip), %rsi    # 0x2e5013
leaq 0x22bfc1(%rip), %rdx    # 0x31ca7d
leaq 0x233c81(%rip), %rcx    # 0x324744
leaq 0x233c28(%rip), %r8     # 0x3246f2
movl $0x186, %r9d            # imm = 0x186
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x23410d(%rip), %rdi    # 0x324c4b
xorl %eax, %eax
callq 0x17070
testl %ebp, %ebp
je 0xf0b74
decb %bpl
pushq $0x1
popq %r14
movl %ebp, %ecx
shll %cl, %r14d
pushq $0x31
popq %rbp
testl %r14d, %r14d
je 0xf0b74
movl %r14d, %eax
andl %ebx, %eax
cmpl $0x1, %eax
movl %ebp, %edi
sbbl $0x0, %edi
callq 0x179c0
shrl %r14d
jmp 0xf0b58
pushq $0xa
popq %rdi
callq 0x179c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf0ba6
cmpq %rsi, 0x30(%rdi)
jbe 0xf0bd4
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
movq 0x3473bb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f445c(%rip), %rsi    # 0x2e5013
leaq 0x22bebf(%rip), %rdx    # 0x31ca7d
leaq 0x233ba6(%rip), %rcx    # 0x32476b
leaq 0x233b26(%rip), %r8     # 0x3246f2
movl $0x198, %r9d            # imm = 0x198
jmp 0xf0c00
movq 0x34738d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f442e(%rip), %rsi    # 0x2e5013
leaq 0x233b91(%rip), %rdx    # 0x32477d
leaq 0x233b78(%rip), %rcx    # 0x32476b
leaq 0x233af8(%rip), %r8     # 0x3246f2
movl $0x199, %r9d            # imm = 0x199
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x233a41(%rip), %rsi    # 0x3246f2
pushq $0x50
popq %rdi
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x93160
testq %r13, %r13
je 0xf0cf8
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)
andq $0x0, 0x10(%rax)
andl $0x0, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x347269(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f430a(%rip), %rsi    # 0x2e5013
leaq 0x22bd6d(%rip), %rdx    # 0x31ca7d
leaq 0x233abc(%rip), %rcx    # 0x3247d3
leaq 0x2339d4(%rip), %r8     # 0x3246f2
movl $0x1b2, %r9d            # imm = 0x1B2
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2339a6(%rip), %rsi    # 0x3246f2
pushq $0x50
popq %rdi
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x93160
testq %r13, %r13
je 0xf0dc1
movq %rax, %r14
movq %r13, 0x8(%rax)
movq 0x10(%r13), %rax
movq %rax, 0x18(%r14)
movq %r15, 0x10(%r14)
movq %r12, 0x20(%r14)
andq $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 0xf0db4
cmpl $-0x1, %eax
jne 0xf0def
leaq 0x233a66(%rip), %rsi    # 0x32480d
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x3471a0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f4241(%rip), %rsi    # 0x2e5013
leaq 0x22bca4(%rip), %rdx    # 0x31ca7d
leaq 0x233a0a(%rip), %rcx    # 0x3247ea
leaq 0x23390b(%rip), %r8     # 0x3246f2
movl $0x1c9, %r9d            # imm = 0x1C9
jmp 0xf0e1b
movq 0x347172(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f4213(%rip), %rsi    # 0x2e5013
leaq 0x233a1d(%rip), %rdx    # 0x324824
leaq 0x2339dc(%rip), %rcx    # 0x3247ea
leaq 0x2338dd(%rip), %r8     # 0x3246f2
movl $0x1da, %r9d            # imm = 0x1DA
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf0e81
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xf0eaf
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 0xf0e65
andq $0x0, 0x28(%rbx)
xorl %eax, %eax
jmp 0xf0e79
leaq 0x233a32(%rip), %rsi    # 0x32489e
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
movl 0x48(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3470e0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f4181(%rip), %rsi    # 0x2e5013
leaq 0x2339ac(%rip), %rdx    # 0x324845
leaq 0x2339ba(%rip), %rcx    # 0x32485a
leaq 0x23384b(%rip), %r8     # 0x3246f2
movl $0x1e2, %r9d            # imm = 0x1E2
jmp 0xf0edb
movq 0x3470b2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f4153(%rip), %rsi    # 0x2e5013
leaq 0x2339b8(%rip), %rdx    # 0x32487f
leaq 0x23398c(%rip), %rcx    # 0x32485a
leaq 0x23381d(%rip), %r8     # 0x3246f2
movl $0x1e3, %r9d            # imm = 0x1E3
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf124b
movq %rdi, %rbx
leaq 0x2334c4(%rip), %rdx    # 0x3246f2
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
movl $0x25e, %ecx            # imm = 0x25E
callq 0x9334a
movq %rbx, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
popq %rbx
retq
movq 0x346d16(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f3db7(%rip), %rsi    # 0x2e5013
leaq 0x22b81a(%rip), %rdx    # 0x31ca7d
leaq 0x233730(%rip), %rcx    # 0x32499a
leaq 0x233481(%rip), %r8     # 0x3246f2
movl $0x25d, %r9d            # imm = 0x25D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf12cd
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xf12fb
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0xf12b7
testb %sil, %sil
je 0xf12a4
movq 0x28(%rax), %rcx
movq %rcx, 0x8(%rdi)
cmpq $0x0, 0x20(%rcx)
movq %rcx, %rax
je 0xf12b7
pushq $0x1
popq %rax
jmp 0xf12cb
movq 0x18(%rax), %rax
movq %rax, (%rdx)
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
popq %rcx
retq
movq 0x346c94(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f3d35(%rip), %rsi    # 0x2e5013
leaq 0x2336d4(%rip), %rdx    # 0x3249b9
leaq 0x2336da(%rip), %rcx    # 0x3249c6
leaq 0x2333ff(%rip), %r8     # 0x3246f2
movl $0x269, %r9d            # imm = 0x269
jmp 0xf1327
movq 0x346c66(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f3d07(%rip), %rsi    # 0x2e5013
leaq 0x2336d3(%rip), %rdx    # 0x3249e6
leaq 0x2336ac(%rip), %rcx    # 0x3249c6
leaq 0x2333d1(%rip), %r8     # 0x3246f2
movl $0x26b, %r9d            # imm = 0x26B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf1e37
andq $0x0, (%rdx)
movq 0x8(%r8), %r9
movq 0x10(%r8), %r10
decq %r10
movq 0x18(%r8), %rdx
movq %rdx, %rax
imulq %r9, %rax
shlq $0x3, %rax
addq (%r8), %rax
cmpq %r10, %r9
jne 0xf1e25
movq 0x20(%r8), %rdx
movq %rdx, (%rsi)
movq 0x28(%r8), %rdx
jmp 0xf1e2a
movq %rdx, (%rsi)
xorl %edx, %edx
movq %rax, (%rdi)
movq %rdx, (%rcx)
incq 0x8(%r8)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf26fe
testq %rsi, %rsi
je 0xf26fe
movq 0x10(%rsi), %rcx
pushq $-0x1
popq %rax
cmpq %rcx, 0x10(%rdi)
jae 0xf26e7
retq
jbe 0xf26ed
pushq $0x1
popq %rax
retq
movq 0x18(%rsi), %rcx
cmpq %rcx, 0x18(%rdi)
jb 0xf26e6
seta %al
movzbl %al, %eax
retq
pushq %rax
movq 0x345862(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f2903(%rip), %rsi    # 0x2e5013
leaq 0x23249f(%rip), %rdx    # 0x324bb6
leaq 0x2324a1(%rip), %rcx    # 0x324bbf
leaq 0x231fcd(%rip), %r8     # 0x3246f2
pushq $0x57
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf274a
movq %rdi, %rbx
movl 0x30(%rdi), %eax
testl %eax, %eax
je 0xf274c
decl %eax
movl %eax, 0x30(%rbx)
popq %rbx
retq
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xf275a
callq 0xf2735
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xf2768
callq 0xf2735
leaq 0x231f83(%rip), %rsi    # 0x3246f2
pushq $0x71
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_tree_new
static GtHuffmanTree *huffman_tree_new(GtUword symbol,
                                       GtUint64 freq)
{
  GtHuffmanTree *huffptr;
  huffptr = gt_malloc(sizeof (GtHuffmanTree));
  huffptr->code.code = 0;
  huffptr->code.numofbits = 0;
  huffptr->symbol.symbol = symbol;
  huffptr->symbol.freq = freq;
  huffptr->leftchild = NULL;
  huffptr->rightchild = NULL;
  huffptr->reference_count = 0;
  return huffptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x231f66(%rip), %rsi    # 0x3246f2
pushq $0x38
popq %rdi
pushq $0x7a
popq %rdx
callq 0x93160
andq $0x0, (%rax)
andl $0x0, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
andl $0x0, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf2827
testq %rsi, %rsi
je 0xf2827
movq %rdi, %rbx
movzbl %dl, %eax
movq %rsi, %rdi
movl %eax, %esi
callq 0xf2a08
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x12bf59
movq 0x34573a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f27db(%rip), %rsi    # 0x2e5013
leaq 0x2324d5(%rip), %rdx    # 0x324d14
leaq 0x2324de(%rip), %rcx    # 0x324d24
leaq 0x2324ef(%rip), %r8     # 0x324d3c
pushq $0x19
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x34aeba(%rip)    # 0x43d728
jne 0xf289e
andq $0x0, (%rsp)
leaq 0x30(%rip), %rsi        # 0xf28ac
leaq 0x82(%rip), %rcx        # 0xf2905
leaq 0xfe(%rip), %r8         # 0xf2988
pushq $0x20
popq %rdi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x34ae8a(%rip)    # 0x43d728
callq 0x69ede
movq 0x34ae7e(%rip), %rax    # 0x43d728
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf2860
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
testq %rax, %rax
je 0xf28cf
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x10f7de
movq 0x345692(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f2733(%rip), %rsi    # 0x2e5013
leaq 0x232475(%rip), %rdx    # 0x324d5c
leaq 0x232480(%rip), %rcx    # 0x324d6e
leaq 0x232490(%rip), %r8     # 0x324d85
pushq $0x2a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf2860
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %rax, %r15
testq %rbx, %rbx
je 0xf2937
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xf2950
movq 0x10(%r15), %rsi
movzbl 0x18(%r15), %edx
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xf2a42
movq 0x345611(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f26b2(%rip), %rsi    # 0x2e5013
leaq 0x1f2857(%rip), %rdx    # 0x2e51bf
leaq 0x232437(%rip), %rcx    # 0x324da6
leaq 0x23240f(%rip), %r8     # 0x324d85
movl $0xb1, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf2860
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %rax, %r15
testq %rbx, %rbx
je 0xf29ba
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xf29d0
movq 0x10(%r15), %rsi
movzbl 0x18(%r15), %edx
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xf2a42
movq 0x345591(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f2632(%rip), %rsi    # 0x2e5013
leaq 0x1f27d7(%rip), %rdx    # 0x2e51bf
leaq 0x232441(%rip), %rcx    # 0x324e30
leaq 0x23238f(%rip), %r8     # 0x324d85
movl $0xbb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf2860
movq %rax, %rdi
callq 0x102da0
movq %rax, %r15
callq 0xf2860
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %r14, 0x10(%rax)
movb %bl, 0x18(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x34a76e(%rip)    # 0x43d730
jne 0xf2fee
andq $0x0, (%rsp)
leaq 0x2c(%rip), %rsi        # 0xf2ffc
leaq 0x6f(%rip), %rcx        # 0xf3046
pushq $0x30
popq %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x34a742(%rip)    # 0x43d730
callq 0x69ede
movq 0x34a736(%rip), %rax    # 0x43d730
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf3065
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xf30c8
callq 0xf2fb4
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %rax, %r15
movq %r14, %rdi
callq 0xda769
testb %al, %al
je 0xf30ac
movq %r14, 0x20(%r15)
andq $0x0, 0x28(%r15)
leaq 0x108(%rip), %rdx       # 0xf319c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0xdbc10
testl %eax, %eax
je 0xf30ac
popq %rbx
popq %r14
popq %r15
retq
leaq 0x33f(%rip), %rdx       # 0xf33f2
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0xdac92
movq 0x344e99(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1f3a(%rip), %rsi    # 0x2e5013
leaq 0x1f20df(%rip), %rdx    # 0x2e51bf
leaq 0x231dc4(%rip), %rcx    # 0x324eab
leaq 0x231d98(%rip), %r8     # 0x324e86
movl $0x8d, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf3164
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf3164
movq %rdi, %r14
callq 0xf2fb4
movq %rax, %rdi
callq 0x102da0
movq %rax, %r15
callq 0xf2fb4
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %rax, %r12
movq %r14, %rdi
callq 0x6c2be
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x6c2be
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x344dfd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1e9e(%rip), %rsi    # 0x2e5013
leaq 0x231cd2(%rip), %rdx    # 0x324e4e
leaq 0x231ce6(%rip), %rcx    # 0x324e69
leaq 0x231cfc(%rip), %r8     # 0x324e86
movl $0xb7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf3411
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xf3463
testq %r15, %r15
je 0xf3439
movq %r15, 0x20(%r14)
andq $0x0, 0x28(%r14)
leaq -0x28a(%rip), %rdx      # 0xf319c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xdbc10
movq 0x344b28(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1bc9(%rip), %rsi    # 0x2e5013
leaq 0x28aa4f(%rip), %rdx    # 0x37dea0
leaq 0x231c26(%rip), %rcx    # 0x32507e
leaq 0x231a27(%rip), %r8     # 0x324e86
pushq $0x7a
jmp 0xf348b
movq 0x344afe(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1b9f(%rip), %rsi    # 0x2e5013
leaq 0x1f1d44(%rip), %rdx    # 0x2e51bf
leaq 0x231bfc(%rip), %rcx    # 0x32507e
leaq 0x2319fd(%rip), %r8     # 0x324e86
pushq $0x79
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf34f8
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xf34f8
leaq 0x231c0a(%rip), %r14    # 0x3250c5
pushq $0x1
popq %r15
pushq $0x1e
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x48
popq %rsi
pushq $0x20
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x344a69(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1b0a(%rip), %rsi    # 0x2e5013
leaq 0x231b89(%rip), %rdx    # 0x325099
leaq 0x231b9d(%rip), %rcx    # 0x3250b4
leaq 0x231ba7(%rip), %r8     # 0x3250c5
pushq $0x1d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf35dc
movq (%rdi), %rax
testq %rax, %rax
je 0xf3606
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xf35da
popq %rcx
jmpq *%rax
popq %rax
retq
movq 0x344985(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f1a26(%rip), %rsi    # 0x2e5013
leaq 0x231b3d(%rip), %rdx    # 0x325131
leaq 0x231b45(%rip), %rcx    # 0x325140
leaq 0x231ac3(%rip), %r8     # 0x3250c5
pushq $0x35
jmp 0xf362e
movq 0x34495b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f19fc(%rip), %rsi    # 0x2e5013
leaq 0x231b30(%rip), %rdx    # 0x32514e
leaq 0x231b1b(%rip), %rcx    # 0x325140
leaq 0x231a99(%rip), %r8     # 0x3250c5
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390