LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq 0x8(%rdi), %r13
xorl %ebp, %ebp
movq %r13, %r14
leaq 0x1(%rbp), %rax
cmpq %r13, %rax
jae 0x2b756f
movq %rbp, %r12
addq %r13, %r12
shrq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2b74a3
cmpq %rbx, %rax
je 0x2b75b7
ja 0x2b7565
incq %r12
movq %r12, %rbp
jmp 0x2b7539
leaq -0x1(%r12), %r13
movq %r12, %r14
jmp 0x2b7539
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b74a3
cmpq %rbx, %rax
jae 0x2b75ba
movq 0x1809e2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2da83(%rip), %rsi     # 0x2e5013
leaq 0xcb8ac(%rip), %rdx     # 0x382e43
leaq 0xcb8d9(%rip), %rcx     # 0x382e77
leaq 0xcb525(%rip), %r8      # 0x382aca
movl $0x286, %r9d            # imm = 0x286
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 0x2b75e6
jbe 0x2b75dc
movb 0x28(%rdi), %cl
shlq %cl, %rsi
jmp 0x2b75e2
movq (%rdi), %rsi
decq %rsi
movq %rsi, %rax
retq
pushq %rax
movq 0x18097a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2da1b(%rip), %rsi     # 0x2e5013
leaq 0xcb812(%rip), %rdx     # 0x382e11
leaq 0xcb895(%rip), %rcx     # 0x382e9b
leaq 0xcb4bd(%rip), %r8      # 0x382aca
movl $0x28d, %r9d            # imm = 0x28D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x2b7672
movq %rsi, %rbx
leaq 0xcb48c(%rip), %r15     # 0x382aca
movq %r15, %rsi
movl $0x29a, %edx            # imm = 0x29A
callq 0x936f9
andq $0x0, (%rsp)
leaq 0xcb651(%rip), %r8      # 0x382ca8
pushq $0x1
popq %r9
movq %r14, %rdi
movl $0x29b, %esi            # imm = 0x29B
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x2b613a
andq $0x0, 0x48(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x0, 0x38(%rsi)
je 0x2b76c6
andq $0x0, (%rsp)
leaq 0xcb434(%rip), %r14     # 0x382aca
leaq 0xcb711(%rip), %r8      # 0x382dae
pushq $0x1
popq %r9
movl $0x2a5, %esi            # imm = 0x2A5
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2b613a
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x2a6, %edx            # imm = 0x2A6
callq 0x936f9
andq $0x0, 0x38(%rbx)
movq 0x40(%rbx), %rdi
callq 0x9082d
andq $0x0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b761f
movq 0x50(%rbx), %rdi
callq 0xae103
andq $0x0, 0x50(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x2b771c
addq $0x70, %rbx
leaq 0xcb3c3(%rip), %rsi     # 0x382aca
movl $0x2b3, %edx            # imm = 0x2B3
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %r8d
cmpl $0x3, %edi
ja 0x2b7962
movl %r8d, %eax
leaq 0xcb65a(%rip), %rcx     # 0x382f8c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x44, %sil
jmp 0x2b795f
testb %sil, %sil
pushq $0x58
popq %rax
pushq $0x4d
popq %rsi
cmovnel %eax, %esi
jmp 0x2b795f
xorb $0x1, %sil
shlb $0x4, %sil
addb $0x3d, %sil
jmp 0x2b795f
movb $0x49, %sil
movl %esi, %eax
retq
pushq %rax
movq 0x1805fe(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0xcb634(%rip), %rsi     # 0x382fa8
leaq 0xcb655(%rip), %rdx     # 0x382fd0
pushq $0x25
popq %rcx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
leaq 0xcb61c(%rip), %rsi     # 0x382fd0
pushq $0x45
popq %rdx
movl $0x98, %edi
callq 0x93160
testq %rax, %rax
je 0x2b7a18
movq %rax, %rbx
andq $0x0, 0x8(%rax)
andq $0x0, 0x20(%rax)
movb $0x0, 0x5a(%rax)
andw $0x0, 0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x80(%rax)
callq 0x2bf44e
movq %rax, 0x90(%rbx)
andq $0x0, (%rbx)
andq $0x0, 0x50(%rbx)
andq $0x0, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq 0x180549(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2d5ea(%rip), %rsi     # 0x2e5013
leaq 0x5d56b(%rip), %rdx     # 0x314f9b
leaq 0xcb5b0(%rip), %rcx     # 0x382fe7
leaq 0xcb592(%rip), %r8      # 0x382fd0
pushq $0x47
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b7b71
pushq $0x1
popq %rdx
movq %rax, (%rsp)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2b7c06
movzbl %bpl, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
xorl %r13d, %r13d
leaq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl %ebp, %edx
callq 0x2b7c9a
testb %al, %al
je 0x2b7b56
leaq 0x17(%rbx), %rax
cmpq %r13, %rax
jb 0x2b7b21
movq %r13, %xmm0
punpckldq 0x2fe2e(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2fe36(%rip), %xmm0    # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x3024a(%rip), %xmm1    # 0x2e7d18
addsd 0xcb4ca(%rip), %xmm1    # 0x382fa0
movsd 0x2e74a(%rip), %xmm0    # 0x2e6228
addsd %xmm0, %xmm1
addsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x30222(%rip), %xmm1    # 0x2e7d20
cvttsd2si %xmm1, %r13
andq %rcx, %r13
orq %rax, %r13
movq %r12, %rdi
movq %r13, %rsi
leaq 0xcb4ba(%rip), %rdx     # 0x382fd0
pushq $0x64
popq %rcx
callq 0x93472
movq %rax, %r12
leaq (%r12,%rbx), %r15
movq 0x10(%rsp), %r14
movl 0x8(%rsp), %edi
movl %ebp, %esi
callq 0x2b7920
movzbl %al, %ecx
movq %r15, %rdi
leaq 0x940ce(%rip), %rsi     # 0x34bc10
movq %r14, %rdx
xorl %eax, %eax
callq 0x17120
cltq
addq %rax, %rbx
jmp 0x2b7a84
movq (%rsp), %rdi
callq 0x2b7ee0
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 %rbx
leaq 0xcb457(%rip), %rsi     # 0x382fd0
pushq $0x40
popq %rdi
movl $0x14e, %edx            # imm = 0x14E
callq 0x93160
testq %rax, %rax
je 0x2b7bce
movq %rax, %rbx
andq $0x0, 0x18(%rax)
movl $0x46, 0x20(%rax)
leaq 0xcb42f(%rip), %rdx     # 0x382fd0
movl $0xd2, %esi
xorl %edi, %edi
movl $0x156, %ecx            # imm = 0x156
callq 0x93472
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andl $0x0, 0x10(%rbx)
movups %xmm0, 0x28(%rbx)
andq $0x0, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq 0x180393(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2d434(%rip), %rsi     # 0x2e5013
leaq 0xcb556(%rip), %rdx     # 0x38313c
leaq 0xcb5be(%rip), %rcx     # 0x3831ab
leaq 0xcb3dc(%rip), %r8      # 0x382fd0
movl $0x14f, %r9d            # imm = 0x14F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b7c61
testq %rsi, %rsi
je 0x2b7c61
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x2b7c38
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x2b7c38
testb %dl, %dl
je 0x2b7c40
movq %rax, (%rdi)
addq %rax, %rcx
movq %rcx, 0x8(%rdi)
movl $0x1, 0x10(%rdi)
jmp 0x2b7c54
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
jmp 0x2b7c54
addq %rax, %rcx
decq %rcx
movq %rcx, (%rdi)
decq %rax
movq %rax, 0x8(%rdi)
orl $-0x1, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
andq $0x0, 0x38(%rdi)
retq
pushq %rax
movq 0x1802ff(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2d3a0(%rip), %rsi     # 0x2e5013
leaq 0xcb4af(%rip), %rdx     # 0x383129
leaq 0xcb4d2(%rip), %rcx     # 0x383153
leaq 0xcb348(%rip), %r8      # 0x382fd0
movl $0x11f, %r9d            # imm = 0x11F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b7f18
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x2b7f03
leaq 0xcb0d7(%rip), %rsi     # 0x382fd0
movl $0x165, %edx            # imm = 0x165
callq 0x936f9
leaq 0xcb0c6(%rip), %rsi     # 0x382fd0
movq %rbx, %rdi
movl $0x167, %edx            # imm = 0x167
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r14), %bl
cmpb 0x4(%rsp), %bl
je 0x2b7fda
testb %bl, %bl
je 0x2b7fda
movzbl %bl, %r13d
cmpl $0xa, %r13d
je 0x2b7fda
movsbl %bl, %ebp
callq 0x17820
movq (%rax), %rcx
movslq %ebp, %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x2b7fb6
cmpb $0x3d, %bl
je 0x2b7fc4
cmpl $0x44, %r13d
je 0x2b7f9e
cmpl $0x49, %r13d
je 0x2b7fae
cmpl $0x4d, %r13d
je 0x2b7fc4
cmpl $0x58, %r13d
jne 0x2b7fe9
subq $0x1, %r12
jb 0x2b7fcf
movq %r15, %rdi
callq 0x2b8413
jmp 0x2b7f86
movq %r15, %rdi
callq 0x2b8018
subq $0x1, %r12
jae 0x2b7f96
jmp 0x2b7fcf
movq %r15, %rdi
callq 0x2b810f
subq $0x1, %r12
jae 0x2b7fa6
jmp 0x2b7fcf
imulq $0xa, %r12, %rcx
leaq (%rax,%rcx), %r12
addq $-0x30, %r12
jmp 0x2b7fd2
movq %r15, %rdi
movq %r12, %rsi
callq 0x2b821a
xorl %r12d, %r12d
incq %r14
jmp 0x2b7f31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x17ff78(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0xcaffc(%rip), %rsi     # 0x382ff6
leaq 0xcafcf(%rip), %rdx     # 0x382fd0
movl $0xa9, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2b83b7
movq %rsi, %r14
testq %rsi, %rsi
je 0x2b83b7
movq %rdi, %rbx
leal -0x1(%r14), %ebp
leaq 0xcad8c(%rip), %r15     # 0x382fd0
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
movq 0x20(%rbx), %rax
movq %rsi, %xmm0
cmpq $0xfd, %r14
jbe 0x2b82f3
cmpq %rsi, %rcx
jb 0x2b82cc
punpckldq 0x2f672(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2f67a(%rip), %xmm0    # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x87b8e(%rip), %xmm1    # 0x33fe18
addsd 0x8ef1e(%rip), %xmm1    # 0x3471b0
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2fa7a(%rip), %xmm1    # 0x2e7d20
cvttsd2si %xmm1, %rdi
andq %rdx, %rdi
orq %rcx, %rdi
addq %rdi, %rsi
movq %rsi, 0x8(%rbx)
movq %rax, %rdi
movq %r15, %rdx
movl $0xd3, %ecx
callq 0x93472
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x2b837f
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb $-0x4, (%rax,%rcx)
addq $-0xfd, %r14
addb $0x3, %bpl
jmp 0x2b8244
cmpq %rsi, %rcx
jb 0x2b8361
unpcklps 0x2f5e1(%rip), %xmm0    # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2f5e9(%rip), %xmm0    # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x87afd(%rip), %xmm1    # 0x33fe18
addsd 0x8ee8d(%rip), %xmm1    # 0x3471b0
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2f9e9(%rip), %xmm1    # 0x2e7d20
cvttsd2si %xmm1, %rdi
andq %rdx, %rdi
orq %rcx, %rdi
addq %rdi, %rsi
movq %rsi, 0x8(%rbx)
leaq 0xcac80(%rip), %rdx     # 0x382fd0
movq %rax, %rdi
movl $0xd0, %ecx
callq 0x93472
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x2b83e5
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %bpl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x17fbe2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2cc83(%rip), %rsi     # 0x2e5013
leaq 0xcacdb(%rip), %rdx     # 0x383072
leaq 0xcacad(%rip), %rcx     # 0x38304b
leaq 0xcac2b(%rip), %r8      # 0x382fd0
movl $0xd3, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x17fbaa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2cc4b(%rip), %rsi     # 0x2e5013
leaq 0xcac5e(%rip), %rdx     # 0x38302d
leaq 0xcac75(%rip), %rcx     # 0x38304b
leaq 0xcabf3(%rip), %r8      # 0x382fd0
movl $0xca, %r9d
jmp 0x2b83ab
movq 0x17fb7c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2cc1d(%rip), %rsi     # 0x2e5013
leaq 0xcac75(%rip), %rdx     # 0x383072
leaq 0xcac47(%rip), %rcx     # 0x38304b
leaq 0xcabc5(%rip), %r8      # 0x382fd0
movl $0xd0, %r9d
jmp 0x2b83ab
// File: /workspace/github_c_makefile_star2_O2/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 0x2b8577
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x2b853c
leaq 0x70(%rbx), %r14
leaq 0xcaaaa(%rip), %rsi     # 0x382fd0
movl $0xb5, %edx
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x90(%rbx), %rdi
callq 0x2bf4b7
movq 0x20(%rbx), %rdi
leaq 0xcaa7d(%rip), %r14     # 0x382fd0
movq %r14, %rsi
movl $0xb7, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0xb8, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b85ba
leaq 0x1(%rsi), %rcx
movq (%rdi), %rax
cmpq %rax, %rcx
jae 0x2b85b8
movq 0x20(%rdi), %rcx
addq %rcx, %rsi
addq %rcx, %rax
decq %rax
cmpq %rax, %rsi
jae 0x2b85b8
movb (%rsi), %cl
movb (%rax), %dl
movb %dl, (%rsi)
movb %cl, (%rax)
incq %rsi
decq %rax
jmp 0x2b85a3
popq %rax
retq
movq 0x17f9a7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2ca48(%rip), %rsi     # 0x2e5013
leaq 0x5c9c9(%rip), %rdx     # 0x314f9b
leaq 0xcab02(%rip), %rcx     # 0x3830db
leaq 0xca9f0(%rip), %r8      # 0x382fd0
movl $0xf7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b86a7
movq 0x18(%r14), %rdi
leal (%rbx,%rbx,2), %esi
leaq 0xca93c(%rip), %rdx     # 0x382fd0
movl $0x144, %ecx            # imm = 0x144
callq 0x93472
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x2b86b3
movl %ebx, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x17f8ae(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c94f(%rip), %rsi     # 0x2e5013
leaq 0xcaaa0(%rip), %rdx     # 0x38316b
leaq 0xcaabb(%rip), %rcx     # 0x38318d
leaq 0xca8f7(%rip), %r8      # 0x382fd0
movl $0x145, %r9d            # imm = 0x145
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b8718
movdqu 0x28(%rsi), %xmm1
psubq %xmm0, %xmm1
movdqu %xmm1, 0x28(%rsi)
decq %r8
movq %r8, 0x38(%rsi)
movq %xmm1, %r9
jmp 0x2b8794
movq (%rsi), %rcx
cmpq 0x8(%rsi), %rcx
je 0x2b87b3
movzbl (%rcx), %r8d
cmpl $0xfd, %r8d
je 0x2b8759
cmpl $0xff, %r8d
je 0x2b874f
cmpl $0xfe, %r8d
jne 0x2b876f
movq (%rax), %r9
incq %r9
movq %r9, (%rax)
jmp 0x2b876a
incq 0x30(%rsi)
movq 0x28(%rsi), %r9
jmp 0x2b876a
movdqu (%rax), %xmm1
psubq %xmm0, %xmm1
movdqu %xmm1, (%rax)
movq %xmm1, %r9
xorl %r8d, %r8d
jmp 0x2b878a
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 0x2b86f7
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 0x2b87c6
xorl %eax, %eax
retq
movq %rdx, (%rdi)
jmp 0x2b87a4
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %r12
callq 0x2b7b71
movq %rax, %r15
leaq 0x1(,%r14,2), %r13
leaq 0x2(,%r14,2), %rdi
leaq 0xca7d2(%rip), %rdx     # 0x382fd0
pushq $0x8
popq %rsi
movl $0x20c, %ecx            # imm = 0x20C
callq 0x9334a
movq %rax, %rbx
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2b7c06
xorl %ebp, %ebp
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2b86eb
testb %al, %al
je 0x2b884c
movq 0x40(%rsp), %rax
cmpq %r13, %rax
ja 0x2b891d
incq (%rbx,%rax,8)
incq %rbp
jmp 0x2b8823
movq %r15, %rdi
callq 0x2b7ee0
movq %rbp, %xmm0
punpckldq 0x2f07f(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2f087(%rip), %xmm0    # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
xorl %r14d, %r14d
cmpq %r13, %r14
ja 0x2b88e0
movq (%rbx,%r14,8), %rax
testq %rax, %rax
je 0x2b88db
movq %rax, %xmm1
punpckldq 0x2f03e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2f046(%rip), %xmm1    # 0x2e78f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd 0x10(%rsp), %xmm0
movapd %xmm0, 0x20(%rsp)
callq 0x17d90
mulsd 0x20(%rsp), %xmm0
movapd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
incq %r14
jmp 0x2b8887
leaq 0xca6e9(%rip), %rsi     # 0x382fd0
movq %rbx, %rdi
movl $0x21f, %edx            # imm = 0x21F
callq 0x936f9
movapd 0x37154(%rip), %xmm1    # 0x2efa50
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
movq 0x17f644(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c6e5(%rip), %rsi     # 0x2e5013
leaq 0xca910(%rip), %rdx     # 0x383245
leaq 0xca928(%rip), %rcx     # 0x383264
leaq 0xca68d(%rip), %r8      # 0x382fd0
movl $0x212, %r9d            # imm = 0x212
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b8975
andq $0x0, 0x80(%r14)
leaq 0xb1a0e(%rip), %r15     # 0x36a38a
leaq 0x4(%rsp), %r12
leaq 0xca648(%rip), %r13     # 0x382fd0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x177b0
cmpl $0x1, %eax
jne 0x2b8a7e
testq %r14, %r14
je 0x2b8a4b
movq 0x78(%r14), %rax
cmpq %rax, 0x80(%r14)
jae 0x2b89bd
movq 0x70(%r14), %rax
jmp 0x2b8a2d
movq %rax, %xmm0
punpckldq 0x2ef16(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2ef1e(%rip), %xmm0    # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x87432(%rip), %xmm1    # 0x33fe18
addsd 0x8741a(%rip), %xmm1    # 0x33fe08
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2f31e(%rip), %xmm1    # 0x2e7d20
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 0x93472
movq %rax, 0x70(%r14)
testq %rax, %rax
je 0x2b8aa1
movl 0x4(%rsp), %ecx
movq 0x80(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x80(%r14)
movl %ecx, (%rax,%rdx,4)
incq %rbx
movb -0x1(%rbx), %al
cmpb %bpl, %al
je 0x2b8a6f
testb %al, %al
je 0x2b8a62
movzbl %al, %ecx
cmpl $0x2c, %ecx
jne 0x2b8a4b
testb %al, %al
je 0x2b8a6f
cmpb %bpl, %al
jne 0x2b8988
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x17f4e3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0xca7f1(%rip), %rsi     # 0x383280
movq %rbx, %rdx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
movq 0x17f4c0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c561(%rip), %rsi     # 0x2e5013
leaq 0xca7ff(%rip), %rdx     # 0x3832b8
leaq 0xca7e2(%rip), %rcx     # 0x3832a2
leaq 0xca509(%rip), %r8      # 0x382fd0
movl $0x241, %r9d            # imm = 0x241
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x5b
popq %rdi
callq 0x17930
pushq $0x2c
popq %rbp
pushq $0x5d
popq %r15
leaq 0xb1700(%rip), %r13     # 0x36a38a
xorl %r12d, %r12d
cmpq (%r14), %r12
jae 0x2b8ceb
movq 0x20(%r14), %rax
movzbl (%rax,%r12), %edx
cmpl $0xfd, %edx
je 0x2b8cbb
cmpl $0xff, %edx
je 0x2b8cb7
cmpl $0xfe, %edx
jne 0x2b8cc8
pushq $0x44
jmp 0x2b8cbd
pushq $0x49
jmp 0x2b8cbd
pushq $0x58
popq %rdi
movq %rbx, %rsi
callq 0x17930
jmp 0x2b8cd5
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x17a50
incq %r12
cmpq (%r14), %r12
movl %r15d, %edi
cmovbl %ebp, %edi
movq %rbx, %rsi
callq 0x17930
jmp 0x2b8c8d
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17930
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
movzbl %sil, %ebp
leaq 0x8(%rsp), %r15
leaq 0x92ee8(%rip), %r12     # 0x34bc10
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2b7c9a
testb %al, %al
je 0x2b8d5e
movq 0x10(%rsp), %r13
movl 0x8(%rsp), %edi
movl %ebp, %esi
callq 0x2b7920
movzbl %al, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x17a50
jmp 0x2b8d28
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_set_sequences
void gt_eoplist_set_sequences(GtEoplist *eoplist,
                              const GtUchar *useq,
                              GtUword ustart,
                              GtUword ulen,
                              const GtUchar *vseq,
                              GtUword vstart,
                              GtUword vlen)
{
  gt_assert(eoplist != NULL);
  eoplist->useq = useq;
  eoplist->ustart = ustart;
  eoplist->ulen = ulen;
  eoplist->vseq = vseq;
  eoplist->vstart = vstart;
  eoplist->vlen = vlen;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2b8d92
movq 0x10(%rsp), %rax
movq %rsi, 0x28(%rdi)
movq %rdx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %r8, 0x30(%rdi)
movq %r9, 0x48(%rdi)
movq %rax, 0x50(%rdi)
popq %rax
retq
movq 0x17f1cf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c270(%rip), %rsi     # 0x2e5013
leaq 0x5c1f1(%rip), %rdx     # 0x314f9b
leaq 0xca598(%rip), %rcx     # 0x383349
leaq 0xca218(%rip), %r8      # 0x382fd0
movl $0x30e, %r9d            # imm = 0x30E
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b9b87
leal 0x1(%rcx), %eax
cmpl %r8d, %eax
jb 0x2b9b85
leal -0x1(%r8), %eax
cmpl %ecx, %eax
jne 0x2b9bb5
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 0x2b9bed
addq $0x40, %rsp
xorl %eax, %eax
popq %rcx
retq
movq 0x17e3da(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b47b(%rip), %rsi     # 0x2e5013
leaq 0xc9a7b(%rip), %rdx     # 0x38361a
leaq 0xc9a59(%rip), %rcx     # 0x3835ff
leaq 0xc9423(%rip), %r8      # 0x382fd0
movl $0x2f9, %r9d            # imm = 0x2F9
jmp 0x2b9be1
movq 0x17e3ac(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b44d(%rip), %rsi     # 0x2e5013
leaq 0x5b84d(%rip), %rdx     # 0x31541a
leaq 0xc9a2b(%rip), %rcx     # 0x3835ff
leaq 0xc93f5(%rip), %r8      # 0x382fd0
movl $0x2fe, %r9d            # imm = 0x2FE
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-eoplist.c
// Function: gt_eoplist_polished_ends
void gt_eoplist_polished_ends(GtEoplist *eoplist,
                              const GtFtPolishing_info *pol_info,
                              bool withpolcheck,
                              bool pol_info_out)
{
  gt_assert(eoplist != NULL);
  eoplist->pol_info = pol_info;
  eoplist->withpolcheck = withpolcheck;
  eoplist->pol_info_out = pol_info_out;
}

// Assembly:
testq %rdi, %rdi
je 0x2ba2d0
movq %rsi, 0x88(%rdi)
movb %dl, 0x58(%rdi)
movb %cl, 0x59(%rdi)
retq
pushq %rax
movq 0x17dc90(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2ad31(%rip), %rsi     # 0x2e5013
leaq 0x5acb2(%rip), %rdx     # 0x314f9b
leaq 0xc92e2(%rip), %rcx     # 0x3835d2
leaq 0xc8cd9(%rip), %r8      # 0x382fd0
movl $0x541, %r9d            # imm = 0x541
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace_new
GtFrontTrace *front_trace_new(void)
{
  GtFrontTrace *front_trace = gt_malloc(sizeof *front_trace);

  gt_assert(front_trace != NULL);
  /*printf("sizeof *backref_table=" GT_WU " bytes\n",
          sizeof *front_trace->backref_table);*/
  front_trace->backref_table = NULL;
  front_trace->backref_nextfree = 0;
  front_trace->backref_allocated = 0;
  front_trace->gen_table = NULL;
  front_trace->maxlcs = (1 << (32 - GT_FT_BACKTRACEBITS)) - 1;
  front_trace->gen_allocated = 0;
  front_trace->gen_nextfree = 0;
  front_trace->previoustrimleft = 0;
#ifdef WITHDISTRIBUTION
  front_trace->lcs_dist = distribution_new();
  front_trace->valid_dist = distribution_new();
  front_trace->trimleft_diff_dist = distribution_new();
  front_trace->space_per_pos_dist = distribution_new();
#endif
  front_trace->backtracepath = NULL;
  front_trace->backtracepath_allocated = 0;
  front_trace->backtracestack.nextfree = front_trace->backtracestack.allocated
                                       = 0;
  front_trace->backtracestack.space = NULL;
  return front_trace;
}

// Assembly:
pushq %rax
leaq 0xc92f1(%rip), %rsi     # 0x3836a1
pushq $0x68
popq %rdi
pushq $0x53
popq %rdx
callq 0x93160
testq %rax, %rax
je 0x2ba3ea
andq $0x0, (%rax)
andq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x1fffffff, 0x8(%rax)  # imm = 0x1FFFFFFF
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
popq %rcx
retq
movq 0x17db77(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2ac18(%rip), %rsi     # 0x2e5013
leaq 0x8fea9(%rip), %rdx     # 0x34a2ab
leaq 0xc92b8(%rip), %rcx     # 0x3836c1
leaq 0xc9291(%rip), %r8      # 0x3836a1
pushq $0x55
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace_reset
void front_trace_reset(GtFrontTrace *front_trace,
                       GT_UNUSED GtUword sumseqlen)
{
#ifdef WITHDISTRIBUTION
  double space_per_pos = (double) front_trace_size(front_trace)/sumseqlen;
#endif

  gt_assert(front_trace != NULL);
#ifdef WITHDISTRIBUTION
  distribution_add(front_trace->space_per_pos_dist,
                   (GtUword) (space_per_pos * 100.0));
#endif
  front_trace->backref_nextfree = 0;
  front_trace->gen_nextfree = 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2ba430
andq $0x0, 0x10(%rdi)
andq $0x0, 0x50(%rdi)
retq
pushq %rax
movq 0x17db30(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2abd1(%rip), %rsi     # 0x2e5013
leaq 0x8fe62(%rip), %rdx     # 0x34a2ab
leaq 0xc9281(%rip), %rcx     # 0x3836d1
leaq 0xc924a(%rip), %r8      # 0x3836a1
pushq $0x7e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2ba4d4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xc9224(%rip), %r14     # 0x3836a1
movq %r14, %rsi
movl $0x97, %edx
callq 0x936f9
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x98, %edx
callq 0x936f9
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x99, %edx
callq 0x936f9
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x9a, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-generation.c
// Function: gt_check_diagonal_run
static void gt_check_diagonal_run(GT_UNUSED const GtUchar *useq,
                                  GT_UNUSED const GtUchar *vseq,
                                  GT_UNUSED GtWord diagonal,
                                  unsigned int firstrow,
                                  unsigned int nextrow)
{
  GtUword idx;

  gt_assert(useq != NULL && vseq != NULL && firstrow <= nextrow);
  for (idx = firstrow; idx < nextrow; idx++)
  {
    gt_assert (useq[idx] == vseq[idx+diagonal]);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2bb96d
testq %rsi, %rsi
je 0x2bb96d
cmpl %r8d, %ecx
ja 0x2bb96d
movl %ecx, %eax
movl %r8d, %ecx
addq %rdx, %rsi
cmpq %rax, %rcx
je 0x2bb96b
movb (%rdi,%rax), %dl
leaq 0x1(%rax), %r8
cmpb (%rsi,%rax), %dl
movq %r8, %rax
je 0x2bb91f
movq 0x17c62e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x296cf(%rip), %rsi     # 0x2e5013
leaq 0xc854f(%rip), %rdx     # 0x383e9a
leaq 0xc8532(%rip), %rcx     # 0x383e84
leaq 0xc7d48(%rip), %r8      # 0x3836a1
movl $0x108, %r9d            # imm = 0x108
xorl %eax, %eax
callq 0x17a50
callq 0x17390
popq %rax
retq
movq 0x17c5f4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29695(%rip), %rsi     # 0x2e5013
leaq 0xc84cb(%rip), %rdx     # 0x383e50
leaq 0xc84f8(%rip), %rcx     # 0x383e84
leaq 0xc7d0e(%rip), %r8      # 0x3836a1
movl $0x105, %r9d            # imm = 0x105
jmp 0x2bb95f
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-generation.c
// Function: polished_point2offset
static GtUword polished_point2offset(GT_UNUSED const GtFrontTrace *front_trace,
                                     const GtFtPolished_point *pp)
{
  GtWord base_diagonal, pp_diagonal;

  gt_assert(pp != NULL);
  pp_diagonal = (GtWord) pp->alignedlen - (GtWord) GT_MULT2(pp->row);
  gt_assert(pp->distance < front_trace->gen_nextfree);
  base_diagonal = (GtWord) pp->trimleft - (GtWord) pp->distance;
  gt_assert(base_diagonal <= pp_diagonal);
  gt_assert(pp_diagonal < base_diagonal +
                          (GtWord) front_trace->gen_table[pp->distance].valid);
  return (GtUword) (pp_diagonal - base_diagonal);
}

// Assembly:
pushq %rax
movq 0x10(%rsi), %rcx
cmpq 0x50(%rdi), %rcx
jae 0x2bb9d5
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
addq %rax, %rax
subq %rax, %rdx
movq 0x18(%rsi), %rsi
subq %rcx, %rsi
movq %rdx, %rax
subq %rsi, %rax
jl 0x2bba03
movq 0x20(%rdi), %rdi
movzwl 0x2(%rdi,%rcx,4), %ecx
addq %rcx, %rsi
cmpq %rsi, %rdx
jge 0x2bba31
popq %rcx
retq
movq 0x17c58c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2962d(%rip), %rsi     # 0x2e5013
leaq 0xc80e4(%rip), %rdx     # 0x383ad1
leaq 0xc80c7(%rip), %rcx     # 0x383abb
leaq 0xc7ca6(%rip), %r8      # 0x3836a1
movl $0xe8, %r9d
jmp 0x2bba5d
movq 0x17c55e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x295ff(%rip), %rsi     # 0x2e5013
leaq 0xc80df(%rip), %rdx     # 0x383afa
leaq 0xc8099(%rip), %rcx     # 0x383abb
leaq 0xc7c78(%rip), %r8      # 0x3836a1
movl $0xea, %r9d
jmp 0x2bba5d
movq 0x17c530(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x295d1(%rip), %rsi     # 0x2e5013
leaq 0xc80ce(%rip), %rdx     # 0x383b17
leaq 0xc806b(%rip), %rcx     # 0x383abb
leaq 0xc7c4a(%rip), %r8      # 0x3836a1
movl $0xec, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-front-generation.c
// Function: valid_total_fronts
static GtUword valid_total_fronts(const GtFrontGeneration *gen_table,
                                  GtUword start,GtUword end)
{
  GtUword idx, valid_total = 0;

  gt_assert(gen_table);
  for (idx = start; idx < end; idx++)
  {
    valid_total += gen_table[idx].valid;
  }
  return valid_total;
}

// Assembly:
testq %rdi, %rdi
je 0x2bba83
xorl %eax, %eax
cmpq %rdx, %rsi
jae 0x2bba82
movzwl 0x2(%rdi,%rsi,4), %ecx
addq %rcx, %rax
incq %rsi
jmp 0x2bba70
retq
pushq %rax
movq 0x17c4dd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2957e(%rip), %rsi     # 0x2e5013
leaq 0xc80cd(%rip), %rdx     # 0x383b69
leaq 0xc80d0(%rip), %rcx     # 0x383b73
leaq 0xc7bf7(%rip), %r8      # 0x3836a1
movl $0xf5, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390