LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/apmeoveridx.c
// Function: apme_freedfsconstinfo
static void apme_freedfsconstinfo(Limdfsconstinfo **mtptr)
{
  ApmeoveridxLimdfsconstinfo **mtiptr = (ApmeoveridxLimdfsconstinfo **) mtptr;
  gt_free((*mtiptr)->eqsvector);
  gt_free(*mtiptr);
  *mtiptr = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x1132a9(%rip), %rsi    # 0x5b5a4f
movl $0xc5, %edx
callq 0xe88c0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x113290(%rip), %rsi    # 0x5b5a4f
movl $0xc6, %edx
callq 0xe88c0
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/apmeoveridx.c
// Function: apme_initLimdfsstate
static void apme_initLimdfsstate(DECLAREPTRDFSSTATE(aliascolumn),
                                 Limdfsconstinfo *mt)
{
  ApmeoveridxLimdfsstate *column = (ApmeoveridxLimdfsstate *) aliascolumn;
  ApmeoveridxLimdfsconstinfo *mti = (ApmeoveridxLimdfsconstinfo *) mt;

  column->Mv = 0UL;
  if (mti->skpp)
  {
    column->Pv = 0UL; /* first column consists of 0 => skip pattern prefix */
    column->maxleqk = mti->patternlength;
    column->lastdistvalue = 0;
  } else
  {
    column->Pv = ~0UL; /* first column: 0 1 2 ... m */
    column->maxleqk = mti->maxdistance;
    column->lastdistvalue = mti->maxdistance;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rsp), %rax
testb $0x1, (%rax)
je 0x4a2842
movq -0x18(%rsp), %rax
movq $0x0, (%rax)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x4a2872
movq -0x18(%rsp), %rax
movq $-0x1, (%rax)
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x40, %edi
leaq 0x112a39(%rip), %rsi    # 0x5b5b98
movl $0x37, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x4a30e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
addq $0x2, %rdi
movl $0x4, %esi
leaq 0x1129c9(%rip), %rdx    # 0x5b5b98
movl $0x41, %ecx
callq 0xe83c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0x11298d(%rip), %rdx    # 0x5b5b98
movl $0x46, %ecx
callq 0xe83c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdx
movq 0x10(%rsp), %rax
addq 0x20(%rax), %rdx
leaq 0x112938(%rip), %rsi    # 0x5b5bb4
movb $0x0, %al
callq 0x199f0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x4a32ab
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdx
leaq 0x112943(%rip), %rsi    # 0x5b5be7
movb $0x0, %al
callq 0x199f0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x4a32d3
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0x112930(%rip), %rsi    # 0x5b5bfc
movb $0x0, %al
callq 0x199f0
movq 0x8(%rsp), %rdi
leaq 0xeff94(%rip), %rsi     # 0x593273
movb $0x0, %al
callq 0x199f0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4a3353
movq (%rsp), %rax
movq 0x30(%rax), %rcx
addq $-0x4, %rcx
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x11287d(%rip), %rsi    # 0x5b5b98
movl $0x64, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x112864(%rip), %rsi    # 0x5b5b98
movl $0x65, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x11284f(%rip), %rsi    # 0x5b5b98
movl $0x66, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagband-struct.c
// Function: gt_diagband_struct_dband_coverage
static GtUword gt_diagband_struct_dband_coverage(
                                    const GtDiagbandStruct *diagband_struct,
                                    GtUword diagband_idx)
{
  gt_assert(diagband_struct != NULL);
  return (GtUword) GT_MAX(diagband_struct->score[diagband_idx + 1],
                       diagband_struct->score[diagband_idx - 1])
         + (GtUword) diagband_struct->score[diagband_idx];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4a361e
movq 0x1989b3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x72a1c(%rip), %rsi     # 0x516013
leaq 0x112619(%rip), %rdx    # 0x5b5c17
leaq 0x112776(%rip), %rcx    # 0x5b5d7b
leaq 0x11258c(%rip), %r8     # 0x5b5b98
movl $0x97, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a3620
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movq 0x10(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x8(%rsp), %rdx
subq $0x1, %rdx
cmpl (%rcx,%rdx,4), %eax
jbe 0x4a3661
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
jmp 0x4a367a
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, %eax
movq 0x10(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x8(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
addq %rcx, %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x4a36f3
movq 0x1988de(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x72947(%rip), %rsi     # 0x516013
leaq 0x1125c7(%rip), %rdx    # 0x5b5c9a
leaq 0x1125d1(%rip), %rcx    # 0x5b5cab
leaq 0x1124b7(%rip), %r8     # 0x5b5b98
movl $0xb0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a36f5
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x4a3756
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
imulq $0xc, 0x8(%rsp), %rcx
addq %rcx, %rax
movl (%rax), %esi
movq 0x18(%rsp), %rax
imulq $0xc, 0x8(%rsp), %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movq 0x18(%rsp), %rax
imulq $0xc, 0x8(%rsp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
callq 0x4a3360
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4a36fe
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11dee0
movq %rax, 0x10(%rsp)
movl $0x18, %edi
leaq 0x1121ab(%rip), %rsi    # 0x5b5b98
movl $0xf8, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movb 0x1f(%rsp), %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x1(%rax)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rdi
leaq 0x83800(%rip), %rsi     # 0x52721f
callq 0x19980
cmpl $0x0, %eax
jne 0x4a3a33
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
jmp 0x4a3a6d
jmp 0x4a3a35
movq 0x198564(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x725cd(%rip), %rsi     # 0x516013
leaq 0xb5316(%rip), %rdx     # 0x558d63
leaq 0x112290(%rip), %rcx    # 0x5b5ce4
leaq 0x11213d(%rip), %r8     # 0x5b5b98
movl $0x101, %r9d            # imm = 0x101
movb $0x0, %al
callq 0x199f0
callq 0x19370
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4a3b24
movq 0x1984ad(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x72516(%rip), %rsi     # 0x516013
leaq 0x1121fb(%rip), %rdx    # 0x5b5cff
leaq 0x112210(%rip), %rcx    # 0x5b5d1b
leaq 0x112086(%rip), %r8     # 0x5b5b98
movl $0x114, %r9d            # imm = 0x114
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a3b26
movq (%rsp), %rax
testb $0x1, (%rax)
je 0x4a3b63
movq (%rsp), %rax
movb 0x1(%rax), %cl
leaq 0xb5226(%rip), %rsi     # 0x558d63
leaq 0x110d65(%rip), %rax    # 0x5b48a9
testb $0x1, %cl
cmovneq %rax, %rsi
movq (%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x1121e0(%rip), %rdi    # 0x5b5d3a
movb $0x0, %al
callq 0x19070
jmp 0x4a3b9d
jmp 0x4a3b65
movq 0x198434(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x7249d(%rip), %rsi     # 0x516013
leaq 0xb51e6(%rip), %rdx     # 0x558d63
leaq 0x112197(%rip), %rcx    # 0x5b5d1b
leaq 0x11200d(%rip), %r8     # 0x5b5b98
movl $0x11c, %r9d            # imm = 0x11C
movb $0x0, %al
callq 0x199f0
callq 0x19370
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq $-0x1, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x68(%rsp), %rcx
subq $0x1, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
movl 0x7c(%rsp), %eax
movl %eax, %esi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0x4d1d10
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x60(%rsp), %rcx
addq 0x58(%rsp), %rcx
cmpq %rcx, %rax
jae 0x4a40de
jmp 0x4a3f7a
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x4a3fc1
movq 0x198010(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x72079(%rip), %rsi     # 0x516013
leaq 0x111dfc(%rip), %rdx    # 0x5b5d9d
leaq 0x111e17(%rip), %rcx    # 0x5b5dbf
leaq 0x111e33(%rip), %r8     # 0x5b5de2
movl $0x54, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a3fc3
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
je 0x4a3fed
movq 0x80(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x40(%rsp)
jmp 0x4a3ff6
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
orq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
andq 0x50(%rsp), %rax
addq 0x50(%rsp), %rax
xorq 0x50(%rsp), %rax
orq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x30(%rsp), %rcx
orq 0x50(%rsp), %rcx
xorq $-0x1, %rcx
orq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
andq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
andq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x4a406d
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4a408d
movq 0x20(%rsp), %rax
andq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x4a408b
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4a408d
movq 0x28(%rsp), %rax
shlq %rax
orq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
shlq %rax
movq 0x38(%rsp), %rcx
orq 0x28(%rsp), %rcx
xorq $-0x1, %rcx
orq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x28(%rsp), %rax
andq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4a3f60
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq 0x90(%rsp), %rax
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq $-0x1, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x68(%rsp), %rcx
subq $0x1, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
movl 0x7c(%rsp), %eax
movl %eax, %esi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0x4d1d10
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x58(%rsp), %rcx
addq 0x90(%rsp), %rcx
cmpq %rcx, %rax
jae 0x4a42fe
movq 0x60(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xa9da0
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xff, %eax
jne 0x4a41e9
movq 0x197de8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x71e51(%rip), %rsi     # 0x516013
leaq 0x111c30(%rip), %rdx    # 0x5b5df9
leaq 0x111c48(%rip), %rcx    # 0x5b5e18
leaq 0x111c0b(%rip), %r8     # 0x5b5de2
movl $0x69, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a41eb
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
je 0x4a420f
movq 0x80(%rsp), %rax
movzbl 0xf(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x40(%rsp)
jmp 0x4a4218
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
orq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
andq 0x50(%rsp), %rax
addq 0x50(%rsp), %rax
xorq 0x50(%rsp), %rax
orq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x30(%rsp), %rcx
orq 0x50(%rsp), %rcx
xorq $-0x1, %rcx
orq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
andq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
andq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x4a428f
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4a42af
movq 0x20(%rsp), %rax
andq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x4a42ad
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4a42af
movq 0x28(%rsp), %rax
shlq %rax
orq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
shlq %rax
movq 0x38(%rsp), %rcx
orq 0x28(%rsp), %rcx
xorq $-0x1, %rcx
orq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x28(%rsp), %rax
andq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4a4177
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdx
leaq 0xb4050(%rip), %rdi     # 0x55895a
leaq 0x111594(%rip), %rsi    # 0x5b5ea5
movl $0x8, %ecx
movl $0x1, %r8d
callq 0xf6510
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf1600
movq 0x8(%rsp), %rdx
addq $0x4, %rdx
leaq 0x111579(%rip), %rdi    # 0x5b5ebc
leaq 0x111579(%rip), %rsi    # 0x5b5ec3
movl $0x8, %ecx
movl $0x1, %r8d
callq 0xf6510
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf1600
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4a657d
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xdb2a0
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x4a6593
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xd9570
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4a65ab
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movw 0xc4(%rax), %ax
movw %ax, 0xa(%rsp)
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl 0xbc(%rax), %ecx
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movl %ecx, (%rax)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movzwl 0xa(%rsp), %ecx
cmpl %ecx, %eax
jae 0x4a66a2
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movl 0xbc(%rax), %eax
movq 0x10(%rsp), %rcx
movq 0xd0(%rcx), %rcx
movl 0xc(%rsp), %esi
movl %eax, (%rcx,%rsi,4)
addl %eax, %edx
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
movl 0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4a663d
movzwl 0xa(%rsp), %ecx
movq 0x10(%rsp), %rax
imull 0xbc(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xe0(%rax)
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movq 0x10(%rsp), %rcx
addl 0xbc(%rcx), %eax
movq 0x10(%rsp), %rcx
cmpl 0xe0(%rcx), %eax
je 0x4a6726
movq 0x1958ab(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6f914(%rip), %rsi     # 0x516013
leaq 0x10fe8b(%rip), %rdx    # 0x5b6591
leaq 0x10fed6(%rip), %rcx    # 0x5b65e3
leaq 0x10f7f4(%rip), %r8     # 0x5b5f08
movl $0x305, %r9d            # imm = 0x305
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a6728
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: vwBits
static inline BitOffset
vwBits(GtUword seqLen, unsigned blockSize, unsigned bucketBlocks,
       unsigned maxPermIdxBits, varExtBitsEstimator biVarBits, void *cbState,
       struct varBitsEstimate *extVarBitsUpperBound)
{
  size_t bucketLen = (size_t)bucketBlocks * blockSize;
  BitOffset maxVarBits = numBuckets(seqLen, bucketLen)
    * (maxPermIdxBits * bucketBlocks);
  if (biVarBits)
  {
    struct segmentDesc desc[2];
    struct varBitsEstimate *extVarBits, extVarBitsTemp;
    extVarBits = extVarBitsUpperBound?extVarBitsUpperBound:&extVarBitsTemp;
    desc[0].repeatCount = (seqLen + 1) / bucketLen;
    desc[0].len = bucketLen;
    desc[1].repeatCount = ((seqLen + 1) % bucketLen)?1:0;
    desc[1].len = seqLen % bucketLen;
    if (biVarBits(cbState, desc, sizeof (desc)/sizeof (desc[0]), extVarBits))
      maxVarBits += extVarBits->maxBitsTotal;
    else
      maxVarBits += numBuckets(seqLen, bucketLen)
        * extVarBits->maxBitsPerBucket;
  }
  else if (extVarBitsUpperBound)
  {
    extVarBitsUpperBound->maxBitsTotal
      = extVarBitsUpperBound->maxBitsPerBucket
      = extVarBitsUpperBound->maxBitsPerPos = 0;
  }
  return maxVarBits;
}

// Assembly:
subq $0x88, %rsp
movq 0x90(%rsp), %rax
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movl %edx, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
movq %r8, 0x68(%rsp)
movq %r9, 0x60(%rsp)
movl 0x78(%rsp), %eax
movl 0x7c(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x80(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x4aa100
movl 0x74(%rsp), %ecx
imull 0x78(%rsp), %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x4a6892
cmpq $0x0, 0x90(%rsp)
je 0x4a67ba
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x4a67c6
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x4a67c6
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rax
addq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x58(%rsp)
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rax
addq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x58(%rsp)
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
cltq
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x58(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rcx
movl $0x2, %edx
callq *%rax
testb $0x1, %al
jne 0x4a6855
jmp 0x4a686a
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
addq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x4a6890
movq 0x80(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x4aa100
movq 0x28(%rsp), %rcx
imulq 0x8(%rcx), %rax
addq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x4a68ce
cmpq $0x0, 0x90(%rsp)
je 0x4a68cc
movq 0x90(%rsp), %rax
movq $0x0, (%rax)
movq 0x90(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x90(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0x4a68ce
movq 0x50(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: blockEncIdxSeqHeaderLength
static inline size_t
blockEncIdxSeqHeaderLength(const struct blockCompositionSeq *seqIdx,
                           size_t numExtHeaders, const uint32_t *extHeaderSizes)
{
  size_t headerSize =
    4                           /* BDX identifier */
    + 4                         /* length field */
    + 8                         /* block size */
    + 8                         /* blocks per bucket */
    + 12                        /* offset of variable length data */
    + 12                        /* offset of range encodings */
    + 4 + 4                     /* bits used per seqpos */
    + 4 + 4                     /* bits used per variable bit offset */
    + 4 + 4 + 4 * seqIdx->blockMapAlphabetSize /* bit counts for partial sums */
    + 4 + 4                     /* block encoding fallback symbol */
    + 4 + 4                     /* range encoding fallback symbol */
    + 4 + 4                     /* num modes */
    + 4 + 8                     /* length of sequence */
    + 4 * seqIdx->numModes      /* one uint32_t for every mode */
    ;
  if (seqIdx->callBackDataOffsetBits)
    headerSize += 4 + 4         /* extra offset bits per constant block */
      + 4 + 8                   /* extension bits stored in constant block */
      + 4 + 8;                  /* variable area bits added per bucket max */

  headerSize += extHeadersSizeAggregate(numExtHeaders, extHeaderSizes);
  return headerSize;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movzwl 0xc4(%rax), %eax
shll $0x2, %eax
addl $0x48, %eax
addl $0x4, %eax
addl $0x4, %eax
addl $0x4, %eax
addl $0x4, %eax
addl $0x4, %eax
addl $0x4, %eax
addl $0x4, %eax
addl $0x8, %eax
movq 0x20(%rsp), %rcx
movl 0xc8(%rcx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
cltq
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0xb8(%rax)
je 0x4a6950
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4aa1f0
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11d510
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10fc47(%rip), %rsi    # 0x5b65fa
callq 0x11d550
movq 0x8(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %r8
leaq 0x10f532(%rip), %rdx    # 0x5b5f08
movl $0x6a4, %ecx            # imm = 0x6A4
callq 0xd8df0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x11e360
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x11f560
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x4a6a20
movl $0x0, 0x34(%rsp)
jmp 0x4a6a28
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: cwSize
static inline off_t
cwSize(const struct blockCompositionSeq *seqIdx)
{
  off_t cwLen;
  cwLen = bitElemsAllocSize(
    superBlockCWBits(seqIdx)
    * numBuckets(seqIdx->baseClass.seqLen,
                 seqIdx->bucketBlocks * seqIdx->blockSize)) * sizeof (BitElem);
  return cwLen;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4aa0b0
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0xb0(%rax), %eax
movq 0x10(%rsp), %rcx
imull 0xb4(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4aa100
movq (%rsp), %rdi
imulq %rax, %rdi
callq 0x4a6b00
shlq $0x0, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: initAppendState
static inline void
initAppendState(struct appendState *aState,
                const struct blockCompositionSeq *seqIdx)
{
  BitOffset compCacheLen = superBlockCWBits(seqIdx) + bitElemBits - 1,
    permCacheLen = superBlockVarMaxBits(seqIdx) + bitElemBits - 1;
  aState->compCacheLen = compCacheLen;
  aState->permCacheLen = permCacheLen;
  aState->compCache = gt_calloc(sizeof (BitElem),
                                bitElemsAllocSize(compCacheLen));
  aState->permCache = gt_calloc(sizeof (BitElem),
                                bitElemsAllocSize(permCacheLen));
  aState->cwMemPos = cwPreCompIdxBits(seqIdx);
  aState->cwDiskOffset = aState->varMemPos = aState->cwMemOldBits =
    aState->varDiskOffset = aState->varMemOldBits = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4aa0b0
addq $0x8, %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4aa1c0
addq $0x8, %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
callq 0x4a6b00
movq %rax, %rsi
movl $0x1, %edi
leaq 0x10f307(%rip), %rdx    # 0x5b5f08
movl $0x6d0, %ecx            # imm = 0x6D0
callq 0xe83c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x4a6b00
movq %rax, %rsi
movl $0x1, %edi
leaq 0x10f2d9(%rip), %rdx    # 0x5b5f08
movl $0x6d2, %ecx            # imm = 0x6D2
callq 0xe83c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x4aa080
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x40(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x44(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x38(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: addBlock2OutputBuffer
static void
addBlock2OutputBuffer(
  struct blockCompositionSeq *newSeqIdx,
  partialSymSum *buck, GtUword blockNum,
  Symbol *block, unsigned blockSize,
  const MRAEnc *alphabet, const int *modes,
  const MRAEnc *blockMapAlphabet, AlphabetRangeSize blockMapAlphabetSize,
  BitString permCompBSPreAlloc, unsigned *compositionPreAlloc,
  unsigned compositionIdxBits, struct appendState *aState)
{
  PermCompIndex permCompIdx[2];
  unsigned significantPermIdxBits;
  /* a. update superbucket table */
  addBlock2PartialSymSums(buck, block, blockSize);
  /* b. add ranges of differently encoded symbols to
   * corresponding representation */
  addRangeEncodedSyms(newSeqIdx->rangeEncs, block, blockSize,
                      blockNum, alphabet, REGIONS_LIST,
                      modes);
  /* c. add to table of composition/permutation indices */
  gt_MRAEncSymbolsTransform(blockMapAlphabet, block, blockSize);
  /* FIXME control remapping */
  /* currently invalid characters in input can seriously break this */
  gt_block2IndexPair(&newSeqIdx->compositionTable, blockSize,
                  blockMapAlphabetSize, block, permCompIdx,
                  &significantPermIdxBits,
                  permCompBSPreAlloc, compositionPreAlloc);
  append2IdxOutput(aState, permCompIdx, compositionIdxBits,
                   significantPermIdxBits);
}

// Assembly:
subq $0x58, %rsp
movq 0x90(%rsp), %rax
movl 0x88(%rsp), %eax
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movw 0x70(%rsp), %ax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq %r9, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x4a96a0
movq 0x50(%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x40(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x60(%rsp), %rax
movl $0x2, %r9d
movq %rax, (%rsp)
callq 0x4a96f0
movq 0x68(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %eax
movl %eax, %edx
callq 0x22b420
movq 0x50(%rsp), %rdi
addq $0x48, %rdi
movl 0x34(%rsp), %esi
movzwl 0x70(%rsp), %edx
movq 0x38(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq 0x78(%rsp), %r10
movq 0x80(%rsp), %rax
leaq 0x1c(%rsp), %r9
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x4af360
movq 0x90(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl 0x88(%rsp), %edx
movl 0x1c(%rsp), %ecx
callq 0x4a9800
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: writeOutputBuffer
static int
writeOutputBuffer(struct blockCompositionSeq *newSeqIdx,
                  struct appendState *aState, bitInsertFunc biFunc,
                  GtUword lastUpdatePos, size_t bucketLen,
                  unsigned callBackDataOffsetBits, void *cbState,
                  const partialSymSum *buckLast)
{
  if (biFunc)
    if (appendCallBackOutput(aState, newSeqIdx, biFunc,
                             lastUpdatePos, bucketLen,
                             callBackDataOffsetBits, cbState)
        == (BitOffset)-1)
    {
      perror("error condition while writing block-compressed"
             " index data");
      return -1;
    }
  if (!updateIdxOutput(newSeqIdx, aState, buckLast))
  {
    perror("error condition while writing block-compressed"
           " index data");
    return -1;
  }
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x4a6e6e
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl 0x14(%rsp), %r9d
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x4a9930
cmpq $-0x1, %rax
jne 0x4a6e6c
leaq 0x10f266(%rip), %rdi    # 0x5b60c3
callq 0x19640
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x4a6ea5
jmp 0x4a6e6e
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x4a9ac0
cmpl $0x0, %eax
jne 0x4a6e9d
leaq 0x10f235(%rip), %rdi    # 0x5b60c3
callq 0x19640
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x4a6ea5
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rsp), %rcx
subq 0x18(%rcx), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x4a7aef
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
je 0x4a7aef
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4a7b27
movq 0x1944aa(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6e513(%rip), %rsi     # 0x516013
leaq 0x10eb61(%rip), %rdx    # 0x5b6668
leaq 0x10eb90(%rip), %rcx    # 0x5b669e
leaq 0x10e3f3(%rip), %r8     # 0x5b5f08
movl $0x945, %r9d            # imm = 0x945
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a7b29
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x197a0
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11dee0
movl 0x24(%rsp), %edi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rcx
xorl %r9d, %r9d
leaq 0x10e3a1(%rip), %rax    # 0x5b5f08
xorl %r8d, %r8d
movl %r9d, %r8d
movq %rax, (%rsp)
movl $0x949, 0x8(%rsp)       # imm = 0x949
movq $0x0, 0x10(%rsp)
callq 0xda1e0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %eax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: addRangeEncodedSyms
static void
addRangeEncodedSyms(struct seqRangeList *rangeList, const Symbol *block,
                    unsigned blockSize, GtUword blockNum,
                    const MRAEnc *alphabet, int selection, const int *rangeSel)
{
  unsigned i;
  for (i = 0; i < blockSize; ++i)
  {
    gt_assert(gt_MRAEncSymbolIsInSelectedRanges(alphabet, block[i],
                                          selection, rangeSel) >= 0);
    if (gt_MRAEncSymbolIsInSelectedRanges(alphabet, block[i], selection,
                                          rangeSel)) {
      gt_SRLAddPosition(rangeList, blockNum * blockSize + i, block[i]);
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x4a97f3
jmp 0x4a972e
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x8(%rsp), %ecx
movb (%rax,%rcx), %al
movl 0xc(%rsp), %edx
movq 0x40(%rsp), %rcx
movzbl %al, %esi
callq 0x22b530
cmpl $0x0, %eax
jge 0x4a978d
movq 0x192844(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6c8ad(%rip), %rsi     # 0x516013
leaq 0x10cb62(%rip), %rdx    # 0x5b62cf
leaq 0x10cbab(%rip), %rcx    # 0x5b631f
leaq 0x10c78d(%rip), %r8     # 0x5b5f08
movl $0x9b2, %r9d            # imm = 0x9B2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a978f
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x8(%rsp), %ecx
movb (%rax,%rcx), %al
movl 0xc(%rsp), %edx
movq 0x40(%rsp), %rcx
movzbl %al, %esi
callq 0x22b530
cmpl $0x0, %eax
je 0x4a97e1
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %eax
imulq %rax, %rsi
movl 0x8(%rsp), %eax
addq %rax, %rsi
movq 0x28(%rsp), %rax
movl 0x8(%rsp), %ecx
movzbl (%rax,%rcx), %edx
callq 0x4b0760
jmp 0x4a97e3
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4a971e
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: append2IdxOutput
static inline void
append2IdxOutput(struct appendState *state,
                 PermCompIndex permCompIdx[2],
                 unsigned bitsOfCompositionIdx, unsigned bitsOfPermutationIdx)
{
  gt_assert(state->cwMemPos + bitsOfCompositionIdx <= state->compCacheLen);
  gt_bsStorePermCompIndex(state->compCache, state->cwMemPos,
                          bitsOfCompositionIdx, permCompIdx[0]);
  state->cwMemPos += bitsOfCompositionIdx;
  gt_assert(state->varMemPos + bitsOfPermutationIdx <= state->permCacheLen);
  gt_bsStorePermCompIndex(state->permCache, state->varMemPos,
                          bitsOfPermutationIdx, permCompIdx[1]);
  state->varMemPos += bitsOfPermutationIdx;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x4(%rsp), %ecx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x4a9868
movq 0x192769(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6c7d2(%rip), %rsi     # 0x516013
leaq 0x10caeb(%rip), %rdx    # 0x5b6333
leaq 0x10cb22(%rip), %rcx    # 0x5b6371
leaq 0x10c6b2(%rip), %r8     # 0x5b5f08
movl $0x6e7, %r9d            # imm = 0x6E7
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a986a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movl 0x4(%rsp), %edx
movq 0x8(%rsp), %rax
movl (%rax), %ecx
callq 0x474070
movl 0x4(%rsp), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movl (%rsp), %ecx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x4a98f0
movq 0x1926e1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6c74a(%rip), %rsi     # 0x516013
leaq 0x10cab2(%rip), %rdx    # 0x5b6382
leaq 0x10ca9a(%rip), %rcx    # 0x5b6371
leaq 0x10c62a(%rip), %r8     # 0x5b5f08
movl $0x6eb, %r9d            # imm = 0x6EB
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a98f2
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
movl (%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
callq 0x474070
movl (%rsp), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: appendCallBackOutput
static BitOffset
appendCallBackOutput(struct appendState *state,
                     const struct blockCompositionSeq *seqIdx,
                     bitInsertFunc biFunc, GtUword start,
                     GtUword len, unsigned callBackDataOffsetBits,
                     void *cbState)
{
  BitOffset bitsWritten;
  gt_assert(state);
  if (callBackDataOffsetBits)
  {
    BitOffset offset = cwPreCBOffsetBits(seqIdx);
    gt_bsStoreUInt64(state->compCache, state->cwMemOldBits + offset,
                  callBackDataOffsetBits,
                  state->varMemPos - state->varMemOldBits);
  }
  bitsWritten = biFunc(state->compCache, state->cwMemOldBits
                       + cwPreCWExtBits(seqIdx),
                       state->permCache, state->varMemPos, start, len, cbState);
  if (bitsWritten == (BitOffset)-1)
    return bitsWritten;
  state->cwMemPos = cwPreCWExtBits(seqIdx) + state->cwMemOldBits
    + seqIdx->cwExtBitsPerBucket;
  state->varMemPos += bitsWritten;
  return bitsWritten;
}

// Assembly:
subq $0x68, %rsp
movq 0x70(%rsp), %rax
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movl %r9d, 0x34(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x4a9997
movq 0x19263a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6c6a3(%rip), %rsi     # 0x516013
leaq 0xbc657(%rip), %rdx     # 0x565fce
leaq 0x10ca43(%rip), %rcx    # 0x5b63c1
leaq 0x10c583(%rip), %r8     # 0x5b5f08
movl $0x6f9, %r9d            # imm = 0x6F9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a9999
cmpl $0x0, 0x34(%rsp)
je 0x4a99e3
movq 0x50(%rsp), %rdi
callq 0x4a9ff0
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rdi
movq 0x58(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, %esi
addq 0x20(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x58(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x58(%rsp), %rax
movl 0x40(%rax), %eax
subq %rax, %rcx
callq 0x4770f0
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movl 0x44(%rax), %eax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4aa020
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq %rcx, %rsi
movq 0x58(%rsp), %rcx
movq 0x8(%rcx), %rdx
movq 0x58(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
movq 0x70(%rsp), %r10
movq %r10, (%rsp)
callq *%rax
movq %rax, 0x28(%rsp)
cmpq $-0x1, 0x28(%rsp)
jne 0x4a9a66
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x4a9aaf
movq 0x50(%rsp), %rdi
callq 0x4aa020
movq %rax, %rcx
movq 0x58(%rsp), %rax
movl 0x44(%rax), %eax
addq %rax, %rcx
movq 0x50(%rsp), %rax
addq 0x90(%rax), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rcx
movq 0x58(%rsp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0xe0(%rax), %eax
movq -0x8(%rsp), %rcx
addl 0xc0(%rcx), %eax
movq -0x8(%rsp), %rcx
addl 0xb8(%rcx), %eax
movq -0x8(%rsp), %rcx
movl 0x68(%rcx), %ecx
movq -0x8(%rsp), %rdx
imull 0xb0(%rdx), %ecx
addl %ecx, %eax
movl %eax, %eax
movq -0x8(%rsp), %rcx
addq 0x90(%rcx), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: extHeadersSizeAggregate
static inline off_t
extHeadersSizeAggregate(size_t numExtHeaders, const uint32_t *extHeaderSizes)
{
  off_t len = 0, i;
  for (i = 0; i < numExtHeaders; ++i)
    len += extHeaderSizes[i] + EXT_HEADER_PREFIX_SIZE;
  return len;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x8(%rsp), %rax
jae 0x4aa244
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl $0x8, %eax
movl %eax, %eax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x4aa20c
movq -0x18(%rsp), %rax
retq
nopw (%rax,%rax)