LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLCompact
void
gt_SRLCompact(struct seqRangeList *rangeList)
{
  gt_assert(rangeList);
  rangeList->ranges = gt_realloc(rangeList->ranges,
                                 sizeof (rangeList->ranges[0])
                                 * rangeList->numRanges);
  if (rangeList->partialSymSums)
    rangeList->partialSymSums =
      gt_realloc(rangeList->partialSymSums, sizeof (GtUword)
                 * gt_MRAEncGetSize(rangeList->alphabet)
                 * rangeList->numRanges);
  rangeList->numRangesStorable = rangeList->numRanges;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4afde9
movq 0x18c1e8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x66251(%rip), %rsi     # 0x516013
leaq 0x1073fd(%rip), %rdx    # 0x5b71c6
leaq 0x107400(%rip), %rcx    # 0x5b71d0
leaq 0x1073d5(%rip), %r8     # 0x5b71ac
movl $0x39, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4afdeb
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
shlq $0x4, %rsi
leaq 0x1073a4(%rip), %rdx    # 0x5b71ac
movl $0x3c, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4afe7b
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x22aeb0
movq 0x8(%rsp), %rdi
movzwl %ax, %eax
movl %eax, %esi
shlq $0x3, %rsi
movq 0x10(%rsp), %rax
imulq 0x8(%rax), %rsi
leaq 0x107347(%rip), %rdx    # 0x5b71ac
movl $0x41, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_deleteSeqRangeList
void
gt_deleteSeqRangeList(struct seqRangeList *rangeList)
{
  gt_assert(rangeList);
  if (rangeList->ranges)
    gt_free(rangeList->ranges);
  if (rangeList->partialSymSums)
    gt_free(rangeList->partialSymSums);
  gt_free(rangeList);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4afee4
movq 0x18c0ed(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x66156(%rip), %rsi     # 0x516013
leaq 0x107302(%rip), %rdx    # 0x5b71c6
leaq 0x107313(%rip), %rcx    # 0x5b71de
leaq 0x1072da(%rip), %r8     # 0x5b71ac
movl $0x48, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4afee6
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4aff0a
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x1072ac(%rip), %rsi    # 0x5b71ac
movl $0x4a, %edx
callq 0xe88c0
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4aff2e
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x107288(%rip), %rsi    # 0x5b71ac
movl $0x4c, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x107273(%rip), %rsi    # 0x5b71ac
movl $0x4d, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLAddPosition
void
gt_SRLAddPosition(struct seqRangeList *rangeList, GtUword pos,
                  Symbol esym)
{
  size_t numRanges;
  struct seqRange *lastRange;
  GtUword lastRangeLen;
  unsigned symBits;
  Symbol sym;
  gt_assert(rangeList);
  sym = MRAEncMapSymbol(rangeList->alphabet, esym);
  numRanges = rangeList->numRanges;
  lastRange = rangeList->ranges + numRanges - 1;
  symBits = rangeList->symBits;
  if (numRanges)
    lastRangeLen = seqRangeLen(lastRange, symBits);

  if (numRanges && lastRange->startPos + lastRangeLen > pos)
  {
    /* TODO: search for range */
    gt_SRLinsertNewRange(rangeList, pos, 1, esym);
  }
  else if (numRanges
           && (seqRangeSym(lastRange, symBits) == sym)
           && (lastRange->startPos + lastRangeLen == pos)
           && (lastRangeLen < rangeList->maxRangeLen))
    seqRangeSetLen(lastRange, ++lastRangeLen, symBits);
  else
    gt_SRLAppendNewRange(rangeList, pos, 1, esym);
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x4b07b4
movq 0x18b81d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x65886(%rip), %rsi     # 0x516013
leaq 0x106a32(%rip), %rdx    # 0x5b71c6
leaq 0x106ab4(%rip), %rcx    # 0x5b724f
leaq 0x106a0a(%rip), %r8     # 0x5b71ac
movl $0xbe, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b07b6
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movzbl 0x27(%rsp), %esi
callq 0x4b05e0
movb %al, 0x3(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x4b0820
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x4b06a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x4b0857
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x4b0857
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
movzbl 0x27(%rsp), %ecx
callq 0x4b0700
jmp 0x4b08d6
cmpq $0x0, 0x18(%rsp)
je 0x4b08bb
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x4b06d0
movzbl %al, %eax
movzbl 0x3(%rsp), %ecx
cmpl %ecx, %eax
jne 0x4b08bb
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jne 0x4b08bb
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x4b08bb
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rsp)
movl 0x4(%rsp), %edx
callq 0x4b0660
jmp 0x4b08d4
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
movzbl 0x27(%rsp), %ecx
callq 0x4aff50
jmp 0x4b08d6
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLOverlapsPosition
int
gt_SRLOverlapsPosition(struct seqRangeList *rangeList, GtUword pos,
                    seqRangeListSearchHint *hint, Symbol *symAtPos)
{
  size_t rangeIdx;
  struct seqRange *p;
  gt_assert(rangeList);
  if (hint)
    rangeIdx = *hint;
  else
    rangeIdx = rangeList->numRanges / 2;
  p = rangeList->ranges + rangeIdx;
  if (posIsInSeqRange(p, pos, rangeList->symBits))
  {
    if (symAtPos)
      *symAtPos = MRAEncRevMapSymbol(rangeList->alphabet,
                                     seqRangeSym(p, rangeList->symBits));
    return 1;
  }
  /* TODO: implement "else if" case to also look at next range */
  else
  {
    GtUword searchPos = pos;
    struct seqRange *searchRes =
      gt_bsearch_data(&searchPos, rangeList->ranges, rangeList->numRanges,
                   sizeof (struct seqRange), posSeqRangeOverlapCompare,
                   rangeList);
    if (searchRes)
    {
      if (symAtPos)
        *symAtPos = seqRangeSym(searchRes, rangeList->symBits);
      if (hint)
        *hint = searchRes - rangeList->ranges;
      return 1;
    }
    else
      return 0;
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x4b09b8
movq 0x18b619(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x65682(%rip), %rsi     # 0x516013
leaq 0x10682e(%rip), %rdx    # 0x5b71c6
leaq 0x1068ed(%rip), %rcx    # 0x5b728c
leaq 0x106806(%rip), %r8     # 0x5b71ac
movl $0xf3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b09ba
cmpq $0x0, 0x38(%rsp)
je 0x4b09d1
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x4b09e2
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
shrq %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
movl 0x28(%rax), %edx
callq 0x4b0b10
cmpl $0x0, %eax
je 0x4b0a63
cmpq $0x0, 0x30(%rsp)
je 0x4b0a56
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x4b06d0
movq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x4b0b90
movb %al, %cl
movq 0x30(%rsp), %rax
movb %cl, (%rax)
movl $0x1, 0x54(%rsp)
jmp 0x4b0b01
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x48(%rsp), %r9
leaq 0x18(%rsp), %rdi
movl $0x10, %ecx
leaq 0x13b(%rip), %r8        # 0x4b0bd0
callq 0x8c130
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4b0af9
cmpq $0x0, 0x30(%rsp)
je 0x4b0aca
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x4b06d0
movb %al, %cl
movq 0x30(%rsp), %rax
movb %cl, (%rax)
cmpq $0x0, 0x38(%rsp)
je 0x4b0aef
movq 0x10(%rsp), %rcx
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0x54(%rsp)
jmp 0x4b0b01
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqranges.c
// Function: posSeqRangeOverlapCompare
static int
posSeqRangeOverlapCompare(const void *key, const void *elem, void *data)
{
  GtUword pos;
  const struct seqRange *range;
  const struct seqRangeList *rangeList;
  pos = *(const GtUword *)key;
  range = elem;
  rangeList = data;
  if (pos < range->startPos)
    return -1;
  else if (pos >= range->startPos + seqRangeLen(range, rangeList->symBits))
    return 1;
  else
    return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x4b0c1d
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x4b0c6b
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x4b06a0
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x8(%rsp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x4b0c63
movl $0x1, 0x44(%rsp)
jmp 0x4b0c6b
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqranges.c
// Function: posSeqRangeNextCompare
static int
posSeqRangeNextCompare(const void *key, const void *elem, void *data)
{
  GtUword pos;
  const struct seqRange *range;
  const struct seqRangeList *rangeList;
  pos = *(const GtUword *)key;
  range = elem;
  rangeList = data;
  if (pos < range->startPos)
    if (pos < range[-1].startPos + seqRangeLen(range - 1, rangeList->symBits))
      return -1;
    else
      return 0;
  else if (pos >= range->startPos + seqRangeLen(range, rangeList->symBits))
    return 1;
  else /* pos < range->startPos + range->len  && pos >= range->startPos */
    return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x4b123a
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq -0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
addq $-0x10, %rdi
movq 0x20(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x4b06a0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x4b1230
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x4b1288
movl $0x0, 0x54(%rsp)
jmp 0x4b1288
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x4b06a0
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x8(%rsp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x4b1280
movl $0x1, 0x54(%rsp)
jmp 0x4b1288
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqranges.c
// Function: posSeqRangeLastCompare
static int
posSeqRangeLastCompare(const void *key, const void *elem)
{
  GtUword pos;
  struct seqRange *range;
  pos = *(GtUword *)key;
  range = (struct seqRange *)elem;
  if (pos >= range->startPos)
    if (pos < range[1].startPos)
      return 0;
    else
      return 1;
  else
    return -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x4b1614
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4b160a
movl $0x0, -0x4(%rsp)
jmp 0x4b161c
movl $0x1, -0x4(%rsp)
jmp 0x4b161c
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLSaveToStream
int
gt_SRLSaveToStream(struct seqRangeList *rangeList, FILE *fp)
{
  size_t numRanges;
  gt_assert(rangeList && fp);
  numRanges = rangeList->numRanges;
  gt_xfwrite(&(rangeList->numRanges), sizeof (rangeList->numRanges), 1, fp);
  gt_xfwrite(rangeList->ranges, sizeof (struct seqRange), numRanges, fp);
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4b164e
cmpq $0x0, 0x8(%rsp)
jne 0x4b1686
movq 0x18a94b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x649b4(%rip), %rsi     # 0x516013
leaq 0x105c6b(%rip), %rdx    # 0x5b72d1
leaq 0x105c74(%rip), %rcx    # 0x5b72e1
leaq 0x105b38(%rip), %r8     # 0x5b71ac
movl $0x1cf, %r9d            # imm = 0x1CF
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b1688
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x10, %esi
callq 0x126d30
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-bottomup.c
// Function: gt_GtArrayGtBUItvinfo_new
GtArrayGtBUItvinfo *gt_GtArrayGtBUItvinfo_new(void)
{
  GtArrayGtBUItvinfo *stack = gt_malloc(sizeof (*stack));

  stack->spaceGtBUItvinfo = NULL;
  stack->allocatedGtBUItvinfo = stack->nextfreeGtBUItvinfo = 0;
  return stack;
}

// Assembly:
pushq %rax
movl $0x18, %edi
leaq 0x10456d(%rip), %rsi    # 0x5b73fa
movl $0x3e, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-bottomup.c
// Function: gt_GtArrayGtBUItvinfo_delete
void gt_GtArrayGtBUItvinfo_delete(GtArrayGtBUItvinfo *stack,
                                  GtESAVisitor *ev)
{
  GtUword idx;

  for (idx=0; idx<stack->allocatedGtBUItvinfo; idx++)
  {
    gt_esa_visitor_info_delete(stack->spaceGtBUItvinfo[idx].info, ev);
  }
  gt_free(stack->spaceGtBUItvinfo);
  gt_free(stack);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4b2f24
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x242710
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4b2ee6
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x1044c7(%rip), %rsi    # 0x5b73fa
movl $0x4e, %edx
callq 0xe88c0
movq 0x10(%rsp), %rdi
leaq 0x1044b1(%rip), %rsi    # 0x5b73fa
movl $0x4f, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-bottomup.c
// Function: allocateBUstack
static GtBUItvinfo *allocateBUstack(GtBUItvinfo *ptr,
                                    GtUword currentallocated,
                                    GtUword allocated,
                                    GtESAVisitor *ev)
{
  GtUword idx;
  GtBUItvinfo *itvinfo;

  itvinfo = gt_realloc(ptr,sizeof (*itvinfo) * allocated);
  gt_assert(allocated > currentallocated);
  for (idx=currentallocated; idx<allocated; idx++)
  {
    itvinfo[idx].info = gt_esa_visitor_info_new(ev);
  }
  gt_assert(itvinfo != NULL);
  return itvinfo;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
shlq $0x5, %rsi
leaq 0x1031fd(%rip), %rdx    # 0x5b73fa
movl $0x6a, %ecx
callq 0xe8540
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0x4b4250
movq 0x187d81(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x61dea(%rip), %rsi     # 0x516013
leaq 0xc2c56(%rip), %rdx     # 0x576e86
leaq 0x103210(%rip), %rcx    # 0x5b7447
leaq 0x1031bc(%rip), %r8     # 0x5b73fa
movl $0x6b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b4252
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x4b429a
movq 0x18(%rsp), %rdi
callq 0x242670
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4b425c
jmp 0x4b429c
cmpq $0x0, 0x8(%rsp)
jne 0x4b42dc
movq 0x187cf5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x61d5e(%rip), %rsi     # 0x516013
leaq 0xc2c00(%rip), %rdx     # 0x576ebc
leaq 0x103184(%rip), %rcx    # 0x5b7447
leaq 0x103130(%rip), %r8     # 0x5b73fa
movl $0x70, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b42de
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-dfs.c
// Function: allocItvinfo
static Itvinfo *allocItvinfo(Itvinfo *ptr,
                             GtUword currentallocated,
                             GtUword allocated,
                             Dfsinfo *(*allocateDfsinfo)(Dfsstate *),
                             Dfsstate *state)
{
  GtUword i;
  Itvinfo *itvinfo;

  itvinfo = gt_realloc(ptr,sizeof *ptr * allocated);
  if (allocateDfsinfo != NULL)
  {
    gt_assert(allocated > currentallocated);
    for (i=currentallocated; i<allocated; i++)
    {
      itvinfo[i].dfsinfo = allocateDfsinfo(state);
    }
  }
  gt_assert(itvinfo != NULL);
  return itvinfo;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
imulq $0x18, 0x20(%rsp), %rsi
leaq 0x10145d(%rip), %rdx    # 0x5b748c
movl $0x3f, %ecx
callq 0xe8540
movq %rax, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x4b60d9
jmp 0x4b604b
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0x4b608f
movq 0x185f42(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5ffab(%rip), %rsi     # 0x516013
leaq 0xc0e17(%rip), %rdx     # 0x576e86
leaq 0x101474(%rip), %rcx    # 0x5b74ea
leaq 0x10140f(%rip), %r8     # 0x5b748c
movl $0x42, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b6091
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x4b60d7
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq %rax, %rcx
movq (%rsp), %rax
imulq $0x18, 0x8(%rsp), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4b609b
jmp 0x4b60d9
jmp 0x4b60db
cmpq $0x0, (%rsp)
jne 0x4b611a
movq 0x185eb7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5ff20(%rip), %rsi     # 0x516013
leaq 0xc0dc2(%rip), %rdx     # 0x576ebc
leaq 0x1013e9(%rip), %rcx    # 0x5b74ea
leaq 0x101384(%rip), %r8     # 0x5b748c
movl $0x48, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b611c
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-dfs.c
// Function: freeItvinfo
static void freeItvinfo(Itvinfo *ptr,
                        GtUword allocated,
                        void (*freeDfsinfo)(Dfsinfo *,Dfsstate *),
                        Dfsstate *state)
{
  GtUword i;

  for (i=0; i<allocated; i++)
  {
    freeDfsinfo(ptr[i].dfsinfo,state);
  }
  gt_free(ptr);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x4b6356
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
imulq $0x18, (%rsp), %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4b6320
movq 0x20(%rsp), %rdi
leaq 0x10112a(%rip), %rsi    # 0x5b748c
movl $0x57, %edx
callq 0xe88c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-merge.c
// Function: findlargestnodeleqlcpvalue
static Mergertrienode *findlargestnodeleqlcpvalue(
                                          Mergertrienode *smallest,
                                          GtUword lcpvalue,
                                          GtError *err)
{
  Mergertrienode *tmp;

  gt_error_check(err);
  for (tmp = smallest->parent; tmp != NULL; tmp = tmp->parent)
  {
    if (tmp->depth <= lcpvalue)
    {
      return tmp;
    }
  }
  gt_error_set(err,"path does not contain a node of depth <= "GT_WU"",
                lcpvalue);
  return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4b69b3
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4b697b
jmp 0x4b69b3
movq 0x18561e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5f687(%rip), %rsi     # 0x516013
leaq 0x5f82c(%rip), %rdx     # 0x5161bf
leaq 0x100c23(%rip), %rcx    # 0x5b75bd
leaq 0x100b8c(%rip), %r8     # 0x5b752d
movl $0x78, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b69b5
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x4b69f3
movq (%rsp), %rax
movq 0x28(%rax), %rax
cmpq 0x10(%rsp), %rax
ja 0x4b69e3
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x4b6a14
jmp 0x4b69e5
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
jmp 0x4b69c2
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x100bd4(%rip), %rsi    # 0x5b75d8
movb $0x0, %al
callq 0xd88c0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-merge.c
// Function: inputthesequences
static int inputthesequences(unsigned int *numofchars,
                             GtUword *nextpostable,
                             Suffixarray *suffixarraytable,
                             const GtStrArray *indexnametab,
                             unsigned int demand,
                             GtLogger *logger,
                             GtError *err)
{
  GtUword idx;
  const char *indexname;

  gt_error_check(err);
  for (idx=0; idx<gt_str_array_size(indexnametab); idx++)
  {
    indexname = gt_str_array_get(indexnametab,idx);
    if (streamsuffixarray(&suffixarraytable[idx],
                          demand,
                          indexname,
                          logger,
                          err) != 0)
    {
      return -1;
    }
    if (idx == 0)
    {
      *numofchars =
            gt_alphabet_num_of_chars(
                     gt_encseq_alphabet(suffixarraytable[idx].encseq));
    }
    nextpostable[idx] = 0;
  }
  return 0;
}

// Assembly:
subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x4b6e87
movq 0x60(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4b6e4f
jmp 0x4b6e87
movq 0x18514a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5f1b3(%rip), %rsi     # 0x516013
leaq 0x5f358(%rip), %rdx     # 0x5161bf
leaq 0x100797(%rip), %rcx    # 0x5b7605
leaq 0x1006b8(%rip), %r8     # 0x5b752d
movl $0x3a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b6e89
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4b6f5a
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11f8c0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rax
shlq $0x8, %rax
addq %rax, %rdi
movl 0x2c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x60(%rsp), %r8
callq 0x233500
cmpl $0x0, %eax
je 0x4b6f03
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x4b6f62
cmpq $0x0, 0x18(%rsp)
jne 0x4b6f35
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0xb0f00
movq %rax, %rdi
callq 0x7e8c0
movl %eax, %ecx
movq 0x48(%rsp), %rax
movl %ecx, (%rax)
movq 0x40(%rsp), %rax
movq 0x18(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4b6e92
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-merge.c
// Function: insertfirstsuffixes
static int insertfirstsuffixes(Mergertrierep *trierep,
                               GtUword *nextpostable,
                               Suffixarray *suffixarraytable,
                               unsigned int numofindexes,
                               GtError *err)
{
  unsigned int idx;
  GtUword suftabvalue;
  int retval;

  gt_error_check(err);
  for (idx=0; idx<numofindexes; idx++)
  {
    retval
      = gt_readnextfromstream_GtUword(&suftabvalue,
                                  &suffixarraytable[idx].suftabstream_GtUword);
    if (retval == 0)
    {
      gt_error_set(err,"file %s: line %d: unexpected end of file when "
                        "reading suftab",__FILE__,__LINE__);
      return -2;
    }
    nextpostable[idx]++;
    fillandinsert(trierep,
                  idx,
                  suftabvalue,
                  trierep->root,
                  (uint64_t) idx);
  }
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x4b6fdc
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4b6fa4
jmp 0x4b6fdc
movq 0x184ff5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5f05e(%rip), %rsi     # 0x516013
leaq 0x5f203(%rip), %rdx     # 0x5161bf
leaq 0x100654(%rip), %rcx    # 0x5b7617
leaq 0x100563(%rip), %r8     # 0x5b752d
movl $0x5b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b6fde
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x4b7091
movq 0x28(%rsp), %rsi
movl 0x14(%rsp), %eax
shlq $0x8, %rax
addq %rax, %rsi
addq $0xa0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x4b6a20
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x4b7049
movq 0x18(%rsp), %rdi
leaq 0x100554(%rip), %rsi    # 0x5b7580
leaq 0x1004fa(%rip), %rdx    # 0x5b752d
movl $0x64, %ecx
movb $0x0, %al
callq 0xd88c0
movl $0xfffffffe, 0x44(%rsp) # imm = 0xFFFFFFFE
jmp 0x4b7099
movq 0x30(%rsp), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x38(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rcx
movl 0x14(%rsp), %eax
movl %eax, %r8d
callq 0x4b6b00
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4b6fe6
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-merge.c
// Function: gt_emissionmergedesa_wrap
void gt_emissionmergedesa_wrap(Emissionmergedesa *emmesa)
{
  unsigned int idx;

  for (idx = 0; idx < emmesa->numofindexes; idx++)
  {
    gt_freesuffixarray(emmesa->suffixarraytable + idx);
  }
  gt_free(emmesa->suffixarraytable);
  gt_free(emmesa->trierep.encseqreadinfo);
  emmesa->trierep.encseqreadinfo = NULL;
  if (emmesa->numofindexes > 1U)
  {
    gt_mergertrie_delete(&emmesa->trierep);
  }
  gt_free(emmesa->nextpostable);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x4b70f8
movq 0x10(%rsp), %rax
movq 0x30058(%rax), %rdi
movl 0xc(%rsp), %eax
shlq $0x8, %rax
addq %rax, %rdi
callq 0x233320
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4b70c1
movq 0x10(%rsp), %rax
movq 0x30058(%rax), %rdi
leaq 0x100422(%rip), %rsi    # 0x5b752d
movl $0x12f, %edx            # imm = 0x12F
callq 0xe88c0
movq 0x10(%rsp), %rax
movq 0x30028(%rax), %rdi
leaq 0x100405(%rip), %rsi    # 0x5b752d
movl $0x130, %edx            # imm = 0x130
callq 0xe88c0
movq 0x10(%rsp), %rax
movq $0x0, 0x30028(%rax)
movq 0x10(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jbe 0x4b715e
movq 0x10(%rsp), %rdi
addq $0x30028, %rdi          # imm = 0x30028
callq 0x4d2df0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x1003bf(%rip), %rsi    # 0x5b752d
movl $0x136, %edx            # imm = 0x136
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-accum.c
// Function: gt_firstcodes_accum_runkmerscan
void gt_firstcodes_accum_runkmerscan(const GtEncseq *encseq,
                                     unsigned int kmersize,
                                     unsigned int minmatchlength,
                                     GtCodeposbuffer *buf)
{
  const GtTwobitencoding *twobitencoding
    = gt_encseq_twobitencoding_export(encseq);
  GtUword totallength, maxunitindex;

  if (gt_encseq_is_mirrored(encseq))
  {
    totallength = (gt_encseq_total_length(encseq)-1)/2;
  } else
  {
    totallength = gt_encseq_total_length(encseq);
  }
  maxunitindex = gt_unitsoftwobitencoding(totallength) - 1;
  if (gt_encseq_accesstype_get(encseq) == GT_ACCESS_TYPE_EQUALLENGTH)
  {
    GtUword equallength = gt_encseq_equallength(encseq);

    gt_assert(equallength >= (GtUword) kmersize);
    gt_firstcodes_accum_kmerscan_eqlen(twobitencoding,
                                       equallength,
                                       totallength,
                                       maxunitindex,
                                       kmersize,
                                       minmatchlength,
                                       buf);
  } else
  {
    gt_firstcodes_accum_kmerscan(encseq,
                                 twobitencoding,
                                 totallength,
                                 maxunitindex,
                                 kmersize,
                                 minmatchlength,
                                 buf);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0xb5250
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc2ec0
testb $0x1, %al
jne 0x4b71b5
jmp 0x4b71cd
movq 0x40(%rsp), %rdi
callq 0xa9d00
subq $0x1, %rax
shrq %rax
movq %rax, 0x20(%rsp)
jmp 0x4b71dc
movq 0x40(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4b72c0
subq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc2d90
cmpl $0x2, %eax
jne 0x4b7287
movq 0x40(%rsp), %rdi
callq 0xc2da0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x3c(%rsp), %ecx
cmpq %rcx, %rax
jae 0x4b7257
movq 0x184d7a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5ede3(%rip), %rsi     # 0x516013
leaq 0x100471(%rip), %rdx    # 0x5b76a8
leaq 0x10048c(%rip), %rcx    # 0x5b76ca
leaq 0x1004a5(%rip), %r8     # 0x5b76ea
movl $0xc4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b7259
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x3c(%rsp), %r8d
movl 0x38(%rsp), %r9d
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x4b7320
jmp 0x4b72b3
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x3c(%rsp), %r8d
movl 0x38(%rsp), %r9d
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x4b73b0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-accum.c
// Function: gt_firstcodes_accum_kmerscan_eqlen
static void gt_firstcodes_accum_kmerscan_eqlen(
                                     const GtBitsequence *twobitencoding,
                                     GtUword equallength,
                                     GtUword totallength,
                                     GtUword maxunitindex,
                                     unsigned int kmersize,
                                     unsigned int minmatchlength,
                                     GtCodeposbuffer *buf)
{
  GtUword startpos;

  if (equallength >= (GtUword) kmersize)
  {
    for (startpos = 0; startpos < totallength; startpos += equallength+1)
    {
      gt_firstcodes_accum_kmerscan_range(twobitencoding,
                                         kmersize,
                                         minmatchlength,
                                         startpos,
                                         equallength,
                                         maxunitindex,
                                         buf);
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0x14(%rsp), %ecx
cmpq %rcx, %rax
jb 0x4b73ab
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x4b73a9
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x4b7550
movq 0x28(%rsp), %rax
addq $0x1, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x4b735e
jmp 0x4b73ab
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-cache.c
// Function: gt_firstcodes_binsearchcache_set_index_code
void gt_firstcodes_binsearchcache_set_index_code(GtArrayGtIndexwithcode
                                                 *binsearchcache,
                                                 GtUword afcindex,
                                                 GtUword code)
{
  if (binsearchcache->nextfreeGtIndexwithcode <
      binsearchcache->allocatedGtIndexwithcode)
  {
    binsearchcache->spaceGtIndexwithcode
      [binsearchcache->nextfreeGtIndexwithcode].afcindex = afcindex;
    binsearchcache->spaceGtIndexwithcode
      [binsearchcache->nextfreeGtIndexwithcode++].code = code;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x4ba83f
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rsp), %rdx
movq 0x10(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x10(%rsi), %rdx
movq %rdx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-cache.c
// Function: gt_firstcodes_binsearchcache_check
void gt_firstcodes_binsearchcache_check(GtArrayGtIndexwithcode *binsearchcache,
                                       GT_UNUSED const GtUword
                                                                 *allfirstcodes,
                                       GtUword differentcodes)
{
  if (binsearchcache != NULL)
  {
    GtUword idx, current = binsearchcache->width;

    gt_assert(binsearchcache->spaceGtIndexwithcode != NULL);
    for (idx=0; idx < binsearchcache->nextfreeGtIndexwithcode &&
                current < differentcodes; idx++)
    {
      gt_assert(binsearchcache->spaceGtIndexwithcode[idx].afcindex == current);
      gt_assert(binsearchcache->spaceGtIndexwithcode[idx].code
                == allfirstcodes[current]);
      current += binsearchcache->width;
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x4ba9d5
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x4ba8b0
movq 0x181721(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5b78a(%rip), %rsi     # 0x516013
leaq 0xfcf8d(%rip), %rdx     # 0x5b781d
leaq 0xfcfb3(%rip), %rcx     # 0x5b784a
leaq 0xfcf01(%rip), %r8      # 0x5b779f
movl $0x71, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ba8b2
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, 0xf(%rsp)
jae 0x4ba8e2
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4ba8ef
jmp 0x4ba9d3
jmp 0x4ba8f1
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
je 0x4ba947
movq 0x18168a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5b6f3(%rip), %rsi     # 0x516013
leaq 0xfcf46(%rip), %rdx     # 0x5b786d
leaq 0xfcf1c(%rip), %rcx     # 0x5b784a
leaq 0xfce6a(%rip), %r8      # 0x5b779f
movl $0x75, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ba949
jmp 0x4ba94b
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x4ba9ab
movq 0x181626(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x5b68f(%rip), %rsi     # 0x516013
leaq 0xfcf20(%rip), %rdx     # 0x5b78ab
leaq 0xfceb8(%rip), %rcx     # 0x5b784a
leaq 0xfce06(%rip), %r8      # 0x5b779f
movl $0x77, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ba9ad
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4ba8bb
jmp 0x4ba9d5
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-cache.c
// Function: gt_firstcodes_binsearchcache_delete
void gt_firstcodes_binsearchcache_delete(GtArrayGtIndexwithcode *binsearchcache,
                                         GtFirstcodesspacelog *fcsl)
{
  if (binsearchcache != NULL)
  {
    if (binsearchcache->spaceGtIndexwithcode != NULL)
    {
      GT_FCI_SUBTRACTWORKSPACE(fcsl,"binsearchcache");
      GT_FREEARRAY(binsearchcache,GtIndexwithcode);
    }
    gt_free (binsearchcache);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4baa98
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x4baa82
movq 0x8(%rsp), %rdi
movl $0x84, %esi
leaq 0xfcd89(%rip), %rdx     # 0x5b779f
xorl %ecx, %ecx
leaq 0xc45a9(%rip), %r8      # 0x57efc8
movl $0x1, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x4bea60
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x4baa7e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0xfcd51(%rip), %rsi     # 0x5b779f
movl $0x85, %edx
callq 0xe88c0
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
jmp 0x4baa80
jmp 0x4baa82
movq 0x10(%rsp), %rdi
leaq 0xfcd11(%rip), %rsi     # 0x5b779f
movl $0x87, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-insert.c
// Function: gt_firstcodes_insert_kmerscan_eqlen
static void gt_firstcodes_insert_kmerscan_eqlen(
                                     const GtBitsequence *twobitencoding,
                                     GtUword equallength,
                                     GtUword totallength,
                                     GtUword numofsequences,
                                     GtUword maxunitindex,
                                     unsigned int kmersize,
                                     unsigned int minmatchlength,
                                     GtCodeposbuffer *buf)
{
  GtUword startpos, fseqnum;

  if (equallength >= (GtUword) kmersize)
  {
    for (startpos = 0, fseqnum = 0; startpos < totallength;
         startpos += equallength+1, fseqnum++)
    {
      gt_firstcodes_insert_kmerscan_range(twobitencoding,
                                          kmersize,
                                          minmatchlength,
                                          startpos,
                                          equallength,
                                          fseqnum,
                                          numofsequences - 1 - fseqnum,
                                          maxunitindex,
                                          buf);
    }
  }
}

// Assembly:
subq $0x58, %rsp
movq 0x68(%rsp), %rax
movl 0x60(%rsp), %eax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x48(%rsp), %rax
movl 0x2c(%rsp), %ecx
cmpq %rcx, %rax
jb 0x4bb307
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x4bb305
movq 0x50(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x60(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x38(%rsp), %r11
subq $0x1, %r11
subq 0x18(%rsp), %r11
movq 0x30(%rsp), %r10
movq 0x68(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x4bb520
movq 0x48(%rsp), %rax
addq $0x1, %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4bb28f
jmp 0x4bb307
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_spacelog_new
GtFirstcodesspacelog *gt_firstcodes_spacelog_new(void)
{
  GtFirstcodesspacelog *fcsl;

  fcsl = gt_malloc(sizeof (GtFirstcodesspacelog));
  fcsl->workspace = fcsl->splitspace = 0;
  fcsl->nextfree = fcsl->allocated = 0;
  fcsl->spacepeak = 0;
  fcsl->max_percent_difference = 0.0;
  fcsl->calc_difference = false;
  fcsl->entries = NULL;
  return fcsl;
}

// Assembly:
pushq %rax
movl $0x40, %edi
leaq 0xf92e9(%rip), %rsi     # 0x5b7af6
movl $0x34, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movq (%rsp), %rax
movb $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_spacelog_showentries
bool gt_firstcodes_spacelog_showentries(FILE *fp,
                                        const GtFirstcodesspacelog *fcsl)
{
  GtUword idx;
  bool foundnonempty = false;

  for (idx = 0; idx < fcsl->nextfree; idx++)
  {
    if (fcsl->entries[idx].size > 0)
    {
      fprintf(fp,"%s %d %s %s "GT_WU"\n",
               fcsl->entries[idx].filename,
               fcsl->entries[idx].line,
               fcsl->entries[idx].title,
               fcsl->entries[idx].work ? "work" : "split",
               (GtUword) fcsl->entries[idx].size);
      foundnonempty = true;
    }
  }
  return foundnonempty;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0xf(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x4be9f0
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
imulq $0x28, 0x10(%rsp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x18(%rax)
jbe 0x4be9db
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
imulq $0x28, 0x10(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
imulq $0x28, 0x10(%rsp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
imulq $0x28, 0x10(%rsp), %rsi
addq %rsi, %rax
movq 0x10(%rax), %r8
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
imulq $0x28, 0x10(%rsp), %rsi
addq %rsi, %rax
movb 0x20(%rax), %sil
leaq 0x57dd9(%rip), %r9      # 0x516778
leaq 0xf9181(%rip), %rax     # 0x5b7b27
testb $0x1, %sil
cmovneq %rax, %r9
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
imulq $0x28, 0x10(%rsp), %rsi
addq %rsi, %rax
movq 0x18(%rax), %rax
leaq 0xf914b(%rip), %rsi     # 0x5b7b16
movq %rax, (%rsp)
movb $0x0, %al
callq 0x199f0
movb $0x1, 0xf(%rsp)
jmp 0x4be9dd
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4be90c
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_spacelog_delete
void gt_firstcodes_spacelog_delete(GtFirstcodesspacelog *fcsl)
{
  if (fcsl != NULL)
  {
#ifdef SKDEBUG
    if (gt_firstcodes_spacelog_showentries(stderr,fcsl))
    {
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    gt_log_log("maximal difference between estimated and real space = %.2f%%",
               fcsl->max_percent_difference);
    gt_free(fcsl->entries);
    gt_free(fcsl);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4bea51
movq (%rsp), %rax
movsd 0x18(%rax), %xmm0
leaq 0xf9110(%rip), %rdi     # 0x5b7b2c
movb $0x1, %al
callq 0xe7740
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0xf90c4(%rip), %rsi     # 0x5b7af6
movl $0xa5, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0xf90af(%rip), %rsi     # 0x5b7af6
movl $0xa6, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_spacelog_find
static GtFirstcodespacelogentry *gt_spacelog_find(GtFirstcodesspacelog *fcsl,
                                                  const char *title)
{
  GtUword idx;

  for (idx = 0; idx < fcsl->nextfree; idx++)
  {
    if (strcmp(fcsl->entries[idx].title,title) == 0)
    {
      return fcsl->entries + idx;
    }
  }
  return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x4bef57
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
imulq $0x28, 0x8(%rsp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x19980
cmpl $0x0, %eax
jne 0x4bef45
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
imulq $0x28, 0x8(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x4bef60
jmp 0x4bef47
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4beef7
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_spacelog_updateaddentry
static void gt_spacelog_updateaddentry(GtFirstcodespacelogentry *entry,
                                       const char *filename,int line,
                                       const char *title,size_t size,
                                       bool work)
{
  entry->filename = filename;
  entry->line = line;
  entry->title = title;
  entry->size = size;
  entry->work = work;
}

// Assembly:
movb %r9b, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
andb $0x1, %al
movb %al, -0x29(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movb -0x29(%rsp), %cl
movq -0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
retq
nopw %cs:(%rax,%rax)