LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x200(%rcx)
movb %al, -0xa(%rsp)
je 0x11c6f8
movq -0x8(%rsp), %rcx
movb $0x1, %al
cmpq $0x1, 0x40(%rcx)
movb %al, -0xb(%rsp)
je 0x11c6f0
movq -0x8(%rsp), %rax
cmpq $0x0, 0x218(%rax)
setne %al
movb %al, -0xb(%rsp)
movb -0xb(%rsp), %al
movb %al, -0xa(%rsp)
movb -0xa(%rsp), %al
andb $0x1, %al
movb %al, -0x9(%rsp)
movb -0x9(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x11c7a9
movq 0x97860(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x418e4(%rip), %rsi     # 0x15e066
leaq 0x6960b(%rip), %rdx     # 0x185d94
leaq 0x69c8e(%rip), %rcx     # 0x18641e
leaq 0x68ec7(%rip), %r8      # 0x18565e
movl $0x1371, %r9d           # imm = 0x1371
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11c7ab
movq 0x8(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x11c810
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
subq $0x1, %rsi
xorl %edx, %edx
callq 0x113f80
movzbl %al, %eax
cmpl $0xfe, %eax
jne 0x11c7f6
movq 0x8(%rsp), %rax
movq 0x180(%rax), %rax
shlq %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x11c821
movq 0x8(%rsp), %rax
movq 0x180(%rax), %rax
shlq %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x11c821
movq 0x8(%rsp), %rax
movq 0x180(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x11c9fe
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
subq $0x1, %rsi
xorl %edx, %edx
callq 0x113f80
movzbl %al, %eax
cmpl $0xfe, %eax
jne 0x11c9e4
movq 0x8(%rsp), %rax
movq 0x188(%rax), %rax
shlq %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x11ca0f
movq 0x8(%rsp), %rax
movq 0x188(%rax), %rax
shlq %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x11ca0f
movq 0x8(%rsp), %rax
movq 0x188(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
addq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
je 0x11d0ee
movq 0x96f1b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x40f9f(%rip), %rsi     # 0x15e066
leaq 0x6940f(%rip), %rdx     # 0x1864dd
leaq 0x69463(%rip), %rcx     # 0x186538
leaq 0x68582(%rip), %r8      # 0x18565e
movl $0x1498, %r9d           # imm = 0x1498
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11d0f0
jmp 0x11d0f2
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x11d13d
movq 0x96ecc(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x40f50(%rip), %rsi     # 0x15e066
leaq 0x69436(%rip), %rdx     # 0x186553
leaq 0x69414(%rip), %rcx     # 0x186538
leaq 0x68533(%rip), %r8      # 0x18565e
movl $0x149a, %r9d           # imm = 0x149A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11d13f
jmp 0x11d141
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x11d18d
movq 0x96e7c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x40f00(%rip), %rsi     # 0x15e066
leaq 0x69433(%rip), %rdx     # 0x1865a0
leaq 0x693c4(%rip), %rcx     # 0x186538
leaq 0x684e3(%rip), %r8      # 0x18565e
movl $0x149c, %r9d           # imm = 0x149C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11d18f
jmp 0x11d191
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x11d1dd
movq 0x96e2c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x40eb0(%rip), %rsi     # 0x15e066
leaq 0x69429(%rip), %rdx     # 0x1865e6
leaq 0x69374(%rip), %rcx     # 0x186538
leaq 0x68493(%rip), %r8      # 0x18565e
movl $0x149e, %r9d           # imm = 0x149E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11d1df
jmp 0x11d1e1
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x11d22d
movq 0x96ddc(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x40e60(%rip), %rsi     # 0x15e066
leaq 0x6942b(%rip), %rdx     # 0x186638
leaq 0x69324(%rip), %rcx     # 0x186538
leaq 0x68443(%rip), %r8      # 0x18565e
movl $0x14a0, %r9d           # imm = 0x14A0
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11d22f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
cmpq 0x30(%rcx), %rax
jne 0x11d3e0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movb $0x1, %al
cmpl $0x1, 0xc(%rcx)
movb %al, 0x17(%rsp)
je 0x11d3b8
movq 0x20(%rsp), %rax
cmpl $0x3, 0xc(%rax)
sete %al
movb %al, 0x17(%rsp)
movq 0x8(%rsp), %rax
movb 0x17(%rsp), %sil
xorl %ecx, %ecx
movl $0x1, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x11d4b0
movq 0x20(%rsp), %rcx
movb $0x1, %al
cmpl $0x1, 0x8(%rcx)
movb %al, 0x7(%rsp)
je 0x11d401
movq 0x20(%rsp), %rax
cmpl $0x3, 0x8(%rax)
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %dl
xorb $-0x1, %dl
leaq 0x1b1(%rip), %rax       # 0x11d5c0
leaq 0xaa(%rip), %rcx        # 0x11d4c0
testb $0x1, %dl
cmovneq %rcx, %rax
movq 0x20(%rsp), %rdi
callq *%rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movb $0x1, %al
cmpl $0x1, 0x8(%rcx)
movb %al, 0x6(%rsp)
je 0x11d44a
movq 0x20(%rsp), %rax
cmpl $0x3, 0x8(%rax)
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rcx
movb $0x1, %al
cmpl $0x1, 0xc(%rcx)
movb %al, 0x5(%rsp)
je 0x11d477
movq 0x20(%rsp), %rax
cmpl $0x3, 0xc(%rax)
sete %al
movb %al, 0x5(%rsp)
movl (%rsp), %eax
movb 0x5(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x11d4a6
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
subq $0x1, %rax
subq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x119540
testb $0x1, %al
jne 0x11d4df
jmp 0x11d59f
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x11d50c
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x131aa0
movq %rax, 0x20(%rsp)
jmp 0x11d5b0
movq 0x18(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x29(%rax)
je 0x11d52d
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x131b20
movq %rax, 0x10(%rsp)
jmp 0x11d53e
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x1, 0x40(%rax)
jbe 0x11d563
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x131b20
movq %rax, 0x8(%rsp)
jmp 0x11d574
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x11d58b
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x11d594
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x11d5b0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x119540
testb $0x1, %al
jne 0x11d5df
jmp 0x11d68f
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x11d60c
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x132010
movq %rax, 0x20(%rsp)
jmp 0x11d698
movq 0x18(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x29(%rax)
je 0x11d62d
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x132080
movq %rax, 0x10(%rsp)
jmp 0x11d636
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x1, 0x40(%rax)
jbe 0x11d65b
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x132080
movq %rax, 0x8(%rsp)
jmp 0x11d664
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x11d67b
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x11d684
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x11d698
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: requiredUIntBits
static inline int requiredUIntBits(GtBitsequence v)
{
  int r;
  static const int MultiplyDeBruijnBitPosition[64] = {
    1, 2, 3, 57, 4, 33, 58, 47, 30, 5, 21, 34, 8, 59, 12, 48,
    63, 31, 19, 6, 17, 22, 35, 24, 54, 9, 60, 37, 26, 13, 49, 40,
    64, 56, 32, 46, 29, 20, 7, 11, 62, 18, 16, 23, 53, 36, 25, 39,
    55, 45, 28, 10, 61, 15, 52, 38, 44, 27, 14, 51, 43, 50, 42, 41
  };
  v |= v >> 1; /* first round down to power of 2 */
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  v |= v >> 32;
  v = (v >> 1) + 1;
  r = MultiplyDeBruijnBitPosition[(v * (GtBitsequence) 0x26752B916FC7B0DULL)
                                  >> 58];
  return r;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x2, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x4, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x8, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x10, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movabsq $0x26752b916fc7b0d, %rcx # imm = 0x26752B916FC7B0D
imulq -0x8(%rsp), %rcx
shrq $0x3a, %rcx
leaq 0x672fe(%rip), %rax     # 0x185540
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x23(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
xorq 0x8(%rsp), %rax
cmpq $0x0, %rax
ja 0x11e324
movq 0x95ce5(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3fd69(%rip), %rsi     # 0x15e066
leaq 0x68488(%rip), %rdx     # 0x18678c
leaq 0x6b4f8(%rip), %rcx     # 0x189803
leaq 0x6734c(%rip), %r8      # 0x18565e
movl $0x18ff, %r9d           # imm = 0x18FF
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11e326
movq 0x10(%rsp), %rdi
xorq 0x8(%rsp), %rdi
callq 0x11e1a0
movl $0x40, %ecx
subl %eax, %ecx
sarl %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
cmpl $0x20, (%rax)
jb 0x11e387
movq 0x95c82(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3fd06(%rip), %rsi     # 0x15e066
leaq 0x6b4bd(%rip), %rdx     # 0x189824
leaq 0x6b495(%rip), %rcx     # 0x189803
leaq 0x672e9(%rip), %r8      # 0x18565e
movl $0x1902, %r9d           # imm = 0x1902
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11e389
movq 0x18(%rsp), %rax
movb $0x0, 0x5(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x4(%rax)
testb $0x1, 0x23(%rsp)
je 0x11e408
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, %edx
movl $0x1f, %ecx
subq %rdx, %rcx
shlq %rcx
shrq %cl, %rax
andq $0x3, %rax
movl $0x3, %edx
subq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, %esi
movl $0x1f, %ecx
subq %rsi, %rcx
shlq %rcx
shrq %cl, %rax
andq $0x3, %rax
movl $0x3, %esi
subq %rax, %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x11e426
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_Viatwobitkeyvalues_reinit
void gt_Viatwobitkeyvalues_reinit(GtViatwobitkeyvalues *vtk,
                                  const GtEncseq *encseq,
                                  GtReadmode readmode,
                                  GtEncseqReader *esr,
                                  GtUword pos,
                                  GtUword depth,
                                  GtUword maxdepth,
                                  GtUword stoppos)
{
  gt_Viatwobitkeyvalues_reinit_without_stoppos(vtk,
                                               encseq,
                                               readmode,
                                               esr,
                                               pos,
                                               depth,
                                               maxdepth);
  vtk->twobitencodingstoppos = stoppos;
}

// Assembly:
subq $0x38, %rsp
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x11ed70
movq 0x48(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_sequence_mapoffset
size_t gt_encseq_sequence_mapoffset(const GtEncseq *encseq)
{
  gt_assert(encseq != NULL && encseq->sat != GT_ACCESS_TYPE_UNDEFINED);
  if (gt_encseq_has_twobitencoding(encseq)) {
    return (size_t) ((unsigned char *) encseq->twobitencoding -
                     (unsigned char *) encseq->mappedptr);
  }
  else {
    if (encseq->sat == GT_ACCESS_TYPE_DIRECTACCESS) {
      return (size_t) ((unsigned char *) encseq->plainseq -
                       (unsigned char *) encseq->mappedptr);
    }
    else {
      return (size_t) ((unsigned char *) encseq->bitpackarray -
                       (unsigned char *) encseq->mappedptr);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11f4ab
movq 0x8(%rsp), %rax
cmpl $0x7, (%rax)
jne 0x11f4e3
movq 0x94b26(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3ebaa(%rip), %rsi     # 0x15e066
leaq 0x6673b(%rip), %rdx     # 0x185bfe
leaq 0x674bc(%rip), %rcx     # 0x186986
leaq 0x6618d(%rip), %r8      # 0x18565e
movl $0x1a31, %r9d           # imm = 0x1A31
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11f4e5
movq 0x8(%rsp), %rdi
callq 0x1168b0
testb $0x1, %al
jne 0x11f4f5
jmp 0x11f514
movq 0x8(%rsp), %rax
movq 0x280(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x11f55a
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x11f53d
movq 0x8(%rsp), %rax
movq 0x290(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x11f55a
movq 0x8(%rsp), %rax
movq 0x2a0(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_compare_viatwobitencoding
int gt_encseq_compare_viatwobitencoding(GtCommonunits *commonunits,
                                        const GtEncseq *encseq1,
                                        const GtEncseq *encseq2,
                                        GtReadmode readmode,
                                        GtEncseqReader *esr1,
                                        GtEncseqReader *esr2,
                                        GtUword pos1,
                                        GtUword pos2,
                                        GtUword depth,
                                        GtUword maxdepth)
{
  GtViatwobitkeyvalues vtk1, vtk2;

  gt_assert(pos1 != pos2);
  gt_Viatwobitkeyvalues_reinit_without_stoppos(&vtk1, encseq1, readmode, esr1,
                                               pos1, depth, maxdepth);
  gt_Viatwobitkeyvalues_reinit_without_stoppos(&vtk2, encseq2, readmode, esr2,
                                               pos2, depth, maxdepth);
  return gt_encseq_twobitencoding_strcmp(commonunits,
                                         encseq1,
                                         encseq2,
                                         readmode,
                                         depth,
                                         maxdepth,
                                         &vtk1,
                                         &vtk2);
}

// Assembly:
subq $0x88, %rsp
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq 0x90(%rsp), %rax
cmpq 0x98(%rsp), %rax
jne 0x11f661
movq 0x949a8(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3ea2c(%rip), %rsi     # 0x15e066
leaq 0x67381(%rip), %rdx     # 0x1869c2
leaq 0x67387(%rip), %rcx     # 0x1869cf
leaq 0x6600f(%rip), %r8      # 0x18565e
movl $0x1a56, %r9d           # imm = 0x1A56
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11f663
movq 0x78(%rsp), %rsi
movl 0x6c(%rsp), %edx
movq 0x60(%rsp), %rcx
movq 0x90(%rsp), %r8
movq 0xa0(%rsp), %r9
movq 0xa8(%rsp), %rax
leaq 0x38(%rsp), %rdi
movq %rax, (%rsp)
callq 0x11ed70
movq 0x70(%rsp), %rsi
movl 0x6c(%rsp), %edx
movq 0x58(%rsp), %rcx
movq 0x98(%rsp), %r8
movq 0xa0(%rsp), %r9
movq 0xa8(%rsp), %rax
leaq 0x18(%rsp), %rdi
movq %rax, (%rsp)
callq 0x11ed70
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movl 0x6c(%rsp), %ecx
movq 0xa0(%rsp), %r8
movq 0xa8(%rsp), %r9
leaq 0x38(%rsp), %r10
leaq 0x18(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x11efb0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: showbufchar
static void showbufchar(FILE *fp, bool complement, GtUchar cc)
{
  if (cc == (GtUchar) GT_WILDCARD) {
    fprintf(fp, "$");
  }
  else {
    if (cc == (GtUchar) GT_SEPARATOR) {
      fprintf(fp, "#");
    }
    else {
      if (complement) {
        cc = GT_COMPLEMENTBASE(cc);
      }
      gt_assert(cc < (GtUchar) 4);
      fprintf(fp, "%c", "acgt"[cc]);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, 0x10(%rsp)
andb $0x1, %cl
movb %cl, 0xf(%rsp)
movb %al, 0xe(%rsp)
movzbl 0xe(%rsp), %eax
cmpl $0xfe, %eax
jne 0x11f97d
movq 0x10(%rsp), %rdi
leaq 0x3fa15(%rip), %rsi     # 0x15f386
movb $0x0, %al
callq 0xb890
jmp 0x11fa25
movzbl 0xe(%rsp), %eax
cmpl $0xff, %eax
jne 0x11f9a1
movq 0x10(%rsp), %rdi
leaq 0x44475(%rip), %rsi     # 0x163e0a
movb $0x0, %al
callq 0xb890
jmp 0x11fa23
testb $0x1, 0xf(%rsp)
je 0x11f9b8
movzbl 0xe(%rsp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, 0xe(%rsp)
jmp 0x11f9ba
movzbl 0xe(%rsp), %eax
cmpl $0x4, %eax
jl 0x11f9fc
movq 0x9460d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3e691(%rip), %rsi     # 0x15e066
leaq 0x69f0d(%rip), %rdx     # 0x1898e9
leaq 0x69f17(%rip), %rcx     # 0x1898fa
leaq 0x65c74(%rip), %r8      # 0x18565e
movl $0x1acc, %r9d           # imm = 0x1ACC
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11f9fe
movq 0x10(%rsp), %rdi
movzbl 0xe(%rsp), %eax
movl %eax, %ecx
leaq 0x64264(%rip), %rax     # 0x183c75
movsbl (%rax,%rcx), %edx
leaq 0x590ef(%rip), %rsi     # 0x178b0b
movb $0x0, %al
callq 0xb890
jmp 0x11fa25
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_showatstartposwithdepth
void gt_encseq_showatstartposwithdepth(FILE *fp,
                                       const GtEncseq *encseq,
                                       GtReadmode readmode,
                                       GtUword start,
                                       GtUword depth)
{
  GtUword idx, end, totallength;
  const GtUword maxshow = 30UL;
  GtUchar cc;
  const GtUchar *characters;

  totallength = encseq->logicaltotallength;
  characters = gt_alphabet_characters(gt_encseq_alphabet(encseq));
  if (depth == 0) {
    end = GT_MIN(start + maxshow, totallength);
  }
  else {
    end = GT_MIN(start + maxshow, GT_MIN(totallength, start+depth));
  }
  for (idx = start; idx <= end; idx++) {
    if (idx == totallength) {
      (void) putc('~', fp);
      break;
    }
    cc = gt_encseq_get_encoded_char(encseq, idx, readmode);
    if (GT_ISSPECIAL(cc)) {
      (void) putc('~', fp);
      break;
    }
    (void) putc((int) characters[(int) cc], fp);
  }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq $0x1e, 0x40(%rsp)
movq 0x78(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x78(%rsp), %rdi
callq 0x11b0e0
movq %rax, %rdi
callq 0x109e50
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x11fac1
movq 0x68(%rsp), %rax
addq $0x1e, %rax
cmpq 0x48(%rsp), %rax
jae 0x11faa8
movq 0x68(%rsp), %rax
addq $0x1e, %rax
movq %rax, 0x28(%rsp)
jmp 0x11fab2
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x11fb60
movq 0x68(%rsp), %rax
addq $0x1e, %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x68(%rsp), %rcx
addq 0x60(%rsp), %rcx
cmpq %rcx, %rax
jae 0x11faef
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x11fafe
movq 0x68(%rsp), %rax
addq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x11fb1d
movq 0x68(%rsp), %rax
addq $0x1e, %rax
movq %rax, 0x10(%rsp)
jmp 0x11fb56
movq 0x48(%rsp), %rax
movq 0x68(%rsp), %rcx
addq 0x60(%rsp), %rcx
cmpq %rcx, %rax
jae 0x11fb3d
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x11fb4c
movq 0x68(%rsp), %rax
addq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x50(%rsp), %rax
ja 0x11fc02
movq 0x58(%rsp), %rax
cmpq 0x48(%rsp), %rax
jne 0x11fb9a
movq 0x80(%rsp), %rsi
movl $0x7e, %edi
callq 0xbc50
jmp 0x11fc02
movq 0x78(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x74(%rsp), %edx
callq 0x113f80
movb %al, 0x3f(%rsp)
movzbl 0x3f(%rsp), %eax
cmpl $0xfe, %eax
jl 0x11fbd1
movq 0x80(%rsp), %rsi
movl $0x7e, %edi
callq 0xbc50
jmp 0x11fc02
movq 0x30(%rsp), %rax
movzbl 0x3f(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
movq 0x80(%rsp), %rsi
callq 0xbc50
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x11fb6a
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: showcharacterdistribution
static void showcharacterdistribution(const GtEncseq *encseq, GtLogger *logger)
{
  unsigned int numofchars, idx;

  numofchars = gt_alphabet_num_of_chars(encseq->alpha);
  gt_assert(encseq->headerptr.characterdistribution != NULL);
  for (idx=0; idx<numofchars; idx++) {
    gt_logger_log(logger, "occurrences(%c)=" GT_WU,
                         (int) gt_alphabet_pretty_symbol(encseq->alpha, idx),
                         gt_encseq_charcount(encseq, (GtUchar) idx));
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x220(%rax), %rdi
callq 0x109da0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x1200aa
movq 0x93f5f(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3dfe3(%rip), %rsi     # 0x15e066
leaq 0x66aac(%rip), %rdx     # 0x186b36
leaq 0x69875(%rip), %rcx     # 0x189906
leaq 0x655c6(%rip), %r8      # 0x18565e
movl $0x1ca8, %r9d           # imm = 0x1CA8
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1200ac
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x12011a
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x220(%rax), %rdi
movl 0x10(%rsp), %esi
callq 0x10a610
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %eax
movzbl %al, %esi
callq 0x11b140
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movq %rax, %rcx
leaq 0x6981a(%rip), %rsi     # 0x189920
movb $0x0, %al
callq 0xcec0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1200b4
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_relpos_seqnum_check
void gt_encseq_relpos_seqnum_check(const char *filename, int line,
                                   const GtEncseq *encseq, GtUword relpos,
                                   GtUword seqnum, GtUword position)
{
  if (encseq->sat == GT_ACCESS_TYPE_EQUALLENGTH) {
    GtUword seqnum2, relpos2;

    seqnum2 = gt_encseq_seqnum(encseq, position);
    relpos2 = position - gt_encseq_seqstartpos(encseq, seqnum2);
    if (seqnum != seqnum2) {
      fprintf(stderr,
              "file %s, line %d: pos="GT_WU", seqnum = "GT_WU" != "GT_WU" "
              " = seqnum.correct\n", filename, line, position, seqnum, seqnum2);
      exit(EXIT_FAILURE);
    }
    if (relpos != relpos2) {
      fprintf(stderr,
              "file %s, line %d: pos="GT_WU", relpos="GT_WU" != "GT_WU" "
              " = relpos.correct\n", filename, line, position,
              relpos, relpos2);
      exit(EXIT_FAILURE);
    }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x40(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x1205a2
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x11a580
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11a710
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x120556
movq 0x93ab9(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x50(%rsp), %rdx
movl 0x4c(%rsp), %ecx
movq 0x28(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x20(%rsp), %rax
leaq 0x66665(%rip), %rsi     # 0x186ba6
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb890
movl $0x1, %edi
callq 0xb780
movq 0x38(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x1205a0
movq 0x93a6f(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x50(%rsp), %rdx
movl 0x4c(%rsp), %ecx
movq 0x28(%rsp), %r8
movq 0x38(%rsp), %r9
movq 0x18(%rsp), %rax
leaq 0x6665d(%rip), %rsi     # 0x186be8
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb890
movl $0x1, %edi
callq 0xb780
jmp 0x1205a2
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_pairbitsum
uint64_t gt_encseq_pairbitsum(const GtEncseq *encseq)
{
  unsigned int idx, numofchars = gt_alphabet_num_of_chars(encseq->alpha);
  uint64_t pairbitsum = 0;

  for (idx = 0; idx < numofchars; idx++) {
    printf("idx=%u, add="GT_WU"\n", idx,
           encseq->headerptr.characterdistribution[idx]);
    pairbitsum += (uint64_t) encseq->headerptr.characterdistribution[idx] *
                  (uint64_t) idx;
  }
  if (encseq->sat == GT_ACCESS_TYPE_BITACCESS) {
    printf("numofseparators="GT_WU"\n", encseq->numofdbsequences - 1);
    pairbitsum += (uint64_t) (encseq->numofdbsequences - 1) *
                  (uint64_t) GT_TWOBITS_FOR_SEPARATOR;
  }
  else {
    printf("specials="GT_WU", leastprob=%u\n",
                gt_encseq_specialcharacters(encseq),
                encseq->leastprobablecharacter);
    pairbitsum += (uint64_t) gt_encseq_specialcharacters(encseq) *
                  (uint64_t) encseq->leastprobablecharacter;
  }
  return pairbitsum;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x220(%rax), %rdi
callq 0x109da0
movl %eax, 0x8(%rsp)
movq $0x0, (%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0x12063f
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
movq 0xf8(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
leaq 0x66621(%rip), %rdi     # 0x186c28
movb $0x0, %al
callq 0xb070
movq 0x10(%rsp), %rax
movq 0xf8(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0xc(%rsp), %ecx
imulq %rcx, %rax
addq (%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1205de
movq 0x10(%rsp), %rax
cmpl $0x3, (%rax)
jne 0x12067f
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
subq $0x1, %rsi
leaq 0x665dc(%rip), %rdi     # 0x186c39
movb $0x0, %al
callq 0xb070
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
subq $0x1, %rax
shlq $0x0, %rax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x1206c6
movq 0x10(%rsp), %rdi
callq 0x11c710
movq %rax, %rsi
movq 0x10(%rsp), %rax
movl 0x170(%rax), %edx
leaq 0x665b0(%rip), %rdi     # 0x186c4e
movb $0x0, %al
callq 0xb070
movq 0x10(%rsp), %rdi
callq 0x11c710
movq 0x10(%rsp), %rcx
movl 0x170(%rcx), %ecx
imulq %rcx, %rax
addq (%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_check_minmax
int gt_encseq_check_minmax(const GtEncseq *encseq, GtError *err)
{
  int had_err = 0;
  GtUword i,
                min,
                max;
  gt_assert(encseq);

  min = gt_encseq_min_seq_length(encseq);
  max = gt_encseq_max_seq_length(encseq);
  for (i = 0UL; !had_err && i < gt_encseq_num_of_sequences(encseq); i++) {
    if (min > gt_encseq_seqlength(encseq, i)) {
      gt_error_set(err, "sequence "GT_WU" has length "GT_WU", but "
                        "indexed minimum is " GT_WU, i,
                        gt_encseq_seqlength(encseq, i), min);
      had_err = -1;
    }
    if (!had_err && max < gt_encseq_seqlength(encseq, i)) {
      gt_error_set(err, "sequence "GT_WU" has length "GT_WU", but "
                        "indexed maximum is " GT_WU, i,
                        gt_encseq_seqlength(encseq, i), max);
      had_err = -1;
    }
  }
  return had_err;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x120726
movq 0x938e3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3d967(%rip), %rsi     # 0x15e066
leaq 0x5b5d0(%rip), %rdx     # 0x17bcd6
leaq 0x6655d(%rip), %rcx     # 0x186c6a
leaq 0x64f4a(%rip), %r8      # 0x18565e
movl $0x1f0f, %r9d           # imm = 0x1F0F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x120728
movq 0x70(%rsp), %rdi
callq 0x11b230
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0x11b290
movq %rax, 0x48(%rsp)
movq $0x0, 0x58(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x64(%rsp)
movb %al, 0x47(%rsp)
jne 0x120782
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rdi
callq 0x113f30
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x12078f
jmp 0x12088d
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x11abd0
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jbe 0x120800
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x11abd0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq %rax, %rcx
movq 0x50(%rsp), %r8
leaq 0x66490(%rip), %rsi     # 0x186c81
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x64(%rsp)
jne 0x120878
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x11abd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x120878
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x11abd0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movq 0x48(%rsp), %r8
leaq 0x66450(%rip), %rsi     # 0x186cb9
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x12087a
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x12074f
movl 0x64(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: testmulticharactercompare
static void testmulticharactercompare(const GtEncseq *encseq,
                                      GtReadmode readmode,
                                      GtUword multicharcmptrials)
{
  GtUword pos1, pos2, totallength;
  GtUword trial;

  totallength = encseq->logicaltotallength;
  (void) multicharactercompare_withtest(encseq, readmode, 0, 0);
  (void) multicharactercompare_withtest(encseq, readmode, 0, totallength-1);
  (void) multicharactercompare_withtest(encseq, readmode, totallength-1, 0);
  (void) multicharactercompare_withtest(encseq, readmode, totallength-1,
                                                        totallength-1);
  for (trial = 0; trial < multicharcmptrials; trial++) {
    pos1 = (GtUword) (random() % totallength);
    pos2 = (GtUword) (random() % totallength);
    (void) multicharactercompare_withtest(encseq, readmode, pos1, pos2);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x133510
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x133510
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x8(%rsp), %rdx
subq $0x1, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x133510
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x8(%rsp), %rdx
subq $0x1, %rdx
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
callq 0x133510
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x120eb8
callq 0x1cd80
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x8(%rsp)
movq %rdx, 0x18(%rsp)
callq 0x1cd80
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x133510
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x120e53
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: testscanatpos
static void testscanatpos(const GtEncseq *encseq,
                          GtReadmode readmode,
                          GtUword scantrials)
{
  GtEncseqReader *esr = NULL;
  GtUword startpos, totallength, trial;

  totallength = encseq->logicaltotallength;
  esr = gt_encseq_create_reader_with_readmode(encseq, readmode, 0);
  runscanatpostrial(encseq, esr, readmode, 0);
  runscanatpostrial(encseq, esr, readmode, totallength-1);
  for (trial = 0; trial < scantrials; trial++) {
    startpos = (GtUword) (random() % totallength);
    printf("trial "GT_WU" at "GT_WU"\n", trial, startpos);
    runscanatpostrial(encseq, esr, readmode, startpos);
  }
  gt_encseq_reader_delete(esr);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x116560
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x2c(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1340e0
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x2c(%rsp), %edx
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
callq 0x1340e0
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x1211fd
callq 0x1cd80
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x689fb(%rip), %rdi     # 0x189bcb
movb $0x0, %al
callq 0xb070
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x2c(%rsp), %edx
movq 0x10(%rsp), %rcx
callq 0x1340e0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x12119b
movq 0x18(%rsp), %rdi
callq 0x1165d0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: testseqnumextraction
static void testseqnumextraction(const GtEncseq *encseq)
{
  GtUchar cc;
  bool startofsequence = true;
  GtUword pos, totallength, currentseqnum = 0;

  totallength = encseq->logicaltotallength;
  for (pos=0; pos < totallength; pos++) {
    /* Random access */
    cc = gt_encseq_get_encoded_char(encseq, pos, GT_READMODE_FORWARD);
    if (cc == (GtUchar) GT_SEPARATOR) {
      currentseqnum++;
      startofsequence = true;
    }
    else {
      GtUword seqnum1;

      seqnum1 = gt_encseq_seqnum(encseq, pos);
      if (currentseqnum != seqnum1) {
        fprintf(stderr,
                "testseqnumextraction: pos="GT_WU": currentseqnum = "GT_WU" "
                "!= "GT_WU" = seqnum\n", pos, currentseqnum, seqnum1);
        exit(GT_EXIT_PROGRAMMING_ERROR);
      }
      if (startofsequence) {
        gt_assert(gt_encseq_seqstartpos(encseq, seqnum1) == pos);
        startofsequence = false;
      }
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movb $0x1, 0x2e(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x12134d
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x113f80
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %eax
cmpl $0xff, %eax
jne 0x121287
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movb $0x1, 0x2e(%rsp)
jmp 0x121338
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11a580
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x1212d8
movq 0x92d2a(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
leaq 0x689ab(%rip), %rsi     # 0x189c72
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
testb $0x1, 0x2e(%rsp)
je 0x121336
jmp 0x1212e1
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11a710
cmpq 0x20(%rsp), %rax
je 0x12132f
movq 0x92cda(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x3cd5e(%rip), %rsi     # 0x15e066
leaq 0x689a7(%rip), %rdx     # 0x189cb6
leaq 0x65a54(%rip), %rcx     # 0x186d6a
leaq 0x64341(%rip), %r8      # 0x18565e
movl $0x1e8d, %r9d           # imm = 0x1E8D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x121331
movb $0x0, 0x2e(%rsp)
jmp 0x121338
jmp 0x12133a
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x12123e
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_loader_new
GtEncseqLoader* gt_encseq_loader_new()
{
  GtEncseqLoader *el = gt_calloc((size_t) 1, sizeof (GtEncseqLoader));
  gt_encseq_loader_drop_multiseq_support(el);
  gt_encseq_loader_drop_lossless_support(el);
  gt_encseq_loader_drop_md5_support(el);
  gt_encseq_loader_drop_description_support(el);
  gt_encseq_loader_enable_autosupport(el);
  gt_encseq_loader_do_not_mirror(el);
  return el;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x10, %esi
leaq 0x63a2c(%rip), %rdx     # 0x18565e
movl $0x2181, %ecx           # imm = 0x2181
callq 0xd5b0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x124720
movq (%rsp), %rdi
callq 0x124730
movq (%rsp), %rdi
callq 0x124740
movq (%rsp), %rdi
callq 0x124750
movq (%rsp), %rdi
callq 0x124770
movq (%rsp), %rdi
callq 0x1247c0
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_check_specialranges
void gt_encseq_check_specialranges(const GtEncseq *encseq)
{
  GtArray *rangesforward, *rangesbackward;
  GtSpecialrangeiterator *sri;
  GtRange range;

  if (!gt_encseq_has_specialranges(encseq))
    return;
  rangesforward = gt_array_new(sizeof (GtRange));
  rangesbackward = gt_array_new(sizeof (GtRange));

  sri = gt_specialrangeiterator_new(encseq, true);
  while (gt_specialrangeiterator_next(sri, &range)) {
    gt_array_add(rangesforward, range);
  }
  gt_specialrangeiterator_delete(sri);
  sri = gt_specialrangeiterator_new(encseq, false);
  while (gt_specialrangeiterator_next(sri, &range)) {
    gt_array_add(rangesbackward, range);
  }
  gt_specialrangeiterator_delete(sri);
  gt_array_reverse(rangesbackward);
  if (!gt_array_equal(rangesforward, rangesbackward, compareGtRange))
    exit(GT_EXIT_PROGRAMMING_ERROR);
  gt_array_delete(rangesforward);
  gt_array_delete(rangesbackward);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x119540
testb $0x1, %al
jne 0x12207c
jmp 0x12216b
movl $0x10, %edi
callq 0x75ab0
movq %rax, 0x28(%rsp)
movl $0x10, %edi
callq 0x75ab0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x119830
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x119950
testb $0x1, %al
jne 0x1220c3
jmp 0x1220d9
movq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x76220
jmp 0x1220ae
movq 0x18(%rsp), %rdi
callq 0x119e60
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x119830
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x119950
testb $0x1, %al
jne 0x122109
jmp 0x12211f
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x76220
jmp 0x1220f4
movq 0x18(%rsp), %rdi
callq 0x119e60
movq 0x20(%rsp), %rdi
callq 0x76060
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x2c(%rip), %rdx        # 0x122170
callq 0x76960
testb $0x1, %al
jne 0x122157
movl $0x2, %edi
callq 0xb780
movq 0x28(%rsp), %rdi
callq 0x770a0
movq 0x20(%rsp), %rdi
callq 0x770a0
addq $0x38, %rsp
retq