LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_set
static void gt_firstcodes_countocc_set(GtFirstcodestab *fct,
                                       GtUword *differences,
                                       GtUword idx,
                                       GtUword value)
{
  gt_assert(value > 0);
  if (fct->countocc_small == NULL)
  {
    if (value <= fct->countmax)
    {
      differences[idx] |= (value << fct->shiftforcounts);
    } else
    {
      differences[idx] &= fct->differencemask;
      ul_u32_gt_hashmap_add(fct->countocc_exceptions,idx,
                            (uint32_t) (value - fct->countmax));
      fct->hashmap_addcount++;
    }
  } else
  {
    if (value <= GT_FIRSTCODES_MAXSMALL)
    {
      fct->countocc_small[idx] = (GtCountAFCtype) value;
    } else
    {
      fct->countocc_small[idx] = 0;
      ul_u32_gt_hashmap_add(fct->countocc_exceptions,idx,
                            value - GT_FIRSTCODES_MAXSMALL);
      fct->hashmap_addcount++;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rcx, %rcx
je 0x3171da
movq %rcx, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x31717d
cmpq $0xff, %rbx
ja 0x317195
movb %bl, (%rax,%rdx)
jmp 0x3171d2
cmpq %rbx, 0x60(%r14)
jae 0x3171c7
movq 0x58(%r14), %rax
andq %rax, (%rsi,%rdx,8)
subl 0x60(%r14), %ebx
movq 0x40(%r14), %rdi
jmp 0x3171a3
movb $0x0, (%rax,%rdx)
movq 0x40(%r14), %rdi
addl $0xffffff01, %ebx       # imm = 0xFFFFFF01
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
movl %ebx, 0x8(%rsi)
movq %rsp, %rdx
callq 0x1015ee
testl %eax, %eax
jne 0x3171c1
movq (%rsp), %rax
movl %ebx, 0x8(%rax)
incq 0x18(%r14)
jmp 0x3171d2
movb 0x68(%r14), %cl
shlq %cl, %rbx
orq %rbx, (%rsi,%rdx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x9168e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_accumulatecounts_merge
GtUword gt_firstcodes_accumulatecounts_merge(
                                        GtFirstcodestab *tab,
                                        GtUword *differences,
                                        GtUword differentcodes,
                                        const GtUword *querystream_fst,
                                        const GtUword *querystream_lst,
                                        GtUword subjectindex,
                                        GtUword subjectcode)
{
  GtUword found = 0, lastocc = 0;
  const GtUword *query = querystream_fst;

  gt_assert(subjectindex < differentcodes);
  while (query <= querystream_lst)
  {
    if (*query <= subjectcode)
    {
      if (*query == subjectcode)
      {
        lastocc++;
      }
      query++;
    } else
    {
      if (lastocc > 0)
      {
        gt_firstcodes_countocc_increment(tab,differences,subjectindex,lastocc);
        found += lastocc;
        lastocc = 0;
      }
      if (subjectindex < differentcodes - 1)
      {
        subjectindex++;
        /* extract diff */
        subjectcode += (differences[subjectindex] & tab->differencemask);
      } else
      {
        break;
      }
    }
  }
  if (lastocc > 0)
  {
    gt_firstcodes_countocc_increment(tab,differences,subjectindex,lastocc);
    found += lastocc;
  }
  return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
cmpq %rdx, %r9
jae 0x3172b4
movq %r8, %r15
movq %rcx, %rbp
cmpq %r8, %rcx
jbe 0x317212
xorl %r12d, %r12d
jmp 0x3172a2
movq %r9, %rbx
movq %rdx, %r13
movq 0x50(%rsp), %rsi
decq %r13
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpq %rsi, (%rbp)
jbe 0x317274
testq %r14, %r14
je 0x317252
movq (%rsp), %rdi
movq %rsi, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x3172b9
movq 0x10(%rsp), %rsi
addq %r14, %r12
cmpq %r13, %rbx
jae 0x3172a2
movq (%rsp), %rcx
movq 0x58(%rcx), %rcx
movq 0x8(%rsp), %rdx
andq 0x8(%rdx,%rbx,8), %rcx
incq %rbx
addq %rcx, %rsi
xorl %r14d, %r14d
jmp 0x317281
sete %cl
movzbl %cl, %ecx
addq %rcx, %r14
addq $0x8, %rbp
cmpq %r15, %rbp
jbe 0x317226
testq %r14, %r14
je 0x3172a2
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x3172b9
addq %r14, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x916c5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_get
static uint32_t gt_firstcodes_countocc_get(const GtFirstcodestab *fct,
                                           const GtUword *differences,
                                           GtUword idx)
{
  if (fct->countocc_small == NULL)
  {
    GtUword count;

    if ((count = (GtUword) (differences[idx] >> fct->shiftforcounts)) > 0)
    {
      return (uint32_t) count;
    } else
    {
      uint32_t *valueptr = ul_u32_gt_hashmap_get(fct->countocc_exceptions,idx);

      gt_assert(valueptr != NULL);
      return *valueptr + (uint32_t) fct->countmax;
    }
  } else
  {
    if (fct->countocc_small[idx] > 0)
    {
      return (uint32_t) fct->countocc_small[idx];
    } else
    {
      uint32_t *valueptr = ul_u32_gt_hashmap_get(fct->countocc_exceptions,idx);

      gt_assert(valueptr != NULL);
      return *valueptr + (uint32_t) GT_FIRSTCODES_MAXSMALL;
    }
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x31790e
movzbl (%rax,%rdx), %eax
testl %eax, %eax
jne 0x317939
movq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
callq 0x1012ee
testq %rax, %rax
je 0x31793f
movq %rax, %rcx
movl $0xff, %eax
addl 0x8(%rcx), %eax
jmp 0x317939
movq (%rsi,%rdx,8), %rax
movb 0x68(%rbx), %cl
shrq %cl, %rax
testq %rax, %rax
jne 0x317939
movq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
callq 0x1012ee
testq %rax, %rax
je 0x317944
movl 0x8(%rax), %eax
addl 0x60(%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x9196f
callq 0x919a8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_get_leftborder
GtUword gt_firstcodes_get_leftborder(const GtFirstcodestab *fct,
                                           GtUword idx)
{
#if defined (_LP64) || defined (_WIN64)
  GT_CHANGEPOINT_GET(changepoint);

  return (GtUword) fct->leftborder[idx]
                         + (changepoint << GT_MODVALUEBITS);
#else
  return (GtUword) fct->leftborder[idx];
#endif
}

// Assembly:
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x31798e
movq 0x70(%rdi), %rdx
xorl %ecx, %ecx
cmpq %rsi, (%rdx,%rcx,8)
jae 0x317988
incq %rcx
cmpq %rcx, %rax
jne 0x317977
movq %rax, %rcx
shlq $0x20, %rcx
jmp 0x317990
xorl %ecx, %ecx
movq 0x30(%rdi), %rax
movl (%rax,%rsi,4), %eax
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_findfirstsamplelarger
GtUword gt_firstcodes_findfirstsamplelarger(const GtFirstcodestab *fct,
                                                  GtUword suftaboffset)
{
  GtUword left = 0, right, mid, midval, found;

  right = found = fct->numofsamples;
  while (left+1 < right)
  {
    mid = GT_DIV2(left+right);
    midval = gt_firstcodes_get_sample(fct,mid);
    if (suftaboffset == midval)
    {
      return mid;
    }
    if (suftaboffset < midval)
    {
      found = mid;
      right = mid - 1;
    } else
    {
      left = mid + 1;
    }
  }
  gt_assert(suftaboffset <= gt_firstcodes_get_sample(fct,found));
  return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
cmpq $0x2, %r12
jb 0x3179f9
xorl %r13d, %r13d
movq %r12, %rbp
movq %r13, %r15
addq %rbp, %r15
shrq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x317950
cmpq %rbx, %rax
je 0x317a0c
ja 0x3179e7
incq %r15
movq %r15, %r13
movq %r12, %r15
jmp 0x3179ee
leaq -0x1(%r15), %rbp
movq %r15, %r12
leaq 0x1(%r13), %rax
cmpq %rbp, %rax
jb 0x3179c1
jmp 0x3179fc
movq %r12, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x317950
cmpq %rbx, %rax
jb 0x317a1e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x91a1a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_sample2full
GtUword gt_firstcodes_sample2full(const GtFirstcodestab *fct,
                                        GtUword idx)
{
  gt_assert(idx <= fct->numofsamples);
  if (idx < fct->numofsamples)
  {
    return (GtUword) idx << (GtUword) fct->sampleshift;
  }
  return fct->differentcodes - 1;
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
jb 0x317a3d
jbe 0x317a33
movb 0x28(%rdi), %cl
shlq %cl, %rsi
jmp 0x317a39
movq (%rdi), %rsi
decq %rsi
movq %rsi, %rax
retq
pushq %rax
callq 0x91a53
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_samples_delete
void gt_firstcodes_samples_delete(GtFirstcodesspacelog *fcsl,
                                  GtFirstcodestab *fct)
{
  if (fct->leftborder_samples != NULL)
  {
    gt_free(fct->leftborder_samples);
    GT_FCI_SUBTRACTWORKSPACE(fcsl,"leftborder_samples");
    fct->leftborder_samples = NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x317a98
movq %rsi, %rbx
leaq 0xcac89(%rip), %r15     # 0x3e26ea
movq %r15, %rsi
movl $0x29a, %edx            # imm = 0x29A
callq 0x1045eb
xorl %r12d, %r12d
movq %r12, (%rsp)
leaq 0xcae4c(%rip), %r8      # 0x3e28c8
movq %r14, %rdi
movl $0x29b, %esi            # imm = 0x29B
movq %r15, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x316945
movq %r12, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_delete
void gt_firstcodes_countocc_delete(GtFirstcodesspacelog *fcsl,
                                   GtFirstcodestab *fct)
{
  if (fct->countocc_small != NULL)
  {
    GT_FCI_SUBTRACTWORKSPACE(fcsl,"countocc_small");
    gt_free(fct->countocc_small);
    fct->countocc_small = NULL;
  }
  gt_hashtable_delete(fct->countocc_exceptions);
  fct->countocc_exceptions = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpq $0x0, 0x38(%rsi)
je 0x317af6
xorl %r15d, %r15d
movq %r15, (%rsp)
leaq 0xcac25(%rip), %r14     # 0x3e26ea
leaq 0xcaf02(%rip), %r8      # 0x3e29ce
movl $0x2a5, %esi            # imm = 0x2A5
movq %r14, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x316945
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x2a6, %edx            # imm = 0x2A6
callq 0x1045eb
movq %r15, 0x38(%rbx)
movq 0x40(%rbx), %rdi
callq 0x101d90
movq $0x0, 0x40(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_tab_delete
void gt_firstcodes_tab_delete(GtFirstcodesspacelog *fcsl,GtFirstcodestab *fct)
{
  gt_firstcodes_samples_delete(fcsl,fct);
  gt_str_delete(fct->outfilenameleftborder);
  fct->outfilenameleftborder = NULL;
#if defined (_LP64) || defined (_WIN64)
  GT_FREEARRAY(&fct->bitchangepoints,GtUword);
#endif
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x317a43
movq 0x50(%rbx), %rdi
callq 0x11bdbf
movq $0x0, 0x50(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x317b57
addq $0x70, %rbx
leaq 0xcabab(%rip), %rsi     # 0x3e26ea
movl $0x2b3, %edx            # imm = 0x2B3
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_pretty_print
char gt_eoplist_pretty_print(GtEopType eoptype,bool distinguish_mismatch_match)
{
  switch (eoptype)
  {
    case GtDeletionOp:
      return DELETION_CHAR;
    case GtInsertionOp:
      return INSERTION_CHAR;
    case GtMismatchOp:
      return distinguish_mismatch_match ? MISMATCH_CHAR : REPLACEMENT_CHAR;
    case GtMatchOp:
      return distinguish_mismatch_match ? MATCH_CHAR : REPLACEMENT_CHAR;
    default:
      fprintf(stderr,"file %s, line %d: illegal eoptype = %d\n",
              __FILE__,__LINE__,(int) eoptype);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
cmpl $0x3, %edi
ja 0x317d7a
movl %edi, %eax
leaq 0xcae66(%rip), %rcx     # 0x3e2bac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x44, %sil
jmp 0x317d77
testb %sil, %sil
movl $0x58, %eax
movl $0x4d, %esi
cmovnel %eax, %esi
jmp 0x317d77
xorb $0x1, %sil
shlb $0x4, %sil
addb $0x3d, %sil
jmp 0x317d77
movb $0x49, %sil
movl %esi, %eax
retq
pushq %rax
callq 0x91a8c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reset
void gt_eoplist_reset(GtEoplist *eoplist)
{
  if (eoplist != NULL)
  {
    eoplist->nextfreeuint8_t = 0;
    eoplist->countdeletions = 0;
    eoplist->countinsertions = 0;
    eoplist->useq = eoplist->vseq = NULL;
    eoplist->ulen = eoplist->vlen = 0;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x317d9d
xorl %eax, %eax
movq %rax, (%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x40(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_new
GtEoplist *gt_eoplist_new(void)
{
  GtEoplist *eoplist = gt_malloc(sizeof *eoplist);

  gt_assert(eoplist != NULL);
  eoplist->allocateduint8_t = 0;
  eoplist->spaceuint8_t = NULL;
  eoplist->display_seed_in_alignment = false;
  eoplist->withpolcheck = false;
  eoplist->pol_info_out = false;
  eoplist->useedoffset = eoplist->seedlen = 0;
  eoplist->pol_info = NULL;
  GT_INITARRAY(&eoplist->trace,int);
  eoplist->fet_segment = gt_full_front_edist_trace_new();
  gt_eoplist_reset(eoplist);
  return eoplist;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcae47(%rip), %rsi     # 0x3e2bf0
movl $0x98, %edi
movl $0x45, %edx
callq 0x104226
testq %rax, %rax
je 0x317e14
movq %rax, %rbx
xorl %r14d, %r14d
movq %r14, 0x8(%rax)
movq %r14, 0x20(%rax)
movb $0x0, 0x5a(%rax)
movw $0x0, 0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x80(%rax)
callq 0x31e87b
movq %rax, 0x90(%rbx)
movq %r14, (%rbx)
movq %r14, 0x50(%rbx)
movq %r14, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x91aba
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist2cigar_string
char *gt_eoplist2cigar_string(const GtEoplist *eoplist,
                              bool distinguish_mismatch_match)
{
  GtStringBuffer sbuf = {NULL,0,0};
  GtCigarOp co;
  GtEoplistReader *eoplist_reader = gt_eoplist_reader_new();

  gt_eoplist_reader_reset(eoplist_reader,eoplist,true);
  while (gt_eoplist_reader_next_cigar(&co,eoplist_reader,
                                      distinguish_mismatch_match))
  {
    stringbuffer_append_cigar(&sbuf,&co,distinguish_mismatch_match);
  }
  gt_eoplist_reader_delete(eoplist_reader);
  return sbuf.space;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
callq 0x317f5a
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x317fcb
leaq 0x8(%rsp), %rdi
movq %rbx, (%rsp)
movq %rbx, %rsi
movl %ebp, %edx
callq 0x318032
testb %al, %al
je 0x317f3c
movzbl %bpl, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
xorl %r13d, %r13d
leaq 0x17(%rbx), %rax
cmpq %r12, %rax
jb 0x317ef2
movq %r12, %xmm0
punpckldq 0x2fa5f(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2fa67(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2fe7b(%rip), %xmm1    # 0x347d18
addsd 0xcad1b(%rip), %xmm1    # 0x3e2bc0
movsd 0x2e37b(%rip), %xmm0    # 0x346228
addsd %xmm0, %xmm1
addsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x2fe53(%rip), %xmm1    # 0x347d20
cvttsd2si %xmm1, %r12
andq %rcx, %r12
orq %rax, %r12
movq %r13, %rdi
movq %r12, %rsi
leaq 0xcad0b(%rip), %rdx     # 0x3e2bf0
movl $0x64, %ecx
callq 0x104461
movq %rax, %r13
leaq (%rbx,%r13), %r14
movq 0x10(%rsp), %r15
movl 0x8(%rsp), %edi
movl %ebp, %esi
callq 0x317d38
movzbl %al, %ecx
movq %r14, %rdi
leaq 0x9399d(%rip), %rsi     # 0x3ab8b0
movq %r15, %rdx
xorl %eax, %eax
callq 0x17130
cltq
addq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl %ebp, %edx
callq 0x318032
testb %al, %al
jne 0x317e6b
jmp 0x317f3f
xorl %r13d, %r13d
movq (%rsp), %rdi
callq 0x3181fe
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_new
GtEoplistReader *gt_eoplist_reader_new(void)
{
  GtEoplistReader *eoplist_reader;

  eoplist_reader = gt_malloc(sizeof *eoplist_reader);
  gt_assert(eoplist_reader != NULL);
  eoplist_reader->width = 0;
  eoplist_reader->outbuffer = NULL;
  eoplist_reader->width = 70;
  eoplist_reader->outbuffer
    = gt_realloc(eoplist_reader->outbuffer,
                 sizeof *eoplist_reader->outbuffer *
                 gt_eoplist_outbuffer_size(eoplist_reader->width));
  eoplist_reader->difference = 0;
  eoplist_reader->currenteop = NULL;
  eoplist_reader->endeoplist = NULL;
  eoplist_reader->aligned_u = eoplist_reader->aligned_v
                            = eoplist_reader->repcount = 0;
  return eoplist_reader;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcac8b(%rip), %rsi     # 0x3e2bf0
movl $0x40, %edi
movl $0x14e, %edx            # imm = 0x14E
callq 0x104226
testq %rax, %rax
je 0x317fc6
movq %rax, %rbx
xorl %r14d, %r14d
movq %r14, 0x18(%rax)
movl $0x46, 0x20(%rax)
leaq 0xcac5f(%rip), %rdx     # 0x3e2bf0
movl $0xd2, %esi
xorl %edi, %edi
movl $0x156, %ecx            # imm = 0x156
callq 0x104461
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
movups %xmm0, 0x28(%rbx)
movq %r14, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x91af1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_reset
void gt_eoplist_reader_reset(GtEoplistReader *eoplist_reader,
                             const GtEoplist *eoplist,bool forward)
{
  gt_assert(eoplist != NULL && eoplist_reader != NULL);
  if (eoplist->spaceuint8_t == NULL || eoplist->nextfreeuint8_t == 0)
  {
    eoplist_reader->currenteop = NULL;
    eoplist_reader->endeoplist = NULL;
  } else
  {
    if (forward)
    {
      eoplist_reader->currenteop = eoplist->spaceuint8_t;
      eoplist_reader->endeoplist = eoplist->spaceuint8_t +
                                   eoplist->nextfreeuint8_t;
      eoplist_reader->difference = 1;
    } else
    {
      eoplist_reader->currenteop = eoplist->spaceuint8_t +
                                   eoplist->nextfreeuint8_t - 1;
      eoplist_reader->endeoplist = eoplist->spaceuint8_t - 1;
      eoplist_reader->difference = -1;
    }
  }
  eoplist_reader->aligned_u = eoplist_reader->aligned_v
                            = eoplist_reader->repcount = 0;
}

// Assembly:
testq %rdi, %rdi
je 0x31802c
testq %rsi, %rsi
je 0x31802c
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x317ffd
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x317ffd
testb %dl, %dl
je 0x318005
movq %rax, (%rdi)
addq %rax, %rcx
movq %rcx, 0x8(%rdi)
movl $0x1, 0x10(%rdi)
jmp 0x31801c
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
jmp 0x31801c
addq %rax, %rcx
decq %rcx
movq %rcx, (%rdi)
decq %rax
movq %rax, 0x8(%rdi)
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movq $0x0, 0x38(%rdi)
retq
pushq %rax
callq 0x91b2a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_delete
void gt_eoplist_reader_delete(GtEoplistReader *eoplist_reader)
{
  if (eoplist_reader != NULL)
  {
    if (eoplist_reader->outbuffer != NULL)
    {
      gt_free(eoplist_reader->outbuffer);
    }
    gt_free(eoplist_reader);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x318236
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x318221
leaq 0xca9d9(%rip), %rsi     # 0x3e2bf0
movl $0x165, %edx            # imm = 0x165
callq 0x1045eb
leaq 0xca9c8(%rip), %rsi     # 0x3e2bf0
movq %rbx, %rdi
movl $0x167, %edx            # imm = 0x167
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_from_cigar
void gt_eoplist_from_cigar(GtEoplist *eoplist,
                           const char *cigarstring,char sep)
{
  const char *cptr;
  GtUword iteration = 0;

  for (cptr = cigarstring; *cptr != '\0' && *cptr != sep && *cptr != '\n';
       cptr++)
  {
    if (isdigit(*cptr))
    {
      iteration = iteration * 10 + (GtUword) (*cptr - '0');
    } else
    {
      GtUword idx;

      switch (*cptr)
      {
        case DELETION_CHAR:
          for (idx = 0; idx < iteration; idx++)
          {
            gt_eoplist_deletion_add(eoplist);
          }
          break;
        case INSERTION_CHAR:
          for (idx = 0; idx < iteration; idx++)
          {
            gt_eoplist_insertion_add(eoplist);
          }
          break;
        case MATCH_CHAR:
          gt_eoplist_match_add(eoplist,iteration);
          break;
        case REPLACEMENT_CHAR:
          gt_eoplist_match_add(eoplist,iteration);
          break;
        case MISMATCH_CHAR:
          for (idx = 0; idx < iteration; idx++)
          {
            gt_eoplist_mismatch_add(eoplist);
          }
          break;
        default:
          fprintf(stderr,"file %s, line %d: illegal symbol '%c' "
                         "in cigar string\n",__FILE__,__LINE__,*cptr);
          exit(GT_EXIT_PROGRAMMING_ERROR);
      }
      iteration = 0;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movb (%rsi), %al
cmpb %bl, %al
je 0x318311
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testb %al, %al
je 0x318311
movzbl %al, %r13d
cmpl $0xa, %r13d
je 0x318311
movsbl %al, %ebp
callq 0x17870
movq (%rax), %rcx
movslq %ebp, %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x3182b2
cmpl $0x48, %r13d
jle 0x3182c0
cmpl $0x49, %r13d
je 0x3182ed
cmpl $0x4d, %r13d
je 0x3182e0
cmpl $0x58, %r13d
jne 0x318320
testq %r12, %r12
je 0x3182ff
movq %r15, %rdi
callq 0x318601
decq %r12
jne 0x3182a3
jmp 0x3182ff
leaq (%r12,%r12,4), %rcx
leaq (%rax,%rcx,2), %r12
addq $-0x30, %r12
jmp 0x318302
cmpl $0x3d, %r13d
je 0x3182e0
cmpl $0x44, %r13d
jne 0x318320
testq %r12, %r12
je 0x3182ff
movq %r15, %rdi
callq 0x318327
decq %r12
jne 0x3182d1
jmp 0x3182ff
movq %r15, %rdi
movq %r12, %rsi
callq 0x318485
jmp 0x3182ff
testq %r12, %r12
je 0x3182ff
movq %r15, %rdi
callq 0x3183d6
decq %r12
jne 0x3182f2
xorl %r12d, %r12d
movb 0x1(%r14), %al
incq %r14
cmpb %bl, %al
jne 0x318257
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x91c47
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_match_add
void gt_eoplist_match_add(GtEoplist *eoplist,GtUword length)
{
  gt_assert(eoplist != NULL && length > 0);
  while (true)
  {
    if (length <= FT_EOPCODE_MAXMATCHES)
    {
      gt_assert(length > 0);
      GT_EOPLIST_PUSH(eoplist,(uint8_t) (length - 1)); /* R length */
      break;
    }
    GT_EOPLIST_PUSH(eoplist,FT_EOPCODE_MAXMATCHES - 1); /* R max */
    length -= FT_EOPCODE_MAXMATCHES;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3185f7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3185f7
movq %rdi, %r14
cmpq $0xfe, %rbx
jb 0x318559
leaq 0xca73a(%rip), %r15     # 0x3e2bf0
movq 0x8(%r14), %rcx
movq 0x20(%r14), %rax
cmpq %rcx, (%r14)
jb 0x31852e
movq %rcx, %xmm0
punpckldq 0x2f410(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2f418(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x8762c(%rip), %xmm1    # 0x39fb18
addsd 0x8e93c(%rip), %xmm1    # 0x3a6e30
cvttsd2si %xmm1, %rdx
movq %rdx, %rdi
sarq $0x3f, %rdi
subsd 0x2f818(%rip), %xmm1    # 0x347d20
cvttsd2si %xmm1, %rsi
andq %rdi, %rsi
orq %rdx, %rsi
addq %rcx, %rsi
movq %rsi, 0x8(%r14)
movq %rax, %rdi
movq %r15, %rdx
movl $0xd3, %ecx
callq 0x104461
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x3185f2
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movb $-0x4, (%rax,%rcx)
addq $-0xfd, %rbx
cmpq $0xfe, %rbx
jae 0x3184b6
movq 0x8(%r14), %rax
cmpq %rax, (%r14)
jae 0x318568
movq 0x20(%r14), %rax
jmp 0x3185d8
movq %rax, %xmm0
punpckldq 0x2f36b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2f373(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x87587(%rip), %xmm1    # 0x39fb18
addsd 0x8e897(%rip), %xmm1    # 0x3a6e30
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
subsd 0x2f777(%rip), %xmm1    # 0x347d20
sarq $0x3f, %rdx
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rax, %rsi
movq %rsi, 0x8(%r14)
movq 0x20(%r14), %rdi
leaq 0xca626(%rip), %rdx     # 0x3e2bf0
movl $0xd0, %ecx
callq 0x104461
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x3185fc
decb %bl
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x91d94
callq 0x91d5b
callq 0x91dcd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_delete
void gt_eoplist_delete(GtEoplist *eoplist)
{
  if (eoplist != NULL)
  {
    GT_FREEARRAY(&eoplist->trace,int);
    gt_full_front_edist_trace_delete(eoplist->fet_segment);
    gt_free(eoplist->spaceuint8_t);
    gt_free(eoplist);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x318720
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x3186e5
leaq 0x70(%rbx), %r14
leaq 0xca524(%rip), %rsi     # 0x3e2bf0
movl $0xb5, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x90(%rbx), %rdi
callq 0x31e8b3
movq 0x20(%rbx), %rdi
leaq 0xca4f4(%rip), %r14     # 0x3e2bf0
movq %r14, %rsi
movl $0xb7, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0xb8, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reverse_end
void gt_eoplist_reverse_end(GtEoplist *eoplist,GtUword firstindex)
{
  uint8_t *fwd, *bck;

  gt_assert(eoplist != NULL);
  if (firstindex + 1 >= eoplist->nextfreeuint8_t)
  {
    return;
  }
  for (fwd = eoplist->spaceuint8_t + firstindex,
       bck = eoplist->spaceuint8_t + eoplist->nextfreeuint8_t - 1; fwd < bck;
       fwd++, bck--)
  {
    uint8_t tmp = *fwd;
    *fwd = *bck;
    *bck = tmp;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x318775
leaq 0x1(%rsi), %rcx
movq (%rdi), %rax
cmpq %rax, %rcx
jae 0x318773
movq 0x20(%rdi), %rcx
leaq (%rcx,%rsi), %rdx
addq %rcx, %rax
decq %rax
cmpq %rax, %rdx
jae 0x318773
addq %rsi, %rcx
incq %rcx
movb -0x1(%rcx), %dl
movb (%rax), %sil
movb %sil, -0x1(%rcx)
movb %dl, (%rax)
decq %rax
leaq 0x1(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0x318758
popq %rax
retq
callq 0x91e78
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_reset_width
void gt_eoplist_reader_reset_width(GtEoplistReader *eoplist_reader,
                                   unsigned int width)
{
  if (eoplist_reader->width < width)
  {
    eoplist_reader->outbuffer = gt_realloc(eoplist_reader->outbuffer,
                                           sizeof *eoplist_reader->outbuffer *
                                           gt_eoplist_outbuffer_size(width));
    gt_assert(eoplist_reader->outbuffer != NULL);
  }
  eoplist_reader->width = width;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, 0x20(%rdi)
jae 0x3187c9
movq 0x18(%r14), %rdi
leal (%rbx,%rbx,2), %esi
leaq 0xca43a(%rip), %rdx     # 0x3e2bf0
movl $0x144, %ecx            # imm = 0x144
callq 0x104461
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x3187d5
movl %ebx, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x91f23
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_reader_next_segment
bool gt_eoplist_reader_next_segment(GtEoplistSegment *segment,
                                    GtEoplistReader *eoplist_reader,
                                    GtUword delta)
{
  while (true)
  {
    if (eoplist_reader->repcount > 0)
    {
      eoplist_reader->aligned_u++;
      eoplist_reader->aligned_v++;
      eoplist_reader->repcount--;
    } else
    {
      if (eoplist_reader->currenteop == eoplist_reader->endeoplist)
      {
        break;
      }
      switch (*eoplist_reader->currenteop)
      {
        case FT_EOPCODE_DELETION:
          eoplist_reader->aligned_u++;
          break;
        case FT_EOPCODE_INSERTION:
          eoplist_reader->aligned_v++;
          break;
        case FT_EOPCODE_MISMATCH:
          eoplist_reader->aligned_u++;
          eoplist_reader->aligned_v++;
          break;
        default:
          eoplist_reader->aligned_u++;
          eoplist_reader->aligned_v++;
          eoplist_reader->repcount = (GtUword) *eoplist_reader->currenteop;
      }
      eoplist_reader->currenteop += eoplist_reader->difference;
    }
    if (eoplist_reader->aligned_u == delta)
    {
      segment->aligned_u = delta;
      segment->aligned_v = eoplist_reader->aligned_v;
      eoplist_reader->aligned_u = eoplist_reader->aligned_v = 0;
      return true;
    }
  }
  if (eoplist_reader->aligned_v > 0 || eoplist_reader->aligned_u > 0)
  {
    gt_assert(eoplist_reader->repcount == 0);
    segment->aligned_u = eoplist_reader->aligned_u;
    segment->aligned_v = eoplist_reader->aligned_v;
    eoplist_reader->aligned_v = 0;
    eoplist_reader->aligned_u = 0;
    gt_assert(eoplist_reader->currenteop == eoplist_reader->endeoplist);
    return true;
  }
  return false;
}

// Assembly:
movq 0x38(%rsi), %r8
leaq 0x28(%rsi), %rax
pcmpeqd %xmm0, %xmm0
testq %r8, %r8
je 0x318807
movdqu 0x28(%rsi), %xmm1
psubq %xmm0, %xmm1
movdqu %xmm1, 0x28(%rsi)
decq %r8
movq %r8, 0x38(%rsi)
movq %xmm1, %r9
jmp 0x318883
movq (%rsi), %rcx
cmpq 0x8(%rsi), %rcx
je 0x3188a2
movzbl (%rcx), %r8d
cmpl $0xfd, %r8d
je 0x318848
cmpl $0xff, %r8d
je 0x31883e
cmpl $0xfe, %r8d
jne 0x31885e
movq (%rax), %r9
incq %r9
movq %r9, (%rax)
jmp 0x318859
incq 0x30(%rsi)
movq 0x28(%rsi), %r9
jmp 0x318859
movdqu (%rax), %xmm1
psubq %xmm0, %xmm1
movdqu %xmm1, (%rax)
movq %xmm1, %r9
xorl %r8d, %r8d
jmp 0x318879
movdqu 0x28(%rsi), %xmm1
psubq %xmm0, %xmm1
movdqu %xmm1, 0x28(%rsi)
movzbl (%rcx), %r8d
movq %r8, 0x38(%rsi)
movq %xmm1, %r9
movslq 0x10(%rsi), %r10
addq %r10, %rcx
movq %rcx, (%rsi)
cmpq %rdx, %r9
jne 0x3187e6
movq %rdx, (%rdi)
movq 0x30(%rsi), %rcx
movq %rcx, 0x8(%rdi)
pxor %xmm0, %xmm0
movdqu %xmm0, (%rax)
movb $0x1, %al
retq
movq 0x28(%rsi), %rdx
movq 0x30(%rsi), %rcx
movq %rcx, %rsi
orq %rdx, %rsi
jne 0x3188b5
xorl %eax, %eax
retq
movq %rdx, (%rdi)
jmp 0x318893
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_segments_entropy
double gt_eoplist_segments_entropy(const GtEoplist *eoplist,GtUword delta)
{
  GtEoplistReader *eoplist_reader = gt_eoplist_reader_new();
  GtEoplistSegment segment;
  const GtUword max_value = 2 * delta + 1;
  GtUword segment_count = 0, idx,
          *segment_dist = gt_calloc(max_value + 1,sizeof *segment_dist);
  double entropy = 0.0;

  gt_eoplist_reader_reset(eoplist_reader,eoplist,true);
  while (gt_eoplist_reader_next_segment(&segment,eoplist_reader,delta))
  {
    gt_assert(segment.aligned_v <= max_value);
    segment_dist[segment.aligned_v]++;
    segment_count++;
  }
  gt_eoplist_reader_delete(eoplist_reader);
  for (idx = 0; idx <= max_value; idx++)
  {
    if (segment_dist[idx] > 0)
    {
      double prob = (double) segment_dist[idx]/segment_count;
      entropy += prob * log2(prob);
    }
  }
  gt_free(segment_dist);
  return entropy == 0.0 ? 0.0 : -entropy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r12
callq 0x317f5a
movq %rax, %r14
leaq 0x1(,%r15,2), %r13
leaq 0x2(,%r15,2), %rdi
leaq 0xca303(%rip), %rdx     # 0x3e2bf0
movl $0x8, %esi
movl $0x20c, %ecx            # imm = 0x20C
callq 0x10436a
movq %rax, %rbx
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x317fcb
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3187da
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movapd %xmm0, 0x10(%rsp)
testb %al, %al
je 0x318987
xorl %ebp, %ebp
leaq 0x20(%rsp), %r12
movq 0x28(%rsp), %rax
cmpq %r13, %rax
ja 0x318a26
incq (%rbx,%rax,8)
incq %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3187da
testb %al, %al
jne 0x318939
movq %rbp, %xmm0
punpckldq 0x2ef73(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2ef7b(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movq %r14, %rdi
callq 0x3181fe
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rax
testq %rax, %rax
je 0x3189e1
movq %rax, %xmm1
punpckldq 0x2ef38(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2ef40(%rip), %xmm1    # 0x3478f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd 0x10(%rsp), %xmm0
movapd %xmm0, 0x30(%rsp)
callq 0x17e20
mulsd 0x30(%rsp), %xmm0
movapd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
incq %r14
cmpq %r13, %r14
jbe 0x318992
leaq 0xca200(%rip), %rsi     # 0x3e2bf0
movq %rbx, %rdi
movl $0x21f, %edx            # imm = 0x21F
callq 0x1045eb
movapd 0x3704b(%rip), %xmm1    # 0x34fa50
movapd (%rsp), %xmm0
xorpd %xmm0, %xmm1
cmpeqsd %xmm1, %xmm0
andnpd %xmm1, %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x91f5c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_read_trace
void gt_eoplist_read_trace(GtEoplist *eoplist,
                           const char *trace,
                           char separator)
{
  if (eoplist != NULL)
  {
    eoplist->trace.nextfreeint = 0;
  }
  while (true)
  {
    int value;
    const char *ptr;

    if (sscanf(trace,"%d",&value) != 1)
    {
      fprintf(stderr,"cannot read number from trace %s\n",trace);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (eoplist != NULL)
    {
      GT_STOREINARRAY(&eoplist->trace,int,
                      256 + eoplist->trace.allocatedint * 0.2,value);
    }
    for (ptr = trace; *ptr != '\0' && *ptr != separator && *ptr != ','; ptr++)
      /* Nothing */;
    if (*ptr == '\0' || *ptr == separator)
    {
      break;
    }
    trace = ptr + 1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x318a4e
movq $0x0, 0x80(%r14)
leaq 0xb1535(%rip), %r15     # 0x3c9f8a
leaq 0x4(%rsp), %r12
leaq 0xca18f(%rip), %r13     # 0x3e2bf0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x177f0
cmpl $0x1, %eax
jne 0x318b5d
testq %r14, %r14
je 0x318b24
movq 0x78(%r14), %rax
cmpq %rax, 0x80(%r14)
jae 0x318a96
movq 0x70(%r14), %rax
jmp 0x318b06
movq %rax, %xmm0
punpckldq 0x2ee3d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2ee45(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x87059(%rip), %xmm1    # 0x39fb18
addsd 0x87041(%rip), %xmm1    # 0x39fb08
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2f245(%rip), %xmm1    # 0x347d20
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rax, %rsi
movq %rsi, 0x78(%r14)
movq 0x70(%r14), %rdi
shlq $0x2, %rsi
movq %r13, %rdx
movl $0x241, %ecx            # imm = 0x241
callq 0x104461
movq %rax, 0x70(%r14)
testq %rax, %rax
je 0x318b65
movl 0x4(%rsp), %ecx
movq 0x80(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x80(%r14)
movl %ecx, (%rax,%rdx,4)
movb (%rbx), %al
cmpb %bpl, %al
je 0x318b4e
incq %rbx
testb %al, %al
je 0x318b46
movzbl %al, %ecx
cmpl $0x2c, %ecx
je 0x318b46
movb (%rbx), %al
incq %rbx
cmpb %bpl, %al
jne 0x318b2e
jmp 0x318b4e
testb %al, %al
jne 0x318a61
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x91f95
callq 0x91fb9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_trace2cigar
void gt_eoplist_trace2cigar(GtEoplist *eoplist,bool dtrace,GtUword trace_delta)
{
  GtUword idx, offset_u = 0, offset_v = 0;

  gt_assert(eoplist != NULL && eoplist->trace.nextfreeint > 0);
  for (idx = 0; idx < eoplist->trace.nextfreeint; idx++)
  {
    GtUword this_distance, aligned_u, aligned_v;

    if (dtrace)
    {
      const int value = -(eoplist->trace.spaceint[idx] - trace_delta);
      gt_assert(value >= 0);
      aligned_v = (GtUword) value;
    } else
    {
      aligned_v = (GtUword) eoplist->trace.spaceint[idx];
    }
    gt_assert(offset_u < eoplist->ulen);
    aligned_u = GT_MIN(trace_delta,eoplist->ulen - offset_u);
    this_distance = gt_full_front_edist_trace_distance(eoplist->fet_segment,
                                                       eoplist->useq + offset_u,
                                                       aligned_u,
                                                       eoplist->vseq + offset_v,
                                                       aligned_v);
    gt_front_trace2eoplist_full_front_directed(eoplist,
                                               gt_full_front_trace_get(
                                                   eoplist->fet_segment),
                                               this_distance,
                                               eoplist->useq + offset_u,
                                               aligned_u,
                                               eoplist->vseq + offset_v,
                                               aligned_v);
    offset_u += aligned_u;
    offset_v += aligned_v;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x18(%rsp)
movl %esi, 0x14(%rsp)
testq %rdi, %rdi
je 0x318c60
movq %rdi, %r14
cmpq $0x0, 0x80(%rdi)
je 0x318c60
xorl %ebp, %ebp
xorl %ebx, %ebx
xorl %r13d, %r13d
movq 0x70(%r14), %rax
movslq (%rax,%rbp,4), %r15
cmpb $0x0, 0x14(%rsp)
je 0x318bc2
movq 0x18(%rsp), %rax
subl %r15d, %eax
js 0x318c5b
movl %eax, %r15d
movq 0x40(%r14), %r12
subq %rbx, %r12
jbe 0x318c56
movq 0x18(%rsp), %rax
cmpq %rax, %r12
cmovaeq %rax, %r12
movq 0x90(%r14), %rdi
movq 0x28(%r14), %rsi
addq %rbx, %rsi
movq 0x30(%r14), %rcx
addq %r13, %rcx
movq %r12, %rdx
movq %r15, %r8
callq 0x31e907
movq %rax, 0x20(%rsp)
movq 0x90(%r14), %rdi
callq 0x31e8f7
movq 0x28(%r14), %rcx
addq %rbx, %rcx
movq 0x30(%r14), %r9
addq %r13, %r9
movq %r15, (%rsp)
movq %r14, %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
movq %r12, %r8
callq 0x31ab61
addq %r12, %rbx
addq %r15, %r13
incq %rbp
cmpq 0x80(%r14), %rbp
jb 0x318ba2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x9202b
callq 0x91ff2
callq 0x92064
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_show_plain
void gt_eoplist_show_plain(const GtEoplist *eoplist,FILE *fp)
{
  GtUword idx;

  fprintf(fp,"[");
  for (idx = 0; idx < eoplist->nextfreeuint8_t; idx++)
  {
    if (eoplist->spaceuint8_t[idx] == FT_EOPCODE_DELETION)
    {
      fputc(DELETION_CHAR,fp);
    } else
    {
      if (eoplist->spaceuint8_t[idx] == FT_EOPCODE_INSERTION)
      {
        fputc(INSERTION_CHAR,fp);
      } else
      {
        if (eoplist->spaceuint8_t[idx] == FT_EOPCODE_MISMATCH)
        {
          fputc(MISMATCH_CHAR,fp);
        } else
        {
          fprintf(fp,"%d",eoplist->spaceuint8_t[idx]);
        }
      }
    }
    fputc(idx + 1 < eoplist->nextfreeuint8_t ? ',' : ']',fp);
  }
  fputc('\n',fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5b, %edi
callq 0x17980
cmpq $0x0, (%r14)
je 0x318cf8
movl $0x2c, %ebp
leaq 0xb12fb(%rip), %r15     # 0x3c9f8a
xorl %r12d, %r12d
movq 0x20(%r14), %rax
movzbl (%rax,%r12), %edx
cmpl $0xfd, %edx
je 0x318cc1
cmpl $0xff, %edx
je 0x318cba
cmpl $0xfe, %edx
jne 0x318cd0
movl $0x44, %edi
jmp 0x318cc6
movl $0x49, %edi
jmp 0x318cc6
movl $0x58, %edi
movq %rbx, %rsi
callq 0x17980
jmp 0x318cdd
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x17ab0
incq %r12
cmpq (%r14), %r12
movl $0x5d, %edi
cmovbl %ebp, %edi
movq %rbx, %rsi
callq 0x17980
cmpq (%r14), %r12
jb 0x318c92
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17980
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_show_cigar
void gt_eoplist_show_cigar(GtEoplistReader *eoplist_reader,
                           bool distinguish_mismatch_match,FILE *fp)
{
  GtCigarOp co;

  while (gt_eoplist_reader_next_cigar(&co,eoplist_reader,
                                      distinguish_mismatch_match))
  {
    fprintf(fp,GT_WU "%c",co.iteration,
            gt_eoplist_pretty_print(co.eoptype,distinguish_mismatch_match));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x318032
testb %al, %al
je 0x318d7a
movzbl %bpl, %ebp
leaq 0x92b6f(%rip), %r15     # 0x3ab8b0
leaq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
movl 0x8(%rsp), %edi
movl %ebp, %esi
callq 0x317d38
movzbl %al, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x17ab0
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x318032
testb %al, %al
jne 0x318d46
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_show_advance
static unsigned int gt_eoplist_show_advance(GtUword one_off,
                                            bool subject_first,
                                            int numwidth,
                                            unsigned int pos,
                                            unsigned int width,
                                            const GtUchar *topbuf,
                                            GtUword top_seqlength,
                                            GtUword top_start_pos,
                                            GtUword top_end_pos,
                                            const GtUchar *midbuf,
                                            const GtUchar *lowbuf,
                                            GtUword low_start_pos,
                                            GtUword low_end_pos,
                                            FILE *fp)
{
  gt_assert(width > 0);
  if (pos + 1 < width)
  {
    return pos + 1;
  }
  gt_assert(pos == width - 1);
  gt_eoplist_write_lines(one_off,subject_first,
                         numwidth, width, topbuf,
                         top_seqlength, top_start_pos, top_end_pos,
                         midbuf, lowbuf, low_start_pos, low_end_pos, fp);
  return 0;
}

// Assembly:
pushq %rax
testl %r8d, %r8d
je 0x319a55
leal 0x1(%rcx), %eax
cmpl %r8d, %eax
jb 0x319a53
leal -0x1(%r8), %eax
cmpl %ecx, %eax
jne 0x319a5a
movq 0x10(%rsp), %rax
subq $0x8, %rsp
movzbl %sil, %esi
movl %r8d, %ecx
movq %r9, %r8
movq %rax, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x50(%rsp)
callq 0x319a5f
addq $0x40, %rsp
xorl %eax, %eax
popq %rcx
retq
callq 0x92340
callq 0x92307
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace_delete
void front_trace_delete(GtFrontTrace *front_trace)
{
  if (front_trace != NULL)
  {
    /*
    distribution_show("lcs",1,front_trace->lcs_dist);
    distribution_show("valid",1,front_trace->valid_dist);
    distribution_show("trimleft_diff",1,front_trace->trimleft_diff_dist);
    distribution_show("space_per_pos",100,front_trace->space_per_pos_dist);
    */
#ifdef WITHDISTRIBUTION
    distribution_delete(front_trace->lcs_dist);
    distribution_delete(front_trace->valid_dist);
    distribution_delete(front_trace->trimleft_diff_dist);
    distribution_delete(front_trace->space_per_pos_dist);
#endif
    gt_free(front_trace->backref_table);
    gt_free(front_trace->gen_table);
    gt_free(front_trace->backtracepath);
    gt_free(front_trace->backtracestack.space);
    gt_free(front_trace);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x31a14a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xc91ce(%rip), %r14     # 0x3e32c1
movq %r14, %rsi
movl $0x97, %edx
callq 0x1045eb
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x98, %edx
callq 0x1045eb
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x99, %edx
callq 0x1045eb
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x9a, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace_add_gen
void front_trace_add_gen(GtFrontTrace *front_trace,GtUword trimleft,
                         GtUword valid)
{
  gt_assert (front_trace != NULL);
  if (front_trace->gen_nextfree >= front_trace->gen_allocated)
  {
    front_trace->gen_allocated
      = front_trace->gen_allocated * 1.2 + 128UL;
    front_trace->gen_table
      = gt_realloc(front_trace->gen_table,
                   sizeof *front_trace->gen_table * front_trace->gen_allocated);
    gt_assert(front_trace->gen_table != NULL);
  }
#ifdef WITHDISTRIBUTION
  distribution_add(front_trace->valid_dist,valid);
#endif
  if (front_trace->gen_nextfree > 0)
  {
    GtUword trimleft_diff;

    gt_assert(front_trace->previoustrimleft <= trimleft);
    trimleft_diff = trimleft - front_trace->previoustrimleft;
#ifdef WITHDISTRIBUTION
    distribution_add(front_trace->trimleft_diff_dist,trimleft_diff);
#endif
    gt_assert(trimleft_diff <= GT_FRONTGENERATION_VALUE_MAX);
    front_trace->gen_table[front_trace->gen_nextfree].trimleft_diff
      = trimleft_diff;
  } else
  {
    front_trace->gen_table[front_trace->gen_nextfree].trimleft_diff = 0;
  }
  front_trace->previoustrimleft = trimleft;
  gt_assert(front_trace->gen_nextfree < front_trace->gen_allocated);
  gt_assert(valid <= GT_FRONTGENERATION_VALUE_MAX);
  front_trace->gen_table[front_trace->gen_nextfree++].valid = valid;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x31a239
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
cmpq %rcx, %rax
jb 0x31a1e9
movq %rcx, %xmm0
punpckldq 0x2d764(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2d76c(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2db80(%rip), %xmm1    # 0x347d18
addsd 0x8cc90(%rip), %xmm1    # 0x3a6e30
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x2db70(%rip), %xmm1    # 0x347d20
sarq $0x3f, %rcx
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %rsi, 0x58(%r14)
movq 0x20(%r14), %rdi
shlq $0x2, %rsi
leaq 0xc90ef(%rip), %rdx     # 0x3e32c1
movl $0xa9, %ecx
callq 0x104461
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x31a252
movq 0x50(%r14), %rax
testq %rax, %rax
je 0x31a20a
movq %r15, %rdx
subq 0x60(%r14), %rdx
jb 0x31a248
cmpq $0x10000, %rdx          # imm = 0x10000
jae 0x31a24d
movq 0x20(%r14), %rcx
movw %dx, (%rcx,%rax,4)
jmp 0x31a213
movq 0x20(%r14), %rcx
movw $0x0, (%rcx)
movq %r15, 0x60(%r14)
cmpq 0x58(%r14), %rax
jae 0x31a23e
cmpq $0x10000, %rbx          # imm = 0x10000
jae 0x31a243
leaq 0x1(%rax), %rdx
movq %rdx, 0x50(%r14)
movw %bx, 0x2(%rcx,%rax,4)
popq %rbx
popq %r14
popq %r15
retq
callq 0x927b3
callq 0x92741
callq 0x9277a
callq 0x92708
callq 0x926cf
callq 0x92696