LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/dot_visitor.c
// Function: dv_output_edge
static int dv_output_edge(GtFeatureNode *fn, void *data,
                          GT_UNUSED GtError *err)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *curnode = NULL;
  GtUword pid, cid;
  int had_err = 0;
  GtDotVisitor *dv = (GtDotVisitor*) data;

  if (!(pid = (GtUword) gt_hashmap_get(dv->ids, fn))) {
    pid = dv->idctr++;
    gt_hashmap_add(dv->ids, fn, (void*) pid);
  }
  printf(""GT_WU" [shape=record, label=\"{ "GT_WU" | %s | %p }\"]\n",
             pid, pid, gt_feature_node_get_type(fn), fn);

  fni = gt_feature_node_iterator_new_direct(fn);
  while ((curnode = gt_feature_node_iterator_next(fni))) {
    if (!(cid = (GtUword) gt_hashmap_get(dv->ids, curnode))) {
      cid = dv->idctr++;
      gt_hashmap_add(dv->ids, curnode, (void*) cid);
    }
    printf(""GT_WU" [shape=record, label=\"{ "GT_WU" | %s | %p }\"]\n",
             cid, cid, gt_feature_node_get_type(curnode), curnode);
    printf(""GT_WU" -> "GT_WU"\n", pid, cid);
  }
  gt_feature_node_iterator_delete(fni);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rsi), %rdi
movq %r12, %rsi
callq 0x8f482
movq %rax, %r14
testq %rax, %rax
jne 0xcdfce
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r14
leaq 0x1(%r14), %rax
movq %rax, 0x18(%rbx)
movq %r12, %rsi
movq %r14, %rdx
callq 0x8f4bd
movq %r12, %rdi
callq 0xda338
leaq 0x24d6c7(%rip), %rdi    # 0x31b6a4
movq %r14, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x17070
movq %r12, %rdi
callq 0xdc826
movq %rax, %r12
leaq 0x24d6d1(%rip), %r13    # 0x31b6d3
movq %r12, %rdi
callq 0xdc92e
testq %rax, %rax
je 0xce075
movq %rax, %rbp
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x8f482
movq %rax, %r15
testq %rax, %rax
jne 0xce041
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r15
leaq 0x1(%r15), %rax
movq %rax, 0x18(%rbx)
movq %rbp, %rsi
movq %r15, %rdx
callq 0x8f4bd
movq %rbp, %rdi
callq 0xda338
leaq 0x24d654(%rip), %rdi    # 0x31b6a4
movq %r15, %rsi
movq %r15, %rdx
movq %rax, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x17070
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x17070
jmp 0xce002
movq %r12, %rdi
callq 0xdc9f1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/dup_feature_stream.c
// Function: gt_dup_feature_stream_new
GtNodeStream* gt_dup_feature_stream_new(GtNodeStream *in_stream,
                                        const char *dest_type,
                                        const char *source_type)
{
  GtNodeVisitor *nv;
  gt_assert(in_stream);
  nv = gt_dup_feature_visitor_new(dest_type, source_type);
  return gt_visitor_stream_new(in_stream, nv);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xce0b0
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xce373
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x12bf59
movq 0x369eb1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x216f52(%rip), %rsi    # 0x2e5013
leaq 0x2212cb(%rip), %rdx    # 0x2ef393
leaq 0x24d621(%rip), %rcx    # 0x31b6f0
leaq 0x24d634(%rip), %r8     # 0x31b70a
pushq $0x1b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/dup_feature_visitor.c
// Function: gt_dup_feature_visitor_class
const GtNodeVisitorClass* gt_dup_feature_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtDupFeatureVisitor),
                                    dup_feature_visitor_free,
                                    NULL,
                                    dup_feature_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x36f5c2(%rip)    # 0x43d6b8
