LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_reset_counts
void gt_diagband_struct_reset_counts(const GtDiagbandStruct *diagband_struct,
                                     FILE *stream)
{
  fprintf(stream,"# number of resets of all used diagonal bands: " GT_WU,
          diagband_struct->reset_with_memset +
          diagband_struct->reset_from_matches);
  if (diagband_struct->reset_with_memset > 0)
  {
    fprintf(stream,"; simple resets: " GT_WU,
            diagband_struct->reset_with_memset);
  }
  if (diagband_struct->reset_from_matches > 0)
  {
    fprintf(stream,"; resets from matches: " GT_WU,
            diagband_struct->reset_from_matches);
  }
  fprintf(stream,"\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdx
addq 0x28(%rdi), %rdx
leaq 0xda271(%rip), %rsi     # 0x380a4d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17a50
movq 0x28(%r14), %rdx
testq %rdx, %rdx
je 0x2a6800
leaq 0xda28a(%rip), %rsi     # 0x380a80
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17a50
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x2a681a
leaq 0xda285(%rip), %rsi     # 0x380a95
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17a50
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17930
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_delete
void gt_diagband_struct_delete(GtDiagbandStruct *diagband_struct)
{
  if (diagband_struct != NULL)
  {
    diagband_struct->score--; /* need to recover original base adress */
    gt_free(diagband_struct->score);
    gt_free(diagband_struct->lastpos);
    gt_free(diagband_struct);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2a687a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
addq $-0x4, %rdi
movq %rdi, 0x30(%rbx)
leaq 0xda1e6(%rip), %r14     # 0x380a31
pushq $0x64
popq %rdx
movq %r14, %rsi
callq 0x936f9
movq 0x38(%rbx), %rdi
pushq $0x65
popq %rdx
movq %r14, %rsi
callq 0x936f9
pushq $0x66
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_single_update
void gt_diagband_struct_single_update(GtDiagbandStruct *diagband_struct,
                                      GtDiagbandseedPosition apos,
                                      GtDiagbandseedPosition bpos,
                                      GtDiagbandseedPosition matchlength)
{
  GtUword diagband_idx;

  gt_assert(diagband_struct != NULL);
  diagband_idx = GT_DIAGBANDSEED_DIAGONALBAND(diagband_struct->amaxlen,
                                              diagband_struct->logdiagbandwidth,
                                              apos,
                                              bpos);
  gt_assert(diagband_idx < diagband_struct->num_diagbands);
  if (diagband_struct->lastpos[diagband_idx] == 0 /* first matches */||
      /* match with end position bpos begins strictly after previous match */
      diagband_struct->lastpos[diagband_idx] + matchlength <= bpos)
  {
    /* no overlap */
    diagband_struct->lastpos[diagband_idx] = bpos;
    if (diagband_struct->score[diagband_idx] == 0)
    {
      diagband_struct->used_diagbands++;
    }
    diagband_struct->score[diagband_idx] += matchlength;
  } else
  {
    /* overlap: add positions after last counted position */
    if (diagband_struct->lastpos[diagband_idx] < bpos)
    {
      const GtUword addlength = bpos - diagband_struct->lastpos[diagband_idx];

      diagband_struct->lastpos[diagband_idx] = bpos;
      if (diagband_struct->score[diagband_idx] == 0)
      {
        diagband_struct->used_diagbands++;
      }
      diagband_struct->score[diagband_idx] += addlength;
    }
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2a68fa
movl %ecx, %eax
movl %edx, %r8d
movl %esi, %ecx
subq %rcx, %r8
addq (%rdi), %r8
movb 0x8(%rdi), %cl
shrq %cl, %r8
cmpq 0x10(%rdi), %r8
jae 0x2a6924
movq 0x38(%rdi), %rcx
movl (%rcx,%r8,4), %esi
testl %esi, %esi
setne %r9b
leal (%rsi,%rax), %r10d
cmpl %edx, %r10d
seta %r10b
testb %r10b, %r9b
je 0x2a68de
movl %edx, %eax
subl %esi, %eax
jbe 0x2a68f8
movl %edx, (%rcx,%r8,4)
movq 0x30(%rdi), %rcx
movl (%rcx,%r8,4), %edx
testl %edx, %edx
jne 0x2a68d6
incq 0x18(%rdi)
addl %edx, %eax
movl %eax, (%rcx,%r8,4)
jmp 0x2a68f8
movl %edx, (%rcx,%r8,4)
movq 0x30(%rdi), %rcx
movl (%rcx,%r8,4), %edx
testl %edx, %edx
jne 0x2a68f2
incq 0x18(%rdi)
addl %eax, %edx
movl %edx, (%rcx,%r8,4)
popq %rax
retq
movq 0x191667(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e708(%rip), %rsi     # 0x2e5013
leaq 0xda19e(%rip), %rdx     # 0x380ab0
leaq 0xda1af(%rip), %rcx     # 0x380ac8
leaq 0xda111(%rip), %r8      # 0x380a31
pushq $0x71
jmp 0x2a694c
movq 0x19163d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e6de(%rip), %rsi     # 0x2e5013
leaq 0xda1ad(%rip), %rdx     # 0x380ae9
leaq 0xda185(%rip), %rcx     # 0x380ac8
leaq 0xda0e7(%rip), %r8      # 0x380a31
pushq $0x76
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_coverage
GtUword gt_diagband_struct_coverage(const GtDiagbandStruct *diagband_struct,
                                    GtDiagbandseedPosition apos,
                                    GtDiagbandseedPosition bpos)
{
  GtUword diagband_idx;

  gt_assert(diagband_struct != NULL);
  diagband_idx = GT_DIAGBANDSEED_DIAGONALBAND(diagband_struct->amaxlen,
                                              diagband_struct->logdiagbandwidth,
                                              apos, bpos);
  return gt_diagband_struct_dband_coverage(diagband_struct,diagband_idx);
}

// Assembly:
testq %rdi, %rdi
je 0x2a6987
movl %edx, %eax
movl %esi, %ecx
subq %rcx, %rax
addq (%rdi), %rax
movb 0x8(%rdi), %cl
shrq %cl, %rax
movq 0x30(%rdi), %rcx
movl 0x4(%rcx,%rax,4), %edx
movl -0x4(%rcx,%rax,4), %esi
cmpl %esi, %edx
cmoval %edx, %esi
movl (%rcx,%rax,4), %eax
addq %rsi, %rax
retq
pushq %rax
movq 0x1915d9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e67a(%rip), %rsi     # 0x2e5013
leaq 0xda110(%rip), %rdx     # 0x380ab0
leaq 0xda170(%rip), %rcx     # 0x380b17
leaq 0xda083(%rip), %r8      # 0x380a31
movl $0xa3, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_multi_update
void gt_diagband_struct_multi_update(GtDiagbandStruct *diagband_struct,
                                     const GtDiagbandseedMaximalmatch *memstore,
                                     GtUword numofmatches)
{
  GtUword idx;

  gt_assert(memstore != NULL);
  for (idx = 0; idx < numofmatches; idx++)
  {
    gt_diagband_struct_single_update(diagband_struct,
                                     memstore[idx].apos,
                                     memstore[idx].bpos,
                                     memstore[idx].len);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2a69fc
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r14
subq $0x1, %rbx
jb 0x2a69f6
movl -0x8(%r14), %esi
movl -0x4(%r14), %edx
movl (%r14), %ecx
movq %r15, %rdi
callq 0x2a687b
addq $0xc, %r14
jmp 0x2a69d7
popq %rbx
popq %r14
popq %r15
retq
movq 0x191565(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e606(%rip), %rsi     # 0x2e5013
leaq 0xda11f(%rip), %rdx     # 0x380b33
leaq 0xda129(%rip), %rcx     # 0x380b44
leaq 0xda00f(%rip), %r8      # 0x380a31
movl $0xb0, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_statistics_new
GtDiagbandStatistics *gt_diagband_statistics_new(const GtStr
                                                   *diagband_distance_arg,
                                                 bool forward)
{
  const char *arg = gt_str_get(diagband_distance_arg);
  GtDiagbandStatistics *diagband_statistics
    = gt_malloc(sizeof *diagband_statistics);

  diagband_statistics->forward = forward;
  diagband_statistics->compute_sum = false;
  if (strcmp(arg,"sum") == 0)
  {
    diagband_statistics->compute_sum = true;
  } else
  {
    gt_assert(false);
  }
  diagband_statistics->sumscore = 0;
  diagband_statistics->track = NULL;
  return diagband_statistics;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
callq 0xad1fa
movq %rax, %r14
leaq 0xd9ebe(%rip), %rsi     # 0x380a31
pushq $0x18
popq %rdi
movl $0xf8, %edx
callq 0x93160
movq %rax, %rbx
movb %bpl, 0x1(%rax)
movb $0x0, (%rax)
leaq 0x4f5c6(%rip), %rsi     # 0x2f6157
movq %r14, %rdi
callq 0x179e0
testl %eax, %eax
jne 0x2a6baf
movb $0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x1913b2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e453(%rip), %rsi     # 0x2e5013
leaq 0x7fe25(%rip), %rdx     # 0x3269ec
leaq 0xd9faf(%rip), %rcx     # 0x380b7d
leaq 0xd9e5c(%rip), %r8      # 0x380a31
movl $0x101, %r9d            # imm = 0x101
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_statistics_display
void gt_diagband_statistics_display(const GtDiagbandStatistics
                                           *diagband_statistics)
{
  gt_assert(diagband_statistics != NULL);
  if (diagband_statistics->compute_sum)
  {
    printf("# forward=%s, sum_diagband_score=" GT_WU "\n",
            diagband_statistics->forward ? "true" : "false",
            diagband_statistics->sumscore);
  } else
  {
    gt_assert(false);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2a6c57
cmpb $0x1, (%rdi)
jne 0x2a6c85
leaq 0x9b38f(%rip), %rax     # 0x341fc4
leaq 0x7fdb0(%rip), %rsi     # 0x3269ec
cmpb $0x0, 0x1(%rdi)
cmovneq %rax, %rsi
movq 0x8(%rdi), %rdx
leaq 0xd9f84(%rip), %rdi     # 0x380bd3
xorl %eax, %eax
popq %rcx
jmp 0x17070
movq 0x19130a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e3ab(%rip), %rsi     # 0x2e5013
leaq 0xd9f29(%rip), %rdx     # 0x380b98
leaq 0xd9f3e(%rip), %rcx     # 0x380bb4
leaq 0xd9db4(%rip), %r8      # 0x380a31
movl $0x114, %r9d            # imm = 0x114
jmp 0x2a6cb1
movq 0x1912dc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e37d(%rip), %rsi     # 0x2e5013
leaq 0x7fd4f(%rip), %rdx     # 0x3269ec
leaq 0xd9f10(%rip), %rcx     # 0x380bb4
leaq 0xd9d86(%rip), %r8      # 0x380a31
movl $0x11c, %r9d            # imm = 0x11C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/dist-short.c
// Function: gt_distanceofshortstringsbytearray
GtUword gt_distanceofshortstringsbytearray(GtUword *eqsvector,
                                              unsigned int alphasize,
                                              const GtUchar *useq,
                                              GtUword ulen,
                                              const GtUchar *vseq,
                                              GtUword vlen)
{
  DECLARELOCALVARS;
  const GtUchar *vptr;

  gt_initeqsvector(eqsvector,(GtUword) alphasize,useq,ulen);
  for (vptr = vseq; vptr < vseq + vlen; vptr++)
  {
    COMPUTENEWDIST(*vptr);
  }
  return distval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %r12
decl %ecx
pushq $0x1
popq %r13
movq %r13, %rbp
shlq %cl, %rbp
movl %esi, %esi
movq %r14, %rcx
callq 0x2c08f8
addq %r15, %rbx
pushq $-0x1
popq %rax
xorl %ecx, %ecx
cmpq %rbx, %r15
jae 0x2a6ec6
movzbl (%r15), %edx
cmpl $0xfe, %edx
je 0x2a6e60
cmpl $0xff, %edx
je 0x2a6ed8
movq (%r12,%rdx,8), %rdi
jmp 0x2a6e62
xorl %edi, %edi
movq %rdi, %rdx
orq %rcx, %rdx
movq %rdi, %rsi
andq %rax, %rsi
addq %rax, %rsi
xorq %rax, %rsi
orq %rdi, %rsi
movq %rsi, %rdi
orq %rax, %rdi
notq %rdi
orq %rcx, %rdi
andq %rax, %rsi
movq %rsi, %rax
andq %rbp, %rax
negq %rax
movl $0x0, %eax
sbbq %rax, %rax
testq %rbp, %rdi
cmovneq %r13, %rax
addq %rax, %r14
leaq 0x1(,%rdi,2), %rcx
addq %rsi, %rsi
movq %rcx, %rax
orq %rdx, %rax
notq %rax
orq %rsi, %rax
andq %rcx, %rdx
incq %r15
movq %rdx, %rcx
jmp 0x2a6e3d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x191089(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e12a(%rip), %rsi     # 0x2e5013
leaq 0xd9d24(%rip), %rdx     # 0x380c14
leaq 0xd9d3f(%rip), %rcx     # 0x380c36
leaq 0xd9d5b(%rip), %r8      # 0x380c59
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/dist-short.c
// Function: gt_distanceofshortstringsencseq
GtUword gt_distanceofshortstringsencseq(GtUword *eqsvector,
                                           unsigned int alphasize,
                                           const GtUchar *useq,
                                           GtUword ulen,
                                           const GtEncseq *encseq,
                                           GtUword vstartpos,
                                           GtUword vlen)
{
  DECLARELOCALVARS;
  GtUchar cc;
  GtUword pos;

  gt_initeqsvector(eqsvector,(GtUword) alphasize,useq,ulen);
  for (pos = vstartpos; pos < vstartpos + vlen; pos++)
  {
    cc = gt_encseq_get_encoded_char(encseq,pos,GT_READMODE_FORWARD);
    COMPUTENEWDIST(cc);
  }
  return distval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %r14
decl %ecx
pushq $0x1
popq %rbp
shlq %cl, %rbp
movl %esi, %esi
movq %rdi, 0x8(%rsp)
movq %r14, %rcx
callq 0x2c08f8
movq 0x50(%rsp), %r13
addq %rbx, %r13
pushq $-0x1
popq %r12
xorl %r15d, %r15d
cmpq %r13, %rbx
jae 0x2a6feb
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x705e4
cmpb $-0x2, %al
je 0x2a6f82
movzbl %al, %eax
cmpl $0xff, %eax
je 0x2a6ffd
movq 0x8(%rsp), %rcx
movq (%rcx,%rax,8), %rdx
jmp 0x2a6f84
xorl %edx, %edx
movq %rdx, %rax
orq %r15, %rax
movq %rdx, %rcx
andq %r12, %rcx
addq %r12, %rcx
xorq %r12, %rcx
orq %rdx, %rcx
movq %rcx, %rdx
orq %r12, %rdx
notq %rdx
orq %r15, %rdx
andq %r12, %rcx
movq %rcx, %rsi
andq %rbp, %rsi
negq %rsi
movl $0x0, %esi
sbbq %rsi, %rsi
testq %rbp, %rdx
pushq $0x1
popq %rdi
cmovneq %rdi, %rsi
addq %rsi, %r14
leaq 0x1(,%rdx,2), %rdx
addq %rcx, %rcx
movq %rdx, %r12
orq %rax, %r12
notq %r12
orq %rcx, %r12
andq %rdx, %rax
incq %rbx
movq %rax, %r15
jmp 0x2a6f4d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x190f64(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3e005(%rip), %rsi     # 0x2e5013
leaq 0xd9c5b(%rip), %rdx     # 0x380c70
leaq 0xd9c73(%rip), %rcx     # 0x380c8f
leaq 0xd9c36(%rip), %r8      # 0x380c59
pushq $0x69
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/dist-short.c
// Function: gt_reversesuffixmatch
GtUword gt_reversesuffixmatch(GtUword *eqsvector,
                                 unsigned int alphasize,
                                 const GtUchar *useq,
                                 GtUword ulen,
                                 const GtUchar *vseq,
                                 GtUword vlen,
                                 GtUword maxdistance)
{
  DECLARELOCALVARS;
  const GtUchar *vptr;

  gt_initeqsvectorrev(eqsvector,(GtUword) alphasize,useq,ulen);
  gt_assert(maxdistance > 0);
  for (vptr = vseq + vlen - 1; vptr >= vseq; vptr--)
  {
    COMPUTENEWDIST(*vptr);
    if (distval <= maxdistance)
    {
      break;
    }
  }
  /* gt_assert(distval <= maxdistance); */
  return (GtUword) (vseq + vlen - vptr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
decl %ecx
pushq $0x1
popq %r13
movq %r13, %rbp
shlq %cl, %rbp
movl %esi, %esi
movq %r15, %rcx
callq 0x2c09a6
movq 0x40(%rsp), %r9
testq %r9, %r9
je 0x2a7153
addq %r14, %rbx
pushq $-0x1
popq %rax
xorl %ecx, %ecx
movq %rax, %rsi
leaq (%rbx,%rax), %rdx
cmpq %r14, %rdx
jb 0x2a710b
movzbl (%rdx), %edx
cmpl $0xfe, %edx
je 0x2a70a3
cmpl $0xff, %edx
je 0x2a711d
movq (%r12,%rdx,8), %rdx
jmp 0x2a70a5
xorl %edx, %edx
movq %rdx, %rdi
andq %rsi, %rdi
addq %rsi, %rdi
xorq %rsi, %rdi
orq %rdx, %rdi
movq %rdi, %r8
orq %rsi, %r8
notq %r8
orq %rcx, %r8
andq %rsi, %rdi
movq %rdi, %rsi
andq %rbp, %rsi
negq %rsi
movl $0x0, %esi
sbbq %rsi, %rsi
testq %rbp, %r8
cmovneq %r13, %rsi
addq %rsi, %r15
cmpq %r9, %r15
jbe 0x2a710b
orq %rcx, %rdx
leaq 0x1(,%r8,2), %rsi
movq %rsi, %rcx
andq %rdx, %rcx
addq %rdi, %rdi
orq %rsi, %rdx
notq %rdx
orq %rdi, %rdx
decq %rax
movq %rdx, %rsi
jmp 0x2a7079
negq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x190e44(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3dee5(%rip), %rsi     # 0x2e5013
leaq 0xd9adf(%rip), %rdx     # 0x380c14
leaq 0xd9b83(%rip), %rcx     # 0x380cbf
leaq 0xd9b16(%rip), %r8      # 0x380c59
pushq $0x7d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x190e0e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3deaf(%rip), %rsi     # 0x2e5013
leaq 0xd9b44(%rip), %rdx     # 0x380caf
leaq 0xd9b4d(%rip), %rcx     # 0x380cbf
leaq 0xd9ae0(%rip), %r8      # 0x380c59
pushq $0x7a
jmp 0x2a7145
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp-param.c
// Function: gt_registerBlockEncOptions
void
gt_registerBlockEncOptions(GtOptionParser *op,
                           struct blockEncParams *paramOutput)
{
  GtOption *option;

  option = gt_option_new_uint_min("bsize", "specify size of blocks",
                                  &paramOutput->blockSize, 8U, 1U);
  gt_option_parser_add_option(op, option);
  option = gt_option_new_uint_min("blbuck", "specify number of blocks per "
                                            "bucket",
                                  &paramOutput->bucketBlocks, 8U, 1U);
  gt_option_parser_add_option(op, option);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7f253(%rip), %rdi     # 0x3265e3
leaq 0xd9985(%rip), %rsi     # 0x380d1c
pushq $0x8
popq %rbp
pushq $0x1
popq %r15
movq %r14, %rdx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x9abef
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
addq $0x4, %r14
leaq 0xd9972(%rip), %rdi     # 0x380d33
leaq 0xd9972(%rip), %rsi     # 0x380d3a
movq %r14, %rdx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x9abef
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x97f31
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: destructOnDiskBlockCompIdx
static void
destructOnDiskBlockCompIdx(struct onDiskBlockCompIdx *idx)
{
  if (idx->idxMMap)
    gt_fa_xmunmap(idx->idxMMap);
  if (idx->idxFP)
    gt_fa_xfclose(idx->idxFP);
  if (idx->idxFN)
    gt_str_delete(idx->idxFN);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2a8b68
callq 0x8b9fa
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2a8b75
callq 0x8a5e5
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2a8b84
popq %rbx
jmp 0xae103
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: symSumBitsDefaultSetup
static inline void
symSumBitsDefaultSetup(struct blockCompositionSeq *seqIdx)
{
  unsigned i;
  AlphabetRangeSize blockMapAlphabetSize = seqIdx->blockMapAlphabetSize;
  seqIdx->partialSymSumBitsSums[0] = 0;
  seqIdx->partialSymSumBits[0] = seqIdx->bitsPerUlong;
  for (i = 1; i < blockMapAlphabetSize; ++i)
    seqIdx->partialSymSumBitsSums[i] = seqIdx->partialSymSumBitsSums[i - 1]
      + (seqIdx->partialSymSumBits[i] = seqIdx->bitsPerUlong);
  seqIdx->symSumBits = blockMapAlphabetSize * seqIdx->bitsPerUlong;
#ifdef EIS_DEBUG
  gt_log_log("symSumBits=%u, blockMapAlphabetSize=%u\n",
          seqIdx->symSumBits, seqIdx->blockMapAlphabetSize);
#endif
  gt_assert(seqIdx->partialSymSumBitsSums[i - 1] + seqIdx->bitsPerUlong
         == seqIdx->symSumBits);
}

// Assembly:
pushq %rax
movzwl 0xc4(%rdi), %ecx
movq 0xd8(%rdi), %rax
andl $0x0, (%rax)
movl 0xbc(%rdi), %edx
movq 0xd0(%rdi), %rsi
movl %edx, (%rsi)
pushq $0x1
popq %rdx
cmpq %rcx, %rdx
jae 0x2a8bf1
movl 0xbc(%rdi), %r8d
movl -0x4(%rax,%rdx,4), %r9d
addl %r8d, %r9d
movl %r8d, (%rsi,%rdx,4)
movl %r9d, (%rax,%rdx,4)
incq %rdx
jmp 0x2a8bd0
movl 0xbc(%rdi), %esi
movl %esi, %r8d
imull %ecx, %r8d
movl %r8d, 0xe0(%rdi)
addl -0x4(%rax,%rdx,4), %esi
cmpl %r8d, %esi
jne 0x2a8c10
popq %rax
retq
movq 0x18f351(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c3f2(%rip), %rsi     # 0x2e5013
leaq 0xd8752(%rip), %rdx     # 0x38137a
leaq 0xd879d(%rip), %rcx     # 0x3813cc
leaq 0xd814a(%rip), %r8      # 0x380d80
movl $0x305, %r9d            # imm = 0x305
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: openOnDiskData
static int
openOnDiskData(const char *projectName, struct onDiskBlockCompIdx *idx,
               char *mode,GtError *err)
{
  GtStr *bdxName = gt_str_new_cstr(projectName);
  gt_str_append_cstr(bdxName, ".bdx");
  idx->idxFP = gt_fa_fopen(gt_str_get(bdxName), mode, err);
  idx->idxFN = gt_str_ref(bdxName);
  gt_str_delete(bdxName);
  if (!idx->idxFP)
    return 0;
  else
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
callq 0xacbd1
movq %rax, %r12
leaq 0xd8732(%rip), %rsi     # 0x3813e3
movq %rax, %rdi
callq 0xacbfb
movq %r12, %rdi
callq 0xad1fa
leaq 0xd80b8(%rip), %rdx     # 0x380d80
movq %rax, %rdi
movq %r15, %rsi
movl $0x6a4, %ecx            # imm = 0x6A4
movq %r14, %r8
callq 0x8a156
movq %rax, (%rbx)
movq %r12, %rdi
callq 0xad4d2
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0xae103
xorl %eax, %eax
cmpq $0x0, (%rbx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: tryMMapOfIndex
static inline int
tryMMapOfIndex(struct onDiskBlockCompIdx *idxData)
{
  size_t len = idxData->rangeEncPos - idxData->cwDataPos;
  gt_assert(idxData && idxData->idxFP && idxData->idxMMap == NULL);
  idxData->idxMMap = gt_fa_mmap_generic_fd(fileno(idxData->idxFP),
                                           gt_str_get(idxData->idxFN),len,
                                           idxData->cwDataPos, false, false,
                                           NULL);
  return (idxData->idxMMap != NULL ? 0 : 1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2a93a3
cmpq $0x0, 0x10(%rbx)
jne 0x2a93a3
movq 0x28(%rbx), %r14
subq 0x18(%rbx), %r14
callq 0x17800
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0xad1fa
movq 0x18(%rbx), %rcx
leaq 0xd7a0f(%rip), %rdx     # 0x380d80
andq $0x0, 0x10(%rsp)
movq %rdx, (%rsp)
movl $0x949, 0x8(%rsp)       # imm = 0x949
movl %ebp, %edi
movq %rax, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8ae80
movq %rax, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18ebbe(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3bc5f(%rip), %rsi     # 0x2e5013
leaq 0xd8096(%rip), %rdx     # 0x381451
leaq 0xd80c5(%rip), %rcx     # 0x381487
leaq 0xd79b7(%rip), %r8      # 0x380d80
movl $0x945, %r9d            # imm = 0x945
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: superBlockCWBits
static inline BitOffset
superBlockCWBits(const struct blockCompositionSeq *seqIdx)
{
  return seqIdx->symSumBits + seqIdx->bitsPerVarDiskOffset
    + seqIdx->callBackDataOffsetBits
    + seqIdx->compositionTable.compositionIdxBits * seqIdx->bucketBlocks
    + seqIdx->cwExtBitsPerBucket;
}

// Assembly:
movl 0xb0(%rdi), %eax
movl 0xc0(%rdi), %ecx
addl 0xe0(%rdi), %ecx
addl 0xb8(%rdi), %ecx
imull 0x68(%rdi), %eax
addl %ecx, %eax
addq 0x90(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: writeExtIdxHeader
static inline int
writeExtIdxHeader(FILE *fp, uint16_t headerID, size_t len,
                  headerWriteFunc cbFunc, void *cbData)
{
  uint32_t expHeader[2] =
    { EH_HEADER_PREFIX | headerID, len };
  gt_xfwrite(expHeader, sizeof (uint32_t), 2, fp);
  return cbFunc(fp, cbData);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
orl $0x45480000, %esi       # imm = 0x45480000
leaq 0x8(%rsp), %rdi
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
pushq $0x4
popq %rsi
pushq $0x2
popq %rdx
movq %r15, %rcx
callq 0xb302c
movq %r15, %rdi
movq %rbx, %rsi
callq *%r14
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: deleteBlockEncIdxSeq
static void
deleteBlockEncIdxSeq(struct encIdxSeq *seq)
{
  struct blockCompositionSeq *bseq;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  bseq = encIdxSeq2blockCompositionSeq(seq);
  gt_free(bseq->extHeaderPos);
  gt_free(bseq->partialSymSumBits);
  destructOnDiskBlockCompIdx(&bseq->externalData);
  gt_destructCompositionList(&bseq->compositionTable);
  gt_MRAEncDelete(bseq->baseClass.alphabet);
  gt_MRAEncDelete(bseq->rangeMapAlphabet);
  gt_MRAEncDelete(bseq->blockMapAlphabet);
  gt_deleteSeqRangeList(bseq->rangeEncs);
  gt_free(bseq->modes);
  gt_free(bseq);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2aa4d4
movq %rdi, %rbx
leaq 0x18d750(%rip), %rax    # 0x437b80
cmpq %rax, (%rdi)
jne 0x2aa4d4
movq %rbx, %rdi
callq 0x2abb6e
movq 0x78(%rbx), %rdi
leaq 0xd6934(%rip), %r14     # 0x380d80
movq %r14, %rsi
movl $0x297, %edx            # imm = 0x297
callq 0x936f9
movq 0xd0(%rbx), %rdi
movq %r14, %rsi
movl $0x298, %edx            # imm = 0x298
callq 0x936f9
leaq 0x18(%rbx), %rdi
callq 0x2a8b56
leaq 0x48(%rbx), %rdi
callq 0x2ad242
movq 0x8(%rbx), %rdi
callq 0x149458
movq 0xa0(%rbx), %rdi
callq 0x149458
movq 0x98(%rbx), %rdi
callq 0x149458
movq 0x70(%rbx), %rdi
callq 0x2ad6ff
movq 0xa8(%rbx), %rdi
movq %r14, %rsi
movl $0x29f, %edx            # imm = 0x29F
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2a0, %edx            # imm = 0x2A0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x18da8d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3ab2e(%rip), %rsi     # 0x2e5013
leaq 0xd7089(%rip), %rdx     # 0x381575
leaq 0xd70b5(%rip), %rcx     # 0x3815a8
leaq 0xd6886(%rip), %r8      # 0x380d80
movl $0x295, %r9d            # imm = 0x295
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: blockCompSeqGet
static Symbol
blockCompSeqGet(struct encIdxSeq *seq, GtUword pos, union EISHint *hint)
{
  Symbol sym;
  struct blockCompositionSeq *seqIdx;
  unsigned blockSize;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  if (pos >= seq->seqLen)
    return ~(Symbol)0;
  seqIdx = encIdxSeq2blockCompositionSeq(seq);
  blockSize = seqIdx->blockSize;
  {
    Symbol block[blockSize];
    blockCompSeqGetBlock(seqIdx, pos/blockSize, &(hint->bcHint), 1, NULL,
                         block);
    sym = block[pos%blockSize];
  }
  return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x2ab49d
movq %rdi, %r15
leaq 0x18c84f(%rip), %rax    # 0x437b80
cmpq %rax, (%rdi)
jne 0x2ab49d
movq %rsi, %rbx
movb $-0x1, %al
cmpq %rsi, 0x10(%r15)
jbe 0x2ab48e
movq %rdx, %r14
movq %r15, %rdi
callq 0x2abb6e
movq %rsp, %rsi
movl 0xb4(%r15), %ecx
movq %rsp, %r12
leaq 0xf(%rcx), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
movl 0xb4(%r15), %eax
movq %rdi, %rcx
imulq %rax, %rcx
cmpq 0x10(%r15), %rcx
jae 0x2ab487
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %r12, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movl 0xb0(%r15), %ecx
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
movq %rdi, -0x38(%rbp)
movq %r15, %rdi
movq %rax, %rsi
movq %r14, -0x68(%rbp)
movq %r14, %rdx
callq 0x2abbb7
movl (%rax), %r13d
movq %rax, -0x30(%rbp)
movl 0x4(%rax), %eax
movl 0xe0(%r15), %ecx
movl 0xc0(%r15), %edx
addq %rcx, %rdx
movl 0xb8(%r15), %r12d
addq %rdx, %r12
addq %rax, %r12
movq %r15, %rax
movl 0x68(%r15), %r15d
movq %rax, %rbx
movl 0xb0(%rax), %ecx
movq -0x38(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r14
subl $0x1, %r14d
jb 0x2ab43e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x28c984
movq 0x50(%rbx), %rcx
movl %eax, %eax
imulq $0x18, %rax, %rax
movl 0x8(%rcx,%rax), %eax
addq %rax, %r13
addq %r15, %r12
jmp 0x2ab40f
movq %rbx, %r14
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movq -0x58(%rbp), %r12
movq %r12, %r8
movq -0x48(%rbp), %rbx
movl %ebx, %r9d
callq 0x2ac054
movq 0x70(%r14), %rdi
movq -0x68(%rbp), %r9
addq $0x20, %r9
movq %r12, %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rcx
movq %rdx, %r8
callq 0x2ae98c
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdx
movb (%r12,%rdx), %al
movq %rsi, %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18cac4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x39b65(%rip), %rsi     # 0x2e5013
leaq 0xd60c0(%rip), %rdx     # 0x381575
leaq 0xd63d1(%rip), %rcx     # 0x38188d
leaq 0xd58bd(%rip), %r8      # 0x380d80
movl $0x619, %r9d            # imm = 0x619
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: newBlockCompSeqHint
static union EISHint *
newBlockCompSeqHint(const struct encIdxSeq *seq)
{
  union EISHint *hintret;
  const struct blockCompositionSeq *seqIdx;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  hintret = gt_malloc(sizeof (union EISHint));
  gt_SRLInitListSearchHint(seqIdx->rangeEncs, &hintret->bcHint.rangeHint);
  /* FIXME: make cache size user-configurable */
  initSuperBlockSeqCache(&hintret->bcHint.sBlockCache, seqIdx, 32);
  return hintret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2ab5c1
movq %rdi, %rbx
leaq 0x18c68f(%rip), %rax    # 0x437b80
cmpq %rax, (%rdi)
jne 0x2ab5c1
movq %rbx, %rdi
callq 0x2ac28e
leaq 0xd5877(%rip), %rsi     # 0x380d80
pushq $0x28
popq %rdi
movl $0x9c1, %edx            # imm = 0x9C1
callq 0x93160
movq %rax, %r14
movq 0x70(%rbx), %rdi
leaq 0x20(%rax), %rsi
callq 0x2adc9d
testq %r14, %r14
je 0x2ab5ef
movq %rbx, %rdi
callq 0x2abfb0
movq %rax, %r15
movq $0x20, (%r14)
movq %rax, %rdi
shlq $0x5, %rdi
movl $0x200, %r12d           # imm = 0x200
addq %r12, %rdi
leaq 0xd5828(%rip), %rsi     # 0x380d80
movl $0x3de, %edx            # imm = 0x3DE
callq 0x93160
movq %rax, 0x8(%r14)
leaq 0x100(%rax), %rcx
movq %rcx, 0x10(%r14)
addq %r12, %rax
movq %rax, 0x18(%r14)
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq $0x20, %r13
je 0x2ab5b4
movq 0x18(%r14), %rax
addq %r12, %rax
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rdi
movq %rbx, %rsi
callq 0x2ac013
movq 0x8(%r14), %rax
orq $-0x1, (%rax,%r13,8)
incq %r13
addq %r15, %r12
jmp 0x2ab57e
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18c9a0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x39a41(%rip), %rsi     # 0x2e5013
leaq 0xd5f9c(%rip), %rdx     # 0x381575
leaq 0xd62bd(%rip), %rcx     # 0x38189d
leaq 0xd5799(%rip), %r8      # 0x380d80
movl $0x9bf, %r9d            # imm = 0x9BF
jmp 0x2ab61b
movq 0x18c972(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x39a13(%rip), %rsi     # 0x2e5013
leaq 0xd62cd(%rip), %rdx     # 0x3818d4
leaq 0xd62dc(%rip), %rcx     # 0x3818ea
leaq 0xd576b(%rip), %r8      # 0x380d80
movl $0x3d7, %r9d            # imm = 0x3D7
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: deleteBlockCompSeqHint
static void
deleteBlockCompSeqHint(struct encIdxSeq *seq, union EISHint *hint)
{
  GT_UNUSED struct blockCompositionSeq *seqIdx;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = encIdxSeq2blockCompositionSeq(seq);
  destructSuperBlockSeqCache(&hint->bcHint.sBlockCache);
  gt_free(hint);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2ab673
leaq 0x18c549(%rip), %rax    # 0x437b80
cmpq %rax, (%rdi)
jne 0x2ab673
movq %rsi, %rbx
callq 0x2abb6e
movq 0x8(%rbx), %rdi
leaq 0xd5731(%rip), %r14     # 0x380d80
movq %r14, %rsi
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9cf, %edx            # imm = 0x9CF
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x18c8ee(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3998f(%rip), %rsi     # 0x2e5013
leaq 0xd5eea(%rip), %rdx     # 0x381575
leaq 0xd626f(%rip), %rcx     # 0x381901
leaq 0xd56e7(%rip), %r8      # 0x380d80
movl $0x9cc, %r9d            # imm = 0x9CC
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: seekToHeader
static FILE *
seekToHeader(const struct encIdxSeq *seqIdx, uint16_t headerID,
             uint32_t *lenRet)
{
  const struct blockCompositionSeq *bSeqIdx;
  size_t i;
  uint32_t query = headerID | EH_HEADER_PREFIX;
  gt_assert(seqIdx);
  bSeqIdx =
    constEncIdxSeq2blockCompositionSeq(seqIdx);
  for (i = 0; i < bSeqIdx->numExtHeaders; ++i)
  {
    if (bSeqIdx->extHeaderPos[i].headerID == query)
    {
      uint32_t headerPrefix[2];
      if (lenRet)
      {
        if (fseeko(bSeqIdx->externalData.idxFP,
                   bSeqIdx->extHeaderPos[i].pos - EXT_HEADER_PREFIX_SIZE,
                   SEEK_SET))
           return NULL;
        if (fread(headerPrefix, sizeof (headerPrefix[0]), 2,
                  bSeqIdx->externalData.idxFP) != 2)
          return NULL;
        *lenRet = headerPrefix[1];
      }
      else
        if (fseeko(bSeqIdx->externalData.idxFP, bSeqIdx->extHeaderPos[i].pos,
                   SEEK_SET))
          return NULL;
      return bSeqIdx->externalData.idxFP;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2ab967
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
orl $0x45480000, %ebp       # imm = 0x45480000
callq 0x2ac28e
movq 0x80(%rbx), %rcx
pushq $0x8
popq %rax
xorl %r15d, %r15d
subq $0x1, %rcx
jb 0x2ab959
movq 0x78(%rbx), %rdx
cmpl %ebp, (%rdx,%rax)
je 0x2ab901
addq $0x10, %rax
jmp 0x2ab8ec
movq 0x18(%rbx), %rdi
movq -0x8(%rdx,%rax), %rsi
testq %r14, %r14
je 0x2ab942
addq $-0x8, %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x17c70
testl %eax, %eax
jne 0x2ab959
movq 0x18(%rbx), %rcx
movq %rsp, %rdi
pushq $0x4
popq %rsi
pushq $0x2
popq %rdx
callq 0x17ad0
cmpq $0x2, %rax
jne 0x2ab956
movl 0x4(%rsp), %eax
movl %eax, (%r14)
jmp 0x2ab950
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x17c70
testl %eax, %eax
jne 0x2ab959
movq 0x18(%rbx), %r15
jmp 0x2ab959
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18c5fa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3969b(%rip), %rsi     # 0x2e5013
leaq 0xd5b21(%rip), %rdx     # 0x3814a0
leaq 0xd5fa5(%rip), %rcx     # 0x38192b
leaq 0xd53f3(%rip), %r8      # 0x380d80
movl $0x954, %r9d            # imm = 0x954
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: printBlockEncPosDiags
static int
printBlockEncPosDiags(const EISeq *seq, GtUword pos, FILE *fp,
                      EISHint hint)
{
  const struct blockCompositionSeq *seqIdx;
  int outCount = 0;
  GtUword bucketNum;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  bucketNum = bucketNumFromPos(seqIdx, pos);
  fputs("##################################################\n"
        "# This bucket:\n"
        "##################################################\n", fp);
  outCount += printBucket(seqIdx, bucketNum, BUCKET_PLAIN, fp, hint);
  if (bucketNum)
  {
    fputs("##################################################\n"
          "# Previous bucket:\n"
          "##################################################\n", fp);
    outCount += printBucket(seqIdx, bucketNum - 1, BUCKET_PLAIN, fp, hint);
  }
  if (bucketNum < bucketNumFromPos(seqIdx, EISLength(seq)))
  {
    fputs("##################################################\n"
          "# Next bucket:\n"
          "##################################################\n", fp);
    outCount += printBucket(seqIdx, bucketNum + 1, BUCKET_PLAIN, fp, hint);
  }
  return outCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2aba9b
movq %rdi, %r15
leaq 0x18c1c3(%rip), %rax    # 0x437b80
cmpq %rax, (%rdi)
jne 0x2aba9b
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movq %r15, %rdi
callq 0x2ac28e
movl 0xb4(%r15), %ebx
imull 0xb0(%r15), %ebx
movq %r13, %rax
xorl %edx, %edx
divq %rbx
movq %rax, %r12
leaq 0xd5f56(%rip), %rdi     # 0x38194e
movq %r14, %rsi
callq 0x17870
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %rbp, (%rsp)
movq %rbp, %r8
callq 0x2ac30f
movl %eax, %ebp
cmpq %r13, %rbx
ja 0x2aba45
leaq 0xd5f9f(%rip), %rdi     # 0x3819c4
movq %r14, %rsi
callq 0x17870
leaq -0x1(%r12), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
movq (%rsp), %r8
callq 0x2ac30f
addl %eax, %ebp
movq 0x10(%r15), %rax
movl 0xb4(%r15), %ecx
imull 0xb0(%r15), %ecx
xorl %edx, %edx
divq %rcx
cmpq %rax, %r12
jae 0x2aba8a
leaq 0xd5fd5(%rip), %rdi     # 0x381a3e
movq %r14, %rsi
callq 0x17870
incq %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq (%rsp), %r8
callq 0x2ac30f
addl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18c4c6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x39567(%rip), %rsi     # 0x2e5013
leaq 0xd5ac2(%rip), %rdx     # 0x381575
leaq 0xd5e7e(%rip), %rcx     # 0x381938
leaq 0xd52bf(%rip), %r8      # 0x380d80
movl $0xa87, %r9d            # imm = 0xA87
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: displayBlockEncBlock
static int
displayBlockEncBlock(const EISeq *seq, GtUword pos, FILE *fp,
                     EISHint hint)
{
  const struct blockCompositionSeq *seqIdx;
  int outCount;
  GtUword bucketNum;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  bucketNum = bucketNumFromPos(seqIdx, pos);
  outCount = printBucket(seqIdx, bucketNum, BUCKET_PRINT_BITSTRING_SEPARATOR
                         | BUCKET_PRINT_BITSTRING | BUCKET_PRINT_BITSIZES
                         | BUCKET_PRINT_RANGES_OVERLAY, fp, hint);
  return outCount;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2abb36
movq %rdi, %r15
leaq 0x18c096(%rip), %rax    # 0x437b80
cmpq %rax, (%rdi)
jne 0x2abb36
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %r15, %rdi
callq 0x2ac28e
movl 0xb4(%r15), %ecx
imull 0xb0(%r15), %ecx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
pushq $0xf
popq %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ac30f
movq 0x18c42b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x394cc(%rip), %rsi     # 0x2e5013
leaq 0xd5a27(%rip), %rdx     # 0x381575
leaq 0xd6171(%rip), %rcx     # 0x381cc6
leaq 0xd5224(%rip), %r8      # 0x380d80
movl $0xaa6, %r9d            # imm = 0xAA6
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-seqblocktranslate.h
// Function: symCountFromComposition
static inline unsigned
symCountFromComposition(struct compList *compositionTable,
                        unsigned alphabetSize,
                        PermCompIndex compIndex, Symbol sym)
{
  BitOffset bitsPerComp, bitsPerCount;
  gt_assert(compositionTable);
  bitsPerCount = compositionTable->bitsPerCount;
  bitsPerComp = bitsPerCount * alphabetSize;
  gt_assert(compIndex < compositionTable->numCompositions);
  return gt_bsGetUInt(compositionTable->catCompsPerms,
                   compIndex * bitsPerComp + sym * bitsPerCount,
                   bitsPerCount);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2abe08
movl %edx, %eax
cmpq %rax, (%rdi)
jbe 0x2abe36
movl 0x18(%rdi), %edx
movl %esi, %esi
movq 0x10(%rdi), %rdi
imulq %rsi, %rax
movzbl %cl, %esi
addq %rax, %rsi
imulq %rdx, %rsi
popq %rax
jmp 0x28c984
movq 0x18c159(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x391fa(%rip), %rsi     # 0x2e5013
leaq 0xd58db(%rip), %rdx     # 0x3816fb
leaq 0xd58e5(%rip), %rcx     # 0x38170c
leaq 0xd58f6(%rip), %r8      # 0x381724
movl $0xb3, %r9d
jmp 0x2abe62
movq 0x18c12b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x391cc(%rip), %rsi     # 0x2e5013
leaq 0xd5938(%rip), %rdx     # 0x381786
leaq 0xd58b7(%rip), %rcx     # 0x38170c
leaq 0xd58c8(%rip), %r8      # 0x381724
movl $0xb6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: adjustPosRankForBlock
static inline GtUword
adjustPosRankForBlock(struct blockCompositionSeq *seqIdx,
                      struct superBlock *sBlock, GtUword pos, Symbol bSym,
                      unsigned blockSize, GtUword preBlockRankCount,
                      BitOffset cwIdxMemOffset, BitOffset varDataMemOffset,
                      unsigned bitsPerCompositionIdx)
{
  GtUword rankCount = preBlockRankCount;
  unsigned inBlockPos;
  if ((inBlockPos = pos % blockSize)
      && symCountFromComposition(
        &seqIdx->compositionTable, seqIdx->blockMapAlphabetSize,
        gt_bsGetPermCompIndex(sBlock->cwData, cwIdxMemOffset,
                           bitsPerCompositionIdx), bSym))
  {
    Symbol block[blockSize];
    unsigned i;
    unpackBlock(seqIdx, sBlock, cwIdxMemOffset, varDataMemOffset, block,
                inBlockPos);
    for (i = 0; i < inBlockPos; ++i)
    {
      if (block[i] == bSym)
        ++rankCount;
    }
  }
  return rankCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %rdx, %rax
movl %r8d, %r13d
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
je 0x2abf26
movl %ecx, %r14d
movq %rdx, %r15
movl 0x20(%rbp), %edx
movq 0x10(%rbp), %rax
leaq 0x48(%rdi), %r12
movq %rdi, -0x38(%rbp)
movzwl 0xc4(%rdi), %ecx
movl %ecx, -0x30(%rbp)
movq %rsi, -0x40(%rbp)
movq 0x10(%rsi), %rdi
movq %rax, %rsi
callq 0x28c984
movzbl %r14b, %ecx
movq %r12, %rdi
movl -0x30(%rbp), %esi
movl %eax, %edx
callq 0x2abdde
testl %eax, %eax
je 0x2abf26
movq %rsp, -0x30(%rbp)
movq 0x18(%rbp), %rcx
movq %rsp, %r12
addq $0xf, %r13
andq $-0x10, %r13
subq %r13, %r12
movq %r12, %rsp
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq %r12, %r8
movl %r15d, %r9d
callq 0x2ac054
xorl %eax, %eax
cmpq %r15, %rax
jae 0x2abf22
xorl %ecx, %ecx
cmpb %r14b, (%r12,%rax)
sete %cl
addq %rcx, %rbx
incq %rax
jmp 0x2abf0c
movq -0x30(%rbp), %rsp
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: superBlockMemSize
static inline size_t
superBlockMemSize(const struct blockCompositionSeq *seqIdx)
{
  if (seqIdxUsesMMap(seqIdx))
  {
    return sizeof (struct superBlock);
  }
  else
  {
    size_t offset;
    offset = offsetAlign(sizeof (struct superBlock), sizeof (BitElem));
    offset = offsetAlign(offset + superBlockCWMaxReadSize(seqIdx),
                         sizeof (BitElem));
    offset += superBlockVarMaxReadSize(seqIdx);
    return offsetAlign(offset, MAX_ALIGN_REQUIREMENT);
  }
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x2abfbb
pushq $0x18
popq %rax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2abf53
leaq 0x18(%rax), %r14
xorl %r15d, %r15d
testb $0x3, %al
setne %r15b
movabsq $0x7ffffffffffffff8, %r12 # imm = 0x7FFFFFFFFFFFFFF8
leaq 0x4(%r12), %rax
andq %rax, %r14
movq %rbx, %rdi
callq 0x2abf85
addq %r14, %rax
leaq (%rax,%r15,4), %rax
xorl %ecx, %ecx
testb $0x7, %al
setne %cl
andq %rax, %r12
leaq (%r12,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: initEmptySuperBlock
static inline void
initEmptySuperBlock(struct superBlock *sBlock,
                    const struct blockCompositionSeq *seqIdx)
{
  if (!seqIdxUsesMMap(seqIdx))
  {
    size_t offset;
    sBlock->cwData = (BitString)
      ((char *)sBlock + (offset = offsetAlign(sizeof (*sBlock),
                                              sizeof (BitElem))));
    sBlock->varData = (BitString)
      ((char *)sBlock + (offset = offsetAlign(offset
                                              + superBlockCWMaxReadSize(seqIdx),
                                              sizeof (BitElem))));
  }
}

// Assembly:
cmpq $0x0, 0x28(%rsi)
je 0x2ac01b
retq
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x10(%rdi)
movq %rsi, %rdi
callq 0x2abf53
leaq 0x18(%rax), %rcx
xorl %edx, %edx
testb $0x3, %al
setne %dl
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
andq %rcx, %rax
addq %rbx, %rax
leaq (%rax,%rdx,4), %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: unpackBlock
static inline void
unpackBlock(const struct blockCompositionSeq *seqIdx,
            const struct superBlock *sBlock,
            BitOffset cwOffset, BitOffset varOffset, Symbol *block,
            unsigned sublen)
{
  unsigned varIdxBits, bitsPerCompositionIdx;
  PermCompIndex compIndex, permIndex;
  bitsPerCompositionIdx = seqIdx->compositionTable.compositionIdxBits;
  compIndex = gt_bsGetPermCompIndex(sBlock->cwData, cwOffset,
                                 bitsPerCompositionIdx);
  varIdxBits = seqIdx->compositionTable.permutations[compIndex].permIdxBits;
  permIndex = gt_bsGetPermCompIndex(sBlock->varData, varOffset, varIdxBits);
  indexPair2block(&seqIdx->compositionTable, seqIdx->blockSize,
                  compIndex, permIndex, block, sublen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl 0x68(%rdi), %eax
movq 0x10(%rsi), %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0x28c984
movq 0x50(%r14), %rcx
movl %eax, %eax
imulq $0x18, %rax, %r13
movl 0x8(%rcx,%r13), %edx
movq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x28c984
testq %rbx, %rbx
je 0x2ac0da
movl 0xb4(%r14), %esi
cmpl %ebp, %esi
jb 0x2ac108
movl 0x64(%r14), %edx
movq 0x50(%r14), %rcx
movq 0x58(%r14), %rdi
imull %eax, %esi
imull %edx, %esi
addq 0x10(%rcx,%r13), %rsi
movl %ebp, %ecx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28f5be
movq 0x18be87(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x38f28(%rip), %rsi     # 0x2e5013
leaq 0xd56c2(%rip), %rdx     # 0x3817b4
leaq 0xd56d5(%rip), %rcx     # 0x3817ce
leaq 0xd5624(%rip), %r8      # 0x381724
movl $0x9b, %r9d
jmp 0x2ac134
movq 0x18be59(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x38efa(%rip), %rsi     # 0x2e5013
leaq 0xd56be(%rip), %rdx     # 0x3817de
leaq 0xd56a7(%rip), %rcx     # 0x3817ce
leaq 0xd55f6(%rip), %r8      # 0x381724
movl $0x9c, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390