LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/dup_feature_visitor.c
// Function: dup_feature_visitor_feature_node
static int dup_feature_visitor_feature_node(GtNodeVisitor *nv,
                                            GtFeatureNode *fn,
                                            GT_UNUSED GtError *err)
{
  GtFeatureNodeIterator *fni, *child_iterator;
  GtFeatureNode *node, *child;
  GtDupFeatureVisitor *v;
  gt_error_check(err);
  v = gt_dup_feature_visitor_cast(nv);
  fni = gt_feature_node_iterator_new(fn);
  while ((node = gt_feature_node_iterator_next(fni))) {
    child_iterator = gt_feature_node_iterator_new_direct(node);
    while ((child = gt_feature_node_iterator_next(child_iterator))) {
      if (gt_feature_node_has_type(child, v->source_type))
        gt_feature_node_add_child(node, duplicate_feature(child,v->dest_type));
    }
    gt_feature_node_iterator_delete(child_iterator);
  }
  gt_feature_node_iterator_delete(fni);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1374e0
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1376ab
callq 0x137420
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %rbx
movq %r14, %rdi
callq 0x143f54
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x1440ea
testq %rax, %rax
je 0x137691
movq %rax, %r14
movq %r14, %rdi
callq 0x144041
movq %rax, %r15
movq %rax, %rdi
callq 0x1440ea
testq %rax, %rax
je 0x137674
movq %rax, %r13
movq %r14, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq 0x18(%rbx), %rsi
movq %r13, %rdi
callq 0x142b18
testb %al, %al
je 0x137660
movq 0x10(%rbx), %r14
movq %r13, %rdi
callq 0x144635
movq %rax, %r15
movq %r13, %rdi
callq 0x144674
movq %rax, %rbp
movq %r13, %rdi
callq 0x144697
movq %rax, %r12
movq %r13, %rdi
callq 0x1424d6
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movl %eax, %r8d
callq 0x1422f4
movq %rax, %rbp
movq %r13, %rdi
callq 0x142998
testb %al, %al
je 0x1375c6
movq %r13, %rdi
callq 0x142ab4
movq %rax, %rdi
callq 0x11acc9
movq %rax, %r14
movq %rbp, %rdi
movq %rax, %rsi
callq 0x141fb5
movq %r14, %rdi
callq 0x11bdbf
movq %r13, %rdi
callq 0x1429c8
testb %al, %al
je 0x1375e2
movq %r13, %rdi
callq 0x142cc3
movq %rbp, %rdi
callq 0x1429dc
movq %r13, %rdi
callq 0x142d3a
movq %rbp, %rdi
movl %eax, %esi
callq 0x142018
movq %r13, %rdi
callq 0x141f60
movq %rax, %r14
movq %rax, %rdi
callq 0x11c131
testq %rax, %rax
je 0x137646
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x11bfb3
movq %rax, %r12
movq %r13, %rdi
movq %rax, %rsi
callq 0x141f50
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x14329d
incq %r15
movq %r14, %rdi
callq 0x11c131
cmpq %rax, %r15
jb 0x13760f
movq %r14, %rdi
callq 0x11c144
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x14275f
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1440ea
movq %rax, %r13
testq %rax, %rax
jne 0x13753c
movq %r15, %rdi
callq 0x14417c
movq (%rsp), %rdi
callq 0x1440ea
movq %rax, %r14
testq %rax, %rax
jne 0x137513
movq (%rsp), %rdi
callq 0x14417c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3fa49
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/dup_feature_visitor.c
// Function: gt_dup_feature_visitor_new
GtNodeVisitor* gt_dup_feature_visitor_new(const char *dest_type,
                                          const char *source_type)
{
  GtDupFeatureVisitor *aiv;
  GtNodeVisitor *nv;
  gt_assert(dest_type && source_type);
  nv = gt_node_visitor_create(gt_dup_feature_visitor_class());
  aiv = gt_dup_feature_visitor_cast(nv);
  aiv->dest_type = gt_cstr_dup(dest_type);
  aiv->source_type = gt_cstr_dup(source_type);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x137714
movq %rsi, %rbx
testq %rsi, %rsi
je 0x137714
movq %rdi, %r14
callq 0x137420
movq %rax, %rdi
callq 0x163080
movq %rax, %r15
callq 0x137420
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %rax, %r12
movq %r14, %rdi
callq 0xe4290
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0xe4290
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3fa80
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_new
GtEditscript *gt_editscript_new(GtAlphabet *alphabet)
{
  uint32_t alphabet_size;
  GtEditscript *es;
  es = gt_calloc((size_t) 1, sizeof (*es));
  alphabet_size = gt_alphabet_size(alphabet);
  es->entry_size =
    gt_determinebitspervalue((GtUword) alphabet_size + 3);
  gt_assert(es->entry_size <= (uint8_t) (sizeof (uint8_t) * CHAR_BIT));
  es->size = 0U;
  es->space = NULL;
  es->del = (uint8_t) alphabet_size;
  es->num_elems = 0;
  return es;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x243dee(%rip), %rdx    # 0x37b518
movl $0x1, %edi
movl $0x18, %esi
movl $0x52, %ecx
callq 0x10436a
movq %rax, %rbx
movq %r14, %rdi
callq 0xd11cf
movl %eax, %ebp
movl %eax, %edi
addq $0x3, %rdi
callq 0x105e91
movb %al, 0x15(%rbx)
movzbl %al, %eax
cmpl $0x9, %eax
jae 0x137773
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb %bpl, 0x14(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3fab7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_reset
void gt_editscript_reset(GtEditscript *editscript)
{
  gt_assert(editscript);
  if (editscript->space != NULL) {
    editscript->space[0] = 0;
  }
  editscript->num_elems = 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1377cf
movq (%rdi), %rax
testq %rax, %rax
je 0x1377c7
movq $0x0, (%rax)
movl $0x0, 0xc(%rdi)
retq
pushq %rax
callq 0x3faee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_reset
void gt_editscript_builder_reset(GtEditscriptBuilder *es_builder,
                                 GtEditscript *editscript)
{
  gt_assert(es_builder);
  gt_assert(editscript);
  gt_editscript_reset(editscript);
  editscript_pos_reset(&es_builder->fillpos);
  es_builder->es = editscript;
  es_builder->last_op = 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1379a1
testq %rsi, %rsi
je 0x1379a6
movq (%rsi), %rax
testq %rax, %rax
je 0x137983
movq $0x0, (%rax)
movl $0x0, 0xc(%rsi)
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0x8(%rdi)
movq %rsi, (%rdi)
movb $0x0, 0x10(%rdi)
popq %rax
retq
callq 0x3fb99
callq 0x3fb60
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_add_match
void gt_editscript_builder_add_match(GtEditscriptBuilder *es_builder)
{
  gt_assert(es_builder);
  es_builder->last_op = 0;
  es_builder->es->trailing_matches++;
  gt_assert(es_builder->es->trailing_matches != 0 &&
            "trailing matches overflow");
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1379bf
movb $0x0, 0x10(%rdi)
movq (%rdi), %rax
incl 0x10(%rax)
je 0x1379c4
popq %rax
retq
callq 0x3fc0b
callq 0x3fbd2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_add_mismatch
void gt_editscript_builder_add_mismatch(GtEditscriptBuilder *es_builder,
                                        GtUchar c)
{
  GtEditscript *es;
  gt_assert(es_builder != NULL);
  es = es_builder->es;
  gt_assert(c <= (GtUchar) es->del || c == (GtUchar) GT_WILDCARD);
  if (c == (GtUchar) GT_WILDCARD) {
    c = (GtUchar) es->del - 1;
  }
  if (es_builder->last_op != (uint8_t) GT_EDITSCRIPT_MISDEL_SYM(es)) {
    gt_editscript_builder_start_group(es_builder,
                                      (uint8_t) GT_EDITSCRIPT_MISDEL_SYM(es));
  }
  editscript_space_add_next(es, &es_builder->fillpos, (GtBitsequence) c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x137b2a
movq %rdi, %rbx
movq (%rdi), %r15
movb 0x14(%r15), %al
cmpb %sil, %al
setae %cl
cmpb $-0x2, %sil
sete %dl
orb %cl, %dl
je 0x137b2f
leal -0x1(%rax), %ecx
cmpb $-0x2, %sil
movzbl %sil, %edx
movzbl %cl, %ebp
cmovnel %edx, %ebp
incb %al
cmpb %al, 0x10(%rbx)
je 0x137a1f
movzbl %al, %esi
movq %rbx, %rdi
callq 0x139321
movzbl %bpl, %r14d
movl 0x8(%rbx), %r12d
movl 0xc(%rbx), %r13d
movzbl 0x15(%r15), %ebp
cmpl $0x0, 0x8(%r15)
je 0x137a3c
movq (%r15), %rdi
jmp 0x137a6e
movb $0x40, %al
movzbl %al, %eax
divb %bpl
incb %al
movzbl %al, %edi
movl %edi, 0x8(%r15)
shll $0x3, %edi
leaq 0x243ac1(%rip), %rsi    # 0x37b518
movl $0x6f, %edx
callq 0x104226
movq %rax, %rdi
movq %rax, (%r15)
movq $0x0, (%rax)
incl 0xc(%r15)
movl %r13d, %eax
subl %ebp, %eax
jbe 0x137a87
movl %eax, %ecx
shlq %cl, %r14
orq %r14, (%rdi,%r12,8)
jmp 0x137b14
movl %r13d, 0x4(%rsp)
movl %r12d, %r13d
incl %r13d
movl 0x8(%r15), %ecx
cmpl %ecx, %r13d
jb 0x137ade
movb $0x40, %al
movzbl %al, %eax
divb 0x15(%r15)
movzbl %al, %eax
addl %ecx, %eax
incl %eax
cvtsi2sd %rax, %xmm0
mulsd 0x210260(%rip), %xmm0   # 0x347d18
cvttsd2si %xmm0, %rax
movl %eax, 0x8(%r15)
movl %eax, %esi
shlq $0x3, %rsi
leaq 0x243a4a(%rip), %rdx    # 0x37b518
movl $0x7b, %ecx
callq 0x104461
movq %rax, %rdi
movq %rax, (%r15)
movl %ebp, %ecx
movl 0x4(%rsp), %esi
subl %esi, %ecx
movq %r14, %rax
shrq %cl, %rax
orq %rax, (%rdi,%r12,8)
movl %r13d, %edx
movq $0x0, (%rdi,%rdx,8)
movl $0x40, %eax
subl %esi, %ebp
je 0x137b11
subl %ebp, %eax
negl %ebp
movl %ebp, %ecx
shlq %cl, %r14
movq %r14, (%rdi,%rdx,8)
movl %r13d, %r12d
movl %r12d, 0x8(%rbx)
movl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3fc7d
callq 0x3fc44
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_get_source_len
GtUword gt_editscript_get_source_len(const GtEditscript *editscript)
{
  GtEditscriptPos pos;
  GtBitsequence elem;
  GtUword length = 0;
  uint32_t served = 0;
  bool skip = false;

  gt_assert(editscript != NULL);
  editscript_pos_reset(&pos);
  if (editscript->num_elems != 0) {
    elem = editscript_space_get_next(editscript, &pos);
    served++;
    while (served < editscript->num_elems) {
      length += editscript_space_get_length(editscript, &pos, &served);
      if (elem == GT_EDITSCRIPT_INS_SYM(editscript))
        skip = true;
      else
        skip = false;

      while (served < editscript->num_elems) {
        elem = editscript_space_get_next(editscript, &pos);
        served++;
        if (elem > (GtBitsequence) editscript->del)
          break;
        if (!skip && elem <= (GtBitsequence) editscript->del)
          length++;
      }
    }
  }
  return length + editscript->trailing_matches;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1381e7
movl $0x0, 0x4(%rsp)
movl 0xc(%rdi), %edx
testl %edx, %edx
je 0x1380ee
movq (%rdi), %r13
movzbl 0x15(%rdi), %r15d
movl $0x40, %r14d
movl $0x40, %eax
cmpl $0x41, %r15d
jb 0x1380d7
movl $0x1, 0x4(%rsp)
movl $0x80, %eax
movq (%r13), %rbp
subl %r15d, %eax
movl %eax, 0x8(%rsp)
movl $0x1, (%rsp)
cmpl $0x1, %edx
jne 0x138108
xorl %eax, %eax
movl 0x10(%rdi), %ecx
addq %rax, %rcx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subl %r15d, %r14d
movl %r14d, %ecx
shrq %cl, %rbp
movl %edx, 0xc(%rsp)
movl %edx, %r12d
negl %r12d
xorl %ebx, %ebx
movq %rdi, 0x10(%rsp)
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
callq 0x137ea7
addq %rbx, %rax
movl (%rsp), %esi
movl 0x4(%rsp), %r11d
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
cmpl %ecx, %esi
jae 0x1381c0
movq 0x10(%rsp), %rdi
movzbl 0x14(%rdi), %r8d
leaq 0x2(%r8), %rcx
xorl %r9d, %r9d
cmpq %rcx, %rbp
setne %r9b
incl %esi
movl %r11d, %ecx
xorl %r11d, %r11d
testl %edx, %edx
sete %r11b
movl $0x40, %r10d
cmovel %r10d, %edx
addl %ecx, %r11d
movq (%r13,%r11,8), %rbp
movl %edx, %ecx
negb %cl
shlq %cl, %rbp
cmpl %r15d, %edx
jae 0x13819d
incl %r11d
movq (%r13,%r11,8), %r10
movl %edx, %ecx
shrq %cl, %r10
orq %r10, %rbp
addl $0x40, %edx
subl %r15d, %edx
movl %r14d, %ecx
shrq %cl, %rbp
cmpq %r8, %rbp
ja 0x1381c7
addq %r9, %rax
leal (%r12,%rsi), %ecx
incl %ecx
incl %esi
cmpl $0x1, %ecx
jne 0x138160
jmp 0x1380f0
movq 0x10(%rsp), %rdi
jmp 0x1381cb
movl 0xc(%rsp), %ecx
movl %esi, (%rsp)
movl %edx, 0x8(%rsp)
movl %r11d, 0x4(%rsp)
movq %rax, %rbx
cmpl %ecx, %esi
jb 0x138122
jmp 0x1380f0
callq 0x3fdd3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_get_target_len
GtUword gt_editscript_get_target_len(const GtEditscript *editscript)
{
  GtEditscriptPos pos;
  GtBitsequence elem;
  GtUword length = 0;
  uint32_t served = 0;

  gt_assert(editscript != NULL);
  editscript_pos_reset(&pos);
  if (editscript->num_elems != 0) {
    (void) editscript_space_get_next(editscript, &pos);
    served++;
    while (served < editscript->num_elems) {
      /* add matches */
      length += editscript_space_get_length(editscript, &pos, &served);
      while (served < editscript->num_elems) {
        elem = editscript_space_get_next(editscript, &pos);
        served++;
        if (elem > (GtBitsequence) editscript->del)
          break;
        if (elem < (GtBitsequence) editscript->del)
          length++;
      }
    }
  }
  return length + editscript->trailing_matches;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x13832e
movl $0x0, 0x8(%rsp)
movl 0xc(%rdi), %r11d
testl %r11d, %r11d
je 0x13824f
movzbl 0x15(%rdi), %r13d
movl $0x40, %r14d
movl $0x40, %eax
cmpl $0x41, %r13d
jb 0x138237
movl $0x1, 0x8(%rsp)
movl $0x80, %eax
movq (%rdi), %r15
subl %r13d, %eax
movl %eax, 0xc(%rsp)
movl $0x1, 0x4(%rsp)
cmpl $0x1, %r11d
jne 0x138269
xorl %eax, %eax
movl 0x10(%rdi), %ecx
addq %rax, %rcx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subl %r13d, %r14d
movl %r11d, %r12d
negl %r12d
xorl %ebp, %ebp
movq %r14, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rdi, %r14
movl %r11d, %ebx
callq 0x137ea7
movl %ebx, %r11d
addq %rbp, %rax
movl 0x4(%rsp), %esi
movl 0x8(%rsp), %ebx
movl 0xc(%rsp), %edx
cmpl %r11d, %esi
jae 0x13830e
movzbl 0x14(%r14), %r8d
incl %esi
movq %r14, %rdi
movq 0x10(%rsp), %r14
movl %ebx, %ecx
xorl %ebx, %ebx
testl %edx, %edx
sete %bl
movl $0x40, %r9d
cmovel %r9d, %edx
addl %ecx, %ebx
movq (%r15,%rbx,8), %r9
movl %edx, %ecx
negb %cl
shlq %cl, %r9
cmpl %r13d, %edx
jae 0x1382ea
incl %ebx
movq (%r15,%rbx,8), %r10
movl %edx, %ecx
shrq %cl, %r10
orq %r10, %r9
addl $0x40, %edx
subl %r13d, %edx
movl %r14d, %ecx
shrq %cl, %r9
cmpq %r8, %r9
ja 0x138311
adcq $0x0, %rax
leal (%r12,%rsi), %ecx
incl %ecx
incl %esi
cmpl $0x1, %ecx
jne 0x1382b4
jmp 0x138251
movq %r14, %rdi
movl %esi, 0x4(%rsp)
movl %edx, 0xc(%rsp)
movl %ebx, 0x8(%rsp)
movq %rax, %rbp
cmpl %r11d, %esi
jb 0x138279
jmp 0x138251
callq 0x3fe0c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_get_sequence
GtUword gt_editscript_get_sequence(const GtEditscript *editscript,
                                   const GtEncseq *encseq,
                                   GtUword start,
                                   GtReadmode dir,
                                   GtUchar **buffer,
                                   GtUword *bufsize)
{
  GtUword length = gt_editscript_get_target_len(editscript),
          written;
  if (*buffer == NULL || length > *bufsize) {
    *bufsize = length;
    gt_log_log("bufsize: " GT_WU, *bufsize);
    *buffer = gt_realloc(*buffer, sizeof (**buffer) * *bufsize);
  }
  written = gt_editscript_get_sub_sequence_v(editscript,
                                             encseq, start, dir,
                                             0, length -1,
                                             *buffer);
  gt_assert(written == length);
  return written;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, %r13
movl %ecx, 0x14(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1381ec
movq %rax, %rbx
movq (%r13), %rax
testq %rax, %rax
je 0x138d83
cmpq (%rbp), %rbx
jbe 0x138db5
movq %rbx, (%rbp)
leaq 0x242aa6(%rip), %rdi    # 0x37b834
movq %rbx, %rsi
xorl %eax, %eax
callq 0x103d72
movq (%r13), %rdi
movq (%rbp), %rsi
leaq 0x242771(%rip), %rdx    # 0x37b518
movl $0x2b6, %ecx            # imm = 0x2B6
callq 0x104461
movq %rax, (%r13)
leaq -0x1(%rbx), %r9
movq %rax, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl 0x14(%rsp), %ecx
xorl %r8d, %r8d
callq 0x138a96
cmpq %rbx, %rax
jne 0x138de9
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x400b8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_io
GtEditscript *gt_editscript_io(GtEditscript *editscript, FILE *fp, GtError *err)
{
  if (editscript == NULL) {
    editscript = gt_calloc((size_t) 1, sizeof (GtEditscript));
    editscript = editscript_io_fp(editscript, fp, err, gt_io_error_fread);
  }
  else {
    editscript = editscript_io_fp(editscript, fp, err, gt_io_error_fwrite);
  }
  return editscript;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
testq %rdi, %rdi
je 0x138f05
movq %rdi, %rbx
addq $0x15, %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x156cc4
testl %eax, %eax
jne 0x138fff
leaq 0x10(%rbx), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x156cc4
testl %eax, %eax
jne 0x138fff
leaq 0x14(%rbx), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x156cc4
testl %eax, %eax
jne 0x138fff
leaq 0xc(%rbx), %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x156cc4
testl %eax, %eax
jne 0x138fff
movl (%r12), %eax
testq %rax, %rax
je 0x139009
movzbl 0x15(%rbx), %ecx
imulq %rax, %rcx
movq %rcx, %rsi
shrq $0x6, %rsi
andl $0x3f, %ecx
cmpq $0x1, %rcx
sbbl $-0x1, %esi
movl %esi, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x3, %rsi
leaq 0x24263b(%rip), %rdx    # 0x37b518
movl $0x2e0, %ecx            # imm = 0x2E0
callq 0x104461
movq %rax, (%rbx)
movl 0x8(%rbx), %edx
movl $0x8, %esi
movq %rax, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x156cc4
jmp 0x138ffb
leaq 0x24260c(%rip), %rdx    # 0x37b518
movl $0x1, %edi
movl $0x18, %esi
movl $0x2f1, %ecx            # imm = 0x2F1
callq 0x10436a
movq %rax, %rbx
leaq 0x15(%rax), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x156d03
testl %eax, %eax
jne 0x138fff
leaq 0x10(%rbx), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x156d03
testl %eax, %eax
jne 0x138fff
leaq 0x14(%rbx), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x156d03
testl %eax, %eax
jne 0x138fff
movq %rbx, %r12
addq $0xc, %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x156d03
testl %eax, %eax
jne 0x138fff
movl (%r12), %eax
testq %rax, %rax
je 0x139009
movzbl 0x15(%rbx), %ecx
imulq %rax, %rcx
movq %rcx, %rsi
shrq $0x6, %rsi
andl $0x3f, %ecx
cmpq $0x1, %rcx
sbbl $-0x1, %esi
movl %esi, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x3, %rsi
leaq 0x242540(%rip), %rdx    # 0x37b518
movl $0x2e0, %ecx            # imm = 0x2E0
callq 0x104461
movq %rax, (%rbx)
movl 0x8(%rbx), %edx
movl $0x8, %esi
movq %rax, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x156d03
testl %eax, %eax
je 0x139009
movq %rbx, %rdi
callq 0x137778
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_new
GtEditscriptBuilder *gt_editscript_builder_new(GtEditscript *editscript)
{
  GtEditscriptBuilder *es_b = gt_malloc(sizeof (*es_b));
  editscript_pos_reset(&es_b->fillpos);
  es_b->es = editscript;
  es_b->last_op = 0;
  return es_b;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x24221d(%rip), %rsi    # 0x37b518
movl $0x18, %edi
movl $0x344, %edx            # imm = 0x344
callq 0x104226
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
movq %rcx, 0x8(%rax)
movq %rbx, (%rax)
movb $0x0, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/editscript.c
// Function: gt_editscript_builder_start_group
static inline void gt_editscript_builder_start_group(GtEditscriptBuilder *es_b,
                                                     uint8_t type)
{
  GtEditscript *es = es_b->es;
  es_b->last_op = type;
  editscript_space_add_next(es, &es_b->fillpos, type);
  editscript_space_add_length(es, &es_b->fillpos,
                              (GtBitsequence) es->trailing_matches);
  es->trailing_matches = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
movb %sil, 0x10(%rdi)
movl %esi, %r12d
movl 0x8(%rdi), %r13d
movl 0xc(%rdi), %r15d
movzbl 0x15(%rbx), %ebp
cmpl $0x0, 0x8(%rbx)
je 0x139353
movq (%rbx), %rdi
jmp 0x139384
movb $0x40, %al
movzbl %al, %eax
divb %bpl
incb %al
movzbl %al, %edi
movl %edi, 0x8(%rbx)
shll $0x3, %edi
leaq 0x2421ab(%rip), %rsi    # 0x37b518
movl $0x6f, %edx
callq 0x104226
movq %rax, %rdi
movq %rax, (%rbx)
movq $0x0, (%rax)
incl 0xc(%rbx)
leaq 0x8(%r14), %r8
movl %r15d, %eax
subl %ebp, %eax
jbe 0x1393a0
movl %eax, %ecx
shlq %cl, %r12
orq %r12, (%rdi,%r13,8)
jmp 0x139434
movl %r15d, 0xc(%rsp)
movl %r13d, %r15d
incl %r15d
movl 0x8(%rbx), %ecx
cmpl %ecx, %r15d
jb 0x1393fe
movb $0x40, %al
movzbl %al, %eax
divb 0x15(%rbx)
movzbl %al, %eax
addl %ecx, %eax
incl %eax
cvtsi2sd %rax, %xmm0
mulsd 0x20e949(%rip), %xmm0   # 0x347d18
cvttsd2si %xmm0, %rax
movl %eax, 0x8(%rbx)
movl %eax, %esi
shlq $0x3, %rsi
leaq 0x242134(%rip), %rdx    # 0x37b518
movl $0x7b, %ecx
movq %r8, 0x10(%rsp)
callq 0x104461
movq 0x10(%rsp), %r8
movq %rax, %rdi
movq %rax, (%rbx)
movl %ebp, %ecx
movl 0xc(%rsp), %esi
subl %esi, %ecx
movq %r12, %rax
shrq %cl, %rax
orq %rax, (%rdi,%r13,8)
movl %r15d, %edx
movq $0x0, (%rdi,%rdx,8)
movl $0x40, %eax
subl %esi, %ebp
je 0x139431
subl %ebp, %eax
negl %ebp
movl %ebp, %ecx
shlq %cl, %r12
movq %r12, (%rdi,%rdx,8)
movl %r15d, %r13d
movl %r13d, 0x8(%r14)
movl %eax, 0xc(%r14)
movl 0x10(%rbx), %edx
movq %rbx, %rdi
movq %r8, %rsi
callq 0x13a4b5
movl $0x0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/elias_gamma.c
// Function: gt_elias_gamma_encode
GtBittab* gt_elias_gamma_encode(GtUword x)
{
  GtBittab* code = NULL;
  GtUword length_in_bits, idx;

  gt_assert(x > 0);
  length_in_bits = (GtUword) gt_determinebitspervalue(x);
  code = gt_bittab_new(length_in_bits + length_in_bits - 1UL);
  for (idx = 0; idx < length_in_bits; idx++)
    if (((x >> idx) & 1))
      gt_bittab_set_bit(code, idx);
  return code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x13aa96
movq %rdi, %rbx
callq 0x105e91
movl %eax, %ebp
movl %eax, %r12d
leaq -0x1(,%r12,2), %rdi
callq 0xd6a50
movq %rax, %r14
testl %ebp, %ebp
je 0x13aa8a
xorl %r15d, %r15d
btq %r15, %rbx
jae 0x13aa82
movq %r14, %rdi
movq %r15, %rsi
callq 0xd6abc
incq %r15
cmpq %r15, %r12
jne 0x13aa71
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x4020e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/elias_gamma.c
// Function: gt_elias_gamma_bitwise_decoder_new
GtEliasGammaBitwiseDecoder* gt_elias_gamma_bitwise_decoder_new(void)
{
  GtEliasGammaBitwiseDecoder *egbd = gt_malloc(sizeof (*egbd));
  egbd->status = LEADING_ZEROS;
  egbd->cur_bit = 0;
  egbd->length_in_bits = 0;
  egbd->x = 1UL;
  return egbd;
}

// Assembly:
pushq %rax
leaq 0x24120c(%rip), %rsi    # 0x37bcaf
movl $0x20, %edi
movl $0x33, %edx
callq 0x104226
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x1, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/elias_gamma.c
// Function: gt_elias_gamma_bitwise_decoder_next
int gt_elias_gamma_bitwise_decoder_next(GtEliasGammaBitwiseDecoder *egbd,
                                        bool bit, GtUword *x)
{
  gt_assert(egbd);
  if (egbd->status == LEADING_ZEROS) {
    if (bit == false)
      egbd->length_in_bits += 1;
    else {
      if (egbd->length_in_bits == 0) {
        *x = 1UL;
        reset_decoder(egbd);
        return 0;
      }
      else
        egbd->status = REST;
    }
  }
  else {
    egbd->x = egbd->x << 1;
    if (bit)
      egbd->x = egbd->x | 1;
    egbd->cur_bit++;
    if (egbd->cur_bit == egbd->length_in_bits) {
      *x = egbd->x;
      reset_decoder(egbd);
      return 0;
    }
  }
  return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x13ab6c
cmpl $0x0, (%rdi)
je 0x13ab2e
movq 0x8(%rdi), %r8
movq 0x18(%rdi), %rax
movzbl %sil, %ecx
leaq (%rcx,%rax,2), %rcx
movq %rcx, 0x18(%rdi)
incq %r8
movq %r8, 0x8(%rdi)
movl $0x1, %eax
cmpq 0x10(%rdi), %r8
jne 0x13ab2d
movq %rcx, (%rdx)
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x1, 0x18(%rdi)
xorl %eax, %eax
retq
movq 0x10(%rdi), %rax
testb %sil, %sil
je 0x13ab44
testq %rax, %rax
je 0x13ab51
movl $0x1, (%rdi)
jmp 0x13ab4b
incq %rax
movq %rax, 0x10(%rdi)
movl $0x1, %eax
retq
movl $0x1, %eax
movq %rax, (%rdx)
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
jmp 0x13ab2b
pushq %rax
callq 0x40245
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc.c
// Function: gt_encdesc_encoder_new
GtEncdescEncoder* gt_encdesc_encoder_new(void)
{
  GtEncdescEncoder *ee;

  ee = gt_calloc((size_t) 1, sizeof (GtEncdescEncoder));
  ee->timer = NULL;
  ee->page_sampling = false;
  ee->regular_sampling = false;
  ee->sampling_rate = 0;

  ee->encdesc = encdesc_new();
  return ee;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x240ff9(%rip), %rbx    # 0x37bd28
movl $0x1, %edi
movl $0x20, %esi
movq %rbx, %rdx
movl $0x345, %ecx            # imm = 0x345
callq 0x10436a
movq %rax, %r14
xorl %eax, %eax
movq %rax, (%r14)
movw $0x0, 0x18(%r14)
movq %rax, 0x10(%r14)
movl $0x1, %edi
movl $0x70, %esi
movq %rbx, %rdx
movl $0x33c, %ecx            # imm = 0x33C
callq 0x10436a
movq %rax, %rbx
callq 0xe3e95
movq %rax, 0x50(%rbx)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc.c
// Function: gt_encdesc_load
GtEncdesc* gt_encdesc_load(const char *name,
                           GtError *err)
{
  int had_err = 0;
  GtEncdesc *encdesc = NULL;
  FILE *fp;
  GtStr *filename;
  int fd;
  GtUword const pages_to_map = 5UL;

  gt_assert(name);
  encdesc = encdesc_new();

  filename = gt_str_new_cstr(name);
  gt_str_append_cstr(filename, GT_ENCDESC_FILESUFFIX);
  fp = gt_fa_fopen_with_suffix(name, GT_ENCDESC_FILESUFFIX, "rb", err);
  if (fp == NULL) {
    gt_assert(gt_error_is_set(err));
    had_err = 1;
  }

  if (!had_err) {
    fd = open(gt_str_get(filename), O_RDONLY);
    if (fd == -1) {
      gt_error_set(err, "open(): cannot read file %s, error: %s",
                   gt_str_get(filename), strerror(errno));
      had_err = 1;
    }
  }
  if (!had_err)
    had_err = encdesc_read_header(encdesc, fp, err);

  if (!had_err) {
    encdesc_init_huffman(encdesc);

    encdesc_read_samplingtab(encdesc, fp);
    gt_fa_fclose(fp);

    encdesc->bitinstream =
      gt_bitinstream_new(gt_str_get(filename),
                         (size_t) encdesc->start_of_encoding, pages_to_map);
    gt_str_delete(filename);

  }
  else {
    gt_encdesc_delete(encdesc);
    encdesc = NULL;
  }
  return encdesc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x13c447
movq %rsi, %r15
movq %rdi, %r12
leaq 0x23fa2b(%rip), %r13    # 0x37bd28
movl $0x1, %edi
movl $0x70, %esi
movq %r13, %rdx
movl $0x33c, %ecx            # imm = 0x33C
callq 0x10436a
movq %rax, %rbx
callq 0xe3e95
movq %rax, 0x50(%rbx)
movq %r12, %rdi
callq 0x11acc9
movq %rax, %r14
leaq 0x23fb7c(%rip), %rbp    # 0x37beae
movq %rax, %rdi
movq %rbp, %rsi
callq 0x11acf3
leaq 0x2693d9(%rip), %rdx    # 0x3a571d
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rcx
movl $0x46c, %r8d            # imm = 0x46C
movq %r15, %r9
callq 0xfcf97
testq %rax, %rax
je 0x13c3ec
movq %rax, %r12
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x17d60
cmpl $-0x1, %eax
je 0x13c3fd
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x13e4a3
testl %eax, %eax
jne 0x13c42b
movq %rbx, %rdi
callq 0x13c11b
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x13c3bd
movq %r12, %rdi
xorl %edx, %edx
callq 0x11f87a
movq %r12, %rdi
callq 0x170e64
movq %rax, 0x28(%rbx)
movq %r12, %rdi
callq 0xfd018
movq %r14, %rdi
callq 0x11b0a1
movq 0x60(%rbx), %rsi
movl $0x5, %edx
movq %rax, %rdi
callq 0x2facc4
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x11bdbf
jmp 0x13c435
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x13c42b
callq 0x40846
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %r14
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x23fc16(%rip), %rsi    # 0x37c031
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movq %rbx, %rdi
callq 0x13c44c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4087f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc.c
// Function: gt_encdesc_delete
void gt_encdesc_delete(GtEncdesc *encdesc)
{
  if (!encdesc) return;
  gt_bitinstream_delete(encdesc->bitinstream);
  GT_FREEARRAY(&encdesc->num_of_fields_tab, GtUword);
  encdesc_delete_desc_fields(encdesc->fields, encdesc->num_of_fields);
  gt_sampling_delete(encdesc->sampling);
  gt_free(encdesc);
}

// Assembly:
testq %rdi, %rdi
je 0x13c5e6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2fae9e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13c493
leaq 0x23f8ad(%rip), %rsi    # 0x37bd28
movl $0x5ed, %edx            # imm = 0x5ED
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x13c5bb
movq %rbx, (%rsp)
movq 0x40(%rbx), %r13
testq %r13, %r13
je 0x13c5a3
xorl %ebp, %ebp
leaq 0x23f86e(%rip), %r15    # 0x37bd28
imulq $0xc8, %rbp, %r12
leaq (%r14,%r12), %rbx
movq 0x8(%r14,%r12), %rdi
callq 0x1543bd
movq 0x10(%r14,%r12), %rdi
callq 0x1543bd
movq 0x40(%r14,%r12), %rdi
movq %r15, %rsi
movl $0x5d2, %edx            # imm = 0x5D2
callq 0x1045eb
movq 0x30(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x13c526
cmpq $0x0, 0x68(%rbx)
je 0x13c519
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x101d90
incq %r12
cmpq 0x68(%rbx), %r12
jb 0x13c4ff
movq 0x30(%rbx), %rdi
movq %r15, %rsi
movl $0x5d6, %edx            # imm = 0x5D6
callq 0x1045eb
movq 0x28(%rbx), %rdi
callq 0x101d90
movq 0x20(%rbx), %rdi
callq 0x101d90
movq 0x38(%rbx), %rdi
callq 0xe5a93
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13c58e
cmpq $0x0, 0x68(%rbx)
je 0x13c581
xorl %r12d, %r12d
cmpq 0x50(%rbx), %r12
jae 0x13c569
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0xd6e4a
testb %al, %al
jne 0x13c575
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x1543bd
incq %r12
cmpq 0x68(%rbx), %r12
jb 0x13c553
movq (%rbx), %rdi
movq %r15, %rsi
movl $0x5e2, %edx            # imm = 0x5E2
callq 0x1045eb
movq 0x18(%rbx), %rdi
callq 0xd7151
incq %rbp
cmpq %r13, %rbp
jne 0x13c4ba
leaq 0x23f77e(%rip), %rsi    # 0x37bd28
movq %r14, %rdi
movl $0x5e6, %edx            # imm = 0x5E6
callq 0x1045eb
movq (%rsp), %rbx
movq 0x28(%rbx), %rdi
callq 0x17132e
leaq 0x23f75d(%rip), %rsi    # 0x37bd28
movq %rbx, %rdi
movl $0x5f0, %edx            # imm = 0x5F0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_hashmap_distr_add
static int encdesc_hashmap_distr_add(GtHashtable *hm_distri, GtWord key)
{
  GtUint64 *valueptr;
  gt_assert(hm_distri != NULL);
  valueptr = li_ull_gt_hashmap_get(hm_distri, key);
  if (!valueptr) {
    li_ull_gt_hashmap_add(hm_distri, key, (GtUint64) 1);
    return 1;
  }
  else {
    (*valueptr) += 1;
    return 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x13d1d7
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
callq 0x1012ee
testq %rax, %rax
je 0x13d19f
incq 0x8(%rax)
xorl %eax, %eax
jmp 0x13d1cf
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq $0x1, 0x8(%rsi)
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1015ee
testl %eax, %eax
jne 0x13d1ca
movq (%rsp), %rax
movq $0x1, 0x8(%rax)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x40bd4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_hashmap_distr_get_corrected
static GtUint64 encdesc_hashmap_distr_get_corrected(const void *data,
                                                    GtUword key)
{
  EncdescHuffDist *dist = (EncdescHuffDist*) data;
  GtUint64 *valueptr;
  /* function will be called with 0-based keys, we have to correct this, so a
     0-key maps to the smalles key within the distribution */
  GtWord corrected_key = (GtWord) key + dist->correction_base;
  gt_assert(dist->li_ull_hashmap);
  if (!(valueptr = li_ull_gt_hashmap_get(dist->li_ull_hashmap,
                                         corrected_key)))
    return 0;
  return *valueptr;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x13d276
addq 0x8(%rax), %rsi
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x1012ee
testq %rax, %rax
je 0x13d272
movq 0x8(%rax), %rax
jmp 0x13d274
xorl %eax, %eax
popq %rcx
retq
callq 0x40c0d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_hashmap_distr_get
static GtUint64 encdesc_hashmap_distr_get(const void *hm_distri,
                                          GtUword key)
{
  GtHashtable *hashmap = (GtHashtable*) hm_distri;
  GtUint64 *valueptr;
  gt_assert(hashmap != NULL);
  if (!(valueptr = li_ull_gt_hashmap_get(hashmap, (GtWord) key)))
    return 0;
  return *valueptr;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x13d2a3
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x1012ee
testq %rax, %rax
je 0x13d29f
movq 0x8(%rax), %rax
jmp 0x13d2a1
xorl %eax, %eax
popq %rcx
retq
callq 0x40c46
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc_header_io.c
// Function: io_hashmap_distri
static inline GtHashtable *io_hashmap_distri(GtHashtable *h_table,
                                             GtUword size,
                                             EncsecDistriData *data,
                                             GtError *err)
{
  if (h_table != NULL) {
    h_table = write_hashmap_distri(h_table, size, data, err);
  }
  else {
    h_table = read_hashmap_distri(h_table, size, data->fp, err);
  }
  return h_table;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
testq %rdi, %rdi
je 0x13ea48
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%r12)
leaq 0x50(%rsp), %rdx
movq %r12, (%rdx)
leaq 0x13f(%rip), %rcx       # 0x13eb59
movq %rcx, 0x8(%rdx)
movq %rax, 0x10(%rdx)
leaq 0x19c(%rip), %rsi       # 0x13ebc5
movq %r15, %rcx
callq 0x101b64
testl %eax, %eax
je 0x13eb1b
movq %rbx, %rdi
callq 0x101d90
xorl %ebx, %ebx
jmp 0x13eb3d
movq (%r12), %r12
movups 0x37b725(%rip), %xmm0   # 0x4ba178
movups %xmm0, 0x20(%rsp)
movups 0x37b709(%rip), %xmm0   # 0x4ba168
movups %xmm0, 0x10(%rsp)
movups 0x37b6ed(%rip), %xmm0   # 0x4ba158
movups %xmm0, (%rsp)
callq 0x101194
movq %rax, %rbx
testq %r14, %r14
je 0x13eb3d
leaq 0x50(%rsp), %r13
movl $0x8, %esi
movl $0x1, %edx
leaq 0x38(%rsp), %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0x156d03
testl %eax, %eax
jne 0x13ea39
movl $0x8, %esi
movl $0x1, %edx
leaq 0x40(%rsp), %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0x156d03
testl %eax, %eax
jne 0x13ea39
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1012ee
testq %rax, %rax
jne 0x13eb4f
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rbp
movq %rax, 0x50(%rsp)
movq %rbp, 0x58(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x48(%rsp), %rdx
callq 0x1015ee
testl %eax, %eax
jne 0x13eb10
movq 0x48(%rsp), %rax
movq %rbp, 0x8(%rax)
decq %r14
jne 0x13ea85
jmp 0x13eb3d
movq 0x8(%r12), %rdx
cmpq %r14, %rdx
je 0x13eb3d
leaq 0x26454f(%rip), %rdi    # 0x3a307b
movq %r14, %rsi
xorl %eax, %eax
callq 0x103d72
cmpq %r14, 0x8(%r12)
jne 0x13eb54
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x41237
callq 0x411fe
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc_header_io.c
// Function: encdesc_li_ull_hashmap_iter_write
static enum iterator_op encdesc_li_ull_hashmap_iter_write(
                                                          GtWord key,
                                                          GtUint64 value,
                                                          void *data,
                                                          GtError *err)
{
  int had_err = 0;
  EncsecDistriData *this_data = (EncsecDistriData*) data;
  this_data->written_elems++;
  had_err = gt_io_error_fwrite_one(key, this_data->fp, err);
  if (!had_err)
    had_err = gt_io_error_fwrite_one(value, this_data->fp, err);
  if (!had_err)
    return CONTINUE_ITERATION;
  return STOP_ITERATION;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rsp)
incq 0x8(%rdx)
movq (%rdx), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %r8
callq 0x156cc4
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x13ebbd
movq (%r14), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %r8
callq 0x156cc4
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/encdesc_header_io.c
// Function: encdesc_distri_iter_write
static void encdesc_distri_iter_write(GtUword symbol,
                                      GtUint64 freq,
                                      void *data)
{
  EncsecDistriData *this_data = (EncsecDistriData*) data;
  if (!this_data->had_err) {
    this_data->written_elems++;
    this_data->had_err = gt_io_error_fwrite_one(symbol, this_data->fp,
                                                this_data->err);
    if (!this_data->had_err)
      this_data->had_err = gt_io_error_fwrite_one(freq, this_data->fp,
                                                  this_data->err);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpl $0x0, 0x20(%rdx)
jne 0x13ec3b
movq %rdx, %rbx
incq 0x8(%rdx)
movq (%rdx), %rcx
movq 0x18(%rdx), %r8
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x156cc4
movl %eax, 0x20(%rbx)
testl %eax, %eax
jne 0x13ec3b
movq (%rbx), %rcx
movq 0x18(%rbx), %r8
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x156cc4
movl %eax, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/extract_feature_stream.c
// Function: gt_extract_feature_stream_set_trans_table
void gt_extract_feature_stream_set_trans_table(GtExtractFeatureStream *es,
                                               GtTransTable *table)
{
  gt_assert(es);
  gt_extract_feature_visitor_set_trans_table((GtExtractFeatureVisitor*)
                         gt_visitor_stream_get_visitor((GtVisitorStream*) es),
                         table);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x13f7e3
movq %rsi, %rbx
callq 0x184235
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x13fdcf
callq 0x415a9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/extract_feature_visitor.c
// Function: gt_extract_feature_visitor_class
const GtNodeVisitorClass* gt_extract_feature_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtExtractFeatureVisitor),
                                    extract_feature_visitor_free,
                                    NULL,
                                    extract_feature_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x37eefe(%rip)    # 0x4be710
jne 0x13f843
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x13f851
leaq 0x4f(%rip), %rcx        # 0x13f879
movl $0x48, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x37eecd(%rip)    # 0x4be710
callq 0xe2545
movq 0x37eec1(%rip), %rax    # 0x4be710
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/extract_feature_visitor.c
// Function: gt_extract_feature_visitor_new
GtNodeVisitor* gt_extract_feature_visitor_new(GtRegionMapping *rm,
                                              const char *type, bool join,
                                              bool translate, bool seqid,
                                              bool target, GtUword width,
                                              GtFile *outfp)
{
  GtNodeVisitor *nv;
  GtExtractFeatureVisitor *efv;
  gt_assert(rm);
  nv = gt_node_visitor_create(gt_extract_feature_visitor_class());
  efv= gt_extract_feature_visitor_cast(nv);
  efv->type = gt_symbol(type);
  efv->join = join;
  efv->translate = translate;
  efv->seqid = seqid;
  efv->ttable = NULL;
  efv->target = target;
  efv->coords = false;
  efv->fastaseq_counter = 0;
  efv->region_mapping = rm;
  efv->width = width;
  efv->outfp = outfp;
  /* XXX */
  efv->retain_ids = getenv("GT_RETAINIDS") ? true : false;
  return nv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
testq %rdi, %rdi
je 0x13fdba
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13f804
movq %rax, %rdi
callq 0x163080
movq %rax, %r13
callq 0x13f804
movq %rax, %rdi
movq %r13, %rsi
callq 0x1630b1
movq %rax, %rbp
movq %rbx, %rdi
callq 0x11c5ff
movq %rax, 0x10(%rbp)
movb %r12b, 0x20(%rbp)
movb %r15b, 0x21(%rbp)
movl (%rsp), %eax
movb %al, 0x22(%rbp)
xorl %eax, %eax
movq %rax, 0x18(%rbp)
movl 0x4(%rsp), %ecx
movb %cl, 0x23(%rbp)
movb $0x0, 0x24(%rbp)
movq %rax, 0x28(%rbp)
movq %r14, 0x38(%rbp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rbp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rbp)
leaq 0x23d20c(%rip), %rdi    # 0x37cfa8
callq 0x17950
testq %rax, %rax
setne 0x25(%rbp)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4172c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: gt_feature_in_stream_class
const GtNodeStreamClass *gt_feature_in_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc)
  {
    nsc = gt_node_stream_class_new(sizeof (GtFeatureInStream),
                                   feature_in_stream_free,
                                   feature_in_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x37e7b4(%rip)    # 0x4be718
jne 0x13ff85
leaq 0x26(%rip), %rsi        # 0x13ff93
leaq 0x65(%rip), %rdx        # 0x13ffd9
movl $0x28, %edi
callq 0x162d34
movq %rax, 0x37e793(%rip)    # 0x4be718
callq 0xe2545
movq 0x37e787(%rip), %rax    # 0x4be718
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: feature_in_stream_free
static void feature_in_stream_free(GtNodeStream *ns)
{
  GtFeatureInStream *stream = feature_in_stream_cast(ns);
  while (gt_queue_size(stream->cache) > 0)
  {
    GtGenomeNode *gn = gt_queue_get(stream->cache);
    gt_genome_node_delete(gn);
  }
  gt_queue_delete(stream->cache);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x13ff56
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x10d7ac
testq %rax, %rax
je 0x13ffcf
movq 0x18(%rbx), %rdi
callq 0x10d74a
movq %rax, %rdi
callq 0x1451a0
movq 0x18(%rbx), %rdi
jmp 0x13ffae
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x10dc23
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: feature_in_stream_next
static int feature_in_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                  GT_UNUSED GtError *error)
{
  GtFeatureInStream *stream = feature_in_stream_cast(ns);
  gt_error_check(error);

  if (!stream->init)
  {
    feature_in_stream_init(stream);
    stream->init = true;
  }

  if (gt_queue_size(stream->cache) > 0)
  {
    GtGenomeNode *node = gt_queue_get(stream->cache);
    GtFeatureNode *fn = gt_feature_node_try_cast(node);
    if (fn)
      gt_genome_node_ref(node);
    *gn = node;
    return 0;
  }

  *gn = NULL;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13ff56
movq %rax, %rdi
movq %r14, %rsi
callq 0x162ff7
movq %rax, %r14
testq %r15, %r15
je 0x14000b
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x14005e
cmpb $0x0, 0x21(%r14)
jne 0x14001f
movq %r14, %rdi
callq 0x13fdf0
movb $0x1, 0x21(%r14)
movq 0x18(%r14), %rdi
callq 0x10d7ac
testq %rax, %rax
je 0x140050
movq 0x18(%r14), %rdi
callq 0x10d74a
movq %rax, %r14
movq %rax, %rdi
callq 0x143cab
testq %rax, %rax
je 0x140053
movq %r14, %rdi
callq 0x1443a0
jmp 0x140053
xorl %r14d, %r14d
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x41810
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: gt_feature_in_stream_new
GtNodeStream* gt_feature_in_stream_new(GtFeatureIndex *fi)
{
  GtNodeStream *ns;
  GtFeatureInStream *stream;
  gt_assert(fi);

  ns = gt_node_stream_create(gt_feature_in_stream_class(), true);
  stream = feature_in_stream_cast(ns);
  stream->fi = fi;
  stream->cache = gt_queue_new();
  stream->useorig = false;
  stream->init = false;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1400ba
movq %rdi, %rbx
callq 0x13ff56
movq %rax, %rdi
movl $0x1, %esi
callq 0x162d6c
movq %rax, %r14
callq 0x13ff56
movq %rax, %rdi
movq %r14, %rsi
callq 0x162ff7
movq %rax, %r15
movq %rbx, 0x10(%rax)
callq 0x10d640
movq %rax, 0x18(%r15)
movw $0x0, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x41847
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_linesorted_out_stream.c
// Function: gt_gff3_linesorted_out_stream_class
const GtNodeStreamClass* gt_gff3_linesorted_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtGFF3LinesortedOutStream),
                                   gff3_linesorted_out_stream_free,
                                   gff3_linesorted_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x3781a6(%rip)    # 0x4be748
jne 0x1465c3
leaq 0x26(%rip), %rsi        # 0x1465d1
leaq 0xb6(%rip), %rdx        # 0x146668
movl $0x58, %edi
callq 0x162d34
movq %rax, 0x378185(%rip)    # 0x4be748
callq 0xe2545
movq 0x378179(%rip), %rax    # 0x4be748
popq %rcx
retq