LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring32.c
// Function: icmp_uint32_t
static inline int
icmp_uint32_t(uint32_t a, uint32_t b)
{
  if (a > b)
    return 1;
  else if (a < b)
    return -1;
  else /* if (a == b) */
    return 0;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0x8(%rsp), %eax
cmpl -0xc(%rsp), %eax
jbe 0x968ec
movl $0x1, -0x4(%rsp)
jmp 0x96908
movl -0x8(%rsp), %eax
cmpl -0xc(%rsp), %eax
jae 0x96900
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x96908
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
callq 0xa2640
shlq $0x4, %rax
shrq $0x2, %rax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0x96aa9
movq 0x5a5528(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x47f591(%rip), %rsi    # 0x516013
leaq 0x49bcfc(%rip), %rdx    # 0x532785
leaq 0x49bfb2(%rip), %rcx    # 0x532a42
leaq 0x49bc6a(%rip), %r8     # 0x532701
movl $0x144, %r9d            # imm = 0x144
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x96aab
jmp 0x96aad
movq 0x8(%rsp), %rax
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
jbe 0x96b2a
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movl 0x34(%rsp), %edx
movslq 0x1c(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x4742f0
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x96bf0
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movslq 0x1c(%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
imull 0x34(%rsp), %eax
movl %eax, %eax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x96aad
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x4742f0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x96bf0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring32.c
// Function: genBitCount_uint32_t
static inline int
genBitCount_uint32_t(uint32_t v)
{
  unsigned c; /* c accumulates the total bits set in v */
  for (c = 0; v; c++)
    v &= v - 1; /* clear the least significant bit set */
  return c;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x0, -0x4(%rsp)
je 0x96bdf
movl -0x4(%rsp), %eax
subl $0x1, %eax
andl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x96bbc
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x96c57
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movl (%rax,%rcx,4), %edx
xorl -0x18(%rsp), %edx
subl -0x18(%rsp), %edx
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x96c19
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring64.c
// Function: icmp_uint64_t
static inline int
icmp_uint64_t(uint64_t a, uint64_t b)
{
  if (a > b)
    return 1;
  else if (a < b)
    return -1;
  else /* if (a == b) */
    return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
jbe 0x9abe0
movl $0x1, -0x4(%rsp)
jmp 0x9abfe
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x9abf6
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x9abfe
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
callq 0xa2640
shlq $0x4, %rax
shrq $0x3, %rax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0x9adc9
movq 0x5a1208(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x47b271(%rip), %rsi    # 0x516013
leaq 0x4979dc(%rip), %rdx    # 0x532785
leaq 0x49811d(%rip), %rcx    # 0x532ecd
leaq 0x49794a(%rip), %r8     # 0x532701
movl $0x15d, %r9d            # imm = 0x15D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x9adcb
jmp 0x9adcd
movq 0x8(%rsp), %rax
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
jbe 0x9ae4a
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movl 0x34(%rsp), %edx
movslq 0x1c(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x477370
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x9af10
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movslq 0x1c(%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
imull 0x34(%rsp), %eax
movl %eax, %eax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x9adcd
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x477370
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x9af10
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring64.c
// Function: genBitCount_uint64_t
static inline int
genBitCount_uint64_t(uint64_t v)
{
  unsigned c; /* c accumulates the total bits set in v */
  for (c = 0; v; c++)
    v &= v - 1; /* clear the least significant bit set */
  return c;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x9af05
movq -0x8(%rsp), %rax
subq $0x1, %rax
andq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x9aedd
movl -0xc(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x9af81
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
xorq -0x20(%rsp), %rdx
subq -0x20(%rsp), %rdx
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x9af3f
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring8.c
// Function: icmp_uint8_t
static inline int
icmp_uint8_t(uint8_t a, uint8_t b)
{
  if (a > b)
    return 1;
  else if (a < b)
    return -1;
  else /* if (a == b) */
    return 0;
}

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x5(%rsp)
movb %al, -0x6(%rsp)
movzbl -0x5(%rsp), %eax
movzbl -0x6(%rsp), %ecx
cmpl %ecx, %eax
jle 0x9ee56
movl $0x1, -0x4(%rsp)
jmp 0x9ee76
movzbl -0x5(%rsp), %eax
movzbl -0x6(%rsp), %ecx
cmpl %ecx, %eax
jge 0x9ee6e
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x9ee76
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
callq 0xa2640
shlq $0x4, %rax
shrq $0x0, %rax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0x9f039
movq 0x59cf98(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x477001(%rip), %rsi    # 0x516013
leaq 0x49376c(%rip), %rdx    # 0x532785
leaq 0x494144(%rip), %rcx    # 0x533164
leaq 0x4936da(%rip), %r8     # 0x532701
movl $0x112, %r9d            # imm = 0x112
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x9f03b
jmp 0x9f03d
movq 0x8(%rsp), %rax
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
jbe 0x9f0b6
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movl 0x34(%rsp), %edx
movslq 0x1c(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x47a490
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x9f180
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movslq 0x1c(%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
imull 0x34(%rsp), %eax
movl %eax, %eax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x9f03d
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x47a490
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x9f180
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/checkbitpackstring8.c
// Function: genBitCount_uint8_t
static inline int
genBitCount_uint8_t(uint8_t v)
{
  unsigned c; /* c accumulates the total bits set in v */
  for (c = 0; v; c++)
    v &= v - 1; /* clear the least significant bit set */
  return c;
}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movl $0x0, -0x8(%rsp)
cmpb $0x0, -0x1(%rsp)
je 0x9f176
movzbl -0x1(%rsp), %ecx
subl $0x1, %ecx
movzbl -0x1(%rsp), %eax
andl %ecx, %eax
movb %al, -0x1(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x9f14f
movl -0x8(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackstringsimpleop.h
// Function: bsSignExpandArray8
static inline void
bsSignExpandArray8(int8_t val[], size_t numValues, unsigned numBits)
{
  int8_t m = 1 << (numBits - 1);
  size_t i;
  for (i = 0; i < numValues; ++i)
    val[i] = (val[i] ^ m) - m;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movb %al, -0x15(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x9f1f0
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x15(%rsp), %ecx
xorl %ecx, %eax
movsbl -0x15(%rsp), %ecx
subl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x9f1a9
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x9f220
cmpq $0x0, 0x5a325a(%rip)    # 0x642b18
jne 0x9f8f4
movl $0x20, %edi
leaq 0x44(%rip), %rsi        # 0x9f910
leaq 0x7d(%rip), %rdx        # 0x9f950
leaq 0xd6(%rip), %rcx        # 0x9f9b0
leaq 0x12f(%rip), %r8        # 0x9fa10
leaq 0x148(%rip), %r9        # 0x9fa30
callq 0x9f2e0
movq %rax, 0x5a3224(%rip)    # 0x642b18
callq 0x9f280
movq 0x5a3218(%rip), %rax    # 0x642b18
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x9fc8e
movq 0x38(%rsp), %rax
addq 0x30(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0xa9d00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x9fcc6
movq 0x59c30b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x476374(%rip), %rsi    # 0x516013
leaq 0x493698(%rip), %rdx    # 0x53333e
leaq 0x4936d2(%rip), %rcx    # 0x53337f
leaq 0x4936f6(%rip), %r8     # 0x5333aa
movl $0x72, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x9fcc8
jmp 0x9fcca
cmpq $0x0, 0x20(%rsp)
je 0x9fd1a
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x9fce2
jmp 0x9fd1a
movq 0x59c2b7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x476320(%rip), %rsi    # 0x516013
leaq 0x4764c5(%rip), %rdx    # 0x5161bf
leaq 0x49367e(%rip), %rcx    # 0x53337f
leaq 0x4936a2(%rip), %r8     # 0x5333aa
movl $0x73, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x9fd1c
callq 0x9f8b0
movq %rax, %rdi
callq 0x9f3b0
movq %rax, 0x10(%rsp)
callq 0x9f8b0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x9f470
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0xaebc0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x2c(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
movq 0x38(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %ecx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0xa1e9e
movq 0x59a133(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x47419c(%rip), %rsi    # 0x516013
leaq 0x491c22(%rip), %rdx    # 0x533aa0
leaq 0x491c42(%rip), %rcx    # 0x533ac7
leaq 0x491c56(%rip), %r8     # 0x533ae2
movl $0x2d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa1ea0
jmp 0xa1ea2
cmpl $0x40, 0x2c(%rsp)
jbe 0xa1ee1
movq 0x59a0f0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x474159(%rip), %rsi    # 0x516013
leaq 0x491c40(%rip), %rdx    # 0x533b01
leaq 0x491bff(%rip), %rcx    # 0x533ac7
leaq 0x491c13(%rip), %r8     # 0x533ae2
movl $0x2e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa1ee3
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x20, %edi
leaq 0x491be1(%rip), %rsi    # 0x533ae2
movl $0x30, %edx
callq 0xe80f0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
shrq $0x6, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
andq $0x3f, %rax
cmpq $0x0, %rax
jbe 0xa1f49
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x8, %esi
leaq 0x491b88(%rip), %rdx    # 0x533ae2
movl $0x36, %ecx
callq 0xe83c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rax
movl $0x40, %ecx
subl 0x18(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x20(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, %ecx
movq $-0x1, %rax
shrq %cl, %rax
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jbe 0xa202c
movq 0x599fa5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x47400e(%rip), %rsi    # 0x516013
leaq 0x491a94(%rip), %rdx    # 0x533aa0
leaq 0x491b1c(%rip), %rcx    # 0x533b2f
leaq 0x491ac8(%rip), %r8     # 0x533ae2
movl $0x45, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa202e
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0x6, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
andq $0x3f, %rax
cmpq $0x0, %rax
jbe 0xa206b
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq $0x20, %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xa2116
movq 0x599ebb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x473f24(%rip), %rsi    # 0x516013
leaq 0x491a55(%rip), %rdx    # 0x533b4b
leaq 0x491a66(%rip), %rcx    # 0x533b63
leaq 0x4919de(%rip), %r8     # 0x533ae2
movl $0x5c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa2118
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
imulq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
andq $0x3f, %rax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
shrq $0x6, %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
ja 0xa2184
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rsp), %rcx
movl 0x1c(%rcx), %ecx
subl 0xc(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq 0x18(%rsp), %rcx
andq 0x10(%rcx), %rax
movq %rax, 0x20(%rsp)
jmp 0xa21e1
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rdx
addl 0x18(%rdx), %ecx
subl $0x40, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq (%rsp), %rdx
movq 0x8(%rcx,%rdx,8), %rdx
movq 0x18(%rsp), %rcx
movl 0x1c(%rcx), %ecx
addl $0x40, %ecx
subl 0xc(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq 0x18(%rsp), %rcx
andq 0x10(%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0xa2947
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rcx
imulq 0x18(%rsp), %rcx
addq %rcx, %rdi
movq 0x28(%rsp), %rsi
callq *%rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0xa2935
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xa2937
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xa28ef
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/countingsort.c
// Function: gt_countingsort_unit_test
int gt_countingsort_unit_test(GtError *err)
{
  unsigned int numbers[]        = { 1, 2, 1, 2, 0 }, numbers_out[5],
               sorted_numbers[] = { 0, 1, 1, 2, 2 };
  int had_err = 0;
  gt_error_check(err);
  gt_countingsort(numbers_out, numbers, sizeof (unsigned int), 5,
                  gt_countingsort_get_max(numbers, sizeof (unsigned int), 5,
                                          NULL, get_int),
                  NULL,  get_int);
  gt_ensure(
         !memcmp(sorted_numbers, numbers_out, sizeof (unsigned int) * 5));
  return had_err;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x49137a(%rip), %rax    # 0x533cf0
movq %rax, 0x60(%rsp)
movq 0x491376(%rip), %rax    # 0x533cf8
movq %rax, 0x68(%rsp)
movl 0x491373(%rip), %eax    # 0x533d00
movl %eax, 0x70(%rsp)
movq 0x491378(%rip), %rax    # 0x533d10
movq %rax, 0x20(%rsp)
movq 0x491374(%rip), %rax    # 0x533d18
movq %rax, 0x28(%rsp)
movl 0x491371(%rip), %eax    # 0x533d20
movl %eax, 0x30(%rsp)
movl $0x0, 0x1c(%rsp)
cmpq $0x0, 0x80(%rsp)
je 0xa2a11
movq 0x80(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0xa29d9
jmp 0xa2a11
movq 0x5995c0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x473629(%rip), %rsi    # 0x516013
leaq 0x4737ce(%rip), %rdx    # 0x5161bf
leaq 0x49128f(%rip), %rcx    # 0x533c87
leaq 0x49125d(%rip), %r8     # 0x533c5c
movl $0x50, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa2a13
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x60(%rsp), %rdi
movl $0x4, %esi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq 0x9f(%rip), %r8         # 0xa2ae0
callq 0xa28c0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %r8
movl $0x4, %edx
movl $0x5, %ecx
xorl %eax, %eax
movl %eax, %r9d
leaq 0x77(%rip), %rax        # 0xa2ae0
movq %rax, (%rsp)
callq 0xa2650
cmpl $0x0, 0x1c(%rsp)
jne 0xa2acd
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl $0x14, %edx
callq 0x192c0
cmpl $0x0, %eax
je 0xa2acb
movq 0x80(%rsp), %rdi
leaq 0x48cb59(%rip), %rsi    # 0x52f5fa
leaq 0x4911f9(%rip), %rdx    # 0x533ca1
leaq 0x4911d8(%rip), %rcx    # 0x533c87
leaq 0x4911a6(%rip), %r8     # 0x533c5c
movl $0x56, %r9d
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
jmp 0xa2acd
jmp 0xa2acf
movl 0x1c(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/dual-pivot-qsort.c
// Function: gt_dual_insertion_sort
static void gt_dual_insertion_sort(GtUword *input,GtUword lowindex,
                                   GtUword highindex)
{
  GtUword pm;

  for (pm = lowindex + 1; pm <= highindex; pm++)
  {
    GtUword pl;

    for (pl = pm; pl > lowindex && input[pl-1] > input[pl]; pl--)
    {
      gt_dpqs_exchange(input, pl, pl-1);
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0xa7e0b
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x28(%rsp), %rcx
movb %al, 0xf(%rsp)
jbe 0xa7dc4
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
seta %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xa7dce
jmp 0xa7df6
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rdx
subq $0x1, %rdx
callq 0xa83f0
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xa7d8b
jmp 0xa7df8
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xa7d71
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_set_bit
void gt_dyn_bittab_set_bit(GtDynBittab *b, GtUword bit)
{
  GtUword new_tabsize;
  gt_assert(b);
  /* make sure tab is large enough */
  if (bit >= b->num_of_bits) {
    if ((new_tabsize = determine_tabsize(bit + 1)) > b->tabsize) {
      b->tabptr = gt_realloc(b->tabptr, new_tabsize * sizeof (GtUword));
      memset(b->tabptr + b->tabsize, 0,
             (new_tabsize - b->tabsize) * sizeof (GtUword));
      b->tabsize = new_tabsize;
    }
    b->num_of_bits = bit + 1;
  }
  /* set bit */
  b->tabptr[(bit >> 3) / sizeof (GtUword)] |=
    1UL << (bit & (8UL * sizeof (GtUword) - 1));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa84be
movq 0x593b13(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x46db7c(%rip), %rsi    # 0x516013
leaq 0x486d6d(%rip), %rdx    # 0x52f20b
leaq 0x48c404(%rip), %rcx    # 0x5348a9
leaq 0x48c3e7(%rip), %r8     # 0x534893
movl $0x2d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa84c0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xa856c
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
callq 0xa85a0
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xa855a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
shlq $0x3, %rsi
leaq 0x48c38b(%rip), %rdx    # 0x534893
movl $0x31, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
subq 0x8(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x19360
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
shrq $0x3, %rcx
shrq $0x3, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_unset_bit
void gt_dyn_bittab_unset_bit(GtDynBittab *b, GtUword bit)
{
  gt_assert(b);
  if (bit < b->num_of_bits) {
    b->tabptr[(bit >> 3) / sizeof (GtUword)] &=
      ~(1UL << (bit & (8UL * sizeof (GtUword) - 1)));
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa862e
movq 0x5939a3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x46da0c(%rip), %rsi    # 0x516013
leaq 0x486bfd(%rip), %rdx    # 0x52f20b
leaq 0x48c2aa(%rip), %rcx    # 0x5348bf
leaq 0x48c277(%rip), %r8     # 0x534893
movl $0x3f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa8630
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa8672
movq 0x8(%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
xorq $-0x1, %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
shrq $0x3, %rcx
shrq $0x3, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_bit_is_set
bool gt_dyn_bittab_bit_is_set(const GtDynBittab *b, GtUword bit)
{
  gt_assert(b);
  if (bit < b->num_of_bits &&
      (b->tabptr[(bit >> 3) / sizeof (GtUword)] &
       1UL << (bit & (8UL * sizeof (GtUword) - 1)))) {
    return true;
  }
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xa86cd
movq 0x593904(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x46d96d(%rip), %rsi    # 0x516013
leaq 0x486b5e(%rip), %rdx    # 0x52f20b
leaq 0x48c223(%rip), %rcx    # 0x5348d7
leaq 0x48c1d8(%rip), %r8     # 0x534893
movl $0x48, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa86cf
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa8719
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
shrq $0x3, %rcx
shrq $0x3, %rcx
movq (%rax,%rcx,8), %rax
movq (%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0xa8719
movb $0x1, 0x17(%rsp)
jmp 0xa871e
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_get_first_bitnum
GtUword gt_dyn_bittab_get_first_bitnum(const GtDynBittab *b)
{
  GtUword i, rval = GT_UNDEF_UWORD;
  gt_assert(b);
  for (i = 0; i < b->num_of_bits; i++)
    if (gt_dyn_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $-0x1, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xa8782
movq 0x59384f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x46d8b8(%rip), %rsi    # 0x516013
leaq 0x486aa9(%rip), %rdx    # 0x52f20b
leaq 0x48c187(%rip), %rcx    # 0x5348f0
leaq 0x48c123(%rip), %r8     # 0x534893
movl $0x54, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa8784
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa87d0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa8680
testb $0x1, %al
jne 0xa87b2
jmp 0xa87be
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xa87d0
jmp 0xa87c0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xa878d
cmpq $-0x1, 0x8(%rsp)
jne 0xa87e8
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa87f2
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_get_next_bitnum
GtUword gt_dyn_bittab_get_next_bitnum(const GtDynBittab *b,
                                            GtUword curnum)
{
  GtUword i, rval = GT_UNDEF_UWORD;

  gt_assert(b);
  gt_assert(curnum < b->num_of_bits);
  for (i = curnum + 1; i < b->num_of_bits; i++)
    if (gt_dyn_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $-0x1, (%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xa88a6
movq 0x59372b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x46d794(%rip), %rsi    # 0x516013
leaq 0x486985(%rip), %rdx    # 0x52f20b
leaq 0x48c0a0(%rip), %rcx    # 0x53492d
leaq 0x48bfff(%rip), %r8     # 0x534893
movl $0x6a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa88a8
jmp 0xa88aa
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xa88f2
movq 0x5936df(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x46d748(%rip), %rsi    # 0x516013
leaq 0x488c03(%rip), %rdx    # 0x5314d5
leaq 0x48c054(%rip), %rcx    # 0x53492d
leaq 0x48bfb3(%rip), %r8     # 0x534893
movl $0x6b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xa88f4
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa8944
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xa8680
testb $0x1, %al
jne 0xa8927
jmp 0xa8932
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0xa8944
jmp 0xa8934
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xa8902
cmpq $-0x1, (%rsp)
jne 0xa895b
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa8964
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_create
GtFastaReader* gt_fasta_reader_create(const GtFastaReaderClass *frc)
{
  GtFastaReader *fr;
  gt_assert(frc && frc->size);
  fr = gt_calloc(1, frc->size);
  fr->c_class = frc;
  return fr;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xdc44c
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xdc484
movq 0x55fb4d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x439bb6(%rip), %rsi    # 0x516013
leaq 0x45f5a2(%rip), %rdx    # 0x53ba06
leaq 0x45f5ac(%rip), %rcx    # 0x53ba17
leaq 0x45f5bc(%rip), %r8     # 0x53ba2e
movl $0x19, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdc486
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0x45f594(%rip), %rdx    # 0x53ba2e
movl $0x1a, %ecx
callq 0xe83c0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_delete
void gt_fasta_reader_delete(GtFastaReader *fr)
{
  if (!fr) return;
  gt_assert(fr->c_class && fr->c_class->free);
  fr->c_class->free(fr);
  gt_free(fr);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xdc4ce
jmp 0xdc548
jmp 0xdc4d0
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0xdc4e8
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdc520
movq 0x55fab1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x439b1a(%rip), %rsi    # 0x516013
leaq 0x45f546(%rip), %rdx    # 0x53ba46
leaq 0x45f560(%rip), %rcx    # 0x53ba67
leaq 0x45f520(%rip), %r8     # 0x53ba2e
movl $0x22, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdc522
movq (%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rdi
leaq 0x45f4f0(%rip), %rsi    # 0x53ba2e
movl $0x24, %edx
callq 0xe88c0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_run
int gt_fasta_reader_run(GtFastaReader *fr,
                     GtFastaReaderProcDescription proc_description,
                     GtFastaReaderProcSequencePart proc_sequence_part,
                     GtFastaReaderProcSequenceLength proc_sequence_length,
                     void *data, GtError *err)
{
  gt_error_check(err);
  gt_assert(fr && fr->c_class && fr->c_class->run);
  return fr->c_class->run(fr, proc_description, proc_sequence_part,
                          proc_sequence_length, data, err);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdc5c2
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0xdc58a
jmp 0xdc5c2
movq 0x55fa0f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x439a78(%rip), %rsi    # 0x516013
leaq 0x439c1d(%rip), %rdx    # 0x5161bf
leaq 0x45f4d5(%rip), %rcx    # 0x53ba7e
leaq 0x45f47e(%rip), %r8     # 0x53ba2e
movl $0x2d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdc5c4
jmp 0xdc5c6
cmpq $0x0, 0x30(%rsp)
je 0xdc5e8
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
je 0xdc5e8
movq 0x30(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0xdc620
movq 0x55f9b1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x439a1a(%rip), %rsi    # 0x516013
leaq 0x45f492(%rip), %rdx    # 0x53ba92
leaq 0x45f477(%rip), %rcx    # 0x53ba7e
leaq 0x45f420(%rip), %r8     # 0x53ba2e
movl $0x2e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdc622
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq *%rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta_reader_rec.c
// Function: gt_fasta_reader_rec_new
GtFastaReader* gt_fasta_reader_rec_new(const GtStr *sequence_filename)
{
  GtFastaReader *fr = gt_fasta_reader_create(gt_fasta_reader_rec_class());
  GtFastaReaderRec *gt_fasta_reader_rec = gt_fasta_reader_rec_cast(fr);
  gt_fasta_reader_rec->seqio = gt_io_new(sequence_filename
                                   ? gt_str_get(sequence_filename) : NULL,
                                   "r");
  return fr;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0xdc6e0
movq %rax, %rdi
callq 0xdc430
movq %rax, 0x18(%rsp)
callq 0xdc6e0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0xdc660
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xdca2b
movq 0x20(%rsp), %rdi
callq 0x11dee0
movq %rax, 0x8(%rsp)
jmp 0xdca34
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xdca34
movq 0x8(%rsp), %rdi
leaq 0x44f59a(%rip), %rsi    # 0x52bfda
callq 0xe6f60
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta_reader_rec.c
// Function: parse_fasta_entry
static int parse_fasta_entry(GtStr *description, GtStr *sequence,
                             GtIO *seqio, GtError *err)
{
  int had_err;
  gt_error_check(err);
  gt_assert(description && sequence && seqio);
  had_err = parse_fasta_description(description, seqio, err);
  if (!had_err)
    had_err = parse_fasta_sequence(sequence, seqio, err);
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdcac8
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0xdca90
jmp 0xdcac8
movq 0x55f509(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x439572(%rip), %rsi    # 0x516013
leaq 0x439717(%rip), %rdx    # 0x5161bf
leaq 0x475b21(%rip), %rcx    # 0x5525d0
leaq 0x45f04f(%rip), %r8     # 0x53bb05
movl $0x51, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcaca
jmp 0xdcacc
cmpq $0x0, 0x20(%rsp)
je 0xdcae4
cmpq $0x0, 0x18(%rsp)
je 0xdcae4
cmpq $0x0, 0x10(%rsp)
jne 0xdcb1c
movq 0x55f4b5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x43951e(%rip), %rsi    # 0x516013
leaq 0x45f080(%rip), %rdx    # 0x53bb7c
leaq 0x475acd(%rip), %rcx    # 0x5525d0
leaq 0x45effb(%rip), %r8     # 0x53bb05
movl $0x52, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcb1e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xdcb60
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xdcb55
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xdcd10
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta_reader_rec.c
// Function: parse_fasta_description
static int parse_fasta_description(GtStr *description, GtIO *seqio,
                                   GtError *err)
{
  GT_UNUSED int rval;
  char cc;
  gt_error_check(err);
  gt_assert(description && seqio);
  rval = gt_io_get_char(seqio, &cc);
  gt_assert(!rval); /* was checked earlier */
  /* make sure we got a proper fasta description */
  if (cc != GT_FASTA_SEPARATOR) {
    gt_error_set(err, "the first character of fasta file \"%s\" has to be '%c'",
                 gt_io_get_filename(seqio), GT_FASTA_SEPARATOR);
    return -1;
  }
  /* read description */
  while (!gt_io_get_char(seqio, &cc) && cc != '\n') {
    if (cc != '\r')
      gt_str_append_char(description, cc);
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xdcbc3
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0xdcb8b
jmp 0xdcbc3
movq 0x55f40e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x439477(%rip), %rsi    # 0x516013
leaq 0x43961c(%rip), %rdx    # 0x5161bf
leaq 0x45eff3(%rip), %rcx    # 0x53bb9d
leaq 0x45ef54(%rip), %r8     # 0x53bb05
movl $0x26, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcbc5
jmp 0xdcbc7
cmpq $0x0, 0x28(%rsp)
je 0xdcbd7
cmpq $0x0, 0x20(%rsp)
jne 0xdcc0f
movq 0x55f3c2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x43942b(%rip), %rsi    # 0x516013
leaq 0x45efc6(%rip), %rdx    # 0x53bbb5
leaq 0x45efa7(%rip), %rcx    # 0x53bb9d
leaq 0x45ef08(%rip), %r8     # 0x53bb05
movl $0x27, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcc11
movq 0x20(%rsp), %rdi
leaq 0x13(%rsp), %rsi
callq 0xe70d0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0xdcc63
movq 0x55f36e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4393d7(%rip), %rsi    # 0x516013
leaq 0x457649(%rip), %rdx    # 0x53428c
leaq 0x45ef53(%rip), %rcx    # 0x53bb9d
leaq 0x45eeb4(%rip), %r8     # 0x53bb05
movl $0x29, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcc65
movsbl 0x13(%rsp), %eax
cmpl $0x3e, %eax
je 0xdcca8
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe7440
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x45ef38(%rip), %rsi    # 0x53bbca
movl $0x3e, %ecx
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xdcd02
jmp 0xdccaa
movq 0x20(%rsp), %rdi
leaq 0x13(%rsp), %rsi
callq 0xe70d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
jne 0xdccd5
movsbl 0x13(%rsp), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xdccdf
jmp 0xdccfa
movsbl 0x13(%rsp), %eax
cmpl $0xd, %eax
je 0xdccf8
movq 0x28(%rsp), %rdi
movsbl 0x13(%rsp), %esi
callq 0x11da70
jmp 0xdccaa
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)