LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array2dim_sparse.c
// Function: gt_array2dim_sparse_example
int gt_array2dim_sparse_example(GT_UNUSED GtError *err)
{
  int **a2dim, i, j;
  GtRowInfo ri[10];
  gt_error_check(err);

  /* initialize row info */
  for (i = 0; i < 10; i++) {
    ri[i].offset = i;
    ri[i].length = 6;
  }

  /* create sparse matrix */
  gt_array2dim_sparse_calloc(a2dim, 10, 60, ri);

  /* fill matrix */
  for (i = 0; i < 10; i++) {
    for (j = 0; j < 6; j++)
      a2dim[i][i+j] = i;
  }

  gt_assert(a2dim[0][0] == 0);
  gt_assert(a2dim[5][5] == 5);
  gt_assert(a2dim[9][14] == 9);

  /* free */
  gt_array2dim_delete(a2dim);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
testq %rdi, %rdi
je 0xd3afc
callq 0xfcc32
testb %al, %al
jne 0xd3c80
leaq 0x8(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
movq $0x6, (%rax)
incq %rcx
addq $0x10, %rax
cmpq $0xa, %rcx
jne 0xd3b03
cmpq $0x0, (%rsp)
jne 0xd3c6c
leaq 0x28b53f(%rip), %r14    # 0x35f06c
movl $0x50, %edi
movq %r14, %rsi
movl $0x32, %edx
callq 0x104226
movq %rax, %rbx
movl $0x3c, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x32, %ecx
callq 0x10436a
movq %rax, (%rbx)
movl $0x8, %ecx
xorl %edx, %edx
movq %rax, %rsi
leaq (%rsi,%rdx,4), %rsi
movq -0x8(%rsp,%rcx,2), %rdi
movq (%rsp,%rcx,2), %rdx
leaq (%rsi,%rdi,4), %rsi
leaq (,%rdx,4), %rdi
subq %rdi, %rsi
movq %rsi, (%rbx,%rcx)
addq $0x8, %rcx
cmpq $0x50, %rcx
jne 0xd3b66
xorl %ecx, %ecx
movdqa 0x284e86(%rip), %xmm0   # 0x358a20
movdqa 0x284e8e(%rip), %xmm1   # 0x358a30
movdqa 0x28b496(%rip), %xmm2   # 0x35f040
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x284e89(%rip), %xmm4   # 0x358a40
xorl %edx, %edx
movq (%rbx,%rdx,8), %rsi
addq %rcx, %rsi
movl $0x1, %edi
movdqa %xmm0, %xmm5
movdqa %xmm5, %xmm6
pxor %xmm1, %xmm6
movdqa %xmm2, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
pcmpeqd %xmm3, %xmm6
pand %xmm7, %xmm6
movd %xmm6, %r8d
testb $0x1, %r8b
je 0xd3bf5
movl %edx, -0x4(%rsi,%rdi,4)
pextrw $0x4, %xmm6, %r8d
testb $0x1, %r8b
je 0xd3c04
movl %edx, (%rsi,%rdi,4)
paddq %xmm4, %xmm5
addq $0x2, %rdi
cmpq $0x7, %rdi
jne 0xd3bc9
incq %rdx
addq $0x4, %rcx
cmpq $0xa, %rdx
jne 0xd3bb9
cmpl $0x0, (%rax)
jne 0xd3c71
movq 0x28(%rbx), %rcx
cmpl $0x5, 0x14(%rcx)
jne 0xd3c76
movq 0x48(%rbx), %rcx
cmpl $0x9, 0x38(%rcx)
jne 0xd3c7b
leaq 0x28b42d(%rip), %r14    # 0x35f06c
movq %rax, %rdi
movq %r14, %rsi
movl $0x3f, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3f, %edx
callq 0x1045eb
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
callq 0x23026
callq 0x2305d
callq 0x23094
callq 0x230cb
callq 0x22fef
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array3dim.c
// Function: gt_array3dim_example
int gt_array3dim_example(GT_UNUSED GtError *err)
{
  double ***a3dim;
  int x, y, z;
  gt_error_check(err);

  /* create a 10 x 20 x 30 double array */
  gt_array3dim_malloc(a3dim, 10, 20, 30);

  /* ... (use array a3dim in conventional way via a3dim[x][y][z]) */
  for (x = 1; x < 10; x++) {
    for (y = 1; y < 20; y++) {
      for (z = 1; z < 30; z++)
        a3dim[x][y][z] = x + y + z;
    }
  }

  /* free */
  gt_array3dim_delete(a3dim);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd3c9e
callq 0xfcc32
testb %al, %al
jne 0xd3e7e
leaq 0x28b460(%rip), %r14    # 0x35f105
movl $0x50, %edi
movq %r14, %rsi
movl $0x1c, %edx
callq 0x104226
movq %rax, %rbx
movl $0x640, %edi            # imm = 0x640
movq %r14, %rsi
movl $0x1c, %edx
callq 0x104226
movq %rax, (%rbx)
addq $0xa0, %rax
movl $0x1, %ecx
movq %rax, (%rbx,%rcx,8)
incq %rcx
addq $0xa0, %rax
cmpq $0xa, %rcx
jne 0xd3cda
leaq 0x28b411(%rip), %rsi    # 0x35f105
movl $0xbb80, %edi           # imm = 0xBB80
movl $0x1c, %edx
callq 0x104226
movq (%rbx), %rcx
movq %rax, (%rcx)
movl $0x1, %eax
movl $0xf0, %ecx
movq (%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rsi
addq %rcx, %rsi
movq %rsi, (%rdx,%rax,8)
incq %rax
cmpq $0x14, %rax
jne 0xd3d13
movl $0x1, %eax
movl $0xf0, %ecx
movq -0x8(%rbx,%rax,8), %rdx
movq (%rbx,%rax,8), %rsi
movq 0x98(%rdx), %rdx
addq %rcx, %rdx
movq %rdx, (%rsi)
movl $0x1, %edx
movq (%rbx,%rax,8), %rsi
movq -0x8(%rsi,%rdx,8), %rdi
addq %rcx, %rdi
movq %rdi, (%rsi,%rdx,8)
incq %rdx
cmpq $0x14, %rdx
jne 0xd3d50
incq %rax
cmpq $0xa, %rax
jne 0xd3d35
movl $0x1, %eax
movl $0x4, %ecx
movdqa 0x284c9c(%rip), %xmm0   # 0x358a20
movdqa 0x284ca4(%rip), %xmm1   # 0x358a30
movdqa 0x28b34c(%rip), %xmm2   # 0x35f0e0
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movq (%rbx,%rax,8), %rdx
movl %ecx, %esi
movl $0x1, %edi
movq (%rdx,%rdi,8), %r8
movl %esi, %r9d
xorl %r10d, %r10d
movq %r10, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm0, %xmm4
pxor %xmm1, %xmm4
movdqa %xmm2, %xmm5
pcmpgtd %xmm4, %xmm5
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
pcmpeqd %xmm3, %xmm4
pand %xmm5, %xmm4
movd %xmm4, %r11d
testb $0x1, %r11b
je 0xd3df3
leal -0x1(%r9), %r11d
xorps %xmm5, %xmm5
cvtsi2sd %r11d, %xmm5
movsd %xmm5, 0x8(%r8,%r10,8)
pextrw $0x4, %xmm4, %r11d
testb $0x1, %r11b
je 0xd3e0e
xorps %xmm4, %xmm4
cvtsi2sd %r9d, %xmm4
movsd %xmm4, 0x10(%r8,%r10,8)
addq $0x2, %r10
addl $0x2, %r9d
cmpq $0x1e, %r10
jne 0xd3dae
incq %rdi
incl %esi
cmpq $0x14, %rdi
jne 0xd3da4
incq %rax
incl %ecx
cmpq $0xa, %rax
jne 0xd3d99
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x28b2be(%rip), %r14    # 0x35f105
movq %r14, %rsi
movl $0x27, %edx
callq 0x1045eb
movq (%rbx), %rdi
movq %r14, %rsi
movl $0x27, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x27, %edx
callq 0x1045eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x23102
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bioseq_iterator.c
// Function: gt_bioseq_iterator_new
GtBioseqIterator* gt_bioseq_iterator_new(int seqfile_counter,
                                         const char **sequence_files)
{
  GtBioseqIterator *bsi;
  gt_assert(sequence_files);
  bsi = gt_calloc(1, sizeof *bsi);
  bsi->seqfile_counter = seqfile_counter ? seqfile_counter : 1 /* for stdin */;
  bsi->sequence_files = gt_cstr_array_dup(sequence_files);
  return bsi;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xd63e9
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x28988f(%rip), %rdx    # 0x35fc44
movl $0x1, %edi
movl $0x18, %esi
movl $0x23, %ecx
callq 0x10436a
movq %rax, %r14
cmpl $0x1, %ebp
adcl $0x0, %ebp
movl %ebp, 0x4(%rax)
movq %rbx, %rdi
callq 0xe45d0
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x242ff
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bioseq_iterator.c
// Function: gt_bioseq_iterator_next
int gt_bioseq_iterator_next(GtBioseqIterator *bsi, GtBioseq **bioseq,
                            GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  gt_assert(bsi && bioseq);
  if (bsi->current_file < bsi->seqfile_counter) {
    if (bsi->sequence_files[bsi->current_file] &&
        !strcmp(bsi->sequence_files[bsi->current_file], "-")) {
      if (bsi->stdin_was_used) {
        gt_error_set(err, "multiple specification of sequence file \"-\"");
        had_err = -1;
      }
      else
        bsi->stdin_was_used = true;
    }
    if (!had_err) {
      if (bsi->sequence_files[bsi->current_file])
        *bioseq = gt_bioseq_new(bsi->sequence_files[bsi->current_file], err);
      else
        *bioseq = gt_bioseq_new("-", err);
      if (*bioseq)
        bsi->current_file++;
      else
        had_err = -1;
    }
  }
  else
    *bioseq = NULL;
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xd6435
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xd64b4
testq %rbx, %rbx
je 0xd64af
testq %r15, %r15
je 0xd64af
movslq (%rbx), %rax
cmpl 0x4(%rbx), %eax
jge 0xd6478
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0xd6481
cmpb $0x2d, (%rdi)
jne 0xd6488
cmpb $0x0, 0x1(%rdi)
jne 0xd6488
cmpb $0x1, 0x10(%rbx)
jne 0xd64a9
leaq 0x289819(%rip), %rsi    # 0x35fc85
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
jmp 0xd649e
movq $0x0, (%r15)
jmp 0xd649a
leaq 0x2f1922(%rip), %rdi    # 0x3c7daa
movq %r14, %rsi
callq 0xd4388
movq %rax, (%r15)
testq %rax, %rax
je 0xd649e
incl (%rbx)
xorl %eax, %eax
jmp 0xd64a3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, 0x10(%rbx)
jmp 0xd6488
callq 0x2436d
callq 0x24336
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_FILE_new
GtBitbuffer *gt_bitbuffer_FILE_new(FILE *outfp,GtBitcount_type bitsperentry)
{
  GtBitbuffer *bb = gt_malloc(sizeof *bb);

  if (outfp != NULL)
  {
     bb->bitsinbuffer = (GtBitcount_type) sizeof bb->currentbitbuffer;
  } else
  {
     gt_assert(bitsperentry == 0);
     bb->bitsinbuffer = (GtBitcount_type) CHAR_BIT;
  }
  if (bitsperentry > 0)
  {
    uint8_t bitsperentry8 = (uint8_t) bitsperentry;
    uint64_t writtenbits = 0;

    gt_assert(outfp != NULL);
    (void) fwrite(&writtenbits,sizeof writtenbits,(size_t) 1,outfp);
    (void) fwrite(&bitsperentry8,sizeof bitsperentry8,(size_t) 1,outfp);
  }
  bb->numberofallvalues = 0;
  bb->bitsperentry = bitsperentry;
  bb->currentbitbuffer = 0;
  bb->remainingbitsinbuffer = bb->bitsinbuffer;
  bb->currentuint8 = 0;
  bb->fp = outfp;
  return bb;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2897e1(%rip), %rsi    # 0x35fcb1
movl $0x20, %edi
movl $0x26, %edx
callq 0x104226
movq %rax, %r14
testq %rbx, %rbx
je 0xd6524
movw $0x8, 0x14(%r14)
testw %bp, %bp
je 0xd6530
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
movsbl %bpl, %edi
movq %rbx, %rsi
callq 0x17980
movzwl 0x14(%r14), %eax
jmp 0xd6534
testw %bp, %bp
jne 0xd655a
movw $0x8, 0x14(%r14)
movw $0x8, %ax
movw %bp, 0x12(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movw %ax, 0x10(%r14)
movb $0x0, 0x17(%r14)
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x243a4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_generic_write_FILE
void gt_bitbuffer_generic_write_FILE(GtBitbuffer *bb,
                                     GtUword value,
                                     GtBitcount_type bitsforvalue)
{
  GtBitcount_type bits2store = bitsforvalue;

  gt_assert(bb != NULL && bitsforvalue <= bb->bitsinbuffer);
  bb->numberofallvalues++;
  while (true)
  {
    gt_assert(bits2store > 0);
    if (bb->remainingbitsinbuffer >= bits2store)
    {
      bb->remainingbitsinbuffer -= bits2store;
      bb->currentbitbuffer |= (uint64_t)
                    ((value & ((1UL << bits2store) - 1))
                     << bb->remainingbitsinbuffer);
      break;
    }
    if (bb->remainingbitsinbuffer == 0) /* buffer full */
    {
      (void) fwrite(&bb->currentbitbuffer,sizeof bb->currentbitbuffer,
                    (size_t) 1,bb->fp);
      bb->currentbitbuffer = 0;
      bb->remainingbitsinbuffer = bb->bitsinbuffer;
    } else
    {
      gt_assert(bits2store > bb->remainingbitsinbuffer);
      bits2store -= bb->remainingbitsinbuffer;
      bb->currentbitbuffer
        |= ((uint64_t) value >> bb->remainingbitsinbuffer);
      bb->remainingbitsinbuffer = 0;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd662c
movl %edx, %ebp
movq %rdi, %rbx
cmpw %bp, 0x14(%rdi)
jb 0xd662c
incq 0x8(%rbx)
testw %bp, %bp
je 0xd6602
movq %rsi, %r14
movzwl 0x10(%rbx), %eax
cmpw %bp, %ax
jae 0xd6607
testw %ax, %ax
jne 0xd65e7
movq 0x18(%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x17fa0
movzwl 0x14(%rbx), %eax
xorl %edx, %edx
jmp 0xd65f6
movq %r14, %rdx
movl %eax, %ecx
shrq %cl, %rdx
subl %eax, %ebp
orq (%rbx), %rdx
xorl %eax, %eax
movq %rdx, (%rbx)
movw %ax, 0x10(%rbx)
testw %bp, %bp
jne 0xd65bf
callq 0x243db
movq $-0x1, %rdx
movl %ebp, %ecx
shlq %cl, %rdx
subl %ebp, %eax
notq %rdx
andq %r14, %rdx
movl %eax, %ecx
shlq %cl, %rdx
movw %ax, 0x10(%rbx)
orq %rdx, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x24412
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_write_bytestring
GtUword gt_bitbuffer_write_bytestring(GtBitbuffer *bb,
                                       uint8_t *bytestring,
                                       GtUword bytestring_offset,
                                       GT_UNUSED GtUword bytestring_length,
                                       GtUword value,
                                       GtBitcount_type bitsforvalue)
{
  GtBitcount_type bits2store = bitsforvalue;

  gt_assert(bb != NULL && bb->fp == NULL);
  bb->numberofallvalues++;
  SHOWCURRENT;
  while (true)
  {
    gt_assert(bits2store > 0);
    if (bb->remainingbitsinbuffer >= bits2store)
    {
      bb->remainingbitsinbuffer -= bits2store;
      bb->currentbitbuffer |= (uint64_t)
        ((value & ((1UL << bits2store) - 1)) << bb->remainingbitsinbuffer);
      SHOWCURRENT;
      break;
    }
    if (bb->remainingbitsinbuffer == 0) /* buffer full */
    {
      SHOWCURRENT;
      gt_assert(bytestring_offset < bytestring_length &&
                bb->currentbitbuffer <= UINT8_MAX);
      bytestring[bytestring_offset++] = (uint8_t) bb->currentbitbuffer;
      bb->currentbitbuffer = 0;
      bb->remainingbitsinbuffer = bb->bitsinbuffer;
    } else
    {
      gt_assert(bits2store > bb->remainingbitsinbuffer);
      bits2store -= bb->remainingbitsinbuffer;
      bb->currentbitbuffer |= ((uint64_t) value >> bits2store) & UINT8_MAX;
      bb->remainingbitsinbuffer = 0;
      SHOWCURRENT;
    }
  }
  return bytestring_offset;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xd66dd
cmpq $0x0, 0x18(%rdi)
jne 0xd66dd
incq 0x8(%rdi)
testw %r9w, %r9w
je 0xd66aa
movq %rcx, %rax
movzwl 0x10(%rdi), %r10d
cmpw %r9w, %r10w
jae 0xd66af
testw %r10w, %r10w
jne 0xd6689
cmpq %rax, %rdx
jae 0xd66d8
movq (%rdi), %rcx
cmpq $0x100, %rcx            # imm = 0x100
jae 0xd66d8
movb %cl, (%rsi,%rdx)
incq %rdx
movq $0x0, (%rdi)
movzwl 0x14(%rdi), %r10d
jmp 0xd669f
subl %r10d, %r9d
movq %r8, %r10
movl %r9d, %ecx
shrq %cl, %r10
movzbl %r10b, %ecx
orq %rcx, (%rdi)
xorl %r10d, %r10d
movw %r10w, 0x10(%rdi)
testw %r9w, %r9w
jne 0xd6658
callq 0x24482
movq $-0x1, %rax
movl %r9d, %ecx
shlq %cl, %rax
subl %r9d, %r10d
movw %r10w, 0x10(%rdi)
notq %rax
andq %r8, %rax
movl %r10d, %ecx
shlq %cl, %rax
orq %rax, (%rdi)
movq %rdx, %rax
popq %rcx
retq
callq 0x24449
callq 0x244b9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_write_bytestring_bf
GtUword gt_bitbuffer_write_bytestring_bf(GtBitbuffer *bb,
                                          uint8_t *bytestring,
                                          GtUword bytestring_offset,
                                          GT_UNUSED GtUword bytestring_length,
                                          GtUword value,
                                          GtBitcount_type bitsforvalue)
{
  int shift;

  gt_assert(bitsforvalue > 0);
  for (shift = (int) (bitsforvalue-1); shift >= 0; shift--)
  {
    if (bb->remainingbitsinbuffer == 0)
    {
      gt_assert(bytestring_offset < bytestring_length);
      bytestring[bytestring_offset++] = bb->currentuint8;
      bb->currentuint8 = 0;
      bb->remainingbitsinbuffer = bb->bitsinbuffer;
    }
    if (value & (1UL << shift))
    {
      bb->currentuint8 |= (1 << (bb->remainingbitsinbuffer-1));
    }
    bb->remainingbitsinbuffer--;
  }
  return bytestring_offset;
}

// Assembly:
pushq %rax
testl %r9d, %r9d
je 0xd674a
movq %rcx, %rax
movzwl %r9w, %r9d
movzwl 0x10(%rdi), %r10d
incq %r9
testw %r10w, %r10w
jne 0xd6714
cmpq %rax, %rdx
jae 0xd6745
movb 0x17(%rdi), %cl
movb %cl, (%rsi,%rdx)
incq %rdx
movb $0x0, 0x17(%rdi)
movzwl 0x14(%rdi), %r10d
leaq -0x2(%r9), %rcx
btq %rcx, %r8
jae 0xd672f
leal -0x1(%r10), %ecx
movl $0x1, %r11d
shll %cl, %r11d
orb %r11b, 0x17(%rdi)
decl %r10d
movw %r10w, 0x10(%rdi)
decq %r9
cmpq $0x1, %r9
ja 0xd66f7
movq %rdx, %rax
popq %rcx
retq
callq 0x244f0
callq 0x24529
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_write_uint32tab_FILE
void gt_bitbuffer_write_uint32tab_FILE(GtBitbuffer *bb,const uint32_t *tab,
                                       GtUword len)
{
  const uint32_t *uintptr;

  gt_assert (bb != NULL && tab != NULL);
  for (uintptr = tab; uintptr < tab + len; uintptr++)
  {
    gt_bitbuffer_write_fixed_bits_FILE (bb, (GtUword) *uintptr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd67b5
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd67b5
testq %rdx, %rdx
jle 0xd67af
movq %rdi, %r14
leaq (%rbx,%rdx,4), %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0xd6762
addq $0x4, %rbx
cmpq %r15, %rbx
jb 0xd679c
popq %rbx
popq %r14
popq %r15
retq
callq 0x245d4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_write_ulongtab_FILE
void gt_bitbuffer_write_ulongtab_FILE(GtBitbuffer *bb,
                                      const GtUword *tab,
                                      GtUword len)
{
  const GtUword *ulongptr;

  gt_assert (bb != NULL && tab != NULL);
  for (ulongptr = tab; ulongptr < tab + len; ulongptr++)
  {
    gt_bitbuffer_write_fixed_bits_FILE(bb, *ulongptr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd67f2
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd67f2
testq %rdx, %rdx
jle 0xd67ec
movq %rdi, %r14
leaq (%rbx,%rdx,8), %r15
movq (%rbx), %rsi
movq %r14, %rdi
callq 0xd6762
addq $0x8, %rbx
cmpq %r15, %rbx
jb 0xd67d8
popq %rbx
popq %r14
popq %r15
retq
callq 0x2460d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_flush
void gt_bitbuffer_flush(bool bruteforce,GtBitbuffer *bb,uint8_t *bytestring)
{
  gt_assert(bb != NULL);
  if (bb->remainingbitsinbuffer < bb->bitsinbuffer)
  {
    if (bb->fp != NULL)
    {
      gt_assert(!bruteforce && bytestring == NULL);
      (void) fwrite(&bb->currentbitbuffer,
                    sizeof bb->currentbitbuffer,
                    (size_t) 1,bb->fp);
      if (bb->bitsperentry > 0)
      {
        uint64_t writtenbits = bb->numberofallvalues * bb->bitsperentry;
        (void) fseek(bb->fp,0,SEEK_SET);
        (void) fwrite(&writtenbits,sizeof writtenbits,(size_t) 1,bb->fp);
      }
    } else
    {
      if (bruteforce)
      {
        *bytestring = bb->currentuint8;
      } else
      {
        gt_assert(bb->fp == NULL && bb->currentbitbuffer <= UINT8_MAX);
        *bytestring = (uint8_t) bb->currentbitbuffer;
      }
    }
  }
  bb->currentbitbuffer = 0;
  bb->currentuint8 = 0;
  bb->remainingbitsinbuffer = bb->bitsinbuffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xd68ab
movq %rsi, %rbx
movzwl 0x10(%rsi), %eax
cmpw 0x14(%rsi), %ax
jae 0xd6890
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0xd6877
testq %rdx, %rdx
jne 0xd68b0
testb %dil, %dil
jne 0xd68b0
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x17fa0
movzwl 0x12(%rbx), %eax
testq %rax, %rax
je 0xd6890
imulq 0x8(%rbx), %rax
movq %rsp, %r14
movq %rax, (%r14)
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x17890
movq 0x18(%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x17fa0
jmp 0xd6890
testb %dil, %dil
je 0xd6883
movb 0x17(%rbx), %al
movb %al, (%rdx)
jmp 0xd6890
movq (%rbx), %rax
cmpq $0x100, %rax            # imm = 0x100
jae 0xd68b5
movb %al, (%rdx)
movq $0x0, (%rbx)
movb $0x0, 0x17(%rbx)
movzwl 0x14(%rbx), %eax
movw %ax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x246b8
callq 0x24646
callq 0x2467f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_delete
void gt_bitbuffer_delete(GtBitbuffer *bb)
{
  if (bb != NULL)
  {
    if (bb->fp != NULL)
    {
      gt_bitbuffer_flush(false,bb,NULL);
    }
    gt_free(bb);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xd68eb
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0xd68d6
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd67f7
leaq 0x2893d4(%rip), %rsi    # 0x35fcb1
movq %rbx, %rdi
movl $0x108, %edx            # imm = 0x108
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_read_bytestring
GtUword gt_bitbuffer_read_bytestring(GtBitbuffer *bb,
                                      GtUword *value,
                                      const uint8_t *bytestring,
                                      GtUword bytestring_offset,
                                      GtBitcount_type bitsforvalue)
{
  unsigned int bits2read = bitsforvalue;

  gt_assert(bb != NULL && bb->fp == NULL && bytestring != NULL);
  while (true)
  {
    if (bb->remainingbitsinbuffer == 0)
    {
      bb->readvalue = bytestring[bytestring_offset++];
      bb->remainingbitsinbuffer = bb->bitsinbuffer;
    }
    if (bb->remainingbitsinbuffer >= bits2read)
    {
      bb->remainingbitsinbuffer -= bits2read;
      if (bits2read < bb->bitsinbuffer)
      {
        bb->currentbitbuffer
          |= (uint64_t) (bb->readvalue >> bb->remainingbitsinbuffer) &
             ((((uint64_t) 1) << bits2read) - 1);
        gt_assert(bb->currentbitbuffer < (1UL << bitsforvalue));
      } else
      {
        bb->currentbitbuffer |= bb->readvalue;
      }
      *value = (GtUword) bb->currentbitbuffer;
      bb->currentbitbuffer = 0;
      break;
    } else
    {
      bits2read -= bb->remainingbitsinbuffer;
      bb->currentbitbuffer
        |= ((((uint64_t) bb->readvalue) &
            ((((uint64_t) 1) << bb->remainingbitsinbuffer) - 1))
           << bits2read);
      bb->remainingbitsinbuffer = 0;
    }
  }
  return bytestring_offset;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xd69c3
testq %rdx, %rdx
je 0xd69c3
cmpq $0x0, 0x18(%rdi)
jne 0xd69c3
movq %rcx, %rax
movzwl %r8w, %r9d
movzwl 0x10(%rdi), %ecx
testw %cx, %cx
jne 0xd6939
movb (%rdx,%rax), %cl
incq %rax
movb %cl, 0x16(%rdi)
movzwl 0x14(%rdi), %ecx
movzwl %cx, %ecx
movl %r9d, %r10d
subl %ecx, %r10d
jbe 0xd696e
movq $-0x1, %r9
shlq %cl, %r9
movzbl 0x16(%rdi), %ecx
notl %r9d
andl %ecx, %r9d
movl %r10d, %ecx
shlq %cl, %r9
orq %r9, (%rdi)
movw $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movl %r10d, %r9d
jmp 0xd6927
subl %r9d, %ecx
movw %cx, 0x10(%rdi)
movzwl 0x14(%rdi), %edx
movzbl 0x16(%rdi), %r10d
cmpl %edx, %r9d
jae 0xd69b1
shrl %cl, %r10d
movq $-0x1, %rdx
movl %r9d, %ecx
shlq %cl, %rdx
notl %edx
andl %r10d, %edx
orq (%rdi), %rdx
movq %rdx, (%rdi)
movq %rdx, %r9
movl %r8d, %ecx
shrq %cl, %r9
testq %r9, %r9
je 0xd69b7
callq 0x2472a
movl %r10d, %edx
orq (%rdi), %rdx
movq %rdx, (%rsi)
movq $0x0, (%rdi)
popq %rcx
retq
callq 0x24763
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitbuffer.c
// Function: gt_bitbuffer_read_bytestring_bf
GtUword gt_bitbuffer_read_bytestring_bf(GtBitbuffer *bb,
                                         GtUword *value,
                                         const uint8_t *bytestring,
                                         GtUword bytestring_offset,
                                         GtBitcount_type bitsforvalue)
{
  int shift;

  gt_assert(bb != NULL && bb->fp == NULL && bytestring != NULL);
  gt_assert(bitsforvalue > 0);
  for (shift = (int) (bitsforvalue - 1); shift >= 0; shift--)
  {
    if (bb->remainingbitsinbuffer == 0)
    {
      bb->readvalue = bytestring[bytestring_offset++];
      bb->remainingbitsinbuffer = bb->bitsinbuffer;
    }
    bb->remainingbitsinbuffer--;
    if (bb->readvalue & (1 << bb->remainingbitsinbuffer))
    {
      bb->currentbitbuffer |= (((uint64_t) 1) << shift);
    }
  }
  *value = (GtUword) bb->currentbitbuffer;
  bb->currentbitbuffer = 0;
  return bytestring_offset;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xd6a43
testq %rdx, %rdx
je 0xd6a43
cmpq $0x0, 0x18(%rdi)
jne 0xd6a43
testw %r8w, %r8w
je 0xd6a48
movq %rcx, %rax
movzwl 0x10(%rdi), %r10d
movb 0x16(%rdi), %r9b
movzwl %r8w, %r8d
incq %r8
testw %r10w, %r10w
jne 0xd6a09
movb (%rdx,%rax), %r9b
incq %rax
movb %r9b, 0x16(%rdi)
movzwl 0x14(%rdi), %r10d
decl %r10d
movw %r10w, 0x10(%rdi)
movzbl %r9b, %ecx
btl %r10d, %ecx
jae 0xd6a2b
leaq -0x2(%r8), %rcx
movl $0x1, %r11d
shlq %cl, %r11
orq %r11, (%rdi)
decq %r8
cmpq $0x1, %r8
ja 0xd69f3
movq (%rdi), %rcx
movq %rcx, (%rsi)
movq $0x0, (%rdi)
popq %rcx
retq
callq 0x247d5
callq 0x2479c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/checkbitpackstring.c
// Function: gt_bitPackString_unit_test
int
gt_bitPackString_unit_test(GtError *err)
{
  return gt_bitPackStringInt_unit_test(err)
    || gt_bitPackStringInt8_unit_test(err)
    || gt_bitPackStringInt16_unit_test(err)
    || gt_bitPackStringInt32_unit_test(err)
    || gt_bitPackStringInt64_unit_test(err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2f5acc
movl $0x1, %ebx
testl %eax, %eax
jne 0xd9c1c
movq %r14, %rdi
callq 0xe0268
testl %eax, %eax
jne 0xd9c1c
movq %r14, %rdi
callq 0xd9c28
testl %eax, %eax
jne 0xd9c1c
movq %r14, %rdi
callq 0xdbf28
testl %eax, %eax
jne 0xd9c1c
movq %r14, %rdi
callq 0xde06c
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: gt_bsGetUniformInt16Array
static inline void
gt_bsGetUniformInt16Array(constBitString str, BitOffset offset,
                          unsigned numBits, size_t numValues, int16_t val[])
{
  /* read blocksize many ints at once, for later sign expansion */
  int blockSize = 16 * gt_pagesize() / sizeof (val[0]);
  /* the factor (16) is completely arbitrary and needs some profiling */
  int16_t *blockPtr = val;
  size_t revIndex = numValues;
  BitOffset offsetTemp = offset;
  gt_assert(blockSize >= 0);
  while (revIndex > (size_t)blockSize)
  {
    gt_bsGetUniformUInt16Array(str, offsetTemp, numBits,
                               blockSize, (uint16_t *)blockPtr);
    bsSignExpandArray16(blockPtr, blockSize, numBits);
    blockPtr += blockSize;
    revIndex -= blockSize;
    offsetTemp += blockSize * numBits;
  }
  gt_bsGetUniformUInt16Array(str, offsetTemp, numBits,
                             revIndex, (uint16_t *)blockPtr);
  bsSignExpandArray16(blockPtr, revIndex, numBits);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
callq 0xe3e95
leal (,%rax,8), %edx
testl %edx, %edx
js 0xdbf23
movl %edx, %r13d
cmpq %r14, %r13
movq %r15, 0x18(%rsp)
jae 0xdbece
movq %rax, %rbp
leal -0x1(%r15), %ecx
movl $0x10000, %eax          # imm = 0x10000
shll %cl, %eax
movq %r15, %rcx
movl %edx, 0xc(%rsp)
movl %edx, %r15d
imull %ecx, %r15d
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
psrad $0x10, %xmm2
andl $0x1fffffff, %ebp       # imm = 0x1FFFFFFF
shlq $0x4, %rbp
movdqa %xmm2, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x2f1667
movdqa 0x20(%rsp), %xmm2
cmpl $0x0, 0xc(%rsp)
je 0xdbec0
xorl %eax, %eax
movdqu (%rbx,%rax,2), %xmm0
movdqa %xmm0, %xmm1
punpcklwd %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3]
punpckhwd %xmm0, %xmm0    # xmm0 = xmm0[4,4,5,5,6,6,7,7]
pxor %xmm2, %xmm0
pxor %xmm2, %xmm1
psubd %xmm2, %xmm1
psubd %xmm2, %xmm0
pslld $0x10, %xmm0
psrad $0x10, %xmm0
pslld $0x10, %xmm1
psrad $0x10, %xmm1
packssdw %xmm0, %xmm1
movdqu %xmm1, (%rbx,%rax,2)
addq $0x8, %rax
cmpq %rax, %r13
jne 0xdbe79
addq %rbp, %rbx
subq %r13, %r14
addq %r15, %r12
cmpq %r13, %r14
ja 0xdbe52
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq 0x18(%rsp), %r15
movl %r15d, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x2f1667
testq %r14, %r14
je 0xdbf14
decb %r15b
movl $0x10000, %eax          # imm = 0x10000
movl %r15d, %ecx
shll %cl, %eax
sarl $0x10, %eax
xorl %ecx, %ecx
movzwl (%rbx,%rcx,2), %edx
xorl %eax, %edx
subl %eax, %edx
movw %dx, (%rbx,%rcx,2)
incq %rcx
cmpq %rcx, %r14
jne 0xdbf00
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2533d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: gt_bsGetUniformInt32Array
static inline void
gt_bsGetUniformInt32Array(constBitString str, BitOffset offset,
                          unsigned numBits, size_t numValues, int32_t val[])
{
  /* read blocksize many ints at once, for later sign expansion */
  int blockSize = 16 * gt_pagesize() / sizeof (val[0]);
  /* the factor (16) is completely arbitrary and needs some profiling */
  int32_t *blockPtr = val;
  size_t revIndex = numValues;
  BitOffset offsetTemp = offset;
  gt_assert(blockSize >= 0);
  while (revIndex > (size_t) blockSize)
  {
    gt_bsGetUniformUInt32Array(str, offsetTemp, numBits,
                               blockSize, (uint32_t *)blockPtr);
    bsSignExpandArray32(blockPtr, blockSize, numBits);
    blockPtr += blockSize;
    revIndex -= blockSize;
    offsetTemp += blockSize * numBits;
  }
  gt_bsGetUniformUInt32Array(str, offsetTemp, numBits,
                             revIndex, (uint32_t *)blockPtr);
  bsSignExpandArray32(blockPtr, revIndex, numBits);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
callq 0xe3e95
movq %rax, %rsi
leal (,%rax,4), %eax
testl %eax, %eax
js 0xde064
movl %eax, %r13d
leal -0x1(%rbp), %ecx
movl $0x1, %r15d
shll %cl, %r15d
cmpq %r14, %r13
movq %rbp, %rdx
jae 0xde027
movl %eax, 0x4(%rsp)
imull %edx, %eax
movq %rax, 0x10(%rsp)
movd %r15d, %xmm0
pshufd $0x0, %xmm0, %xmm1      # xmm1 = xmm0[0,0,0,0]
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
shlq $0x4, %rsi
movq %rsi, 0x18(%rsp)
movdqa %xmm1, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %rdx, %rbp
movq %r13, %rcx
movq %rbx, %r8
callq 0x2f280c
movdqa 0x20(%rsp), %xmm1
cmpl $0x0, 0x4(%rsp)
je 0xde012
xorl %eax, %eax
movdqu (%rbx,%rax,4), %xmm0
pxor %xmm1, %xmm0
psubd %xmm1, %xmm0
movdqu %xmm0, (%rbx,%rax,4)
addq $0x4, %rax
cmpq %rax, %r13
jne 0xddff7
addq 0x18(%rsp), %rbx
subq %r13, %r14
addq 0x10(%rsp), %r12
cmpq %r13, %r14
movq %rbp, %rdx
ja 0xddfd2
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x2f280c
testq %r14, %r14
je 0xde055
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
xorl %r15d, %ecx
subl %r15d, %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r14
jne 0xde041
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x25505
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: gt_bsGetUniformInt64Array
static inline void
gt_bsGetUniformInt64Array(constBitString str, BitOffset offset,
                          unsigned numBits, size_t numValues, int64_t val[])
{
  /* read blocksize many ints at once, for later sign expansion */
  int blockSize = 16 * gt_pagesize() / sizeof (val[0]);
  /* the factor (16) is completely arbitrary and needs some profiling */
  int64_t *blockPtr = val;
  size_t revIndex = numValues;
  BitOffset offsetTemp = offset;
  gt_assert(blockSize >= 0);
  while (revIndex > (size_t) blockSize)
  {
    gt_bsGetUniformUInt64Array(str, offsetTemp, numBits,
                               blockSize, (uint64_t *)blockPtr);
    bsSignExpandArray64(blockPtr, blockSize, numBits);
    blockPtr += blockSize;
    revIndex -= blockSize;
    offsetTemp += blockSize * numBits;
  }
  gt_bsGetUniformUInt64Array(str, offsetTemp, numBits,
                             revIndex, (uint64_t *)blockPtr);
  bsSignExpandArray64(blockPtr, revIndex, numBits);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
callq 0xe3e95
movq %rax, %rsi
addl %eax, %eax
js 0xe0263
movl %eax, %r13d
leal -0x1(%rbp), %ecx
movl $0x1, %r15d
shlq %cl, %r15
cmpq %r14, %r13
movq %rbp, %rdx
jae 0xe0224
movl %eax, 0x4(%rsp)
imull %edx, %eax
movq %rax, 0x10(%rsp)
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm1     # xmm1 = xmm0[0,1,0,1]
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x4, %rsi
movq %rsi, 0x18(%rsp)
movdqa %xmm1, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %rdx, %rbp
movq %r13, %rcx
movq %rbx, %r8
callq 0x2f395a
movdqa 0x20(%rsp), %xmm1
cmpl $0x0, 0x4(%rsp)
je 0xe020f
xorl %eax, %eax
movdqu (%rbx,%rax,8), %xmm0
pxor %xmm1, %xmm0
psubq %xmm1, %xmm0
movdqu %xmm0, (%rbx,%rax,8)
addq $0x2, %rax
cmpq %rax, %r13
jne 0xe01f4
addq 0x18(%rsp), %rbx
subq %r13, %r14
addq 0x10(%rsp), %r12
cmpq %r13, %r14
movq %rbp, %rdx
ja 0xe01cf
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x2f395a
testq %r14, %r14
je 0xe0254
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
xorq %r15, %rcx
subq %r15, %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xe023e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x256cd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator_encseq.c
// Function: gt_codon_iterator_encseq_class
const GtCodonIteratorClass* gt_codon_iterator_encseq_class(void)
{
  static const GtCodonIteratorClass *cic = NULL;
  gt_class_alloc_lock_enter();
  if (!cic)
  {
    cic = gt_codon_iterator_class_new(sizeof (GtCodonIteratorEncseq),
                                      gt_codon_iterator_encseq_delete,
                                      gt_codon_iterator_encseq_current_position,
                                      gt_codon_iterator_encseq_length,
                                      gt_codon_iterator_encseq_rewind,
                                      gt_codon_iterator_encseq_next);
  }
  gt_class_alloc_lock_leave();
  return cic;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x3dbd86(%rip)    # 0x4be4b8
jne 0xe2768
leaq 0x3b(%rip), %rsi        # 0xe2776
leaq 0x58(%rip), %rdx        # 0xe279a
leaq 0x65(%rip), %rcx        # 0xe27ae
leaq 0x71(%rip), %r8         # 0xe27c1
leaq 0x77(%rip), %r9         # 0xe27ce
movl $0x20, %edi
callq 0xe255c
movq %rax, 0x3dbd50(%rip)    # 0x4be4b8
callq 0xe2545
movq 0x3dbd44(%rip), %rax    # 0x4be4b8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator_encseq.c
// Function: gt_codon_iterator_encseq_new_with_readmode
GtCodonIterator* gt_codon_iterator_encseq_new_with_readmode(GtEncseq *encseq,
                                                         GtUword startpos,
                                                         GtUword length,
                                                         GtReadmode readmode,
                                                         GT_UNUSED GtError *err)
{
  GtCodonIteratorEncseq *cie;
  GtCodonIterator *ci;
  gt_assert(encseq && startpos + length - 1 < gt_encseq_total_length(encseq));
  gt_error_check(err);
  ci = gt_codon_iterator_create(gt_codon_iterator_encseq_class());
  cie = gt_codon_iterator_encseq_cast(ci);
  cie->encseq = gt_encseq_ref(encseq);
  cie->readmode = readmode;
  ci->pvt->length = length;
  ci->pvt->curpos = 0;
  ci->pvt->startpos = startpos;
  return ci;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe29b1
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq (%rsi,%rdx), %r13
decq %r13
callq 0xe7b9c
cmpq %rax, %r13
jae 0xe29b1
testq %r12, %r12
je 0xe2958
movq %r12, %rdi
callq 0xfcc32
testb %al, %al
jne 0xe29b6
callq 0xe2724
movq %rax, %rdi
callq 0xe25b3
movq %rax, %r12
callq 0xe2724
movq %rax, %rdi
movq %r12, %rsi
callq 0xe2610
movq %rax, %r13
movq %r15, %rdi
callq 0xea9be
movq %rax, 0x18(%r13)
movl %ebp, 0x10(%r13)
movq 0x8(%r12), %rax
movq %r14, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x25c3e
callq 0x25c07
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/compact_ulong_store.c
// Function: gt_compact_ulong_store_new
GtCompactUlongStore *gt_compact_ulong_store_new(GtUword numofentries,
                                                unsigned int bitsperentry)
{
  GtCompactUlongStore *cus;
  GtUword arraysize, totalbits;

  /* if this assertion appears, then probably the 32-bit version of the
     code is used. Better use the 64-bit version by compiling with
     64bit=yes */
  gt_assert(numofentries <= ULONG_MAX/bitsperentry);
  gt_assert(bitsperentry <= (unsigned int) GT_INTWORDSIZE);
  totalbits = numofentries * bitsperentry;
  cus = gt_malloc(sizeof (*cus));
  cus->numofentries = numofentries;
  arraysize = GT_DIVWORDSIZE(totalbits);
  if (GT_MODWORDSIZE(totalbits) > 0) {
    arraysize++;
  }
  cus->tab = gt_calloc((size_t) arraysize,sizeof (*cus->tab));
  cus->bitsperentry = bitsperentry;
  cus->bitsleft = (unsigned int) GT_INTWORDSIZE - cus->bitsperentry;
  cus->maskright = ~0UL >> cus->bitsleft;
  return cus;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %r15, %rax
mulq %rdi
jo 0xe3bb8
movl %esi, %ebx
cmpl $0x41, %esi
jae 0xe3bbd
movq %rdi, %r12
imulq %rdi, %r15
leaq 0x27ed24(%rip), %r13    # 0x36286d
movl $0x20, %edi
movq %r13, %rsi
movl $0x30, %edx
callq 0x104226
movq %rax, %r14
movq %r12, 0x8(%rax)
movq %r15, %rdi
shrq $0x6, %rdi
andl $0x3f, %r15d
cmpq $0x1, %r15
sbbq $-0x1, %rdi
movl $0x8, %esi
movq %r13, %rdx
movl $0x36, %ecx
callq 0x10436a
movq %rax, (%r14)
movl %ebx, 0x18(%r14)
movl $0x40, %eax
subl %ebx, %eax
negl %ebx
movq $-0x1, %rdx
movl %ebx, %ecx
shrq %cl, %rdx
movl %eax, 0x1c(%r14)
movq %rdx, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2608a
callq 0x26053
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/compact_ulong_store.c
// Function: gt_compact_ulong_store_get
GtUword gt_compact_ulong_store_get(const GtCompactUlongStore *cus,
                                         GtUword idx)
{
  unsigned int unitoffset;
  GtUword unitindex;

  gt_assert(idx < cus->numofentries);
  idx *= cus->bitsperentry;
  unitoffset = (unsigned int) GT_MODWORDSIZE(idx);
  unitindex = GT_DIVWORDSIZE(idx);
  if (unitoffset <= (unsigned int) cus->bitsleft) {
    return (GtUword) (cus->tab[unitindex] >>
                             (cus->bitsleft - unitoffset))
           & cus->maskright;
  } else {
    return (GtUword)
           ((cus->tab[unitindex] <<
                (unitoffset + cus->bitsperentry - GT_INTWORDSIZE)) |
              (cus->tab[unitindex+1] >>
                (GT_INTWORDSIZE + cus->bitsleft - unitoffset))) &
           cus->maskright;
  }
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
jbe 0xe3c72
movl 0x18(%rdi), %ecx
imulq %rcx, %rsi
movl %esi, %r8d
andl $0x3f, %r8d
shrq $0x6, %rsi
movl 0x1c(%rdi), %edx
movq (%rdi), %r9
movq (%r9,%rsi,8), %rax
subl %r8d, %edx
jae 0xe3c68
addl %r8d, %ecx
shlq %cl, %rax
movq 0x8(%r9,%rsi,8), %rsi
movl %edx, %ecx
shrq %cl, %rsi
orq %rsi, %rax
jmp 0xe3c6d
movl %edx, %ecx
shrq %cl, %rax
andq 0x10(%rdi), %rax
retq
pushq %rax
callq 0x260f8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/compact_ulong_store.c
// Function: gt_compact_ulong_store_update
void gt_compact_ulong_store_update(GtCompactUlongStore *cus,
                                   GtUword idx, GtUword value)
{
  unsigned int unitoffset;
  GtUword unitindex;

  gt_assert(idx < cus->numofentries && value <= cus->maskright);
  idx *= cus->bitsperentry;
  unitoffset = (unsigned int) GT_MODWORDSIZE(idx);
  unitindex = GT_DIVWORDSIZE(idx);
  if (unitoffset <= (unsigned int) cus->bitsleft) {
    unsigned int shiftleft = cus->bitsleft - unitoffset;

    cus->tab[unitindex]
      = (GtUword) (cus->tab[unitindex] & ~(cus->maskright << shiftleft)) |
        (GtUword) (value << shiftleft);
  } else {
    unsigned int shift = unitoffset - cus->bitsleft;

    cus->tab[unitindex]
      = (GtUword) (cus->tab[unitindex] & ~(cus->maskright >> shift)) |
        (GtUword)(value >> shift);
    shift = (unsigned int) GT_INTWORDSIZE - shift;
    cus->tab[unitindex+1]
      = (GtUword) (cus->tab[unitindex+1] & ~(cus->maskright << shift)) |
        (GtUword) (value << shift);
  }
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
jbe 0xe3cf0
movq 0x10(%rdi), %r8
cmpq %rdx, %r8
jb 0xe3cf0
movl 0x18(%rdi), %r9d
imulq %rsi, %r9
movl %r9d, %r10d
andl $0x3f, %r10d
movl 0x1c(%rdi), %ecx
shrq $0x6, %r9
movl %r10d, %eax
movq (%rdi), %rsi
leaq (%rsi,%r9,8), %rsi
movq (%rsi), %r9
subl %ecx, %eax
jbe 0xe3cda
movl %eax, %ecx
shrq %cl, %r8
notq %r8
movq %rdx, %r10
shrq %cl, %r10
andq %r8, %r9
orq %r9, %r10
movq %r10, (%rsi)
movl $0x40, %ecx
subl %eax, %ecx
movq 0x8(%rsi), %r9
addq $0x8, %rsi
movq 0x10(%rdi), %r8
jmp 0xe3cdd
subl %r10d, %ecx
shlq %cl, %r8
shlq %cl, %rdx
notq %r8
andq %r9, %r8
orq %r8, %rdx
movq %rdx, (%rsi)
retq
pushq %rax
callq 0x2612f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/countingsort.c
// Function: gt_countingsort
void gt_countingsort(void *out, const void *in, size_t elem_size,
                     GtUword size, GtUword max_elemvalue,
                     void *data, GtGetElemvalue get_elemvalue)
{
  GtUword i, k, *c;
  gt_assert(out && in && elem_size && size && max_elemvalue && get_elemvalue);

  /* allocate count array */
  c = gt_calloc(sizeof (GtUword), max_elemvalue + 1);

  /* count number of elements of a given value */
  for (i = 0; i < size; i++) {
    k = get_elemvalue((const char*) in + elem_size * i, data);
    gt_assert(k <= max_elemvalue);
    c[k]++;
  }

  /* compute running sum of the count array */
  for (i = 1; i <= max_elemvalue; i++)
    c[i] += c[i-1];

  /* sorting (stable) */
  for (i = size; i > 0; i--) {
    k = get_elemvalue((const char*) in + elem_size * (i-1), data);
    memcpy((char*) out + elem_size * (c[k] - 1),
           (const char*) in + elem_size * (i-1), elem_size);
    c[k]--;
  }

  gt_free(c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, (%rsp)
movq %rdi, 0x20(%rsp)
testq %rdi, %rdi
je 0xe4008
movq %rsi, %r13
testq %rsi, %rsi
je 0xe4008
movq %rdx, %r15
testq %rdx, %rdx
je 0xe4008
movq %rcx, %r14
testq %rcx, %rcx
je 0xe4008
cmpq $0x0, (%rsp)
je 0xe4008
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xe4008
movq (%rsp), %rax
leaq 0x1(%rax), %rsi
leaq 0x27eafb(%rip), %rdx    # 0x362a11
movl $0x8, %edi
movq %rsi, 0x18(%rsp)
movl $0x20, %ecx
callq 0x10436a
movq %rax, %rbp
movq %r13, %r12
movq %r14, %rbx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq %r12, %rdi
callq *%rax
cmpq (%rsp), %rax
ja 0xe4003
incq (%rbp,%rax,8)
addq %r15, %r12
decq %rbx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
jne 0xe3f3d
movq 0x18(%rsp), %rcx
cmpq $0x3, %rcx
movl $0x2, %eax
cmovaeq %rcx, %rax
movq (%rbp), %rcx
movl $0x1, %edx
addq (%rbp,%rdx,8), %rcx
movq %rcx, (%rbp,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xe3f7e
leaq -0x1(%r14), %rax
imulq %r15, %rax
addq %rax, %r13
movq %r15, %rax
negq %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rbx
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq *0x8(%rsp)
movq %rax, %r12
movq (%rbp,%rax,8), %rdi
decq %rdi
imulq %r15, %rdi
addq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x17660
decq (%rbp,%r12,8)
addq (%rsp), %r13
decq %r14
jne 0xe3faa
leaq 0x27ea29(%rip), %rsi    # 0x362a11
movq %rbp, %rdi
movl $0x35, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1045eb
callq 0x2619d
callq 0x26166
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/countingsort.c
// Function: gt_countingsort_get_max
GtUword gt_countingsort_get_max(const void *in, size_t elem_size,
                                      GtUword size, void *data,
                                      GtGetElemvalue get_elemvalue)
{
  GtUword i, value, max_value = 0;
  for (i = 0; i < size; i++) {
    value = get_elemvalue((const char*) in + elem_size * i, data);
    if (value > max_value)
      max_value = value;
  }
  return max_value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xe4048
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbp
xorl %r12d, %r12d
movq %rbp, %rdi
movq %r14, %rsi
callq *%rbx
cmpq %r12, %rax
cmovaq %rax, %r12
addq %r13, %rbp
decq %r15
jne 0xe402f
jmp 0xe404b
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/countingsort.c
// Function: gt_countingsort_unit_test
int gt_countingsort_unit_test(GtError *err)
{
  unsigned int numbers[]        = { 1, 2, 1, 2, 0 }, numbers_out[5],
               sorted_numbers[] = { 0, 1, 1, 2, 2 };
  int had_err = 0;
  gt_error_check(err);
  gt_countingsort(numbers_out, numbers, sizeof (unsigned int), 5,
                  gt_countingsort_get_max(numbers, sizeof (unsigned int), 5,
                                          NULL, get_int),
                  NULL,  get_int);
  gt_ensure(
         !memcmp(sorted_numbers, numbers_out, sizeof (unsigned int) * 5));
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movaps 0x27ea2e(%rip), %xmm0   # 0x362aa0
movaps %xmm0, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0xe4094
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xe4155
xorl %r15d, %r15d
xorl %r14d, %r14d
leaq (%rsp,%r15), %rdi
addq $0x10, %rdi
callq 0xe415a
cmpq %r14, %rax
cmovaq %rax, %r14
addq $0x4, %r15
cmpq $0x14, %r15
jne 0xe409a
leaq 0x9b(%rip), %rax        # 0xe415a
movq %rax, (%rsp)
xorl %r15d, %r15d
leaq 0x30(%rsp), %r12
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
movl $0x5, %ecx
movq %r12, %rdi
movq %r14, %r8
xorl %r9d, %r9d
callq 0xe3ea0
movdqa (%r12), %xmm0
movd 0x10(%r12), %xmm1
pcmpeqb 0x27e8a3(%rip), %xmm1   # 0x3629a0
pcmpeqb 0x27e8ab(%rip), %xmm0   # 0x3629b0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0xe4146
leaq 0x27a323(%rip), %rsi    # 0x35e43e
leaq 0x27e934(%rip), %rdx    # 0x362a56
leaq 0x27e913(%rip), %rcx    # 0x362a3c
leaq 0x27e8e1(%rip), %r8     # 0x362a11
movq %rbx, %rdi
movl $0x56, %r9d
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x261d4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_set_bit
void gt_dyn_bittab_set_bit(GtDynBittab *b, GtUword bit)
{
  GtUword new_tabsize;
  gt_assert(b);
  /* make sure tab is large enough */
  if (bit >= b->num_of_bits) {
    if ((new_tabsize = determine_tabsize(bit + 1)) > b->tabsize) {
      b->tabptr = gt_realloc(b->tabptr, new_tabsize * sizeof (GtUword));
      memset(b->tabptr + b->tabsize, 0,
             (new_tabsize - b->tabsize) * sizeof (GtUword));
      b->tabsize = new_tabsize;
    }
    b->num_of_bits = bit + 1;
  }
  /* set bit */
  b->tabptr[(bit >> 3) / sizeof (GtUword)] |=
    1UL << (bit & (8UL * sizeof (GtUword) - 1));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xe6e4d
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, 0x10(%rdi)
jbe 0xe6dce
movq %r14, %r15
shrq $0x6, %r15
jmp 0xe6e31
leaq 0x1(%r14), %r12
movq %r14, %r15
shrq $0x6, %r15
leaq 0x1(%r15), %rax
cmpq $0x40, %r12
movl $0x1, %r13d
cmovaeq %rax, %r13
cmpq 0x8(%rbx), %r13
jbe 0xe6e2d
movq (%rbx), %rdi
leaq (,%r13,8), %rsi
leaq 0x27c85d(%rip), %rdx    # 0x363660
movl $0x31, %ecx
callq 0x104461
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq (%rax,%rcx,8), %rdi
movq %r13, %rdx
subq %rcx, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x173a0
movq %r13, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl $0x1, %eax
movl %r14d, %ecx
shlq %cl, %rax
movq (%rbx), %rcx
orq %rax, (%rcx,%r15,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2710c