LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x30(%rdi), %rax
cmpq %rsi, %rax
setbe %bpl
andb 0x3a8(%rdi), %bpl
cmpb $0x1, %bpl
jne 0xc3a42
notq %rsi
addq 0x38(%rbx), %rsi
cmpq %rax, %rsi
jae 0xc3a7c
cmpl $0x2, (%rbx)
jne 0xc3a56
movq %rbx, %rdi
callq 0xc3a81
jmp 0xc3a69
cmpq $0x1, 0x40(%rbx)
jne 0xc3a61
xorl %eax, %eax
jmp 0xc3a69
movq %rbx, %rdi
callq 0xc38bf
testb %bpl, %bpl
je 0xc3a75
notq %rax
addq 0x48(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2b27a
// File: /workspace/github_c_makefile_star2_O3/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 0xc3ba9
movq %rdi, %rbx
movq 0x48(%rdi), %r14
cmpq %rsi, %r14
jbe 0xc3ba9
movq 0x40(%rbx), %rax
cmpq %rsi, %rax
setbe %bpl
andb 0x3a8(%rbx), %bpl
movq %rsi, %rcx
notq %rcx
addq %rcx, %r14
testb %bpl, %bpl
cmoveq %rsi, %r14
cmpq %rax, %r14
jae 0xc3bae
cmpq $0x1, %rax
jne 0xc3b18
testb %bpl, %bpl
je 0xc3b53
movq 0x30(%rbx), %r15
incq %r15
jmp 0xc3b9b
cmpl $0x2, (%rbx)
jne 0xc3b58
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3d7f
testb %bpl, %bpl
je 0xc3b98
movq 0x40(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r14
je 0xc3b0c
incq %r14
cmpq %rax, %r14
jae 0xc3bb3
movq 0x30(%rbx), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3d7f
jmp 0xc3b8c
xorl %r15d, %r15d
jmp 0xc3b9b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3bbd
testb %bpl, %bpl
je 0xc3b98
movq 0x40(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r14
je 0xc3b0c
incq %r14
cmpq %rax, %r14
jae 0xc3bb8
movq 0x30(%rbx), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3bbd
addq %r15, %r15
subq %rax, %r15
addq $0x2, %r15
jmp 0xc3b9b
movq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b397
callq 0x2b2ec
callq 0x2b35e
callq 0x2b325
// File: /workspace/github_c_makefile_star2_O3/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 0xc3c81
cmpl $0x5, %eax
je 0xc3c5d
cmpl $0x4, %eax
jne 0xc3d78
testq %rsi, %rsi
je 0xc3ca8
decq %rsi
movq 0x250(%rdi), %rax
movq 0x260(%rdi), %rcx
leaq (%rax,%rcx,8), %rdx
addq $-0x8, %rdx
xorl %ecx, %ecx
cmpq %rax, %rdx
jb 0xc3c35
movq %rax, %r8
movq %rdx, %r9
subq %r8, %r9
sarq %r9
andq $-0x8, %r9
cmpq %rsi, (%r8,%r9)
ja 0xc3c28
leaq (%r8,%r9), %rcx
addq %r9, %r8
addq $0x8, %r8
jmp 0xc3c30
leaq (%r8,%r9), %rdx
addq $-0x8, %rdx
cmpq %rdx, %r8
jbe 0xc3c08
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 0xc3d09
testq %rsi, %rsi
je 0xc3ca8
movq 0x250(%rdi), %rax
movq 0x260(%rdi), %rcx
leaq (%rax,%rcx,8), %rdx
addq $-0x8, %rdx
cmpq %rax, %rdx
jae 0xc3caf
xorl %ecx, %ecx
jmp 0xc3ce5
testq %rsi, %rsi
je 0xc3ca8
movq 0x250(%rdi), %rax
movq 0x260(%rdi), %rcx
leaq (%rax,%rcx,8), %rdx
addq $-0x8, %rdx
cmpq %rax, %rdx
jae 0xc3d11
xorl %ecx, %ecx
jmp 0xc3d47
xorl %eax, %eax
jmp 0xc3d76
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 0xc3cd8
leaq (%r9,%r10), %rcx
addq %r10, %r9
addq $0x8, %r9
jmp 0xc3ce0
leaq (%r9,%r10), %rdx
addq $-0x8, %rdx
cmpq %rdx, %r9
jbe 0xc3cb8
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 0xc3d76
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 0xc3d3a
leaq (%r9,%r10), %rcx
addq %r10, %r9
addq $0x8, %r9
jmp 0xc3d42
leaq (%r9,%r10), %rdx
addq $-0x8, %rdx
cmpq %rdx, %r9
jbe 0xc3d1a
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 0x2b3d0
// File: /workspace/github_c_makefile_star2_O3/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 0xc3e42
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq %rsi, %rax
jbe 0xc3e42
cmpb $0x1, 0x3a8(%rbx)
jne 0xc3dd0
cmpq %r14, 0x40(%rbx)
ja 0xc3dd0
notq %r14
addq %rax, %r14
cmpl $0x2, (%rbx)
jne 0xc3dde
movq 0x1f0(%rbx), %rax
jmp 0xc3e3c
testq %r14, %r14
je 0xc3e06
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3ab6
movq %rax, %r15
movq 0x40(%rbx), %rax
decq %rax
cmpq %rax, %r14
jne 0xc3e13
movq 0x30(%rbx), %rax
subq %r15, %rax
jmp 0xc3e3c
cmpq $0x1, 0x40(%rbx)
jne 0xc3e2c
movq 0x30(%rbx), %rax
jmp 0xc3e3c
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3bbd
notq %r15
addq %rax, %r15
movq %r15, %rax
jmp 0xc3e3c
movl $0x1, %esi
movq %rbx, %rdi
callq 0xc3bbd
decq %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2b433
// File: /workspace/github_c_makefile_star2_O3/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 0xd4d0c
testq %rax, %rax
je 0xc406f
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xd53d4
movl $0xe, %ecx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
callq 0xd53ef
xorl %eax, %eax
jmp 0xc4074
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc410d
movq %rdi, %rbx
movzbl %sil, %r14d
movq 0x220(%rdi), %rdi
callq 0xba7a2
cmpl %r14d, %eax
jbe 0xc410d
movq 0xf8(%rbx), %rcx
movq (%rcx,%r14,8), %rax
cmpb $0x1, 0x3a8(%rbx)
jne 0xc4105
movl $0x3, %edx
subl %r14d, %edx
movslq %edx, %rdx
addq (%rcx,%rdx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2b517
// File: /workspace/github_c_makefile_star2_O3/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 0xc4275
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 0xc427f
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl %eax, 0xc(%rsp)
movl %eax, %edx
movq %r14, %rcx
callq 0xc4301
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xc4336
testq %rbx, %rbx
je 0xc427a
movq %rax, %r14
testq %rax, %rax
je 0xc427a
testq %r12, %r12
je 0xc420f
leaq (%rbx,%r15,8), %rbp
addq $-0x10, %rbp
xorl %r13d, %r13d
cmpq (%rbx), %r13
jne 0xc41e7
movq %r14, %rdi
movq %r13, %rsi
callq 0xc4427
xorl %eax, %eax
cmpq %rbp, %rbx
setb %al
leaq (%rbx,%rax,8), %rbx
cmpq 0x10(%r14), %r13
jne 0xc41fd
movq %r14, %rdi
callq 0xcf47b
movq 0x18(%r14), %rax
addq %rax, 0x10(%r14)
incq %r13
cmpq %r13, %r12
jne 0xc41cb
jmp 0xc420f
movq %r14, %rdi
callq 0xcf47b
movq 0x20(%r14), %rax
cmpq 0x30(%r14), %rax
jb 0xc4207
leaq 0x3e6fa(%rip), %rsi     # 0x10291a
movq %r14, %rdi
movl $0x72e, %edx            # imm = 0x72E
callq 0x35c27
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 0xc44b2
movl %eax, %ebx
movl %ebp, %edi
movq %r14, %rsi
callq 0xc2cf3
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b5c2
callq 0x2b5fb
// File: /workspace/github_c_makefile_star2_O3/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 0xc42fb
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 0x2b634
// File: /workspace/github_c_makefile_star2_O3/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 0xc4471
movl 0x8(%rdi), %eax
cmpl $0x6, %eax
je 0xc4472
cmpl $0x5, %eax
je 0xc4458
cmpl $0x4, %eax
jne 0xc448b
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 0x2b690
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xc44d7
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xc4561
leaq 0x3d57f(%rip), %rsi     # 0x101a5d
leaq 0x3ccc1(%rip), %rdx     # 0x1011a6
leaq 0x3e42e(%rip), %rcx     # 0x10291a
movq %r15, %rdi
movl $0x3c0, %r8d            # imm = 0x3C0
movq %rbx, %r9
callq 0x7442f
movq %rax, %r15
testq %rax, %rax
je 0xc4547
sete %bpl
movl 0x10(%r14), %edi
movq (%r14), %rcx
movq 0x8(%r14), %r8
decq %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0xc4b81
leaq 0xaf83(%rip), %rdi      # 0xcf4aa
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0xd67cb
testl %eax, %eax
setne %al
orb %bpl, %al
movzbl %al, %ebx
negl %ebx
jmp 0xc454c
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0x74532
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b6b3
// File: /workspace/github_c_makefile_star2_O3/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 0xc460d
movq 0x200(%rdi), %rax
testq %rax, %rax
je 0xc460d
movq 0x40(%rdi), %r8
movq 0x210(%rdi), %r9
cmpb $0xa, -0x1(%rax,%r9)
leaq -0x10(%r9), %rcx
cmoveq %r9, %rcx
cmpq %rdx, %r8
ja 0xc45a5
notq %rdx
addq 0x48(%rdi), %rdx
testq %rdx, %rdx
je 0xc45c4
cmpq %r8, %rdx
jae 0xc4612
decq %r8
cmpq %r8, %rdx
jae 0xc45db
movq 0x218(%rdi), %rdi
movq (%rdi,%rdx,8), %rcx
jmp 0xc45e5
cmpq $0x2, %r8
jb 0xc4605
movq 0x218(%rdi), %rcx
testq %rcx, %rcx
je 0xc461c
movq (%rcx), %rcx
jmp 0xc4608
decq %rcx
movq 0x218(%rdi), %rdi
movq -0x8(%rdi,%rdx,8), %r8
cmpq %rcx, %r8
jae 0xc4617
notq %r8
addq %r8, %rcx
movq %rcx, (%rsi)
movq -0x8(%rdi,%rdx,8), %rcx
addq %rcx, %rax
incq %rax
jmp 0xc460b
decq %rcx
movq %rcx, (%rsi)
popq %rcx
retq
callq 0x2b797
callq 0x2b6ec
callq 0x2b725
callq 0x2b75e
// File: /workspace/github_c_makefile_star2_O3/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 0xc4698
movq %rdi, %rbx
movq 0x200(%rdi), %rax
testq %rax, %rax
je 0xc4698
movq 0x210(%rbx), %rcx
cmpb $0xa, -0x1(%rax,%rcx)
jne 0xc467f
cmpq $0x0, 0x48(%rbx)
je 0xc4686
xorl %r14d, %r14d
movq %rsp, %r15
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc4566
movq (%rsp), %rax
cmpq %r14, %rax
cmovaq %rax, %r14
incq %r12
cmpq 0x48(%rbx), %r12
jb 0xc465b
jmp 0xc4689
movq -0x10(%rax,%rcx), %r14
jmp 0xc4689
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2b7d0
// File: /workspace/github_c_makefile_star2_O3/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 0xc47ab
movq %rdi, %r14
movq 0x40(%rdi), %rbx
testq %rbx, %rbx
je 0xc46f9
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc4566
addq 0x8(%rsp), %rbx
incq %r15
cmpq 0x40(%r14), %r15
jb 0xc46db
jmp 0xc46fb
xorl %ebx, %ebx
leaq 0x3e218(%rip), %rsi     # 0x10291a
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movl $0x1327, %edx           # imm = 0x1327
callq 0x35862
movq %rax, %r13
cmpq $0x0, 0x40(%r14)
je 0xc476c
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0xc4566
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 0xc4724
movq 0x200(%r14), %rsi
testq %rsi, %rsi
je 0xc47b0
movq %r13, %rdi
movq 0x10(%rsp), %rdx
callq 0xb2a0
testl %eax, %eax
jne 0xc47b5
leaq 0x3e18a(%rip), %rsi     # 0x10291a
movq %r13, %rdi
movl $0x1333, %edx           # imm = 0x1333
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x35c27
callq 0x2b8a0
callq 0x2b867
callq 0x2b842
// File: /workspace/github_c_makefile_star2_O3/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 0xc4930
cmpb $0x0, 0x2a(%rdi)
jne 0xc4930
movb 0x3a9(%rdi), %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc4950
movb $0x1, %al
cmpq $0x1, 0x40(%rdi)
je 0xc494f
cmpq $0x0, 0x218(%rdi)
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc49b3
movq %rdi, %rbx
cmpb $0x1, 0x3a8(%rdi)
jne 0xc49a4
movq 0x30(%rbx), %rsi
decq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbff84
movl %eax, %ecx
movq 0x180(%rbx), %rax
addq %rax, %rax
cmpb $-0x2, %cl
jne 0xc49ad
decq %rax
jmp 0xc49b1
movq 0x180(%rbx), %rax
jmp 0xc49b1
orq $0x1, %rax
popq %rbx
retq
callq 0x2b94b
// File: /workspace/github_c_makefile_star2_O3/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 0xc4a37
movq 0x30(%rbx), %rsi
decq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbff84
movl %eax, %ecx
movq 0x188(%rbx), %rax
addq %rax, %rax
cmpb $-0x2, %cl
jne 0xc4a40
decq %rax
jmp 0xc4a44
movq 0x188(%rbx), %rax
jmp 0xc4a44
orq $0x1, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc4bb6
movq %rcx, %rax
movl %edx, %r9d
cmpl $0x6, %edi
je 0xc4bd5
cmpl $0x5, %edi
je 0xc4bb9
cmpl $0x4, %edi
jne 0xc4c0c
movq %r8, %rdi
movl %esi, %ecx
shlq %cl, %rdi
movabsq $-0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x8080808080808081
mulq %rcx
shrq $0x7, %rdx
jmp 0xc4bf3
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 0xc4bf3
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 0x2ba8b
// File: /workspace/github_c_makefile_star2_O3/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 0x28(%rdi), %rax
addq %rax, %rsi
cmpq (%rdi), %rsi
jne 0xc4c42
movq 0x18(%rdi), %rcx
cmpq %rsi, %rcx
ja 0xc4c47
movq 0x40(%rdi), %rdx
cmpq %rax, %rdx
ja 0xc4c4c
cmpq %rcx, %rdx
ja 0xc4c51
movq 0x48(%rdi), %rax
cmpq 0x20(%rdi), %rax
ja 0xc4c56
popq %rax
retq
callq 0x2baae
callq 0x2bb92
callq 0x2bb59
callq 0x2bb20
callq 0x2bae7
// File: /workspace/github_c_makefile_star2_O3/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 0xc4cc7
movl 0xc(%rbx), %ecx
andl $-0x3, %ecx
xorl %edx, %edx
cmpl $0x1, %ecx
sete %dl
addq %rdx, %rax
jmp 0xc4d10
movl 0x8(%rbx), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
leaq 0xd8(%rip), %rax        # 0xc4daf
leaq 0x34(%rip), %rcx        # 0xc4d12
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 0xc4d10
movq (%rbx), %rcx
movq 0x38(%rcx), %rcx
subq %rax, %rcx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
cmpb $0x0, 0x3a8(%rbx)
jne 0xc4d35
testb $0x1, 0x28(%rbx)
jne 0xc4d35
movq 0x30(%rbx), %r14
movq %r14, %rax
jmp 0xc4da9
cmpl $0x2, (%rbx)
jne 0xc4d6c
movq 0x10(%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc0168
testb %al, %al
jne 0xc4d30
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3a81
movq 0x1f0(%rbx), %rcx
leaq 0x1(%rcx), %r14
imulq %rax, %r14
addq %rcx, %r14
jmp 0xc4d30
cmpb $0x1, 0x29(%rbx)
jne 0xc4d84
movq %r14, %rdi
xorl %esi, %esi
callq 0xcf4c1
movq %rax, %r15
movq (%r14), %rbx
jmp 0xc4d88
movq 0x30(%rbx), %r15
cmpq $0x2, 0x40(%rbx)
jb 0xc4d9e
movq %r14, %rdi
movl $0x1, %esi
callq 0xcf4c1
jmp 0xc4da2
movq 0x30(%rbx), %rax
cmpq %rax, %r15
cmovbq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
cmpb $0x0, 0x3a8(%rbx)
jne 0xc4dd1
testb $0x1, 0x28(%rbx)
jne 0xc4dd1
xorl %r14d, %r14d
movq %r14, %rax
jmp 0xc4e43
cmpl $0x2, (%rbx)
jne 0xc4dee
movq 0x10(%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc0168
testb %al, %al
je 0xc4e06
incq %r14
jmp 0xc4dcc
cmpb $0x1, 0x29(%rbx)
jne 0xc4e21
movq %r14, %rdi
xorl %esi, %esi
callq 0xcf638
movq %rax, %r15
movq (%r14), %rbx
jmp 0xc4e24
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3a81
movq 0x1f0(%rbx), %r14
incq %r14
imulq %rax, %r14
jmp 0xc4dcc
xorl %r15d, %r15d
cmpq $0x2, 0x40(%rbx)
jb 0xc4e3a
movq %r14, %rdi
movl $0x1, %esi
callq 0xcf638
jmp 0xc4e3c
xorl %eax, %eax
cmpq %rax, %r15
cmovaq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc4ef6
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 0xc12b5
movq %r14, %rdi
callq 0xc1740
testb %al, %al
je 0xc4e9c
xorl %edi, %edi
movq %r15, %rsi
callq 0xc4ca3
movq %rax, %r8
jmp 0xc4ea9
movzbl 0x3a8(%r14), %eax
movq 0x30(%r14,%rax,8), %r8
cmpl $0x1, %ebp
jne 0xc4eb5
notq %r12
addq 0x38(%r14), %r12
xorl %edx, %edx
cmpl $0x1, %ebp
setne %dl
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0xc4efb
movq %rax, %r12
cmpq 0x38(%r14), %rax
jae 0xc4ee4
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0xc12b5
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2bc76
// File: /workspace/github_c_makefile_star2_O3/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 0xbff74
decq %rax
cmpq %r15, %rax
jbe 0xc5230
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0xc3ab6
movq %rax, %rbp
decq %rbp
jmp 0xc523b
movq %rbx, %rdi
callq 0xbff64
movq %rax, %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc3ab6
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 0xc52f4
xorl %ebp, %ebp
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0xc4efb
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
jae 0xc5293
movq (%r14), %rax
jmp 0xc52ba
leaq 0x20(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%r14), %rdi
leaq 0x100(,%rax,8), %rsi
leaq 0x3d66d(%rip), %rdx     # 0x10291a
movl $0x18e6, %ecx           # imm = 0x18E6
callq 0x35a9d
movq %rax, (%r14)
testq %rax, %rax
je 0xc5303
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 0xc52ee
addq $0x20, %r15
addl $-0x20, %ebp
cmpq %r15, %r12
jne 0xc526e
negl %ebp
movl %ebp, %eax
jmp 0xc52f4
testl %eax, %eax
je 0xc5308
subl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2bd93
callq 0x2bd5a
// File: /workspace/github_c_makefile_star2_O3/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 0xc545a
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 0x3d3d4(%rip), %rcx     # 0x1027e0
movl $0x40, %r8d
subl (%rcx,%r9,4), %r8d
movl %r8d, %ecx
sarl %ecx
movl %ecx, (%rsi)
cmpl $0x20, %ecx
jae 0xc545f
movw $0x0, 0x4(%rsi)
testb %dil, %dil
je 0xc544a
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 0xc544d
cmpq %rax, %rdx
setb %al
movzbl %al, %eax
negl %eax
orl $0x1, %eax
popq %rcx
retq
callq 0x2be3e
callq 0x2be05
// File: /workspace/github_c_makefile_star2_O3/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 0xc54ce
movq %rcx, %rax
movq %rcx, %r8
xorq %rdx, %r8
testl %r8d, %r8d
je 0xc5482
bsfl %r8d, %ecx
cmovel %r8d, %ecx
jmp 0xc548d
shrq $0x20, %r8
bsfl %r8d, %ecx
orl $0x20, %ecx
testq %rsi, %rsi
je 0xc54d3
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 0xc54b9
xorl $0x3, %edx
shrq %cl, %rax
notl %eax
jmp 0xc54bc
shrq %cl, %rax
andl $0x3, %eax
cmpl %eax, %edx
setb %al
movzbl %al, %eax
negl %eax
orl $0x1, %eax
popq %rcx
retq
callq 0x2beb0
callq 0x2be77
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq.c
// Function: gt_Viatwobitkeyvalues_reinit_without_stoppos
static void gt_Viatwobitkeyvalues_reinit_without_stoppos(
                                         GtViatwobitkeyvalues *vtk,
                                         const GtEncseq *encseq,
                                         GtReadmode readmode,
                                         GtEncseqReader *esr,
                                         GtUword pos,
                                         GtUword depth,
                                         GtUword maxdepth)
{
  if (maxdepth == 0) {
    vtk->endpos = encseq->logicaltotallength;
  }
  else {
    gt_assert(depth < maxdepth);
    vtk->endpos = pos + maxdepth;
    if (vtk->endpos > encseq->logicaltotallength) {
      vtk->endpos = encseq->logicaltotallength;
    }
  }
  vtk->pos = pos + depth;
  /* to have a defined value: */
  vtk->twobitcurrentpos = encseq->logicaltotallength;
  /* to have a defined value: */
  vtk->twobitencodingstoppos = GT_TWOBITENCODINGSTOPPOSUNDEF(encseq);
  if (vtk->pos < vtk->endpos) {
    bool fwd = GT_ISDIRREVERSE(readmode) ? false : true;

    if (esr != NULL && gt_encseq_has_twobitencoding_stoppos_support(encseq)) {
      gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, vtk->pos);
      vtk->twobitencodingstoppos = gt_getnexttwobitencodingstoppos(fwd, esr);
    }
    vtk->twobitcurrentpos
      = fwd ? vtk->pos : GT_REVERSEPOS(encseq->logicaltotallength, vtk->pos);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xc5765
cmpq %rax, %r9
jae 0xc57e8
addq %r8, %rax
movq 0x38(%r14), %rcx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
movq %rax, 0x10(%rbx)
movq 0x38(%r14), %rcx
jmp 0xc5770
movq 0x38(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rax, %rcx
addq %r8, %r9
movq %r9, (%rbx)
movq %rcx, 0x8(%rbx)
movzbl 0x3a8(%r14), %ecx
movq 0x30(%r14,%rcx,8), %rcx
movq %rcx, 0x18(%rbx)
cmpq %rax, %r9
jae 0xc57df
movl %ebp, %r12d
andl $-0x3, %r12d
testq %r15, %r15
je 0xc57c6
movq %r14, %rdi
callq 0xc1740
testb %al, %al
je 0xc57c6
movq (%rbx), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xc12b5
xorl %edi, %edi
movq %r15, %rsi
callq 0xc4ca3
movq %rax, 0x18(%rbx)
cmpl $0x1, %r12d
jne 0xc57d8
movq (%rbx), %rax
notq %rax
addq 0x38(%r14), %rax
jmp 0xc57db
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2c006