LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x32211a
movl %edi, %eax
leaq 0xca1ea(%rip), %rcx     # 0x3ec2d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x44, %sil
jmp 0x322117
testb %sil, %sil
movl $0x58, %eax
movl $0x4d, %esi
cmovnel %eax, %esi
jmp 0x322117
xorb $0x1, %sil
shlb $0x4, %sil
addb $0x3d, %sil
jmp 0x322117
movb $0x49, %sil
movl %esi, %eax
retq
pushq %rax
callq 0x9392d
// File: /workspace/github_c_makefile_star2_O1/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 0x32213d
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_O1/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 0xca1c7(%rip), %rsi     # 0x3ec310
movl $0x98, %edi
movl $0x45, %edx
callq 0x1092b2
testq %rax, %rax
je 0x3221b4
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 0x328b2f
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 0x9395b
// File: /workspace/github_c_makefile_star2_O1/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 0x3222fa
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x32236b
leaq 0x8(%rsp), %rdi
movq %rbx, (%rsp)
movq %rbx, %rsi
movl %ebp, %edx
callq 0x3223d2
testb %al, %al
je 0x3222dc
movzbl %bpl, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
xorl %r13d, %r13d
leaq 0x17(%rbx), %rax
cmpq %r12, %rax
jb 0x322292
movq %r12, %xmm0
punpckldq 0x2e6bf(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2e6c7(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2eadb(%rip), %xmm1    # 0x350d18
addsd 0xca09b(%rip), %xmm1    # 0x3ec2e0
movsd 0x2cfdb(%rip), %xmm0    # 0x34f228
addsd %xmm0, %xmm1
addsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x2eab3(%rip), %xmm1    # 0x350d20
cvttsd2si %xmm1, %r12
andq %rcx, %r12
orq %rax, %r12
movq %r13, %rdi
movq %r12, %rsi
leaq 0xca08b(%rip), %rdx     # 0x3ec310
movl $0x64, %ecx
callq 0x1094e6
movq %rax, %r13
leaq (%rbx,%r13), %r14
movq 0x10(%rsp), %r15
movl 0x8(%rsp), %edi
movl %ebp, %esi
callq 0x3220d8
movzbl %al, %ecx
movq %r14, %rdi
leaq 0x92c0d(%rip), %rsi     # 0x3b4ec0
movq %r15, %rdx
xorl %eax, %eax
callq 0x17130
cltq
addq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl %ebp, %edx
callq 0x3223d2
testb %al, %al
jne 0x32220b
jmp 0x3222df
xorl %r13d, %r13d
movq (%rsp), %rdi
callq 0x322500
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_O1/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 0xca00b(%rip), %rsi     # 0x3ec310
movl $0x40, %edi
movl $0x14e, %edx            # imm = 0x14E
callq 0x1092b2
testq %rax, %rax
je 0x322366
movq %rax, %rbx
xorl %r14d, %r14d
movq %r14, 0x18(%rax)
movl $0x46, 0x20(%rax)
leaq 0xc9fdf(%rip), %rdx     # 0x3ec310
movl $0xd2, %esi
xorl %edi, %edi
movl $0x156, %ecx            # imm = 0x156
callq 0x1094e6
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 0x93992
// File: /workspace/github_c_makefile_star2_O1/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 0x3223cc
testq %rsi, %rsi
je 0x3223cc
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x32239d
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x32239d
testb %dl, %dl
je 0x3223a5
movq %rax, (%rdi)
addq %rax, %rcx
movq %rcx, 0x8(%rdi)
movl $0x1, 0x10(%rdi)
jmp 0x3223bc
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
jmp 0x3223bc
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 0x939cb
// File: /workspace/github_c_makefile_star2_O1/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 0x322538
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x322523
leaq 0xc9df7(%rip), %rsi     # 0x3ec310
movl $0x165, %edx            # imm = 0x165
callq 0x109670
leaq 0xc9de6(%rip), %rsi     # 0x3ec310
movq %rbx, %rdi
movl $0x167, %edx            # imm = 0x167
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x322613
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testb %al, %al
je 0x322613
movzbl %al, %r13d
cmpl $0xa, %r13d
je 0x322613
movsbl %al, %ebp
callq 0x17870
movq (%rax), %rcx
movslq %ebp, %rax
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x3225b4
cmpl $0x48, %r13d
jle 0x3225c2
cmpl $0x49, %r13d
je 0x3225ef
cmpl $0x4d, %r13d
je 0x3225e2
cmpl $0x58, %r13d
jne 0x322622
testq %r12, %r12
je 0x322601
movq %r15, %rdi
callq 0x3228fe
decq %r12
jne 0x3225a5
jmp 0x322601
leaq (%r12,%r12,4), %rcx
leaq (%rax,%rcx,2), %r12
addq $-0x30, %r12
jmp 0x322604
cmpl $0x3d, %r13d
je 0x3225e2
cmpl $0x44, %r13d
jne 0x322622
testq %r12, %r12
je 0x322601
movq %r15, %rdi
callq 0x322629
decq %r12
jne 0x3225d3
jmp 0x322601
movq %r15, %rdi
movq %r12, %rsi
callq 0x322783
jmp 0x322601
testq %r12, %r12
je 0x322601
movq %r15, %rdi
callq 0x3226d6
decq %r12
jne 0x3225f4
xorl %r12d, %r12d
movb 0x1(%r14), %al
incq %r14
cmpb %bl, %al
jne 0x322559
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x93b21
// File: /workspace/github_c_makefile_star2_O1/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 0x3228f4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3228f4
movq %rdi, %r14
cmpq $0xfe, %rbx
jb 0x322858
leaq 0xc9b5c(%rip), %r15     # 0x3ec310
movq 0x8(%r14), %rax
cmpq %rax, (%r14)
jb 0x322829
movq %rax, %xmm0
punpckldq 0x2e116(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2e11e(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x86822(%rip), %xmm1    # 0x3a9008
addsd 0x8dbe2(%rip), %xmm1    # 0x3b03d0
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2e51e(%rip), %xmm1    # 0x350d20
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rax, %rsi
movq %rsi, 0x8(%r14)
movq 0x20(%r14), %rdi
movq %r15, %rdx
movl $0xd3, %ecx
callq 0x1094e6
movq %rax, 0x20(%r14)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x3228ef
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movb $-0x4, (%rax,%rcx)
addq $-0xfd, %rbx
cmpq $0xfe, %rbx
jae 0x3227b4
movq 0x8(%r14), %rax
cmpq %rax, (%r14)
jb 0x3228d1
movq %rax, %xmm0
punpckldq 0x2e072(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2e07a(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x8677e(%rip), %xmm1    # 0x3a9008
addsd 0x8db3e(%rip), %xmm1    # 0x3b03d0
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
subsd 0x2e47e(%rip), %xmm1    # 0x350d20
sarq $0x3f, %rdx
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rax, %rsi
movq %rsi, 0x8(%r14)
movq 0x20(%r14), %rdi
leaq 0xc9a4d(%rip), %rdx     # 0x3ec310
movl $0xd0, %ecx
callq 0x1094e6
movq %rax, 0x20(%r14)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x3228f9
decb %bl
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x93c6e
callq 0x93c35
callq 0x93ca7
// File: /workspace/github_c_makefile_star2_O1/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 0x322a1b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x3229e0
leaq 0x70(%rbx), %r14
leaq 0xc9949(%rip), %rsi     # 0x3ec310
movl $0xb5, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x90(%rbx), %rdi
callq 0x328b67
movq 0x20(%rbx), %rdi
leaq 0xc9919(%rip), %r14     # 0x3ec310
movq %r14, %rsi
movl $0xb7, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0xb8, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x322a70
leaq 0x1(%rsi), %rcx
movq (%rdi), %rax
cmpq %rax, %rcx
jae 0x322a6e
movq 0x20(%rdi), %rcx
leaq (%rcx,%rsi), %rdx
addq %rcx, %rax
decq %rax
cmpq %rax, %rdx
jae 0x322a6e
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 0x322a53
popq %rax
retq
callq 0x93d52
// File: /workspace/github_c_makefile_star2_O1/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 0x322ac4
movq 0x18(%r14), %rdi
leal (%rbx,%rbx,2), %esi
leaq 0xc985f(%rip), %rdx     # 0x3ec310
movl $0x144, %ecx            # imm = 0x144
callq 0x1094e6
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x322ad0
movl %ebx, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x93dfd
// File: /workspace/github_c_makefile_star2_O1/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), %rax
pcmpeqd %xmm0, %xmm0
testq %rax, %rax
je 0x322af9
movdqu 0x28(%rsi), %xmm1
psubq %xmm0, %xmm1
movdqu %xmm1, 0x28(%rsi)
decq %rax
movq %rax, 0x38(%rsi)
jmp 0x322b5c
movq (%rsi), %rcx
cmpq 0x8(%rsi), %rcx
je 0x322b73
movzbl (%rcx), %r8d
cmpl $0xfd, %r8d
je 0x322b2d
cmpl $0xff, %r8d
je 0x322b27
cmpl $0xfe, %r8d
jne 0x322b3d
incq 0x28(%rsi)
jmp 0x322b52
incq 0x30(%rsi)
jmp 0x322b52
movdqu 0x28(%rsi), %xmm1
psubq %xmm0, %xmm1
movdqu %xmm1, 0x28(%rsi)
jmp 0x322b52
movdqu 0x28(%rsi), %xmm1
psubq %xmm0, %xmm1
movdqu %xmm1, 0x28(%rsi)
movzbl (%rcx), %eax
movq %rax, 0x38(%rsi)
movslq 0x10(%rsi), %r8
addq %r8, %rcx
movq %rcx, (%rsi)
cmpq %rdx, 0x28(%rsi)
jne 0x322add
movq %rdx, (%rdi)
movq 0x30(%rsi), %rax
addq $0x28, %rsi
jmp 0x322b8e
movq 0x30(%rsi), %rax
testq %rax, %rax
jne 0x322b83
cmpq $0x0, 0x28(%rsi)
je 0x322b9d
movq 0x28(%rsi), %rcx
addq $0x28, %rsi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
pxor %xmm0, %xmm0
movdqu %xmm0, (%rsi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3222fa
movq %rax, %r14
leaq 0x1(,%r15,2), %r13
leaq 0x2(,%r15,2), %rdi
leaq 0xc973d(%rip), %rdx     # 0x3ec310
movl $0x8, %esi
movl $0x20c, %ecx            # imm = 0x20C
callq 0x1093ef
movq %rax, %rbx
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x32236b
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x322ad5
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movapd %xmm0, 0x10(%rsp)
testb %al, %al
je 0x322c6d
xorl %ebp, %ebp
leaq 0x20(%rsp), %r12
movq 0x28(%rsp), %rax
cmpq %r13, %rax
ja 0x322d0c
incq (%rbx,%rax,8)
incq %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x322ad5
testb %al, %al
jne 0x322c1f
movq %rbp, %xmm0
punpckldq 0x2dc8d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2dc95(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movq %r14, %rdi
callq 0x322500
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rax
testq %rax, %rax
je 0x322cc7
movq %rax, %xmm1
punpckldq 0x2dc52(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2dc5a(%rip), %xmm1    # 0x3508f0
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 0x322c78
leaq 0xc963a(%rip), %rsi     # 0x3ec310
movq %rbx, %rdi
movl $0x21f, %edx            # imm = 0x21F
callq 0x109670
movapd 0x35d95(%rip), %xmm1    # 0x358a80
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 0x93e36
// File: /workspace/github_c_makefile_star2_O1/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 0x322d34
movq $0x0, 0x80(%r14)
leaq 0xb096f(%rip), %r15     # 0x3d36aa
leaq 0x4(%rsp), %r12
leaq 0xc95c9(%rip), %r13     # 0x3ec310
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x177f0
cmpl $0x1, %eax
jne 0x322e55
testq %r14, %r14
je 0x322e08
movq 0x78(%r14), %rax
cmpq %rax, 0x80(%r14)
jb 0x322de6
movq %rax, %xmm0
punpckldq 0x2db5d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2db65(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x86269(%rip), %xmm1    # 0x3a9008
addsd 0x86251(%rip), %xmm1    # 0x3a8ff8
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2df65(%rip), %xmm1    # 0x350d20
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 0x1094e6
movq %rax, 0x70(%r14)
movq 0x70(%r14), %rax
testq %rax, %rax
je 0x322e5d
movl 0x4(%rsp), %ecx
movq 0x80(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x80(%r14)
movl %ecx, (%rax,%rdx,4)
movb (%rbx), %cl
cmpb %bpl, %cl
sete %dl
movq %rbx, %rax
je 0x322e2f
testb %cl, %cl
je 0x322e2f
movzbl %cl, %esi
cmpl $0x2c, %esi
je 0x322e2f
movb 0x1(%rax), %cl
incq %rax
cmpb %bpl, %cl
sete %dl
jne 0x322e15
testb %cl, %cl
sete %cl
orb %dl, %cl
incq %rax
testb $0x1, %cl
cmoveq %rax, %rbx
je 0x322d47
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x93e6f
callq 0x93e93
// File: /workspace/github_c_makefile_star2_O1/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 0x322f66
movq %rdi, %r14
cmpq $0x0, 0x80(%rdi)
je 0x322f66
cmpq $0x0, 0x80(%r14)
je 0x322f4d
xorl %ebp, %ebp
xorl %ebx, %ebx
xorl %r13d, %r13d
movq 0x70(%r14), %rax
movslq (%rax,%rbp,4), %r15
cmpb $0x0, 0x14(%rsp)
je 0x322ec8
movq 0x18(%rsp), %rax
subl %r15d, %eax
js 0x322f61
movl %eax, %r15d
movq 0x40(%r14), %r12
subq %rbx, %r12
jbe 0x322f5c
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 0x328bbb
movq %rax, 0x20(%rsp)
movq 0x90(%r14), %rdi
callq 0x328bab
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 0x324e38
addq %r12, %rbx
addq %r15, %r13
incq %rbp
cmpq 0x80(%r14), %rbp
jb 0x322ea8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x93f05
callq 0x93ecc
callq 0x93f3e
// File: /workspace/github_c_makefile_star2_O1/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 0x322ffe
movl $0x2c, %ebp
leaq 0xb0715(%rip), %r15     # 0x3d36aa
xorl %r12d, %r12d
movq 0x20(%r14), %rax
movzbl (%rax,%r12), %edx
cmpl $0xfd, %edx
je 0x322fc7
cmpl $0xff, %edx
je 0x322fc0
cmpl $0xfe, %edx
jne 0x322fd6
movl $0x44, %edi
jmp 0x322fcc
movl $0x49, %edi
jmp 0x322fcc
movl $0x58, %edi
movq %rbx, %rsi
callq 0x17980
jmp 0x322fe3
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 0x322f98
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17980
// File: /workspace/github_c_makefile_star2_O1/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 0x3223d2
testb %al, %al
je 0x323080
movzbl %bpl, %ebp
leaq 0x91e79(%rip), %r15     # 0x3b4ec0
leaq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
movl 0x8(%rsp), %edi
movl %ebp, %esi
callq 0x3220d8
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 0x3223d2
testb %al, %al
jne 0x32304c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/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 0x323d6c
leal 0x1(%rcx), %eax
cmpl %r8d, %eax
jb 0x323d6a
leal -0x1(%r8), %eax
cmpl %ecx, %eax
jne 0x323d71
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 0x323d76
addq $0x40, %rsp
xorl %eax, %eax
popq %rcx
retq
callq 0x94253
callq 0x9421a
// File: /workspace/github_c_makefile_star2_O1/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 0x324432
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xc863a(%rip), %r14     # 0x3eca15
movq %r14, %rsi
movl $0x97, %edx
callq 0x109670
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x98, %edx
callq 0x109670
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x99, %edx
callq 0x109670
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x9a, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x324522
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x58(%rdi), %rax
cmpq %rax, 0x50(%rdi)
jb 0x3244ca
movq %rax, %xmm0
punpckldq 0x2c47f(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2c487(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2c89b(%rip), %xmm1    # 0x350d18
addsd 0x8bf4b(%rip), %xmm1    # 0x3b03d0
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x2c88b(%rip), %xmm1    # 0x350d20
sarq $0x3f, %rcx
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %rsi, 0x58(%r14)
movq 0x20(%r14), %rdi
shlq $0x2, %rsi
leaq 0xc855e(%rip), %rdx     # 0x3eca15
movl $0xa9, %ecx
callq 0x1094e6
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x32453b
movq 0x50(%r14), %rax
testq %rax, %rax
je 0x3244ef
movq %r15, %rcx
subq 0x60(%r14), %rcx
jb 0x324531
cmpq $0x10000, %rcx          # imm = 0x10000
jae 0x324536
movq 0x20(%r14), %rdx
movw %cx, (%rdx,%rax,4)
jmp 0x3244f8
movq 0x20(%r14), %rcx
movw $0x0, (%rcx)
movq %r15, 0x60(%r14)
cmpq 0x58(%r14), %rax
jae 0x324527
cmpq $0x10000, %rbx          # imm = 0x10000
jae 0x32452c
movq 0x20(%r14), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x50(%r14)
movw %bx, 0x2(%rcx,%rax,4)
popq %rbx
popq %r14
popq %r15
retq
callq 0x946c6
callq 0x94654
callq 0x9468d
callq 0x9461b
callq 0x945e2
callq 0x945a9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-front-generation.c
// Function: front_trace_add_trace
void front_trace_add_trace(GtFrontTrace *front_trace,
                           uint8_t backreference,
                           uint32_t localmatch_count)
{
  gt_assert (front_trace != NULL);
  if (front_trace->backref_nextfree >= front_trace->backref_allocated)
  {
    front_trace->backref_allocated
      = front_trace->backref_allocated * 1.2 + 128UL;
    front_trace->backref_table
      = gt_realloc(front_trace->backref_table,
                   sizeof *front_trace->backref_table
                   * front_trace->backref_allocated);
    gt_assert(front_trace->backref_table != NULL);
  }
  gt_assert(front_trace->backref_nextfree < front_trace->backref_allocated);
  front_trace->backref_table[front_trace->backref_nextfree].bits
    = backreference;
  gt_assert(localmatch_count <= front_trace->maxlcs);
  front_trace->backref_table[front_trace->backref_nextfree++].lcs
    = localmatch_count;
#ifdef WITHDISTRIBUTION
  distribution_add(front_trace->lcs_dist,lcs);
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x32461a
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jb 0x3245d2
movq %rax, %xmm0
punpckldq 0x2c375(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2c37d(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2c791(%rip), %xmm1    # 0x350d18
addsd 0x8be41(%rip), %xmm1    # 0x3b03d0
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x2c781(%rip), %xmm1    # 0x350d20
sarq $0x3f, %rcx
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %rsi, 0x18(%r14)
movq (%r14), %rdi
shlq $0x2, %rsi
leaq 0xc8455(%rip), %rdx     # 0x3eca15
movl $0xd1, %ecx
callq 0x1094e6
movq %rax, (%r14)
testq %rax, %rax
je 0x324629
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x32461f
movq (%r14), %rcx
movl (%rcx,%rax,4), %edx
andb $0x7, %bpl
movzbl %bpl, %esi
andl $-0x8, %edx
orl %esi, %edx
movl %edx, (%rcx,%rax,4)
movl %ebx, %eax
cmpq %rax, 0x8(%r14)
jb 0x324624
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movl (%rax,%rcx,4), %edx
andl $0x7, %edx
leal (%rdx,%rbx,8), %edx
movl %edx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x947aa
callq 0x94738
callq 0x94771
callq 0x946ff
// File: /workspace/github_c_makefile_star2_O1/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 0x32514d
testq %rsi, %rsi
je 0x32514d
cmpl %r8d, %ecx
ja 0x32514d
jae 0x325146
movl %r8d, %eax
addq %rdx, %rsi
movl %ecx, %ecx
movb (%rdi,%rcx), %dl
cmpb (%rsi,%rcx), %dl
jne 0x325148
incq %rcx
cmpq %rcx, %rax
jne 0x325136
popq %rax
retq
callq 0x94f3c
callq 0x94f75
// File: /workspace/github_c_makefile_star2_O1/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 0x32518c
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 0x325191
movq 0x20(%rdi), %rdi
movzwl 0x2(%rdi,%rcx,4), %ecx
addq %rcx, %rsi
cmpq %rsi, %rdx
jge 0x325196
popq %rcx
retq
callq 0x94fae
callq 0x95020
callq 0x94fe7
// File: /workspace/github_c_makefile_star2_O1/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 0x3251b8
xorl %eax, %eax
cmpq %rdx, %rsi
jae 0x3251b7
movzwl 0x2(%rdi,%rsi,4), %ecx
addq %rcx, %rax
incq %rsi
cmpq %rsi, %rdx
jne 0x3251a7
retq
pushq %rax
callq 0x95059
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-front-generation.c
// Function: stack_top_ptr_get
static GtBacktraceFrontStackelem *stack_top_ptr_get(
                          GtBacktraceFrontStack *stack)
{
  if (stack->nextfree >= stack->allocated)
  {
    stack->allocated = stack->allocated * 1.2 + 128UL;
    stack->space = gt_realloc(stack->space,
                              sizeof *stack->space * stack->allocated);
    gt_assert(stack->space != NULL);
  }
  return stack->space + stack->nextfree++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jb 0x325244
movq %rax, %xmm0
punpckldq 0x2b707(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2b70f(%rip), %xmm0    # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x2bb23(%rip), %xmm1    # 0x350d18
addsd 0x8b1d3(%rip), %xmm1    # 0x3b03d0
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x2bb0f(%rip), %xmm1    # 0x350d20
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x10(%rbx)
movq (%rbx), %rdi
shlq $0x3, %rdx
leaq (%rdx,%rdx,8), %rsi
leaq 0xc77e3(%rip), %rdx     # 0x3eca15
movl $0x19a, %ecx            # imm = 0x19A
callq 0x1094e6
movq %rax, (%rbx)
testq %rax, %rax
je 0x32525d
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
leaq (%rax,%rax,8), %rax
shlq $0x3, %rax
addq (%rbx), %rax
popq %rbx
retq
callq 0x95092
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-front-prune.c
// Function: ft_longest_common_all
static GtUword ft_longest_common_all(GtFtSequenceObject *useq,
                                     GtUword ustart,
                                     GtFtSequenceObject *vseq,
                                     GtUword vstart)
{
  GtUword upos, vpos;

  for (upos = ustart, vpos = vstart;
       ft_sequenceobject_symbol_match(useq,upos,vseq,vpos);
       upos++, vpos++)
    /* Nothing */ ;
  return upos - ustart;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %r14
cmpq %rsi, 0x30(%rdi)
jbe 0x32893b
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq %rbx, %r14
cmpq %r15, 0x30(%r12)
jbe 0x32893b
movq %r13, %rdi
movq %r14, %rsi
callq 0x3293f0
cmpb $-0x2, %al
je 0x32893b
movl %eax, %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x3293f0
cmpb %al, %bpl
jne 0x32893b
incq %r14
incq %r15
cmpq %r14, 0x30(%r13)
ja 0x328907
subq %rbx, %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_O1/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_full_front_edist_trace_new
GtFullFrontEdistTrace *gt_full_front_edist_trace_new(void)
{
  GtFullFrontEdistTrace *fet = gt_malloc(sizeof *fet);

  gt_assert(fet != NULL);
  fet->spaceGtFtFrontvalue = NULL;
  fet->allocatedGtFtFrontvalue = 0;
  fet->front_trace = front_trace_new();
  return fet;
}

// Assembly:
pushq %rbx
leaq 0xc47ab(%rip), %rsi     # 0x3ed2e2
movl $0x18, %edi
movl $0x3d3, %edx            # imm = 0x3D3
callq 0x1092b2
testq %rax, %rax
je 0x328b62
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
callq 0x324364
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x95570
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_full_front_edist_trace_delete
void gt_full_front_edist_trace_delete(GtFullFrontEdistTrace *fet)
{
  if (fet != NULL)
  {
    gt_free(fet->spaceGtFtFrontvalue);
    front_trace_delete(fet->front_trace);
    gt_free(fet);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x328baa
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xc4765(%rip), %r14     # 0x3ed2e2
movq %r14, %rsi
movl $0x3e0, %edx            # imm = 0x3E0
callq 0x109670
movq 0x10(%rbx), %rdi
callq 0x3243c5
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3e2, %edx            # imm = 0x3E2
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-front-prune.c
// Function: gt_sequenceobject_esr_get
static GtUchar gt_sequenceobject_esr_get(GtFtSequenceObject *seq,GtUword idx)
{
  gt_assert(idx < seq->substringlength);
  if (idx >= seq->cache_num_positions)
  {
    const GtUword addamount = 16UL;
    GtUword cidx, tostore = GT_MIN(seq->cache_num_positions + addamount,
                                seq->substringlength);

    if (tostore > seq->sequence_cache->allocated)
    {
      seq->sequence_cache->allocated += addamount;
      seq->sequence_cache->space
        = gt_realloc(seq->sequence_cache->space,
                     sizeof (GtUchar) * seq->sequence_cache->allocated);
      seq->cache_ptr = (GtUchar *) seq->sequence_cache->space;
    }
    for (cidx = seq->cache_num_positions; cidx < tostore; cidx++)
    {
      seq->cache_ptr[cidx]
        = gt_encseq_reader_next_encoded_char(seq->encseqreader);
    }
    seq->cache_num_positions = tostore;
  }
  gt_assert(seq->cache_ptr != NULL && idx < seq->cache_num_positions);
  return seq->cache_ptr[idx];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3293eb
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %r15
cmpq %rsi, %r15
ja 0x3293c8
addq $0x10, %r15
cmpq %rax, %r15
cmovaeq %rax, %r15
movq 0x28(%r14), %rax
movq 0x10(%rax), %rsi
cmpq %rsi, %r15
jbe 0x3293a2
addq $0x10, %rsi
movq %rsi, 0x10(%rax)
movq (%rax), %rdi
leaq 0xc3f55(%rip), %rdx     # 0x3ed2e2
movl $0x9f, %ecx
callq 0x1094e6
movq 0x28(%r14), %rcx
movq %rax, (%rcx)
movq %rax, 0x20(%r14)
movq 0x40(%r14), %r12
cmpq %r15, %r12
jae 0x3293c4
movq 0x18(%r14), %rdi
callq 0xec7be
movq 0x20(%r14), %rcx
movb %al, (%rcx,%r12)
incq %r12
cmpq %r12, %r15
jne 0x3293ab
movq %r15, 0x40(%r14)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x3293e6
cmpq %rbx, 0x40(%r14)
jbe 0x3293e6
movb (%rax,%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x9568d
callq 0x95654