LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array2dim.c
// Function: gt_array2dim_example
int gt_array2dim_example(GT_UNUSED GtError *err)
{
  double **a2dim;
  int i, j;
  gt_error_check(err);

  /* create a 10 x 20 double array */
  gt_array2dim_malloc(a2dim, 10, 20);

  /* ... (use array a2dim in conventional way via a2dim[row][column]) */
  for (i = 1; i < 10; i++) {
    for (j = 1; j < 20; j++)
      a2dim[i][j] = i + j;
  }

  /* free */
  gt_array2dim_delete(a2dim);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd5f8a
callq 0x101a9a
testb %al, %al
jne 0xd60ae
leaq 0x292194(%rip), %r14    # 0x368125
movl $0x50, %edi
movq %r14, %rsi
movl $0x1d, %edx
callq 0x1092b2
movq %rax, %rbx
movl $0x640, %edi            # imm = 0x640
movq %r14, %rsi
movl $0x1d, %edx
callq 0x1092b2
movq %rax, (%rbx)
addq $0xa0, %rax
movl $0x1, %ecx
movq %rax, (%rbx,%rcx,8)
incq %rcx
addq $0xa0, %rax
cmpq $0xa, %rcx
jne 0xd5fc6
movl $0x1, %eax
movl $0x3, %ecx
movdqa 0x28ba85(%rip), %xmm0   # 0x361a70
movdqa 0x28ba8d(%rip), %xmm1   # 0x361a80
movdqa 0x292105(%rip), %xmm2   # 0x368100
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movq (%rbx,%rax,8), %rdx
movl %ecx, %esi
xorl %edi, %edi
movq %rdi, %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, %r8d
testb $0x1, %r8b
je 0xd604c
leal -0x1(%rsi), %r8d
xorps %xmm5, %xmm5
cvtsi2sd %r8d, %xmm5
movsd %xmm5, 0x8(%rdx,%rdi,8)
pextrw $0x4, %xmm4, %r8d
testb $0x1, %r8b
je 0xd6065
xorps %xmm4, %xmm4
cvtsi2sd %esi, %xmm4
movsd %xmm4, 0x10(%rdx,%rdi,8)
addq $0x2, %rdi
addl $0x2, %esi
cmpq $0x14, %rdi
jne 0xd6008
incq %rax
incl %ecx
cmpq $0xa, %rax
jne 0xd6000
movq (%rbx), %rdi
leaq 0x29209e(%rip), %r14    # 0x368125
movq %r14, %rsi
movl $0x26, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x26, %edx
callq 0x109670
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x23498
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xd60d0
callq 0x101a9a
testb %al, %al
jne 0xd624e
leaq 0x8(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
movq $0x6, (%rax)
incq %rcx
addq $0x10, %rax
cmpq $0xa, %rcx
jne 0xd60d7
cmpq $0x0, (%rsp)
jne 0xd623a
leaq 0x29206b(%rip), %r14    # 0x36816c
movl $0x50, %edi
movq %r14, %rsi
movl $0x32, %edx
callq 0x1092b2
movq %rax, %rbx
movl $0x3c, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x32, %ecx
callq 0x1093ef
movq %rax, (%rbx)
movl $0x8, %ecx
movq -0x10(%rsp,%rcx,2), %rdx
movq -0x8(%rsp,%rcx,2), %rsi
leaq (%rax,%rdx,4), %rax
leaq (%rax,%rsi,4), %rax
movq (%rsp,%rcx,2), %rdx
shlq $0x2, %rdx
subq %rdx, %rax
movq %rax, (%rbx,%rcx)
addq $0x8, %rcx
cmpq $0x50, %rcx
jne 0xd6135
xorl %eax, %eax
movdqa 0x28b906(%rip), %xmm0   # 0x361a70
movdqa 0x28b90e(%rip), %xmm1   # 0x361a80
movdqa 0x291fc6(%rip), %xmm2   # 0x368140
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x28b909(%rip), %xmm4   # 0x361a90
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
addq %rax, %rdx
movl $0x1, %esi
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, %edi
testb $0x1, %dil
je 0xd61c4
movl %ecx, -0x4(%rdx,%rsi,4)
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xd61d2
movl %ecx, (%rdx,%rsi,4)
paddq %xmm4, %xmm5
addq $0x2, %rsi
cmpq $0x7, %rsi
jne 0xd6199
incq %rcx
addq $0x4, %rax
cmpq $0xa, %rcx
jne 0xd6189
movq (%rbx), %rdi
cmpl $0x0, (%rdi)
jne 0xd623f
movq 0x28(%rbx), %rax
cmpl $0x5, 0x14(%rax)
jne 0xd6244
movq 0x48(%rbx), %rax
cmpl $0x9, 0x38(%rax)
jne 0xd6249
leaq 0x291f5c(%rip), %r14    # 0x36816c
movq %r14, %rsi
movl $0x3f, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3f, %edx
callq 0x109670
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
callq 0x23506
callq 0x2353d
callq 0x23574
callq 0x235ab
callq 0x234cf
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xd626a
callq 0x101a9a
testb %al, %al
jne 0xd644a
leaq 0x291f94(%rip), %r14    # 0x368205
movl $0x50, %edi
movq %r14, %rsi
movl $0x1c, %edx
callq 0x1092b2
movq %rax, %rbx
movl $0x640, %edi            # imm = 0x640
movq %r14, %rsi
movl $0x1c, %edx
callq 0x1092b2
movq %rax, (%rbx)
addq $0xa0, %rax
movl $0x1, %ecx
movq %rax, (%rbx,%rcx,8)
incq %rcx
addq $0xa0, %rax
cmpq $0xa, %rcx
jne 0xd62a6
leaq 0x291f45(%rip), %rsi    # 0x368205
movl $0xbb80, %edi           # imm = 0xBB80
movl $0x1c, %edx
callq 0x1092b2
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 0xd62df
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 0xd631c
incq %rax
cmpq $0xa, %rax
jne 0xd6301
movl $0x1, %eax
movl $0x4, %ecx
movdqa 0x28b720(%rip), %xmm0   # 0x361a70
movdqa 0x28b728(%rip), %xmm1   # 0x361a80
movdqa 0x291e80(%rip), %xmm2   # 0x3681e0
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 0xd63bf
leal -0x1(%r9), %r11d
xorps %xmm5, %xmm5
cvtsi2sd %r11d, %xmm5
movsd %xmm5, 0x8(%r8,%r10,8)
pextrw $0x4, %xmm4, %r11d
testb $0x1, %r11b
je 0xd63da
xorps %xmm4, %xmm4
cvtsi2sd %r9d, %xmm4
movsd %xmm4, 0x10(%r8,%r10,8)
addq $0x2, %r10
addl $0x2, %r9d
cmpq $0x1e, %r10
jne 0xd637a
incq %rdi
incl %esi
cmpq $0x14, %rdi
jne 0xd6370
incq %rax
incl %ecx
cmpq $0xa, %rax
jne 0xd6365
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x291df2(%rip), %r14    # 0x368205
movq %r14, %rsi
movl $0x27, %edx
callq 0x109670
movq (%rbx), %rdi
movq %r14, %rsi
movl $0x27, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x27, %edx
callq 0x109670
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x235e2
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xd8a45
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x290333(%rip), %rdx    # 0x368d44
movl $0x1, %edi
movl $0x18, %esi
movl $0x23, %ecx
callq 0x1093ef
movq %rax, %r14
cmpl $0x1, %ebp
adcl $0x0, %ebp
movl %ebp, 0x4(%rax)
movq %rbx, %rdi
callq 0xe8aa0
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x247df
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xd8a98
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0xd8b33
testq %rbx, %rbx
je 0xd8b2e
testq %r15, %r15
je 0xd8b2e
movslq (%rbx), %rax
cmpl 0x4(%rbx), %eax
jge 0xd8aeb
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %r12
testq %r12, %r12
je 0xd8afd
leaq 0x2f8a0c(%rip), %rsi    # 0x3d14d2
movq %r12, %rdi
callq 0x17a40
testl %eax, %eax
jne 0xd8af8
cmpb $0x1, 0x10(%rbx)
jne 0xd8af4
leaq 0x2902a6(%rip), %rsi    # 0x368d85
movq %r14, %rdi
xorl %eax, %eax
callq 0x1019cf
jmp 0xd8b1d
movq $0x0, (%r15)
jmp 0xd8b19
movb $0x1, 0x10(%rbx)
testq %r12, %r12
jne 0xd8b04
leaq 0x2f89ce(%rip), %r12    # 0x3d14d2
movq %r12, %rdi
movq %r14, %rsi
callq 0xd69c0
movq %rax, (%r15)
testq %rax, %rax
je 0xd8b1d
incl (%rbx)
xorl %eax, %eax
jmp 0xd8b22
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2484d
callq 0x24816
// File: /workspace/github_c_makefile_star2_O1/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 0x290265(%rip), %rsi    # 0x368db1
movl $0x20, %edi
movl $0x26, %edx
callq 0x1092b2
movq %rax, %r14
testq %rbx, %rbx
setne %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
je 0xd8bd5
movw $0x8, 0x14(%r14)
testw %bp, %bp
je 0xd8baa
movq $0x0, 0x8(%rsp)
testq %rbx, %rbx
je 0xd8bda
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
movsbl %bpl, %edi
movq %rbx, %rsi
callq 0x17980
movw %bp, 0x12(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movzwl 0x14(%r14), %eax
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 0x24884
callq 0x248bb
// File: /workspace/github_c_makefile_star2_O1/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 0xd8cae
movl %edx, %ebp
movq %rdi, %rbx
cmpw %bp, 0x14(%rdi)
jb 0xd8cae
incq 0x8(%rbx)
testw %bp, %bp
je 0xd8c84
movq %rsi, %r14
movzwl 0x10(%rbx), %eax
cmpw %bp, %ax
jae 0xd8c89
testq %rax, %rax
je 0xd8c5a
subl %eax, %ebp
movq %r14, %rdx
movl %eax, %ecx
shrq %cl, %rdx
orq %rdx, (%rbx)
xorl %eax, %eax
jmp 0xd8c7b
movq 0x18(%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x17fa0
movq $0x0, (%rbx)
movzwl 0x14(%rbx), %eax
movw %ax, 0x10(%rbx)
testw %bp, %bp
jne 0xd8c3b
callq 0x248f2
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 0x24929
// File: /workspace/github_c_makefile_star2_O1/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 0xd8d5c
cmpq $0x0, 0x18(%rdi)
jne 0xd8d5c
incq 0x8(%rdi)
testw %r9w, %r9w
je 0xd8d29
movq %rcx, %rax
movzwl 0x10(%rdi), %r10d
cmpw %r9w, %r10w
jae 0xd8d2e
testw %r10w, %r10w
je 0xd8cfd
subl %r10d, %r9d
movq %r8, %r10
movl %r9d, %ecx
shrq %cl, %r10
movzbl %r10b, %ecx
orq %rcx, (%rdi)
xorl %ecx, %ecx
jmp 0xd8d1f
cmpq %rax, %rdx
jae 0xd8d57
movq (%rdi), %rcx
cmpq $0x100, %rcx            # imm = 0x100
jae 0xd8d57
movb %cl, (%rsi,%rdx)
incq %rdx
movq $0x0, (%rdi)
movzwl 0x14(%rdi), %ecx
movw %cx, 0x10(%rdi)
testw %r9w, %r9w
jne 0xd8cd5
callq 0x24999
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 0x24960
callq 0x249d0
// File: /workspace/github_c_makefile_star2_O1/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 0xd8dc5
movq %rcx, %rax
movzwl %r9w, %r9d
incq %r9
cmpw $0x0, 0x10(%rdi)
jne 0xd8d92
cmpq %rax, %rdx
jae 0xd8dc0
movb 0x17(%rdi), %cl
movb %cl, (%rsi,%rdx)
incq %rdx
movb $0x0, 0x17(%rdi)
movzwl 0x14(%rdi), %ecx
movw %cx, 0x10(%rdi)
leaq -0x2(%r9), %rcx
btq %rcx, %r8
jae 0xd8dae
movb 0x10(%rdi), %cl
decb %cl
movl $0x1, %r10d
shll %cl, %r10d
orb %r10b, 0x17(%rdi)
decw 0x10(%rdi)
decq %r9
cmpq $0x1, %r9
jg 0xd8d71
movq %rdx, %rax
popq %rcx
retq
callq 0x24a07
callq 0x24a40
// File: /workspace/github_c_makefile_star2_O1/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 0xd8e30
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd8e30
testq %rdx, %rdx
jle 0xd8e2a
movq %rdi, %r14
leaq (%rbx,%rdx,4), %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0xd8ddd
addq $0x4, %rbx
cmpq %r15, %rbx
jb 0xd8e17
popq %rbx
popq %r14
popq %r15
retq
callq 0x24aeb
// File: /workspace/github_c_makefile_star2_O1/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 0xd8e6d
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd8e6d
testq %rdx, %rdx
jle 0xd8e67
movq %rdi, %r14
leaq (%rbx,%rdx,8), %r15
movq (%rbx), %rsi
movq %r14, %rdi
callq 0xd8ddd
addq $0x8, %rbx
cmpq %r15, %rbx
jb 0xd8e53
popq %rbx
popq %r14
popq %r15
retq
callq 0x24b24
// File: /workspace/github_c_makefile_star2_O1/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 0xd8f26
movq %rsi, %rbx
movzwl 0x10(%rsi), %eax
cmpw 0x14(%rsi), %ax
jae 0xd8f0b
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0xd8ef2
testq %rdx, %rdx
jne 0xd8f2b
testb %dil, %dil
jne 0xd8f2b
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x17fa0
movzwl 0x12(%rbx), %eax
testq %rax, %rax
je 0xd8f0b
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 0xd8f0b
testb %dil, %dil
je 0xd8efe
movb 0x17(%rbx), %al
movb %al, (%rdx)
jmp 0xd8f0b
movq (%rbx), %rax
cmpq $0x100, %rax            # imm = 0x100
jae 0xd8f30
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 0x24bcf
callq 0x24b5d
callq 0x24b96
// File: /workspace/github_c_makefile_star2_O1/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 0xd8f66
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0xd8f51
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd8e72
leaq 0x28fe59(%rip), %rsi    # 0x368db1
movq %rbx, %rdi
movl $0x108, %edx            # imm = 0x108
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9041
testq %rdx, %rdx
je 0xd9041
cmpq $0x0, 0x18(%rdi)
jne 0xd9041
movq %rcx, %rax
movzwl %r8w, %r9d
movzwl 0x10(%rdi), %ecx
testw %cx, %cx
jne 0xd8fb8
movb (%rdx,%rax), %cl
incq %rax
movb %cl, 0x16(%rdi)
movzwl 0x14(%rdi), %ecx
movw %cx, 0x10(%rdi)
movzwl %cx, %ecx
movl %r9d, %r10d
subl %ecx, %r10d
jbe 0xd8fed
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 0xd8fa2
subl %r9d, %ecx
movw %cx, 0x10(%rdi)
movzwl 0x14(%rdi), %r10d
movzbl 0x16(%rdi), %edx
cmpl %r10d, %r9d
jae 0xd902d
shrl %cl, %edx
movq $-0x1, %r10
movl %r9d, %ecx
shlq %cl, %r10
notl %r10d
andl %edx, %r10d
orq (%rdi), %r10
movq %r10, (%rdi)
movl %r8d, %ecx
shrq %cl, %r10
testq %r10, %r10
je 0xd9032
callq 0x24c41
movl %edx, %ecx
orq %rcx, (%rdi)
movq (%rdi), %rcx
movq %rcx, (%rsi)
movq $0x0, (%rdi)
popq %rcx
retq
callq 0x24c7a
// File: /workspace/github_c_makefile_star2_O1/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 0xd90c6
testq %rdx, %rdx
je 0xd90c6
cmpq $0x0, 0x18(%rdi)
jne 0xd90c6
testw %r8w, %r8w
je 0xd90cb
movq %rcx, %rax
movzwl 0x10(%rdi), %r10d
movb 0x16(%rdi), %r9b
movzwl %r8w, %r8d
incq %r8
testw %r10w, %r10w
jne 0xd908c
movb (%rdx,%rax), %r9b
incq %rax
movb %r9b, 0x16(%rdi)
movzwl 0x14(%rdi), %r10d
movw %r10w, 0x10(%rdi)
decl %r10d
movw %r10w, 0x10(%rdi)
movzbl %r9b, %ecx
btl %r10d, %ecx
jae 0xd90ae
leaq -0x2(%r8), %rcx
movl $0x1, %r11d
shlq %cl, %r11
orq %r11, (%rdi)
decq %r8
cmpq $0x1, %r8
jg 0xd9071
movq (%rdi), %rcx
movq %rcx, (%rsi)
movq $0x0, (%rdi)
popq %rcx
retq
callq 0x24cec
callq 0x24cb3
// File: /workspace/github_c_makefile_star2_O1/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 0x2fef90
movl $0x1, %ebx
testl %eax, %eax
jne 0xdc338
movq %r14, %rdi
callq 0xe3fec
testl %eax, %eax
jne 0xdc338
movq %r14, %rdi
callq 0xdc344
testl %eax, %eax
jne 0xdc338
movq %r14, %rdi
callq 0xdedb4
testl %eax, %eax
jne 0xdc338
movq %r14, %rdi
callq 0xe1678
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_O1/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 0xe837d
leal (,%rax,8), %edx
testl %edx, %edx
js 0xdedaf
movl %edx, %r13d
cmpq %r14, %r13
movq %r15, 0x18(%rsp)
jae 0xded5a
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 0x2faa92
movdqa 0x20(%rsp), %xmm2
cmpl $0x0, 0xc(%rsp)
je 0xded4c
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 0xded05
addq %rbp, %rbx
subq %r13, %r14
addq %r15, %r12
cmpq %r13, %r14
ja 0xdecde
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq 0x18(%rsp), %r15
movl %r15d, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x2faa92
testq %r14, %r14
je 0xdeda0
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 0xded8c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x25854
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
callq 0xe837d
leal (,%rax,4), %esi
testl %esi, %esi
js 0xe1672
movl %esi, %r13d
cmpq %r14, %r13
jae 0xe1622
movq %rax, %rbp
movq 0x8(%rsp), %rdx
leal -0x1(%rdx), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %esi, 0x14(%rsp)
movl %esi, %r15d
imull %edx, %r15d
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm1      # xmm1 = xmm0[0,0,0,0]
andl $0x3fffffff, %ebp       # imm = 0x3FFFFFFF
shlq $0x4, %rbp
movdqa %xmm1, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x2fbc54
movdqa 0x20(%rsp), %xmm1
cmpl $0x0, 0x14(%rsp)
je 0xe1614
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 0xe15f9
addq %rbp, %rbx
subq %r13, %r14
addq %r15, %r12
cmpq %r13, %r14
ja 0xe15d2
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq 0x8(%rsp), %r15
movl %r15d, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x2fbc54
decb %r15b
movl $0x1, %eax
movl %r15d, %ecx
shll %cl, %eax
testq %r14, %r14
je 0xe1663
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
xorl %eax, %edx
subl %eax, %edx
movl %edx, (%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %r14
jne 0xe1651
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x25a1c
nop
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
callq 0xe837d
movl %eax, %edi
addl %eax, %edi
js 0xe3fe6
movl %edi, %r13d
cmpq %r14, %r13
jae 0xe3f91
movq %rax, %r15
movq 0x8(%rsp), %rdx
leal -0x1(%rdx), %ecx
movl $0x1, %eax
shlq %cl, %rax
movl %edi, 0x14(%rsp)
movl %edi, %ebp
imull %edx, %ebp
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm1     # xmm1 = xmm0[0,1,0,1]
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
shlq $0x4, %r15
movdqa %xmm1, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x2fce15
movdqa 0x20(%rsp), %xmm1
cmpl $0x0, 0x14(%rsp)
je 0xe3f83
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 0xe3f68
addq %r15, %rbx
subq %r13, %r14
addq %rbp, %r12
cmpq %r13, %r14
ja 0xe3f41
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq 0x8(%rsp), %r15
movl %r15d, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x2fce15
decb %r15b
movl $0x1, %eax
movl %r15d, %ecx
shlq %cl, %rax
testq %r14, %r14
je 0xe3fd7
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
xorq %rax, %rdx
subq %rax, %rdx
movq %rdx, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0xe3fc1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x25be4
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x3e28b2(%rip)    # 0x4c94b8
jne 0xe6c3c
leaq 0x3b(%rip), %rsi        # 0xe6c4a
leaq 0x58(%rip), %rdx        # 0xe6c6e
leaq 0x65(%rip), %rcx        # 0xe6c82
leaq 0x71(%rip), %r8         # 0xe6c95
leaq 0x77(%rip), %r9         # 0xe6ca2
movl $0x20, %edi
callq 0xe6a30
movq %rax, 0x3e287c(%rip)    # 0x4c94b8
callq 0xe6a19
movq 0x3e2870(%rip), %rax    # 0x4c94b8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe6e85
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq (%rsi,%rdx), %r13
decq %r13
callq 0xec1d8
cmpq %rax, %r13
jae 0xe6e85
testq %r12, %r12
je 0xe6e2c
movq %r12, %rdi
callq 0x101a9a
testb %al, %al
jne 0xe6e8a
callq 0xe6bf8
movq %rax, %rdi
callq 0xe6a87
movq %rax, %r12
callq 0xe6bf8
movq %rax, %rdi
movq %r12, %rsi
callq 0xe6ae4
movq %rax, %r13
movq %r15, %rdi
callq 0xeef4f
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 0x26155
callq 0x2611e
// File: /workspace/github_c_makefile_star2_O1/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 0xe8078
movl %esi, %ebx
cmpl $0x41, %esi
jae 0xe807d
movq %rdi, %r12
imulq %rdi, %r15
leaq 0x283977(%rip), %r13    # 0x36b980
movl $0x20, %edi
movq %r13, %rsi
movl $0x30, %edx
callq 0x1092b2
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 0x1093ef
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 0x265da
callq 0x265a3
// File: /workspace/github_c_makefile_star2_O1/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 0xe8132
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 0xe8128
addl %r8d, %ecx
shlq %cl, %rax
movq 0x8(%r9,%rsi,8), %rsi
movl %edx, %ecx
shrq %cl, %rsi
orq %rsi, %rax
jmp 0xe812d
movl %edx, %ecx
shrq %cl, %rax
andq 0x10(%rdi), %rax
retq
pushq %rax
callq 0x26648
// File: /workspace/github_c_makefile_star2_O1/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 0xe81b0
movq 0x10(%rdi), %r8
cmpq %rdx, %r8
jb 0xe81b0
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 0xe819a
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 0xe819d
subl %r10d, %ecx
shlq %cl, %r8
shlq %cl, %rdx
notq %r8
andq %r9, %r8
orq %r8, %rdx
movq %rdx, (%rsi)
retq
pushq %rax
callq 0x2667f
// File: /workspace/github_c_makefile_star2_O1/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 0xe84f0
movq %rsi, %r13
testq %rsi, %rsi
je 0xe84f0
movq %rdx, %r15
testq %rdx, %rdx
je 0xe84f0
movq %rcx, %r14
testq %rcx, %rcx
je 0xe84f0
cmpq $0x0, (%rsp)
je 0xe84f0
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xe84f0
movq (%rsp), %rax
leaq 0x1(%rax), %rsi
leaq 0x283723(%rip), %rdx    # 0x36bb21
movl $0x8, %edi
movq %rsi, 0x18(%rsp)
movl $0x20, %ecx
callq 0x1093ef
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 0xe84eb
incq (%rbp,%rax,8)
addq %r15, %r12
decq %rbx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
jne 0xe8425
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 0xe8466
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 0xe8492
leaq 0x283651(%rip), %rsi    # 0x36bb21
movq %rbp, %rdi
movl $0x35, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x109670
callq 0x266ed
callq 0x266b6
// File: /workspace/github_c_makefile_star2_O1/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 0xe8530
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 0xe8517
jmp 0xe8533
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq