LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_enable_statistics_output
void gt_hpol_processor_enable_statistics_output(GtHpolProcessor *hpp,
    bool output_multihit_stats, GtFile *outfile)
{
  gt_assert(hpp != NULL);
  hpp->output_stats = true;
  hpp->outfp_stats = outfile;
  hpp->output_multihit_stats = output_multihit_stats;
  gt_hpol_processor_output_stats_header(hpp->outfp_stats);
  gt_aligned_segments_pile_enable_edit_tracking(hpp->asp);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x18e7a6
movq 0x4ad82b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x387894(%rip), %rsi    # 0x516013
leaq 0x3c75b7(%rip), %rdx    # 0x555d3d
leaq 0x3c76d0(%rip), %rcx    # 0x555e5d
leaq 0x3c756c(%rip), %r8     # 0x555d00
movl $0x20c, %r9d            # imm = 0x20C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18e7a8
movq 0x10(%rsp), %rax
movb $0x1, 0xf9(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xc8(%rax)
movb 0xf(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0xfa(%rax)
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0x18e800
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1296d0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x18f9eb
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0xa5bf0
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0xa5bf0
movq (%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0xe1770
movq (%rsp), %rax
movq 0xf0(%rax), %rdi
callq 0x7e3d0
movq (%rsp), %rdi
leaq 0x3c631f(%rip), %rsi    # 0x555d00
movl $0x3e9, %edx            # imm = 0x3E9
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x488bd0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xe0f20
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x18fd6e
movq 0x38(%rsp), %rax
movq 0xa8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xa8(%rax)
movq 0x28(%rsp), %rdi
callq 0x488c70
testb $0x1, %al
jne 0x18fd64
movq 0x30(%rsp), %rdi
callq 0x488c70
testb $0x1, %al
jne 0x18fcee
jmp 0x18fd64
movq 0x38(%rsp), %rax
movq 0xb0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb0(%rax)
movq 0x38(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x488bd0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xe1030
movq 0x38(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x488bd0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
callq 0xe0fc0
movl $0x1, 0x44(%rsp)
jmp 0x18fda3
movl $0x2, 0x44(%rsp)
jmp 0x18fda3
movq 0x38(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x488bd0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
callq 0xe0fc0
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movb %r8b, %al
movq 0x8(%rsp), %r8
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movb %al, -0x21(%rsp)
movq %r9, -0x30(%rsp)
movq $0x0, -0x38(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
ja 0x19040a
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x21(%rsp), %ecx
cmpl %ecx, %eax
jne 0x1903c7
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
cmpq $0x0, -0x30(%rsp)
je 0x1903c5
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movsbq (%rax,%rcx), %rcx
movq -0x30(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1903f7
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x1903f3
cmpq $0x0, 0x8(%rsp)
je 0x1903f1
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1903f5
jmp 0x19040a
jmp 0x1903f7
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x19036e
movq -0x38(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %r9b, %al
movb 0x58(%rsp), %r9b
movb 0x50(%rsp), %r9b
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x30(%rsp), %rcx
movb %al, 0xf(%rsp)
jbe 0x19176b
cmpq $0x0, 0x20(%rsp)
seta %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x191775
jmp 0x1917cc
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
jne 0x1917ca
movb 0x50(%rsp), %dl
movq 0x40(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movb 0x58(%rsp), %dl
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x19174c
jmp 0x1917ce
cmpq $0x0, 0x20(%rsp)
je 0x19180e
movq 0x4aa7c3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38482c(%rip), %rsi    # 0x516013
leaq 0x3fc2f5(%rip), %rdx    # 0x58dae3
leaq 0x3c4f65(%rip), %rcx    # 0x55675a
leaq 0x3c4504(%rip), %r8     # 0x555d00
movl $0x258, %r9d            # imm = 0x258
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x191810
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_new
GtHuffman *gt_huffman_new(const void *distribution,
                          GtDistrFunc distr_func,
                          GtUword num_of_symbols)
{
  GtHuffman *huff;

  gt_assert(distribution && distr_func != NULL);
  gt_assert(num_of_symbols > 0);

  huff = gt_malloc(sizeof (GtHuffman));
  huff->num_of_symbols = num_of_symbols;
  initialise_rbt(huff, distribution, distr_func);
  make_huffman_tree(huff);

  huff->code_tab = gt_calloc((size_t) huff->num_of_symbols,
                             sizeof (GtHuffmanCode));

  huff->num_of_text_symbols = 0;
  huff->num_of_text_bits = 0;
  huffman_tree_set_codes_rec(huff->root_huffman_tree);
  (void) gt_huffman_iterate(huff, calc_size, huff);
  (void) gt_huffman_iterate(huff, store_codes, huff);

  return huff;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x191843
cmpq $0x0, 0x18(%rsp)
jne 0x19187b
movq 0x4aa756(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3847bf(%rip), %rsi    # 0x516013
leaq 0x3c51ad(%rip), %rdx    # 0x556a08
leaq 0x3c51c9(%rip), %rcx    # 0x556a2b
leaq 0x3c51d1(%rip), %r8     # 0x556a3a
movl $0x157, %r9d            # imm = 0x157
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19187d
jmp 0x19187f
cmpq $0x0, 0x10(%rsp)
ja 0x1918bf
movq 0x4aa712(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38477b(%rip), %rsi    # 0x516013
leaq 0x3c51b3(%rip), %rdx    # 0x556a52
leaq 0x3c5185(%rip), %rcx    # 0x556a2b
leaq 0x3c518d(%rip), %r8     # 0x556a3a
movl $0x158, %r9d            # imm = 0x158
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1918c1
movl $0x38, %edi
leaq 0x3c516d(%rip), %rsi    # 0x556a3a
movl $0x15a, %edx            # imm = 0x15A
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x191990
movq 0x8(%rsp), %rdi
callq 0x191b30
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movl $0x10, %esi
leaq 0x3c511d(%rip), %rdx    # 0x556a3a
movl $0x160, %ecx            # imm = 0x160
callq 0xe83c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x191f30
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x755(%rip), %rsi       # 0x1920c0
callq 0x191fe0
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x78f(%rip), %rsi       # 0x192110
callq 0x191fe0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/huffcode.c
// Function: initialise_rbt
static void initialise_rbt(GtHuffman *huffman,
                           const void *distr,
                           GtDistrFunc distrfunc)
{
  GtHuffmanTree *huffptr;
  GT_UNUSED GtHuffmanTree *huffptr2;
  GtUword i;
  GtUint64 ret;
  bool nodecreated;

  huffman->num_of_coded_symbols = 0;
  huffman->rbt_root = gt_rbtree_new(huffman_tree_cmp,
                                    huffman_tree_delete,
                                    NULL);
  gt_assert(huffman->rbt_root);

  for (i = 0; i < huffman->num_of_symbols; i++) {
    ret = distrfunc(distr, i);
    if (ret > 0) {
      huffptr = huffman_tree_new(i, ret);
      nodecreated = false;
      huffptr2 = (GtHuffmanTree*)gt_rbtree_search(huffman->rbt_root,
                                                  huffptr,
                                                  &nodecreated);
      gt_assert(nodecreated && huffptr2 != NULL);
      huffman->num_of_coded_symbols++;
    }
  }
  gt_log_log("added " GT_WU " of " GT_WU " symbols as nodes",
             huffman->num_of_coded_symbols,
             huffman->num_of_symbols);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq $0x0, 0x28(%rax)
leaq 0x37c9(%rip), %rdi      # 0x195180
leaq 0x38c2(%rip), %rsi      # 0x195280
xorl %eax, %eax
movl %eax, %edx
callq 0x1b7e90
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x191a17
movq 0x4aa5ba(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x384623(%rip), %rsi    # 0x516013
leaq 0x3c54a4(%rip), %rdx    # 0x556e9b
leaq 0x3c54af(%rip), %rcx    # 0x556ead
leaq 0x3c5035(%rip), %r8     # 0x556a3a
movl $0x9a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x191a19
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x191afd
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq *%rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x191ae8
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x195310
movq %rax, 0x28(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x1b8790
movq %rax, 0x20(%rsp)
testb $0x1, 0xf(%rsp)
je 0x191a9d
cmpq $0x0, 0x20(%rsp)
jne 0x191ad5
movq 0x4aa4fc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x384565(%rip), %rsi    # 0x516013
leaq 0x3c5407(%rip), %rdx    # 0x556ebc
leaq 0x3c53f1(%rip), %rcx    # 0x556ead
leaq 0x3c4f77(%rip), %r8     # 0x556a3a
movl $0xa4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x191ad7
movq 0x40(%rsp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x191aea
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x191a22
movq 0x40(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0x3c53c6(%rip), %rdi    # 0x556edc
movb $0x0, %al
callq 0xe7740
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movb $0x1, 0xe(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x191fd2
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x191fd0
movq 0x10(%rsp), %rax
movq (%rax), %rcx
shlq %rcx
orq $0x0, %rcx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
shlq %rcx
orq $0x1, %rcx
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x191f30
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x191f30
jmp 0x191fd2
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x192033
movq 0x4a9f9e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x384007(%rip), %rsi    # 0x516013
leaq 0x3bcc0a(%rip), %rdx    # 0x54ec1d
leaq 0x3c4a4b(%rip), %rcx    # 0x556a65
leaq 0x3c4a19(%rip), %r8     # 0x556a3a
movl $0x178, %r9d            # imm = 0x178
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x192035
jmp 0x192037
cmpq $0x0, 0x10(%rsp)
jne 0x192077
movq 0x4a9f5a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x383fc3(%rip), %rsi    # 0x516013
leaq 0x3c4a21(%rip), %rdx    # 0x556a78
leaq 0x3c4a07(%rip), %rcx    # 0x556a65
leaq 0x3c49d5(%rip), %r8     # 0x556a3a
movl $0x179, %r9d            # imm = 0x179
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x192079
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1920a3
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x192260
movl %eax, 0x24(%rsp)
jmp 0x1920ab
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/huffcode.c
// Function: calc_size
static int calc_size(GT_UNUSED GtUword symbol,
                     GtUint64 freq,
                     GT_UNUSED const GtBitsequence code,
                     unsigned int code_len,
                     void *huffman)
{
  GtHuffman *huff = (GtHuffman*)huffman;
  huff->num_of_text_bits += code_len * freq;
  huff->num_of_text_symbols += freq;
  return 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq %r8, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, %ecx
imulq -0x10(%rsp), %rcx
movq -0x30(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x30(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/huffcode.c
// Function: store_codes
static int store_codes(GtUword symbol,
                       GT_UNUSED GtUint64 freq,
                       const GtBitsequence code,
                       unsigned int code_len,
                       void *huffman)
{
  GtHuffman *huff = (GtHuffman*)huffman;
  huff->code_tab[symbol].code = code;
  gt_safe_assign(huff->code_tab[symbol].numofbits, code_len);
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x40(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0x1921b0
cmpl $0x1, 0x14(%rsp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, 0x10(%rsp)
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1921b0
movl 0x10(%rsp), %ecx
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x40(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x1921bb
movl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1921bb
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1921f8
movq 0x4a9dcf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x385e4a(%rip), %rsi    # 0x518025
leaq 0x3c4858(%rip), %rdx    # 0x556a3a
movl $0xfa, %ecx
movb $0x0, %al
callq 0x199f0
movl $0x1, %edi
callq 0x19890
jmp 0x1921fa
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x192242
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1b7f50
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x3c4802(%rip), %rsi    # 0x556a3a
movl $0x16f, %edx            # imm = 0x16F
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x3c47ed(%rip), %rsi    # 0x556a3a
movl $0x171, %edx            # imm = 0x171
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1922a1
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x195400
movl %eax, 0xc(%rsp)
jmp 0x1922e2
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x192260
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1922e0
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x192260
movl %eax, 0xc(%rsp)
jmp 0x1922e2
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x192342
movq 0x4a9c8f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x383cf8(%rip), %rsi    # 0x516013
leaq 0x3bc8fb(%rip), %rdx    # 0x54ec1d
leaq 0x3c4763(%rip), %rcx    # 0x556a8c
leaq 0x3c470a(%rip), %r8     # 0x556a3a
movl $0x186, %r9d            # imm = 0x186
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x192344
cmpq $0x0, 0x8(%rsp)
je 0x19235c
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rsp)
je 0x192373
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq %r8, (%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0xc(%rsp), %ecx
leaq 0x3c4b83(%rip), %rdi    # 0x556f93
movb $0x0, %al
callq 0x19070
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x195450
leaq 0x400e47(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x192498
movq 0x4a9b39(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x383ba2(%rip), %rsi    # 0x516013
leaq 0x3bc7a5(%rip), %rdx    # 0x54ec1d
leaq 0x3c4634(%rip), %rcx    # 0x556ab3
leaq 0x3c45b4(%rip), %r8     # 0x556a3a
movl $0x198, %r9d            # imm = 0x198
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19249a
jmp 0x19249c
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x1924e4
movq 0x4a9aed(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x383b56(%rip), %rsi    # 0x516013
leaq 0x3c4601(%rip), %rdx    # 0x556ac5
leaq 0x3c45e8(%rip), %rcx    # 0x556ab3
leaq 0x3c4568(%rip), %r8     # 0x556a3a
movl $0x199, %r9d            # imm = 0x199
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1924e6
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl $0x50, %edi
leaq 0x3c4441(%rip), %rsi    # 0x556a3a
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xe80f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x192648
movq 0x4a9989(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3839f2(%rip), %rsi    # 0x516013
leaq 0x3bc5f5(%rip), %rdx    # 0x54ec1d
leaq 0x3c44ec(%rip), %rcx    # 0x556b1b
leaq 0x3c4404(%rip), %r8     # 0x556a3a
movl $0x1b2, %r9d            # imm = 0x1B2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19264a
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x50, %edi
leaq 0x3c4326(%rip), %rsi    # 0x556a3a
movl $0x1c7, %edx            # imm = 0x1C7
callq 0xe80f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x192763
movq 0x4a986e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3838d7(%rip), %rsi    # 0x516013
leaq 0x3bc4da(%rip), %rdx    # 0x54ec1d
leaq 0x3c43e8(%rip), %rcx    # 0x556b32
leaq 0x3c42e9(%rip), %r8     # 0x556a3a
movl $0x1c9, %r9d            # imm = 0x1C9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x192765
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x40, %rsi
movq 0x8(%rsp), %rdx
addq $0x30, %rdx
movq 0x8(%rsp), %rcx
addq $0x38, %rcx
movq 0x8(%rsp), %r8
movq 0x20(%r8), %r8
callq *%rax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x48(%rax)
movq 0x8(%rsp), %rax
cmpl $-0x1, 0x48(%rax)
jne 0x192819
movq 0x10(%rsp), %rdi
leaq 0x3c434e(%rip), %rsi    # 0x556b55
movb $0x0, %al
callq 0xd88c0
movq $0x0, 0x30(%rsp)
jmp 0x19286a
jmp 0x19281b
movq 0x8(%rsp), %rax
cmpl $0x1, 0x48(%rax)
je 0x19285e
movq 0x4a9773(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3837dc(%rip), %rsi    # 0x516013
leaq 0x3c432e(%rip), %rdx    # 0x556b6c
leaq 0x3c42ed(%rip), %rcx    # 0x556b32
leaq 0x3c41ee(%rip), %r8     # 0x556a3a
movl $0x1da, %r9d            # imm = 0x1DA
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x192860
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1928d6
movq 0x4a96fb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x383764(%rip), %rsi    # 0x516013
leaq 0x3c42d7(%rip), %rdx    # 0x556b8d
leaq 0x3c42e5(%rip), %rcx    # 0x556ba2
leaq 0x3c4176(%rip), %r8     # 0x556a3a
movl $0x1e2, %r9d            # imm = 0x1E2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1928d8
jmp 0x1928da
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x19291e
movq 0x4a96b3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38371c(%rip), %rsi    # 0x516013
leaq 0x3c42c9(%rip), %rdx    # 0x556bc7
leaq 0x3c429d(%rip), %rcx    # 0x556ba2
leaq 0x3c412e(%rip), %r8     # 0x556a3a
movl $0x1e3, %r9d            # imm = 0x1E3
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x192920
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x40, %rsi
movq 0x18(%rsp), %rdx
addq $0x30, %rdx
movq 0x18(%rsp), %rcx
addq $0x38, %rcx
movq 0x18(%rsp), %r8
movq 0x20(%r8), %r8
callq *%rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x48(%rax)
movq 0x18(%rsp), %rax
cmpl $-0x1, 0x48(%rax)
jne 0x19298a
movq 0x10(%rsp), %rdi
leaq 0x3c4271(%rip), %rsi    # 0x556be6
movb $0x0, %al
callq 0xd88c0
movq 0x18(%rsp), %rax
movl 0x48(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x19299f
movq 0x18(%rsp), %rax
movq $0x0, 0x28(%rax)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x192f7e
movq 0x4a9053(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3830bc(%rip), %rsi    # 0x516013
leaq 0x3bbcbf(%rip), %rdx    # 0x54ec1d
leaq 0x3c3d7d(%rip), %rcx    # 0x556ce2
leaq 0x3c3ace(%rip), %r8     # 0x556a3a
movl $0x25d, %r9d            # imm = 0x25D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x192f80
movl $0x1, %edi
movl $0x10, %esi
leaq 0x3c3aa9(%rip), %rdx    # 0x556a3a
movl $0x25e, %ecx            # imm = 0x25E
callq 0xe83c0
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x193034
movq 0x4a8f9d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x383006(%rip), %rsi    # 0x516013
leaq 0x3c3ced(%rip), %rdx    # 0x556d01
leaq 0x3c3cf3(%rip), %rcx    # 0x556d0e
leaq 0x3c3a18(%rip), %r8     # 0x556a3a
movl $0x269, %r9d            # imm = 0x269
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x193036
jmp 0x193038
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x19307c
movq 0x4a8f55(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x382fbe(%rip), %rsi    # 0x516013
leaq 0x3c3cd2(%rip), %rdx    # 0x556d2e
leaq 0x3c3cab(%rip), %rcx    # 0x556d0e
leaq 0x3c39d0(%rip), %r8     # 0x556a3a
movl $0x26b, %r9d            # imm = 0x26B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19307e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1930ba
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x193135
testb $0x1, 0x1f(%rsp)
je 0x1930d9
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1930ef
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x19312b
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x193133
movl $0x1, 0x4(%rsp)
jmp 0x193135
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x194404
movl $0x0, -0x4(%rsp)
jmp 0x1944d9
movq -0x20(%rsp), %rax
movq $0x0, (%rax)
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x194479
movq -0x38(%rsp), %rax
movq (%rax), %rcx
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rsp), %rdx
imulq 0x18(%rdx), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x38(%rsp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x38(%rsp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1944c0
movq -0x38(%rsp), %rax
movq (%rax), %rcx
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rsp), %rdx
imulq 0x18(%rdx), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rax
movq $0x0, (%rax)
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_unit_test
int gt_huffman_unit_test(GtError *err)
{
  int had_err = 0;

  had_err = test_bitwise(err);

  if (!had_err)
    had_err = test_mem(err);

  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x194520
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x194514
movq 0x10(%rsp), %rdi
callq 0x193190
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1951b7
cmpq $0x0, 0x8(%rsp)
jne 0x1951ef
movq 0x4a6de2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x380e4b(%rip), %rsi    # 0x516013
leaq 0x3c1d2f(%rip), %rdx    # 0x556efe
leaq 0x3c1d31(%rip), %rcx    # 0x556f07
leaq 0x3c185d(%rip), %r8     # 0x556a3a
movl $0x57, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1951f1
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x19520f
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x195271
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x19522d
movl $0x1, 0x34(%rsp)
jmp 0x195271
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x19524b
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x195271
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x195269
movl $0x1, 0x34(%rsp)
jmp 0x195271
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x195302
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jbe 0x1952b6
movq 0x8(%rsp), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0x195300
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1952d0
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x195280
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1952ea
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x195280
movq 0x8(%rsp), %rdi
leaq 0x3c1744(%rip), %rsi    # 0x556a3a
movl $0x71, %edx
callq 0xe88c0
jmp 0x195302
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x38, %edi
leaq 0x3c1710(%rip), %rsi    # 0x556a3a
movl $0x7a, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movl $0x0, 0x30(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_leaf_call_actfunc
static inline int huffman_leaf_call_actfunc(GtHuffmanTree *h_tree,
                                            void *actinfo,
                                            GtHuffmanActFunc actfun) {
  return actfun(h_tree->symbol.symbol,
                h_tree->symbol.freq,
                h_tree->code.code,
                h_tree->code.numofbits,
                actinfo);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rdi
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq 0x8(%rsp), %r8
callq *%rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/huffcode.c
// Function: print_huff_code
static void print_huff_code(unsigned length, GtBitsequence code)
{
  if (length > 0) {
    unsigned leftbit;

    for (leftbit = 1U << (length-1);
        leftbit != 0;
        leftbit >>= 1)
      (void) putchar((code & leftbit) ? '1' : '0');
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jbe 0x1954ad
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x1954ab
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %eax
andq %rax, %rcx
movl $0x30, %edi
movl $0x31, %eax
cmpq $0x0, %rcx
cmovnel %eax, %edi
callq 0x19960
movl 0x4(%rsp), %eax
shrl %eax
movl %eax, 0x4(%rsp)
jmp 0x195476
jmp 0x1954ad
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1954e6
cmpq $0x0, 0x18(%rsp)
jne 0x19551e
movq 0x4a6ab3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x380b1c(%rip), %rsi    # 0x516013
leaq 0x3c1b5e(%rip), %rdx    # 0x55705c
leaq 0x3c1b67(%rip), %rcx    # 0x55706c
leaq 0x3c1b78(%rip), %r8     # 0x557084
movl $0x19, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x195520
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x195790
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1f6b70
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x9f220
cmpq $0x0, 0x4ad87a(%rip)    # 0x642dd8
jne 0x195596
movl $0x20, %edi
leaq 0x44(%rip), %rsi        # 0x1955b0
xorl %eax, %eax
movl %eax, %r9d
leaq 0xb8(%rip), %rcx        # 0x195630
leaq 0x161(%rip), %r8        # 0x1956e0
movq %r9, %rdx
movq $0x0, (%rsp)
callq 0x1b2170
movq %rax, 0x4ad842(%rip)    # 0x642dd8
callq 0x9f280
movq 0x4ad836(%rip), %rax    # 0x642dd8
popq %rcx
retq
nopw %cs:(%rax,%rax)