LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: fwdextract2bitenc
static GtUword fwdextract2bitenc(GtEndofTwobitencoding *ptbe,
                                       const GtEncseq *encseq,
                                       GtUword currentpos,
                                       GtUword twobitencodingstoppos)
{
  gt_assert(encseq != NULL && currentpos < encseq->totallength);
  if (encseq->sat != GT_ACCESS_TYPE_BITACCESS) {
    if (currentpos < twobitencodingstoppos) {
      if (twobitencodingstoppos - currentpos >
          (GtUword) GT_UNITSIN2BITENC) {
        ptbe->unitsnotspecial = (unsigned int) GT_UNITSIN2BITENC;
      }
      else {
        ptbe->unitsnotspecial
          = (unsigned int) (twobitencodingstoppos - currentpos);
      }
      ptbe->tbe = calctbeforward(encseq->twobitencoding, currentpos);
    }
    else {
      ptbe->unitsnotspecial = 0;
      ptbe->tbe = 0;
    }
  }
  else {
    if (gt_encseq_has_specialranges(encseq)) {
      GtBitsequence spbits;

      spbits = fwdextractspecialbits(encseq->specialbits, currentpos);
      ptbe->unitsnotspecial
        = fwdbitaccessunitsnotspecial(spbits, encseq, currentpos);
    }
    else {
      ptbe->unitsnotspecial
        = fwdbitaccessunitsnotspecial0(encseq, currentpos);
    }
    if (ptbe->unitsnotspecial == 0)
      ptbe->tbe = 0;
    else
      ptbe->tbe = calctbeforward(encseq->twobitencoding, currentpos);
  }
  return currentpos + (GtUword) GT_UNITSIN2BITENC;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xb4b72
movq %rdx, %rbx
movq %rsi, %r15
cmpq %rdx, 0x30(%rsi)
jbe 0xb4b72
movq %rdi, %r14
cmpl $0x3, (%r15)
jne 0xb4b0f
cmpb $0x0, 0x3a8(%r15)
jne 0xb4b25
testb $0x1, 0x28(%r15)
jne 0xb4b25
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb4d5a
jmp 0xb4b42
subq %rbx, %rcx
jbe 0xb4b5b
cmpq $0x20, %rcx
pushq $0x20
popq %rax
cmovbq %rcx, %rax
movl %eax, 0x8(%r14)
jmp 0xb4b4a
movq 0x2b0(%r15), %rdi
movq %rbx, %rsi
callq 0xb4d0a
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb4d3e
movl %eax, 0x8(%r14)
testl %eax, %eax
je 0xb4b60
movq 0x280(%r15), %rdi
movq %rbx, %rsi
callq 0xb4ce4
jmp 0xb4b62
andl $0x0, 0x8(%r14)
xorl %eax, %eax
movq %rax, (%r14)
addq $0x20, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x7943f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x154e3(%rip), %rsi     # 0xca066
leaq 0x3afde(%rip), %rdx     # 0xefb68
leaq 0x3b00a(%rip), %rcx     # 0xefb9b
leaq 0x37002(%rip), %r8      # 0xebb9a
movl $0x175b, %r9d           # imm = 0x175B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: revextract2bitenc
static GtUword revextract2bitenc(GtEndofTwobitencoding *ptbe,
                                       const GtEncseq *encseq,
                                       GtUword currentpos,
                                       GtUword twobitencodingstoppos)
{
  gt_assert(encseq != NULL && currentpos < encseq->totallength);
  if (encseq->sat != GT_ACCESS_TYPE_BITACCESS) {
    if (currentpos >= twobitencodingstoppos) {
      if (currentpos - twobitencodingstoppos + 1 >
          (GtUword) GT_UNITSIN2BITENC) {
        ptbe->unitsnotspecial = (unsigned int) GT_UNITSIN2BITENC;
      }
      else {
        ptbe->unitsnotspecial
          = (unsigned int) (currentpos - twobitencodingstoppos + 1);
      }
      ptbe->tbe = calctbereverse(encseq->twobitencoding, currentpos);
    }
    else {
      ptbe->unitsnotspecial = 0;
      ptbe->tbe = 0;
    }
  }
  else {
    if (gt_encseq_has_specialranges(encseq)) {
      GtBitsequence spbits;

      spbits = revextractspecialbits(encseq->specialbits, currentpos);
      ptbe->unitsnotspecial = revbitaccessunitsnotspecial(spbits, currentpos);
    }
    else {
      ptbe->unitsnotspecial = revbitaccessunitsnotspecial0(currentpos);
    }
    if (ptbe->unitsnotspecial == 0) {
      ptbe->tbe = 0;
    }
    else {
      ptbe->tbe = calctbereverse(encseq->twobitencoding, currentpos);
    }
  }
  if (currentpos > (GtUword) GT_UNITSIN2BITENC) {
    return currentpos - (GtUword) GT_UNITSIN2BITENC;
  }
  else {
    return 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xb4c5e
movq %rdx, %rbx
movq %rsi, %r15
cmpq %rdx, 0x30(%rsi)
jbe 0xb4c5e
movq %rdi, %r14
cmpl $0x3, (%r15)
jne 0xb4bf5
cmpb $0x0, 0x3a8(%r15)
jne 0xb4c04
testb $0x1, 0x28(%r15)
jne 0xb4c04
cmpq $0x1f, %rbx
pushq $0x1f
popq %rax
cmovbq %rbx, %rax
incl %eax
movl %eax, 0x8(%r14)
jmp 0xb4c3c
movq %rbx, %rax
subq %rcx, %rax
jae 0xb4c2a
andl $0x0, 0x8(%r14)
jmp 0xb4c26
movq 0x2b0(%r15), %rdi
movq %rbx, %rsi
callq 0xb4ddf
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb4e17
movl %eax, 0x8(%r14)
testl %eax, %eax
jne 0xb4c3c
xorl %eax, %eax
jmp 0xb4c4b
incq %rax
cmpq $0x20, %rax
pushq $0x20
popq %rcx
cmovbq %rax, %rcx
movl %ecx, 0x8(%r14)
movq 0x280(%r15), %rdi
movq %rbx, %rsi
callq 0xb4da8
movq %rax, (%r14)
xorl %eax, %eax
subq $0x20, %rbx
cmovaeq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x79353(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x153f7(%rip), %rsi     # 0xca066
leaq 0x3aef2(%rip), %rdx     # 0xefb68
leaq 0x3af6c(%rip), %rcx     # 0xefbe9
leaq 0x36f16(%rip), %r8      # 0xebb9a
movl $0x17de, %r9d           # imm = 0x17DE
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/intbits.h
// Function: gt_intbits_reverse_unitwise
static inline GtBitsequence gt_intbits_reverse_unitwise(GtBitsequence bs)
{
#if defined (_LP64) || defined (_WIN64)
  /* 10 shifts, 10 &, 5 |, 4 assignments = 29 ops */
  bs = (bs & 0xFFFFFFFF00000000) >> 32 | (bs & 0x00000000FFFFFFFF) << 32;
  bs = (bs & 0xFFFF0000FFFF0000) >> 16 | (bs & 0x0000FFFF0000FFFF) << 16;
  bs = (bs & 0xFF00FF00FF00FF00) >> 8 |  (bs & 0x00FF00FF00FF00FF) << 8;
  bs = (bs & 0XF0F0F0F0F0F0F0F0) >> 4 |  (bs & 0x0F0F0F0F0F0F0F0F) << 4;
  return (bs & 0xCCCCCCCCCCCCCCCC) >> 2 |  (bs & 0x3333333333333333) << 2;
#else
  /* 8 shifts, 8 &, 4 |, 3 assignments = 23 ops */
  bs = (bs & 0xFFFF0000) >> 16 | (bs & 0x0000FFFF) << 16;
  bs = (bs & 0xFF00FF00) >> 8 |  (bs & 0x00FF00FF) << 8;
  bs = (bs & 0XF0F0F0F0) >> 4 |  (bs & 0x0F0F0F0F) << 4;
  return (bs & 0xCCCCCCCC) >> 2 |  (bs & 0x33333333) << 2;
#endif
}

// Assembly:
bswapq %rdi
movq %rdi, %rax
shrq $0x4, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rax, %rcx
shlq $0x4, %rdi
movabsq $-0xf0f0f0f0f0f0f10, %rax # imm = 0xF0F0F0F0F0F0F0F0
andq %rdi, %rax
orq %rcx, %rax
movabsq $-0xccccccccccccccd, %rcx # imm = 0xF333333333333333
andq %rax, %rcx
shrq $0x2, %rax
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
andq %rax, %rdx
leaq (%rdx,%rcx,4), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: calctbeforward
static inline GtTwobitencoding calctbeforward(const GtTwobitencoding *tbe,
                                              GtUword startpos)
{
  GtUword remain = GT_MODBYUNITSIN2BITENC(startpos);

  if (remain > 0) {
    GtUword unit = GT_DIVBYUNITSIN2BITENC(startpos);
    return (GtTwobitencoding)
           ((tbe[unit] << GT_MULT2(remain)) |
            (tbe[unit+1] >> GT_MULT2(GT_UNITSIN2BITENC - remain)));
  }
  return tbe[GT_DIVBYUNITSIN2BITENC(startpos)];
}

// Assembly:
movq %rsi, %rcx
andq $0x1f, %rcx
je 0xb4d01
shrq $0x5, %rsi
addl %ecx, %ecx
movq (%rdi,%rsi,8), %rax
movq 0x8(%rdi,%rsi,8), %rdx
shldq %cl, %rdx, %rax
retq
shrq $0x2, %rsi
movq (%rdi,%rsi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: fwdextractspecialbits
static inline GtBitsequence fwdextractspecialbits(
                                               const GtBitsequence *specialbits,
                                               GtUword startpos)
{
  GtUword remain, unit;

  remain = GT_MODWORDSIZE(startpos);
  unit = GT_DIVWORDSIZE(startpos);
  if (remain <= (GtUword) GT_DIV2(GT_INTWORDSIZE))
    return (GtBitsequence) ((specialbits[unit] << remain) & GT_FIRSTHALVEBITS);
  else {
    return (GtBitsequence) (((specialbits[unit] << remain) |
                           (specialbits[unit+1] >> (GT_INTWORDSIZE - remain))) &
                           GT_FIRSTHALVEBITS);
  }
}

// Assembly:
movl %esi, %ecx
andl $0x3f, %ecx
movq %rsi, %rax
shrq $0x6, %rax
movq (%rdi,%rax,8), %rdx
cmpq $0x20, %rcx
ja 0xb4d25
shlq %cl, %rdx
jmp 0xb4d30
movq 0x8(%rdi,%rax,8), %rax
movl %esi, %ecx
shldq %cl, %rax, %rdx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: calctbereverse
static inline GtTwobitencoding calctbereverse(const GtTwobitencoding *tbe,
                                              GtUword startpos)
{
  GtUword remain = GT_MODBYUNITSIN2BITENC(startpos);

  /* right end of word */
  if (remain < (GtUword) (GT_UNITSIN2BITENC - 1)) {
    GtUword unit = GT_DIVBYUNITSIN2BITENC(startpos);
    GtTwobitencoding tmp = (GtTwobitencoding)
                        (tbe[unit] >> GT_MULT2(GT_UNITSIN2BITENC - 1 - remain));
    if (unit > 0)
      tmp |= tbe[unit-1] << GT_MULT2(1 + remain);
    return tmp;
  }
  return tbe[GT_DIVBYUNITSIN2BITENC(startpos)];
}

// Assembly:
movl %esi, %edx
andl $0x1f, %edx
movq %rsi, %r8
shrq $0x5, %r8
movq (%rdi,%r8,8), %rax
cmpq $0x1f, %rdx
je 0xb4dde
addl %edx, %edx
movl %edx, %ecx
xorb $0x3e, %cl
shrq %cl, %rax
cmpq $0x20, %rsi
jb 0xb4dde
movq -0x8(%rdi,%r8,8), %rsi
addb $0x2, %dl
movl %edx, %ecx
shlq %cl, %rsi
orq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: revextractspecialbits
static inline GtBitsequence revextractspecialbits(
                                               const GtBitsequence *specialbits,
                                               GtUword startpos)
{
  int remain;
  GtUword unit;

  remain = (int) GT_MODWORDSIZE(startpos);
  unit = GT_DIVWORDSIZE(startpos);
  if (remain >= GT_DIV2(GT_INTWORDSIZE)) {
    return (GtBitsequence) ((specialbits[unit] >> (GT_INTWORDSIZE - 1 - remain))
                           & GT_LASTHALVEBITS);
  }
  else {
    GtBitsequence tmp = (specialbits[unit] >> (GT_INTWORDSIZE - 1 - remain)) &
                      GT_LASTHALVEBITS;
    if (unit > 0)
      tmp |= (specialbits[unit-1] << (1+remain)) & GT_LASTHALVEBITS;
    return tmp;
  }
}

// Assembly:
movl %esi, %edx
andl $0x3f, %edx
movq %rsi, %r8
shrq $0x6, %r8
movq (%rdi,%r8,8), %rax
movl %edx, %ecx
notb %cl
shrq %cl, %rax
cmpl $0x20, %edx
jb 0xb4dfe
movl %eax, %eax
retq
cmpq $0x40, %rsi
jb 0xb4e16
movq -0x8(%rdi,%r8,8), %rsi
incb %dl
movl %edx, %ecx
shlq %cl, %rsi
andl $-0x2, %esi
orq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/intbits.h
// Function: gt_bitsequence_tostring
static inline void gt_bitsequence_tostring(char *buffer,
                                                        GtBitsequence bs)
{
  unsigned int i;
  GtBitsequence mask;

  for (i=0, mask = (GtBitsequence) GT_FIRSTBIT;
       i < (unsigned int) GT_INTWORDSIZE;
       i++, mask >>= 1) {
    buffer[i] = (bs & mask) ? '1' : '0';
  }
  buffer[GT_INTWORDSIZE] = '\0';
}

// Assembly:
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorl %ecx, %ecx
cmpq $0x40, %rcx
je 0xb4e73
testq %rsi, %rax
sete %dl
xorb $0x31, %dl
movb %dl, (%rdi,%rcx)
incq %rcx
shrq %rax
jmp 0xb4e59
movb $0x0, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: derefcharboundaries
static GtUword derefcharboundaries(const GtEncseq *encseq,
                                         bool fwd,
                                         bool complement,
                                         GtUword start,
                                         GtUword maxoffset,
                                         GtUword currentoffset,
                                         GtUword totallength)
{
  if (fwd) {
    if (start + currentoffset == totallength) {
      return totallength + GT_COMPAREOFFSET;
    }
    start += currentoffset;
  }
  else {
    if (start < currentoffset) {
      return currentoffset - start + (GtUword) GT_COMPAREOFFSET;
    }
    start -= currentoffset;
  }
  if (currentoffset <= maxoffset) {
    GtUchar cc;
    cc = gt_encseq_get_encoded_char(encseq, start, GT_READMODE_FORWARD);
    if (GT_ISSPECIAL(cc)) {
      return start + GT_COMPAREOFFSET;
    }
    if (complement) {
      cc = GT_COMPLEMENTBASE(cc);
    }
    return (GtUword) cc;
  }
  return start + GT_COMPAREOFFSET;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
testl %esi, %esi
je 0xb52d5
movq 0x20(%rsp), %rax
addq %r9, %rcx
movq %rcx, %r14
cmpq %rax, %rcx
jne 0xb52ec
addq $0x100, %rax            # imm = 0x100
jmp 0xb5326
movq %rcx, %r14
subq %r9, %r14
jae 0xb52ec
subq %rcx, %r9
addq $0x100, %r9             # imm = 0x100
movq %r9, %rax
jmp 0xb5326
cmpq %r8, %r9
jbe 0xb52fd
addq $0x100, %r14            # imm = 0x100
movq %r14, %rax
jmp 0xb5326
movq %r14, %rsi
xorl %edx, %edx
callq 0xa1fd0
addq $0x100, %r14            # imm = 0x100
movb $0x3, %cl
subb %al, %cl
movzbl %al, %eax
movzbl %cl, %ecx
testb %bl, %bl
cmovel %eax, %ecx
cmpb $-0x2, %al
movzbl %cl, %eax
cmovaeq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: runscanatpostrial
static void runscanatpostrial(const GtEncseq *encseq,
                              GtEncseqReader *esr,
                              GtReadmode readmode, GtUword startpos)
{
  GtUword pos, totallength;
  GtUchar ccra, ccsr;

  totallength = encseq->logicaltotallength;
  gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, startpos);
  printf("runscanatpostrial with startpos "GT_WU"\n", startpos);
  for (pos=startpos; pos < totallength; pos++) {
    /* Random access */
    ccra = gt_encseq_get_encoded_char(encseq, pos, readmode);
    ccsr = gt_encseq_reader_next_encoded_char(esr);
    if (ccra != ccsr) {
      fprintf(stderr, "startpos = " GT_WU
                     " access=%s, mode=%s: position="GT_WU
                     ": random access (correct) = %u != %u = "
                     " sequential read (wrong)\n",
                     startpos,
                     gt_encseq_accessname(encseq),
                     gt_readmode_show(readmode),
                     pos,
                     (unsigned int) ccra,
                     (unsigned int) ccsr);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x38(%rdi), %rbx
movq %rsi, %rdi
movq %r14, %rsi
callq 0xa3924
leaq 0x3ac7f(%rip), %rdi     # 0xeffd9
movq %r15, %rsi
xorl %eax, %eax
callq 0xb070
movq %r15, (%rsp)
cmpq %rbx, %r15
jae 0xb538f
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xa1fd0
movl %eax, %r13d
movq %r12, %rdi
callq 0xa2941
cmpb %al, %r13b
jne 0xb539e
incq %r15
jmp 0xb5368
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %al, %ebx
movzbl %r13b, %r13d
movq 0x78c0c(%rip), %rax     # 0x12dfb8
movq (%rax), %r12
movq %r14, %rdi
callq 0xa3e1f
movq %rax, %r14
movl %ebp, %edi
callq 0xbf590
leaq 0x3ac36(%rip), %rsi     # 0xefffe
movq %r12, %rdi
movq (%rsp), %rdx
movq %r14, %rcx
movq %rax, %r8
movq %r15, %r9
xorl %eax, %eax
pushq %rbx
pushq %r13
callq 0xb8c0
popq %rcx
popq %rdx
pushq $0x2
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: makeerrormsg
static void makeerrormsg(const GtRange *vala,
                         const GtRange *valb,
                         const char *cmpflag)
{
  fprintf(stderr, "("GT_WU","GT_WU") %s ("GT_WU","GT_WU")\n",
                  vala->start,
                  vala->end,
                  cmpflag,
                  valb->start,
                  valb->end);
}

// Assembly:
pushq %rax
movq %rdx, %r8
movq 0x78bc1(%rip), %rax     # 0x12dfb8
movq (%rax), %rax
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq (%rsi), %r9
movq 0x8(%rsi), %rsi
movq %rsi, (%rsp)
leaq 0x3ad8b(%rip), %rsi     # 0xf019e
movq %rax, %rdi
xorl %eax, %eax
callq 0xb8c0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: calcswranges
static GtUword calcswranges(const char *kind,
                                  bool dolog,
                                  GtUword *rangestab,
                                  const GtDiscDistri *distrangelength,
                                  GtLogger *logger)
{
  Updatesumrangeinfo updatesumrangeinfo;

  updatesumrangeinfo.kind = kind;
  updatesumrangeinfo.ranges_uint8_t = 0;
  updatesumrangeinfo.ranges_uint16_t = 0;
  updatesumrangeinfo.ranges_uint32_t = 0;
  updatesumrangeinfo.realranges = 0;
  updatesumrangeinfo.logger = dolog ? logger : NULL;
  gt_disc_distri_foreach(distrangelength, updatesumranges, &updatesumrangeinfo);
  if (rangestab != NULL) {
    rangestab[0] = updatesumrangeinfo.ranges_uint8_t;
    rangestab[1] = updatesumrangeinfo.ranges_uint16_t;
    rangestab[2] = updatesumrangeinfo.ranges_uint32_t;
  }
  return updatesumrangeinfo.realranges;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsp, %rdx
movq %rdi, 0x28(%rdx)
xorl %eax, %eax
testl %esi, %esi
cmovneq %r8, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdx)
movups %xmm0, 0x18(%rdx)
movq %rax, (%rdx)
leaq 0x29(%rip), %rsi        # 0xb5474
movq %rcx, %rdi
callq 0xa15e0
testq %rbx, %rbx
je 0xb5469
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x20(%rsp), %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: updatesumranges
static void updatesumranges(GtUword key, GtUint64 value,
                            void *data)
{
  GtUword distvalue;
  Updatesumrangeinfo *updatesumrangeinfo = (Updatesumrangeinfo *) data;

  gt_assert(value <= (GtUint64) ULONG_MAX);
  distvalue = (GtUword) value;
  updatesumrangeinfo->ranges_uint8_t
     += currentspecialrangevalue(key, distvalue, (GtUword) UCHAR_MAX);
  updatesumrangeinfo->ranges_uint16_t
     += currentspecialrangevalue(key, distvalue, (GtUword) USHRT_MAX);
  updatesumrangeinfo->ranges_uint32_t
     += currentspecialrangevalue(key, distvalue, (GtUword) UINT32_MAX);
  updatesumrangeinfo->realranges += distvalue;
  gt_logger_log(updatesumrangeinfo->logger,
                "%sranges of length " GT_WU "=" GT_WU,
                updatesumrangeinfo->kind, key, distvalue);
}

// Assembly:
movq %rsi, %r8
movq %rdi, %rcx
movq %rsi, %rax
cmpq $0x101, %rdi            # imm = 0x101
jb 0xb5498
movq %rcx, %rax
shrq $0x8, %rax
testb %cl, %cl
je 0xb5494
incq %rax
imulq %r8, %rax
addq %rax, 0x8(%rdx)
movq %r8, %rax
cmpq $0x10001, %rcx          # imm = 0x10001
jb 0xb54bb
movq %rcx, %rax
shrq $0x10, %rax
testw %cx, %cx
je 0xb54b7
incq %rax
imulq %r8, %rax
addq %rax, 0x10(%rdx)
leaq -0x1(%rcx), %rax
shrq $0x20, %rax
jne 0xb54f6
movdqu 0x18(%rdx), %xmm0
movq %r8, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
paddq %xmm0, %xmm1
movdqu %xmm1, 0x18(%rdx)
movq (%rdx), %rdi
movq 0x28(%rdx), %rdx
leaq 0x3aed5(%rip), %rsi     # 0xf03c4
xorl %eax, %eax
jmp 0xc9c1
pushq %rax
movq 0x78aba(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x14b5e(%rip), %rsi     # 0xca066
leaq 0x3aed0(%rip), %rdx     # 0xf03df
leaq 0x3aedf(%rip), %rcx     # 0xf03f5
leaq 0x3667d(%rip), %r8      # 0xebb9a
movl $0x13d3, %r9d           # imm = 0x13D3
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: determineleastprobablecharacter
static unsigned int determineleastprobablecharacter(const GtAlphabet *alpha,
                                                    const GtUword
                                                    *characterdistribution)
{
  unsigned int idx, minidx;
  GtUword mindist;

  gt_assert(gt_alphabet_num_of_chars(alpha) > 0);
  mindist = characterdistribution[0];
  minidx = 0;
  for (idx=1U; idx<gt_alphabet_num_of_chars(alpha); idx++) {
    if (characterdistribution[idx] < mindist) {
      mindist = characterdistribution[idx];
      minidx = idx;
    }
  }
  return minidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9b59a
testl %eax, %eax
je 0xb557d
movq (%rbx), %r15
xorl %ebp, %ebp
pushq $0x1
popq %r12
movq %r14, %rdi
callq 0x9b59a
movl %eax, %eax
cmpq %rax, %r12
jae 0xb5572
movq (%rbx,%r12,8), %rax
cmpq %r15, %rax
cmovbl %r12d, %ebp
cmovbq %rax, %r15
incq %r12
jmp 0xb554f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x78a34(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x14ad8(%rip), %rsi     # 0xca066
leaq 0x3aeac(%rip), %rdx     # 0xf0441
leaq 0x3aec9(%rip), %rcx     # 0xf0465
leaq 0x365f7(%rip), %r8      # 0xebb9a
movl $0x1183, %r9d           # imm = 0x1183
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_size_of_exceptiontablemap
static size_t gt_encseq_size_of_exceptiontablemap(GtEncseq *encseq)
{
  GtUword sizeoistab;
  unsigned int bitsforsubalpha;

  sizeoistab = CALLCASTFUNC(uint64_t, unsigned_long,   /* exceptiontables */
                            gt_encseq_sizeofSWtable(encseq->oissat,
                                true,
                                true,
                                encseq->totallength,
                                encseq->specialcharinfo.realexceptionranges));
  sizeoistab += UCHAR_MAX * sizeof (GtUword);    /* classstartpositions */
  sizeoistab += encseq->numofallchars * sizeof (char); /* allchars */
  sizeoistab += UCHAR_MAX * sizeof (char);             /* maxchars */
  sizeoistab += UCHAR_MAX * sizeof (unsigned char);    /* subsymbolmap */
  bitsforsubalpha = gt_determinebitspervalue((GtUword)
                                             encseq->maxsubalphasize-1);
  sizeoistab += sizeofbitarray(bitsforsubalpha,
                              (BitOffset) encseq->
                                          specialcharinfo.exceptioncharacters);
/* exceptions */
  return (size_t) sizeoistab;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x388(%rdi), %edi
movq 0x30(%rbx), %rcx
movq 0x1e0(%rbx), %r8
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0xa7df3
movq %rax, %r14
movzbl 0x360(%rbx), %edi
decq %rdi
addq 0x340(%rbx), %r14
callq 0x58fe7
movl %eax, %ecx
imulq 0x1d0(%rbx), %rcx
movq %rcx, %rax
shrq $0x3, %rax
addq %r14, %rax
andl $0x7, %ecx
cmpq $0x1, %rcx
sbbq $-0x1, %rax
addq $0x9f6, %rax            # imm = 0x9F6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViadirectaccess
static bool containsspecialViadirectaccess(const GtEncseq *encseq,
                                           GtReadmode readmode,
                                           GT_UNUSED GtEncseqReader *esr,
                                           GtUword startpos,
                                           GtUword len)
{
  GtUword pos;

  gt_assert(encseq != NULL);
  if (!GT_ISDIRREVERSE(readmode)) {
    for (pos = startpos; pos < startpos + len; pos++) {
      if (GT_ISSPECIAL(encseq->plainseq[pos]))
        return true;
    }
  }
  else {
    gt_assert(startpos < encseq->totallength);
    startpos = GT_REVERSEPOS(encseq->totallength, startpos);
    gt_assert (startpos + 1 >= len);
    for (pos = startpos; /* Nothing */; pos--) {
      if (GT_ISSPECIAL(encseq->plainseq[pos]))
        return true;
      if (pos == startpos + 1 - len)
        break;
    }
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xb5c33
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xb5c15
movq 0x30(%rdi), %rdx
subq %rcx, %rdx
jbe 0xb5c61
cmpq %r8, %rdx
jb 0xb5c8f
negq %r8
addq 0x290(%rdi), %rdx
pushq $-0x1
popq %rcx
movb (%rdx,%rcx), %al
cmpb $-0x2, %al
setae %al
jae 0xb5c31
leaq -0x1(%rcx), %rsi
cmpq %rcx, %r8
movq %rsi, %rcx
jne 0xb5bfd
jmp 0xb5c31
addq %rcx, %r8
cmpq %r8, %rcx
setb %al
jae 0xb5c31
movq 0x290(%rdi), %rdx
cmpb $-0x3, (%rdx,%rcx)
leaq 0x1(%rcx), %rcx
jbe 0xb5c18
popq %rcx
retq
movq 0x7837e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x14422(%rip), %rsi     # 0xca066
leaq 0x36685(%rip), %rdx     # 0xec2d0
leaq 0x3aa20(%rip), %rcx     # 0xf0672
leaq 0x35f41(%rip), %r8      # 0xebb9a
movl $0x8f2, %r9d            # imm = 0x8F2
jmp 0xb5cbb
movq 0x78350(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x143f4(%rip), %rsi     # 0xca066
leaq 0x39f34(%rip), %rdx     # 0xefbad
leaq 0x3a9f2(%rip), %rcx     # 0xf0672
leaq 0x35f13(%rip), %r8      # 0xebb9a
movl $0x8fa, %r9d            # imm = 0x8FA
jmp 0xb5cbb
movq 0x78322(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x143c6(%rip), %rsi     # 0xca066
leaq 0x3ae98(%rip), %rdx     # 0xf0b3f
leaq 0x3a9c4(%rip), %rcx     # 0xf0672
leaq 0x35ee5(%rip), %r8      # 0xebb9a
movl $0x8fc, %r9d            # imm = 0x8FC
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViabytecompress
static bool containsspecialViabytecompress(const GtEncseq *encseq,
                                           GtReadmode readmode,
                                           GT_UNUSED GtEncseqReader *esr,
                                           GtUword startpos,
                                           GtUword len)
{
  GtUword pos;
  GtUchar cc;

  if (!GT_ISDIRREVERSE(readmode)) {
    for (pos = startpos; pos < startpos + len; pos++) {
      cc = delivercharViabytecompress(encseq, pos);
      if (GT_ISSPECIAL(cc))
        return true;
    }
  }
  else {
    gt_assert(startpos < encseq->totallength);
    startpos = GT_REVERSEPOS(encseq->totallength, startpos);
    gt_assert (startpos + 1 >= len);
    for (pos = startpos; /* Nothing */; pos--) {
      cc = delivercharViabytecompress(encseq, pos);
      if (GT_ISSPECIAL(cc))
        return true;
      if (pos == startpos + 1 - len)
        break;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdi, %r14
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xb61da
movq 0x30(%r14), %r12
movq %r12, %rax
subq %r15, %rax
jbe 0xb6203
cmpq %rbx, %rax
jb 0xb6231
notq %r15
addq %r15, %r12
decq %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0xa2358
cmpb $-0x2, %al
setae %bpl
subq $0x1, %rbx
setb %cl
cmpb $-0x3, %al
ja 0xb61f8
decq %r12
testb %cl, %cl
je 0xb61b5
jmp 0xb61f8
addq %r15, %rbx
cmpq %rbx, %r15
setb %bpl
jae 0xb61f8
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2358
incq %r15
cmpb $-0x3, %al
jbe 0xb61dd
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x77dae(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x13e52(%rip), %rsi     # 0xca066
leaq 0x39992(%rip), %rdx     # 0xefbad
leaq 0x3a523(%rip), %rcx     # 0xf0745
leaq 0x35971(%rip), %r8      # 0xebb9a
movl $0x9bc, %r9d            # imm = 0x9BC
jmp 0xb625d
movq 0x77d80(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x13e24(%rip), %rsi     # 0xca066
leaq 0x3a8f6(%rip), %rdx     # 0xf0b3f
leaq 0x3a4f5(%rip), %rcx     # 0xf0745
leaq 0x35943(%rip), %r8      # 0xebb9a
movl $0x9be, %r9d            # imm = 0x9BE
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: seqdelivercharViaequallength
static GtUchar seqdelivercharViaequallength(GtEncseqReader *esr)
{
  GtUword twobits = EXTRACTENCODEDCHAR(esr->encseq->twobitencoding,
                                             esr->currentpos);

  if (twobits != (GtUword) esr->encseq->leastprobablecharacter ||
      !issinglepositioninseparatorViaequallength(esr) || esr->currentpos == 0)
    return (GtUchar) twobits;
  return (GtUchar) GT_SEPARATOR;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rdx
movq 0x10(%rdi), %rax
movq 0x280(%rdx), %rcx
movq %rax, %rsi
shrq $0x5, %rsi
movq (%rcx,%rsi,8), %r14
movl %eax, %ecx
notl %ecx
addl %ecx, %ecx
shrq %cl, %r14
andl $0x3, %r14d
movl 0x170(%rdx), %ecx
cmpq %rcx, %r14
jne 0xb67aa
movq %rdi, %rbx
cmpq 0x18(%rdi), %rax
jne 0xb67aa
movq %rbx, %rdi
callq 0xa3350
movb $-0x1, %al
cmpq $0x0, 0x10(%rbx)
jne 0xb67ad
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViabitaccess
static bool containsspecialViabitaccess(const GtEncseq *encseq,
                                        GtReadmode readmode,
                                        GT_UNUSED GtEncseqReader *esr,
                                        GtUword startpos,
                                        GtUword len)
{
  GtUword pos;

  gt_assert(encseq != NULL);
  if (GT_ISDIRREVERSE(readmode)) {
    gt_assert(startpos < encseq->totallength);
    startpos = GT_REVERSEPOS(encseq->totallength, startpos);
  }
  if (encseq->specialbits == NULL)
    return false;
  if (!GT_ISDIRREVERSE(readmode)) {
    gt_assert(startpos + len <= encseq->totallength);
    for (pos = startpos; pos < startpos + len; pos++) {
      if (GT_ISIBITSET(encseq->specialbits, pos))
        return true;
    }
  }
  else {
    gt_assert (startpos + 1 >= len);
    for (pos = startpos; /* Nothing */; pos--) {
      if (GT_ISIBITSET(encseq->specialbits, pos))
        return true;
      if (pos == startpos + 1 - len)
        break;
    }
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xb6f49
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xb6f02
movq 0x30(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
jbe 0xb6f7a
movq 0x2b0(%rdi), %rsi
testq %rsi, %rsi
je 0xb6f45
cmpq %r8, %rax
jb 0xb6fd6
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
notq %rcx
addq %rcx, %rdx
decq %r8
movq %rdx, %rax
shrq $0x6, %rax
movq %rdi, %r9
movl %edx, %ecx
shrq %cl, %r9
subq $0x1, %r8
setb %cl
testq %r9, (%rsi,%rax,8)
setne %al
jne 0xb6f47
decq %rdx
testb %cl, %cl
je 0xb6eda
jmp 0xb6f47
movq 0x2b0(%rdi), %rdx
testq %rdx, %rdx
je 0xb6f45
addq %rcx, %r8
cmpq 0x30(%rdi), %r8
ja 0xb6fa8
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmpq %r8, %rcx
setb %al
jae 0xb6f47
movq %rcx, %rdi
movq %rsi, %r9
shrq %cl, %r9
shrq $0x6, %rdi
incq %rcx
testq %r9, (%rdx,%rdi,8)
je 0xb6f25
jmp 0xb6f47
xorl %eax, %eax
popq %rcx
retq
movq 0x77068(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1310c(%rip), %rsi     # 0xca066
leaq 0x3536f(%rip), %rdx     # 0xec2d0
leaq 0x398f4(%rip), %rcx     # 0xf085c
leaq 0x34c2b(%rip), %r8      # 0xebb9a
movl $0xb4e, %r9d            # imm = 0xB4E
jmp 0xb7002
movq 0x77037(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x130db(%rip), %rsi     # 0xca066
leaq 0x38c1b(%rip), %rdx     # 0xefbad
leaq 0x398c3(%rip), %rcx     # 0xf085c
leaq 0x34bfa(%rip), %r8      # 0xebb9a
movl $0xb50, %r9d            # imm = 0xB50
jmp 0xb7002
movq 0x77009(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x130ad(%rip), %rsi     # 0xca066
leaq 0x39cce(%rip), %rdx     # 0xf0c8e
leaq 0x39895(%rip), %rcx     # 0xf085c
leaq 0x34bcc(%rip), %r8      # 0xebb9a
movl $0xb56, %r9d            # imm = 0xB56
jmp 0xb7002
movq 0x76fdb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1307f(%rip), %rsi     # 0xca066
leaq 0x39b51(%rip), %rdx     # 0xf0b3f
leaq 0x39867(%rip), %rcx     # 0xf085c
leaq 0x34b9e(%rip), %r8      # 0xebb9a
movl $0xb5d, %r9d            # imm = 0xB5D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViatables
static bool containsspecialViatables(const GtEncseq *encseq,
                                     GtReadmode readmode,
                                     GtEncseqReader *esr,
                                     GtUword startpos,
                                     GtUword len)
{
  bool cspecial = false;

  gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, startpos);
  if (encseq->has_wildcardranges) {
    cspecial = containsSWViatables(encseq, esr, startpos, len,
                                   SWtable_wildcardrange);
  }
  if (!cspecial && encseq->numofdbsequences > 1UL) {
    cspecial = containsSWViatables(encseq, esr, startpos, len,
                                   SWtable_ssptab);
  }
  return cspecial;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %edx
movq %rdi, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xa3924
cmpb $0x1, 0x29(%r12)
jne 0xb7853
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xb91c7
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xb787d
cmpq $0x2, 0x40(%r12)
jb 0xb787b
pushq $0x1
popq %r8
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb91c7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackarray.h
// Function: bitpackarray_store_uint32
static inline void
bitpackarray_store_uint32(BitPackArray *array, BitOffset index, uint32_t val)
{
  gt_assert(array && index < array->numElems
            && array->bitsPerElem <= sizeof (val)*CHAR_BIT);
  gt_bsStoreUInt32(array->store,
                   array->bitsPerElem * index,
                   array->bitsPerElem,
                   val);
}

// Assembly:
testq %rdi, %rdi
je 0xb8e64
cmpq %rsi, 0x8(%rdi)
jbe 0xb8e64
movl %edx, %ecx
movl 0x10(%rdi), %edx
cmpq $0x21, %rdx
jae 0xb8e64
movq (%rdi), %rdi
imulq %rdx, %rsi
jmp 0xc6bfc
pushq %rax
movq 0x7514c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x111f0(%rip), %rsi     # 0xca066
leaq 0x37c58(%rip), %rdx     # 0xf0ad5
leaq 0x37ca1(%rip), %rcx     # 0xf0b25
leaq 0x3606d(%rip), %r8      # 0xeeef8
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: containsSWViatables
static bool containsSWViatables(const GtEncseq *encseq,
                                GtEncseqReader *esr,
                                GtUword startpos,
                                GtUword len,
                                KindofSWtable kindsw)
{
  GtEncseqReaderViatablesinfo *swstate = assignSWstate(esr, kindsw);

  gt_assert(swstate != NULL);
  if (swstate->hasprevious) {
    if (!GT_ISDIRREVERSE(esr->readmode)) {
      gt_assert(startpos + len > 0);
      if (startpos + len - 1 >= swstate->previousrange.start &&
          startpos < swstate->previousrange.end) {
        return true;
      }
    }
    else {
      startpos = GT_REVERSEPOS(encseq->totallength, startpos);
      gt_assert(startpos + 1 >= len);
      if (startpos + 1 - len < swstate->previousrange.end &&
          startpos >= swstate->previousrange.start) {
        return true;
      }
    }
  }
  return false;
}

// Assembly:
pushq %rax
xorl %eax, %eax
testl %r8d, %r8d
setne %al
movq 0x28(%rsi,%rax,8), %r8
testq %r8, %r8
je 0xb922b
cmpb $0x1, 0x3a(%r8)
jne 0xb9227
movl 0x8(%rsi), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0xb9211
movq 0x30(%rdi), %rsi
movq %rsi, %rax
subq %rdx, %rax
subq %rcx, %rax
jb 0xb9259
cmpq 0x20(%r8), %rax
jae 0xb9227
notq %rdx
addq %rdx, %rsi
movb $0x1, %al
cmpq 0x18(%r8), %rsi
jb 0xb9227
jmp 0xb9229
addq %rdx, %rcx
je 0xb9287
decq %rcx
cmpq 0x18(%r8), %rcx
jb 0xb9227
movb $0x1, %al
cmpq %rdx, 0x20(%r8)
ja 0xb9229
xorl %eax, %eax
popq %rcx
retq
movq 0x74d86(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x10e2a(%rip), %rsi     # 0xca066
leaq 0x35f7f(%rip), %rdx     # 0xef1c2
leaq 0x37b31(%rip), %rcx     # 0xf0d7b
leaq 0x32949(%rip), %r8      # 0xebb9a
movl $0xcb3, %r9d            # imm = 0xCB3
jmp 0xb92b3
movq 0x74d58(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x10dfc(%rip), %rsi     # 0xca066
leaq 0x378ce(%rip), %rdx     # 0xf0b3f
leaq 0x37b03(%rip), %rcx     # 0xf0d7b
leaq 0x3291b(%rip), %r8      # 0xebb9a
movl $0xcbe, %r9d            # imm = 0xCBE
jmp 0xb92b3
movq 0x74d2a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x10dce(%rip), %rsi     # 0xca066
leaq 0x37af0(%rip), %rdx     # 0xf0d8f
leaq 0x37ad5(%rip), %rcx     # 0xf0d7b
leaq 0x328ed(%rip), %r8      # 0xebb9a
movl $0xcb6, %r9d            # imm = 0xCB6
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq_access_type.c
// Function: gt_encseq_access_type_get
GtEncseqAccessType gt_encseq_access_type_get(const char *str)
{
  size_t i;

  for (i=0; i<sizeof (wpa)/sizeof (wpa[0]); i++)
  {
    gt_assert(i == 0 || wpa[i-1].sat < wpa[i].sat);
    if (strcmp(str,wpa[i].name) == 0)
    {
      return wpa[i].sat;
    }
  }
  return GT_ACCESS_TYPE_UNDEFINED;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x74716(%rip), %r14     # 0x12dc00
xorl %r15d, %r15d
testq %r15, %r15
je 0xb9501
cmpq $0x7, %r15
je 0xb951d
movl (%r14), %eax
cmpl 0x10(%r14), %eax
jae 0xb9526
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xb880
incq %r15
addq $0x10, %r14
testl %eax, %eax
jne 0xb94ed
movl (%r14), %eax
jmp 0xb9520
pushq $0x7
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x74a8b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x10b2f(%rip), %rsi     # 0xca066
leaq 0x37a18(%rip), %rdx     # 0xf0f56
leaq 0x37a35(%rip), %rcx     # 0xf0f7a
leaq 0x379ec(%rip), %r8      # 0xf0f38
pushq $0x40
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_md5_to_sequence_length
int gt_encseq_col_md5_to_sequence_length(GtSeqCol *sc, GtUword *len,
                                         GtStr *md5_seqid, GtError *err)
{
  GtUword seqnum = GT_UNDEF_UWORD;
  int had_err = 0;
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(esc && len && md5_seqid && err);
  gt_assert(gt_md5_seqid_has_prefix(gt_str_get(md5_seqid)));
  seqnum = gt_md5_tab_map(esc->md5_tab, gt_str_get(md5_seqid) +
                                          GT_MD5_SEQID_PREFIX_LEN);
  if (seqnum != GT_UNDEF_UWORD) {
    gt_assert(seqnum < gt_encseq_num_of_sequences(esc->encseq));
    *len = gt_encseq_seqlength(esc->encseq, seqnum);
  } else {
    gt_error_set(err, "sequence %s not found", gt_str_get(md5_seqid));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
callq 0xb9a4c
movq %rax, %rdi
movq %r12, %rsi
callq 0xbfaea
movq %rax, %r12
testq %r14, %r14
je 0xb98d9
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0xb99e6
testq %r14, %r14
je 0xb9987
testq %r15, %r15
je 0xb9987
testq %rbx, %rbx
je 0xb9987
testq %r12, %r12
je 0xb9987
movq %r15, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x59a50
testb %al, %al
je 0xb99b8
movq 0x10(%r12), %r13
movq %r15, %rdi
callq 0x143d2
leaq 0x4(%rax), %rsi
movq %r13, %rdi
callq 0xbf3ee
cmpq $-0x1, %rax
je 0xb995e
movq %rax, %r13
movq 0x8(%r12), %rdi
callq 0xa1f8d
cmpq %rax, %r13
jae 0xb9a14
movq 0x8(%r12), %rdi
movq %r13, %rsi
callq 0xa6b5f
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0xb997d
movq %r15, %rdi
callq 0x143d2
leaq 0x3149d(%rip), %rsi     # 0xeae0a
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x7462a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x106ce(%rip), %rsi     # 0xca066
leaq 0x37829(%rip), %rdx     # 0xf11c8
leaq 0x377e7(%rip), %rcx     # 0xf118d
leaq 0x37805(%rip), %r8      # 0xf11b2
movl $0x147, %r9d            # imm = 0x147
jmp 0xb9a40
movq 0x745f9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1069d(%rip), %rsi     # 0xca066
leaq 0x31368(%rip), %rdx     # 0xead38
leaq 0x377b6(%rip), %rcx     # 0xf118d
leaq 0x377d4(%rip), %r8      # 0xf11b2
movl $0x148, %r9d            # imm = 0x148
jmp 0xb9a40
movq 0x745cb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1066f(%rip), %rsi     # 0xca066
leaq 0x10c5b(%rip), %rdx     # 0xca659
leaq 0x37788(%rip), %rcx     # 0xf118d
leaq 0x377a6(%rip), %r8      # 0xf11b2
movl $0x146, %r9d            # imm = 0x146
jmp 0xb9a40
movq 0x7459d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x10641(%rip), %rsi     # 0xca066
leaq 0x37ad5(%rip), %rdx     # 0xf1501
leaq 0x3775a(%rip), %rcx     # 0xf118d
leaq 0x37778(%rip), %r8      # 0xf11b2
movl $0x14c, %r9d            # imm = 0x14C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_class
const GtSeqColClass* gt_encseq_col_class(void)
{
  static const GtSeqColClass *esc_class = NULL;
  gt_class_alloc_lock_enter();
  if (!esc_class) {
      esc_class = gt_seq_col_class_new(sizeof (GtEncseqCol),
                                       gt_encseq_col_delete,
                                       gt_encseq_col_enable_match_desc_start,
                                       gt_encseq_col_grep_desc,
                                       gt_encseq_col_grep_desc_desc,
                                       gt_encseq_col_grep_desc_md5,
                                       gt_encseq_col_grep_desc_sequence_length,
                                       gt_encseq_col_md5_to_seq,
                                       gt_encseq_col_md5_to_description,
                                       gt_encseq_col_md5_to_sequence_length,
                                       gt_encseq_col_num_of_files,
                                       gt_encseq_col_num_of_seqs,
                                       gt_encseq_col_get_md5_fingerprint,
                                       gt_encseq_col_get_sequence,
                                       gt_encseq_col_get_description,
                                       gt_encseq_col_get_sequence_length);
  }
  gt_class_alloc_lock_leave();
  return esc_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x4f21f
cmpq $0x0, 0x7631c(%rip)     # 0x12fd80
jne 0xb9af6
leaq 0x100a(%rip), %r15      # 0xbaa7b
leaq 0xee5(%rip), %r12       # 0xba95d
leaq 0xd83(%rip), %r13       # 0xba802
leaq 0xced(%rip), %rbp       # 0xba773
leaq 0xbb2(%rip), %rax       # 0xba63f
leaq 0xb50(%rip), %r14       # 0xba5e4
leaq -0x1ff(%rip), %rbx      # 0xb989c
leaq 0x921(%rip), %r11       # 0xba3c3
leaq 0x6dc(%rip), %r10       # 0xba185
leaq 0x61(%rip), %rsi        # 0xb9b11
leaq 0x9d(%rip), %rdx        # 0xb9b54
leaq 0x21c(%rip), %rcx       # 0xb9cda
leaq 0x387(%rip), %r8        # 0xb9e4c
leaq 0x4ab(%rip), %r9        # 0xb9f77
pushq $0x30
popq %rdi
pushq %r15
pushq %r12
pushq %r13
pushq %rbp
pushq %rax
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
leaq 0x599(%rip), %rax       # 0xba07e
pushq %rax
callq 0xbf99c
addq $0x50, %rsp
movq %rax, 0x7628a(%rip)     # 0x12fd80
callq 0x4f266
movq 0x7627e(%rip), %rax     # 0x12fd80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_delete
static void gt_encseq_col_delete(GtSeqCol *sc)
{
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  if (!esc) return;
  gt_seq_info_cache_delete(esc->grep_cache);
  gt_hashmap_delete(esc->duplicates);
  gt_md5_tab_delete(esc->md5_tab);
  gt_encseq_delete(esc->encseq);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xb9a4c
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbfaea
testq %rax, %rax
je 0xb9b52
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xbfff4
movq 0x20(%rbx), %rdi
callq 0x563a7
movq 0x10(%rbx), %rdi
callq 0xbf2f3
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0xa4fe9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_enable_match_desc_start
static void gt_encseq_col_enable_match_desc_start(GtSeqCol *sc)
{
  GtEncseqCol *esc;
  GtUword j;
  GtSeqInfo seq_info;
  GtStr *descbuf = gt_str_new();
  esc = gt_encseq_col_cast(sc);
  esc->matchstart = true;
  /* pre-cache seqids for faster search */
  if (!esc->grep_cache)
    esc->grep_cache = gt_seq_info_cache_new();
  for (j = 0; j < gt_encseq_num_of_sequences(esc->encseq); j++) {
    const char *desc;
    GtUword desc_len;
    desc = gt_encseq_description(esc->encseq, &desc_len, j);
    gt_assert(desc);
    gt_str_reset(descbuf);
    gt_str_append_cstr_nt(descbuf, desc, desc_len);
    seq_info.filenum = gt_encseq_filenum(esc->encseq,
                                         gt_encseq_seqstartpos(esc->encseq, j));
    seq_info.seqnum = j - gt_encseq_filenum_first_seqnum(esc->encseq,
                                                         seq_info.filenum);
    if (!gt_seq_info_cache_get(esc->grep_cache, gt_str_get(descbuf)))
      gt_seq_info_cache_add(esc->grep_cache, gt_str_get(descbuf), &seq_info);
    else {
      if (!esc->duplicates)
        esc->duplicates = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
      gt_hashmap_add(esc->duplicates, gt_str_get(descbuf), (void*) 1);
    }
  }
  gt_str_delete(descbuf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x13d5c
movq %rax, %rbx
callq 0xb9a4c
movq %rax, %rdi
movq %r14, %rsi
callq 0xbfaea
movq %rax, %r14
movb $0x1, 0x28(%rax)
cmpq $0x0, 0x18(%rax)
jne 0xb9b94
callq 0xbffc4
movq %rax, 0x18(%r14)
xorl %r15d, %r15d
movq %rsp, %r12
pushq $0x1
popq %rbp
movq 0x8(%r14), %rdi
callq 0xa1f8d
cmpq %rax, %r15
jae 0xb9c8b
movq 0x8(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xa7510
testq %rax, %rax
je 0xb9ca2
movq %rax, %r13
movq %rbx, %rdi
callq 0x1452f
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13f76
movq 0x8(%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xa6788
movq %r13, %rdi
movq %rax, %rsi
callq 0xb3583
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0xb3692
movq %r15, %rcx
subq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%r14), %r13
movq %rbx, %rdi
callq 0x143d2
movq %r13, %rdi
movq %rax, %rsi
callq 0xc0019
testq %rax, %rax
je 0xb9c67
movq 0x20(%r14), %r13
testq %r13, %r13
jne 0xb9c4f
pushq $0x1
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, %r13
movq %rax, 0x20(%r14)
movq %rbx, %rdi
callq 0x143d2
movq %r13, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x55f31
jmp 0xb9c83
movq 0x18(%r14), %r13
movq %rbx, %rdi
callq 0x143d2
movq %r13, %rdi
movq %rax, %rsi
leaq 0x8(%rsp), %rdx
callq 0xc005d
incq %r15
jmp 0xb9b9d
movq %rbx, %rdi
callq 0x152db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7430f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x103b3(%rip), %rsi     # 0xca066
leaq 0x2a164(%rip), %rdx     # 0xe3e1e
leaq 0x37569(%rip), %rcx     # 0xf122a
leaq 0x374ea(%rip), %r8      # 0xf11b2
movl $0x8c, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300