jne 0xce122
andq $0x0, (%rsp)
leaq 0x2c(%rip), %rsi        # 0xce130
leaq 0x6b(%rip), %rcx        # 0xce176
pushq $0x20
popq %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x36f596(%rip)    # 0x43d6b8
callq 0x69ede
movq 0x36f58a(%rip), %rax    # 0x43d6b8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xce3d7
movq %rsi, %rbx
testq %rsi, %rsi
je 0xce3d7
movq %rdi, %r14
callq 0xce0e8
movq %rax, %rdi
callq 0x102da0
movq %rax, %r15
callq 0xce0e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %rax, %r12
movq %r14, %rdi
callq 0x6c2be
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x6c2be
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x369b8a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x216c2b(%rip), %rsi    # 0x2e5013
leaq 0x24d33d(%rip), %rdx    # 0x31b72c
leaq 0x24d34f(%rip), %rcx    # 0x31b745
leaq 0x24d363(%rip), %r8     # 0x31b760
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x24d49a(%rip), %rdx    # 0x31b8b8
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x52
popq %rcx
callq 0x9334a
movq %rax, %rbx
movq %r14, %rdi
callq 0x56cd2
movl %eax, %ebp
movl %eax, %edi
addq $0x3, %rdi
callq 0x9580f
movb %al, 0x15(%rbx)
movzbl %al, %eax
cmpl $0x9, %eax
jae 0xce461
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb %bpl, 0x14(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x369b00(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x216ba1(%rip), %rsi    # 0x2e5013
leaq 0x24d459(%rip), %rdx    # 0x31b8d2
leaq 0x24d48c(%rip), %rcx    # 0x31b90c
leaq 0x24d431(%rip), %r8     # 0x31b8b8
pushq $0x56
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xce4e4
movq (%rdi), %rax
testq %rax, %rax
je 0xce4df
andq $0x0, (%rax)
andl $0x0, 0xc(%rdi)
retq
pushq %rax
movq 0x369a7c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x216b1d(%rip), %rsi    # 0x2e5013
leaq 0x24b191(%rip), %rdx    # 0x31968e
leaq 0x24d41a(%rip), %rcx    # 0x31b91e
leaq 0x24d3ad(%rip), %r8     # 0x31b8b8
movl $0x109, %r9d            # imm = 0x109
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xce706
testq %rsi, %rsi
je 0xce734
movq (%rsi), %rax
testq %rax, %rax
je 0xce6eb
andq $0x0, (%rax)
andl $0x0, 0xc(%rsi)
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0x8(%rdi)
movq %rsi, (%rdi)
movb $0x0, 0x10(%rdi)
popq %rax
retq
movq 0x36985b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2168fc(%rip), %rsi    # 0x2e5013
leaq 0x24d595(%rip), %rdx    # 0x31bcb3
leaq 0x24d599(%rip), %rcx    # 0x31bcbe
leaq 0x24d18c(%rip), %r8     # 0x31b8b8
movl $0x34e, %r9d            # imm = 0x34E
jmp 0xce760
movq 0x36982d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2168ce(%rip), %rsi    # 0x2e5013
leaq 0x24af42(%rip), %rdx    # 0x31968e
leaq 0x24d56b(%rip), %rcx    # 0x31bcbe
leaq 0x24d15e(%rip), %r8     # 0x31b8b8
movl $0x34f, %r9d            # imm = 0x34F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xce780
movb $0x0, 0x10(%rdi)
movq (%rdi), %rax
incl 0x10(%rax)
je 0xce7ae
popq %rax
retq
movq 0x3697e1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x216882(%rip), %rsi    # 0x2e5013
leaq 0x24d51b(%rip), %rdx    # 0x31bcb3
leaq 0x24d53b(%rip), %rcx    # 0x31bcda
leaq 0x24d112(%rip), %r8     # 0x31b8b8
movl $0x358, %r9d            # imm = 0x358
jmp 0xce7da
movq 0x3697b3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x216854(%rip), %rsi    # 0x2e5013
leaq 0x24d534(%rip), %rdx    # 0x31bcfa
leaq 0x24d50d(%rip), %rcx    # 0x31bcda
leaq 0x24d0e4(%rip), %r8     # 0x31b8b8
movl $0x35c, %r9d            # imm = 0x35C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0xce851
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r14
movb 0x14(%r14), %r15b
cmpb %bpl, %r15b
setae %al
cmpb $-0x2, %bpl
sete %cl
orb %al, %cl
je 0xce87f
leal 0x1(%r15), %eax
cmpb %al, 0x10(%rbx)
je 0xce823
movzbl %al, %esi
movq %rbx, %rdi
callq 0xcfd39
decb %r15b
cmpb $-0x2, %bpl
movzbl %bpl, %eax
movzbl %r15b, %ecx
cmovnel %eax, %ecx
addq $0x8, %rbx
movzbl %cl, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcfd6f
movq 0x369710(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2167b1(%rip), %rsi    # 0x2e5013
leaq 0x24d4d6(%rip), %rdx    # 0x31bd3f
leaq 0x24d4e2(%rip), %rcx    # 0x31bd52
leaq 0x24d041(%rip), %r8     # 0x31b8b8
movl $0x36e, %r9d            # imm = 0x36E
jmp 0xce8ab
movq 0x3696e2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x216783(%rip), %rsi    # 0x2e5013
leaq 0x24d4de(%rip), %rdx    # 0x31bd75
leaq 0x24d4b4(%rip), %rcx    # 0x31bd52
leaq 0x24d013(%rip), %r8     # 0x31b8b8
movl $0x370, %r9d            # imm = 0x370
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/editscript.c
// Function: editscript_space_get_next
static inline GtBitsequence editscript_space_get_next(const GtEditscript *es,
                                                      GtEditscriptPos *pos)
{
  GtBitsequence elem = 0;
  uint32_t shift;

  if (pos->bitsleft == 0) {
    pos->cur_word++;
    pos->bitsleft = (uint32_t) GT_INTWORDSIZE;
  }
  shift = pos->bitsleft;

  elem = es->space[pos->cur_word] << (GT_INTWORDSIZE - shift);
  if (shift < es->entry_size) {
    pos->cur_word++;
    elem |= es->space[pos->cur_word] >> (GtBitsequence) shift;
    pos->bitsleft = (uint32_t) (GT_INTWORDSIZE - (es->entry_size - shift));
  }
  else {
    pos->bitsleft -= es->entry_size;
  }
  elem >>= GT_INTWORDSIZE - es->entry_size;
  return elem;
}

// Assembly:
movl (%rsi), %r8d
movl 0x4(%rsi), %edx
testl %edx, %edx
jne 0xceba0
incl %r8d
movl %r8d, (%rsi)
pushq $0x40
popq %rdx
movq (%rdi), %r9
movl %r8d, %eax
movq (%r9,%rax,8), %rax
movl %edx, %ecx
negb %cl
shlq %cl, %rax
movzbl 0x15(%rdi), %edi
cmpl %edi, %edx
jae 0xcebce
incl %r8d
movl %r8d, (%rsi)
movq (%r9,%r8,8), %r8
movl %edx, %ecx
shrq %cl, %r8
orq %r8, %rax
addl $0x40, %edx
subl %edi, %edx
movl %edx, 0x4(%rsi)
negb %dil
movl %edi, %ecx
shrq %cl, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/editscript.c
// Function: editscript_space_get_length
static inline GtBitsequence
editscript_space_get_length(const GtEditscript *es,
                            GtEditscriptPos *pos,
                            uint32_t *elems_used)
{
  GtBitsequence ret = 0,
                elem = 0,
                part_elem = 0,
                num_elems = 0;

  elem = editscript_space_get_next(es, pos);
  (*elems_used)++;
  /* first bit not set, the value itself. */
  if ((elem & GT_EDITSCRIPT_FIRSTMASK(es)) == 0) {
    return elem;
  }
  /* first bit is set, cosecutive 1-bits represent number of elements to read */
  while (elem == GT_EDITSCRIPT_FULLMASK(es)) {
    num_elems += es->entry_size;
    elem = editscript_space_get_next(es, pos);
    (*elems_used)++;
  }
  /* elem is not full with 1 bits, but some most significant bits are set equal
     to number of elements to read, iterate over 1 bits, read elements of number
     while we do so. */
  while ((elem & GT_EDITSCRIPT_FIRSTMASK(es)) != 0) {
    elem <<= 1;
    part_elem = editscript_space_get_next(es, pos);
    (*elems_used)++;
    ret <<= es->entry_size;
    ret |= part_elem;
  }
  /* more elements to read as has been indicated by full 1-bit elems from above
     */
  while (num_elems != 0) {
    num_elems--;
    elem = editscript_space_get_next(es, pos);
    (*elems_used)++;
    ret <<= es->entry_size;
    ret |= elem;
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xceb8d
movq %rax, %r12
incl (%rbx)
movb 0x15(%r15), %cl
leal -0x1(%rcx), %eax
movzbl %al, %eax
btq %rax, %r12
jae 0xcec84
xorl %r13d, %r13d
pushq $-0x1
popq %rbp
movq %rbp, %rax
shlq %cl, %rax
xorq %r12, %rax
cmpq $-0x1, %rax
jne 0xcec3b
movzbl %cl, %eax
addq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xceb8d
movq %rax, %r12
incl (%rbx)
movb 0x15(%r15), %cl
jmp 0xcec10
xorl %ebp, %ebp
decb %cl
movzbl %cl, %eax
btq %rax, %r12
jae 0xcec7b
addq %r12, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xceb8d
incl (%rbx)
movb 0x15(%r15), %cl
shlq %cl, %rbp
orq %rax, %rbp
jmp 0xcec3d
movq %r15, %rdi
movq %r14, %rsi
callq 0xceb8d
incl (%rbx)
movb 0x15(%r15), %cl
shlq %cl, %rbp
orq %rax, %rbp
subq $0x1, %r13
jae 0xcec64
movq %rbp, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xced95
movq %rdi, %rbx
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0x10(%rsp)
movl 0xc(%rdi), %eax
testl %eax, %eax
je 0xced7d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl %eax, 0x4(%rsp)
callq 0xceb8d
movq %rax, %r12
movl 0x4(%rsp), %eax
leaq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %r14
xorl %r13d, %r13d
cmpl %eax, %r14d
jae 0xced80
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xcebdc
addq %rax, %r13
movq %rbx, %rbp
movzbl 0x14(%rbx), %r15d
leaq 0x2(%r15), %rax
xorl %ebx, %ebx
cmpq %rax, %r12
movl 0x4(%rsp), %eax
setne %bl
movl 0x8(%rsp), %r14d
cmpl %eax, %r14d
movl %eax, %ecx
cmoval %r14d, %ecx
movl %ecx, 0xc(%rsp)
cmpl %eax, %r14d
jae 0xced62
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq 0xceb8d
movq %rax, %r12
cmpq %r15, %rax
ja 0xced69
addq %rbx, %r13
incl %r14d
movl 0x4(%rsp), %eax
jmp 0xced3c
movl 0xc(%rsp), %r14d
jmp 0xced70
incl %r14d
movl 0x4(%rsp), %eax
movl %r14d, 0x8(%rsp)
movq %rbp, %rbx
jmp 0xcecf4
xorl %r13d, %r13d
movl 0x10(%rbx), %eax
addq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3691cc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21626d(%rip), %rsi    # 0x2e5013
leaq 0x24cd15(%rip), %rdx    # 0x31bac2
leaq 0x24cc22(%rip), %rcx    # 0x31b9d6
leaq 0x24cafd(%rip), %r8     # 0x31b8b8
movl $0x18a, %r9d            # imm = 0x18A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xcee8d
movq %rdi, %rbx
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0x10(%rsp)
movl 0xc(%rdi), %ebp
testl %ebp, %ebp
je 0xcee75
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xceb8d
leaq 0xc(%rsp), %rax
movl $0x1, (%rax)
pushq $0x1
popq %r15
xorl %r12d, %r12d
cmpl %ebp, %r15d
jae 0xcee78
movq %rbx, %rdi
movq %r14, %rsi
leaq 0xc(%rsp), %rdx
callq 0xcebdc
addq %rax, %r12
movl 0xc(%rsp), %r13d
cmpl %ebp, %r13d
movl %ebp, %r15d
cmoval %r13d, %r15d
cmpl %ebp, %r13d
jae 0xcee6e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xceb8d
movzbl 0x14(%rbx), %ecx
cmpq %rcx, %rax
ja 0xcee68
adcq $0x0, %r12
incl %r13d
jmp 0xcee46
incl %r13d
movl %r13d, %r15d
movl %r15d, 0xc(%rsp)
jmp 0xcee1f
xorl %r12d, %r12d
movl 0x10(%rbx), %eax
addq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3690d4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x216175(%rip), %rsi    # 0x2e5013
leaq 0x24cc1d(%rip), %rdx    # 0x31bac2
leaq 0x24cb47(%rip), %rcx    # 0x31b9f3
leaq 0x24ca05(%rip), %r8     # 0x31b8b8
movl $0x1aa, %r9d            # imm = 0x1AA
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xcedcd
movq %rax, %rbx
movq (%r13), %rax
testq %rax, %rax
je 0xcf875
cmpq (%rbp), %rbx
jbe 0xcf8a7
movq %rbx, (%rbp)
leaq 0x24c354(%rip), %rdi    # 0x31bbd4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x92a82
movq (%r13), %rdi
movq (%rbp), %rsi
leaq 0x24c01f(%rip), %rdx    # 0x31b8b8
movl $0x2b6, %ecx            # imm = 0x2B6
callq 0x93472
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 0xcf543
cmpq %rbx, %rax
jne 0xcf8db
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x368686(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x215727(%rip), %rsi    # 0x2e5013
leaq 0x24c2ee(%rip), %rdx    # 0x31bbe1
leaq 0x24c2f9(%rip), %rcx    # 0x31bbf3
leaq 0x24bfb7(%rip), %r8     # 0x31b8b8
movl $0x2bc, %r9d            # imm = 0x2BC
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0xcf975
leaq 0x2453d(%rip), %rcx     # 0xf3eb0
jmp 0xcf996
leaq 0x24bf3c(%rip), %rdx    # 0x31b8b8
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
movl $0x2f1, %ecx            # imm = 0x2F1
callq 0x9334a
leaq 0x2455a(%rip), %rcx     # 0xf3eed
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcf9a5
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/editscript.c
// Function: editscript_io_fp
static GtEditscript *editscript_io_fp(GtEditscript *editscript, FILE *fp,
                                      GtError *err, GtIOFunc io_func)
{
  int had_err = 0;
  GtUword bits;

  had_err = EDITSCRIPT_IO_ONE(&editscript->entry_size);
  if (!had_err)
    had_err = EDITSCRIPT_IO_ONE(&editscript->trailing_matches);
  if (!had_err)
    had_err = EDITSCRIPT_IO_ONE(&editscript->del);
  if (!had_err)
    had_err = EDITSCRIPT_IO_ONE(&editscript->num_elems);
  if (!had_err && editscript->num_elems != 0) {
    bits = (GtUword) editscript->num_elems * (GtUword) editscript->entry_size;
    editscript->size = (uint32_t) (bits / (GT_INTWORDSIZE));
    if (bits % GT_INTWORDSIZE) {
      editscript->size++;
    }

    editscript->space =
      gt_realloc(editscript->space,
                 editscript->size * sizeof (*(editscript->space)));
    had_err = io_func(editscript->space,
                      sizeof (*(editscript->space)),
                      (size_t) (editscript->size),
                      fp, err);
  }

  if (had_err) {
    gt_editscript_delete(editscript);
    editscript = NULL;
  }
  return(editscript);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
addq $0x15, %rdi
pushq $0x1
popq %rdx
movq %rdx, %rsi
movq %r12, %rcx
movq %r15, %r8
callq *%r14
testl %eax, %eax
jne 0xcfa19
leaq 0x10(%rbx), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
movq %r15, %r8
callq *%r14
testl %eax, %eax
jne 0xcfa19
leaq 0x14(%rbx), %rdi
pushq $0x1
popq %rdx
movq %rdx, %rsi
movq %r12, %rcx
movq %r15, %r8
callq *%r14
testl %eax, %eax
jne 0xcfa19
leaq 0xc(%rbx), %r13
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq *%r14
testl %eax, %eax
je 0xcfa30
movq %rbx, %rdi
callq 0xce497
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl (%r13), %eax
testq %rax, %rax
je 0xcfa23
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 0x24be55(%rip), %rdx    # 0x31b8b8
movl $0x2e0, %ecx            # imm = 0x2E0
callq 0x93472
movq %rax, (%rbx)
movl 0x8(%rbx), %edx
pushq $0x8
popq %rsi
movq %rax, %rdi
movq %r12, %rcx
movq %r15, %r8
callq *%r14
testl %eax, %eax
jne 0xcfa19
jmp 0xcfa23
// File: /workspace/github_c_makefile_star2_O2/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 0x24bba3(%rip), %rsi    # 0x31b8b8
pushq $0x18
popq %rdi
movl $0x344, %edx            # imm = 0x344
callq 0x93160
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_O2/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movb %sil, 0x10(%rdi)
leaq 0x8(%rdi), %r14
movl %esi, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcfd6f
movl 0x10(%rbx), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd0e38
andl $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/editscript.c
// Function: editscript_space_add_next
static inline void editscript_space_add_next(GtEditscript *es,
                                             GtEditscriptPos *fillpos,
                                             GtBitsequence elem)
{
  uint32_t cur_word = fillpos->cur_word,
           remaining = fillpos->bitsleft,
           bits2store = (uint32_t) es->entry_size;
  if (es->size == 0) {
    es->size = (uint32_t) (GT_INTWORDSIZE / es->entry_size) + 1U;
    es->space = gt_malloc(es->size * sizeof (*es->space));
    es->space[0] = 0;
  }
  es->num_elems++;
  if (remaining > bits2store) {
    es->space[cur_word] |= elem << (remaining - bits2store);
    remaining -= bits2store;
  }
  else {
    if (cur_word + 1 >= es->size) {
      es->size += (GT_INTWORDSIZE / es->entry_size) + 1U;
      es->size *= 1.2;
      es->space = gt_realloc(es->space, es->size * sizeof (*(es->space)));
    }
    es->space[cur_word] |= elem >> (bits2store - remaining);
    cur_word++;
    es->space[cur_word] = 0;
    bits2store -= remaining;
    remaining = (uint32_t) GT_INTWORDSIZE;
    /* this has to be checked because (uint64_t << 64) is not defined */
    if (bits2store != 0) {
      es->space[cur_word] |= elem << (remaining - bits2store);
      remaining -= bits2store;
    }
  }
  fillpos->cur_word = cur_word;
  fillpos->bitsleft = remaining;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %r12d
movl 0x4(%rsi), %r13d
movzbl 0x15(%rdi), %ebp
cmpl $0x0, 0x8(%rdi)
jne 0xcfdbe
movb $0x40, %al
movzbl %al, %eax
divb %bpl
incb %al
movzbl %al, %edi
movl %edi, 0x8(%r15)
shll $0x3, %edi
leaq 0x24bb09(%rip), %rsi    # 0x31b8b8
pushq $0x6f
popq %rdx
callq 0x93160
movq %rax, (%r15)
andq $0x0, (%rax)
incl 0xc(%r15)
movl %r13d, %eax
movq (%r15), %rdi
subl %ebp, %eax
jbe 0xcfdda
movl %eax, %ecx
shlq %cl, %r14
orq %r14, (%rdi,%r12,8)
jmp 0xcfe60
movl %r13d, 0x4(%rsp)
movl %r12d, %r13d
incl %r13d
movl 0x8(%r15), %ecx
cmpl %ecx, %r13d
jb 0xcfe2f
movb $0x40, %al
movzbl %al, %eax
divb 0x15(%r15)
movzbl %al, %eax
addl %ecx, %eax
incl %eax
cvtsi2sd %rax, %xmm0
mulsd 0x217f0d(%rip), %xmm0   # 0x2e7d18
cvttsd2si %xmm0, %rax
movl %eax, 0x8(%r15)
movl %eax, %esi
shlq $0x3, %rsi
leaq 0x24ba97(%rip), %rdx    # 0x31b8b8
pushq $0x7b
popq %rcx
callq 0x93472
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
andq $0x0, (%rdi,%rdx,8)
pushq $0x40
popq %rax
subl %esi, %ebp
je 0xcfe5d
subl %ebp, %eax
negl %ebp
movl %ebp, %ecx
shlq %cl, %r14
movq %r14, (%rdi,%rdx,8)
movl %r13d, %r12d
movl %r12d, (%rbx)
movl %eax, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd0f85
movq %rdi, %rbx
callq 0x9580f
movl %eax, %r12d
leaq -0x1(,%r12,2), %rdi
callq 0x5e0b0
movq %rax, %r14
xorl %r15d, %r15d
cmpq %r15, %r12
je 0xd0f76
btq %r15, %rbx
jae 0xd0f71
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e143
incq %r15
jmp 0xd0f5b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x366fdc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21407d(%rip), %rsi    # 0x2e5013
leaq 0x2818cd(%rip), %rdx    # 0x35286a
leaq 0x24b095(%rip), %rcx    # 0x31c039
leaq 0x24b0a4(%rip), %r8     # 0x31c04f
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x24b08c(%rip), %rsi    # 0x31c04f
pushq $0x20
popq %rdi
pushq $0x33
popq %rdx
callq 0x93160
andl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x1, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd106f
cmpl $0x0, (%rdi)
je 0xd1038
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rax
movzbl %sil, %esi
leaq (%rsi,%rax,2), %rax
movq %rax, 0x18(%rdi)
incq %rcx
movq %rcx, 0x8(%rdi)
cmpq 0x10(%rdi), %rcx
jne 0xd1055
movq %rax, (%rdx)
andl $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 0xd104e
testq %rax, %rax
je 0xd1059
movl $0x1, (%rdi)
jmp 0xd1055
incq %rax
movq %rax, 0x10(%rdi)
pushq $0x1
popq %rax
retq
pushq $0x1
popq %rax
movq %rax, (%rdx)
andl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
jmp 0xd1035
pushq %rax
movq 0x366ef1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x213f92(%rip), %rsi    # 0x2e5013
leaq 0x24afe2(%rip), %rdx    # 0x31c06a
leaq 0x24afe0(%rip), %rcx    # 0x31c06f
leaq 0x24afb9(%rip), %r8     # 0x31c04f
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/elias_gamma.c
// Function: gt_elias_gamma_unit_test
int gt_elias_gamma_unit_test(GtError *err)
{
  int stat = -1,
      had_err = 0;
  GtUword idx,
                idx_j,
                unit_test_x_size = 100UL,
                number = unit_test_x_size + 1;
  GtBittab *code;
  GtEliasGammaBitwiseDecoder *egbd = gt_elias_gamma_bitwise_decoder_new();

  for (idx = 1UL; idx <= unit_test_x_size; idx++) {
    code = gt_elias_gamma_encode(idx);
    for (idx_j = gt_bittab_size(code) - 1; idx_j != 0 ; idx_j--) {
      if (gt_bittab_bit_is_set(code, idx_j))
        stat = gt_elias_gamma_bitwise_decoder_next(egbd, true, &number);
      else
        stat = gt_elias_gamma_bitwise_decoder_next(egbd, false, &number);
      gt_ensure(stat == 1);
    }

    if (gt_bittab_bit_is_set(code, idx_j))
      stat = gt_elias_gamma_bitwise_decoder_next(egbd, true, &number);
    else
      stat = gt_elias_gamma_bitwise_decoder_next(egbd, false, &number);
    gt_ensure(stat == 0);
    gt_ensure(number == idx);
    gt_bittab_delete(code);
  }
  gt_elias_gamma_bitwise_decoder_delete(egbd);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movq $0x65, (%r14)
pushq $0x1
popq %r15
callq 0xd0fbb
movq %rax, %r12
xorl %r13d, %r13d
cmpq $0x65, %r15
je 0xd1203
movq %r15, %rdi
callq 0xd0f30
movq %rax, %rbp
movq %rax, %rdi
callq 0x5e96c
movq %rax, %rsi
decq %rsi
movq %rsi, %rbx
movq %rbp, %rdi
subq $0x1, %rbx
jb 0xd1165
callq 0x5e839
movzbl %al, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0xd0ff5
orl %r13d, %eax
movq %rbx, %rsi
jne 0xd1109
movq 0x8(%rsp), %rdi
leaq 0x22d2b9(%rip), %rsi    # 0x2fe3f2
leaq 0x2536fb(%rip), %rdx    # 0x32483b
leaq 0x24af4c(%rip), %rcx    # 0x31c093
leaq 0x24af01(%rip), %r8     # 0x31c04f
pushq $0x79
popq %r9
xorl %eax, %eax
callq 0x89dbb
incq %rbx
movq %rbx, %rsi
pushq $-0x1
popq %r13
jmp 0xd1103
xorl %esi, %esi
callq 0x5e839
movzbl %al, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0xd0ff5
testl %r13d, %r13d
jne 0xd11b7
testl %eax, %eax
je 0xd11b7
movq 0x8(%rsp), %rdi
leaq 0x22d263(%rip), %rsi    # 0x2fe3f2
leaq 0x25395f(%rip), %rdx    # 0x324af5
leaq 0x24aef6(%rip), %rcx    # 0x31c093
leaq 0x24aeab(%rip), %r8     # 0x31c04f
movl $0x80, %r9d
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %r13
jmp 0xd11ca
testl %r13d, %r13d
pushq $-0x1
popq %r13
jne 0xd11ca
xorl %r13d, %r13d
cmpq %r15, 0x10(%rsp)
jne 0xd11da
movq %rbp, %rdi
callq 0x5ecf6
incq %r15
jmp 0xd10e3
movq 0x8(%rsp), %rdi
leaq 0x22d20c(%rip), %rsi    # 0x2fe3f2
leaq 0x24aebf(%rip), %rdx    # 0x31c0ac
leaq 0x24ae9f(%rip), %rcx    # 0x31c093
leaq 0x24ae54(%rip), %r8     # 0x31c04f
movl $0x81, %r9d
jmp 0xd11aa
movq %r12, %rdi
callq 0xd10a6
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
leaq 0x24aea0(%rip), %rdx    # 0x31c0c8
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
movl $0x345, %ecx            # imm = 0x345
callq 0x9334a
movq %rax, %rbx
andq $0x0, (%rax)
andw $0x0, 0x18(%rax)
andq $0x0, 0x10(%rax)
callq 0xd1257
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd2e02
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x29710f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd2cc3
leaq 0x24941a(%rip), %rsi    # 0x31c0c8
movl $0x5ed, %edx            # imm = 0x5ED
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0xd2dd7
movq %rbx, (%rsp)
movq 0x40(%rbx), %r13
xorl %ebp, %ebp
leaq 0x2493e7(%rip), %r15    # 0x31c0c8
cmpq %r13, %rbp
je 0xd2dbf
imulq $0xc8, %rbp, %r12
leaq (%r14,%r12), %rbx
movq 0x8(%r14,%r12), %rdi
callq 0xf09fc
movq 0x10(%r14,%r12), %rdi
callq 0xf09fc
movq 0x40(%r14,%r12), %rdi
movq %r15, %rsi
movl $0x5d2, %edx            # imm = 0x5D2
callq 0x936f9
movq 0x30(%r14,%r12), %rdi
testq %rdi, %rdi
je 0xd2d4d
xorl %r12d, %r12d
cmpq 0x68(%rbx), %r12
jae 0xd2d40
movq (%rdi,%r12,8), %rdi
callq 0x9082d
incq %r12
movq 0x30(%rbx), %rdi
jmp 0xd2d28
movq %r15, %rsi
movl $0x5d6, %edx            # imm = 0x5D6
callq 0x936f9
movq 0x28(%rbx), %rdi
callq 0x9082d
movq 0x20(%rbx), %rdi
callq 0x9082d
movq 0x38(%rbx), %rdi
callq 0x6e064
cmpq $0x0, (%rbx)
je 0xd2dae
xorl %r12d, %r12d
cmpq 0x68(%rbx), %r12
jae 0xd2d9e
cmpq 0x50(%rbx), %r12
jae 0xd2d8d
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0x5e839
testb %al, %al
jne 0xd2d99
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0xf09fc
incq %r12
jmp 0xd2d71
movq (%rbx), %rdi
movq %r15, %rsi
movl $0x5e2, %edx            # imm = 0x5E2
callq 0x936f9
movq 0x18(%rbx), %rdi
callq 0x5ecf6
incq %rbp
jmp 0xd2ce1
leaq 0x249302(%rip), %rsi    # 0x31c0c8
movq %r14, %rdi
movl $0x5e6, %edx            # imm = 0x5E6
callq 0x936f9
movq (%rsp), %rbx
movq 0x28(%rbx), %rdi
callq 0x1148a7
leaq 0x2492e1(%rip), %rsi    # 0x31c0c8
movq %rbx, %rdi
movl $0x5f0, %edx            # imm = 0x5F0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd3cb2
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd3d52
testq %rax, %rax
je 0xd3c7c
incq (%rax)
xorl %eax, %eax
jmp 0xd3caa
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq $0x1, 0x8(%rsi)
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x8ff07
testl %eax, %eax
jne 0xd3ca7
movq (%rsp), %rax
movq $0x1, 0x8(%rax)
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x3642af(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x211350(%rip), %rsi    # 0x2e5013
leaq 0x248aa5(%rip), %rdx    # 0x31c76f
leaq 0x248ab0(%rip), %rcx    # 0x31c781
leaq 0x2483f0(%rip), %r8     # 0x31c0c8
movl $0x134, %r9d            # imm = 0x134
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_digits_per_value
static unsigned encdesc_digits_per_value(GtUword value,
                                         GtUword base)
{
  if (value > 0) {
    double log_val, log_base;
    log_val = log((double) value);
    log_base = log((double) base);
    return (unsigned) (floor(log_val / log_base )) + 1U;
  }
  else
    return 1U;
}

// Assembly:
testq %rdi, %rdi
je 0xd3d4d
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %xmm1
punpckldq 0x213bdc(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x213be4(%rip), %xmm1   # 0x2e78f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x175e0
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %rbx, %xmm0
callq 0x175e0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x17cc0
cvttsd2si %xmm0, %rax
incl %eax
addq $0x10, %rsp
popq %rbx
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd3d91
addq 0x8(%rax), %rsi
callq 0xd3d52
testq %rax, %rax
je 0xd3d8d
movq (%rax), %rax
jmp 0xd3d8f
xorl %eax, %eax
popq %rcx
retq
movq 0x3641d0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x211271(%rip), %rsi    # 0x2e5013
leaq 0x248a3d(%rip), %rdx    # 0x31c7e6
leaq 0x248a4b(%rip), %rcx    # 0x31c7fb
leaq 0x248311(%rip), %r8     # 0x31c0c8
movl $0x38a, %r9d            # imm = 0x38A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xd3de7
callq 0xd3d52
testq %rax, %rax
je 0xd3de3
movq (%rax), %rax
jmp 0xd3de5
xorl %eax, %eax
popq %rcx
retq
movq 0x36417a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21121b(%rip), %rsi    # 0x2e5013
leaq 0x248a20(%rip), %rdx    # 0x31c81f
leaq 0x248a29(%rip), %rcx    # 0x31c82f
leaq 0x2482bb(%rip), %r8     # 0x31c0c8
movl $0x39d, %r9d            # imm = 0x39D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/encdesc.c
// Function: prepare_generic
static inline void prepare_generic(EncdescWriteInfo *info,
                                   unsigned length,
                                   GtBitsequence code)
{
  EncdescCode *this_code;

  GT_GETNEXTFREEINARRAY(this_code, info->codes, EncdescCode,
                        GT_ENCDESC_ARRAY_RESIZE);

  this_code->length = length;
  this_code->code = code;

  info->total_bits_prepared += this_code->length;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rcx), %rsi
cmpq %rsi, 0x10(%rcx)
jae 0xd43ef
movq (%rcx), %rax
jmp 0xd4413
addq $0x32, %rsi
movq %rsi, 0x8(%rcx)
movq (%rcx), %rdi
shlq $0x4, %rsi
leaq 0x247cc3(%rip), %rdx    # 0x31c0c8
pushq $0x3d
popq %rcx
callq 0x93472
movq (%rbx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0xd443b
movq 0x10(%rcx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10(%rcx)
shlq $0x4, %rdx
movl %ebp, 0x8(%rax,%rdx)
movq %r14, (%rax,%rdx)
movl %ebp, %eax
addq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x363b26(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x210bc7(%rip), %rsi    # 0x2e5013
leaq 0x2484f0(%rip), %rdx    # 0x31c943
leaq 0x2484d9(%rip), %rcx    # 0x31c933
leaq 0x247c67(%rip), %r8     # 0x31c0c8
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_read_bits
static inline int encdesc_read_bits(GtBitInStream *instream,
                                    unsigned bits_to_read,
                                    GtBitsequence *bitseq,
                                    GtError *err) {
  int had_err = 0;
  unsigned readbits;
  bool bit;

  for (readbits = 0, *bitseq = 0;
       !had_err && readbits < bits_to_read;
       readbits++) {
    *bitseq = *bitseq << 1;
    if (gt_bitinstream_get_next_bit(instream,
                                    &bit) != 1) {
      gt_error_set(err, "could not get next bit");
      had_err = -1;
    }
    else if (bit)
      *bitseq = *bitseq | (GtBitsequence) 1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
andq $0x0, (%rdx)
leaq 0x7(%rsp), %r12
xorl %eax, %eax
xorl %r13d, %r13d
testl %eax, %eax
jne 0xd44d9
cmpl %ebp, %r13d
jae 0xd44d9
shlq (%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x29705d
cmpl $0x1, %eax
jne 0xd44c0
xorl %eax, %eax
cmpb $0x1, 0x7(%rsp)
jne 0xd44d4
orb $0x1, (%r14)
jmp 0xd44d4
movq %rbx, %rdi
leaq 0x2486d6(%rip), %rsi    # 0x31cba0
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
incl %r13d
jmp 0xd4495
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq