LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x763e2
cmpq $0x0, 0x18(%rsp)
je 0x763e2
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x18(%rcx), %rax
je 0x7641a
movq 0x13dbef(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe7c73(%rip), %rsi     # 0x15e066
leaq 0xf6094(%rip), %rdx     # 0x16c48e
leaq 0xf60c4(%rip), %rcx     # 0x16c4c5
leaq 0xf5f22(%rip), %r8      # 0x16c32a
movl $0xa7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7641c
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x76483
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x75c80
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x76220
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x76425
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x76490
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x768cc
movq 0x13d73d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe77c1(%rip), %rsi     # 0x15e066
leaq 0xf5cdb(%rip), %rdx     # 0x16c587
leaq 0xf5d05(%rip), %rcx     # 0x16c5b8
leaq 0xf5a70(%rip), %r8      # 0x16c32a
movl $0xdf, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x768ce
jmp 0x768d0
movq 0x20(%rsp), %rdi
callq 0x764c0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x764c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x7692e
movq 0x13d6db(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe775f(%rip), %rsi     # 0x15e066
leaq 0xf5cb7(%rip), %rdx     # 0x16c5c5
leaq 0xf5ca3(%rip), %rcx     # 0x16c5b8
leaq 0xf5a0e(%rip), %r8      # 0x16c32a
movl $0xe0, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76930
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rsp), %rax
imulq 0x8(%rax), %rdx
callq 0xb250
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x764c0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x764c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x769d1
movq 0x13d638(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe76bc(%rip), %rsi     # 0x15e066
leaq 0xf5c4f(%rip), %rdx     # 0x16c600
leaq 0xf5c77(%rip), %rcx     # 0x16c62f
leaq 0xf596b(%rip), %r8      # 0x16c32a
movl $0xe9, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x769d3
movq 0x48(%rsp), %rdi
callq 0x76490
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x76490
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x76a07
movb $0x0, 0x57(%rsp)
jmp 0x76a92
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x76a1a
movb $0x0, 0x57(%rsp)
jmp 0x76a92
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x76a8d
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x75c80
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x75c80
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x8(%rsp), %rax
callq *%rax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x76a7b
movb $0x0, 0x57(%rsp)
jmp 0x76a92
jmp 0x76a7d
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x76a23
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x76b08
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x76ad0
jmp 0x76b08
movq 0x13d501(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe7585(%rip), %rsi     # 0x15e066
leaq 0xe7b60(%rip), %rdx     # 0x15e648
leaq 0xf5b4f(%rip), %rcx     # 0x16c63e
leaq 0xf5834(%rip), %r8      # 0x16c32a
movl $0xfd, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76b0a
jmp 0x76b0c
cmpq $0x0, 0x38(%rsp)
je 0x76b1c
cmpq $0x0, 0x30(%rsp)
jne 0x76b54
movq 0x13d4b5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe7539(%rip), %rsi     # 0x15e066
leaq 0xf5b1b(%rip), %rdx     # 0x16c64f
leaq 0xf5b03(%rip), %rcx     # 0x16c63e
leaq 0xf57e8(%rip), %r8      # 0x16c32a
movl $0xfe, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76b56
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x76bd0
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq %rax, %rdi
movq (%rsp), %rax
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq *%rax
movl %eax, 0x14(%rsp)
cmpl $0x0, %eax
je 0x76bbe
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x76bd8
jmp 0x76bc0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x76b5f
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x76c58
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x76c20
jmp 0x76c58
movq 0x13d3b1(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe7435(%rip), %rsi     # 0x15e066
leaq 0xe7a10(%rip), %rdx     # 0x15e648
leaq 0xf5a25(%rip), %rcx     # 0x16c664
leaq 0xf56e4(%rip), %r8      # 0x16c32a
movl $0x10b, %r9d            # imm = 0x10B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76c5a
jmp 0x76c5c
cmpq $0x0, 0x38(%rsp)
je 0x76c6c
cmpq $0x0, 0x30(%rsp)
jne 0x76ca4
movq 0x13d365(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe73e9(%rip), %rsi     # 0x15e066
leaq 0xf59cb(%rip), %rdx     # 0x16c64f
leaq 0xf59d9(%rip), %rcx     # 0x16c664
leaq 0xf5698(%rip), %r8      # 0x16c32a
movl $0x10c, %r9d            # imm = 0x10C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76ca6
movq 0x38(%rsp), %rdi
callq 0x76490
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0x76d13
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
subq $0x1, %rsi
callq 0x75c80
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq *%rax
movl %eax, 0x14(%rsp)
cmpl $0x0, %eax
je 0x76d01
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x76d1b
jmp 0x76d03
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x76cb5
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x76d62
cmpq $0x0, 0x8(%rsp)
je 0x76d62
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
je 0x76d9a
movq 0x13d26f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe72f3(%rip), %rsi     # 0x15e066
leaq 0xf5714(%rip), %rdx     # 0x16c48e
leaq 0xf58fc(%rip), %rcx     # 0x16c67d
leaq 0xf55a2(%rip), %r8      # 0x16c32a
movl $0x117, %r9d            # imm = 0x117
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76d9c
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x76dad
jmp 0x76e9b
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rax
addq 0x8(%rax), %rdx
movq 0x10(%rsp), %rax
imulq 0x18(%rax), %rdx
callq 0x7f2b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jbe 0x76e5d
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
subq $0x1, %rax
movq 0x8(%rsp), %rcx
addq 0x8(%rcx), %rax
movq 0x10(%rsp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq (%rsp), %rax
subq $0x1, %rax
movq 0x10(%rsp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0xb500
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x76df7
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x8(%rsp), %rax
imulq 0x8(%rax), %rdx
callq 0xb500
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x76ef9
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x76ec1
jmp 0x76ef9
movq 0x13d110(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe7194(%rip), %rsi     # 0x15e066
leaq 0xe776f(%rip), %rdx     # 0x15e648
leaq 0xf57b4(%rip), %rcx     # 0x16c694
leaq 0xf5443(%rip), %r8      # 0x16c32a
movl $0x143, %r9d            # imm = 0x143
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76efb
movl $0x8, %edi
callq 0x75ab0
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x64, 0x18(%rsp)
jae 0x76fa8
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq (%rcx), %rax
je 0x76f91
movq 0x13d078(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe70fc(%rip), %rsi     # 0x15e066
leaq 0xf5734(%rip), %rdx     # 0x16c6a5
leaq 0xf571c(%rip), %rcx     # 0x16c694
leaq 0xf53ab(%rip), %r8      # 0x16c32a
movl $0x14a, %r9d            # imm = 0x14A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76f93
jmp 0x76f95
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x76f13
jmp 0x76faa
movq 0x10(%rsp), %rdi
callq 0x76490
cmpq $0x64, %rax
je 0x76ff2
movq 0x13d017(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe709b(%rip), %rsi     # 0x15e066
leaq 0xf56f7(%rip), %rdx     # 0x16c6c9
leaq 0xf56bb(%rip), %rcx     # 0x16c694
leaq 0xf534a(%rip), %r8      # 0x16c32a
movl $0x14c, %r9d            # imm = 0x14C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x76ff4
jmp 0x76ff6
movq 0x10(%rsp), %rdi
callq 0x75d90
cmpq $0x63, (%rax)
je 0x7703e
movq 0x13cfcb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe704f(%rip), %rsi     # 0x15e066
leaq 0xf56c3(%rip), %rdx     # 0x16c6e1
leaq 0xf566f(%rip), %rcx     # 0x16c694
leaq 0xf52fe(%rip), %r8      # 0x16c32a
movl $0x14d, %r9d            # imm = 0x14D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x77040
jmp 0x77042
movq 0x10(%rsp), %rdi
callq 0x76490
cmpq $0x63, %rax
je 0x7708a
movq 0x13cf7f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe7003(%rip), %rsi     # 0x15e066
leaq 0xf5699(%rip), %rdx     # 0x16c703
leaq 0xf5623(%rip), %rcx     # 0x16c694
leaq 0xf52b2(%rip), %r8      # 0x16c32a
movl $0x14e, %r9d            # imm = 0x14E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7708c
movq 0x10(%rsp), %rdi
callq 0x770a0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x770ae
jmp 0x770f4
movq (%rsp), %rax
cmpl $0x0, 0x20(%rax)
je 0x770c7
movq (%rsp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x770f4
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0xf5255(%rip), %rsi     # 0x16c32a
movl $0x204, %edx            # imm = 0x204
callq 0xdab0
movq (%rsp), %rdi
leaq 0xf5240(%rip), %rsi     # 0x16c32a
movl $0x205, %edx            # imm = 0x205
callq 0xdab0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x786cb
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x78693
jmp 0x786cb
movq 0x13b93e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe59c2(%rip), %rsi     # 0x15e066
leaq 0xe5f9d(%rip), %rdx     # 0x15e648
leaq 0xf4458(%rip), %rcx     # 0x16cb0a
leaq 0xf3c71(%rip), %r8      # 0x16c32a
movl $0x12f, %r9d            # imm = 0x12F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x786cd
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x78742
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
je 0x78740
movq 0x20(%rsp), %rdi
leaq 0xe7a61(%rip), %rsi     # 0x160177
leaq 0xf43ff(%rip), %rdx     # 0x16cb1c
leaq 0xf43e6(%rip), %rcx     # 0x16cb0a
leaq 0xf3bff(%rip), %r8      # 0x16c32a
movl $0x132, %r9d            # imm = 0x132
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x78742
jmp 0x78744
jmp 0x78746
cmpl $0x0, 0x4(%rsp)
jne 0x7879b
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
addq $0x65, %rcx
cmpq %rcx, %rax
je 0x78799
movq 0x20(%rsp), %rdi
leaq 0xe7a08(%rip), %rsi     # 0x160177
leaq 0xf43bc(%rip), %rdx     # 0x16cb32
leaq 0xf438d(%rip), %rcx     # 0x16cb0a
leaq 0xf3ba6(%rip), %r8      # 0x16c32a
movl $0x133, %r9d            # imm = 0x133
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x7879b
jmp 0x7879d
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movb $0x0, 0x17(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x78806
movq 0x28(%rsp), %rdi
callq 0xb240
movq %rax, (%rsp)
jmp 0x7880e
movq $0x0, (%rsp)
movq (%rsp), %rdi
addq $0x2, %rdi
shlq $0x0, %rdi
leaq 0xf4327(%rip), %rsi     # 0x16cb48
movl $0x23, %edx
callq 0xd2e0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x78845
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x78865
movq 0x20(%rsp), %rdi
leaq 0xeed95(%rip), %rsi     # 0x1675e6
callq 0xb5e0
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x7894c
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xb5e0
movq 0x20(%rsp), %rax
addq (%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jb 0x78942
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x78928
testb $0x1, 0x17(%rsp)
je 0x78912
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x78902
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x788c5
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x78942
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x78926
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
jmp 0x7892d
movb $0x1, 0x17(%rsp)
jmp 0x7892f
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x78886
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x78f49
movq 0x13b0c0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe5144(%rip), %rsi     # 0x15e066
leaq 0xf3cd9(%rip), %rdx     # 0x16cc02
leaq 0xf3ce3(%rip), %rcx     # 0x16cc13
leaq 0xf3cea(%rip), %r8      # 0x16cc21
movl $0x28, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x78f4b
movl $0x18, %edi
leaq 0xf3cca(%rip), %rsi     # 0x16cc21
movl $0x2a, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
je 0x78f9f
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
shrq $0x6, %rcx
addq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x78fac
movq 0x8(%rsp), %rax
movq $0x1, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x8, %esi
leaq 0xf3c60(%rip), %rdx     # 0x16cc21
movl $0x32, %ecx
callq 0xd5b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x79152
cmpq $0x0, 0x8(%rsp)
je 0x79152
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x7918a
movq 0x13ae7f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4f03(%rip), %rsi     # 0x15e066
leaq 0xf3b09(%rip), %rdx     # 0x16cc73
leaq 0xf3b37(%rip), %rcx     # 0x16cca8
leaq 0xf3aa9(%rip), %r8      # 0x16cc21
movl $0x49, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7918c
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x791dc
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdx
xorq $-0x1, %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x79194
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
xorq $-0x1, %rdx
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
subq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
shlq $0x3, %rax
shlq $0x3, %rax
addq %rax, %rcx
movq $-0x1, %rax
shrq %cl, %rax
andq %rax, %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x79282
cmpq $0x0, 0x8(%rsp)
je 0x79282
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x792ba
movq 0x13ad4f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4dd3(%rip), %rsi     # 0x15e066
leaq 0xf39d9(%rip), %rdx     # 0x16cc73
leaq 0xf3a1c(%rip), %rcx     # 0x16ccbd
leaq 0xf3979(%rip), %r8      # 0x16cc21
movl $0x5a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x792bc
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x79301
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x792c4
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7933b
cmpq $0x0, 0x18(%rsp)
je 0x7933b
cmpq $0x0, 0x10(%rsp)
jne 0x79373
movq 0x13ac96(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4d1a(%rip), %rsi     # 0x15e066
leaq 0xf397a(%rip), %rdx     # 0x16cccd
leaq 0xf3988(%rip), %rcx     # 0x16cce2
leaq 0xf38c0(%rip), %r8      # 0x16cc21
movl $0x63, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79375
jmp 0x79377
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x793c3
movq 0x13ac46(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4cca(%rip), %rsi     # 0x15e066
leaq 0xf394d(%rip), %rdx     # 0x16ccf0
leaq 0xf3938(%rip), %rcx     # 0x16cce2
leaq 0xf3870(%rip), %r8      # 0x16cc21
movl $0x64, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x793c5
jmp 0x793c7
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x79413
movq 0x13abf6(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4c7a(%rip), %rsi     # 0x15e066
leaq 0xf3924(%rip), %rdx     # 0x16cd17
leaq 0xf38e8(%rip), %rcx     # 0x16cce2
leaq 0xf3820(%rip), %r8      # 0x16cc21
movl $0x65, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79415
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x79471
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
andq (%rax,%rcx,8), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x7941e
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x794ab
cmpq $0x0, 0x18(%rsp)
je 0x794ab
cmpq $0x0, 0x10(%rsp)
jne 0x794e3
movq 0x13ab26(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4baa(%rip), %rsi     # 0x15e066
leaq 0xf380a(%rip), %rdx     # 0x16cccd
leaq 0xf3874(%rip), %rcx     # 0x16cd3e
leaq 0xf3750(%rip), %r8      # 0x16cc21
movl $0x6d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x794e5
jmp 0x794e7
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x79533
movq 0x13aad6(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4b5a(%rip), %rsi     # 0x15e066
leaq 0xf37dd(%rip), %rdx     # 0x16ccf0
leaq 0xf3824(%rip), %rcx     # 0x16cd3e
leaq 0xf3700(%rip), %r8      # 0x16cc21
movl $0x6e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79535
jmp 0x79537
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x79583
movq 0x13aa86(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4b0a(%rip), %rsi     # 0x15e066
leaq 0xf37b4(%rip), %rdx     # 0x16cd17
leaq 0xf37d4(%rip), %rcx     # 0x16cd3e
leaq 0xf36b0(%rip), %r8      # 0x16cc21
movl $0x6f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79585
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x795e1
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
orq (%rax,%rcx,8), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x7958e
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7961b
cmpq $0x0, 0x18(%rsp)
je 0x7961b
cmpq $0x0, 0x10(%rsp)
jne 0x79653
movq 0x13a9b6(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4a3a(%rip), %rsi     # 0x15e066
leaq 0xf3718(%rip), %rdx     # 0x16cd4b
leaq 0xf372f(%rip), %rcx     # 0x16cd69
leaq 0xf35e0(%rip), %r8      # 0x16cc21
movl $0x79, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79655
jmp 0x79657
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x796a3
movq 0x13a966(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe49ea(%rip), %rsi     # 0x15e066
leaq 0xf36f5(%rip), %rdx     # 0x16cd78
leaq 0xf36df(%rip), %rcx     # 0x16cd69
leaq 0xf3590(%rip), %r8      # 0x16cc21
movl $0x7a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x796a5
jmp 0x796a7
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x796f3
movq 0x13a916(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe499a(%rip), %rsi     # 0x15e066
leaq 0xf36cf(%rip), %rdx     # 0x16cda2
leaq 0xf368f(%rip), %rcx     # 0x16cd69
leaq 0xf3540(%rip), %r8      # 0x16cc21
movl $0x7b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x796f5
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x79758
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
xorq $-0x1, %rax
andq %rax, %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x796fe
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7977e
cmpq $0x0, 0x8(%rsp)
jne 0x797b6
movq 0x13a853(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe48d7(%rip), %rsi     # 0x15e066
leaq 0xe6d92(%rip), %rdx     # 0x160528
leaq 0xf3635(%rip), %rcx     # 0x16cdd2
leaq 0xf347d(%rip), %r8      # 0x16cc21
movl $0x83, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x797b8
jmp 0x797ba
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x79806
movq 0x13a803(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4887(%rip), %rsi     # 0x15e066
leaq 0xf349c(%rip), %rdx     # 0x16cc82
leaq 0xf35e5(%rip), %rcx     # 0x16cdd2
leaq 0xf342d(%rip), %r8      # 0x16cc21
movl $0x84, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79808
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x79851
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x79810
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x799b2
movq 0x13a657(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe46db(%rip), %rsi     # 0x15e066
leaq 0xf4b2b(%rip), %rdx     # 0x16e4bd
leaq 0xf3460(%rip), %rcx     # 0x16cdf9
leaq 0xf3281(%rip), %r8      # 0x16cc21
movl $0x95, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x799b4
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x79a35
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rdx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx,%rdx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
shlq %rdx
orq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
shrq $0x3f, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x799bd
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x79a92
movq 0x13a577(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe45fb(%rip), %rsi     # 0x15e066
leaq 0xf4a4b(%rip), %rdx     # 0x16e4bd
leaq 0xf339b(%rip), %rcx     # 0x16ce14
leaq 0xf31a1(%rip), %r8      # 0x16cc21
movl $0xa0, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79a94
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0x79b18
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
shrq %rdx
orq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
shlq $0x3f, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x79aa2
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x79b69
movq 0x13a4a0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4524(%rip), %rsi     # 0x15e066
leaq 0xf4974(%rip), %rdx     # 0x16e4bd
leaq 0xf32e0(%rip), %rcx     # 0x16ce30
leaq 0xf30ca(%rip), %r8      # 0x16cc21
movl $0xab, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79b6b
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x79ba9
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x79b74
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x79bce
cmpq $0x0, 0x8(%rsp)
jne 0x79c06
movq 0x13a403(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4487(%rip), %rsi     # 0x15e066
leaq 0xf325a(%rip), %rdx     # 0x16ce40
leaq 0xf3260(%rip), %rcx     # 0x16ce4d
leaq 0xf302d(%rip), %r8      # 0x16cc21
movl $0xb3, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79c08
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x79c55
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x79c60
testb $0x1, %al
jne 0x79c33
jmp 0x79c45
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x76220
jmp 0x79c47
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x79c10
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_bit_is_set
bool gt_bittab_bit_is_set(const GtBittab *b, GtUword bit)
{
  gt_assert(b && bit < b->num_of_bits);
  if (b->tabptr[(bit >> 3) / sizeof (GtUword)] &
      1UL << (bit & (8UL * sizeof (GtUword) - 1))) {
    return true;
  }
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x79c84
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x79cbc
movq 0x13a34d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe43d1(%rip), %rsi     # 0x15e066
leaq 0xf2f97(%rip), %rdx     # 0x16cc33
leaq 0xf31c4(%rip), %rcx     # 0x16ce67
leaq 0xf2f77(%rip), %r8      # 0x16cc21
movl $0xba, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79cbe
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
shrq $0x3, %rcx
shrq $0x3, %rcx
movq (%rax,%rcx,8), %rax
movq (%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x79cf9
movb $0x1, 0x17(%rsp)
jmp 0x79cfe
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x79d59
movq 0x13a2b0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4334(%rip), %rsi     # 0x15e066
leaq 0xf4784(%rip), %rdx     # 0x16e4bd
leaq 0xf313c(%rip), %rcx     # 0x16ce7c
leaq 0xf2eda(%rip), %r8      # 0x16cc21
movl $0xc5, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79d5b
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x79d9c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x79d8c
movb $0x1, 0x17(%rsp)
jmp 0x79da1
jmp 0x79d8e
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x79d63
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x79de2
cmpq $0x0, 0x10(%rsp)
je 0x79de2
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x79e1a
movq 0x13a1ef(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4273(%rip), %rsi     # 0x15e066
leaq 0xf3094(%rip), %rdx     # 0x16ce8e
leaq 0xf30bc(%rip), %rcx     # 0x16cebd
leaq 0xf2e19(%rip), %r8      # 0x16cc21
movl $0xd0, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79e1c
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x79e72
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x79e60
movb $0x0, 0x27(%rsp)
jmp 0x79e77
jmp 0x79e62
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x79e25
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $-0x1, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x79f32
movq 0x13a0d7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe415b(%rip), %rsi     # 0x15e066
leaq 0xf45ab(%rip), %rdx     # 0x16e4bd
leaq 0xf2fc1(%rip), %rcx     # 0x16ceda
leaq 0xf2d01(%rip), %r8      # 0x16cc21
movl $0xe1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x79f34
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x79f80
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x79c60
testb $0x1, %al
jne 0x79f62
jmp 0x79f6e
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x79f80
jmp 0x79f70
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x79f3d
cmpq $-0x1, 0x8(%rsp)
jne 0x79f98
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x79fa2
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $-0x1, (%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7a056
movq 0x139fb3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe4037(%rip), %rsi     # 0x15e066
leaq 0xf4487(%rip), %rdx     # 0x16e4bd
leaq 0xf2ed2(%rip), %rcx     # 0x16cf0f
leaq 0xf2bdd(%rip), %r8      # 0x16cc21
movl $0xf7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7a058
jmp 0x7a05a
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x7a0a2
movq 0x139f67(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe3feb(%rip), %rsi     # 0x15e066
leaq 0xf2ea7(%rip), %rdx     # 0x16cf29
leaq 0xf2e86(%rip), %rcx     # 0x16cf0f
leaq 0xf2b91(%rip), %r8      # 0x16cc21
movl $0xf8, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7a0a4
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7a0f4
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x79c60
testb $0x1, %al
jne 0x7a0d7
jmp 0x7a0e2
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0x7a0f4
jmp 0x7a0e4
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x7a0b2
cmpq $-0x1, (%rsp)
jne 0x7a10b
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x7a114
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7a22e
cmpq $0x0, 0x8(%rsp)
jne 0x7a266
movq 0x139da3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe3e27(%rip), %rsi     # 0x15e066
leaq 0xf2d14(%rip), %rdx     # 0x16cf5a
leaq 0xf2d18(%rip), %rcx     # 0x16cf65
leaq 0xf29cd(%rip), %r8      # 0x16cc21
movl $0x12a, %r9d            # imm = 0x12A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7a268
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7a2ae
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
leaq 0xe4da5(%rip), %rsi     # 0x15f03e
movb $0x0, %al
callq 0xb890
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x7a270
movq 0x8(%rsp), %rsi
movl $0xa, %edi
callq 0x1c8f0
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7a318
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x79c60
testb $0x1, %al
jne 0x7a2e8
jmp 0x7a2f9
movq 0x8(%rsp), %rsi
movl $0x31, %edi
callq 0x1c8f0
jmp 0x7a308
movq 0x8(%rsp), %rsi
movl $0x30, %edi
callq 0x1c8f0
jmp 0x7a30a
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x7a2c5
movq 0x8(%rsp), %rsi
movl $0xa, %edi
callq 0x1c8f0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7a389
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x7a351
jmp 0x7a389
movq 0x139c80(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe3d04(%rip), %rsi     # 0x15e066
leaq 0xe42df(%rip), %rdx     # 0x15e648
leaq 0xf2c04(%rip), %rcx     # 0x16cf74
leaq 0xf28aa(%rip), %r8      # 0x16cc21
movl $0x13d, %r9d            # imm = 0x13D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7a38b
movl $0x20, %edi
callq 0x78f00
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x78fe0
movq 0x10(%rsp), %rdi
movl $0x10, %esi
callq 0x78fe0
movq 0x10(%rsp), %rdi
movl $0x18, %esi
callq 0x78fe0
movq 0x10(%rsp), %rdi
callq 0x79ee0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x79fb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x7a40f
jmp 0x7a3f9
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7a000
movq %rax, 0x18(%rsp)
jmp 0x7a3d6
movq 0x10(%rsp), %rdi
callq 0x7a420
xorl %eax, %eax
addq $0x28, %rsp
retq