LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: fwdbitaccessunitsnotspecial0
static inline unsigned fwdbitaccessunitsnotspecial0(const GtEncseq
                                                    *encseq,
                                                    GtUword startpos)
{
  gt_assert(startpos < encseq->totallength);
  if (encseq->totallength - startpos > (GtUword) GT_UNITSIN2BITENC)
    return (unsigned int) GT_UNITSIN2BITENC;
  return (unsigned int) (encseq->totallength - startpos);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x132ba4
movq 0x81465(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2b4e9(%rip), %rsi     # 0x15e066
leaq 0x56c31(%rip), %rdx     # 0x1897b5
leaq 0x56c49(%rip), %rcx     # 0x1897d4
leaq 0x52acc(%rip), %r8      # 0x18565e
movl $0x1722, %r9d           # imm = 0x1722
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x132ba6
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
subq (%rsp), %rax
cmpq $0x20, %rax
jbe 0x132bc3
movl $0x20, 0x14(%rsp)
jmp 0x132bd4
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
subq (%rsp), %rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
andq $0x1f, %rax
movq %rax, -0x20(%rsp)
cmpq $0x1f, -0x20(%rsp)
jae 0x132c70
movq -0x18(%rsp), %rax
shrq $0x5, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1f, %ecx
subq -0x20(%rsp), %rcx
shlq %rcx
shrq %cl, %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x28(%rsp)
jbe 0x132c64
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
addq $0x1, %rcx
shlq %rcx
shlq %cl, %rax
orq -0x30(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x132c87
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
shrq $0x5, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
andq $0x3f, %rax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
shrq $0x6, %rax
movq %rax, -0x28(%rsp)
cmpl $0x20, -0x1c(%rsp)
jl 0x132cec
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x3f, %ecx
subl -0x1c(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x132d61
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x3f, %ecx
subl -0x1c(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq %rcx, %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x28(%rsp)
jbe 0x132d57
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq %rcx, %rax
orq -0x30(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: extract2bitenc_bruteforce
static void extract2bitenc_bruteforce(bool fwd,
                                      GtEndofTwobitencoding *ptbe,
                                      const GtEncseq *encseq,
                                      GtUword startpos)
{
  bool mirrored = false;
  if (encseq->hasmirror && startpos >= encseq->totallength) {
    if (startpos == encseq->totallength) {
      /* handle special case where we start on the virtual separator */
      ptbe->tbe = 0;
      ptbe->unitsnotspecial = 0;
      return;
    }
    mirrored = true;
    /* invert coordinates */
    fwd = !fwd;
    startpos = GT_REVERSEPOS(encseq->totallength,
                             startpos - encseq->totallength - 1);
  }
  if (fwd)
    fwdextract2bitenc_bruteforce(ptbe, encseq, startpos);
  else {
    revextract2bitenc_bruteforce(ptbe, encseq,
                                 GT_REVERSEPOS(encseq->totallength, startpos));
  }
  if (mirrored) {
    /* reverse */
    ptbe->tbe = gt_intbits_reverse_unitwise(ptbe->tbe);
    /* complement */
    if (ptbe->unitsnotspecial > 0)
      ptbe->tbe ^= ~0;
  }
}

// Assembly:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x132f14
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x132f14
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x132edc
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0x8(%rax)
jmp 0x132f8d
movb $0x1, 0x7(%rsp)
movb 0x27(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq 0x30(%rdx), %rcx
subq $0x1, %rcx
subq %rcx, %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x27(%rsp)
je 0x132f31
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x133210
jmp 0x132f52
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdx
subq $0x1, %rdx
subq 0x8(%rsp), %rdx
callq 0x133370
testb $0x1, 0x7(%rsp)
je 0x132f8d
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x1328d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jbe 0x132f8b
movq 0x18(%rsp), %rax
movq (%rax), %rcx
xorq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x132f8d
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: fwdextract2bitenc_bruteforce
static void fwdextract2bitenc_bruteforce(GtEndofTwobitencoding *ptbe,
                                         const GtEncseq *encseq,
                                         GtUword startpos)
{
  GtUchar cc;
  GtUword pos;

  ptbe->tbe = 0;
  for (pos = startpos; pos < startpos + GT_UNITSIN2BITENC; pos++) {
    if (pos == encseq->totallength) {
      ptbe->unitsnotspecial = (unsigned int) (pos - startpos);
      ptbe->tbe <<= GT_MULT2(startpos + GT_UNITSIN2BITENC - pos);
      return;
    }
    cc = gt_encseq_get_encoded_char(encseq, pos, GT_READMODE_FORWARD);
    if (GT_ISSPECIAL(cc)) {
      ptbe->unitsnotspecial = (unsigned int) (pos - startpos);
      ptbe->tbe <<= GT_MULT2(startpos + GT_UNITSIN2BITENC - pos);
      return;
    }
    gt_assert(cc < (GtUchar) 4);
    ptbe->tbe = (ptbe->tbe << 2) | cc;
  }
  ptbe->unitsnotspecial = (unsigned int) GT_UNITSIN2BITENC;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jae 0x13335f
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x133296
movq (%rsp), %rax
subq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rcx
addq $0x20, %rcx
subq (%rsp), %rcx
shlq %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rdx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x13336b
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x113f80
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jl 0x1332ec
movq (%rsp), %rax
subq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rcx
addq $0x20, %rcx
subq (%rsp), %rcx
shlq %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rdx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x13336b
jmp 0x1332ee
movzbl 0xf(%rsp), %eax
cmpl $0x4, %eax
jl 0x133330
movq 0x80cd9(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2ad5d(%rip), %rsi     # 0x15e066
leaq 0x565d9(%rip), %rdx     # 0x1898e9
leaq 0x56697(%rip), %rcx     # 0x1899ae
leaq 0x52340(%rip), %r8      # 0x18565e
movl $0x1a7b, %r9d           # imm = 0x1A7B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x133332
movq 0x20(%rsp), %rax
movq (%rax), %rcx
shlq $0x2, %rcx
movzbl 0xf(%rsp), %eax
orq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x133238
movq 0x20(%rsp), %rax
movl $0x20, 0x8(%rax)
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: revextract2bitenc_bruteforce
static void revextract2bitenc_bruteforce(GtEndofTwobitencoding *ptbe,
                                         const GtEncseq *encseq,
                                         GtUword startpos)
{
  GtUchar cc;
  unsigned int unit;
  GtUword pos;

  ptbe->tbe = 0;
  for (unit = 0, pos = startpos;
       unit < (unsigned int) GT_UNITSIN2BITENC;
       unit++) {
    cc = gt_encseq_get_encoded_char(encseq, pos, GT_READMODE_FORWARD);
    if (GT_ISSPECIAL(cc)) {
      ptbe->unitsnotspecial = unit;
      return;
    }
    gt_assert(cc < (GtUchar) 4);
    ptbe->tbe |= (((GtBitsequence) cc) << GT_MULT2(unit));
    if (pos == 0) {
      ptbe->unitsnotspecial = unit+1;
      return;
    }
    pos--;
  }
  ptbe->unitsnotspecial = (unsigned int) GT_UNITSIN2BITENC;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x20, 0x8(%rsp)
jae 0x133474
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x113f80
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jl 0x1333dc
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x133480
jmp 0x1333de
movzbl 0xf(%rsp), %eax
cmpl $0x4, %eax
jl 0x133420
movq 0x80be9(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2ac6d(%rip), %rsi     # 0x15e066
leaq 0x564e9(%rip), %rdx     # 0x1898e9
leaq 0x565c4(%rip), %rcx     # 0x1899cb
leaq 0x52250(%rip), %r8      # 0x18565e
movl $0x1a92, %r9d           # imm = 0x1A92
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x133422
movzbl 0xf(%rsp), %eax
movl 0x8(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq 0x20(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rsp)
jne 0x133458
movl 0x8(%rsp), %ecx
addl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x133480
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1333a0
movq 0x20(%rsp), %rax
movl $0x20, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x20(%rsp)
cmpl $0x40, -0x14(%rsp)
jae 0x1334fb
movq -0x10(%rsp), %rdx
andq -0x20(%rsp), %rdx
movl $0x30, %eax
movl $0x31, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rax
shrq %rax
movq %rax, -0x20(%rsp)
jmp 0x1334b1
movq -0x8(%rsp), %rax
movb $0x0, 0x40(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dl, %al
movb %sil, %dl
movq 0x40(%rsp), %rsi
movq %rdi, 0x28(%rsp)
andb $0x1, %dl
movb %dl, 0x27(%rsp)
andb $0x1, %al
movb %al, 0x26(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
testb $0x1, 0x27(%rsp)
je 0x133e2d
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq 0x40(%rsp), %rax
jne 0x133e1c
movq 0x40(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x30(%rsp)
jmp 0x133ed7
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x133e65
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x133e53
movq 0x8(%rsp), %rax
subq 0x18(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x30(%rsp)
jmp 0x133ed7
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x133ec7
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x113f80
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0xfe, %eax
jl 0x133ea4
movq 0x18(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x30(%rsp)
jmp 0x133ed7
testb $0x1, 0x26(%rsp)
je 0x133ebb
movzbl 0x7(%rsp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
movq %rax, 0x30(%rsp)
jmp 0x133ed7
movq 0x18(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: fwdextractspecialbits_bruteforce
static inline GtBitsequence fwdextractspecialbits_bruteforce(
                                               unsigned int *unitsnotspecial,
                                               const GtBitsequence *specialbits,
                                               GtUword startpos)
{
  GtUword idx;
  GtBitsequence result = 0, mask = GT_FIRSTBIT;
  bool found = false;

  *unitsnotspecial = (unsigned int) GT_UNITSIN2BITENC;
  for (idx=startpos; idx<startpos + GT_UNITSIN2BITENC; idx++) {
    if (GT_ISIBITSET(specialbits, idx)) {
      if (!found) {
        *unitsnotspecial = (unsigned int) (idx - startpos);
        found = true;
      }
      result |= mask;
    }
    mask >>= 1;
  }
  return result;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x28(%rsp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x30(%rsp)
movb $0x0, -0x31(%rsp)
movq -0x8(%rsp), %rax
movl $0x20, (%rax)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jae 0x133fca
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x133faa
testb $0x1, -0x31(%rsp)
jne 0x133f9b
movq -0x20(%rsp), %rax
subq -0x18(%rsp), %rax
movl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, -0x31(%rsp)
movq -0x30(%rsp), %rax
orq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
shrq %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x133f31
movq -0x28(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: revextractspecialbits_bruteforce
static inline GtBitsequence revextractspecialbits_bruteforce(
                                    unsigned int *unitsnotspecial,
                                    const GtBitsequence *specialbits,
                                    GtUword startpos)
{
  GtUword idx;
  GtBitsequence result = 0, mask = (GtBitsequence) 1;
  bool found = false;
  GtUword twobitencodingstoppos;

  if (startpos >= (GtUword) GT_UNITSIN2BITENC) {
    twobitencodingstoppos = startpos - GT_UNITSIN2BITENC + 1;
    *unitsnotspecial = (unsigned int) GT_UNITSIN2BITENC;
  }
  else {
    twobitencodingstoppos = 0;
    *unitsnotspecial = (unsigned int) (startpos+1);
  }
  for (idx=startpos; /* Nothing */; idx--) {
    if (GT_ISIBITSET(specialbits, idx)) {
      if (!found) {
        *unitsnotspecial = (unsigned int) (startpos - idx);
        found = true;
      }
      result |= mask;
    }
    mask <<= 1;
    if (idx == twobitencodingstoppos)
      break;
  }
  return result;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x28(%rsp)
movq $0x1, -0x30(%rsp)
movb $0x0, -0x31(%rsp)
cmpq $0x20, -0x18(%rsp)
jb 0x13401d
movq -0x18(%rsp), %rax
subq $0x20, %rax
addq $0x1, %rax
movq %rax, -0x40(%rsp)
movq -0x8(%rsp), %rax
movl $0x20, (%rax)
jmp 0x134038
movq $0x0, -0x40(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1340a4
testb $0x1, -0x31(%rsp)
jne 0x134095
movq -0x18(%rsp), %rax
subq -0x20(%rsp), %rax
movl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, -0x31(%rsp)
movq -0x30(%rsp), %rax
orq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
shlq %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x40(%rsp), %rax
jne 0x1340bf
jmp 0x1340d4
jmp 0x1340c1
movq -0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x134042
movq -0x28(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0x54(%rsp), %edx
movq 0x48(%rsp), %rcx
callq 0x115f90
movq 0x48(%rsp), %rsi
leaq 0x55ab4(%rip), %rdi     # 0x189bdd
movb $0x0, %al
callq 0xb070
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x134205
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x54(%rsp), %edx
callq 0x113f80
movb %al, 0x37(%rsp)
movq 0x58(%rsp), %rdi
callq 0x115010
movb %al, 0x36(%rsp)
movzbl 0x37(%rsp), %eax
movzbl 0x36(%rsp), %ecx
cmpl %ecx, %eax
je 0x1341f0
movq 0x7fe54(%rip), %rax     # 0x1b3fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
callq 0x116850
movq %rax, 0x28(%rsp)
movl 0x54(%rsp), %edi
callq 0x149af0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq %rax, %r8
movq 0x40(%rsp), %r9
movzbl 0x37(%rsp), %r10d
movzbl 0x36(%rsp), %eax
leaq 0x55a2b(%rip), %rsi     # 0x189c02
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
jmp 0x1341f2
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x13413a
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x7fdae(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %rax
movq (%rax), %r9
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x55b47(%rip), %rsi     # 0x189da2
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb890
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: getsatforcevalue
static int getsatforcevalue(const char *str, GtError *err)
{
  GtEncseqAccessType sat = gt_encseq_access_type_get(str);

  if (sat == GT_ACCESS_TYPE_UNDEFINED) {
    gt_error_set(err, "Illegal argument \"%s\" to option -sat; "
                     "must be one of the following keywords: %s",
                     str,
                     gt_encseq_access_type_list());
    return -1;
  }
  switch (sat) {
    case GT_ACCESS_TYPE_UCHARTABLES: return 0;
    case GT_ACCESS_TYPE_USHORTTABLES: return 1;
    case GT_ACCESS_TYPE_UINT32TABLES: return 2;
    default: return 3;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13e840
movl %eax, 0x1c(%rsp)
cmpl $0x7, 0x1c(%rsp)
jne 0x1342d1
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x13e7d0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x55b2f(%rip), %rsi     # 0x189def
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x13431c
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x4, %eax
je 0x1342f6
jmp 0x1342e0
movl 0x4(%rsp), %eax
subl $0x5, %eax
je 0x134300
jmp 0x1342eb
movl 0x4(%rsp), %eax
subl $0x6, %eax
je 0x13430a
jmp 0x134314
movl $0x0, 0x34(%rsp)
jmp 0x13431c
movl $0x1, 0x34(%rsp)
jmp 0x13431c
movl $0x2, 0x34(%rsp)
jmp 0x13431c
movl $0x3, 0x34(%rsp)
movl 0x34(%rsp), %eax
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_flush2file
static int gt_encseq_flush2file(const char *indexname,
                                GtEncseq *encseq,
                                bool esq_no_header,
                                GtError *err)
{
  FILE *fp;
  bool haserr = false;

  gt_error_check(err);
  fp = gt_fa_fopen_with_suffix(indexname, GT_ENCSEQFILESUFFIX, "wb", err);
  if (fp == NULL)
    haserr = true;
  if (!haserr) {
    if (gt_mapspec_write(esq_no_header
                           ? gt_encseq_assign_sequence_mapspec
                           : gt_encseq_assign_mapspec,
                         fp, encseq,
                         encseq->sizeofrep, err) != 0) {
      haserr = true;
    }
  }
  if (!esq_no_header)
    gt_encseq_headerptr_delete(&encseq->headerptr);
  gt_fa_xfclose(fp);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movb $0x0, 0xf(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x136090
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x136058
jmp 0x136090
movq 0x7df79(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x27ffd(%rip), %rsi     # 0x15e066
leaq 0x285d8(%rip), %rdx     # 0x15e648
leaq 0x540f4(%rip), %rcx     # 0x18a16b
leaq 0x4f5e0(%rip), %r8      # 0x18565e
movl $0x5a1, %r9d            # imm = 0x5A1
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x136092
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %r9
leaq 0x4e5e1(%rip), %rsi     # 0x184684
leaq 0x4dd78(%rip), %rdx     # 0x183e22
leaq 0x4f5ad(%rip), %rcx     # 0x18565e
movl $0x5a2, %r8d            # imm = 0x5A2
callq 0x7faa0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1360ce
movb $0x1, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
jne 0x136117
movb 0x27(%rsp), %cl
leaq -0x1e310(%rip), %rdi    # 0x117dd0
leaq -0x88f7(%rip), %rax     # 0x12d7f0
testb $0x1, %cl
cmovneq %rax, %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x18(%rsp), %r8
callq 0x145e90
cmpl $0x0, %eax
je 0x136115
movb $0x1, 0xf(%rsp)
jmp 0x136117
testb $0x1, 0x27(%rsp)
jne 0x13612c
movq 0x28(%rsp), %rdi
addq $0x70, %rdi
callq 0x117ff0
movq 0x10(%rsp), %rdi
callq 0x7fd50
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: flushoistab2file
static int flushoistab2file(const char *indexname, GtEncseq *encseq,
                            GtError *err)
{
  FILE *fp;
  int had_err = 0;

  gt_error_check(err);
  fp = gt_fa_fopen_with_suffix(indexname, GT_OISTABFILESUFFIX, "wb", err);
  if (fp == NULL)
    had_err = -1;
  if (!had_err) {
    GtUword sizeoistab = (GtUword)
                                    gt_encseq_size_of_exceptiontablemap(encseq);
    if (gt_mapspec_write(assignoistabmapspecification, fp, encseq, sizeoistab,
                         err) != 0) {
      had_err = -1;
    }
  }
  gt_free(encseq->exceptionheaderptr.classstartpositionsptr);
  gt_free(encseq->exceptionheaderptr.maxcharsptr);
  gt_free(encseq->exceptionheaderptr.allcharsptr);
  gt_free(encseq->exceptionheaderptr.subsymbolmapptr);
  gt_fa_xfclose(fp);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1361bb
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x136183
jmp 0x1361bb
movq 0x7de4e(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x27ed2(%rip), %rsi     # 0x15e066
leaq 0x284ad(%rip), %rdx     # 0x15e648
leaq 0x53fde(%rip), %rcx     # 0x18a180
leaq 0x4f4b5(%rip), %r8      # 0x18565e
movl $0x478, %r9d            # imm = 0x478
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1361bd
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %r9
leaq 0x4e4bb(%rip), %rsi     # 0x184689
leaq 0x4dc4d(%rip), %rdx     # 0x183e22
leaq 0x4f482(%rip), %rcx     # 0x18565e
movl $0x479, %r8d            # imm = 0x479
callq 0x7faa0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1361fc
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x14(%rsp)
jne 0x136241
movq 0x28(%rsp), %rdi
callq 0x137380
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %r8
leaq 0x1233(%rip), %rdi      # 0x137460
callq 0x145e90
cmpl $0x0, %eax
je 0x13623f
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x136241
movq 0x28(%rsp), %rax
movq 0x368(%rax), %rdi
leaq 0x4f40a(%rip), %rsi     # 0x18565e
movl $0x484, %edx            # imm = 0x484
callq 0xdab0
movq 0x28(%rsp), %rax
movq 0x370(%rax), %rdi
leaq 0x4f3ed(%rip), %rsi     # 0x18565e
movl $0x485, %edx            # imm = 0x485
callq 0xdab0
movq 0x28(%rsp), %rax
movq 0x378(%rax), %rdi
leaq 0x4f3d0(%rip), %rsi     # 0x18565e
movl $0x486, %edx            # imm = 0x486
callq 0xdab0
movq 0x28(%rsp), %rax
movq 0x380(%rax), %rdi
leaq 0x4f3b3(%rip), %rsi     # 0x18565e
movl $0x487, %edx            # imm = 0x487
callq 0xdab0
movq 0x18(%rsp), %rdi
callq 0x7fd50
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movb %sil, %al
movq %rdi, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
testb $0x1, 0x5f(%rsp)
je 0x136f52
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x136f5b
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x136f5b
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x11f(%rip), %rsi       # 0x137090
leaq 0x10(%rsp), %rdx
callq 0x112d70
cmpq $0x0, 0x50(%rsp)
je 0x136fac
movq 0x18(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: detencseqofsatviautables
static uint64_t detencseqofsatviautables(int kind,
                                         GtUword totallength,
                                         GtUword numofsequences,
                                         GtUword numofdbfiles,
                                         GtUword lengthofdbfilenames,
                                         GtUword wildcardranges,
                                         unsigned int numofchars,
                                         GtUword lengthofalphadef)
{
  GtEncseqAccessType sat[] = {GT_ACCESS_TYPE_UCHARTABLES,
                              GT_ACCESS_TYPE_USHORTTABLES,
                              GT_ACCESS_TYPE_UINT32TABLES};

  gt_assert(kind < (int) (sizeof (sat)/sizeof (sat[0])));
  return gt_encseq_determine_size(sat[kind], totallength, numofsequences,
                                  numofdbfiles, lengthofdbfilenames,
                                  wildcardranges, numofchars, 0,
                                  lengthofalphadef);
}

// Assembly:
subq $0x58, %rsp
movq 0x68(%rsp), %rax
movl 0x60(%rsp), %eax
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x4e64f(%rip), %rax     # 0x185640
movq %rax, 0x1c(%rsp)
movl 0x4e64c(%rip), %eax     # 0x185648
movl %eax, 0x24(%rsp)
cmpl $0x3, 0x54(%rsp)
jl 0x13703f
movq 0x7cfca(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2704e(%rip), %rsi     # 0x15e066
leaq 0x53090(%rip), %rdx     # 0x18a0af
leaq 0x530b5(%rip), %rcx     # 0x18a0db
leaq 0x4e631(%rip), %r8      # 0x18565e
movl $0x141f, %r9d           # imm = 0x141F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x137041
movslq 0x54(%rsp), %rax
movl 0x1c(%rsp,%rax,4), %edi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movl 0x60(%rsp), %r10d
movq 0x68(%rsp), %rax
xorl %r11d, %r11d
movl %r10d, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x11cb80
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $-0x1, 0x18(%rsp)
jbe 0x1370ec
movq 0x7cf1d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x26fa1(%rip), %rsi     # 0x15e066
leaq 0x52f7b(%rip), %rdx     # 0x18a047
leaq 0x52f64(%rip), %rcx     # 0x18a037
leaq 0x4e584(%rip), %r8      # 0x18565e
movl $0x13ed, %r9d           # imm = 0x13ED
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1370ee
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0xff, %edx
callq 0x1371a0
movq %rax, %rcx
movq (%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0xffff, %edx           # imm = 0xFFFF
callq 0x1371a0
movq %rax, %rcx
movq (%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1371a0
movq %rax, %rcx
movq (%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rdx
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %r8
leaq 0x52ed3(%rip), %rsi     # 0x18a065
movb $0x0, %al
callq 0xcec0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: currentspecialrangevalue
static GtUword currentspecialrangevalue(GtUword len,
                                              GtUword occcount,
                                              GtUword maxrangevalue)
{
  if (maxrangevalue == UINT32_MAX) {
    gt_assert(len - 1 <= UINT32_MAX);
    return occcount;
  }
  if (len <= maxrangevalue+1UL)
    return occcount;
  if (len % (maxrangevalue+1UL) == 0)
    return len/(maxrangevalue+1UL) * occcount;
  return (1UL + len/(maxrangevalue+1UL)) * occcount;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0x8(%rsp)
jne 0x13721a
jmp 0x1371c1
movq 0x18(%rsp), %rax
subq $0x1, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jbe 0x13720c
movq 0x7cdfd(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x26e81(%rip), %rsi     # 0x15e066
leaq 0x52e94(%rip), %rdx     # 0x18a080
leaq 0x52ea3(%rip), %rcx     # 0x18a096
leaq 0x4e464(%rip), %r8      # 0x18565e
movl $0x13d3, %r9d           # imm = 0x13D3
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13720e
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x137294
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
ja 0x137239
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x137294
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x137272
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
xorl %edx, %edx
divq %rcx
imulq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x137294
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
xorl %edx, %edx
divq %rcx
addq $0x1, %rax
imulq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x109da0
cmpl $0x0, %eax
ja 0x1372f5
movq 0x7cd14(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x26d98(%rip), %rsi     # 0x15e066
leaq 0x52e52(%rip), %rdx     # 0x18a127
leaq 0x52e6f(%rip), %rcx     # 0x18a14b
leaq 0x4e37b(%rip), %r8      # 0x18565e
movl $0x1183, %r9d           # imm = 0x1183
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1372f7
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
callq 0x109da0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jae 0x13736d
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
cmpq 0x8(%rsp), %rax
jae 0x13735e
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x137360
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x137314
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x388(%rax), %edi
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x1e0(%rax), %r8
movl $0x1, %edx
movl %edx, %esi
callq 0x11ce80
movq %rax, %rdx
leaq 0x4e29f(%rip), %rdi     # 0x18565e
movl $0x464, %esi            # imm = 0x464
callq 0x12d160
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x7f8, %rax            # imm = 0x7F8
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x340(%rax), %rax
shlq $0x0, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0xff, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0xff, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x360(%rax), %eax
movl %eax, %edi
subq $0x1, %rdi
callq 0x8c6d0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
movq 0x10(%rsp), %rax
movq 0x1d0(%rax), %rsi
callq 0x11ce50
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: filloistabmapspecstartptr
static int filloistabmapspecstartptr(GtEncseq *encseq,
                                     const char *indexname,
                                     GtError *err)
{
  bool haserr = false;
  GtStr *tmpfilename;
  GtUword sizeoistab;

  gt_error_check(err);
  tmpfilename = gt_str_new_cstr(indexname);
  gt_str_append_cstr(tmpfilename, GT_OISTABFILESUFFIX);

  sizeoistab = (GtUword) gt_encseq_size_of_exceptiontablemap(encseq);

  if (gt_mapspec_read(assignoistabmapspecification, encseq,
                      gt_str_get(tmpfilename),
                      sizeoistab, &encseq->oistabmappedptr, err) != 0) {
    haserr = true;
  }
  if (!haserr) {
    encseq->has_ssptab = true;
    encseq->classstartpositions
                            = encseq->exceptionheaderptr.classstartpositionsptr;
    encseq->allchars = encseq->exceptionheaderptr.allcharsptr;
    encseq->maxchars = encseq->exceptionheaderptr.maxcharsptr;
    encseq->subsymbolmap = (unsigned char*)
                                     encseq->exceptionheaderptr.subsymbolmapptr;
  }
  gt_str_delete(tmpfilename);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x137ca8
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x137c70
jmp 0x137ca8
movq 0x7c361(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x263e5(%rip), %rsi     # 0x15e066
leaq 0x269c0(%rip), %rdx     # 0x15e648
leaq 0x52657(%rip), %rcx     # 0x18a2e6
leaq 0x4d9c8(%rip), %r8      # 0x18565e
movl $0x494, %r9d            # imm = 0x494
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x137caa
movq 0x28(%rsp), %rdi
callq 0x18f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x4c9c4(%rip), %rsi     # 0x184689
callq 0x18fb0
movq 0x30(%rsp), %rdi
callq 0x137380
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x19940
movq (%rsp), %rsi
movq %rax, %rdx
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %r8
addq $0x20, %r8
movq 0x20(%rsp), %r9
leaq -0x8ad(%rip), %rdi      # 0x137460
callq 0x145950
cmpl $0x0, %eax
je 0x137d1c
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x137d8c
movq 0x30(%rsp), %rax
movb $0x1, 0x2a(%rax)
movq 0x30(%rsp), %rax
movq 0x368(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x338(%rax)
movq 0x30(%rsp), %rax
movq 0x378(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x350(%rax)
movq 0x30(%rsp), %rax
movq 0x370(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x348(%rax)
movq 0x30(%rsp), %rax
movq 0x380(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x358(%rax)
movq 0x10(%rsp), %rdi
callq 0x1afc0
movb 0x1f(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
cmpl $0x1, 0x34(%rsp)
je 0x138d58
cmpl $0x3, 0x34(%rsp)
je 0x138d58
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x138d53
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1145e0
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jl 0x138d41
movb $0x1, 0x47(%rsp)
jmp 0x138e68
jmp 0x138d43
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x138d04
jmp 0x138e63
jmp 0x138d5a
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x138da2
movq 0x7b267(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x252eb(%rip), %rsi     # 0x15e066
leaq 0x50a33(%rip), %rdx     # 0x1897b5
leaq 0x516bb(%rip), %rcx     # 0x18a444
leaq 0x4c8ce(%rip), %r8      # 0x18565e
movl $0x9bc, %r9d            # imm = 0x9BC
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x138da4
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
subq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
cmpq 0x18(%rsp), %rax
jae 0x138e03
movq 0x7b206(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2528a(%rip), %rsi     # 0x15e066
leaq 0x51a5b(%rip), %rdx     # 0x18a83e
leaq 0x5165a(%rip), %rcx     # 0x18a444
leaq 0x4c86d(%rip), %r8      # 0x18565e
movl $0x9be, %r9d            # imm = 0x9BE
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x138e05
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1145e0
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jl 0x138e35
movb $0x1, 0x47(%rsp)
jmp 0x138e68
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x1, %rcx
subq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jne 0x138e4f
jmp 0x138e61
jmp 0x138e51
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x138e0f
jmp 0x138e63
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)