LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/text_width_calculator_cairo.c
// Function: gt_text_width_calculator_cairo_get_text_width
double gt_text_width_calculator_cairo_get_text_width(GtTextWidthCalculator *twc,
                                                     const char *text,
                                                     GT_UNUSED GtError *err)
{
  GtTextWidthCalculatorCairo *twcc;
  PangoRectangle rect;
  gt_assert(twc && text);
  twcc = gt_text_width_calculator_cairo_cast(twc);

  /* redo layout */
  pango_layout_set_text(twcc->layout, text, -1);

  /* get extents */
  pango_layout_get_pixel_extents(twcc->layout, &rect, NULL);

  if (twcc->style)
    cairo_restore(twcc->context);
  gt_assert(gt_double_smaller_double(0, rect.width));
  return rect.width;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x55166
movq %rsi, %r14
testq %rsi, %rsi
je 0x55166
movq %rdi, %rbx
callq 0x55170
movq %rax, %rdi
movq %rbx, %rsi
callq 0x550b3
movq %rax, %rbx
movq 0x28(%rax), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xb1a0
movq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xb3c0
cmpq $0x0, 0x10(%rbx)
je 0x55143
movq 0x18(%rbx), %rdi
callq 0xba50
cvtsi2sdl 0x10(%rsp), %xmm1
xorps %xmm0, %xmm0
callq 0x7a42f
testb %al, %al
je 0x5516b
xorps %xmm0, %xmm0
cvtsi2sdl 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x18846
callq 0x1887d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/text_width_calculator_cairo.c
// Function: gt_text_width_calculator_cairo_class
const GtTextWidthCalculatorClass* gt_text_width_calculator_cairo_class(void)
{
  static const GtTextWidthCalculatorClass *twcc = NULL;
  gt_class_alloc_lock_enter();
  if (!twcc)
  {
    twcc = gt_text_width_calculator_class_new(
                                  sizeof (GtTextWidthCalculatorCairo),
                                  gt_text_width_calculator_cairo_get_text_width,
                                  gt_text_width_calculator_cairo_delete);
  }
  gt_class_alloc_lock_leave();
  return twcc;
}

// Assembly:
pushq %rax
callq 0x72367
cmpq $0x0, 0xfda2a(%rip)     # 0x152ba8
jne 0x5519f
leaq -0x9f(%rip), %rsi       # 0x550e8
leaq 0x1f(%rip), %rdx        # 0x551ad
movl $0x40, %edi
callq 0x54ee4
movq %rax, 0xfda09(%rip)     # 0x152ba8
callq 0x7237d
movq 0xfd9fd(%rip), %rax     # 0x152ba8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/text_width_calculator_cairo.c
// Function: gt_text_width_calculator_cairo_delete
void gt_text_width_calculator_cairo_delete(GtTextWidthCalculator *twc)
{
  GtTextWidthCalculatorCairo *twcc;
  if (!twc) return;
  twcc = gt_text_width_calculator_cairo_cast(twc);
  g_object_unref(twcc->layout);
  if (twcc->style)
    gt_style_delete(twcc->style);
  if (twcc->own_context)
  {
    cairo_destroy(twcc->context);
    cairo_surface_destroy(twcc->mysurf);
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x551f9
movq %rdi, %rbx
callq 0x55170
movq %rax, %rdi
movq %rbx, %rsi
callq 0x550b3
movq %rax, %rbx
movq 0x28(%rax), %rdi
callq 0xb9a0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x551e0
callq 0x53f50
cmpb $0x1, 0x38(%rbx)
jne 0x551f9
movq 0x18(%rbx), %rdi
callq 0xb8c0
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0xb7a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/track.c
// Function: gt_track_new
GtTrack* gt_track_new(GtStr *title, GtUword max_num_lines,
                      bool split_lines, GtLineBreaker *lb)
{
  GtTrack *track;
  gt_assert(title && lb);
  track = gt_calloc(1, sizeof (GtTrack));
  gt_assert(track);
  track->title = gt_str_ref(title);
  track->lines = gt_array_new(sizeof (GtLine*));
  track->max_num_lines = max_num_lines;
  track->split = split_lines;
  track->lb = lb;
  track->y_index = GT_UNDEF_UWORD;
  return track;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5540f
movq %rcx, %rbx
testq %rcx, %rcx
je 0x5540f
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x97935(%rip), %rdx     # 0xecce9
movl $0x1, %edi
movl $0x38, %esi
movl $0x2d, %ecx
callq 0x359a6
testq %rax, %rax
je 0x55414
movq %rax, %r12
movq %r15, %rdi
callq 0x3bcaf
movq %rax, (%r12)
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x30(%r12)
movq %r14, 0x8(%r12)
movb %bpl, 0x20(%r12)
movq %rbx, 0x18(%r12)
movq $-0x1, 0x28(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x188b4
callq 0x188eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/track.c
// Function: gt_track_insert_block
int gt_track_insert_block(GtTrack *track, GtBlock *block, GtError *err)
{
  GtLine *line = NULL;
  int had_err = 0;

  gt_assert(track && block);
  had_err = get_next_free_line(track, &line, block, err);
  if (!had_err)
  {
    if (line) {
      block = gt_block_ref(block);
      gt_line_insert_block(line, block);
      had_err = gt_line_breaker_register_block(track->lb, line, block, err);
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x555a6
movq %rsi, %r15
testq %rsi, %rsi
je 0x555a6
movq %rdx, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
callq 0x6f310
testq %rax, %rax
je 0x554d1
xorl %r12d, %r12d
leaq 0xf(%rsp), %rbp
movq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x6f037
movq (%rax), %r13
movq %r13, 0x10(%rsp)
movq 0x18(%r14), %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x8f1bb
testl %eax, %eax
jne 0x55597
cmpb $0x0, 0xf(%rsp)
je 0x55532
incq %r12
movq 0x30(%r14), %rdi
callq 0x6f310
cmpq %rax, %r12
jb 0x55488
cmpq $-0x1, 0x8(%r14)
je 0x554eb
movq 0x30(%r14), %rdi
callq 0x6f310
cmpq 0x8(%r14), %rax
jne 0x554eb
incq 0x10(%r14)
cmpb $0x0, 0x20(%r14)
je 0x5550f
callq 0x8e5ac
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x30(%r14), %rdi
movl $0x8, %edx
callq 0x6f240
jmp 0x55565
movq 0x30(%r14), %rdi
callq 0x6f310
testq %rax, %rax
je 0x5553b
movq 0x30(%r14), %rdi
xorl %esi, %esi
callq 0x6f037
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x55556
testq %r13, %r13
jne 0x5556f
xorl %eax, %eax
jmp 0x55597
callq 0x8e5ac
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x30(%r14), %rdi
movl $0x8, %edx
callq 0x6f240
movq 0x30(%r14), %rdi
callq 0x6f310
cmpq $0x1, %rax
jne 0x555b0
movq 0x10(%rsp), %r13
testq %r13, %r13
je 0x555ab
movq %r15, %rdi
callq 0x8a757
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x8e5e1
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x8f20f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x189c7
callq 0x18a37
callq 0x18a00
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/track.c
// Function: gt_track_sketch
int gt_track_sketch(GtTrack* track, GtCanvas *canvas, GtError *err)
{
  int i = 0, had_err = 0;
  gt_assert(track && canvas);
  had_err = gt_canvas_visit_track_pre(canvas, track, err);
  if (!had_err) {
    for (i = 0; i < gt_array_size(track->lines); i++) {
      had_err = gt_line_sketch(*(GtLine**) gt_array_get(track->lines, i),
                               canvas,
                               err);
      if (had_err)
        break;
    }
  }
  if (!had_err)
    had_err = gt_canvas_visit_track_post(canvas, track, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5565c
movq %rsi, %r15
testq %rsi, %rsi
je 0x5565c
movq %rdx, %rbx
movq %rdi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x4bef9
testl %eax, %eax
je 0x55603
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x30(%r14), %rdi
callq 0x6f310
testq %rax, %rax
je 0x55643
xorl %r12d, %r12d
movq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x8e649
testl %eax, %eax
jne 0x555f7
incq %r12
movq 0x30(%r14), %rdi
callq 0x6f310
cmpq %r12, %rax
ja 0x55614
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4bf22
callq 0x18aa7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/track.c
// Function: gt_track_delete
void gt_track_delete(GtTrack *track)
{
  GtUword i;
  if (!track) return;
  if (track->lb)
    gt_line_breaker_delete(track->lb);
  for (i = 0; i < gt_array_size(track->lines); i++)
    gt_line_delete(*(GtLine**) gt_array_get(track->lines, i));
  gt_array_delete(track->lines);
  gt_str_delete(track->title);
  gt_free(track);
}

// Assembly:
testq %rdi, %rdi
je 0x56872
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x56810
callq 0x8f14f
movq 0x30(%rbx), %rdi
callq 0x6f310
testq %rax, %rax
je 0x56846
xorl %r14d, %r14d
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x8f03c
incq %r14
movq 0x30(%rbx), %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x56821
movq 0x30(%rbx), %rdi
callq 0x6f768
movq (%rbx), %rdi
callq 0x3c87b
leaq 0x9648b(%rip), %rsi     # 0xecce9
movq %rbx, %rdi
movl $0x19e, %edx            # imm = 0x19E
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/lua-5.1.5/src/ldo.c
// Function: f_parser
static void f_parser (lua_State *L, void *ud) {
  int i;
  Proto *tf;
  Closure *cl;
  struct SParser *p = cast(struct SParser *, ud);
  int c = luaZ_lookahead(p->z);
  luaC_checkGC(L);
  tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
                                                             &p->buff, p->name);
  cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
  cl->l.p = tf;
  for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */
    cl->l.upvals[i] = luaF_newupval(L);
  setclvalue(L, L->top, cl);
  incr_top(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x5f3b7
movl %eax, %ebp
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x5f2d5
movq %rbx, %rdi
callq 0x56a4b
cmpl $0x1b, %ebp
leaq 0x10f(%rip), %rax       # 0x5f3ee
leaq 0x1da(%rip), %r8        # 0x5f4c0
cmoveq %rax, %r8
leaq 0x8(%r14), %rdx
movq (%r14), %rsi
movq 0x20(%r14), %rcx
movq %rbx, %rdi
callq *%r8
movq %rax, %r14
movzbl 0x70(%rax), %esi
movq 0x78(%rbx), %rdx
movq %rbx, %rdi
callq 0x5f029
movq %rax, %r15
movq %r14, 0x20(%rax)
cmpb $0x0, 0x70(%r14)
je 0x5f36d
xorl %r12d, %r12d
movl $0x28, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5c968
movq 0x20(%rbx), %rcx
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x28(%rcx)
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0xa, 0x8(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x28(%r15,%r12,8)
incq %r12
movzbl 0x70(%r14), %eax
cmpq %rax, %r12
jb 0x5f31f
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movl $0x6, 0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0x5f3a6
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
leal (%rax,%rax), %esi
testl %eax, %eax
cmovlel %ecx, %esi
movq %rbx, %rdi
callq 0x5ca36
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: testnext
static int testnext (LexState *ls, int c) {
  if (ls->t.token == c) {
    luaX_next(ls);
    return 1;
  }
  else return 0;
}

// Assembly:
xorl %eax, %eax
cmpl %esi, 0x10(%rdi)
jne 0x61c66
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0x61c4c
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x60d69
movl %eax, 0x10(%rbx)
jmp 0x61c60
leaq 0x10(%rbx), %rax
addq $0x20, %rbx
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl $0x11f, (%rbx)          # imm = 0x11F
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/lua-5.1.5/src/lparser.c
// Function: test_then_block
static int test_then_block (LexState *ls) {
  /* test_then_block -> [IF | ELSEIF] cond THEN block */
  int condexit;
  luaX_next(ls);  /* skip IF or ELSEIF */
  condexit = cond(ls);
  checknext(ls, TK_THEN);
  block(ls);  /* `then' part */
  return condexit;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0x61dbb
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x60d69
movl %eax, 0x10(%rbx)
jmp 0x61dcf
leaq 0x20(%rbx), %rax
leaq 0x10(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl $0x11f, (%rax)          # imm = 0x11F
movq %rbx, %rdi
callq 0x61e7e
movl %eax, %ebp
movq %rbx, %rdi
movl $0x112, %esi            # imm = 0x112
callq 0x61ebc
movq %rbx, %rdi
callq 0x61c67
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/lua-5.1.5/src/ldump.c
// Function: DumpString
static void DumpString(const TString* s, DumpState* D)
{
 if (s==NULL) /* also see current code in Lua 5.4 */
 {
  size_t size=0;
  DumpVar(size,D);
 }
 else
 {
  size_t size=s->tsv.len+1;		/* include trailing '\0' */
  DumpVar(size,D);
  DumpBlock(getstr(s),size,D);
 }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x651f2
movq %rdi, %r14
movq 0x10(%rdi), %rax
incq %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x65215
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
testl %eax, %eax
jne 0x65215
movq (%rsp), %rdx
addq $0x18, %r14
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %r14, %rsi
jmp 0x6520f
movq $0x0, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x65215
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/lua-5.1.5/src/lapi.c
// Function: luaB_corunning
LUA_API int lua_pushthread (lua_State *L) {
  lua_lock(L);
  setthvalue(L, L->top, L);
  api_incr_top(L);
  lua_unlock(L);
  return (G(L)->mainthread == L);
}

// Assembly:
movq 0x10(%rdi), %rax
movq %rdi, (%rax)
movl $0x8, 0x8(%rax)
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rcx
leaq 0x10(%rax), %rdx
movq %rdx, 0x10(%rdi)
cmpq %rdi, 0xb0(%rcx)
jne 0x680cb
movl $0x0, 0x18(%rax)
addq $0x20, %rax
movq %rax, 0x10(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_new
GtArray* gt_array_new(size_t size_of_elem)
{
  GtArray *a = gt_calloc(1, sizeof *a);
  gt_assert(size_of_elem);
  a->size_of_elem = size_of_elem;
  return a;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x7fff4(%rip), %rdx     # 0xeef7b
movl $0x1, %edi
movl $0x28, %esi
movl $0x2b, %ecx
callq 0x359a6
testq %rbx, %rbx
je 0x6efa6
movq %rbx, 0x18(%rax)
popq %rbx
retq
callq 0x18dd1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_clone
GtArray* gt_array_clone(const GtArray *a)
{
  GtArray *a_copy;
  gt_assert(a);
  a_copy = gt_malloc(sizeof (GtArray));
  a_copy->space = gt_malloc(a->next_free * a->size_of_elem);
  memcpy(a_copy->space, a->space, a->next_free * a->size_of_elem);
  a_copy->next_free = a_copy->allocated = a->next_free;
  a_copy->size_of_elem = a->size_of_elem;
  a_copy->reference_count = 0;
  return a_copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6f026
movq %rdi, %rbx
leaq 0x7ffbc(%rip), %r14     # 0xeef7b
movl $0x28, %edi
movq %r14, %rsi
movl $0x35, %edx
callq 0x35862
movq %rax, %r15
movq 0x18(%rbx), %rdi
imulq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x36, %edx
callq 0x35862
movq %rax, (%r15)
movq (%rbx), %rsi
movq 0x18(%rbx), %rdx
imulq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0xb520
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r15)
movq %rax, 0x8(%r15)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r15)
movl $0x0, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x18e08
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_rem
void gt_array_rem(GtArray *a, GtUword idx)
{
  GtUword i;
  gt_assert(a && idx < a->next_free);
  /* move elements */
  for (i = idx + 1; i < a->next_free; i++) {
    memcpy((char*) a->space + (i-1) * a->size_of_elem,
           (char*) a->space + i * a->size_of_elem,
           a->size_of_elem);
  }
  /* remove last (now duplicated) element */
  a->next_free--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6f0f9
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
jbe 0x6f0f9
leaq 0x1(%r14), %rcx
cmpq %rax, %rcx
jae 0x6f0ec
leaq 0x1(%r14), %r15
movq (%rbx), %rax
movq 0x18(%rbx), %rdx
movq %rdx, %rdi
imulq %r14, %rdi
addq %rax, %rdi
movq %rdx, %rsi
imulq %r15, %rsi
addq %rax, %rsi
callq 0xb520
movq 0x8(%rbx), %rax
addq $0x2, %r14
cmpq %rax, %r14
movq %r15, %r14
jb 0x6f0b8
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x18ee4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_rem_span
void gt_array_rem_span(GtArray *a, GtUword frompos, GtUword topos)
{
  GtUword i, len;
  gt_assert(a && frompos <= topos);
  gt_assert(frompos < a->next_free && topos < a->next_free);
  /* move elements */
  len = topos - frompos + 1;
  for (i = topos + 1; i < a->next_free; i++) {
    memcpy((char*) a->space + (i-len) * a->size_of_elem,
           (char*) a->space + i * a->size_of_elem,
           a->size_of_elem);
  }
  /* remove last (now duplicated) elements */
  a->next_free -= len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f16f
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %r12
subq %rsi, %r12
jb 0x6f16f
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %r14, %rax
jbe 0x6f174
incq %r14
cmpq %rax, %r14
jae 0x6f159
movq (%rbx), %rax
movq 0x18(%rbx), %rdx
movq %rdx, %rdi
imulq %r15, %rdi
addq %rax, %rdi
movq %rdx, %rsi
imulq %r14, %rsi
addq %rax, %rsi
callq 0xb520
incq %r14
movq 0x8(%rbx), %rax
incq %r15
jmp 0x6f128
notq %r12
addq %rax, %r12
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x18f52
callq 0x18f1b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_reverse
void gt_array_reverse(GtArray *a)
{
  char *front, *back, *tmp;
  gt_assert(a);
  tmp = gt_malloc(a->size_of_elem);
  for (front = a->space,
       back = (char*) a->space + (a->next_free-1) * a->size_of_elem;
       front < back; front += a->size_of_elem, back -= a->size_of_elem) {
    memcpy(tmp, front, a->size_of_elem);
    memcpy(front, back, a->size_of_elem);
    memcpy(back, tmp, a->size_of_elem);
  }
  gt_free(tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f216
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x7fde3(%rip), %rsi     # 0xeef7b
movl $0x7f, %edx
callq 0x35862
movq %rax, %r14
movq 0x8(%rbx), %r15
movq 0x18(%rbx), %rdx
decq %r15
imulq %rdx, %r15
testq %r15, %r15
jle 0x6f1f7
movq (%rbx), %r12
addq %r12, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0xb520
movq 0x18(%rbx), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xb520
movq 0x18(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb520
movq 0x18(%rbx), %rdx
addq %rdx, %r12
subq %rdx, %r15
cmpq %r15, %r12
jb 0x6f1bf
leaq 0x7fd7d(%rip), %rsi     # 0xeef7b
movq %r14, %rdi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x35c27
callq 0x18f89
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_add_elem
void gt_array_add_elem(GtArray *a, void *elem, size_t size_of_elem)
{
  gt_assert(a && elem);
  gt_assert(a->size_of_elem == size_of_elem);
  gt_assert(a->next_free <= a->allocated);
  /* make sure we have enough space */
  if ((a->next_free + 1) * size_of_elem > a->allocated) {
    a->space = gt_dynalloc(a->space, &a->allocated,
                           (a->next_free + 1) * size_of_elem);
  }
  /* add */
  memcpy((char*) a->space + a->next_free * size_of_elem, elem, size_of_elem);
  a->next_free++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6f2aa
movq %rsi, %r15
testq %rsi, %rsi
je 0x6f2aa
movq %rdx, %r14
movq %rdi, %rbx
cmpq %rdx, 0x18(%rdi)
jne 0x6f2af
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rcx
cmpq %rcx, %rdi
ja 0x6f2b4
leaq 0x1(%rdi), %rdx
imulq %r14, %rdx
movq (%rbx), %rax
cmpq %rcx, %rdx
jbe 0x6f28e
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x74134
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
imulq %r14, %rdi
addq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb520
incq 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x18ff9
callq 0x19032
callq 0x1906b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_add_array
void gt_array_add_array(GtArray *dest, const GtArray *src)
{
  GtUword i;
  gt_assert(dest && src && dest->size_of_elem == src->size_of_elem);
  for (i = 0; i < gt_array_size(src); i++)
    gt_array_add_elem(dest, gt_array_get(src, i), src->size_of_elem);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6f30b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x6f30b
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq 0x18(%rbx), %rax
jne 0x6f30b
cmpq $0x0, 0x8(%rbx)
je 0x6f305
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f037
movq 0x18(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x6f240
incq %r15
cmpq 0x8(%rbx), %r15
jb 0x6f2e2
popq %rbx
popq %r14
popq %r15
retq
callq 0x190a4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_cmp
int gt_array_cmp(const GtArray *array_a, const GtArray *array_b)
{
  gt_assert(gt_array_size(array_a) == gt_array_size(array_b));
  gt_assert(gt_array_elem_size(array_a) == gt_array_elem_size(array_b));
  return memcmp(array_a->space, array_b->space,
                array_a->size_of_elem * array_a->next_free);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x6f411
movq 0x8(%rbx), %rax
jmp 0x6f413
xorl %eax, %eax
testq %r14, %r14
je 0x6f41e
movq 0x8(%r14), %rcx
jmp 0x6f420
xorl %ecx, %ecx
cmpq %rcx, %rax
jne 0x6f456
movq %rbx, %rdi
callq 0x6f31d
movq %rax, %r15
movq %r14, %rdi
callq 0x6f31d
cmpq %rax, %r15
jne 0x6f45b
movq (%r14), %rsi
movq 0x8(%rbx), %rdx
imulq 0x18(%rbx), %rdx
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb270
callq 0x192a5
callq 0x192de
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_equal
bool gt_array_equal(const GtArray *a, const GtArray *b, GtCompare cmpfunc)
{
  GtUword idx, size_a, size_b;
  int cmp;
  gt_assert(gt_array_elem_size(a) == gt_array_elem_size(b));
  size_a = gt_array_size(a);
  size_b = gt_array_size(b);
  if (size_a < size_b)
    return false;
  if (size_a > size_b)
    return false;
  for (idx = 0; idx < size_a; idx++) {
    cmp = cmpfunc(gt_array_get(a, idx), gt_array_get(b, idx));
    if (cmp != 0)
      return false;
  }
  return true;
}

// 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 0x6f31d
movq %rax, %r12
movq %r14, %rdi
callq 0x6f31d
cmpq %rax, %r12
jne 0x6f4ff
testq %r15, %r15
je 0x6f494
movq 0x8(%r15), %rbp
jmp 0x6f496
xorl %ebp, %ebp
testq %r14, %r14
je 0x6f4a1
movq 0x8(%r14), %rax
jmp 0x6f4a3
xorl %eax, %eax
cmpq %rax, %rbp
jne 0x6f4ea
testq %rbp, %rbp
je 0x6f4ee
decq %rbp
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x6f037
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x6f037
movq %r13, %rdi
movq %rax, %rsi
callq *%rbx
testl %eax, %eax
sete %al
jne 0x6f4f0
leaq 0x1(%r12), %rcx
cmpq %r12, %rbp
movq %rcx, %r12
jne 0x6f4b3
jmp 0x6f4f0
xorl %eax, %eax
jmp 0x6f4f0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19317
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_iterate
int gt_array_iterate(GtArray *a, GtArrayProcessor array_processor, void *info,
                  GtError *err)
{
  GtUword idx;
  int rval;
  gt_error_check(err);
  gt_assert(a && array_processor);
  for (idx = 0; idx < gt_array_size(a); idx++) {
    if ((rval = array_processor(gt_array_get(a, idx), info, err)))
      return rval;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x6f52a
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x6f575
testq %r12, %r12
je 0x6f570
testq %r15, %r15
je 0x6f570
cmpq $0x0, 0x8(%r12)
je 0x6f564
xorl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x6f037
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
testl %eax, %eax
jne 0x6f566
incq %r13
cmpq 0x8(%r12), %r13
jb 0x6f53f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x19389
callq 0x19350
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_iterate_reverse
int gt_array_iterate_reverse(GtArray *a, GtArrayProcessor array_processor,
                             void *info, GtError *err)
{
  GtUword idx;
  int rval;
  gt_error_check(err);
  gt_assert(a && array_processor);
  for (idx = gt_array_size(a); idx > 0; idx--) {
    if ((rval = array_processor(gt_array_get(a, idx-1), info, err)))
      return rval;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x6f5a0
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x6f5e9
testq %r12, %r12
je 0x6f5e4
testq %r15, %r15
je 0x6f5e4
movq 0x8(%r12), %r13
decq %r13
cmpq $-0x1, %r13
je 0x6f5d8
movq %r12, %rdi
movq %r13, %rsi
callq 0x6f037
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
decq %r13
testl %eax, %eax
je 0x6f5b2
jmp 0x6f5da
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x193fb
callq 0x193c2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_prepend_array
void gt_array_prepend_array(GtArray *dest, const GtArray *src)
{
  GtUword i;
  gt_assert(dest && src && dest->size_of_elem == src->size_of_elem);
  if (!src->next_free)
    return; /* nothing to do */
  /* make sure <dest> is large enough */
  dest->space = gt_dynalloc(dest->space, &dest->allocated,
                            (dest->next_free + src->next_free) *
                            dest->size_of_elem);
  /* move elements in <dest> to the back */
  for (i = dest->next_free; i > 0; i--) {
    memcpy((char*) dest->space + (i-1+src->next_free) * dest->size_of_elem,
           (char*) dest->space + (i-1) * dest->size_of_elem,
           dest->size_of_elem);
  }
  /* copy <src> to the start of <dest> */
  memcpy((char*) dest->space, (char*) src->space,
         src->size_of_elem * src->next_free);
  dest->next_free += src->next_free;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6f690
movq %rsi, %r14
testq %rsi, %rsi
je 0x6f690
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x18(%r14), %rax
jne 0x6f690
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x6f68a
movq (%rbx), %rdi
leaq 0x10(%rbx), %rsi
addq 0x8(%rbx), %rdx
imulq %rax, %rdx
callq 0x74134
movq %rax, (%rbx)
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x6f66e
decq %r15
movq 0x8(%r14), %rdi
addq %r15, %rdi
movq (%rbx), %rax
movq 0x18(%rbx), %rdx
imulq %rdx, %rdi
addq %rax, %rdi
movq %rdx, %rsi
imulq %r15, %rsi
addq %rax, %rsi
callq 0xb520
addq $-0x1, %r15
jb 0x6f641
movq (%rbx), %rax
movq (%r14), %rsi
movq 0x8(%r14), %rdx
imulq 0x18(%r14), %rdx
movq %rax, %rdi
callq 0xb520
movq 0x8(%r14), %rax
addq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x19434
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_example
int gt_array_example(GT_UNUSED GtError *err)
{
  GtUword i;
  GtArray *a;

  gt_error_check(err);

  /* an example array use case */

  a = gt_array_new(sizeof (GtUword));
  for (i = 0; i < 100; i++) {
    gt_array_add(a, i);
    gt_assert(i == *(GtUword*) gt_array_get(a, i));
  }
  gt_assert(gt_array_size(a) == 100);
  gt_assert(*(GtUword*) gt_array_pop(a) == 99);
  gt_assert(gt_array_size(a) == 99);
  gt_array_delete(a);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x6f6b0
callq 0x34fea
testb %al, %al
jne 0x6f763
leaq 0x7f8c4(%rip), %rdx     # 0xeef7b
movl $0x1, %edi
movl $0x28, %esi
movl $0x2b, %ecx
callq 0x359a6
movq %rax, %rbx
movq $0x8, 0x18(%rax)
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f240
movq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f037
cmpq (%rax), %r15
jne 0x6f74f
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq $0x64, %rax
jb 0x6f6e2
testq %rbx, %rbx
je 0x6f754
cmpq $0x64, 0x8(%rbx)
jne 0x6f754
movq %rbx, %rdi
callq 0x6f072
cmpq $0x63, (%rax)
jne 0x6f759
cmpq $0x63, 0x8(%rbx)
jne 0x6f75e
movq %rbx, %rdi
callq 0x6f768
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x194a6
callq 0x19551
callq 0x194df
callq 0x19518
callq 0x1946d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: gt_array_delete
void gt_array_delete(GtArray *a)
{
  if (!a) return;
  if (a->reference_count) {
    a->reference_count--;
    return;
  }
  gt_free(a->space);
  gt_free(a);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f780
movq %rdi, %rbx
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0x6f788
decl %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0x7f7e9(%rip), %r14     # 0xeef7b
movq %r14, %rsi
movl $0x204, %edx            # imm = 0x204
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x205, %edx            # imm = 0x205
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array.c
// Function: iterate_test_func
static int iterate_test_func(void *value, void *info, GT_UNUSED GtError *err)
{
  GtUword *i;
  GtRange range;
  int had_err = 0;
  gt_error_check(err);
  i = (GtUword*) info;
  range = *(GtRange*) value;
  gt_ensure(range.start == *i + 1);
  gt_ensure(range.end == *i + 101);
  (*i)++;
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x7074a
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x707c3
movq (%rbx), %rcx
leaq 0x1(%rcx), %rax
cmpq %rax, (%r15)
jne 0x70789
addq $0x65, %rcx
xorl %eax, %eax
cmpq %rcx, 0x8(%r15)
je 0x707ba
leaq 0x729f0(%rip), %rsi     # 0xe3159
leaq 0x7f013(%rip), %rdx     # 0xef783
leaq 0x7efe4(%rip), %rcx     # 0xef75b
leaq 0x7e7fd(%rip), %r8      # 0xeef7b
movq %r14, %rdi
movl $0x133, %r9d            # imm = 0x133
jmp 0x707ae
leaq 0x729c9(%rip), %rsi     # 0xe3159
leaq 0x7efd6(%rip), %rdx     # 0xef76d
leaq 0x7efbd(%rip), %rcx     # 0xef75b
leaq 0x7e7d6(%rip), %r8      # 0xeef7b
movq %r14, %rdi
movl $0x132, %r9d            # imm = 0x132
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq (%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x195c3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/basename.c
// Function: gt_basename
char *gt_basename(const char *path)
{
  char *sbuf, *c;
  bool foundother = false;
  size_t i, pathlen;

  if (path != NULL)
    pathlen = strlen(path);
  else
    pathlen = 0;
  sbuf = gt_malloc(sizeof (char) * (pathlen + 2));
  if (path == NULL || *path == '\0') {
    strcpy(sbuf, ".");
    return sbuf;
  }
  strcpy(sbuf, path);
  for (c = sbuf + pathlen - 1; c >= sbuf; c--) {
    if (*c == GT_PATH_SEPARATOR) {
      if (foundother) {
        c++;
        for (i=0; c[i] != '\0'; i++)
          sbuf[i] = c[i];
        sbuf[i] = '\0';
        break;
      }
      if (c > sbuf)
        *c = '\0';
    }
    else
      foundother = true;
  }
  return sbuf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7083d
movq %rdi, %r14
callq 0xb260
movq %rax, %r15
leaq 0x2(%rax), %rdi
leaq 0x7efa9(%rip), %rsi     # 0xef799
movl $0x23, %edx
callq 0x35862
movq %rax, %rbx
cmpb $0x0, (%r14)
je 0x70856
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb600
leaq (%rbx,%r15), %rax
decq %rax
cmpq %rbx, %rax
jb 0x7085b
xorl %ecx, %ecx
movl %ecx, %edx
cmpb $0x2f, (%rax)
setne %cl
jne 0x70833
testb $0x1, %dl
jne 0x70864
cmpq %rbx, %rax
jbe 0x70833
movb $0x0, (%rax)
decq %rax
cmpq %rbx, %rax
jae 0x7081c
jmp 0x7085b
leaq 0x7ef55(%rip), %rsi     # 0xef799
movl $0x2, %edi
movl $0x23, %edx
callq 0x35862
movq %rax, %rbx
movw $0x2e, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movb 0x1(%rax), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x70880
movq %rbx, %rsi
movb %dl, (%rsi)
movb 0x2(%rax,%rcx), %dl
incq %rcx
incq %rsi
testb %dl, %dl
jne 0x70870
movb $0x0, (%rbx,%rcx)
jmp 0x7085b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_new
GtBittab* gt_bittab_new(GtUword num_of_bits)
{
  GtBittab *b;

  gt_assert(num_of_bits != 0);

  b = gt_malloc(sizeof (GtBittab));
  b->num_of_bits = num_of_bits;

  if (num_of_bits / (8UL * sizeof (GtUword)))
    b->tabsize = 1 + ((num_of_bits - 1) / (8UL * sizeof (GtUword)));
  else
    b->tabsize = 1UL;

  b->tabptr = gt_calloc(b->tabsize, sizeof (GtUword));

  return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x70d3b
movq %rdi, %rbx
leaq 0x7eb8a(%rip), %r14     # 0xef872
movl $0x18, %edi
movq %r14, %rsi
movl $0x2a, %edx
callq 0x35862
movq %rax, %r15
movq %rbx, 0x10(%rax)
leaq -0x1(%rbx), %rax
shrq $0x6, %rax
incq %rax
cmpq $0x40, %rbx
movl $0x1, %edi
cmovaeq %rax, %rdi
movq %rdi, 0x8(%r15)
movl $0x8, %esi
movq %r14, %rdx
movl $0x32, %ecx
callq 0x359a6
movq %rax, (%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x19633
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_complement
void gt_bittab_complement(GtBittab *dest, const GtBittab *src)
{
  GtUword i;

  gt_assert(dest && src && dest->num_of_bits == src->num_of_bits);

  for (i = 0; i < src->tabsize - 1; i++)
    dest->tabptr[i] = ~src->tabptr[i];

  /* the ``last'' bittab gets special treatment to prevent that unused bits
     become set. this could disturb subsequent gt_bittab_count_set_bits() calls.
   */
  dest->tabptr[src->tabsize - 1] = ~src->tabptr[src->tabsize - 1] &
                                   (~0UL >> (- src->num_of_bits +
                                             src->tabsize * 8UL *
                                             sizeof (GtUword)));
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70df7
testq %rsi, %rsi
je 0x70df7
movq 0x10(%rdi), %r8
cmpq 0x10(%rsi), %r8
jne 0x70df7
movq (%rsi), %rdx
cmpq $0x1, 0x8(%rsi)
movq (%rdi), %rax
jne 0x70dbb
xorl %edi, %edi
movl $0x40, %ecx
jmp 0x70de1
xorl %r8d, %r8d
movq (%rdx,%r8,8), %rcx
notq %rcx
movq %rcx, (%rax,%r8,8)
incq %r8
movq 0x8(%rsi), %rcx
leaq -0x1(%rcx), %rdi
cmpq %rdi, %r8
jb 0x70dbe
movq 0x10(%rsi), %r8
shlq $0x6, %rcx
movq (%rdx,%rdi,8), %rdx
notq %rdx
subl %r8d, %ecx
shlq %cl, %rdx
shrq %cl, %rdx
movq %rdx, (%rax,%rdi,8)
popq %rax
retq
callq 0x196d8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_equal
void gt_bittab_equal(GtBittab *dest, const GtBittab *src)
{
  GtUword i;
  gt_assert(dest && src && dest->num_of_bits == src->num_of_bits);
  for (i = 0; i < src->tabsize; i++)
    dest->tabptr[i] = src->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70e33
testq %rsi, %rsi
je 0x70e33
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x70e33
cmpq $0x0, 0x8(%rsi)
je 0x70e31
movq (%rsi), %rax
movq (%rdi), %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
cmpq 0x8(%rsi), %rdx
jb 0x70e20
popq %rax
retq
callq 0x1970f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_and
void gt_bittab_and(GtBittab *dest, const GtBittab *src1,
                   const GtBittab *src2)
{
  GtUword i;
  gt_assert(dest && src1 && src2);
  gt_assert(dest->num_of_bits == src1->num_of_bits);
  gt_assert(dest->num_of_bits == src2->num_of_bits);
  for (i = 0; i < src1->tabsize; i++)
    dest->tabptr[i] = src1->tabptr[i] & src2->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70e81
testq %rsi, %rsi
je 0x70e81
testq %rdx, %rdx
je 0x70e81
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x70e86
cmpq 0x10(%rdx), %rax
jne 0x70e8b
cmpq $0x0, 0x8(%rsi)
je 0x70e7f
movq (%rsi), %rax
movq (%rdx), %rcx
movq (%rdi), %rdx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
andq (%rax,%rdi,8), %r8
movq %r8, (%rdx,%rdi,8)
incq %rdi
cmpq 0x8(%rsi), %rdi
jb 0x70e6a
popq %rax
retq
callq 0x19746
callq 0x1977d
callq 0x197b4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_or
void gt_bittab_or(GtBittab *dest, const GtBittab *src1, const GtBittab *src2)
{
  GtUword i;
  gt_assert(dest && src1 && src2);
  gt_assert(dest->num_of_bits == src1->num_of_bits);
  gt_assert(dest->num_of_bits == src2->num_of_bits);
  for (i = 0; i < src1->tabsize; i++)
    dest->tabptr[i] = src1->tabptr[i] | src2->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70ed9
testq %rsi, %rsi
je 0x70ed9
testq %rdx, %rdx
je 0x70ed9
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x70ede
cmpq 0x10(%rdx), %rax
jne 0x70ee3
cmpq $0x0, 0x8(%rsi)
je 0x70ed7
movq (%rsi), %rax
movq (%rdx), %rcx
movq (%rdi), %rdx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
orq (%rax,%rdi,8), %r8
movq %r8, (%rdx,%rdi,8)
incq %rdi
cmpq 0x8(%rsi), %rdi
jb 0x70ec2
popq %rax
retq
callq 0x197eb
callq 0x19822
callq 0x19859
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_nand
void gt_bittab_nand(GtBittab *dest,
                  const GtBittab *minuend,
                  const GtBittab *subtrahend)
{
  GtUword i;
  gt_assert(dest && minuend && subtrahend);
  gt_assert(dest->num_of_bits == minuend->num_of_bits);
  gt_assert(minuend->num_of_bits == subtrahend->num_of_bits);
  for (i = 0; i < dest->tabsize; i++)
    dest->tabptr[i] = minuend->tabptr[i] & ~subtrahend->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70f34
testq %rsi, %rsi
je 0x70f34
testq %rdx, %rdx
je 0x70f34
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x70f39
cmpq 0x10(%rdx), %rax
jne 0x70f3e
cmpq $0x0, 0x8(%rdi)
je 0x70f32
movq (%rsi), %rax
movq (%rdx), %rcx
movq (%rdi), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %r8
notq %r8
andq (%rax,%rsi,8), %r8
movq %r8, (%rdx,%rsi,8)
incq %rsi
cmpq 0x8(%rdi), %rsi
jb 0x70f1a
popq %rax
retq
callq 0x19890
callq 0x198c7
callq 0x198fe
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_and_equal
void gt_bittab_and_equal(GtBittab *dest, const GtBittab *src)
{
  GtUword i;
  gt_assert(dest && src);
  gt_assert(dest->num_of_bits == src->num_of_bits);
  for (i = 0; i < dest->tabsize; i++)
    dest->tabptr[i] &= src->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70f7a
testq %rsi, %rsi
je 0x70f7a
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x70f7f
cmpq $0x0, 0x8(%rdi)
je 0x70f78
movq (%rsi), %rax
movq (%rdi), %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
andq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq 0x8(%rdi), %rdx
jb 0x70f67
popq %rax
retq
callq 0x19935
callq 0x1996e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_shift_left_equal
void gt_bittab_shift_left_equal(GtBittab *b)
{
  GtUword i, new_carry, old_carry = 0;
  gt_assert(b);
  for (i = 0; i < b->tabsize; i++) {
    new_carry = b->tabptr[i] & ((GtUword) 1 << (8UL * sizeof (GtUword) - 1));
    b->tabptr[i] = (b->tabptr[i] << 1) | old_carry;
    old_carry = new_carry >> (8UL * sizeof (GtUword) - 1);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70ff7
cmpq $0x0, 0x8(%rdi)
je 0x70ff5
movq (%rdi), %rax
xorl %edx, %edx
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rsi
leaq (%rdx,%rsi,2), %rdx
movq %rdx, (%rax,%rcx,8)
shrq $0x3f, %rsi
incq %rcx
movq %rsi, %rdx
cmpq 0x8(%rdi), %rcx
jb 0x70fd9
popq %rax
retq
callq 0x19a19
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_shift_right_equal
void gt_bittab_shift_right_equal(GtBittab *b)
{
  GtUword i, new_carry, old_carry = 0;
  gt_assert(b);
  for (i = b->tabsize; i > 0; i--) {
    new_carry = b->tabptr[i-1] & 1UL;
    b->tabptr[i-1] = (b->tabptr[i-1] >> 1) | old_carry;
    old_carry = new_carry << (8UL * sizeof (GtUword) - 1);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x71031
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x7102f
movq (%rdi), %rcx
xorl %edx, %edx
movq -0x8(%rcx,%rax,8), %rsi
movq %rsi, %rdi
shrq %rdi
orq %rdx, %rdi
movq %rdi, -0x8(%rcx,%rax,8)
shlq $0x3f, %rsi
movq %rsi, %rdx
decq %rax
jne 0x71010
popq %rax
retq
callq 0x19a52
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_unset
void gt_bittab_unset(GtBittab *b)
{
  GtUword i;
  gt_assert(b);
  for (i = 0; i < b->tabsize; i++)
    b->tabptr[i] = 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7105b
cmpq $0x0, 0x8(%rdi)
je 0x71059
movq (%rdi), %rax
xorl %ecx, %ecx
movq $0x0, (%rax,%rcx,8)
incq %rcx
cmpq 0x8(%rdi), %rcx
jb 0x71048
popq %rax
retq
callq 0x19a8b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_get_all_bitnums
void gt_bittab_get_all_bitnums(const GtBittab *b, GtArray *bitnums)
{
  GtUword i;
  gt_assert(b && bitnums);
  for (i = 0; i < b->num_of_bits; i++)
    if (gt_bittab_bit_is_set(b, i)) gt_array_add(bitnums, i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x710c9
movq %rsi, %rbx
testq %rsi, %rsi
je 0x710c9
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rdi)
je 0x710bf
xorl %esi, %esi
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x710ce
testb %al, %al
je 0x710ac
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f240
movq 0x8(%rsp), %rsi
incq %rsi
movq %rsi, 0x8(%rsp)
cmpq 0x10(%r14), %rsi
jb 0x71090
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x19ac4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_is_true
bool gt_bittab_is_true(const GtBittab *b)
{
  GtUword i;
  gt_assert(b);
  for (i = 0; i < b->tabsize; i++) {
    if (b->tabptr[i])
      return true;
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x71133
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x7112f
movq (%rdi), %rdx
movb $0x1, %al
cmpq $0x0, (%rdx)
jne 0x71131
movl $0x1, %esi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x71127
leaq 0x1(%rax), %rsi
cmpq $0x0, (%rdx,%rax,8)
je 0x71114
cmpq %rcx, %rax
setb %al
jmp 0x71131
xorl %eax, %eax
popq %rcx
retq
callq 0x19b36
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_cmp
bool gt_bittab_cmp(const GtBittab *b1, const GtBittab *b2)
{
  GtUword i;
  gt_assert(b1 && b2 && b1->num_of_bits == b2->num_of_bits);
  for (i = 0; i < b1->tabsize; i++) {
    if (b1->tabptr[i] != b2->tabptr[i])
      return false;
  }
  return true;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7118f
testq %rsi, %rsi
je 0x7118f
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x7118f
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x71187
movq (%rdi), %rcx
movq (%rsi), %rdx
movq (%rcx), %rsi
cmpq (%rdx), %rsi
jne 0x7118b
movl $0x1, %edi
movq %rdi, %rsi
cmpq %rdi, %rax
je 0x7117f
movq (%rcx,%rsi,8), %r8
leaq 0x1(%rsi), %rdi
cmpq (%rdx,%rsi,8), %r8
je 0x71169
cmpq %rax, %rsi
setae %al
jmp 0x7118d
movb $0x1, %al
jmp 0x7118d
xorl %eax, %eax
popq %rcx
retq
callq 0x19b6f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_get_first_bitnum
GtUword gt_bittab_get_first_bitnum(const GtBittab *b)
{
  GtUword i, rval = GT_UNDEF_UWORD;
  gt_assert(b);
  for (i = 0; i < b->num_of_bits; i++)
    if (gt_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x711e6
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x711d7
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x710ce
testb %al, %al
jne 0x711db
incq %r14
movq 0x10(%rbx), %rax
cmpq %rax, %r14
jb 0x711ba
jmp 0x711de
xorl %eax, %eax
jmp 0x711de
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19be1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_get_next_bitnum
GtUword gt_bittab_get_next_bitnum(const GtBittab *b,
                                        GtUword curnum)
{
  GtUword i, rval = GT_UNDEF_UWORD;

  gt_assert(b);
  gt_assert(curnum < b->num_of_bits);
  for (i = curnum + 1; i < b->num_of_bits; i++)
    if (gt_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x71238
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x10(%rdi)
jbe 0x7123d
incq %rbx
movq 0x10(%r14), %rax
cmpq %rax, %rbx
jae 0x71230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x710ce
movl %eax, %ecx
movq %rbx, %rax
testb %cl, %cl
je 0x71210
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19c8c
callq 0x19c53
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_show
void gt_bittab_show(const GtBittab *b, FILE *outfp)
{
  GtUword i;
  gt_assert(b && outfp);
  /* header line */
  for (i = 0; i < b->num_of_bits; i++)
    fprintf(outfp, ""GT_WU"", i % 10);
  gt_xfputc('\n', outfp);
  /* actual bits */
  for (i = 0; i < b->num_of_bits; i++) {
    if (gt_bittab_bit_is_set(b, i))
      gt_xfputc('1', outfp);
    else
      gt_xfputc('0', outfp);
  }
  gt_xfputc('\n', outfp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x7134e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7134e
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x712ff
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
leaq 0x70dde(%rip), %r15     # 0xe20ac
xorl %r12d, %r12d
movq %r12, %rax
mulq %r13
shrq $0x2, %rdx
andq $-0x2, %rdx
leaq (%rdx,%rdx,4), %rax
movq %r12, %rdx
subq %rax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb8d0
incq %r12
cmpq 0x10(%r14), %r12
jb 0x712d1
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3d29e
cmpq $0x0, 0x10(%r14)
je 0x71338
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x710ce
movzbl %al, %edi
orl $0x30, %edi
movq %rbx, %rsi
callq 0x3d29e
incq %r15
cmpq 0x10(%r14), %r15
jb 0x71316
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3d29e
callq 0x19cfe
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_example
int gt_bittab_example(GT_UNUSED GtError *err)
{
  GtUword bit;
  GtBittab *b;
  gt_error_check(err);

  b = gt_bittab_new(32);
  gt_bittab_set_bit(b, 8);
  gt_bittab_set_bit(b, 16);
  gt_bittab_set_bit(b, 24);

  /* a typical iterator loop */
  for (bit  = gt_bittab_get_first_bitnum(b);
       bit != gt_bittab_get_last_bitnum(b);
       bit  = gt_bittab_get_next_bitnum(b, bit)) {
    /* ... */
  }

  gt_bittab_delete(b);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x71365
callq 0x34fea
testb %al, %al
jne 0x713d0
movl $0x20, %edi
callq 0x70cd4
movq %rax, %rbx
movl $0x8, %esi
movq %rax, %rdi
callq 0x70d40
movl $0x10, %esi
movq %rbx, %rdi
callq 0x70d40
movl $0x18, %esi
movq %rbx, %rdi
callq 0x70d40
movq %rbx, %rdi
callq 0x711a4
movq %rax, %r14
movq %rbx, %rdi
callq 0x711eb
cmpq %rax, %r14
je 0x713be
movq %rbx, %rdi
movq %r14, %rsi
callq 0x711fb
jmp 0x713a1
movq %rbx, %rdi
callq 0x713d5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19d37