LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/type_node.c
// Function: create_transitive_part_of_edges
static void create_transitive_part_of_edges(GtTypeNode *node,
                                            GtBoolMatrix *part_of_out_edges,
                                            GtBoolMatrix *part_of_in_edges,
                                            GtArray *node_stack)
{
  GtUword i, j;
  /* For every incoming part_of edge of the current node add a corresponding
     part_of edge to all nodes in the stack. Note that the current node is not
     part of the stack yet, therefore this is skipped on the first invocation.
   */
  if (gt_array_size(node_stack)) {
    for (i  = gt_bool_matrix_get_first_column(part_of_in_edges, node->num);
         i != gt_bool_matrix_get_last_column(part_of_in_edges, node->num);
         i  = gt_bool_matrix_get_next_column(part_of_in_edges, node->num, i)) {
      for (j = 0; j < gt_array_size(node_stack); j++) {
        GtTypeNode *child = *(GtTypeNode**) gt_array_get(node_stack, j);
        gt_bool_matrix_set(part_of_out_edges, i, child->num, true);
        gt_bool_matrix_set(part_of_in_edges, child->num, i, true);
      }
    }
  }
  /* add node to stack */
  gt_array_add(node_stack, node);
  /* call method recursively for all is_a edges of the current node */
  for (i = 0; i < gt_array_size(node->is_a_out_edges); i++) {
    GtTypeNode *parent = *(GtTypeNode**) gt_array_get(node->is_a_out_edges, i);
    create_transitive_part_of_edges(parent, part_of_out_edges, part_of_in_edges,
                                    node_stack);
  }
  /* pop node from stack */
  gt_array_pop(node_stack);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, (%rsp)
movq %rcx, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x30d78d
movq (%rsp), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x348aeb
movq %rax, %r12
movq (%rsp), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x348b3a
cmpq %rax, %r12
je 0x30d78d
movq %rbx, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x30d776
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd47ba
movq (%rax), %rbp
movq (%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %ecx
callq 0x348a28
movq (%rbp), %rsi
movq %r14, %rdi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x348a28
incq %r13
movq %rbx, %rdi
callq 0xd4a9a
cmpq %rax, %r13
jb 0x30d730
movq (%rsp), %rax
movq (%rax), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x348b89
jmp 0x30d709
movq %rsp, %r12
movl $0x8, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd49ce
movq (%r12), %rax
movq 0x20(%rax), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x30d7eb
xorl %r12d, %r12d
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq %r12, %rsi
callq 0xd47ba
movq (%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30d6d1
incq %r12
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xd4a9a
cmpq %rax, %r12
jb 0x30d7b5
movq %rbx, %rdi
callq 0xd47f5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/type_node.c
// Function: gt_type_node_is_a
bool gt_type_node_is_a(GtTypeNode *child_node, const char *parent_id)
{
  GtUword i;
  gt_assert(child_node && parent_id);

  /* XXX: do path compression */
  if (!strcmp(child_node->id, parent_id))
    return true;
  for (i = 0; i < gt_array_size(child_node->is_a_out_edges); i++) {
    GtTypeNode *node = *(GtTypeNode**) gt_array_get(child_node->is_a_out_edges,
                                                    i);
    if (gt_type_node_is_a(node, parent_id))
      return true;
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x30d87e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x30d87e
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
callq 0x17a40
testl %eax, %eax
je 0x30d86a
movq 0x20(%r14), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x30d86f
xorl %r15d, %r15d
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xd47ba
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x30d802
movl %eax, %ebp
testb %al, %al
jne 0x30d871
incq %r15
movq 0x20(%r14), %rdi
callq 0xd4a9a
cmpq %rax, %r15
jb 0x30d83a
jmp 0x30d871
movb $0x1, %bpl
jmp 0x30d871
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x8f166
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/apmeoveridx.c
// Function: apme_initdfsconstinfo
static void apme_initdfsconstinfo(Limdfsconstinfo *mt,
                                  unsigned int alphasize,
                                  ...)
                                 /* Variable argument list is as follows:
                                    unsigned int alphasize
                                    const GtUchar *pattern,
                                    GtUword patternlength,
                                    GtUword maxdistance,
                                    GtUword maxintervalwidth,
                                    bool skpp
                                 */
{
  va_list ap;
  const GtUchar *pattern;
  ApmeoveridxLimdfsconstinfo *mti = (ApmeoveridxLimdfsconstinfo *) mt;

  va_start(ap,alphasize);
  pattern = va_arg(ap, const GtUchar *);
  mti->patternlength = va_arg(ap, GtUword);
  mti->maxdistance = va_arg(ap, GtUword);
  mti->maxintervalwidth = va_arg(ap, GtUword);
  mti->skpp = (bool) va_arg(ap, int);
  va_end(ap);
  gt_assert(mti->maxdistance < mti->patternlength);
  gt_initeqsvector(mti->eqsvector,(GtUword) alphasize,
                pattern,mti->patternlength);
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x3118a2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movl $0x10, %ecx
cmpq $0x28, %rcx
ja 0x3118df
movl $0x10, %eax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3118ed
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x311909
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x311917
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rdi)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x311937
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x311945
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rdi)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x311965
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x311973
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rdi)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x311993
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3119a1
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpl $0x0, (%rax)
setne (%rdi)
movq 0x10(%rdi), %rcx
cmpq %rcx, 0x18(%rdi)
jae 0x3119c4
movq 0x20(%rdi), %rdi
movl %esi, %esi
callq 0x329b7c
addq $0xd8, %rsp
retq
callq 0x90ada
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_new
GtDiagbandStruct *gt_diagband_struct_new(GtUword amaxlen,GtUword bmaxlen,
                                         GtUword logdiagbandwidth)
{
  GtDiagbandStruct *diagband_struct = gt_malloc(sizeof *diagband_struct);

  diagband_struct->used_diagbands = 0;
  diagband_struct->num_diagbands
    = gt_diagband_struct_num_diagbands(amaxlen,bmaxlen,logdiagbandwidth);
  diagband_struct->amaxlen = amaxlen;
  diagband_struct->logdiagbandwidth = logdiagbandwidth;
  /* diagband_score[0] and diagband_score[num_diagbands+1] remain zero as
     boundaries */
  diagband_struct->score = gt_calloc(diagband_struct->num_diagbands + 2,
                                     sizeof *diagband_struct->score);
  diagband_struct->score++; /* so we need not increment the index when
                               accessing score */
  diagband_struct->lastpos
    = gt_calloc(diagband_struct->num_diagbands,
                sizeof *diagband_struct->lastpos);
  diagband_struct->reset_from_matches = 0;
  diagband_struct->reset_with_memset = 0;
  return diagband_struct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0xd8069(%rip), %r14     # 0x3e9d71
movl $0x40, %edi
movq %r14, %rsi
movl $0x37, %edx
callq 0x1092b2
movq %rax, %rbx
movq $0x0, 0x18(%rax)
addq %r13, %r12
movl %r15d, %ecx
shrq %cl, %r12
leaq 0x1(%r12), %rax
movq %rax, 0x10(%rbx)
movq %r13, (%rbx)
movq %r15, 0x8(%rbx)
addq $0x3, %r12
movl $0x4, %esi
movq %r12, %rdi
movq %r14, %rdx
movl $0x41, %ecx
callq 0x1093ef
addq $0x4, %rax
movq %rax, 0x30(%rbx)
movq 0x10(%rbx), %rdi
movl $0x4, %esi
movq %r14, %rdx
movl $0x46, %ecx
callq 0x1093ef
movq %rax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd7fe7(%rip), %rsi     # 0x3e9d8d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
movq 0x28(%r14), %rdx
testq %rdx, %rdx
je 0x311dca
leaq 0xd8000(%rip), %rsi     # 0x3e9dc0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x311de4
leaq 0xd7ffb(%rip), %rsi     # 0x3e9dd5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17980
// File: /workspace/github_c_makefile_star2_O1/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 0x311e4c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
addq $-0x4, %rdi
movq %rdi, 0x30(%rbx)
leaq 0xd7f5a(%rip), %r14     # 0x3e9d71
movq %r14, %rsi
movl $0x64, %edx
callq 0x109670
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x65, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x66, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x311ec8
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 0x311ecd
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 0x311eac
movl %edx, %eax
subl %esi, %eax
jbe 0x311ec6
movl %edx, (%rcx,%r8,4)
movq 0x30(%rdi), %rcx
movl (%rcx,%r8,4), %edx
testl %edx, %edx
jne 0x311ea4
incq 0x18(%rdi)
addl %edx, %eax
movl %eax, (%rcx,%r8,4)
jmp 0x311ec6
movl %edx, (%rcx,%r8,4)
movq 0x30(%rdi), %rcx
movl (%rcx,%r8,4), %edx
testl %edx, %edx
jne 0x311ec0
incq 0x18(%rdi)
addl %eax, %edx
movl %edx, (%rcx,%r8,4)
popq %rax
retq
callq 0x90ca0
callq 0x90c69
// File: /workspace/github_c_makefile_star2_O1/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 0x311eff
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
callq 0x90cd7
// File: /workspace/github_c_makefile_star2_O1/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 0x311f43
movq %rdx, %rbx
testq %rdx, %rdx
je 0x311f3d
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r14
movl -0x8(%r14), %esi
movl -0x4(%r14), %edx
movl (%r14), %ecx
movq %r15, %rdi
callq 0x311e4d
addq $0xc, %r14
decq %rbx
jne 0x311f21
popq %rbx
popq %r14
popq %r15
retq
callq 0x90d10
// File: /workspace/github_c_makefile_star2_O1/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 0x120d23
movq %rax, %r14
leaq 0xd7d19(%rip), %rsi     # 0x3e9d71
movl $0x18, %edi
movl $0xf8, %edx
callq 0x1092b2
movq %rax, %rbx
movb %bpl, 0x1(%rax)
movb $0x0, (%rax)
leaq 0x4d0ff(%rip), %rsi     # 0x35f177
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
jne 0x312096
movb $0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x90dbb
// File: /workspace/github_c_makefile_star2_O1/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 0x31210b
cmpb $0x1, (%rdi)
jne 0x312110
leaq 0x99149(%rip), %rax     # 0x3ab232
leaq 0x7d8dc(%rip), %rsi     # 0x38f9cc
cmpb $0x0, 0x1(%rdi)
cmovneq %rax, %rsi
movq 0x8(%rdi), %rdx
leaq 0xd7e10(%rip), %rdi     # 0x3e9f13
xorl %eax, %eax
popq %rcx
jmp 0x17070
callq 0x90e2d
callq 0x90df4
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r12
decl %ecx
movl $0x1, %r13d
movl $0x1, %ebp
shlq %cl, %rbp
movl %esi, %esi
movq %rbx, %rcx
callq 0x329b7c
testq %r14, %r14
jle 0x31231a
addq %r15, %r14
movq $-0x1, %rax
xorl %ecx, %ecx
movzbl (%r15), %edx
cmpl $0xfe, %edx
je 0x3122b4
cmpl $0xff, %edx
je 0x31232c
movq (%r12,%rdx,8), %rdi
jmp 0x3122b6
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, %rbx
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
cmpq %r14, %r15
jb 0x31229a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90e9f
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %r8, 0x10(%rsp)
movq %rcx, %rbx
movq 0x50(%rsp), %r13
decl %ecx
movl $0x1, %ebp
shlq %cl, %rbp
movl %esi, %esi
movq %rdi, 0x8(%rsp)
movq %rbx, %rcx
callq 0x329b7c
leaq (%r14,%r13), %rax
cmpq %r14, %rax
jbe 0x31241a
movq $-0x1, %r12
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xec1f8
cmpb $-0x2, %al
je 0x3123ab
movzbl %al, %eax
cmpl $0xff, %eax
je 0x31242c
movq 0x8(%rsp), %rcx
movq (%rcx,%rax,8), %rdx
jmp 0x3123ad
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
movl $0x1, %edi
cmovneq %rdi, %rsi
addq %rsi, %rbx
leaq 0x1(,%rdx,2), %rdx
addq %rcx, %rcx
movq %rdx, %r12
orq %rax, %r12
notq %r12
orq %rcx, %r12
andq %rdx, %rax
incq %r14
movq %rax, %r15
decq %r13
jne 0x31237f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90ed6
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdi, %r12
movq 0x40(%rsp), %r13
decl %ecx
movl $0x1, %ebp
shlq %cl, %rbp
movl %esi, %esi
movq %r15, %rcx
callq 0x329c08
testq %r13, %r13
je 0x31252e
leaq (%rbx,%r14), %rax
decq %rax
cmpq %rbx, %rax
jb 0x312511
movq $-0x1, %rdi
xorl %ecx, %ecx
movl $0x1, %edx
movzbl (%rax), %esi
cmpl $0xfe, %esi
je 0x3124a5
cmpl $0xff, %esi
je 0x312529
movq (%r12,%rsi,8), %rsi
jmp 0x3124a7
xorl %esi, %esi
movq %rsi, %r8
andq %rdi, %r8
addq %rdi, %r8
xorq %rdi, %r8
orq %rsi, %r8
movq %r8, %r9
orq %rdi, %r9
notq %r9
orq %rcx, %r9
andq %rdi, %r8
movq %r8, %rdi
andq %rbp, %rdi
negq %rdi
movl $0x0, %edi
sbbq %rdi, %rdi
testq %rbp, %r9
cmovneq %rdx, %rdi
addq %rdi, %r15
cmpq %r13, %r15
jbe 0x312511
orq %rcx, %rsi
leaq 0x1(,%r9,2), %rdi
movq %rdi, %rcx
andq %rsi, %rcx
addq %r8, %r8
orq %rdi, %rsi
notq %rsi
orq %r8, %rsi
decq %rax
movq %rsi, %rdi
cmpq %rbx, %rax
jae 0x312488
addq %r14, %rbx
subq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90f0d
callq 0x90f44
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/dist-short.c
// Function: gt_forwardprefixmatch
Definedunsignedlong gt_forwardprefixmatch(const GtEncseq *encseq,
                                       unsigned int alphasize,
                                       GtUword startpos,
                                       bool nowildcards,
                                       GtUword *eqsvector,
                                       const GtUchar *useq,
                                       GtUword ulen,
                                       GtUword maxdistance)
{
  DECLARELOCALVARS;
  GtUword pos, totallength = gt_encseq_total_length(encseq);
  GtUchar cc;
  Definedunsignedlong result;

  gt_initeqsvector(eqsvector,(GtUword) alphasize,useq,ulen);
  gt_assert(maxdistance > 0);
  for (pos = startpos; /* Nothing */; pos++)
  {
    gt_assert(pos - startpos <= (GtUword) (ulen + maxdistance));
    cc = gt_encseq_get_encoded_char(encseq,pos,GT_READMODE_FORWARD);
    if (nowildcards && cc == (GtUchar) GT_WILDCARD)
    {
      result.defined = false;
      result.valueunsignedlong = 0;
      return result;
    }
    COMPUTENEWDIST(cc);
    if (distval <= maxdistance || pos == totallength-1)
    {
      break;
    }
  }
  result.defined = true;
  result.valueunsignedlong = (GtUword) (pos - startpos + 1);
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movl %ecx, 0x14(%rsp)
movq %rdx, %r15
movl %esi, %r13d
movq 0x70(%rsp), %r12
leal -0x1(%r12), %ecx
movl $0x1, %ebp
shlq %cl, %rbp
movq %rdi, 0x30(%rsp)
callq 0xec1d8
movq %rax, %rbx
movl %r13d, %esi
movq %r14, 0x18(%rsp)
movq %r14, %rdi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
callq 0x329b7c
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0x3126b0
addq %r12, %rax
movq %rax, 0x20(%rsp)
movq %r15, 0x8(%rsp)
subq %rbx, %r15
incq %r15
movq %r15, 0x28(%rsp)
movq $-0x1, %r15
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
leaq (%rax,%r13), %rsi
xorl %ebx, %ebx
movq 0x30(%rsp), %rdi
xorl %edx, %edx
callq 0xec1f8
cmpb $-0x2, %al
sete %cl
testb %cl, 0x14(%rsp)
jne 0x31268d
cmpb $-0x2, %al
je 0x312605
movzbl %al, %eax
cmpl $0xff, %eax
movq 0x78(%rsp), %rdi
je 0x3126ab
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rax
jmp 0x31260c
xorl %eax, %eax
movq 0x78(%rsp), %rdi
movq %rax, %rcx
andq %r15, %rcx
addq %r15, %rcx
xorq %r15, %rcx
orq %rax, %rcx
movq %rcx, %rdx
orq %r15, %rdx
notq %rdx
orq %r14, %rdx
andq %r15, %rcx
movq %rcx, %rsi
andq %rbp, %rsi
negq %rsi
movl $0x0, %esi
sbbq %rsi, %rsi
testq %rbp, %rdx
movl $0x1, %r8d
cmovneq %r8, %rsi
addq %rsi, %r12
cmpq %rdi, %r12
jbe 0x312692
movq 0x28(%rsp), %rsi
addq %r13, %rsi
je 0x312692
orq %r14, %rax
leaq 0x1(,%rdx,2), %rdx
movq %rdx, %r14
andq %rax, %r14
addq %rcx, %rcx
orq %rdx, %rax
notq %rax
orq %rcx, %rax
incq %r13
movq %rax, %r15
cmpq 0x20(%rsp), %r13
jbe 0x3125bd
callq 0x90fb4
xorl %r13d, %r13d
jmp 0x312697
incq %r13
movb $0x1, %bl
movl %ebx, %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90f7b
callq 0x90fed
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7cefa(%rip), %rdi     # 0x38f5c3
leaq 0xd798c(%rip), %rsi     # 0x3ea05c
movq %r14, %rdx
movl $0x8, %ecx
movl $0x1, %r8d
callq 0x10f73b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
addq $0x4, %r14
leaq 0xd797a(%rip), %rdi     # 0x3ea073
leaq 0xd797a(%rip), %rsi     # 0x3ea07a
movq %r14, %rdx
movl $0x8, %ecx
movl $0x1, %r8d
callq 0x10f73b
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10cd10
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x314254
callq 0x102b12
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x314261
callq 0x101f02
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x314270
popq %rbx
jmp 0x121b03
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x120955
movq %rax, %r12
leaq 0xd6491(%rip), %rsi     # 0x3ea723
movq %rax, %rdi
callq 0x12097f
movq %r12, %rdi
callq 0x120d23
leaq 0xd5e17(%rip), %rdx     # 0x3ea0c0
movq %rax, %rdi
movq %r15, %rsi
movl $0x6a4, %ecx            # imm = 0x6A4
movq %r14, %r8
callq 0x101c23
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x120e79
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0x121b03
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_O1/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 0x3158f3
movq %rdi, %rbx
leaq 0x1ae369(%rip), %rax    # 0x4c3bc0
cmpq %rax, (%rdi)
jne 0x3158f3
movq 0x78(%rbx), %rdi
leaq 0xd4855(%rip), %r14     # 0x3ea0c0
movq %r14, %rsi
movl $0x297, %edx            # imm = 0x297
callq 0x109670
movq 0xd0(%rbx), %rdi
movq %r14, %rsi
movl $0x298, %edx            # imm = 0x298
callq 0x109670
leaq 0x18(%rbx), %rdi
callq 0x314242
leaq 0x48(%rbx), %rdi
callq 0x3183a2
movq 0x8(%rbx), %rdi
callq 0x1a6aec
movq 0xa0(%rbx), %rdi
callq 0x1a6aec
movq 0x98(%rbx), %rdi
callq 0x1a6aec
movq 0x70(%rbx), %rdi
callq 0x318854
movq 0xa8(%rbx), %rdi
movq %r14, %rsi
movl $0x29f, %edx            # imm = 0x29F
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2a0, %edx            # imm = 0x2A0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
callq 0x9182a
// File: /workspace/github_c_makefile_star2_O1/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 $0x38, %rsp
testq %rdi, %rdi
je 0x3167c7
movq %rdi, %r14
leaq 0x1ad5a2(%rip), %rax    # 0x4c3bc0
cmpq %rax, (%rdi)
jne 0x3167c7
movb $-0x1, %al
cmpq %rsi, 0x10(%r14)
jbe 0x3167b8
movq %rdx, %r8
movq %rsp, %rdi
movl 0xb4(%r14), %ecx
movq %rsp, %rbx
leaq 0xf(%rcx), %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
movl 0xb4(%r14), %eax
movq %r15, %rcx
imulq %rax, %rcx
cmpq 0x10(%r14), %rcx
jae 0x3167b2
movq %rcx, -0x38(%rbp)
movq %rax, -0x60(%rbp)
movq %rdx, -0x40(%rbp)
movq %rbx, -0x48(%rbp)
movq %rdi, -0x50(%rbp)
movl 0xb0(%r14), %ecx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r8, -0x58(%rbp)
movq %r8, %rdx
callq 0x316e82
movq %rax, %rsi
movl (%rax), %ebx
movl 0x4(%rax), %eax
movl 0xe0(%r14), %ecx
movl 0xc0(%r14), %edx
addq %rcx, %rdx
movl 0xb8(%r14), %r12d
addq %rdx, %r12
addq %rax, %r12
movl 0xb0(%r14), %ecx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
movq %r14, -0x30(%rbp)
je 0x316720
movq %rdx, %r15
movl 0x68(%r14), %r13d
movq 0x10(%rsi), %rdi
movq %rsi, %r14
movq %r12, %rsi
movl %r13d, %edx
callq 0x2fba84
movq %r14, %rsi
movq -0x30(%rbp), %r14
movq 0x50(%r14), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movl 0x8(%rcx,%rax,8), %eax
addq %rax, %rbx
addq %r13, %r12
decl %r15d
jne 0x3166ee
movl 0x68(%r14), %edx
movq 0x10(%rsi), %rdi
movq %rsi, %r14
movq %r12, %rsi
callq 0x2fba84
movq -0x30(%rbp), %rcx
movq 0x50(%rcx), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %r15
movl 0x8(%rcx,%r15,8), %edx
movq 0x8(%r14), %rdi
movq -0x30(%rbp), %r14
movq %rbx, %rsi
callq 0x2fba84
movl 0xb4(%r14), %esi
movq -0x60(%rbp), %r12
cmpl %r12d, %esi
jb 0x3167cc
movl 0x64(%r14), %edx
movq 0x50(%r14), %rcx
movq 0x58(%r14), %rdi
imull %eax, %esi
imull %edx, %esi
addq 0x10(%rcx,%r15,8), %rsi
movq %r12, %rcx
movq -0x48(%rbp), %rbx
movq %rbx, %r8
callq 0x2fdfa6
movq 0x70(%r14), %rdi
movq -0x58(%rbp), %r9
addq $0x20, %r9
movq %rbx, %rsi
movq -0x38(%rbp), %rdx
movq %r12, %rcx
movq %rdx, %r8
callq 0x319a53
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rdi, %rsp
movb (%rbx,%rdx), %al
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x91c2a
callq 0x91bf1
// File: /workspace/github_c_makefile_star2_O1/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 0x3169ba
movq %rdi, %rbx
leaq 0x1ad3d3(%rip), %rax    # 0x4c3bc0
cmpq %rax, (%rdi)
jne 0x3169ba
leaq 0xd38c3(%rip), %rsi     # 0x3ea0c0
movl $0x28, %edi
movl $0x9c1, %edx            # imm = 0x9C1
callq 0x1092b2
movq %rax, %r14
movq 0x70(%rbx), %rdi
leaq 0x20(%rax), %rsi
callq 0x318d48
testq %r14, %r14
je 0x3169bf
movabsq $0x7ffffffffffffffc, %r15 # imm = 0x7FFFFFFFFFFFFFFC
movl $0x18, %r12d
cmpq $0x0, 0x28(%rbx)
jne 0x3168ce
movl 0xc0(%rbx), %ecx
addl 0xe0(%rbx), %ecx
addl 0xb8(%rbx), %ecx
movl 0xb0(%rbx), %eax
movl 0x68(%rbx), %edx
imull %eax, %edx
addl %ecx, %edx
movq 0x88(%rbx), %rcx
movq 0x90(%rbx), %rsi
addq %rsi, %rdx
addq $0x7, %rdx
movq %rdx, %rsi
shrq $0x3, %rsi
andl $0x7, %edx
cmpq $0x1, %rdx
sbbq $-0x1, %rsi
leaq 0x18(%rsi), %rdx
xorl %edi, %edi
testb $0x3, %sil
setne %dil
imull 0x6c(%rbx), %eax
andq %r15, %rdx
addq %rcx, %rax
addq $0x7, %rax
movq %rax, %rcx
shrq $0x3, %rcx
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %rcx
addq %rdx, %rcx
leaq (%rcx,%rdi,4), %rax
xorl %ecx, %ecx
testb $0x7, %al
setne %cl
leaq -0x4(%r15), %rdx
andq %rax, %rdx
leaq (%rdx,%rcx,8), %r12
movq $0x20, (%r14)
movq %r12, %rdi
shlq $0x5, %rdi
movl $0x200, %r13d           # imm = 0x200
addq %r13, %rdi
leaq 0xd37d4(%rip), %rsi     # 0x3ea0c0
movl $0x3de, %edx            # imm = 0x3DE
callq 0x1092b2
movq %rax, 0x8(%r14)
leaq 0x100(%rax), %rcx
movq %rcx, 0x10(%r14)
addq %r13, %rax
movq %rax, 0x18(%r14)
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x18(%r14), %rdx
addq %rax, %rdx
movq 0x10(%r14), %rsi
movq %rdx, (%rsi,%rcx,8)
cmpq $0x0, 0x28(%rbx)
jne 0x316991
movq 0x10(%r14), %rdx
movq (%rdx,%rcx,8), %rdx
leaq 0x18(%rdx), %rsi
movq %rsi, 0x10(%rdx)
movl 0xc0(%rbx), %esi
addl 0xe0(%rbx), %esi
addl 0xb8(%rbx), %esi
movl 0xb0(%rbx), %edi
imull 0x68(%rbx), %edi
addl %esi, %edi
movq 0x90(%rbx), %rsi
addq %rdi, %rsi
addq $0x7, %rsi
movq %rsi, %rdi
shrq $0x3, %rdi
andl $0x7, %esi
cmpq $0x1, %rsi
sbbq $-0x1, %rdi
leaq 0x18(%rdi), %rsi
xorl %r8d, %r8d
testb $0x3, %dil
setne %r8b
andq %r15, %rsi
addq %rdx, %rsi
leaq (%rsi,%r8,4), %rsi
movq %rsi, 0x8(%rdx)
movq 0x8(%r14), %rdx
movq $-0x1, (%rdx,%rcx,8)
incq %rcx
addq %r12, %rax
cmpq $0x20, %rcx
jne 0x316910
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x91c9c
callq 0x91c63
// File: /workspace/github_c_makefile_star2_O1/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 0x316a0b
leaq 0x1ad1ec(%rip), %rax    # 0x4c3bc0
cmpq %rax, (%rdi)
jne 0x316a0b
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0xd36d9(%rip), %r14     # 0x3ea0c0
movq %r14, %rsi
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9cf, %edx            # imm = 0x9CF
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
callq 0x91cd5
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x316d3e
movq %rdi, %rbx
leaq 0x1acf24(%rip), %rax    # 0x4c3bc0
cmpq %rax, (%rdi)
jne 0x316d43
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x316d1a
movq %rdx, %r14
orl $0x45480000, %esi       # imm = 0x45480000
movq 0x78(%rbx), %rcx
addq $0x8, %rcx
xorl %r15d, %r15d
cmpl %esi, (%rcx)
je 0x316cd4
addq $0x10, %rcx
decq %rax
jne 0x316cc5
jmp 0x316d1d
movq 0x18(%rbx), %rdi
movq -0x8(%rcx), %rsi
testq %r14, %r14
je 0x316d2a
addq $-0x8, %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x17cf0
testl %eax, %eax
jne 0x316d1d
movq 0x18(%rbx), %rcx
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x17b40
cmpq $0x2, %rax
jne 0x316d1a
movl 0xc(%rsp), %eax
movl %eax, (%r14)
jmp 0x316d38
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x17cf0
testl %eax, %eax
jne 0x316d1d
movq 0x18(%rbx), %r15
jmp 0x316d1d
callq 0x91db9
callq 0x91d80
// File: /workspace/github_c_makefile_star2_O1/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 0x316e3c
movq %rdi, %r15
leaq 0x1ace5a(%rip), %rax    # 0x4c3bc0
cmpq %rax, (%rdi)
jne 0x316e3c
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movl 0xb4(%r15), %ebx
imull 0xb0(%r15), %ebx
movq %rsi, %rax
xorl %edx, %edx
divq %rbx
movq %rax, %r12
leaq 0xd3ec6(%rip), %rdi     # 0x3eac5f
movq %r14, %rsi
callq 0x178c0
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %rbp, (%rsp)
movq %rbp, %r8
callq 0x317466
movl %eax, %ebp
cmpq %r13, %rbx
ja 0x316de6
leaq 0xd3f0f(%rip), %rdi     # 0x3eacd5
movq %r14, %rsi
callq 0x178c0
leaq -0x1(%r12), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
movq (%rsp), %r8
callq 0x317466
addl %eax, %ebp
movq 0x10(%r15), %rax
movl 0xb4(%r15), %ecx
imull 0xb0(%r15), %ecx
xorl %edx, %edx
divq %rcx
cmpq %rax, %r12
jae 0x316e2b
leaq 0xd3f45(%rip), %rdi     # 0x3ead4f
movq %r14, %rsi
callq 0x178c0
incq %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq (%rsp), %r8
callq 0x317466
addl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x91df2
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x316e7c
leaq 0x1acd73(%rip), %rax    # 0x4c3bc0
cmpq %rax, (%rdi)
jne 0x316e7c
movq %rcx, %r8
movq %rdx, %rcx
movl 0xb4(%rdi), %r9d
imull 0xb0(%rdi), %r9d
movq %rsi, %rax
xorl %edx, %edx
divq %r9
movq %rax, %rsi
movl $0xf, %edx
jmp 0x317466
pushq %rax
callq 0x91e2b
// File: /workspace/github_c_makefile_star2_O1/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
movl %ecx, %r14d
movq %rdx, %rax
movl %r8d, %ecx
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x3172e7
movq %rdi, %r12
movq %rdx, %r15
movq %rcx, -0x30(%rbp)
movl 0x20(%rbp), %edx
movq 0x10(%rbp), %rax
movzwl 0xc4(%rdi), %r13d
movq %rsi, -0x38(%rbp)
movq 0x10(%rsi), %rdi
movq %rax, %rsi
callq 0x2fba84
movl %eax, %eax
cmpq %rax, 0x48(%r12)
jbe 0x3172f9
movl 0x60(%r12), %edx
movq 0x58(%r12), %rdi
imulq %r13, %rax
movzbl %r14b, %esi
addq %rax, %rsi
imulq %rdx, %rsi
callq 0x2fba84
testl %eax, %eax
je 0x3172e7
movq %rsp, -0x40(%rbp)
movq %rsp, %r13
movq -0x30(%rbp), %rax
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
movl 0x68(%r12), %edx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rbp), %rsi
callq 0x2fba84
movq 0x50(%r12), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movq %rax, -0x30(%rbp)
movl 0x8(%rcx,%rax,8), %edx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rbp), %rsi
callq 0x2fba84
movl 0xb4(%r12), %esi
cmpl %r15d, %esi
jb 0x3172fe
movl 0x64(%r12), %edx
movq 0x50(%r12), %rcx
movq 0x58(%r12), %rdi
imull %eax, %esi
imull %edx, %esi
movq -0x30(%rbp), %rax
addq 0x10(%rcx,%rax,8), %rsi
movq %r15, %rcx
movq %r13, %r8
callq 0x2fdfa6
xorl %eax, %eax
xorl %ecx, %ecx
cmpb %r14b, (%r13,%rax)
sete %cl
addq %rcx, %rbx
incq %rax
cmpq %r15, %rax
jb 0x3172ce
movq -0x40(%rbp), %rsp
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x91e9d
callq 0x91ed6
// File: /workspace/github_c_makefile_star2_O1/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 0x2fba84
movq 0x50(%r14), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %r13
movl 0x8(%rcx,%r13,8), %edx
movq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x2fba84
testq %rbx, %rbx
je 0x317389
movl 0xb4(%r14), %esi
cmpl %ebp, %esi
jb 0x31738e
movl 0x64(%r14), %edx
movq 0x50(%r14), %rcx
movq 0x58(%r14), %rdi
imull %eax, %esi
imull %edx, %esi
addq 0x10(%rcx,%r13,8), %rsi
movl %ebp, %ecx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fdfa6
callq 0x91f48
callq 0x91f0f