LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x3f2cb
movl %eax, %ebp
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x3f1f4
movq %rbx, %rdi
callq 0x3774d
cmpl $0x1b, %ebp
leaq 0x102(%rip), %rax       # 0x3f300
leaq 0x1b1(%rip), %r8        # 0x3f3b6
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 0x3ef88
movq %rax, %r15
movq %r14, 0x20(%rax)
xorl %r13d, %r13d
pushq $0x28
popq %r12
movzbl 0x70(%r14), %eax
cmpq %rax, %r13
jae 0x3f286
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x3cca9
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)
andl $0x0, 0x20(%rax)
movq %rax, 0x28(%r15,%r13,8)
incq %r13
jmp 0x3f23b
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 0x3f2b4
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x37621
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%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/external/lua-5.1.5/src/lundump.c
// Function: LoadInt
static int LoadInt(LoadState* S)
{
 int x;
 LoadVar(S,x);
 IF (x<0, "bad integer");
 return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x3f8cb
movl (%r14), %eax
testl %eax, %eax
js 0x3fa3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x974a0(%rip), %rsi     # 0xd6ee4
movq %rbx, %rdi
callq 0x3f938
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x43eac
movq %rdi, %r14
movq 0x10(%rdi), %rax
incq %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
pushq $0x8
popq %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x43e50
addq $0x18, %r14
movq (%r15), %rsi
movq %r14, %rdi
jmp 0x43eb8
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
pushq $0x8
popq %rsi
movq %rbx, %rdx
callq 0x43e50
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lua-5.1.5/src/lbaselib.c
// Function: load_aux
static int load_aux (lua_State *L, int status) {
  if (status == 0)  /* OK? */
    return 1;
  else {
    lua_pushnil(L);
    lua_insert(L, -2);  /* put before error message */
    return 2;  /* return nil plus error message */
  }
}

// Assembly:
testl %esi, %esi
je 0x45c27
pushq %rax
movq 0x10(%rdi), %rax
andl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rdi)
pushq $-0x2
popq %rsi
callq 0x37926
pushq $0x2
popq %rax
addq $0x8, %rsp
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8cb98(%rip), %rdx     # 0xd7f23
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x2b
popq %rcx
callq 0xce9a
testq %rbx, %rbx
je 0x4b3a4
movq %rbx, 0x18(%rax)
popq %rbx
retq
movq 0xe2c0d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7ecb1(%rip), %rsi     # 0xca066
leaq 0x8cca1(%rip), %rdx     # 0xd805d
leaq 0x8cb71(%rip), %rcx     # 0xd7f34
leaq 0x8cb59(%rip), %r8      # 0xd7f23
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4b44c
movq %rdi, %rbx
leaq 0x8cb35(%rip), %r14     # 0xd7f23
pushq $0x28
popq %rdi
pushq $0x35
popq %rdx
movq %r14, %rsi
callq 0xccb0
movq %rax, %r15
movq 0x18(%rbx), %rdi
imulq 0x8(%rbx), %rdi
pushq $0x36
popq %rdx
movq %r14, %rsi
callq 0xccb0
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)
andl $0x0, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xe2b65(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7ec09(%rip), %rsi     # 0xca066
leaq 0x8dcc0(%rip), %rdx     # 0xd9124
leaq 0x8cad6(%rip), %rcx     # 0xd7f41
leaq 0x8cab1(%rip), %r8      # 0xd7f23
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4b598
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
cmpq %rsi, %rcx
ja 0x4b5f5
movq 0xe2a19(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7eabd(%rip), %rsi     # 0xca066
leaq 0x8c9a0(%rip), %rdx     # 0xd7f50
leaq 0x8c9ef(%rip), %rcx     # 0xd7fa6
leaq 0x8c965(%rip), %r8      # 0xd7f23
pushq $0x60
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
imulq %rdx, %rax
addq %rcx, %rax
movq %rdx, %rsi
imulq %r14, %rsi
addq %rcx, %rsi
movq %rax, %rdi
callq 0xb520
movq 0x8(%rbx), %rcx
movq %r14, %rax
leaq 0x1(%rax), %r14
cmpq %rcx, %r14
jb 0x4b5ce
decq %rcx
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b6a7
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %r12
subq %rsi, %r12
jb 0x4b6a7
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %r14, %rax
ja 0x4b689
movq 0xe2979(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7ea1d(%rip), %rsi     # 0xca066
leaq 0x8c98b(%rip), %rdx     # 0xd7fdb
leaq 0x8c972(%rip), %rcx     # 0xd7fc9
leaq 0x8c8c5(%rip), %r8      # 0xd7f23
pushq $0x6f
jmp 0x4b6cf
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
movq 0x8(%rbx), %rax
incq %r15
incq %r14
cmpq %rax, %r14
jb 0x4b662
notq %r12
addq %r12, %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xe290a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e9ae(%rip), %rsi     # 0xca066
leaq 0x8c8f4(%rip), %rdx     # 0xd7fb3
leaq 0x8c903(%rip), %rcx     # 0xd7fc9
leaq 0x8c856(%rip), %r8      # 0xd7f23
pushq $0x6e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4b775
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x8c827(%rip), %rsi     # 0xd7f23
pushq $0x7f
popq %rdx
callq 0xccb0
movq %rax, %r14
movq (%rbx), %r15
movq 0x8(%rbx), %r12
decq %r12
movq 0x18(%rbx), %rdx
imulq %rdx, %r12
addq %r15, %r12
cmpq %r12, %r15
jae 0x4b756
movq %r14, %rdi
movq %r15, %rsi
callq 0xb520
movq 0x18(%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xb520
movq 0x18(%rbx), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xb520
movq 0x18(%rbx), %rdx
addq %rdx, %r15
subq %rdx, %r12
jmp 0x4b71c
leaq 0x8c7c6(%rip), %rsi     # 0xd7f23
movq %r14, %rdi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd249
movq 0xe283c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e8e0(%rip), %rsi     # 0xca066
leaq 0x8d997(%rip), %rdx     # 0xd9124
leaq 0x8c876(%rip), %rcx     # 0xd800a
leaq 0x8c788(%rip), %r8      # 0xd7f23
pushq $0x7e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4b86f
movq %rsi, %r15
testq %rsi, %rsi
je 0x4b86f
movq %rdx, %r14
movq %rdi, %rbx
cmpq %rdx, 0x18(%rdi)
jne 0x4b89d
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rcx
cmpq %rcx, %rdi
ja 0x4b8cb
leaq 0x1(%rdi), %rdx
imulq %r14, %rdx
movq (%rbx), %rax
cmpq %rcx, %rdx
jbe 0x4b853
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x516a0
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
movq 0xe2742(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e7e6(%rip), %rsi     # 0xca066
leaq 0x8c7a7(%rip), %rdx     # 0xd802e
leaq 0x8c7aa(%rip), %rcx     # 0xd8038
leaq 0x8c68e(%rip), %r8      # 0xd7f23
movl $0x97, %r9d
jmp 0x4b8f7
movq 0xe2714(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e7b8(%rip), %rsi     # 0xca066
leaq 0x8c795(%rip), %rdx     # 0xd804a
leaq 0x8c77c(%rip), %rcx     # 0xd8038
leaq 0x8c660(%rip), %r8      # 0xd7f23
movl $0x98, %r9d
jmp 0x4b8f7
movq 0xe26e6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e78a(%rip), %rsi     # 0xca066
leaq 0x8c787(%rip), %rdx     # 0xd806a
leaq 0x8c74e(%rip), %rcx     # 0xd8038
leaq 0x8c632(%rip), %r8      # 0xd7f23
movl $0x99, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4b950
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4b950
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq 0x18(%rbx), %rax
jne 0x4b950
xorl %r15d, %r15d
cmpq 0x8(%rbx), %r15
jae 0x4b94a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b48e
movq 0x18(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b801
incq %r15
jmp 0x4b925
popq %rbx
popq %r14
popq %r15
retq
movq 0xe2661(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e705(%rip), %rsi     # 0xca066
leaq 0x8c71f(%rip), %rdx     # 0xd8087
leaq 0x8c74f(%rip), %rcx     # 0xd80be
leaq 0x8c5ad(%rip), %r8      # 0xd7f23
movl $0xa7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4bc14
movq 0x8(%rbx), %rax
jmp 0x4bc16
xorl %eax, %eax
testq %r14, %r14
je 0x4bc21
movq 0x8(%r14), %rcx
jmp 0x4bc23
xorl %ecx, %ecx
cmpq %rcx, %rax
jne 0x4bc59
movq %rbx, %rdi
callq 0x4b995
movq %rax, %r15
movq %r14, %rdi
callq 0x4b995
cmpq %rax, %r15
jne 0x4bc87
movq (%r14), %rsi
movq 0x8(%rbx), %rdx
imulq 0x18(%rbx), %rdx
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb270
movq 0xe2358(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e3fc(%rip), %rsi     # 0xca066
leaq 0x8c50f(%rip), %rdx     # 0xd8180
leaq 0x8c539(%rip), %rcx     # 0xd81b1
leaq 0x8c2a4(%rip), %r8      # 0xd7f23
movl $0xdf, %r9d
jmp 0x4bcb3
movq 0xe232a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e3ce(%rip), %rsi     # 0xca066
leaq 0x8c51f(%rip), %rdx     # 0xd81be
leaq 0x8c50b(%rip), %rcx     # 0xd81b1
leaq 0x8c276(%rip), %r8      # 0xd7f23
movl $0xe0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
callq 0x4b995
movq %rax, %r12
movq %r14, %rdi
callq 0x4b995
cmpq %rax, %r12
jne 0x4bd52
testq %r15, %r15
je 0x4bcf4
movq 0x8(%r15), %rbx
jmp 0x4bcf6
xorl %ebx, %ebx
testq %r14, %r14
je 0x4bd01
movq 0x8(%r14), %rax
jmp 0x4bd03
xorl %eax, %eax
cmpq %rax, %rbx
jne 0x4bd3f
xorl %r12d, %r12d
cmpq %r12, %rbx
sete %bpl
je 0x4bd41
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b48e
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b48e
movq %r13, %rdi
movq %rax, %rsi
callq *(%rsp)
incq %r12
testl %eax, %eax
je 0x4bd0b
jmp 0x4bd41
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xe225f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e303(%rip), %rsi     # 0xca066
leaq 0x8c48f(%rip), %rdx     # 0xd81f9
leaq 0x8c4b7(%rip), %rcx     # 0xd8228
leaq 0x8c1ab(%rip), %r8      # 0xd7f23
movl $0xe9, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x4bdb2
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x4be29
testq %r12, %r12
je 0x4bdfb
testq %r15, %r15
je 0x4bdfb
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq 0x8(%r12), %rbp
jae 0x4bde9
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4b48e
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
incq %rbp
testl %eax, %eax
je 0x4bdc1
movl %eax, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xe21b6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e25a(%rip), %rsi     # 0xca066
leaq 0x8c435(%rip), %rdx     # 0xd8248
leaq 0x8c41d(%rip), %rcx     # 0xd8237
leaq 0x8c102(%rip), %r8      # 0xd7f23
movl $0xfe, %r9d
jmp 0x4be55
movq 0xe2188(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e22c(%rip), %rsi     # 0xca066
leaq 0x7e818(%rip), %rdx     # 0xca659
leaq 0x8c3ef(%rip), %rcx     # 0xd8237
leaq 0x8c0d4(%rip), %r8      # 0xd7f23
movl $0xfd, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4be87
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x4bef9
testq %r12, %r12
je 0x4becb
testq %r15, %r15
je 0x4becb
movq 0x8(%r12), %r13
decq %r13
cmpq $-0x1, %r13
je 0x4bebf
movq %r12, %rdi
movq %r13, %rsi
callq 0x4b48e
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
decq %r13
testl %eax, %eax
je 0x4be99
jmp 0x4bec1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xe20e6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e18a(%rip), %rsi     # 0xca066
leaq 0x8c365(%rip), %rdx     # 0xd8248
leaq 0x8c373(%rip), %rcx     # 0xd825d
leaq 0x8c032(%rip), %r8      # 0xd7f23
movl $0x10c, %r9d            # imm = 0x10C
jmp 0x4bf25
movq 0xe20b8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e15c(%rip), %rsi     # 0xca066
leaq 0x7e748(%rip), %rdx     # 0xca659
leaq 0x8c345(%rip), %rcx     # 0xd825d
leaq 0x8c004(%rip), %r8      # 0xd7f23
movl $0x10b, %r9d            # imm = 0x10B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4bfcd
movq %rsi, %r14
testq %rsi, %rsi
je 0x4bfcd
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x18(%r14), %rax
jne 0x4bfcd
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x4bfc7
movq (%rbx), %rdi
leaq 0x10(%rbx), %rsi
addq 0x8(%rbx), %rdx
imulq %rax, %rdx
callq 0x516a0
movq %rax, (%rbx)
movq 0x8(%rbx), %r15
decq %r15
movq (%rbx), %rdi
cmpq $-0x1, %r15
je 0x4bfae
movq 0x8(%r14), %rax
addq %r15, %rax
movq 0x18(%rbx), %rdx
imulq %rdx, %rax
addq %rdi, %rax
movq %rdx, %rsi
imulq %r15, %rsi
addq %rdi, %rsi
movq %rax, %rdi
callq 0xb520
jmp 0x4bf7c
movq (%r14), %rsi
movq 0x8(%r14), %rdx
imulq 0x18(%r14), %rdx
callq 0xb520
movq 0x8(%r14), %rax
addq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0xe1fe4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7e088(%rip), %rsi     # 0xca066
leaq 0x8c0a2(%rip), %rdx     # 0xd8087
leaq 0x8c28a(%rip), %rcx     # 0xd8276
leaq 0x8bf30(%rip), %r8      # 0xd7f23
movl $0x117, %r9d            # imm = 0x117
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4c01f
callq 0xc103
testb %al, %al
jne 0x4c16c
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, %rbx
xorl %eax, %eax
movq %rsp, %r15
movq %rax, (%rsp)
cmpq $0x63, %rax
ja 0x4c068
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4b801
movq (%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b48e
cmpq (%rax), %r12
jne 0x4c0a7
movq (%rsp), %rax
incq %rax
jmp 0x4c033
testq %rbx, %rbx
je 0x4c0df
cmpq $0x64, 0x8(%rbx)
jne 0x4c0df
movq %rbx, %rdi
callq 0x4b52b
cmpq $0x63, (%rax)
jne 0x4c10d
cmpq $0x63, 0x8(%rbx)
jne 0x4c13b
movq %rbx, %rdi
callq 0x4c19d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xe1f0a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7dfae(%rip), %rsi     # 0xca066
leaq 0x8c1df(%rip), %rdx     # 0xd829e
leaq 0x8c1c7(%rip), %rcx     # 0xd828d
leaq 0x8be56(%rip), %r8      # 0xd7f23
movl $0x14a, %r9d            # imm = 0x14A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0xe1ed2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7df76(%rip), %rsi     # 0xca066
leaq 0x8c1cb(%rip), %rdx     # 0xd82c2
leaq 0x8c18f(%rip), %rcx     # 0xd828d
leaq 0x8be1e(%rip), %r8      # 0xd7f23
movl $0x14c, %r9d            # imm = 0x14C
jmp 0x4c0d3
movq 0xe1ea4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7df48(%rip), %rsi     # 0xca066
leaq 0x8c1b5(%rip), %rdx     # 0xd82da
leaq 0x8c161(%rip), %rcx     # 0xd828d
leaq 0x8bdf0(%rip), %r8      # 0xd7f23
movl $0x14d, %r9d            # imm = 0x14D
jmp 0x4c0d3
movq 0xe1e76(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7df1a(%rip), %rsi     # 0xca066
leaq 0x8c1a9(%rip), %rdx     # 0xd82fc
leaq 0x8c133(%rip), %rcx     # 0xd828d
leaq 0x8bdc2(%rip), %r8      # 0xd7f23
movl $0x14e, %r9d            # imm = 0x14E
jmp 0x4c0d3
movq 0xe1e45(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7dee9(%rip), %rsi     # 0xca066
leaq 0x7e4d5(%rip), %rdx     # 0xca659
leaq 0x8c102(%rip), %rcx     # 0xd828d
leaq 0x8bd91(%rip), %r8      # 0xd7f23
movl $0x143, %r9d            # imm = 0x143
jmp 0x4c0d3
// File: /workspace/github_c_makefile_star2_O2/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 0x4c1b5
movq %rdi, %rbx
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0x4c1bd
decl %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0x8bd5c(%rip), %r14     # 0xd7f23
movq %r14, %rsi
movl $0x204, %edx            # imm = 0x204
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0x205, %edx            # imm = 0x205
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/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 0x4d10d
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x4d184
movq (%rbx), %rcx
leaq 0x1(%rcx), %rax
cmpq %rax, (%r15)
jne 0x4d14c
addq $0x65, %rcx
xorl %eax, %eax
cmpq %rcx, 0x8(%r15)
je 0x4d17b
leaq 0x7f02d(%rip), %rsi     # 0xcc159
leaq 0x8b5f8(%rip), %rdx     # 0xd872b
leaq 0x8b5c9(%rip), %rcx     # 0xd8703
leaq 0x8ade2(%rip), %r8      # 0xd7f23
movq %r14, %rdi
movl $0x133, %r9d            # imm = 0x133
jmp 0x4d171
leaq 0x7f006(%rip), %rsi     # 0xcc159
leaq 0x8b5bb(%rip), %rdx     # 0xd8715
leaq 0x8b5a2(%rip), %rcx     # 0xd8703
leaq 0x8adbb(%rip), %r8      # 0xd7f23
movq %r14, %rdi
movl $0x132, %r9d            # imm = 0x132
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
incq (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0xe0e2d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7ced1(%rip), %rsi     # 0xca066
leaq 0x7d4bd(%rip), %rdx     # 0xca659
leaq 0x8b560(%rip), %rcx     # 0xd8703
leaq 0x8ad79(%rip), %r8      # 0xd7f23
movl $0x12f, %r9d            # imm = 0x12F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
testq %rdi, %rdi
je 0x4d1da
movq %r14, %rdi
callq 0xb260
movq %rax, %r15
jmp 0x4d1dd
xorl %r15d, %r15d
leaq 0x2(%r15), %rdi
leaq 0x8b559(%rip), %rsi     # 0xd8741
pushq $0x23
popq %rdx
callq 0xccb0
movq %rax, %rbx
testq %r14, %r14
je 0x4d233
cmpb $0x0, (%r14)
je 0x4d233
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb600
leaq (%r15,%rbx), %rax
decq %rax
xorl %edx, %edx
cmpq %rbx, %rax
jb 0x4d238
cmpb $0x2f, (%rax)
setne %cl
jne 0x4d22c
testb $0x1, %dl
jne 0x4d241
cmpq %rbx, %rax
jbe 0x4d22c
movb $0x0, (%rax)
decq %rax
movl %ecx, %edx
jmp 0x4d212
movw $0x2e, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
incq %rax
movq %rbx, %rcx
movb (%rax), %dl
testb %dl, %dl
je 0x4d257
movb %dl, (%rcx)
incq %rcx
incq %rax
jmp 0x4d247
movb $0x0, (%rcx)
jmp 0x4d238
// File: /workspace/github_c_makefile_star2_O2/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 0x4d701
movq %rdi, %rbx
leaq 0x8b162(%rip), %r14     # 0xd881a
pushq $0x18
popq %rdi
pushq $0x2a
popq %rdx
movq %r14, %rsi
callq 0xccb0
movq %rax, %r15
movq %rbx, 0x10(%rax)
leaq -0x1(%rbx), %rax
shrq $0x6, %rax
incq %rax
cmpq $0x40, %rbx
pushq $0x1
popq %rdi
cmovaeq %rax, %rdi
movq %rdi, 0x8(%r15)
pushq $0x8
popq %rsi
pushq $0x32
popq %rcx
movq %r14, %rdx
callq 0xce9a
movq %rax, (%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xe08b0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c954(%rip), %rsi     # 0xca066
leaq 0x8b0e2(%rip), %rdx     # 0xd87fb
leaq 0x8b0ec(%rip), %rcx     # 0xd880c
leaq 0x8b0f3(%rip), %r8      # 0xd881a
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4d83d
testq %rsi, %rsi
je 0x4d83d
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x4d83d
movq (%rsi), %rax
xorl %ecx, %ecx
movq 0x8(%rsi), %rdx
leaq -0x1(%rdx), %r8
cmpq %r8, %rcx
jae 0x4d81d
movq (%rax,%rcx,8), %rdx
notq %rdx
movq (%rdi), %r8
movq %rdx, (%r8,%rcx,8)
incq %rcx
jmp 0x4d7fd
movq -0x8(%rax,%rdx,8), %rax
notq %rax
movl %edx, %ecx
shll $0x6, %ecx
subl 0x10(%rsi), %ecx
shlq %cl, %rax
shrq %cl, %rax
movq (%rdi), %rcx
movq %rax, -0x8(%rcx,%rdx,8)
popq %rax
retq
movq 0xe0774(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c818(%rip), %rsi     # 0xca066
leaq 0x8b017(%rip), %rdx     # 0xd886c
leaq 0x8b045(%rip), %rcx     # 0xd88a1
leaq 0x8afb7(%rip), %r8      # 0xd881a
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4d8a5
testq %rsi, %rsi
je 0x4d8a5
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x4d8a5
xorl %eax, %eax
cmpq 0x8(%rsi), %rax
jae 0x4d8a3
movq (%rsi), %rcx
movq (%rcx,%rax,8), %rcx
movq (%rdi), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
jmp 0x4d88a
popq %rax
retq
movq 0xe070c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c7b0(%rip), %rsi     # 0xca066
leaq 0x8afaf(%rip), %rdx     # 0xd886c
leaq 0x8aff2(%rip), %rcx     # 0xd88b6
leaq 0x8af4f(%rip), %r8      # 0xd881a
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4d91f
testq %rsi, %rsi
je 0x4d91f
testq %rdx, %rdx
je 0x4d91f
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x4d949
cmpq 0x10(%rdx), %rax
jne 0x4d973
xorl %eax, %eax
cmpq 0x8(%rsi), %rax
jae 0x4d91d
movq (%rsi), %rcx
movq (%rdx), %r8
movq (%r8,%rax,8), %r8
andq (%rcx,%rax,8), %r8
movq (%rdi), %rcx
movq %r8, (%rcx,%rax,8)
incq %rax
jmp 0x4d8fd
popq %rax
retq
movq 0xe0692(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c736(%rip), %rsi     # 0xca066
leaq 0x8af8f(%rip), %rdx     # 0xd88c6
leaq 0x8af9d(%rip), %rcx     # 0xd88db
leaq 0x8aed5(%rip), %r8      # 0xd881a
pushq $0x63
jmp 0x4d99b
movq 0xe0668(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c70c(%rip), %rsi     # 0xca066
leaq 0x8af88(%rip), %rdx     # 0xd88e9
leaq 0x8af73(%rip), %rcx     # 0xd88db
leaq 0x8aeab(%rip), %r8      # 0xd881a
pushq $0x64
jmp 0x4d99b
movq 0xe063e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c6e2(%rip), %rsi     # 0xca066
leaq 0x8af85(%rip), %rdx     # 0xd8910
leaq 0x8af49(%rip), %rcx     # 0xd88db
leaq 0x8ae81(%rip), %r8      # 0xd881a
pushq $0x65
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4d9ed
testq %rsi, %rsi
je 0x4d9ed
testq %rdx, %rdx
je 0x4d9ed
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x4da17
cmpq 0x10(%rdx), %rax
jne 0x4da41
xorl %eax, %eax
cmpq 0x8(%rsi), %rax
jae 0x4d9eb
movq (%rsi), %rcx
movq (%rdx), %r8
movq (%r8,%rax,8), %r8
orq (%rcx,%rax,8), %r8
movq (%rdi), %rcx
movq %r8, (%rcx,%rax,8)
incq %rax
jmp 0x4d9cb
popq %rax
retq
movq 0xe05c4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c668(%rip), %rsi     # 0xca066
leaq 0x8aec1(%rip), %rdx     # 0xd88c6
leaq 0x8af2b(%rip), %rcx     # 0xd8937
leaq 0x8ae07(%rip), %r8      # 0xd881a
pushq $0x6d
jmp 0x4da69
movq 0xe059a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c63e(%rip), %rsi     # 0xca066
leaq 0x8aeba(%rip), %rdx     # 0xd88e9
leaq 0x8af01(%rip), %rcx     # 0xd8937
leaq 0x8addd(%rip), %r8      # 0xd881a
pushq $0x6e
jmp 0x4da69
movq 0xe0570(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c614(%rip), %rsi     # 0xca066
leaq 0x8aeb7(%rip), %rdx     # 0xd8910
leaq 0x8aed7(%rip), %rcx     # 0xd8937
leaq 0x8adb3(%rip), %r8      # 0xd881a
pushq $0x6f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4dabe
testq %rsi, %rsi
je 0x4dabe
testq %rdx, %rdx
je 0x4dabe
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x4dae8
cmpq 0x10(%rdx), %rax
jne 0x4db12
xorl %eax, %eax
cmpq 0x8(%rdi), %rax
jae 0x4dabc
movq (%rsi), %rcx
movq (%rdx), %r8
movq (%r8,%rax,8), %r8
notq %r8
andq (%rcx,%rax,8), %r8
movq (%rdi), %rcx
movq %r8, (%rcx,%rax,8)
incq %rax
jmp 0x4da99
popq %rax
retq
movq 0xe04f3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c597(%rip), %rsi     # 0xca066
leaq 0x8ae6e(%rip), %rdx     # 0xd8944
leaq 0x8ae85(%rip), %rcx     # 0xd8962
leaq 0x8ad36(%rip), %r8      # 0xd881a
pushq $0x79
jmp 0x4db3a
movq 0xe04c9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c56d(%rip), %rsi     # 0xca066
leaq 0x8ae71(%rip), %rdx     # 0xd8971
leaq 0x8ae5b(%rip), %rcx     # 0xd8962
leaq 0x8ad0c(%rip), %r8      # 0xd881a
pushq $0x7a
jmp 0x4db3a
movq 0xe049f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c543(%rip), %rsi     # 0xca066
leaq 0x8ae71(%rip), %rdx     # 0xd899b
leaq 0x8ae31(%rip), %rcx     # 0xd8962
leaq 0x8ace2(%rip), %r8      # 0xd881a
pushq $0x7b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4db7a
testq %rsi, %rsi
je 0x4db7a
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x4dba8
xorl %eax, %eax
cmpq 0x8(%rdi), %rax
jae 0x4db78
movq (%rsi), %rcx
movq (%rcx,%rax,8), %rcx
movq (%rdi), %rdx
andq %rcx, (%rdx,%rax,8)
incq %rax
jmp 0x4db5f
popq %rax
retq
movq 0xe0437(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c4db(%rip), %rsi     # 0xca066
leaq 0x7e975(%rip), %rdx     # 0xcc507
leaq 0x8ae32(%rip), %rcx     # 0xd89cb
leaq 0x8ac7a(%rip), %r8      # 0xd881a
movl $0x83, %r9d
jmp 0x4dbd4
movq 0xe0409(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c4ad(%rip), %rsi     # 0xca066
leaq 0x8acbb(%rip), %rdx     # 0xd887b
leaq 0x8ae04(%rip), %rcx     # 0xd89cb
leaq 0x8ac4c(%rip), %r8      # 0xd881a
movl $0x84, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4dca5
xorl %eax, %eax
xorl %ecx, %ecx
cmpq 0x8(%rdi), %rax
jae 0x4dca3
movq (%rdi), %rdx
movq (%rdx,%rax,8), %rsi
leaq (%rcx,%rsi,2), %rcx
movq %rcx, (%rdx,%rax,8)
shrq $0x3f, %rsi
incq %rax
movq %rsi, %rcx
jmp 0x4dc82
popq %rax
retq
movq 0xe030c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c3b0(%rip), %rsi     # 0xca066
leaq 0x8c3cf(%rip), %rdx     # 0xda08c
leaq 0x8ad2e(%rip), %rcx     # 0xd89f2
leaq 0x8ab4f(%rip), %r8      # 0xd881a
movl $0x95, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4dd0e
movq 0x8(%rdi), %rax
xorl %ecx, %ecx
subq $0x1, %rax
jb 0x4dd0c
movq (%rdi), %rdx
movq (%rdx,%rax,8), %rsi
movq %rsi, %r8
shrq %r8
orq %rcx, %r8
movq %r8, (%rdx,%rax,8)
shlq $0x3f, %rsi
movq %rsi, %rcx
jmp 0x4dce9
popq %rax
retq
movq 0xe02a3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c347(%rip), %rsi     # 0xca066
leaq 0x8c366(%rip), %rdx     # 0xda08c
leaq 0x8ace0(%rip), %rcx     # 0xd8a0d
leaq 0x8aae6(%rip), %r8      # 0xd881a
movl $0xa0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4dd63
xorl %eax, %eax
cmpq 0x8(%rdi), %rax
jae 0x4dd61
movq (%rdi), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x4dd4e
popq %rax
retq
movq 0xe024e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c2f2(%rip), %rsi     # 0xca066
leaq 0x8c311(%rip), %rdx     # 0xda08c
leaq 0x8aca7(%rip), %rcx     # 0xd8a29
leaq 0x8aa91(%rip), %r8      # 0xd881a
movl $0xab, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4ddf5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4ddf5
movq %rdi, %r14
xorl %esi, %esi
movq %rsp, %r15
pushq $0x8
popq %r12
movq %rsi, (%rsp)
cmpq 0x10(%r14), %rsi
jae 0x4dde9
movq %r14, %rdi
callq 0x4de2d
testb %al, %al
je 0x4dde0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4b801
movq (%rsp), %rsi
incq %rsi
jmp 0x4ddbc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xe01bc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c260(%rip), %rsi     # 0xca066
leaq 0x8ac2c(%rip), %rdx     # 0xd8a39
leaq 0x8ac32(%rip), %rcx     # 0xd8a46
leaq 0x8a9ff(%rip), %r8      # 0xd881a
movl $0xb3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4deb1
movq 0x8(%rdi), %rax
xorl %edx, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x4dea9
movq (%rdi), %rsi
leaq 0x1(%rcx), %rdx
cmpq $0x0, (%rsi,%rcx,8)
je 0x4de93
cmpq %rax, %rcx
setb %al
popq %rcx
retq
movq 0xe0100(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c1a4(%rip), %rsi     # 0xca066
leaq 0x8c1c3(%rip), %rdx     # 0xda08c
leaq 0x8aba5(%rip), %rcx     # 0xd8a75
leaq 0x8a943(%rip), %r8      # 0xd881a
movl $0xc5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4df28
testq %rsi, %rsi
je 0x4df28
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x4df28
movq 0x8(%rdi), %rax
xorl %edx, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x4df20
movq (%rdi), %rdx
movq (%rdx,%rcx,8), %r8
movq (%rsi), %r9
leaq 0x1(%rcx), %rdx
cmpq (%r9,%rcx,8), %r8
je 0x4df04
cmpq %rax, %rcx
setae %al
popq %rcx
retq
movq 0xe0089(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c12d(%rip), %rsi     # 0xca066
leaq 0x8ab47(%rip), %rdx     # 0xd8a87
leaq 0x8ab6f(%rip), %rcx     # 0xd8ab6
leaq 0x8a8cc(%rip), %r8      # 0xd881a
movl $0xd0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4dfda
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
cmpq %rax, %r14
jae 0x4dfd2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4de2d
testb %al, %al
jne 0x4dfcf
incq %r14
jmp 0x4dfb2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xdffd7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7c07b(%rip), %rsi     # 0xca066
leaq 0x8c09a(%rip), %rdx     # 0xda08c
leaq 0x8aada(%rip), %rcx     # 0xd8ad3
leaq 0x8a81a(%rip), %r8      # 0xd881a
movl $0xe1, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4e092
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x10(%rdi)
jbe 0x4e0c0
incq %rbx
movq 0x10(%r14), %rax
cmpq %rax, %rbx
jae 0x4e08a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4de2d
movl %eax, %ecx
movq %rbx, %rax
testb %cl, %cl
je 0x4e06a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xdff1f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7bfc3(%rip), %rsi     # 0xca066
leaq 0x8bfe2(%rip), %rdx     # 0xda08c
leaq 0x8aa57(%rip), %rcx     # 0xd8b08
leaq 0x8a762(%rip), %r8      # 0xd881a
movl $0xf7, %r9d
jmp 0x4e0ec
movq 0xdfef1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7bf95(%rip), %rsi     # 0xca066
leaq 0x8aa4a(%rip), %rdx     # 0xd8b22
leaq 0x8aa29(%rip), %rcx     # 0xd8b08
leaq 0x8a734(%rip), %r8      # 0xd881a
movl $0xf8, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4e205
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4e205
movq %rdi, %r14
pushq $0xa
popq %r13
leaq 0x7cf10(%rip), %r15     # 0xcb0ac
xorl %r12d, %r12d
movq %r12, %rax
xorl %edx, %edx
divq %r13
cmpq 0x10(%r14), %r12
jae 0x4e1bf
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb8c0
incq %r12
jmp 0x4e19f
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x1640e
xorl %r15d, %r15d
cmpq 0x10(%r14), %r15
jae 0x4e1f1
movq %r14, %rdi
movq %r15, %rsi
callq 0x4de2d
movzbl %al, %edi
orl $0x30, %edi
movq %rbx, %rsi
callq 0x1640e
incq %r15
jmp 0x4e1cd
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1640e
movq 0xdfdac(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7be50(%rip), %rsi     # 0xca066
leaq 0x8a936(%rip), %rdx     # 0xd8b53
leaq 0x8a93a(%rip), %rcx     # 0xd8b5e
leaq 0x8a5ef(%rip), %r8      # 0xd881a
movl $0x12a, %r9d            # imm = 0x12A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300