LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: alphabet_to_key_values
static void alphabet_to_key_values(const GtAlphabet *alpha,
                                   GtUword *alphatype,
                                   GtUword *lengthofalphadef,
                                   char **alphadef, bool customalphabet)
{
  gt_assert(alpha);
  if (!customalphabet && gt_alphabet_is_dna(alpha)) {
    if (alphatype != NULL)
      *alphatype = 0UL;
    if (alphadef != NULL)
      *alphadef = NULL;
    if (lengthofalphadef != NULL)
      *lengthofalphadef = 0UL;
  } else if (!customalphabet && gt_alphabet_is_protein(alpha)) {
    if (alphatype != NULL)
      *alphatype = 1UL;
    if (alphadef != NULL)
      *alphadef = NULL;
    if (lengthofalphadef != NULL)
      *lengthofalphadef = 0UL;
  } else {
    GtStr *s = gt_str_new();
    if (alphatype != NULL)
      *alphatype = 2UL;
    gt_alphabet_to_str(alpha, s);
    if (alphadef != NULL)
      *alphadef = gt_cstr_dup(gt_str_get(s));
    if (lengthofalphadef != NULL)
      *lengthofalphadef = gt_str_length(s);
    gt_str_delete(s);
  }
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x117ca1
movq 0x9c368(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x463ec(%rip), %rsi     # 0x15e066
leaq 0x63a43(%rip), %rdx     # 0x17b6c4
leaq 0x70e1d(%rip), %rcx     # 0x188aa5
leaq 0x6d9cf(%rip), %r8      # 0x18565e
movl $0x43e, %r9d            # imm = 0x43E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x117ca3
testb $0x1, 0x17(%rsp)
jne 0x117cfb
movq 0x30(%rsp), %rdi
callq 0x10a8e0
testb $0x1, %al
jne 0x117cba
jmp 0x117cfb
cmpq $0x0, 0x28(%rsp)
je 0x117cce
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0x117ce2
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x20(%rsp)
je 0x117cf6
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
jmp 0x117dcb
testb $0x1, 0x17(%rsp)
jne 0x117d50
movq 0x30(%rsp), %rdi
callq 0x10a680
testb $0x1, %al
jne 0x117d12
jmp 0x117d50
cmpq $0x0, 0x28(%rsp)
je 0x117d26
movq 0x28(%rsp), %rax
movq $0x1, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0x117d3a
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x20(%rsp)
je 0x117d4e
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
jmp 0x117dc9
callq 0x18f00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x117d6e
movq 0x28(%rsp), %rax
movq $0x2, (%rax)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x109f50
cmpq $0x0, 0x18(%rsp)
je 0x117da2
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
callq 0x7c400
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x20(%rsp)
je 0x117dbf
movq 0x8(%rsp), %rdi
callq 0x19a00
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x1afc0
jmp 0x117dcb
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_equallength_write_twobitencoding_to_file
int gt_encseq_equallength_write_twobitencoding_to_file(const char *indexname,
                                     GtUword totallength,
                                     GtUword lengthofsinglesequence,
                                     GtTwobitencoding *twobitencoding,
                                     GtUword numofsequences,
                                     GtUword numoffiles,
                                     const GtFilelengthvalues *filelengthtab,
                                     const GtStrArray *filenametab,
                                     const GtUword *characterdistribution,
                                     GtError *err)
{
  gt_assert (lengthofsinglesequence > 0);
  return gt_encseq_generic_write_twobitencoding_to_file(indexname,
                                     totallength,
                                     GT_ACCESS_TYPE_EQUALLENGTH,
                                     lengthofsinglesequence,
                                     lengthofsinglesequence,
                                     lengthofsinglesequence,
                                     0,
                                     0,
                                     lengthofsinglesequence,
                                     twobitencoding,
                                     numofsequences,
                                     numoffiles,
                                     filelengthtab,
                                     filenametab,
                                     characterdistribution,
                                     err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0xd8(%rsp), %rax
movq 0xd0(%rsp), %rax
movq 0xc8(%rsp), %rax
movq 0xc0(%rsp), %rax
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
cmpq $0x0, 0x70(%rsp)
ja 0x1189c2
movq 0x9b647(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x456cb(%rip), %rsi     # 0x15e066
leaq 0x6d395(%rip), %rdx     # 0x185d37
leaq 0x6d3a9(%rip), %rcx     # 0x185d52
leaq 0x6ccae(%rip), %r8      # 0x18565e
movl $0x652, %r9d            # imm = 0x652
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1189c4
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0x70(%rsp), %r9
movq 0x70(%rsp), %r13
movq 0x68(%rsp), %r12
movq 0x60(%rsp), %r15
movq 0x58(%rsp), %r14
movq 0xc0(%rsp), %rbx
movq 0xc8(%rsp), %r11
movq 0xd0(%rsp), %r10
movq 0xd8(%rsp), %rax
movl $0x2, %edx
xorl %ebp, %ebp
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
callq 0x1169f0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: setencsequtablesNULL
static void setencsequtablesNULL(GtEncseqAccessType sat,
                                 GtSWtable *swtable)
{
  switch (sat) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      swtable->st_uchar.positions = NULL;
      swtable->st_uchar.mappositions = NULL;
      swtable->st_uchar.endidxinpage = NULL;
      swtable->st_uchar.rangelengths = NULL;
      break;
    case GT_ACCESS_TYPE_USHORTTABLES:
      swtable->st_uint16.positions = NULL;
      swtable->st_uint16.mappositions = NULL;
      swtable->st_uint16.endidxinpage = NULL;
      swtable->st_uint16.rangelengths = NULL;
      break;
    case GT_ACCESS_TYPE_UINT32TABLES:
      swtable->st_uint32.positions = NULL;
      swtable->st_uint32.mappositions = NULL;
      swtable->st_uint32.endidxinpage = NULL;
      swtable->st_uint32.rangelengths = NULL;
      break;
    default:
      break;
  }
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x14(%rsp)
subl $0x4, %eax
je 0x118cf1
jmp 0x118cd8
movl -0x14(%rsp), %eax
subl $0x5, %eax
je 0x118d26
jmp 0x118ce3
movl -0x14(%rsp), %eax
subl $0x6, %eax
je 0x118d5b
jmp 0x118d90
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x118d92
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x118d92
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x118d92
jmp 0x118d92
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_ref
GtEncseq* gt_encseq_ref(GtEncseq *encseq)
{
  if (!encseq) return NULL;
  gt_mutex_lock(encseq->refcount_lock);
  encseq->reference_count++;
  gt_mutex_unlock(encseq->refcount_lock);
  return encseq;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x118dbc
movq $0x0, 0x10(%rsp)
jmp 0x118dff
movq 0x8(%rsp), %rax
movq 0x398(%rax), %rdi
callq 0x1c340
movq 0x8(%rsp), %rax
movq 0x390(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x390(%rax)
movq 0x8(%rsp), %rax
movq 0x398(%rax), %rdi
callq 0x1c3e0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_all_sequence_separators_get
GtUword *gt_all_sequence_separators_get(const GtEncseq *encseq)
{
  switch (encseq->satsep) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      return gt_all_ssps_get_uchar(&encseq->ssptab.st_uchar);
    case GT_ACCESS_TYPE_USHORTTABLES:
      return gt_all_ssps_get_uint16(&encseq->ssptab.st_uint16);
    case GT_ACCESS_TYPE_UINT32TABLES:
      return gt_all_ssps_get_uint32(&encseq->ssptab.st_uint32);
    default: return NULL; /* which means that all sequences are of the
                             same length */
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x4, %eax
je 0x118e42
jmp 0x118e2c
movl 0x4(%rsp), %eax
subl $0x5, %eax
je 0x118e5a
jmp 0x118e37
movl 0x4(%rsp), %eax
subl $0x6, %eax
je 0x118e72
jmp 0x118e8a
movq 0x8(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x118ea0
movq %rax, 0x10(%rsp)
jmp 0x118e93
movq 0x8(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x119040
movq %rax, 0x10(%rsp)
jmp 0x118e93
movq 0x8(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x1191e0
movq %rax, 0x10(%rsp)
jmp 0x118e93
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_all_sequence_lengths_get
GtUword *gt_all_sequence_lengths_get(const GtEncseq *encseq)
{
  GtUword idx, previousstart = 0,
          *ssptab = gt_all_sequence_separators_get(encseq);
  const GtUword numofsequences = gt_encseq_num_of_sequences(encseq),
                totallength = gt_encseq_total_length(encseq);;

  if (ssptab == NULL)
  {
    return NULL; /* all sequences are of the same length */
  }
  gt_assert(numofsequences > 0);
  for (idx = 0; idx < numofsequences - 1; idx++)
  {
    GtUword nextsep = ssptab[idx];
    gt_assert(previousstart < nextsep);
    ssptab[idx] = nextsep - previousstart;
    previousstart = nextsep + 1;
  }
  gt_assert(previousstart < totallength);
  ssptab[idx] = totallength - previousstart;
  return ssptab;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x118e10
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x113f30
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x113ee0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1193d5
movq $0x0, 0x40(%rsp)
jmp 0x119535
jmp 0x1193d7
cmpq $0x0, 0x18(%rsp)
ja 0x119417
movq 0x9abf2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x44c76(%rip), %rsi     # 0x15e066
leaq 0x6c92d(%rip), %rdx     # 0x185d24
leaq 0x6ca27(%rip), %rcx     # 0x185e25
leaq 0x6c259(%rip), %r8      # 0x18565e
movl $0xc9e, %r9d            # imm = 0xC9E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x119419
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1194cb
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x119490
movq 0x9ab79(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x44bfd(%rip), %rsi     # 0x15e066
leaq 0x6c9d1(%rip), %rdx     # 0x185e41
leaq 0x6c9ae(%rip), %rcx     # 0x185e25
leaq 0x6c1e0(%rip), %r8      # 0x18565e
movl $0xca2, %r9d            # imm = 0xCA2
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x119492
movq 0x8(%rsp), %rdx
subq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x119422
jmp 0x1194cd
movq 0x28(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x119511
movq 0x9aaf8(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x44b7c(%rip), %rsi     # 0x15e066
leaq 0x6c968(%rip), %rdx     # 0x185e59
leaq 0x6c92d(%rip), %rcx     # 0x185e25
leaq 0x6c15f(%rip), %r8      # 0x18565e
movl $0xca6, %r9d            # imm = 0xCA6
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x119513
movq 0x10(%rsp), %rdx
subq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_specialrangeiterator_new
GtSpecialrangeiterator* gt_specialrangeiterator_new(const GtEncseq *encseq,
                                                    bool moveforward)
{
  GtSpecialrangeiterator *sri;

  gt_assert(encseq->has_specialranges
              || (encseq->hasmirror && encseq->logicalnumofdbsequences == 2UL));
  sri = gt_malloc(sizeof (*sri));
  sri->esr = NULL;
  sri->originalmoveforward = moveforward;
  gt_specialrangeiterator_reinit(sri, encseq, moveforward);
  sri->reflected = false;
  sri->skipnext = false;
  sri->middle_separator_emitted = false;
  gt_assert(sri != NULL);
  return sri;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x28(%rax)
jne 0x11989f
movq 0x10(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x119867
movq 0x10(%rsp), %rax
cmpq $0x2, 0x48(%rax)
je 0x11989f
movq 0x9a76a(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x447ee(%rip), %rsi     # 0x15e066
leaq 0x6c68f(%rip), %rdx     # 0x185f0e
leaq 0x6c6e3(%rip), %rcx     # 0x185f69
leaq 0x6bdd1(%rip), %r8      # 0x18565e
movl $0xd3d, %r9d            # imm = 0xD3D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1198a1
movl $0x80, %edi
leaq 0x6bdb1(%rip), %rsi     # 0x18565e
movl $0xd3e, %edx            # imm = 0xD3E
callq 0xd2e0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x68(%rax)
movb 0xf(%rsp), %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, 0x64(%rax)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x1197f0
movq (%rsp), %rax
movb $0x0, 0x62(%rax)
movq (%rsp), %rax
movb $0x0, 0x63(%rax)
movq (%rsp), %rax
movb $0x0, 0x65(%rax)
cmpq $0x0, (%rsp)
jne 0x119943
movq 0x9a6c6(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4474a(%rip), %rsi     # 0x15e066
leaq 0x6c662(%rip), %rdx     # 0x185f85
leaq 0x6c63f(%rip), %rcx     # 0x185f69
leaq 0x6bd2d(%rip), %r8      # 0x18565e
movl $0xd45, %r9d            # imm = 0xD45
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x119945
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_specialrangeiterator_invert_range
static inline void gt_specialrangeiterator_invert_range(GtEncseq *encseq,
                                                        GtRange *range)
{
  gt_assert(encseq && range);
  range->start = GT_REVERSEPOS(encseq->logicaltotallength,
                               range->start);
  range->end = GT_REVERSEPOS(encseq->logicaltotallength,
                             range->end);
  if (range->end <= range->start) {
    GtUword tmp;
    tmp = ++range->end;
    range->end = ++range->start;
    range->start = tmp;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x119cce
cmpq $0x0, 0x8(%rsp)
jne 0x119d06
movq 0x9a303(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x44387(%rip), %rsi     # 0x15e066
leaq 0x6f26c(%rip), %rdx     # 0x188f52
leaq 0x6f275(%rip), %rcx     # 0x188f62
leaq 0x6b96a(%rip), %r8      # 0x18565e
movl $0xe94, %r9d            # imm = 0xE94
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x119d08
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rcx
subq $0x1, %rcx
movq 0x8(%rsp), %rax
subq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rcx
subq $0x1, %rcx
movq 0x8(%rsp), %rax
subq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
ja 0x119d90
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x8(%rcx)
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_specialrangeiterator_deliver_range
static inline bool gt_specialrangeiterator_deliver_range(
                                                    GtSpecialrangeiterator *sri,
                                                    GtRange *range)
{
  switch (sri->esr->encseq->sat) {
    case  GT_ACCESS_TYPE_DIRECTACCESS:
      return gt_dabc_specialrangeiterator_next(true, range, sri);
    case GT_ACCESS_TYPE_BYTECOMPRESS:
      return gt_dabc_specialrangeiterator_next(false, range, sri);
    case GT_ACCESS_TYPE_EQUALLENGTH:
      return gt_equallength_specialrangeiterator_next(range, sri);
    case GT_ACCESS_TYPE_BITACCESS:
      return gt_bitaccess_specialrangeiterator_next(range, sri);
    default:
      return gt_viautables_specialrangeiterator_next(range, sri);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x119e3f
movq 0x8(%rsp), %rax
leaq 0x6b699(%rip), %rcx     # 0x18546c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl $0x1, %edi
callq 0x12ffc0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x119e54
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
xorl %edi, %edi
callq 0x12ffc0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x119e54
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x130210
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x119e54
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x130410
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x119e54
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x130770
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seqnum_ssptab
GtUword gt_encseq_seqnum_ssptab(const GtEncseq *encseq,
                                         GtUword position)
{
  gt_assert(position < encseq->totallength);
  switch (encseq->satsep) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      return gt_encseq_seqnum_uchar(&encseq->ssptab.st_uchar,position);
    case GT_ACCESS_TYPE_USHORTTABLES:
      return gt_encseq_seqnum_uint16(&encseq->ssptab.st_uint16,position);
    case GT_ACCESS_TYPE_UINT32TABLES:
      return gt_encseq_seqnum_uint32(&encseq->ssptab.st_uint32,position);
    default:
      fprintf(stderr, "%s(%d) undefined\n", __func__, (int) encseq->satsep);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x11a0c6
movq 0x99f43(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x43fc7(%rip), %rsi     # 0x15e066
leaq 0x708ab(%rip), %rdx     # 0x18a951
leaq 0x6bf5e(%rip), %rcx     # 0x18600b
leaq 0x6b5aa(%rip), %r8      # 0x18565e
movl $0xf48, %r9d            # imm = 0xF48
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11a0c8
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x4, %eax
je 0x11a0f1
jmp 0x11a0db
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x11a10e
jmp 0x11a0e6
movl 0xc(%rsp), %eax
subl $0x6, %eax
je 0x11a12b
jmp 0x11a148
movq 0x18(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq 0x10(%rsp), %rsi
callq 0x11a190
movq %rax, 0x20(%rsp)
jmp 0x11a179
movq 0x18(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq 0x10(%rsp), %rsi
callq 0x11a2e0
movq %rax, 0x20(%rsp)
jmp 0x11a179
movq 0x18(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq 0x10(%rsp), %rsi
callq 0x11a430
movq %rax, 0x20(%rsp)
jmp 0x11a179
movq 0x99e89(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0x6bec2(%rip), %rsi     # 0x186023
leaq 0x6bea3(%rip), %rdx     # 0x18600b
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seqnum
GtUword gt_encseq_seqnum(const GtEncseq *encseq,
                               GtUword position)
{
  GtUword num;
  bool wasmirrored = false;
  if (encseq->hasmirror && position >= encseq->totallength) {
    position = encseq->logicaltotallength - 1 - position;
    wasmirrored = true;
  }
  gt_assert(position < encseq->totallength);
  if (encseq->sat != GT_ACCESS_TYPE_EQUALLENGTH) {
    if (encseq->numofdbsequences == 1UL) {
      num = 0;
    }
    else {
      num = gt_encseq_seqnum_ssptab(encseq, position);
    }
  }
  else {
    num = gt_encseq_seqnum_Viaequallength(encseq, position);
  }
  if (wasmirrored) {
    num = encseq->logicalnumofdbsequences - 1 - num;
  }
  return num;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x11a5cd
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x11a5cd
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
subq $0x1, %rax
subq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x1, 0xf(%rsp)
jmp 0x11a5cf
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x11a617
movq 0x999f2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x43a76(%rip), %rsi     # 0x15e066
leaq 0x7035a(%rip), %rdx     # 0x18a951
leaq 0x6ba37(%rip), %rcx     # 0x186035
leaq 0x6b059(%rip), %r8      # 0x18565e
movl $0xf5f, %r9d            # imm = 0xF5F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11a619
movq 0x20(%rsp), %rax
cmpl $0x2, (%rax)
je 0x11a650
movq 0x20(%rsp), %rax
cmpq $0x1, 0x40(%rax)
jne 0x11a63a
movq $0x0, 0x10(%rsp)
jmp 0x11a64e
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11a070
movq %rax, 0x10(%rsp)
jmp 0x11a664
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11a690
movq %rax, 0x10(%rsp)
testb $0x1, 0xf(%rsp)
je 0x11a682
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
subq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seqstartpos_viautables
static GtUword gt_encseq_seqstartpos_viautables(const GtEncseq *encseq,
                                                      GtUword seqnum)
{
  switch (encseq->satsep) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      return gt_encseq_seqstartposSW_uchar(&encseq->ssptab.st_uchar,
                                           seqnum);
    case GT_ACCESS_TYPE_USHORTTABLES:
      return gt_encseq_seqstartposSW_uint16(&encseq->ssptab.st_uint16,
                                            seqnum);
    case GT_ACCESS_TYPE_UINT32TABLES:
      return gt_encseq_seqstartposSW_uint32(&encseq->ssptab.st_uint32,
                                            seqnum);
    default:
      fprintf(stderr, "%s(%d) undefined\n", __func__, (int) encseq->satsep);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x4, %eax
je 0x11aab7
jmp 0x11aaa1
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x11aad4
jmp 0x11aaac
movl 0xc(%rsp), %eax
subl $0x6, %eax
je 0x11aaf1
jmp 0x11ab0e
movq 0x18(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq 0x10(%rsp), %rsi
callq 0x1313d0
movq %rax, 0x20(%rsp)
jmp 0x11ab3f
movq 0x18(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq 0x10(%rsp), %rsi
callq 0x131430
movq %rax, 0x20(%rsp)
jmp 0x11ab3f
movq 0x18(%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq 0x10(%rsp), %rsi
callq 0x131490
movq %rax, 0x20(%rsp)
jmp 0x11ab3f
movq 0x994c3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0x6b4fc(%rip), %rsi     # 0x186023
leaq 0x6e7c7(%rip), %rdx     # 0x1892f5
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seqlength
GtUword gt_encseq_seqlength(const GtEncseq *encseq, GtUword seqnum)
{
  gt_assert(encseq != NULL && seqnum < encseq->logicalnumofdbsequences);
  if (encseq->hasmirror && seqnum >= encseq->numofdbsequences) {
    seqnum = GT_REVERSEPOS(encseq->logicalnumofdbsequences, seqnum);
  }
  if (encseq->sat != GT_ACCESS_TYPE_EQUALLENGTH) {
    if (seqnum == 0) {
      if (encseq->numofdbsequences == 1UL)
        return encseq->totallength;
      else
        return gt_encseq_seqstartpos_viautables(encseq, 1UL) - 1;
    }
    else {
      GtUword startpos = gt_encseq_seqstartpos(encseq, seqnum);
      if (seqnum == encseq->numofdbsequences - 1)
        return encseq->totallength - startpos;
      else {
        return gt_encseq_seqstartpos_viautables(encseq, seqnum + 1UL)
                 - 1 - startpos;
      }
    }
  }
  else
    return encseq->equallength.valueunsignedlong;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x11abf6
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jb 0x11ac2e
movq 0x993db(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4345f(%rip), %rsi     # 0x15e066
leaq 0x6b438(%rip), %rdx     # 0x186046
leaq 0x6b4d6(%rip), %rcx     # 0x1860eb
leaq 0x6aa42(%rip), %r8      # 0x18565e
movl $0xfa0, %r9d            # imm = 0xFA0
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11ac30
movq 0x18(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x11ac65
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jb 0x11ac65
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
subq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x2, (%rax)
je 0x11ad17
cmpq $0x0, 0x10(%rsp)
jne 0x11acb4
movq 0x18(%rsp), %rax
cmpq $0x1, 0x40(%rax)
jne 0x11ac9a
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x11ad28
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11aa80
subq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x11ad28
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11a710
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x40(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x11acf4
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
subq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x11ad28
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x11aa80
subq $0x1, %rax
subq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x11ad28
movq 0x18(%rsp), %rax
movq 0x1f0(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_check_markpos
void gt_encseq_check_markpos(const GtEncseq *encseq)
{
  if (encseq->numofdbsequences > 1UL) {
    GtUword *markpos, totallength, pos, currentseqnum = 0, seqnum;
    GtUchar currentchar;
    GtEncseqReader *esr;

    markpos = encseq2markpositions(encseq);
    totallength = encseq->logicaltotallength;
    esr = gt_encseq_create_reader_with_readmode(encseq, GT_READMODE_FORWARD, 0);

    for (pos=0; pos<totallength; pos++) {
      currentchar = gt_encseq_reader_next_encoded_char(esr);
      if (currentchar == (GtUchar) GT_SEPARATOR)
        currentseqnum++;
      else {
        seqnum = gt_encseq_sep2seqnum(markpos, encseq->numofdbsequences,
                                      totallength, pos);
        if (seqnum != currentseqnum) {
          fprintf(stderr, "pos= "GT_WU" seqnum = "GT_WU" != "GT_WU" = "
                          "currentseqnum\n",
                          pos, seqnum, currentseqnum);
          exit(GT_EXIT_PROGRAMMING_ERROR);
        }
      }
    }
    gt_encseq_reader_delete(esr);
    gt_free(markpos);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x1, 0x40(%rax)
jbe 0x11ae6d
movq $0x0, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11ae80
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x116560
movq %rax, 0x8(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x11ae4d
movq 0x8(%rsp), %rdi
callq 0x115010
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0xff, %eax
jne 0x11add7
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x11ae38
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x119e90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x11ae36
movq 0x991cc(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
leaq 0x6b2da(%rip), %rsi     # 0x1860ff
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
jmp 0x11ae38
jmp 0x11ae3a
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x11ad9d
movq 0x8(%rsp), %rdi
callq 0x1165d0
movq 0x38(%rsp), %rdi
leaq 0x6a7fb(%rip), %rsi     # 0x18565e
movl $0xfd4, %edx            # imm = 0xFD4
callq 0xdab0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: encseq2markpositions
static GtUword *encseq2markpositions(const GtEncseq *encseq)
{
  GtArrayGtUword asp;
  GtSpecialrangeiterator *sri;
  GtRange range;
  GtEncseqReader *esr = NULL;

  gt_assert (encseq->numofdbsequences > 1UL);
  asp.allocatedGtUword = encseq->numofdbsequences-1;
  asp.nextfreeGtUword = 0;
  asp.spaceGtUword
    = gt_malloc(sizeof (*asp.spaceGtUword) * asp.allocatedGtUword);
  sri = gt_specialrangeiterator_new(encseq, true);
  while (gt_specialrangeiterator_next(sri, &range)) {
    if (esr == NULL) {
      esr = gt_encseq_create_reader_with_readmode(encseq, GT_READMODE_FORWARD,
                                                  range.start);
    } else {
      gt_encseq_reader_reinit_with_readmode(esr, (GtEncseq*) encseq,
                                            GT_READMODE_FORWARD, range.start);
    }
    gt_addmarkpos(&asp, esr, &range);
  }
  gt_specialrangeiterator_delete(sri);
  gt_encseq_reader_delete(esr);
  return asp.spaceGtUword;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x1, 0x40(%rax)
ja 0x11aed6
movq 0x99133(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x431b7(%rip), %rsi     # 0x15e066
leaq 0x6e485(%rip), %rdx     # 0x18933b
leaq 0x6e49d(%rip), %rcx     # 0x18935a
leaq 0x6a79a(%rip), %r8      # 0x18565e
movl $0xf0a, %r9d            # imm = 0xF0A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11aed8
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
subq $0x1, %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rdi
shlq $0x3, %rdi
leaq 0x6a75b(%rip), %rsi     # 0x18565e
movl $0xf0e, %edx            # imm = 0xF0E
callq 0xd2e0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x119830
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x119950
testb $0x1, %al
jne 0x11af3b
jmp 0x11af87
cmpq $0x0, 0x8(%rsp)
jne 0x11af5b
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rdx
xorl %esi, %esi
callq 0x116560
movq %rax, 0x8(%rsp)
jmp 0x11af71
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rcx
xorl %edx, %edx
callq 0x115f90
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1317c0
jmp 0x11af26
movq 0x20(%rsp), %rdi
callq 0x119e60
movq 0x8(%rsp), %rdi
callq 0x1165d0
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_specialcharinfo_read
int gt_specialcharinfo_read(GtSpecialcharinfo *specialcharinfo,
                            const char *indexname, GtError *err)
{
  GtEncseqMetadata *emd = gt_encseq_metadata_new(indexname, err);
  if (emd == NULL)
    return -1;
  *specialcharinfo = gt_encseq_metadata_specialcharinfo(emd);
  gt_encseq_metadata_delete(emd);
  return 0;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x1410b0
movq %rax, 0x80(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0x11b004
movl $0xffffffff, 0xa4(%rsp) # imm = 0xFFFFFFFF
jmp 0x11b04f
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x142d00
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x70, %edx
callq 0xb500
movq 0x80(%rsp), %rdi
callq 0x142d80
movl $0x0, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_charcount
GtUword gt_encseq_charcount(const GtEncseq *encseq, GtUchar cc)
{
  gt_assert(encseq != NULL &&
            (unsigned int) cc < gt_alphabet_num_of_chars(encseq->alpha));
  if (encseq->hasmirror) {
    return encseq->headerptr.characterdistribution[cc]
             + encseq->headerptr.characterdistribution[GT_COMPLEMENTBASE(cc)];
  } else return encseq->headerptr.characterdistribution[cc];
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x8(%rsp)
movb %al, 0x7(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11b17a
movzbl 0x7(%rsp), %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x220(%rax), %rdi
callq 0x109da0
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jb 0x11b1b2
movq 0x98e57(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x42edb(%rip), %rsi     # 0x15e066
leaq 0x6afb8(%rip), %rdx     # 0x18614a
leaq 0x6afff(%rip), %rcx     # 0x186198
leaq 0x6a4be(%rip), %r8      # 0x18565e
movl $0x10ac, %r9d           # imm = 0x10AC
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11b1b4
movq 0x8(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x11b1fd
movq 0x8(%rsp), %rax
movq 0xf8(%rax), %rax
movzbl 0x7(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movq 0xf8(%rcx), %rcx
movzbl 0x7(%rsp), %esi
movl $0x3, %edx
subl %esi, %edx
movslq %edx, %rdx
addq (%rcx,%rdx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x11b217
movq 0x8(%rsp), %rax
movq 0xf8(%rax), %rax
movzbl 0x7(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: determineoptimalsssptablerep
static GtEncseqAccessType determineoptimalsssptablerep(
                                  GtUword totallength,
                                  GtUword numofseparators)
{
  uint64_t sepsizemin, sepsize;
  GtEncseqAccessType satmin;

  gt_assert (numofseparators > 0);
  sepsizemin = gt_encseq_sizeofSWtable(GT_ACCESS_TYPE_UCHARTABLES, false, false,
                                       totallength, numofseparators);
  satmin = GT_ACCESS_TYPE_UCHARTABLES;
  sepsize = gt_encseq_sizeofSWtable(GT_ACCESS_TYPE_USHORTTABLES, false, false,
                                    totallength, numofseparators);
  if (sepsize < sepsizemin) {
    sepsizemin = sepsize;
    satmin = GT_ACCESS_TYPE_USHORTTABLES;
  }
  sepsize = gt_encseq_sizeofSWtable(GT_ACCESS_TYPE_UINT32TABLES, false, false,
                                    totallength, numofseparators);
  if (sepsize < sepsizemin)
    satmin = GT_ACCESS_TYPE_UINT32TABLES;
  return satmin;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
ja 0x11b57e
movq 0x98a8b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x42b0f(%rip), %rsi     # 0x15e066
leaq 0x6df2e(%rip), %rdx     # 0x18948c
leaq 0x6df3b(%rip), %rcx     # 0x1894a0
leaq 0x6a0f2(%rip), %r8      # 0x18565e
movl $0x6ba, %r9d            # imm = 0x6BA
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11b580
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x4, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x11ce80
movq %rax, 0x10(%rsp)
movl $0x4, 0x4(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x5, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x11ce80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x11b5e0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x5, 0x4(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x6, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x11ce80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x11b611
movl $0x6, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: initSWtable
static void initSWtable(GtSWtable *swtable,
                        GtUword totallength,
                        GtEncseqAccessType sat,
                        GtUword items)
{
  switch (sat) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      swtable->st_uchar.maxrangevalue = (GtUword) UCHAR_MAX;
      swtable->st_uchar.numofpages
        = totallength/swtable->st_uchar.maxrangevalue + 1;
      swtable->st_uchar.numofpositionstostore = items;
      break;
    case GT_ACCESS_TYPE_USHORTTABLES:
      swtable->st_uint16.maxrangevalue = (GtUword) USHRT_MAX;
      swtable->st_uint16.numofpages
        = totallength/swtable->st_uint16.maxrangevalue + 1;
      swtable->st_uint16.numofpositionstostore = items;
      break;
    case GT_ACCESS_TYPE_UINT32TABLES:
      swtable->st_uint32.maxrangevalue = (GtUword) UINT32_MAX;
      swtable->st_uint32.numofpages
        = totallength/swtable->st_uint32.maxrangevalue + 1;
      swtable->st_uint32.numofpositionstostore = items;
      break;
    default:
      fprintf(stderr, "initSWtable(sat = %d is undefined)\n",sat);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x4, %eax
je 0x11b663
jmp 0x11b646
movl 0x4(%rsp), %eax
subl $0x5, %eax
je 0x11b6a3
jmp 0x11b651
movl 0x4(%rsp), %eax
subl $0x6, %eax
je 0x11b6e0
jmp 0x11b71e
movq 0x20(%rsp), %rax
movq $0xff, 0x30(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
xorl %edx, %edx
divq 0x30(%rcx)
movq %rax, %rcx
addq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x11b744
movq 0x20(%rsp), %rax
movq $0xffff, 0x30(%rax)     # imm = 0xFFFF
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
xorl %edx, %edx
divq 0x30(%rcx)
movq %rax, %rcx
addq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x11b744
movq 0x20(%rsp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x30(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
xorl %edx, %edx
divq 0x30(%rcx)
movq %rax, %rcx
addq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x11b744
movq 0x988b3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movl 0x14(%rsp), %edx
leaq 0x6dd8a(%rip), %rsi     # 0x1894bd
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: ssptaboutinfo_processseppos
static void ssptaboutinfo_processseppos(Gtssptaboutinfo *ssptaboutinfo,
                                        GtUword seppos)
{
  if (ssptaboutinfo != NULL) {
    switch (ssptaboutinfo->satsep) {
      case GT_ACCESS_TYPE_UCHARTABLES:
        ssptaboutinfo->ssptabptr->st_uchar.positions[ssptaboutinfo->fillpos++]
          = (GtUchar) (seppos &
                       ssptaboutinfo->ssptabptr->st_uchar.maxrangevalue);
        break;
      case GT_ACCESS_TYPE_USHORTTABLES:
        ssptaboutinfo->ssptabptr->st_uint16.positions[ssptaboutinfo->fillpos++]
          = (uint16_t) (seppos &
                        ssptaboutinfo->ssptabptr->st_uint16.maxrangevalue);
        break;
      case GT_ACCESS_TYPE_UINT32TABLES:
        ssptaboutinfo->ssptabptr->st_uint32.positions[ssptaboutinfo->fillpos++]
          = (uint32_t) (seppos &
                        ssptaboutinfo->ssptabptr->st_uint32.maxrangevalue);
        break;
      default:
        fprintf(stderr, "ssptaboutinfo_processseppos(sat = %d is undefined)\n",
                       (int) ssptaboutinfo->satsep);
        exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x11bb1c
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x4, %eax
je 0x11ba46
jmp 0x11ba2d
movl 0x4(%rsp), %eax
subl $0x5, %eax
je 0x11ba80
jmp 0x11ba38
movl 0x4(%rsp), %eax
subl $0x6, %eax
je 0x11bab9
jmp 0x11baf0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
andq 0x30(%rcx), %rax
movb %al, %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movb %dl, (%rax,%rcx)
jmp 0x11bb1a
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
andq 0x30(%rcx), %rax
movw %ax, %dx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movw %dx, (%rax,%rcx,2)
jmp 0x11bb1a
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
andq 0x30(%rcx), %rax
movl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movl %edx, (%rax,%rcx,4)
jmp 0x11bb1a
movq 0x984e1(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x6da08(%rip), %rsi     # 0x189511
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
jmp 0x11bb1c
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: flushssptab2file
static int flushssptab2file(const char *indexname,
                            Gtssptransferinfo *ssptransferinfo,
                            GtError *err)
{
  FILE *fp;
  bool haserr = false;

  gt_error_check(err);
  fp = gt_fa_fopen_with_suffix(indexname, GT_SSPTABFILESUFFIX, "wb", err);
  if (fp == NULL)
    haserr = true;
  if (!haserr) {
    GtUword sizessptab;

    sizessptab = CALLCASTFUNC(uint64_t, unsigned_long,
                              gt_encseq_sizeofSWtable(ssptransferinfo->satsep,
                                                      false,
                                                      false,
                                                      ssptransferinfo->
                                                        totallength,
                                                      ssptransferinfo->
                                                        numofdbsequences-1));
    if (gt_mapspec_write(assignssptabmapspecification, fp, ssptransferinfo,
                         sizessptab,
                         err) != 0) {
      haserr = true;
    }
  }
  gt_fa_xfclose(fp);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x17(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x11bc48
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x11bc10
jmp 0x11bc48
movq 0x983c1(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x42445(%rip), %rsi     # 0x15e066
leaq 0x42a20(%rip), %rdx     # 0x15e648
leaq 0x6d946(%rip), %rcx     # 0x189575
leaq 0x69a28(%rip), %r8      # 0x18565e
movl $0x3bf, %r9d            # imm = 0x3BF
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11bc4a
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %r9
leaq 0x68a7e(%rip), %rsi     # 0x1846d9
leaq 0x681c0(%rip), %rdx     # 0x183e22
leaq 0x699f5(%rip), %rcx     # 0x18565e
movl $0x3c0, %r8d            # imm = 0x3C0
callq 0x7faa0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x11bc86
movb $0x1, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x11bcf8
movq 0x28(%rsp), %rax
movl 0x10(%rax), %edi
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %r8
subq $0x1, %r8
xorl %edx, %edx
movl %edx, %esi
callq 0x11ce80
movq %rax, %rdx
leaq 0x699a1(%rip), %rdi     # 0x18565e
movl $0x3cd, %esi            # imm = 0x3CD
callq 0x12d160
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %r8
leaq 0x15d69(%rip), %rdi     # 0x131a50
callq 0x145e90
cmpl $0x0, %eax
je 0x11bcf6
movb $0x1, 0x17(%rsp)
jmp 0x11bcf8
movq 0x18(%rsp), %rdi
callq 0x7fd50
movb 0x17(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_max_desc_length
GtUword gt_encseq_max_desc_length(const GtEncseq *encseq)
{
  gt_assert(encseq && encseq->destab);
  /* decides whether destab contains max desc length as a separate field */
  if (encseq->destab[encseq->destablength - 1] == '\n') {
    GtUword i,
                  maxlen = 0;
    for (i = 0; i < gt_encseq_num_of_sequences(encseq); i++) {
      GtUword len;
      (void) gt_encseq_description(encseq, &len, i);
      if (len > maxlen)
        maxlen = len;
    }
    return maxlen;
  } else {
    void *ptr;
    ptr = encseq->destab + encseq->destablength - 2 * (sizeof (GtUword));
    return *(GtUword*) ptr;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x11c050
movq 0x28(%rsp), %rax
cmpq $0x0, 0x200(%rax)
jne 0x11c088
movq 0x97f81(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x42005(%rip), %rsi     # 0x15e066
leaq 0x6a232(%rip), %rdx     # 0x18629a
leaq 0x6a244(%rip), %rcx     # 0x1862b3
leaq 0x695e8(%rip), %r8      # 0x18565e
movl $0x1302, %r9d           # imm = 0x1302
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11c08a
movq 0x28(%rsp), %rax
movq 0x200(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x210(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x11c128
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x113f30
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x11c11c
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x11bd20
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x11c10a
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x11c10c
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x11c0c1
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x11c156
movq 0x28(%rsp), %rax
movq 0x200(%rax), %rax
movq 0x28(%rsp), %rcx
addq 0x210(%rcx), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_has_multiseq_support
bool gt_encseq_has_multiseq_support(const GtEncseq *encseq)
{
  bool ret =  encseq->sat == GT_ACCESS_TYPE_EQUALLENGTH ||
              encseq->has_ssptab ||
              encseq->accesstype_via_utables;
  return ret;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movb $0x1, %al
cmpl $0x2, (%rcx)
movb %al, -0xa(%rsp)
je 0x11c695
movq -0x8(%rsp), %rcx
movb $0x1, %al
testb $0x1, 0x2a(%rcx)
movb %al, -0xa(%rsp)
jne 0x11c695
movq -0x8(%rsp), %rax
movb 0x3a9(%rax), %al
movb %al, -0xa(%rsp)
movb -0xa(%rsp), %al
andb $0x1, %al
movb %al, -0x9(%rsp)
movb -0x9(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)