LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x3a8(%rdi)
jne 0xc29e1
cmpq %rsi, 0x30(%rbx)
jbe 0xc29e5
xorl %ebp, %ebp
jmp 0xc29ef
notq %rsi
addq 0x38(%rbx), %rsi
movb $0x1, %bpl
cmpq 0x30(%rbx), %rsi
jae 0xc2a2a
cmpl $0x2, (%rbx)
jne 0xc2a04
movq %rbx, %rdi
callq 0xc2a2f
jmp 0xc2a17
cmpq $0x1, 0x40(%rbx)
jne 0xc2a0f
xorl %eax, %eax
jmp 0xc2a17
movq %rbx, %rdi
callq 0xc286e
testb %bpl, %bpl
je 0xc2a23
notq %rax
addq 0x48(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2b4e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seqstartpos
GtUword gt_encseq_seqstartpos(const GtEncseq *encseq,
                                    GtUword seqnum)
{
  GtUword pos;
  bool wasmirrored = false;
  gt_assert(encseq != NULL && seqnum < encseq->logicalnumofdbsequences);
  if (encseq->hasmirror && seqnum >= encseq->numofdbsequences) {
    seqnum = encseq->logicalnumofdbsequences - 1 - seqnum;
    wasmirrored = true;
  }
  gt_assert(seqnum < encseq->numofdbsequences);
  if (encseq->numofdbsequences == 1UL) {
    gt_assert(seqnum == 0);
    return (wasmirrored ? encseq->totallength + 1 : 0);
  }
  if (encseq->sat != GT_ACCESS_TYPE_EQUALLENGTH) {
    pos = gt_encseq_seqstartpos_viautables(encseq, seqnum);
    if (wasmirrored) {
      if (seqnum == encseq->numofdbsequences - 1) {
        pos = encseq->totallength + 1;
      } else {
        gt_assert(seqnum + 1 < encseq->numofdbsequences);
        pos = encseq->totallength
                + (encseq->totallength
                    - (gt_encseq_seqstartpos_viautables(encseq,
                                                        seqnum + 1) - 2));
      }
    }
  } else {
    pos = gt_encseq_seqstartpos_Viaequallength(encseq, seqnum);
    if (wasmirrored) {
      if (seqnum == encseq->numofdbsequences - 1) {
        pos = encseq->totallength + 1;
      } else {
        gt_assert(seqnum + 1 < encseq->numofdbsequences);
        pos = encseq->totallength
                + (encseq->totallength
                    - (gt_encseq_seqstartpos_Viaequallength(encseq,
                                                            seqnum + 1) - 2));
      }
    }
  }
  return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc2b61
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq %rsi, %rax
jbe 0xc2b61
cmpb $0x1, 0x3a8(%rbx)
jne 0xc2a96
cmpq %r14, 0x40(%rbx)
jbe 0xc2a9a
xorl %ebp, %ebp
jmp 0xc2aa3
notq %r14
addq %rax, %r14
movb $0x1, %bpl
movq 0x40(%rbx), %rax
cmpq %rax, %r14
jae 0xc2b66
cmpq $0x1, %rax
jne 0xc2acc
testq %r14, %r14
jne 0xc2b6b
testb %bpl, %bpl
jne 0xc2b24
xorl %r15d, %r15d
jmp 0xc2b53
cmpl $0x2, (%rbx)
jne 0xc2b07
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2d3c
testb %bpl, %bpl
je 0xc2b2d
movq 0x40(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r14
je 0xc2b24
incq %r14
cmpq %rax, %r14
jae 0xc2b70
movq 0x30(%rbx), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2d3c
jmp 0xc2b49
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2b7a
testb %bpl, %bpl
je 0xc2b2d
movq 0x40(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r14
jne 0xc2b32
movq 0x30(%rbx), %r15
incq %r15
jmp 0xc2b53
movq %rax, %r15
jmp 0xc2b53
incq %r14
cmpq %rax, %r14
jae 0xc2b75
movq 0x30(%rbx), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2b7a
addq %r15, %r15
subq %rax, %r15
addq $0x2, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b63d
callq 0x2b559
callq 0x2b604
callq 0x2b5cb
callq 0x2b592
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rax
movl 0x4(%rdi), %eax
cmpl $0x6, %eax
je 0xc2c3e
cmpl $0x5, %eax
je 0xc2c1a
cmpl $0x4, %eax
jne 0xc2d35
testq %rsi, %rsi
je 0xc2c65
decq %rsi
movq 0x250(%rdi), %rax
movq 0x260(%rdi), %rcx
leaq (%rax,%rcx,8), %rdx
addq $-0x8, %rdx
xorl %ecx, %ecx
cmpq %rdx, %rax
ja 0xc2bf2
movq %rax, %r8
movq %rdx, %r9
subq %r8, %r9
sarq %r9
andq $-0x8, %r9
cmpq %rsi, (%r8,%r9)
ja 0xc2be5
leaq (%r8,%r9), %rcx
addq %r9, %r8
addq $0x8, %r8
jmp 0xc2bed
leaq (%r8,%r9), %rdx
addq $-0x8, %rdx
cmpq %rdx, %r8
jbe 0xc2bc5
movq %rcx, %rdx
subq %rax, %rdx
shlq $0x5, %rdx
addq $0x100, %rdx            # imm = 0x100
testq %rcx, %rcx
cmoveq %rcx, %rdx
movq 0x240(%rdi), %rax
movzbl (%rax,%rsi), %eax
jmp 0xc2cc6
testq %rsi, %rsi
je 0xc2c65
movq 0x250(%rdi), %rax
movq 0x260(%rdi), %rcx
leaq (%rax,%rcx,8), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rax
jbe 0xc2c6c
xorl %ecx, %ecx
jmp 0xc2ca2
testq %rsi, %rsi
je 0xc2c65
movq 0x250(%rdi), %rax
movq 0x260(%rdi), %rcx
leaq (%rax,%rcx,8), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rax
jbe 0xc2cce
xorl %ecx, %ecx
jmp 0xc2d04
xorl %eax, %eax
jmp 0xc2d33
leaq -0x1(%rsi), %r8
xorl %ecx, %ecx
movq %rax, %r9
movq %rdx, %r10
subq %r9, %r10
sarq %r10
andq $-0x8, %r10
cmpq %r8, (%r9,%r10)
ja 0xc2c95
leaq (%r9,%r10), %rcx
addq %r10, %r9
addq $0x8, %r9
jmp 0xc2c9d
leaq (%r9,%r10), %rdx
addq $-0x8, %rdx
cmpq %rdx, %r9
jbe 0xc2c75
movq %rcx, %rdx
subq %rax, %rdx
shlq $0xd, %rdx
addq $0x10000, %rdx          # imm = 0x10000
testq %rcx, %rcx
cmoveq %rcx, %rdx
movq 0x240(%rdi), %rax
movzwl -0x2(%rax,%rsi,2), %eax
addq %rdx, %rax
incq %rax
jmp 0xc2d33
leaq -0x1(%rsi), %r8
xorl %ecx, %ecx
movq %rax, %r9
movq %rdx, %r10
subq %r9, %r10
sarq %r10
andq $-0x8, %r10
cmpq %r8, (%r9,%r10)
ja 0xc2cf7
leaq (%r9,%r10), %rcx
addq %r10, %r9
addq $0x8, %r9
jmp 0xc2cff
leaq (%r9,%r10), %rdx
addq $-0x8, %rdx
cmpq %rdx, %r9
jbe 0xc2cd7
movq %rcx, %rdx
subq %rax, %rdx
shlq $0x1d, %rdx
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rdx, %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
movq 0x240(%rdi), %rcx
movl -0x4(%rcx,%rsi,4), %ecx
addq %rcx, %rax
incq %rax
popq %rcx
retq
movl %eax, %edi
callq 0x2b676
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc2dff
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq %rsi, %rax
jbe 0xc2dff
cmpb $0x1, 0x3a8(%rbx)
jne 0xc2d8d
cmpq %r14, 0x40(%rbx)
ja 0xc2d8d
notq %r14
addq %rax, %r14
cmpl $0x2, (%rbx)
jne 0xc2d9b
movq 0x1f0(%rbx), %rax
jmp 0xc2df9
testq %r14, %r14
je 0xc2dc3
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2a64
movq %rax, %r15
movq 0x40(%rbx), %rax
decq %rax
cmpq %rax, %r14
jne 0xc2dd0
movq 0x30(%rbx), %rax
subq %r15, %rax
jmp 0xc2df9
cmpq $0x1, 0x40(%rbx)
jne 0xc2de9
movq 0x30(%rbx), %rax
jmp 0xc2df9
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2b7a
notq %r15
addq %rax, %r15
movq %r15, %rax
jmp 0xc2df9
movl $0x1, %esi
movq %rbx, %rdi
callq 0xc2b7a
decq %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2b6d9
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xd3f64
testq %rax, %rax
je 0xc302c
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xd4c6c
movl $0xe, %ecx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
callq 0xd4c87
xorl %eax, %eax
jmp 0xc3031
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc30ca
movq %rdi, %rbx
movzbl %sil, %r14d
movq 0x220(%rdi), %rdi
callq 0xb96b7
cmpl %r14d, %eax
jbe 0xc30ca
movq 0xf8(%rbx), %rcx
movq (%rcx,%r14,8), %rax
cmpb $0x1, 0x3a8(%rbx)
jne 0xc30c2
movl $0x3, %edx
subl %r14d, %edx
movslq %edx, %rdx
addq (%rcx,%rdx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2b7bd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seppos2ssptab
int gt_encseq_seppos2ssptab(const char *indexname,
                            GtUword totallength,
                            GtUword numofdbsequences,
                            const GtUword *seppostab,
                            GtError *err)
{
  GtSWtable ssptab;
  Gtssptaboutinfo *ssptaboutinfo;
  GtUword idx;
  const GtUword *sepposptr;
  Gtssptransferinfo ssptransferinfo;
  GtEncseqAccessType satsep;
  int ret;

  gt_assert (numofdbsequences > 1UL);
  satsep = determineoptimalsssptablerep(totallength, numofdbsequences-1);
  initSWtable(&ssptab, totallength, satsep, numofdbsequences-1);
  setencsequtablesNULL(satsep, &ssptab);
  ssptaboutinfo = ssptaboutinfo_new(totallength, numofdbsequences, &ssptab);
  gt_assert(ssptaboutinfo != NULL && seppostab != NULL);
  for (idx=0, sepposptr = seppostab; idx < totallength; idx++) {
    if (idx == *sepposptr) {
      ssptaboutinfo_processseppos(ssptaboutinfo, idx);
      if (sepposptr < seppostab + numofdbsequences - 2)
        sepposptr++;
    }
    ssptaboutinfo_processanyposition(ssptaboutinfo, idx);
  }
  ssptaboutinfo_finalize(ssptaboutinfo);
  ssptaboutinfo_delete(ssptaboutinfo);
  ssptransferinfo.totallength = totallength;
  ssptransferinfo.numofdbsequences = numofdbsequences;
  ssptransferinfo.satsep = satsep;
  ssptransferinfo.ssptabptr = &ssptab;

  ret = flushssptab2file(indexname, &ssptransferinfo, err);
  gt_ssptab_delete(satsep, &ssptab);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpq $0x1, %rdx
jbe 0xc3232
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq %r8, 0x18(%rsp)
leaq -0x1(%rdx), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0xc323c
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl %eax, 0xc(%rsp)
movl %eax, %edx
movq %r14, %rcx
callq 0xc32be
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xc32f3
testq %rbx, %rbx
je 0xc3237
movq %rax, %r14
testq %rax, %rax
je 0xc3237
testq %r12, %r12
je 0xc31cc
leaq (%rbx,%r15,8), %rbp
addq $-0x10, %rbp
xorl %r13d, %r13d
cmpq (%rbx), %r13
jne 0xc31a4
movq %r14, %rdi
movq %r13, %rsi
callq 0xc33e4
xorl %eax, %eax
cmpq %rbp, %rbx
setb %al
leaq (%rbx,%rax,8), %rbx
cmpq 0x10(%r14), %r13
jne 0xc31ba
movq %r14, %rdi
callq 0xce5a4
movq 0x18(%r14), %rax
addq %rax, 0x10(%r14)
incq %r13
cmpq %r13, %r12
jne 0xc3188
jmp 0xc31cc
movq %r14, %rdi
callq 0xce5a4
movq 0x20(%r14), %rax
cmpq 0x30(%r14), %rax
jb 0xc31c4
leaq 0x3f84d(%rip), %rsi     # 0x102a2a
movq %r14, %rdi
movl $0x72e, %edx            # imm = 0x72E
callq 0x362a0
leaq 0x58(%rsp), %rsi
movq %r12, (%rsi)
movq %r15, 0x8(%rsi)
movl 0xc(%rsp), %ebp
movl %ebp, 0x10(%rsi)
leaq 0x20(%rsp), %r14
movq %r14, 0x18(%rsi)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
callq 0xc346f
movl %eax, %ebx
movl %ebp, %edi
movq %r14, %rsi
callq 0xc1c40
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b868
callq 0x2b8a1
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0xc32b8
movabsq $-0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x8080808080808081
movq %rdi, %rax
mulq %rcx
shrq $0x7, %rdx
leaq (%rsi,%rdx,8), %rcx
addq $0x8, %rcx
movabsq $-0x7fff7fff7fff7fff, %rdx # imm = 0x8000800080008001
movq %rdi, %rax
mulq %rdx
leaq (%rsi,%rsi), %rax
shrq $0xf, %rdx
leaq (%rax,%rdx,8), %rax
addq $0x8, %rax
xorl %r8d, %r8d
cmpq %rcx, %rax
cmovbq %rax, %rcx
adcl $0x4, %r8d
shlq $0x2, %rsi
movabsq $-0x7fffffff7fffffff, %rdx # imm = 0x8000000080000001
movq %rdi, %rax
mulq %rdx
shrq $0x1f, %rdx
leaq (%rsi,%rdx,8), %rax
addq $0x8, %rax
cmpq %rcx, %rax
movl $0x6, %eax
cmovael %r8d, %eax
retq
pushq %rax
callq 0x2b8da
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xc342e
movl 0x8(%rdi), %eax
cmpl $0x6, %eax
je 0xc342f
cmpl $0x5, %eax
je 0xc3415
cmpl $0x4, %eax
jne 0xc3448
movq (%rdi), %rax
movq 0x28(%rdi), %rcx
andl 0x30(%rax), %esi
movq (%rax), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movb %sil, (%rax,%rcx)
retq
movq (%rdi), %rax
movq 0x28(%rdi), %rcx
andl 0x30(%rax), %esi
movq (%rax), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movw %si, (%rax,%rcx,2)
retq
movq (%rdi), %rax
movq 0x28(%rdi), %rcx
andl 0x30(%rax), %esi
movq (%rax), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movl %esi, (%rax,%rcx,4)
retq
pushq %rax
movl %eax, %edi
callq 0x2b936
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xc3495
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xc351e
leaq 0x3e64d(%rip), %rsi     # 0x101ae9
leaq 0x3dd8f(%rip), %rdx     # 0x101232
leaq 0x3f580(%rip), %rcx     # 0x102a2a
movq %r15, %rdi
movl $0x3c0, %r8d            # imm = 0x3C0
movq %rbx, %r9
callq 0x73e9b
movq %rax, %r15
xorl %r12d, %r12d
testq %rax, %rax
sete %bpl
je 0xc3507
movl 0x10(%r14), %edi
movq (%r14), %rcx
movq 0x8(%r14), %r8
decq %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0xc3b39
leaq 0xb0eb(%rip), %rdi      # 0xce5d3
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0xd60e5
testl %eax, %eax
movb %bpl, %r12b
movl $0x1, %ebp
cmovel %r12d, %ebp
movq %r15, %rdi
callq 0x73f9e
movzbl %bpl, %eax
negl %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b959
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_description
const char* gt_encseq_description(const GtEncseq *encseq,
                                  GtUword *desclen,
                                  GtUword seqnum)
{
  GtUword destablen;

  gt_assert(encseq != NULL && encseq->destab != NULL);
  if (encseq->destab[encseq->destablength - 1] == '\n') {
    destablen = encseq->destablength;
  } else {
    /* XXX: hard-coded! final two ulongs are max desc length and
       terminator constant */
    destablen = encseq->destablength - (2 * sizeof (GtUword));
  }
  if (seqnum >= encseq->numofdbsequences) {
      seqnum = encseq->logicalnumofdbsequences - 1 - seqnum;
  }
  if (seqnum > 0) {
    GtUword nextend;
    gt_assert(seqnum < encseq->numofdbsequences);
    if (seqnum < encseq->numofdbsequences - 1)
      nextend = encseq->sdstab[seqnum];
    else
      nextend = destablen - 1;
    gt_assert(encseq->sdstab[seqnum-1] < nextend);
    *desclen = nextend - encseq->sdstab[seqnum-1] - 1;
    return encseq->destab + encseq->sdstab[seqnum-1] + 1;
  }
  gt_assert(seqnum == 0);
  if (encseq->numofdbsequences > 1UL) {
    gt_assert(encseq->sdstab != NULL);
    *desclen = encseq->sdstab[0];
  }
  else {
    *desclen = destablen - 1;
  }
  return encseq->destab;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xc35ca
movq 0x200(%rdi), %rax
testq %rax, %rax
je 0xc35ca
movq 0x40(%rdi), %r8
movq 0x210(%rdi), %r9
cmpb $0xa, -0x1(%rax,%r9)
leaq -0x10(%r9), %rcx
cmoveq %r9, %rcx
cmpq %rdx, %r8
ja 0xc3562
notq %rdx
addq 0x48(%rdi), %rdx
testq %rdx, %rdx
je 0xc3581
cmpq %r8, %rdx
jae 0xc35cf
decq %r8
cmpq %r8, %rdx
jae 0xc3598
movq 0x218(%rdi), %rcx
movq (%rcx,%rdx,8), %rcx
jmp 0xc359b
cmpq $0x2, %r8
jb 0xc35c2
movq 0x218(%rdi), %rcx
testq %rcx, %rcx
je 0xc35d9
movq (%rcx), %rcx
jmp 0xc35c5
decq %rcx
movq 0x218(%rdi), %rdi
movq -0x8(%rdi,%rdx,8), %r8
cmpq %rcx, %r8
jae 0xc35d4
notq %r8
addq %r8, %rcx
movq %rcx, (%rsi)
movq -0x8(%rdi,%rdx,8), %rcx
addq %rcx, %rax
incq %rax
jmp 0xc35c8
decq %rcx
movq %rcx, (%rsi)
popq %rcx
retq
callq 0x2ba3d
callq 0x2b992
callq 0x2b9cb
callq 0x2ba04
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc3655
movq %rdi, %rbx
movq 0x200(%rdi), %rax
testq %rax, %rax
je 0xc3655
movq 0x210(%rbx), %rcx
cmpb $0xa, -0x1(%rax,%rcx)
jne 0xc363c
cmpq $0x0, 0x48(%rbx)
je 0xc3643
xorl %r14d, %r14d
movq %rsp, %r15
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc3523
movq (%rsp), %rax
cmpq %r14, %rax
cmovaq %rax, %r14
incq %r12
cmpq 0x48(%rbx), %r12
jb 0xc3618
jmp 0xc3646
movq -0x10(%rax,%rcx), %r14
jmp 0xc3646
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2ba76
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_check_descriptions
void gt_encseq_check_descriptions(const GtEncseq *encseq)
{
  GtUword desclen, seqnum, totaldesclength, offset = 0;
  const char *desptr;
  char *copydestab;

  gt_assert(encseq != NULL);
  totaldesclength = encseq->numofdbsequences; /* for each new line */
  for (seqnum = 0; seqnum < encseq->numofdbsequences; seqnum++) {
    (void) gt_encseq_description(encseq, &desclen, seqnum);
    totaldesclength += desclen;
  }
  copydestab = gt_malloc(sizeof (*copydestab) * totaldesclength);
  for (seqnum = 0; seqnum < encseq->numofdbsequences; seqnum++) {
    desptr = gt_encseq_description(encseq, &desclen, seqnum);
    strncpy(copydestab + offset, desptr, (size_t) desclen);
    copydestab[offset+desclen] = '\n';
    offset += (desclen+1);
  }
  gt_assert(encseq->destab != NULL);
  if (strncmp(copydestab, encseq->destab, (size_t) totaldesclength) != 0) {
    fprintf(stderr, "different descriptions\n");
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_free(copydestab);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xc3764
movq %rdi, %r14
movq 0x40(%rdi), %rbx
testq %rbx, %rbx
je 0xc36b4
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc3523
addq 0x8(%rsp), %rbx
incq %r15
cmpq 0x40(%r14), %r15
jb 0xc3698
leaq 0x3f36f(%rip), %rsi     # 0x102a2a
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movl $0x1327, %edx           # imm = 0x1327
callq 0x35ee2
movq %rax, %r13
cmpq $0x0, 0x40(%r14)
je 0xc3725
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0xc3523
leaq (%r15,%r13), %rbp
movq %r14, %rbx
movq %r13, %r14
movq 0x8(%rsp), %r13
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0xb2d0
movb $0xa, (%r13,%rbp)
addq %r13, %r15
incq %r15
movq %r14, %r13
movq %rbx, %r14
incq %r12
cmpq 0x40(%rbx), %r12
jb 0xc36dd
movq 0x200(%r14), %rsi
testq %rsi, %rsi
je 0xc3769
movq %r13, %rdi
movq 0x10(%rsp), %rdx
callq 0xb2a0
testl %eax, %eax
jne 0xc376e
leaq 0x3f2e1(%rip), %rsi     # 0x102a2a
movq %r13, %rdi
movl $0x1333, %edx           # imm = 0x1333
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x362a0
callq 0x2bb46
callq 0x2bb0d
callq 0x2bae8
// File: /workspace/github_c_makefile_star2_O1/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:
movb $0x1, %al
cmpl $0x2, (%rdi)
je 0xc38e8
cmpb $0x0, 0x2a(%rdi)
jne 0xc38e8
movb 0x3a9(%rdi), %al
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_has_description_support
bool gt_encseq_has_description_support(const GtEncseq *encseq)
{
  bool ret = (encseq->destab != NULL
                && (encseq->numofdbsequences == 1UL
                      || encseq->sdstab != NULL));
  return ret;
}

// Assembly:
cmpq $0x0, 0x200(%rdi)
je 0xc3908
movb $0x1, %al
cmpq $0x1, 0x40(%rdi)
je 0xc3907
cmpq $0x0, 0x218(%rdi)
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_specialranges
GtUword gt_encseq_specialranges(const GtEncseq *encseq)
{
  gt_assert(encseq != NULL);
  if (encseq->hasmirror) {
    /* check whether central specialranges can be merged */
    if (gt_encseq_get_encoded_char(encseq, encseq->totallength-1,
                               GT_READMODE_FORWARD) == (GtUchar) GT_WILDCARD) {
      return (encseq->specialcharinfo.specialranges*2)-1;
    } else {
      return (encseq->specialcharinfo.specialranges*2)+1;
    }
  }
  return encseq->specialcharinfo.specialranges;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xc396b
movq %rdi, %rbx
cmpb $0x1, 0x3a8(%rdi)
jne 0xc395c
movq 0x30(%rbx), %rsi
decq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbef7c
movl %eax, %ecx
movq 0x180(%rbx), %rax
addq %rax, %rax
cmpb $-0x2, %cl
jne 0xc3965
decq %rax
jmp 0xc3969
movq 0x180(%rbx), %rax
jmp 0xc3969
orq $0x1, %rax
popq %rbx
retq
callq 0x2bbf1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_realspecialranges
GtUword gt_encseq_realspecialranges(const GtEncseq *encseq)
{
  if (encseq->hasmirror) {
    /* check whether central specialranges can be merged */
    if (gt_encseq_get_encoded_char(encseq, encseq->totallength-1,
                               GT_READMODE_FORWARD) == (GtUchar) GT_WILDCARD) {
      return (encseq->specialcharinfo.realspecialranges*2)-1;
    } else {
      return (encseq->specialcharinfo.realspecialranges*2)+1;
    }
  }
  return encseq->specialcharinfo.realspecialranges;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x3a8(%rdi)
jne 0xc39ef
movq 0x30(%rbx), %rsi
decq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbef7c
movl %eax, %ecx
movq 0x188(%rbx), %rax
addq %rax, %rax
cmpb $-0x2, %cl
jne 0xc39f8
decq %rax
jmp 0xc39fc
movq 0x188(%rbx), %rax
jmp 0xc39fc
orq $0x1, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_sizeofSWtable
static uint64_t gt_encseq_sizeofSWtable(GtEncseqAccessType sat,
                                        bool withrangelength,
                                        bool withmappositions,
                                        GtUword totallength,
                                        GtUword items)
{
  if (items == 0)
    return 0;
  switch (sat) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      return SIZEOFSWTABLE(GtUchar, UCHAR_MAX);
    case GT_ACCESS_TYPE_USHORTTABLES:
      return SIZEOFSWTABLE(uint16_t, USHRT_MAX);
    case GT_ACCESS_TYPE_UINT32TABLES:
      return SIZEOFSWTABLE(uint32_t, UINT32_MAX);
    default:
      fprintf(stderr, "gt_encseq_sizeofSWtable(sat=%d) is undefined\n",
              (int) sat);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
testq %r8, %r8
je 0xc3b6e
movq %rcx, %rax
movl %edx, %r9d
cmpl $0x6, %edi
je 0xc3b8d
cmpl $0x5, %edi
je 0xc3b71
cmpl $0x4, %edi
jne 0xc3bc4
movq %r8, %rdi
movl %esi, %ecx
shlq %cl, %rdi
movabsq $-0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x8080808080808081
mulq %rcx
shrq $0x7, %rdx
jmp 0xc3bab
xorl %eax, %eax
retq
leaq (%r8,%r8), %rdi
movl %esi, %ecx
shlq %cl, %rdi
movabsq $-0x7fff7fff7fff7fff, %rcx # imm = 0x8000800080008001
mulq %rcx
shrq $0xf, %rdx
jmp 0xc3bab
leaq (,%r8,4), %rdi
movl %esi, %ecx
shlq %cl, %rdi
movabsq $-0x7fffffff7fffffff, %rcx # imm = 0x8000000080000001
mulq %rcx
shrq $0x1f, %rdx
leaq (%rdi,%rdx,8), %rax
shlq $0x3, %r8
xorl %ecx, %ecx
testb %r9b, %r9b
cmovneq %r8, %rcx
addq %rcx, %rax
addq $0x8, %rax
retq
pushq %rax
callq 0x2bd31
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_GtSpecialcharinfo_check
void gt_GtSpecialcharinfo_check(const GtSpecialcharinfo *specialcharinfo,
                                GtUword numofseparatorpositions)
{
  gt_assert(specialcharinfo->wildcards + numofseparatorpositions ==
            specialcharinfo->specialcharacters);
  gt_assert(specialcharinfo->lengthofspecialprefix <=
            specialcharinfo->specialcharacters);
  gt_assert(specialcharinfo->lengthofwildcardprefix <=
            specialcharinfo->wildcards);
  gt_assert(specialcharinfo->lengthofwildcardprefix <=
            specialcharinfo->lengthofspecialprefix);
  gt_assert(specialcharinfo->lengthofwildcardsuffix <=
            specialcharinfo->lengthofspecialsuffix);
}

// Assembly:
pushq %rax
movq (%rdi), %rdx
movq 0x28(%rdi), %rax
addq %rax, %rsi
cmpq %rdx, %rsi
jne 0xc3bfd
movq 0x18(%rdi), %rcx
cmpq %rdx, %rcx
ja 0xc3c02
movq 0x40(%rdi), %rdx
cmpq %rax, %rdx
ja 0xc3c07
cmpq %rcx, %rdx
ja 0xc3c0c
movq 0x48(%rdi), %rax
cmpq 0x20(%rdi), %rax
ja 0xc3c11
popq %rax
retq
callq 0x2bd54
callq 0x2be38
callq 0x2bdff
callq 0x2bdc6
callq 0x2bd8d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_getnexttwobitencodingstoppos
GtUword gt_getnexttwobitencodingstoppos(GT_UNUSED bool fwd,
                                        GtEncseqReader *esr)
{
  GtUword rawstoppos;

  if (esr->currentpos == esr->encseq->totallength) {
    return esr->currentpos + (GT_ISDIRREVERSE(esr->originalreadmode) ? 1 : 0);
  }
  rawstoppos = (!GT_ISDIRREVERSE(esr->readmode)
                                      ? fwdgetnexttwobitencodingstoppos
                                      : revgetnexttwobitencodingstoppos) (esr);

  if (GT_ISDIRREVERSE(esr->readmode) != GT_ISDIRREVERSE(esr->originalreadmode))
    rawstoppos = GT_REVERSEPOS(esr->encseq->logicaltotallength, rawstoppos) + 1;

  return rawstoppos;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rcx
movq 0x10(%rsi), %rax
cmpq 0x30(%rcx), %rax
jne 0xc3c82
movl 0xc(%rbx), %ecx
andl $-0x3, %ecx
xorl %edx, %edx
cmpl $0x1, %ecx
sete %dl
addq %rdx, %rax
jmp 0xc3ccb
movl 0x8(%rbx), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
leaq 0xe4(%rip), %rax        # 0xc3d76
leaq 0x34(%rip), %rcx        # 0xc3ccd
cmoveq %rax, %rcx
movq %rbx, %rdi
callq *%rcx
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
andl $-0x3, %ecx
cmpl $0x1, %ecx
sete %cl
andl $-0x3, %edx
cmpl $0x1, %edx
setne %dl
xorb %cl, %dl
jne 0xc3ccb
movq (%rbx), %rcx
movq 0x38(%rcx), %rcx
subq %rax, %rcx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: fwdgetnexttwobitencodingstoppos
static GtUword fwdgetnexttwobitencodingstoppos(GtEncseqReader *esr)
{
  if (gt_encseq_has_specialranges(esr->encseq)) {
    if (esr->encseq->sat == GT_ACCESS_TYPE_EQUALLENGTH) {
      return fwdgetnexttwobitencodingstopposViaequallength(esr->encseq,
                                                           esr->currentpos);
    }
    else {
      GtUword stopposwildcard, stopposssptab;

      if (esr->encseq->has_wildcardranges) {
        stopposwildcard = fwdgetnexttwobitencodingstopposSW(esr,
                                                     SWtable_wildcardrange);
      }
      else {
        stopposwildcard = esr->encseq->totallength;
      }
      if (esr->encseq->numofdbsequences > 1UL) {
        stopposssptab = fwdgetnexttwobitencodingstopposSW(esr,
                                                          SWtable_ssptab);
      }
      else {
        stopposssptab = esr->encseq->totallength;
      }
      return GT_MIN(stopposwildcard, stopposssptab);
    }
  }
  else {
    return esr->encseq->totallength;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpb $0x1, 0x3a8(%r14)
jne 0xc3ce8
cmpb $0x1, 0x28(%r14)
jne 0xc3cef
cmpb $0x1, 0x28(%r14)
jne 0xc3d27
cmpl $0x2, (%r14)
jne 0xc3d30
movq 0x10(%rbx), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbf160
testb %al, %al
jne 0xc3d2b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc2a2f
movq 0x1f0(%r14), %rcx
leaq 0x1(%rcx), %rbx
imulq %rax, %rbx
addq %rcx, %rbx
jmp 0xc3d2b
movq 0x30(%r14), %rbx
movq %rbx, %rax
jmp 0xc3d6e
cmpb $0x1, 0x29(%r14)
jne 0xc3d46
movq %rbx, %rdi
xorl %esi, %esi
callq 0xce5ea
movq %rax, %r14
jmp 0xc3d4a
movq 0x30(%r14), %r14
movq (%rbx), %rax
cmpq $0x2, 0x40(%rax)
jb 0xc3d63
movq %rbx, %rdi
movl $0x1, %esi
callq 0xce5ea
jmp 0xc3d67
movq 0x30(%rax), %rax
cmpq %rax, %r14
cmovbq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: revgetnexttwobitencodingstoppos
static GtUword revgetnexttwobitencodingstoppos(GtEncseqReader *esr)
{
  if (gt_encseq_has_specialranges(esr->encseq)) {
    if (esr->encseq->sat == GT_ACCESS_TYPE_EQUALLENGTH) {
      return revgetnexttwobitencodingstopposViaequallength(esr->encseq,
                                                           esr->currentpos);
    }
    else {
      GtUword stopposwildcard, stopposssptab;

      if (esr->encseq->has_wildcardranges) {
        stopposwildcard = revgetnexttwobitencodingstopposSW(esr,
                                                        SWtable_wildcardrange);
      }
      else {
        stopposwildcard = 0;
      }
      if (esr->encseq->numofdbsequences > 1UL) {
        stopposssptab = revgetnexttwobitencodingstopposSW(esr,
                                                          SWtable_ssptab);
      }
      else {
        stopposssptab = 0;
      }
      return GT_MAX(stopposwildcard, stopposssptab);
    }
  }
  else {
    return 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpb $0x1, 0x3a8(%r14)
jne 0xc3d91
cmpb $0x1, 0x28(%r14)
jne 0xc3d98
cmpb $0x1, 0x28(%r14)
jne 0xc3db6
cmpl $0x2, (%r14)
jne 0xc3dba
movq 0x10(%rbx), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbf160
testb %al, %al
je 0xc3dd0
incq %rbx
jmp 0xc3de9
xorl %ebx, %ebx
jmp 0xc3de9
cmpb $0x1, 0x29(%r14)
jne 0xc3dee
movq %rbx, %rdi
xorl %esi, %esi
callq 0xce784
movq %rax, %r14
jmp 0xc3df1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc2a2f
movq 0x1f0(%r14), %rbx
incq %rbx
imulq %rax, %rbx
movq %rbx, %rax
jmp 0xc3e13
xorl %r14d, %r14d
movq (%rbx), %rax
cmpq $0x2, 0x40(%rax)
jb 0xc3e0a
movq %rbx, %rdi
movl $0x1, %esi
callq 0xce784
jmp 0xc3e0c
xorl %eax, %eax
cmpq %rax, %r14
cmovaq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_extract2bitencwithtwobitencodingstoppos
GtUword gt_encseq_extract2bitencwithtwobitencodingstoppos(
                                         GtEndofTwobitencoding *ptbe,
                                         GtEncseqReader *esr,
                                         const GtEncseq *encseq,
                                         GtReadmode readmode,
                                         GtUword pos)
{
  GtUword twobitencodingstoppos, ret;
  bool fwd;

  gt_assert(pos < encseq->logicaltotallength);
  fwd = GT_ISDIRREVERSE(readmode) ? false : true;
  gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, pos);
  if (gt_encseq_has_twobitencoding_stoppos_support(encseq)) {
    twobitencodingstoppos = gt_getnexttwobitencodingstoppos(fwd, esr);
  }
  else {
    twobitencodingstoppos = GT_TWOBITENCODINGSTOPPOSUNDEF(encseq);
  }
  if (GT_ISDIRREVERSE(readmode)) {
    pos = GT_REVERSEPOS(encseq->logicaltotallength, pos);
  }
  ret = gt_encseq_extract2bitenc(ptbe, encseq, fwd, pos, twobitencodingstoppos);

  /* XXX: may be less efficient, but just assigning ret to esr->currentpos may
     not reflect the real reading direction! */
  if (ret < encseq->logicaltotallength) {
    gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, ret);
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %r8, 0x38(%rdx)
jbe 0xc3ec8
movq %r8, %r12
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl %ecx, %ebp
andl $-0x3, %ebp
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movq %r8, %rcx
callq 0xc0212
movq %r14, %rdi
callq 0xc06bb
testb %al, %al
je 0xc3e6e
xorl %edi, %edi
movq %r15, %rsi
callq 0xc3c5e
movq %rax, %r8
jmp 0xc3e7b
movzbl 0x3a8(%r14), %eax
movq 0x30(%r14,%rax,8), %r8
cmpl $0x1, %ebp
jne 0xc3e87
notq %r12
addq 0x38(%r14), %r12
xorl %edx, %edx
cmpl $0x1, %ebp
setne %dl
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0xc3ecd
movq %rax, %r12
cmpq 0x38(%r14), %rax
jae 0xc3eb6
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0xc0212
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2bf1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_relpos_extract2bitencvector
unsigned int gt_encseq_relpos_extract2bitencvector(
                                          GtArrayGtTwobitencoding *tbereservoir,
                                          const GtEncseq *encseq,
                                          GtUword seqnum,
                                          GtUword relpos,
                                          GtUword maxnofelem)
{
  GtEndofTwobitencoding etbecurrent;
  GtUword pos, twobitencodingstoppos;
  unsigned int offset;

  if (seqnum < gt_encseq_num_of_sequences(encseq) - 1) {
    twobitencodingstoppos = gt_encseq_seqstartpos(encseq, seqnum + 1) - 1;
  }
  else {
    twobitencodingstoppos = gt_encseq_total_length(encseq);
  }
  pos = gt_encseq_seqstartpos(encseq, seqnum) + relpos;
  if (maxnofelem > 0) {
    GtUword maxpos = pos + maxnofelem;
    if (twobitencodingstoppos > maxpos)
      twobitencodingstoppos = maxpos;
  }
  for (offset = 0; /* Nothing */;
       offset += (unsigned int) GT_UNITSIN2BITENC) {
    if (pos == twobitencodingstoppos) {
      return offset;
    }
    (void) gt_encseq_extract2bitenc(&etbecurrent, encseq, true, pos,
                                    twobitencodingstoppos);
    GT_STOREINARRAY(tbereservoir, GtTwobitencoding, 32UL, etbecurrent.tbe);
    if (etbecurrent.unitsnotspecial < (unsigned int) GT_UNITSIN2BITENC) {
      gt_assert(etbecurrent.unitsnotspecial > 0);
      return offset + etbecurrent.unitsnotspecial;
    }
    pos += GT_UNITSIN2BITENC;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xbef6c
decq %rax
cmpq %r15, %rax
jbe 0xc41ec
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0xc2a64
movq %rax, %rbp
decq %rbp
jmp 0xc41f7
movq %rbx, %rdi
callq 0xbef5c
movq %rax, %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc2a64
movq %rax, %r15
addq %r12, %r15
leaq (%r15,%r13), %r12
cmpq %r12, %rbp
cmovbq %rbp, %r12
testq %r13, %r13
cmoveq %rbp, %r12
xorl %eax, %eax
cmpq %r12, %r15
je 0xc42ae
xorl %ebp, %ebp
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0xc3ecd
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
jb 0xc4271
leaq 0x20(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%r14), %rdi
leaq 0x100(,%rax,8), %rsi
leaq 0x3e7c6(%rip), %rdx     # 0x102a2a
movl $0x18e6, %ecx           # imm = 0x18E6
callq 0x36116
movq %rax, (%r14)
movq (%r14), %rax
testq %rax, %rax
je 0xc42bd
movq (%rsp), %rcx
movq 0x10(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10(%r14)
movq %rcx, (%rax,%rdx,8)
movl 0x8(%rsp), %eax
cmpl $0x1f, %eax
jbe 0xc42a8
addq $0x20, %r15
addl $-0x20, %ebp
cmpq %r15, %r12
jne 0xc422a
negl %ebp
movl %ebp, %eax
jmp 0xc42ae
testl %eax, %eax
je 0xc42c2
subl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2c039
callq 0x2c000
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: prefixofdifferenttwobitencodings
static int prefixofdifferenttwobitencodings(bool complement,
                                            GtCommonunits *commonunits,
                                            GtTwobitencoding tbe1,
                                            GtTwobitencoding tbe2)
{
  gt_assert((tbe1 ^ tbe2) > 0);
  commonunits->common = (unsigned int) GT_DIV2(GT_MULT2(GT_UNITSIN2BITENC) -
                                               requiredUIntBits(tbe1 ^ tbe2));
  gt_assert(commonunits->common < (unsigned int) GT_UNITSIN2BITENC);
  commonunits->leftspecial = commonunits->rightspecial = false;
  if (complement) {
    return GT_COMPLEMENTBASE(EXTRACTENCODEDCHARSCALARFROMLEFT(tbe1,
                                                   commonunits->common)) <
           GT_COMPLEMENTBASE(EXTRACTENCODEDCHARSCALARFROMLEFT(tbe2,
                                                   commonunits->common))
           ? -1 : 1;
  }
  return tbe1 < tbe2 ? -1 : 1;
}

// Assembly:
pushq %rax
cmpq %rcx, %rdx
je 0xc4414
movq %rcx, %rax
xorq %rdx, %rcx
movq %rcx, %r8
shrq %r8
orq %rcx, %r8
movq %r8, %rcx
shrq $0x2, %rcx
orq %r8, %rcx
movq %rcx, %r8
shrq $0x4, %r8
orq %rcx, %r8
movq %r8, %rcx
shrq $0x8, %rcx
orq %r8, %rcx
movq %rcx, %r9
shrq $0x10, %r9
orq %rcx, %r9
movq %r9, %rcx
shrq $0x21, %rcx
shrq %r9
orq %rcx, %r9
movabsq $0x26752b916fc7b0d, %rcx # imm = 0x26752B916FC7B0D
imulq %rcx, %r9
addq %rcx, %r9
shrq $0x3a, %r9
leaq 0x3e52a(%rip), %rcx     # 0x1028f0
movl $0x40, %r8d
subl (%rcx,%r9,4), %r8d
movl %r8d, %ecx
sarl %ecx
movl %ecx, (%rsi)
cmpl $0x20, %ecx
jae 0xc4419
movw $0x0, 0x4(%rsi)
testb %dil, %dil
je 0xc4404
andb $-0x2, %r8b
movb $0x3e, %cl
subb %r8b, %cl
shrq %cl, %rdx
notl %edx
andl $0x3, %edx
shrq %cl, %rax
notl %eax
andl $0x3, %eax
cmpl %eax, %edx
jmp 0xc4407
cmpq %rax, %rdx
setb %al
movzbl %al, %eax
negl %eax
orl $0x1, %eax
popq %rcx
retq
callq 0x2c0e4
callq 0x2c0ab
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: suffixofdifferenttwobitencodings
static int suffixofdifferenttwobitencodings(bool complement,
                                            GtCommonunits *commonunits,
                                            GtTwobitencoding tbe1,
                                            GtTwobitencoding tbe2)
{
  unsigned int tmplcsvalue = 0;

  gt_assert((tbe1 ^ tbe2) > 0);
  tmplcsvalue = GT_DIV2(numberoftrailingzeros(tbe1 ^ tbe2));
  gt_assert(tmplcsvalue < (unsigned int) GT_UNITSIN2BITENC);
  gt_assert(commonunits != NULL);
  commonunits->common = tmplcsvalue;
  commonunits->leftspecial = commonunits->rightspecial = false;
  if (complement) {
    return GT_COMPLEMENTBASE(EXTRACTENCODEDCHARSCALARFROMRIGHT(tbe1,
                                                               tmplcsvalue)) <
           GT_COMPLEMENTBASE(EXTRACTENCODEDCHARSCALARFROMRIGHT(tbe2,
                                                               tmplcsvalue))
           ? -1 : 1;
  }
  return EXTRACTENCODEDCHARSCALARFROMRIGHT(tbe1, tmplcsvalue) <
         EXTRACTENCODEDCHARSCALARFROMRIGHT(tbe2, tmplcsvalue)
         ? -1 : 1;
}

// Assembly:
pushq %rax
cmpq %rcx, %rdx
je 0xc44bd
movq %rcx, %rax
xorq %rdx, %rcx
testl %ecx, %ecx
je 0xc4452
movl %ecx, %r8d
negl %r8d
andl %ecx, %r8d
imull $0x77cb531, %r8d, %ecx  # imm = 0x77CB531
shrl $0x1b, %ecx
leaq 0x3e424(%rip), %r8      # 0x102870
movl (%r8,%rcx,4), %ecx
jmp 0xc4477
shrq $0x20, %rcx
movl %ecx, %r8d
negl %r8d
andl %ecx, %r8d
imull $0x77cb531, %r8d, %ecx  # imm = 0x77CB531
shrl $0x1b, %ecx
leaq 0x3e400(%rip), %r8      # 0x102870
movl (%r8,%rcx,4), %ecx
addl $0x20, %ecx
cmpl $0x40, %ecx
jae 0xc44c2
testq %rsi, %rsi
je 0xc44c7
movl %ecx, %r8d
shrl %r8d
andl $0x3e, %ecx
shrq %cl, %rdx
movl %r8d, (%rsi)
movw $0x0, 0x4(%rsi)
andl $0x3, %edx
testb %dil, %dil
je 0xc44a8
xorl $0x3, %edx
shrq %cl, %rax
notl %eax
jmp 0xc44ab
shrq %cl, %rax
andl $0x3, %eax
cmpl %eax, %edx
setb %al
movzbl %al, %eax
negl %eax
orl $0x1, %eax
popq %rcx
retq
callq 0x2c18f
callq 0x2c11d
callq 0x2c156