LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x59ef2
callq 0x89eb7
testb %al, %al
jne 0x59f9a
leaq 0x2a50c6(%rip), %r14    # 0x2fefbf
pushq $0x50
popq %rdi
pushq $0x1d
popq %rbp
movq %r14, %rsi
movl %ebp, %edx
callq 0x93160
movq %rax, %rbx
movl $0x640, %edi            # imm = 0x640
movq %r14, %rsi
movl %ebp, %edx
callq 0x93160
movq %rax, (%rbx)
pushq $0x1
popq %rax
movl $0xa0, %ecx
cmpq $0xa, %rax
je 0x59f3d
movq -0x8(%rbx,%rax,8), %rdx
addq %rcx, %rdx
movq %rdx, (%rbx,%rax,8)
incq %rax
jmp 0x59f26
pushq $0x1
popq %rax
pushq $0x2
popq %rcx
cmpq $0xa, %rax
je 0x59f6f
movq (%rbx,%rax,8), %rdx
xorl %esi, %esi
cmpq $0x13, %rsi
je 0x59f67
leal (%rcx,%rsi), %edi
cvtsi2sd %edi, %xmm0
movsd %xmm0, 0x8(%rdx,%rsi,8)
incq %rsi
jmp 0x59f4f
incq %rax
incq %rcx
jmp 0x59f43
movq (%rbx), %rdi
leaq 0x2a5046(%rip), %r14    # 0x2fefbf
pushq $0x26
popq %rbp
movq %r14, %rsi
movl %ebp, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x936f9
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3ddfc7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28b068(%rip), %rsi    # 0x2e5013
leaq 0x28b20d(%rip), %rdx    # 0x2e51bf
leaq 0x2a4ff1(%rip), %rcx    # 0x2fefaa
leaq 0x2a4fff(%rip), %r8     # 0x2fefbf
pushq $0x1a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5a1ee
callq 0x89eb7
testb %al, %al
jne 0x5a34b
leaq 0x2a4e75(%rip), %r14    # 0x2ff06a
pushq $0x50
popq %rdi
pushq $0x1c
popq %rbp
movq %r14, %rsi
movl %ebp, %edx
callq 0x93160
movq %rax, %rbx
movl $0x640, %edi            # imm = 0x640
movq %r14, %rsi
movl %ebp, %edx
callq 0x93160
movq %rax, (%rbx)
pushq $0x1
popq %rax
movl $0xa0, %ecx
cmpq $0xa, %rax
je 0x5a239
movq -0x8(%rbx,%rax,8), %rdx
addq %rcx, %rdx
movq %rdx, (%rbx,%rax,8)
incq %rax
jmp 0x5a222
leaq 0x2a4e2a(%rip), %rsi    # 0x2ff06a
pushq $0x1c
popq %rdx
movl $0xbb80, %edi           # imm = 0xBB80
callq 0x93160
movq (%rbx), %rcx
movq %rax, (%rcx)
pushq $0x1
popq %rax
movl $0xf0, %ecx
cmpq $0x14, %rax
je 0x5a275
movq (%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rsi
addq %rcx, %rsi
movq %rsi, (%rdx,%rax,8)
incq %rax
jmp 0x5a25b
pushq $0x1
popq %rax
movl $0xf0, %ecx
movq %rax, %rdx
cmpq $0xa, %rdx
je 0x5a2bf
movq -0x8(%rbx,%rdx,8), %rsi
movq (%rbx,%rdx,8), %rdi
movq 0x98(%rsi), %rsi
addq %rcx, %rsi
movq %rsi, (%rdi)
movq %rax, %rsi
cmpq $0x14, %rsi
je 0x5a2ba
movq (%rbx,%rdx,8), %rdi
movq -0x8(%rdi,%rsi,8), %r8
addq %rcx, %r8
movq %r8, (%rdi,%rsi,8)
incq %rsi
jmp 0x5a29f
incq %rdx
jmp 0x5a280
pushq $0x1
popq %rax
pushq $0x3
popq %rcx
movq %rax, %rdx
cmpq $0xa, %rdx
je 0x5a310
movq (%rbx,%rdx,8), %rsi
movq %rcx, %rdi
movq %rax, %r8
cmpq $0x14, %r8
je 0x5a308
movq (%rsi,%r8,8), %r9
xorl %r10d, %r10d
cmpq $0x1d, %r10
je 0x5a300
leal (%rdi,%r10), %r11d
cvtsi2sd %r11d, %xmm0
movsd %xmm0, 0x8(%r9,%r10,8)
incq %r10
jmp 0x5a2e5
incq %r8
incq %rdi
jmp 0x5a2d8
incq %rdx
incq %rcx
jmp 0x5a2c8
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x2a4d4d(%rip), %r14    # 0x2ff06a
pushq $0x27
popq %rbp
movq %r14, %rsi
movl %ebp, %edx
callq 0x936f9
movq (%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x936f9
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3ddc16(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28acb7(%rip), %rsi    # 0x2e5013
leaq 0x28ae5c(%rip), %rdx    # 0x2e51bf
leaq 0x2a4ceb(%rip), %rcx    # 0x2ff055
leaq 0x2a4cf9(%rip), %r8     # 0x2ff06a
pushq $0x19
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x5d68f
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x2a2548(%rip), %rdx    # 0x2ffba9
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x23
popq %rcx
callq 0x9334a
movq %rax, %r14
cmpl $0x1, %ebp
adcl $0x0, %ebp
movl %ebp, 0x4(%rax)
movq %rbx, %rdi
callq 0x6c728
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3da8d2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x287973(%rip), %rsi    # 0x2e5013
leaq 0x28e1a3(%rip), %rdx    # 0x2eb84a
leaq 0x2a24e4(%rip), %rcx    # 0x2ffb92
leaq 0x2a24f4(%rip), %r8     # 0x2ffba9
pushq $0x22
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x5d70e
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x5d7ad
testq %rbx, %rbx
je 0x5d783
testq %r15, %r15
je 0x5d783
movslq (%rbx), %rax
cmpl 0x4(%rbx), %eax
jge 0x5d751
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x5d757
cmpb $0x2d, (%rdi)
jne 0x5d75e
cmpb $0x0, 0x1(%rdi)
jne 0x5d75e
cmpb $0x1, 0x10(%rbx)
jne 0x5d77d
leaq 0x2a24a5(%rip), %rsi    # 0x2ffbea
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
jmp 0x5d774
andq $0x0, (%r15)
jmp 0x5d770
leaq 0x30aa4c(%rip), %rdi    # 0x3681aa
movq %r14, %rsi
callq 0x5a868
movq %rax, (%r15)
testq %rax, %rax
je 0x5d774
incl (%rbx)
xorl %eax, %eax
jmp 0x5d777
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, 0x10(%rbx)
jmp 0x5d75e
movq 0x3da7de(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28787f(%rip), %rsi    # 0x2e5013
leaq 0x2a2441(%rip), %rdx    # 0x2ffbdc
leaq 0x2a2422(%rip), %rcx    # 0x2ffbc4
leaq 0x2a2400(%rip), %r8     # 0x2ffba9
pushq $0x35
jmp 0x5d7d5
movq 0x3da7b4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x287855(%rip), %rsi    # 0x2e5013
leaq 0x2879fa(%rip), %rdx    # 0x2e51bf
leaq 0x2a23f8(%rip), %rcx    # 0x2ffbc4
leaq 0x2a23d6(%rip), %r8     # 0x2ffba9
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2a241e(%rip), %rsi    # 0x2ffc16
pushq $0x20
popq %rdi
pushq $0x26
popq %rdx
callq 0x93160
movq %rax, %r14
testq %rbx, %rbx
je 0x5d841
movw $0x8, 0x14(%r14)
testw %bp, %bp
je 0x5d84d
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x17f00
movsbl %bpl, %edi
movq %rbx, %rsi
callq 0x17930
movzwl 0x14(%r14), %eax
jmp 0x5d851
testw %bp, %bp
jne 0x5d877
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
movq 0x3da6ea(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28778b(%rip), %rsi    # 0x2e5013
leaq 0x29c1e7(%rip), %rdx    # 0x2f9a76
leaq 0x2a2395(%rip), %rcx    # 0x2ffc2b
leaq 0x2a2379(%rip), %r8     # 0x2ffc16
pushq $0x2d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5d985
movl %edx, %ebp
movq %rdi, %rbx
cmpw %bp, 0x14(%rdi)
jb 0x5d985
movq %rsi, %r14
incq 0x8(%rbx)
pushq $0x8
popq %r15
pushq $0x1
popq %r12
testw %bp, %bp
je 0x5d94f
movzwl 0x10(%rbx), %eax
cmpw %bp, %ax
jae 0x5d92a
testq %rax, %rax
je 0x5d909
movq %r14, %rdx
movl %eax, %ecx
shrq %cl, %rdx
subl %eax, %ebp
orq (%rbx), %rdx
xorl %eax, %eax
jmp 0x5d921
movq 0x18(%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x17f00
movzwl 0x14(%rbx), %eax
xorl %edx, %edx
movq %rdx, (%rbx)
movw %ax, 0x10(%rbx)
jmp 0x5d8e5
pushq $-0x1
popq %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 %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3da612(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2876b3(%rip), %rsi    # 0x2e5013
leaq 0x2a2329(%rip), %rdx    # 0x2ffc90
leaq 0x2a2302(%rip), %rcx    # 0x2ffc70
leaq 0x2a22a1(%rip), %r8     # 0x2ffc16
pushq $0x51
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3da5dc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28767d(%rip), %rsi    # 0x2e5013
leaq 0x2a22a4(%rip), %rdx    # 0x2ffc41
leaq 0x2a22cc(%rip), %rcx    # 0x2ffc70
leaq 0x2a226b(%rip), %r8     # 0x2ffc16
pushq $0x4d
jmp 0x5d977
// File: /workspace/github_c_makefile_star2_O2/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 0x5daa7
cmpq $0x0, 0x18(%rdi)
jne 0x5daa7
movq %rcx, %rax
incq 0x8(%rdi)
testw %r9w, %r9w
je 0x5da43
movzwl 0x10(%rdi), %r10d
cmpw %r9w, %r10w
jae 0x5da1e
testw %r10w, %r10w
je 0x5d9f9
subl %r10d, %r9d
movq %r8, %r10
movl %r9d, %ecx
shrq %cl, %r10
movzbl %r10b, %ecx
orq %rcx, (%rdi)
xorl %ecx, %ecx
jmp 0x5da18
cmpq %rax, %rdx
jae 0x5da6f
movq (%rdi), %rcx
cmpq $0x100, %rcx            # imm = 0x100
jae 0x5da6f
movb %cl, (%rsi,%rdx)
incq %rdx
andq $0x0, (%rdi)
movzwl 0x14(%rdi), %ecx
movw %cx, 0x10(%rdi)
jmp 0x5d9cb
pushq $-0x1
popq %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
movq 0x3da51e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2875bf(%rip), %rsi    # 0x2e5013
leaq 0x2a2235(%rip), %rdx    # 0x2ffc90
leaq 0x2a225a(%rip), %rcx    # 0x2ffcbc
leaq 0x2a21ad(%rip), %r8     # 0x2ffc16
pushq $0x7f
popq %r9
jmp 0x5da9b
movq 0x3da4f2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x287593(%rip), %rsi    # 0x2e5013
leaq 0x2a2253(%rip), %rdx    # 0x2ffcda
leaq 0x2a222e(%rip), %rcx    # 0x2ffcbc
leaq 0x2a2181(%rip), %r8     # 0x2ffc16
movl $0x8c, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3da4ba(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28755b(%rip), %rsi    # 0x2e5013
leaq 0x2a21e0(%rip), %rdx    # 0x2ffc9f
leaq 0x2a21f6(%rip), %rcx    # 0x2ffcbc
leaq 0x2a2149(%rip), %r8     # 0x2ffc16
pushq $0x7a
jmp 0x5da6b
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testl %r9d, %r9d
je 0x5db69
movq %rcx, %rax
movzwl %r9w, %r9d
pushq $0x1
popq %r10
testq %r9, %r9
jle 0x5db2c
movzwl 0x10(%rdi), %r11d
testw %r11w, %r11w
jne 0x5db0d
cmpq %rax, %rdx
jae 0x5db31
movb 0x17(%rdi), %cl
movb %cl, (%rsi,%rdx)
incq %rdx
movb $0x0, 0x17(%rdi)
movzwl 0x14(%rdi), %r11d
decq %r9
btq %r9, %r8
jae 0x5db22
leal -0x1(%r11), %ecx
movl %r10d, %ebx
shll %cl, %ebx
orb %bl, 0x17(%rdi)
decl %r11d
movw %r11w, 0x10(%rdi)
jmp 0x5dae6
movq %rdx, %rax
popq %rbx
retq
movq 0x3da430(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2874d1(%rip), %rsi    # 0x2e5013
leaq 0x2a220e(%rip), %rdx    # 0x2ffd57
leaq 0x2a21e6(%rip), %rcx    # 0x2ffd36
leaq 0x2a20bf(%rip), %r8     # 0x2ffc16
movl $0xaa, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3da3f8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x287499(%rip), %rsi    # 0x2e5013
leaq 0x2a21a4(%rip), %rdx    # 0x2ffd25
leaq 0x2a21ae(%rip), %rcx    # 0x2ffd36
leaq 0x2a2087(%rip), %r8     # 0x2ffc16
movl $0xa5, %r9d
jmp 0x5db5d
// File: /workspace/github_c_makefile_star2_O2/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 0x5dc60
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5dc60
movq %rdi, %r14
leaq (%rbx,%rdx,4), %r15
cmpq %r15, %rbx
jae 0x5dc5a
movl (%rbx), %esi
movq %r14, %rdi
callq 0x5dbdd
addq $0x4, %rbx
jmp 0x5dc45
popq %rbx
popq %r14
popq %r15
retq
movq 0x3da301(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2873a2(%rip), %rsi    # 0x2e5013
leaq 0x2a216e(%rip), %rdx    # 0x2ffde6
leaq 0x2a2181(%rip), %rcx    # 0x2ffe00
leaq 0x2a1f90(%rip), %r8     # 0x2ffc16
movl $0xca, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x5dccd
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5dccd
movq %rdi, %r14
leaq (%rbx,%rdx,8), %r15
cmpq %r15, %rbx
jae 0x5dcc7
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x5dbdd
addq $0x8, %rbx
jmp 0x5dcb1
popq %rbx
popq %r14
popq %r15
retq
movq 0x3da294(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x287335(%rip), %rsi    # 0x2e5013
leaq 0x2a2101(%rip), %rdx    # 0x2ffde6
leaq 0x2a2136(%rip), %rcx    # 0x2ffe22
leaq 0x2a1f23(%rip), %r8     # 0x2ffc16
movl $0xd7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x5ddae
movq %rsi, %rbx
movzwl 0x10(%rsi), %eax
cmpw 0x14(%rsi), %ax
jae 0x5dd96
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x5dd7d
testq %rdx, %rdx
jne 0x5dddc
testb %dil, %dil
jne 0x5dddc
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x17f00
movzwl 0x12(%rbx), %eax
testq %rax, %rax
je 0x5dd96
imulq 0x8(%rbx), %rax
movq %rsp, %r14
movq %rax, (%r14)
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x17840
movq 0x18(%rbx), %rcx
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x17f00
jmp 0x5dd96
testb %dil, %dil
je 0x5dd89
movb 0x17(%rbx), %al
movb %al, (%rdx)
jmp 0x5dd96
movq (%rbx), %rax
cmpq $0x100, %rax            # imm = 0x100
jae 0x5de0a
movb %al, (%rdx)
andq $0x0, (%rbx)
movb $0x0, 0x17(%rbx)
movzwl 0x14(%rbx), %eax
movw %ax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3da1b3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x287254(%rip), %rsi    # 0x2e5013
leaq 0x2a1fb7(%rip), %rdx    # 0x2ffd7d
leaq 0x2a2076(%rip), %rcx    # 0x2ffe43
leaq 0x2a1e42(%rip), %r8     # 0x2ffc16
movl $0xe0, %r9d
jmp 0x5de36
movq 0x3da185(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x287226(%rip), %rsi    # 0x2e5013
leaq 0x2a2062(%rip), %rdx    # 0x2ffe56
leaq 0x2a2048(%rip), %rcx    # 0x2ffe43
leaq 0x2a1e14(%rip), %r8     # 0x2ffc16
movl $0xe5, %r9d
jmp 0x5de36
movq 0x3da157(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2871f8(%rip), %rsi    # 0x2e5013
leaq 0x2a2056(%rip), %rdx    # 0x2ffe78
leaq 0x2a201a(%rip), %rcx    # 0x2ffe43
leaq 0x2a1de6(%rip), %r8     # 0x2ffc16
movl $0xf6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x5de73
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x5de5e
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5dd05
leaq 0x2a1db1(%rip), %rsi    # 0x2ffc16
movq %rbx, %rdi
movl $0x108, %edx            # imm = 0x108
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5df9b
testq %rdx, %rdx
je 0x5df9b
cmpq $0x0, 0x18(%rdi)
jne 0x5df9b
movq %rcx, %rax
movzwl %r8w, %r9d
movzwl 0x10(%rdi), %ecx
pushq $-0x1
popq %r11
testw %cx, %cx
jne 0x5def7
movb (%rdx,%rax), %cl
incq %rax
movb %cl, 0x16(%rdi)
movzwl 0x14(%rdi), %ecx
movzwl %cx, %ecx
movl %r9d, %r10d
subl %ecx, %r10d
jbe 0x5df27
movq %r11, %r9
shlq %cl, %r9
movzbl 0x16(%rdi), %ecx
notl %r9d
andl %ecx, %r9d
movl %r10d, %ecx
shlq %cl, %r9
orq %r9, (%rdi)
andw $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movl %r10d, %r9d
jmp 0x5dee5
subl %r9d, %ecx
movw %cx, 0x10(%rdi)
movzwl 0x14(%rdi), %r10d
movzbl 0x16(%rdi), %edx
cmpl %r10d, %r9d
jae 0x5df8c
shrl %cl, %edx
movl %r9d, %ecx
shlq %cl, %r11
notl %r11d
andl %edx, %r11d
orq (%rdi), %r11
movq %r11, (%rdi)
movq %r11, %rdx
movl %r8d, %ecx
shrq %cl, %rdx
testq %rdx, %rdx
je 0x5df92
movq 0x3da003(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2870a4(%rip), %rsi    # 0x2e5013
leaq 0x2a1fa2(%rip), %rdx    # 0x2fff18
leaq 0x2a1f7e(%rip), %rcx    # 0x2ffefb
leaq 0x2a1c92(%rip), %r8     # 0x2ffc16
movl $0x12a, %r9d            # imm = 0x12A
jmp 0x5dfc7
movl %edx, %r11d
orq (%rdi), %r11
movq %r11, (%rsi)
andq $0x0, (%rdi)
popq %rcx
retq
movq 0x3d9fc6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x287067(%rip), %rsi    # 0x2e5013
leaq 0x2a1f15(%rip), %rdx    # 0x2ffec8
leaq 0x2a1f41(%rip), %rcx    # 0x2ffefb
leaq 0x2a1c55(%rip), %r8     # 0x2ffc16
movl $0x11a, %r9d            # imm = 0x11A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x5e04a
testq %rdx, %rdx
je 0x5e04a
cmpq $0x0, 0x18(%rdi)
jne 0x5e04a
testw %r8w, %r8w
je 0x5e078
movq %rcx, %rax
movzwl 0x10(%rdi), %r10d
movb 0x16(%rdi), %r9b
movzwl %r8w, %ecx
pushq $0x1
popq %r8
testq %rcx, %rcx
jle 0x5e03e
testw %r10w, %r10w
jne 0x5e01e
movb (%rdx,%rax), %r9b
incq %rax
movb %r9b, 0x16(%rdi)
movzwl 0x14(%rdi), %r10d
decq %rcx
decl %r10d
movw %r10w, 0x10(%rdi)
movzbl %r9b, %r11d
btl %r10d, %r11d
jae 0x5e003
movq %r8, %r11
shlq %cl, %r11
orq %r11, (%rdi)
jmp 0x5e003
movq (%rdi), %rcx
movq %rcx, (%rsi)
andq $0x0, (%rdi)
popq %rcx
retq
movq 0x3d9f17(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x286fb8(%rip), %rsi    # 0x2e5013
leaq 0x2a1e66(%rip), %rdx    # 0x2ffec8
leaq 0x2a1edc(%rip), %rcx    # 0x2fff45
leaq 0x2a1ba6(%rip), %r8     # 0x2ffc16
movl $0x147, %r9d            # imm = 0x147
jmp 0x5e0a4
movq 0x3d9ee9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x286f8a(%rip), %rsi    # 0x2e5013
leaq 0x2a1c95(%rip), %rdx    # 0x2ffd25
leaq 0x2a1eae(%rip), %rcx    # 0x2fff45
leaq 0x2a1b78(%rip), %r8     # 0x2ffc16
movl $0x148, %r9d            # imm = 0x148
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2908d0
pushq $0x1
popq %rbx
testl %eax, %eax
jne 0x61586
movq %r14, %rdi
callq 0x67be4
testl %eax, %eax
jne 0x61586
movq %r14, %rdi
callq 0x61590
testl %eax, %eax
jne 0x61586
movq %r14, %rdi
callq 0x63870
testl %eax, %eax
jne 0x61586
movq %r14, %rdi
callq 0x65a10
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %r8, %rbp
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
callq 0x6be41
leal (,%rax,8), %ecx
testl %ecx, %ecx
js 0x63810
movq %rax, %r12
movl %ecx, %edx
movq %rdx, 0x18(%rsp)
movl %ebx, 0xc(%rsp)
imull %ebx, %ecx
andl $0x1fffffff, %r12d      # imm = 0x1FFFFFFF
shlq $0x4, %r12
movq %r14, %r13
subq 0x18(%rsp), %r13
jbe 0x637df
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r15, 0x20(%rsp)
movl 0xc(%rsp), %r15d
movl %r15d, %edx
movq %rcx, %rbx
movq 0x18(%rsp), %r14
movq %r14, %rcx
movq %rbp, %r8
callq 0x28b66f
movq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq 0x20(%rsp), %r15
callq 0x63848
movq %rbx, %rcx
addq %rbx, %r15
addq %r12, %rbp
movq %r13, %r14
jmp 0x6378f
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movl 0xc(%rsp), %ebx
movl %ebx, %edx
movq %r14, %rcx
movq %rbp, %r8
callq 0x28b66f
movq %rbp, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63848
movq 0x3d4751(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2817f2(%rip), %rsi    # 0x2e5013
leaq 0x29dd2d(%rip), %rdx    # 0x301555
leaq 0x29dd35(%rip), %rcx    # 0x301564
leaq 0x29dc9b(%rip), %r8     # 0x3014d1
movl $0x12b, %r9d            # imm = 0x12B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %r8, %rbp
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
callq 0x6be41
leal (,%rax,4), %ecx
testl %ecx, %ecx
js 0x659b7
movq %rax, %r12
movl %ecx, %edx
movq %rdx, 0x18(%rsp)
movl %ebx, 0xc(%rsp)
imull %ebx, %ecx
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
shlq $0x4, %r12
movq %r14, %r13
subq 0x18(%rsp), %r13
jbe 0x65986
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r15, 0x20(%rsp)
movl 0xc(%rsp), %r15d
movl %r15d, %edx
movq %rcx, %rbx
movq 0x18(%rsp), %r14
movq %r14, %rcx
movq %rbp, %r8
callq 0x28cbb5
movq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq 0x20(%rsp), %r15
callq 0x659ef
movq %rbx, %rcx
addq %rbx, %r15
addq %r12, %rbp
movq %r13, %r14
jmp 0x65936
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movl 0xc(%rsp), %ebx
movl %ebx, %edx
movq %r14, %rcx
movq %rbp, %r8
callq 0x28cbb5
movq %rbp, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x659ef
movq 0x3d25aa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27f64b(%rip), %rsi    # 0x2e5013
leaq 0x29bb86(%rip), %rdx    # 0x301555
leaq 0x29be3c(%rip), %rcx    # 0x301812
leaq 0x29baf4(%rip), %r8     # 0x3014d1
movl $0x144, %r9d            # imm = 0x144
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: bsSignExpandArray32
static inline void
bsSignExpandArray32(int32_t val[], size_t numValues, unsigned numBits)
{
  int32_t m = ((int32_t)1) << (numBits - 1);
  size_t i;
  for (i = 0; i < numValues; ++i)
    val[i] = (val[i] ^ m) - m;
}

// Assembly:
leal -0x1(%rdx), %ecx
pushq $0x1
popq %rax
shll %cl, %eax
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x65a0d
movl (%rdi,%rcx,4), %edx
xorl %eax, %edx
subl %eax, %edx
movl %edx, (%rdi,%rcx,4)
incq %rcx
jmp 0x659f9
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %r8, %r13
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
callq 0x6be41
movq %rax, %r12
movl %r12d, %ecx
addl %ecx, %ecx
js 0x67b88
movl %ecx, %edx
movq %rdx, 0x18(%rsp)
movl %ebx, 0xc(%rsp)
imull %ebx, %ecx
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
shlq $0x4, %r12
movq %r14, %rbp
subq 0x18(%rsp), %rbp
jbe 0x67b57
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r15, 0x20(%rsp)
movl 0xc(%rsp), %r15d
movl %r15d, %edx
movq %rcx, %rbx
movq 0x18(%rsp), %r14
movq %r14, %rcx
movq %r13, %r8
callq 0x28e0e4
movq %r13, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq 0x20(%rsp), %r15
callq 0x67bc0
movq %rbx, %rcx
addq %rbx, %r15
addq %r12, %r13
movq %rbp, %r14
jmp 0x67b07
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movl 0xc(%rsp), %ebx
movl %ebx, %edx
movq %r14, %rcx
movq %r13, %r8
callq 0x28e0e4
movq %r13, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x67bc0
movq 0x3d03d9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27d47a(%rip), %rsi    # 0x2e5013
leaq 0x2999b5(%rip), %rdx    # 0x301555
leaq 0x29a0f6(%rip), %rcx    # 0x301c9d
leaq 0x299923(%rip), %r8     # 0x3014d1
movl $0x15d, %r9d            # imm = 0x15D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: bsSignExpandArray64
static inline void
bsSignExpandArray64(int64_t val[], size_t numValues, unsigned numBits)
{
  int64_t m = ((int64_t)1) << (numBits - 1);
  size_t i;
  for (i = 0; i < numValues; ++i)
    val[i] = (val[i] ^ m) - m;
}

// Assembly:
leal -0x1(%rdx), %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x67be3
movq (%rdi,%rcx,8), %rdx
xorq %rax, %rdx
subq %rax, %rdx
movq %rdx, (%rdi,%rcx,8)
incq %rcx
jmp 0x67bcb
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: gt_bsGetUniformInt8Array
static inline void
gt_bsGetUniformInt8Array(constBitString str, BitOffset offset, unsigned numBits,
                         size_t numValues, int8_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 */
  int8_t *blockPtr = val;
  size_t revIndex = numValues;
  BitOffset offsetTemp = offset;
  gt_assert(blockSize >= 0);
  while (revIndex > (size_t) blockSize)
  {
    gt_bsGetUniformUInt8Array(str, offsetTemp, numBits,
                              blockSize, (uint8_t *)blockPtr);
    bsSignExpandArray8(blockPtr, blockSize, numBits);
    blockPtr += blockSize;
    revIndex -= blockSize;
    offsetTemp += blockSize * numBits;
  }
  gt_bsGetUniformUInt8Array(str, offsetTemp, numBits,
                            revIndex, (uint8_t *)blockPtr);
  bsSignExpandArray8(blockPtr, revIndex, numBits);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, (%rsp)
callq 0x6be41
movq %rax, %r13
shll $0x4, %r13d
js 0x69e1e
movl %r13d, %r12d
imull %ebx, %r13d
movq %rbp, %rax
subq %r12, %rbp
jbe 0x69def
movq (%rsp), %rdi
movq %r15, %rsi
movl %ebx, %edx
movq %r12, %rcx
movq %r14, %r8
callq 0x28f5be
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x69e56
addq %r12, %r14
addq %r13, %r15
jmp 0x69dbe
movq (%rsp), %rdi
movq %r15, %rsi
movl %ebx, %edx
movq %rax, %r15
movq %rax, %rcx
movq %r14, %r8
callq 0x28f5be
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x69e56
movq 0x3ce143(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27b1e4(%rip), %rsi    # 0x2e5013
leaq 0x29771f(%rip), %rdx    # 0x301555
leaq 0x2980f7(%rip), %rcx    # 0x301f34
leaq 0x29768d(%rip), %r8     # 0x3014d1
movl $0x112, %r9d            # imm = 0x112
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x3d31b2(%rip)    # 0x43d468
jne 0x6a2ea
leaq 0x39(%rip), %rsi        # 0x6a2f8
leaq 0x56(%rip), %rdx        # 0x6a31c
leaq 0x94(%rip), %rcx        # 0x6a361
leaq 0xd1(%rip), %r8         # 0x6a3a5
leaq 0xd4(%rip), %r9         # 0x6a3af
pushq $0x20
popq %rdi
callq 0x69f28
movq %rax, 0x3d317e(%rip)    # 0x43d468
callq 0x69ede
movq 0x3d3172(%rip), %rax    # 0x43d468
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6a5dd
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq (%rsi,%rdx), %r13
decq %r13
callq 0x7055e
cmpq %rax, %r13
jae 0x6a5dd
testq %r12, %r12
je 0x6a587
movq %r12, %rdi
callq 0x89eb7
testb %al, %al
jne 0x6a607
callq 0x6a2a8
movq %rax, %rdi
callq 0x69fae
movq %rax, %r12
callq 0x6a2a8
movq %rax, %rdi
movq %r12, %rsi
callq 0x6a040
movq %rax, %r13
movq %r15, %rdi
callq 0x73cbe
movq %rax, 0x18(%r13)
movl %ebp, 0x10(%r13)
movq 0x8(%r12), %rax
movq %r14, (%rax)
andq $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
movq 0x3cd984(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27aa25(%rip), %rsi    # 0x2e5013
leaq 0x297b19(%rip), %rdx    # 0x30210e
leaq 0x297b53(%rip), %rcx    # 0x30214f
leaq 0x297b77(%rip), %r8     # 0x30217a
pushq $0x72
jmp 0x6a62f
movq 0x3cd95a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27a9fb(%rip), %rsi    # 0x2e5013
leaq 0x27aba0(%rip), %rdx    # 0x2e51bf
leaq 0x297b29(%rip), %rcx    # 0x30214f
leaq 0x297b4d(%rip), %r8     # 0x30217a
pushq $0x73
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x6ba96
movl %esi, %ebx
cmpl $0x41, %esi
jae 0x6bac0
movq %rdi, %r12
imulq %rdi, %r15
leaq 0x296d8f(%rip), %r13    # 0x3027c4
pushq $0x20
popq %rdi
pushq $0x30
popq %rdx
movq %r13, %rsi
callq 0x93160
movq %rax, %r14
movq %r12, 0x8(%rax)
movq %r15, %rdi
shrq $0x6, %rdi
andl $0x3f, %r15d
cmpq $0x1, %r15
sbbq $-0x1, %rdi
pushq $0x8
popq %rsi
pushq $0x36
popq %rcx
movq %r13, %rdx
callq 0x9334a
movq %rax, (%r14)
movl %ebx, 0x18(%r14)
pushq $0x40
popq %rax
subl %ebx, %eax
negl %ebx
pushq $-0x1
popq %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
movq 0x3cc4cb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x27956c(%rip), %rsi    # 0x2e5013
leaq 0x296cd4(%rip), %rdx    # 0x302782
leaq 0x296cf4(%rip), %rcx    # 0x3027a9
leaq 0x296d08(%rip), %r8     # 0x3027c4
pushq $0x2d
jmp 0x6bae8
movq 0x3cc4a1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x279542(%rip), %rsi    # 0x2e5013
leaq 0x296d0b(%rip), %rdx    # 0x3027e3
leaq 0x296cca(%rip), %rcx    # 0x3027a9
leaq 0x296cde(%rip), %r8     # 0x3027c4
pushq $0x2e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/compact_ulong_store.c
// Function: gt_compact_ulong_store_size
size_t gt_compact_ulong_store_size(GtUword numofentries,
                                   unsigned int bitsperentry)
{
  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);
  totalbits = numofentries * bitsperentry;
  arraysize = GT_DIVWORDSIZE(totalbits);
  if (GT_MODWORDSIZE(totalbits) > 0) {
    arraysize++;
  }
  return sizeof (GtCompactUlongStore) + sizeof (GtUword) * arraysize;
}

// Assembly:
movl %esi, %ecx
movq %rcx, %rax
mulq %rdi
jo 0x6bb1f
imulq %rdi, %rcx
movq %rcx, %rax
shrq $0x6, %rax
andl $0x3f, %ecx
cmpq $0x1, %rcx
sbbq $-0x1, %rax
leaq 0x20(,%rax,8), %rax
retq
pushq %rax
movq 0x3cc441(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2794e2(%rip), %rsi    # 0x2e5013
leaq 0x296c4a(%rip), %rdx    # 0x302782
leaq 0x296cd2(%rip), %rcx    # 0x302811
leaq 0x296c7e(%rip), %r8     # 0x3027c4
pushq $0x45
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390