LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_use_mean_cutoff
void gt_kmer_database_use_mean_cutoff(GtKmerDatabase *kdb,
                                      GtUword mean_fraction, GtUword min_cutoff)
{
  gt_assert(kdb != NULL);
  gt_assert(mean_fraction != 0);
  gt_assert(min_cutoff != 0);

  kdb->cutoff_is_set = true;
  kdb->mean_cutoff = true;
  kdb->mean_fraction = mean_fraction;
  kdb->min_cutoff = min_cutoff;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1998c2
movq 0x4a270f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37c778(%rip), %rsi    # 0x516013
leaq 0x3bdf00(%rip), %rdx    # 0x5577a2
leaq 0x3be161(%rip), %rcx    # 0x557a0a
leaq 0x3bde8b(%rip), %r8     # 0x55773b
movl $0x22f, %r9d            # imm = 0x22F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1998c4
jmp 0x1998c6
cmpq $0x0, 0x8(%rsp)
jne 0x199906
movq 0x4a26cb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37c734(%rip), %rsi    # 0x516013
leaq 0x3be145(%rip), %rdx    # 0x557a2b
leaq 0x3be11d(%rip), %rcx    # 0x557a0a
leaq 0x3bde47(%rip), %r8     # 0x55773b
movl $0x230, %r9d            # imm = 0x230
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x199908
jmp 0x19990a
cmpq $0x0, (%rsp)
jne 0x199949
movq 0x4a2688(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37c6f1(%rip), %rsi    # 0x516013
leaq 0x3be115(%rip), %rdx    # 0x557a3e
leaq 0x3be0da(%rip), %rcx    # 0x557a0a
leaq 0x3bde04(%rip), %r8     # 0x55773b
movl $0x231, %r9d            # imm = 0x231
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19994b
movq 0x10(%rsp), %rax
movb $0x1, 0x78(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x79(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_mean_nu_of_occ
GtUword gt_kmer_database_get_mean_nu_of_occ(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->seen_kmers <= kdb->nu_kmer_codes);

  if (kdb->seen_kmers == 0)
    return 0;
  return kdb->seen_kmer_counts[kdb->nu_kmer_codes] / kdb->seen_kmers;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x199b19
movq 0x4a24b8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37c521(%rip), %rsi    # 0x516013
leaq 0x3bdca9(%rip), %rdx    # 0x5577a2
leaq 0x3bdfbb(%rip), %rcx    # 0x557abb
leaq 0x3bdc34(%rip), %r8     # 0x55773b
movl $0x251, %r9d            # imm = 0x251
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x199b1b
jmp 0x199b1d
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x199b69
movq 0x4a2468(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37c4d1(%rip), %rsi    # 0x516013
leaq 0x3bdf96(%rip), %rdx    # 0x557adf
leaq 0x3bdf6b(%rip), %rcx    # 0x557abb
leaq 0x3bdbe4(%rip), %r8     # 0x55773b
movl $0x252, %r9d            # imm = 0x252
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x199b6b
movq 0x8(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x199b82
movq $0x0, 0x10(%rsp)
jmp 0x199ba8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
xorl %edx, %edx
divq 0x40(%rcx)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_min_nu_of_occ
GtUword gt_kmer_database_get_min_nu_of_occ(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);
  gt_assert(kdb->min_nu_occ <= kdb->seen_kmer_counts[kdb->nu_kmer_codes]);

  if (kdb->offset[kdb->nu_kmer_codes] == 0)
    return 0;
  return kdb->min_nu_occ;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x199c09
movq 0x4a23c8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37c431(%rip), %rsi    # 0x516013
leaq 0x3bdbb9(%rip), %rdx    # 0x5577a2
leaq 0x3bdf15(%rip), %rcx    # 0x557b05
leaq 0x3bdb44(%rip), %r8     # 0x55773b
movl $0x25b, %r9d            # imm = 0x25B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x199c0b
jmp 0x199c0d
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rsp), %rdx
movq 0x28(%rdx), %rdx
cmpq (%rcx,%rdx,8), %rax
jbe 0x199c66
movq 0x4a236b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37c3d4(%rip), %rsi    # 0x516013
leaq 0x3bdee2(%rip), %rdx    # 0x557b28
leaq 0x3bdeb8(%rip), %rcx    # 0x557b05
leaq 0x3bdae7(%rip), %r8     # 0x55773b
movl $0x25c, %r9d            # imm = 0x25C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x199c68
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x199c8b
movq $0x0, 0x10(%rsp)
jmp 0x199c99
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_byte_size
GtUword gt_kmer_database_get_byte_size(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);

  return ((GtUword) kdb->current_size * sizeof (*kdb->positions)) +
    ((GtUword) kdb->current_size * sizeof (*kdb->unique_ids)) +
   (2 * ((GtUword) sizeof (GtUword) * (kdb->nu_kmer_codes + 1)) - 1);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x19a274
movq 0x4a1d5d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37bdc6(%rip), %rsi    # 0x516013
leaq 0x3bd54e(%rip), %rdx    # 0x5577a2
leaq 0x3bdba5(%rip), %rcx    # 0x557e00
leaq 0x3bd4d9(%rip), %r8     # 0x55773b
movl $0x2ba, %r9d            # imm = 0x2BA
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19a276
movq (%rsp), %rax
movq 0x38(%rax), %rax
shlq $0x3, %rax
movq (%rsp), %rcx
movq 0x38(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq (%rsp), %rcx
movq 0x28(%rcx), %rcx
addq $0x1, %rcx
shlq $0x3, %rcx
shlq %rcx
subq $0x1, %rcx
addq %rcx, %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_get_used_size
GtUword gt_kmer_database_get_used_size(GtKmerDatabase *kdb)
{
  GtUword size_positions;

  gt_assert(kdb != NULL);

  size_positions = (GtUword) sizeof (GtUword) * kdb->offset[kdb->nu_kmer_codes];

  return size_positions + 2 *
    ((GtUword) sizeof (GtUword) * (kdb->nu_kmer_codes + 1)) - 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x19a2f9
movq 0x4a1cd8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37bd41(%rip), %rsi    # 0x516013
leaq 0x3bd4c9(%rip), %rdx    # 0x5577a2
leaq 0x3bdb3f(%rip), %rcx    # 0x557e1f
leaq 0x3bd454(%rip), %r8     # 0x55773b
movl $0x2c5, %r9d            # imm = 0x2C5
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19a2fb
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
addq $0x1, %rcx
shlq $0x3, %rcx
shlq %rcx
addq %rcx, %rax
subq $0x1, %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_print_buffer
void gt_kmer_database_print_buffer(GtKmerDatabase *kdb, GtLogger *logger)
{
  GtUword i,
          kmercode,
          startpos;

  gt_assert(kdb != NULL && logger != NULL);

  if (!gt_logger_enabled(logger) || kdb->sb.printed)
    return;

  for (i = 0; i < kdb->sb.kmer_count; i++) {
    gt_kmer_database_decode_kmer(kdb->sb.kmers[i].a, kmercode, startpos);
    gt_logger_log(logger, "Kmer: " GT_WU ", Startpos: " GT_WU, kmercode,
           startpos + kdb->sb.offset);
  }
  kdb->sb.printed = true;
  gt_logger_log(logger, "number of kmers in sb: " GT_WU, kdb->sb.kmer_count);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x19a5ce
cmpq $0x0, 0x18(%rsp)
jne 0x19a606
movq 0x4a19cb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37ba34(%rip), %rsi    # 0x516013
leaq 0x3bd858(%rip), %rdx    # 0x557e3e
leaq 0x3bd92b(%rip), %rcx    # 0x557f18
leaq 0x3bd147(%rip), %r8     # 0x55773b
movl $0x2fc, %r9d            # imm = 0x2FC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19a608
movq 0x18(%rsp), %rdi
callq 0xe7980
testb $0x1, %al
jne 0x19a618
jmp 0x19a626
movq 0x20(%rsp), %rax
testb $0x1, 0xd4(%rax)
je 0x19a62b
jmp 0x19a6fe
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0xb0(%rcx), %rax
jae 0x19a6d3
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rax
movq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
shrq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rcx
movq 0x10(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq (%rcx), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0xc0(%rax), %rcx
leaq 0x3bd87d(%rip), %rsi    # 0x557f36
movb $0x0, %al
callq 0xe7cd0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x19a634
movq 0x20(%rsp), %rax
movb $0x1, 0xd4(%rax)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rdx
leaq 0x3bd858(%rip), %rsi    # 0x557f4f
movb $0x0, %al
callq 0xe7cd0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_increase_size
static void gt_kmer_database_increase_size(GtKmerDatabase *kdb)
{
  gt_assert(kdb != NULL);

  kdb->current_size = (GtUword) (kdb->current_size * 1.2) + kdb->initial_size;
  kdb->positions = gt_realloc((void*) kdb->positions, (size_t)
                              kdb->current_size * sizeof (*kdb->positions));
  kdb->unique_ids = gt_realloc((void*) kdb->unique_ids, (size_t)
                               kdb->current_size * sizeof (*kdb->unique_ids));
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x19ba24
movq 0x4a05ad(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37a616(%rip), %rsi    # 0x516013
leaq 0x3bbd9e(%rip), %rdx    # 0x5577a2
leaq 0x3bc77e(%rip), %rcx    # 0x558189
leaq 0x3bbd29(%rip), %r8     # 0x55773b
movl $0x9f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19ba26
movq (%rsp), %rax
movq 0x38(%rax), %xmm0
movaps 0x37cefa(%rip), %xmm1   # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x37cefe(%rip), %xmm1   # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x37d30f(%rip), %xmm1   # 0x518d68
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x37d2fc(%rip), %xmm1   # 0x518d70
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rax, %rcx
movq (%rsp), %rax
addq 0x30(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rax
movq 0x38(%rax), %rsi
shlq $0x3, %rsi
leaq 0x3bbc8d(%rip), %rdx    # 0x55773b
movl $0xa3, %ecx
callq 0xe8540
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rsp), %rax
movq 0x38(%rax), %rsi
shlq $0x3, %rsi
leaq 0x3bbc5d(%rip), %rdx    # 0x55773b
movl $0xa5, %ecx
callq 0xe8540
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: determineCtab0
static void determineCtab0(GtUword *Ctab, const GtScoreHandler *scorehandler,
                           GtUchar vseq0, const GtUchar *useq, GtUword ustart)
{
  GtUword rowindex, repl, mincost = GT_UWORD_MAX;

  if (Ctab[1] == 0)
  {
    Ctab[0] = 0;
    return;
  }
  for (rowindex = 0; rowindex < Ctab[1]; rowindex++)
  {
    repl = gt_scorehandler_get_replacement(scorehandler,
                           vseq0, useq[ustart+rowindex]);

    if (repl == 0)
    {
      Ctab[0] = rowindex;
      return;
    }
    if (repl <= mincost)
    {
      mincost = repl;
      Ctab[0] = rowindex;
    }
  }

  if (mincost > 2 * gt_scorehandler_get_gapscore(scorehandler))
  {
    Ctab[0] = (Ctab[1] > 0) ?  Ctab[1]-1 : 0;
  }
}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb %al, 0x47(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq $-0x1, 0x18(%rsp)
movq 0x50(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x19c8f4
movq 0x50(%rsp), %rax
movq $0x0, (%rax)
jmp 0x19c9e2
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x19c988
movq 0x48(%rsp), %rdi
movb 0x47(%rsp), %dl
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rcx
addq 0x28(%rsp), %rcx
movzbl %dl, %esi
movzbl (%rax,%rcx), %edx
callq 0x1d12c0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x19c950
movq 0x28(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
jmp 0x19c9e2
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x19c973
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
jmp 0x19c975
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x19c8fd
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1d11d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
shlq %rcx
cmpq %rcx, %rax
jbe 0x19c9e2
movq 0x50(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x19c9cc
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x19c9d5
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x19c9d5
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: gt_linearalign_compute_generic
GtUword gt_linearalign_compute_generic(GtLinspaceManagement *spacemanager,
                                       const GtScoreHandler *scorehandler,
                                       GtAlignment *align,
                                       const GtUchar *useq,
                                       GtUword ustart,
                                       GtUword ulen,
                                       const GtUchar *vseq,
                                       GtUword vstart,
                                       GtUword vlen)
{
  GtUword distance;
  gt_assert(spacemanager && scorehandler && align);

  gt_alignment_set_seqs(align, useq+ustart, ulen, vseq+vstart, vlen);
  distance = gt_calc_linearalign(spacemanager, scorehandler, align,
                                 useq, ustart, ulen,
                                 vseq, vstart, vlen);

  return distance;
}

// Assembly:
subq $0x58, %rsp
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x19ca39
cmpq $0x0, 0x48(%rsp)
je 0x19ca39
cmpq $0x0, 0x40(%rsp)
jne 0x19ca71
movq 0x49f560(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3795c9(%rip), %rsi    # 0x516013
leaq 0x3b0a21(%rip), %rdx    # 0x54d472
leaq 0x3bb8b7(%rip), %rcx    # 0x55830f
leaq 0x3bb895(%rip), %r8     # 0x5582f4
movl $0x1bb, %r9d            # imm = 0x1BB
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19ca73
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x60(%rsp), %rcx
addq 0x68(%rsp), %rcx
movq 0x70(%rsp), %r8
callq 0x129f60
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r11
movq 0x68(%rsp), %r10
movq 0x70(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x19bdf0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: gt_linearalign_compute
GtUword gt_linearalign_compute(GtLinspaceManagement *spacemanager,
                               GtAlignment *align,
                               const GtUchar *useq,
                               GtUword ustart,
                               GtUword ulen,
                               const GtUchar *vseq,
                               GtUword vstart,
                               GtUword vlen,
                               GtUword matchcost,
                               GtUword mismatchcost,
                               GtUword gapcost)
{
  GtUword distance;
  GtScoreHandler *scorehandler;
  gt_assert(spacemanager && align);

  scorehandler = gt_scorehandler_new(matchcost, mismatchcost, 0, gapcost);

  distance =  gt_linearalign_compute_generic(spacemanager, scorehandler, align,
                                             useq, ustart, ulen,
                                             vseq, vstart, vlen);
  gt_scorehandler_delete(scorehandler);
  return distance;
}

// Assembly:
subq $0x58, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x19cb3e
cmpq $0x0, 0x48(%rsp)
jne 0x19cb76
movq 0x49f45b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3794c4(%rip), %rsi    # 0x516013
leaq 0x3b05c2(%rip), %rdx    # 0x54d118
leaq 0x3bb7d1(%rip), %rcx    # 0x55832e
leaq 0x3bb790(%rip), %r8     # 0x5582f4
movl $0x1d5, %r9d            # imm = 0x1D5
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19cb78
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x1d0fb0
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r11
movq 0x60(%rsp), %r10
movq 0x68(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x19c9f0
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1d1150
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: evaluateallLScolumns
static GtMaxcoordvalue *evaluateallLScolumns(GtLinspaceManagement *spacemanager,
                                             const GtScoreHandler *scorehandler,
                                             const GtUchar *useq,
                                             GtUword ustart,
                                             GtUword ulen,
                                             const GtUchar *vseq,
                                             GtUword vstart,
                                             GtUword vlen)
{
  GtUword colindex;
  GtWord *Ltabcolumn;
  GtUwordPair *Starttabcolumn;
  GtMaxcoordvalue *max;

  Ltabcolumn = gt_linspace_management_get_valueTabspace(spacemanager);
  Starttabcolumn = gt_linspace_management_get_rTabspace(spacemanager);

  firstLStabcolumn(Ltabcolumn, Starttabcolumn, ulen);

  max = gt_linspace_management_get_maxspace(spacemanager);
  for (colindex = 1UL; colindex <= vlen; colindex++)
  {
    nextLStabcolumn(Ltabcolumn, Starttabcolumn, scorehandler,
                    useq, ustart, ulen, vseq[vstart+colindex-1], colindex, max);
  }
  return max;
}

// Assembly:
subq $0x68, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rdi
callq 0x1a3720
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
callq 0x1a3750
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x19e010
movq 0x60(%rsp), %rdi
callq 0x1a3800
movq %rax, 0x18(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x78(%rsp), %rax
ja 0x19d128
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %r9
movq 0x38(%rsp), %rax
movq 0x70(%rsp), %r10
addq 0x30(%rsp), %r10
subq $0x1, %r10
movb (%rax,%r10), %r11b
movq 0x30(%rsp), %r10
movq 0x18(%rsp), %rax
movzbl %r11b, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x19e0e0
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x19d0b6
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: gt_linearalign_compute_local
GtWord gt_linearalign_compute_local(GtLinspaceManagement *spacemanager,
                                    GtAlignment *align,
                                    const GtUchar *useq,
                                    GtUword ustart,
                                    GtUword ulen,
                                    const GtUchar *vseq,
                                    GtUword vstart,
                                    GtUword vlen,
                                    GtWord matchscore,
                                    GtWord mismatchscore,
                                    GtWord gapscore)
{
  GtWord score;
  gt_assert(align && spacemanager);
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchscore,
                                                     mismatchscore,
                                                     0, gapscore);

  score = gt_linearalign_compute_local_generic(spacemanager, scorehandler,
                                               align, useq, ustart, ulen,
                                               vseq, vstart, vlen);
  gt_scorehandler_delete(scorehandler);
  return score;
}

// Assembly:
subq $0x58, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x19d18e
cmpq $0x0, 0x50(%rsp)
jne 0x19d1c6
movq 0x49ee0b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x378e74(%rip), %rsi    # 0x516013
leaq 0x3bb1c4(%rip), %rdx    # 0x55836a
leaq 0x3bb1d3(%rip), %rcx    # 0x558380
leaq 0x3bb140(%rip), %r8     # 0x5582f4
movl $0x2da, %r9d            # imm = 0x2DA
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19d1c8
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x1d0fb0
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r11
movq 0x60(%rsp), %r10
movq 0x68(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x19cc00
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1d1150
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: gt_calc_linearedist
static GtUword gt_calc_linearedist(bool downcase,
                                   const GtUchar *useq, GtUword ulen,
                                   const GtUchar *vseq, GtUword vlen)
{
  GtUword *dpcolumn, edist;

  printf("%s(%*.*s,%*.*s)\n",__func__,(int) ulen,(int) ulen,(char *) useq,
                             (int) vlen,(int) vlen,(char *) vseq);
  dpcolumn = gt_malloc(sizeof *dpcolumn * (GT_MIN(ulen,vlen) + 1));
  fillDPtable_unitcost(downcase,dpcolumn,
                       ulen <= vlen ? useq : vseq, GT_MIN(ulen,vlen),
                       ulen <= vlen ? vseq : useq, GT_MAX(ulen,vlen));
  edist = dpcolumn[GT_MIN(ulen,vlen)];
  gt_free(dpcolumn);
  return edist;
}

// Assembly:
subq $0xa8, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0x90(%rsp), %rax
movl %eax, %edx
movq 0x90(%rsp), %rax
movl %eax, %ecx
movq 0x98(%rsp), %r8
movq 0x80(%rsp), %rax
movl %eax, %r9d
movq 0x80(%rsp), %rax
movl %eax, %r10d
movq 0x88(%rsp), %rax
leaq 0x3bb089(%rip), %rdi    # 0x55862d
leaq 0x3bb093(%rip), %rsi    # 0x55863e
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x19070
movq 0x90(%rsp), %rax
cmpq 0x80(%rsp), %rax
jae 0x19d5dc
movq 0x90(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x19d5e9
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
leaq 0x3bacf7(%rip), %rsi    # 0x5582f4
movl $0x209, %edx            # imm = 0x209
callq 0xe80f0
movq %rax, 0x78(%rsp)
movb 0xa7(%rsp), %al
movb %al, 0x5f(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x90(%rsp), %rax
cmpq 0x80(%rsp), %rax
ja 0x19d642
movq 0x98(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x19d64f
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rax
cmpq 0x80(%rsp), %rax
jae 0x19d67a
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x19d687
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rax
cmpq 0x80(%rsp), %rax
ja 0x19d6b2
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x19d6bf
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x90(%rsp), %rax
cmpq 0x80(%rsp), %rax
jbe 0x19d6ea
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x19d6f7
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %r8
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq 0x60(%rsp), %rsi
movb 0x5f(%rsp), %al
movq 0x20(%rsp), %r9
movzbl %al, %edi
andl $0x1, %edi
callq 0x19e450
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x90(%rsp), %rax
cmpq 0x80(%rsp), %rax
jae 0x19d74a
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x19d757
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
leaq 0x3bab7e(%rip), %rsi    # 0x5582f4
movl $0x20e, %edx            # imm = 0x20E
callq 0xe88c0
movq 0x70(%rsp), %rax
addq $0xa8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: evaluateallEDtabRtabcolumns
static GtUword evaluateallEDtabRtabcolumns(GtUword *EDtabcolumn,
                                           GtUword *Rtabcolumn,
                                           const GtScoreHandler *scorehandler,
                                           GtUword midcol,
                                           const GtUchar *useq,
                                           GtUword ustart,
                                           GtUword ulen,
                                           const GtUchar *vseq,
                                           GtUword vstart,
                                           GtUword vlen)
{
  GtUword gapcost, colindex;
  gt_assert(scorehandler && EDtabcolumn && Rtabcolumn);

  gapcost = gt_scorehandler_get_gapscore(scorehandler);
  firstEDtabRtabcolumn(EDtabcolumn, Rtabcolumn, ulen, gapcost);

  for (colindex = 1UL; colindex <= vlen; colindex++)
  {
    nextEDtabRtabcolumn(EDtabcolumn, Rtabcolumn, colindex, midcol,
                        vseq[vstart+colindex-1], useq, ustart,
                        ulen, scorehandler);
  }
  return EDtabcolumn[ulen];
}

// Assembly:
subq $0x58, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x19dabe
cmpq $0x0, 0x50(%rsp)
je 0x19dabe
cmpq $0x0, 0x48(%rsp)
jne 0x19daf6
movq 0x49e4db(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x378544(%rip), %rsi    # 0x516013
leaq 0x3baaa3(%rip), %rdx    # 0x558579
leaq 0x3baac6(%rip), %rcx    # 0x5585a3
leaq 0x3ba810(%rip), %r8     # 0x5582f4
movl $0x81, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19daf8
movq 0x40(%rsp), %rdi
callq 0x1d11d0
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x19dd20
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x78(%rsp), %rax
ja 0x19db9b
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %r8
addq 0x18(%rsp), %r8
subq $0x1, %r8
movb (%rax,%r8), %r8b
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r11
movq 0x60(%rsp), %r10
movq 0x40(%rsp), %rax
movzbl %r8b, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x19ddb0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x19db29
movq 0x50(%rsp), %rax
movq 0x60(%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: set_LinearCrosspointthreadinfo
static GtLinearCrosspointthreadinfo
            set_LinearCrosspointthreadinfo(GtLinspaceManagement *spacemanager,
                                           const GtScoreHandler *scorehandler,
                                           const GtUchar *useq,
                                           GtUword ustart,
                                           GtUword ulen,
                                           const GtUchar *vseq,
                                           GtUword vstart,
                                           GtUword vlen,
                                           GtUword *Ctab,
                                           GtUword rowoffset,
                                           GtUword threadidx,
                                           GtUword *threadcount)
{
  GtLinearCrosspointthreadinfo threadinfo;
  threadinfo.spacemanager = spacemanager;
  threadinfo.scorehandler = scorehandler;
  threadinfo.useq = useq;
  threadinfo.ustart = ustart;
  threadinfo.ulen = ulen;
  threadinfo.vseq = vseq;
  threadinfo.vstart = vstart;
  threadinfo.vlen = vlen;
  threadinfo.Ctab = Ctab;
  threadinfo.rowoffset = rowoffset;
  threadinfo.threadidx = threadidx;
  threadinfo.threadcount = threadcount;

  return threadinfo;
}

// Assembly:
movq %rdi, %rax
movq 0x38(%rsp), %r10
movq 0x30(%rsp), %r10
movq 0x28(%rsp), %r10
movq 0x20(%rsp), %r10
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r10
movq 0x8(%rsp), %r10
movq %rsi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq %r9, -0x28(%rsp)
movq -0x8(%rsp), %rcx
movq %rcx, (%rdi)
movq -0x10(%rsp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x18(%rsp), %rcx
movq %rcx, 0x10(%rdi)
movq -0x20(%rsp), %rcx
movq %rcx, 0x20(%rdi)
movq -0x28(%rsp), %rcx
movq %rcx, 0x28(%rdi)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rdi)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rdi)
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rdi)
movq 0x20(%rsp), %rcx
movq %rcx, 0x40(%rdi)
movq 0x28(%rsp), %rcx
movq %rcx, 0x48(%rdi)
movq 0x30(%rsp), %rcx
movq %rcx, 0x50(%rdi)
movq 0x38(%rsp), %rcx
movq %rcx, 0x58(%rdi)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: evaluatelinearcrosspoints_thread_caller
static void *evaluatelinearcrosspoints_thread_caller(void *data)
{
  GtLinearCrosspointthreadinfo *threadinfo =
                                         (GtLinearCrosspointthreadinfo *) data;
  (void) evaluatelinearcrosspoints(threadinfo->spacemanager,
                                   threadinfo->scorehandler,
                                   threadinfo->useq,
                                   threadinfo->ustart,
                                   threadinfo-> ulen,
                                   threadinfo->vseq,
                                   threadinfo->vstart,
                                   threadinfo->vlen,
                                   threadinfo->Ctab,
                                   threadinfo->rowoffset,
                                   threadinfo->threadidx,
                                   threadinfo->threadcount);
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x28(%rax), %r8
movq 0x30(%rsp), %rax
movq 0x18(%rax), %r9
movq 0x30(%rsp), %rax
movq 0x30(%rax), %r15
movq 0x30(%rsp), %rax
movq 0x38(%rax), %r14
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rbx
movq 0x30(%rsp), %rax
movq 0x48(%rax), %r11
movq 0x30(%rsp), %rax
movq 0x50(%rax), %r10
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x19c1b0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: firstEDtabRtabcolumn
static void firstEDtabRtabcolumn(GtUword *EDtabcolumn,
                                 GtUword *Rtabcolumn,
                                 GtUword ulen,
                                 GtUword gapcost)
{
  GtUword rowindex;
  EDtabcolumn[0] = 0;
  Rtabcolumn[0]  = 0;

  for (rowindex=1; rowindex <= ulen; rowindex++)
  {
    EDtabcolumn[rowindex] = EDtabcolumn[rowindex-1]+ gapcost;
    Rtabcolumn[rowindex]  = rowindex;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movq $0x1, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x18(%rsp), %rax
ja 0x19dda9
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
addq -0x20(%rsp), %rdx
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rsp), %rdx
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x19dd55
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign.c
// Function: firstLStabcolumn
static void firstLStabcolumn(GtWord *Ltabcolumn,
                             GtUwordPair *Starttabcolumn,
                             GtUword ulen)
{
  GtUword rowindex;

  gt_assert(Ltabcolumn != NULL && Starttabcolumn != NULL);
  for (rowindex = 0; rowindex <= ulen; rowindex++)
  {
    Ltabcolumn[rowindex] = 0;
    Starttabcolumn[rowindex].a = rowindex;
    Starttabcolumn[rowindex].b = 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x19e033
cmpq $0x0, 0x18(%rsp)
jne 0x19e06b
movq 0x49df66(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x377fcf(%rip), %rsi    # 0x516013
leaq 0x3ba588(%rip), %rdx    # 0x5585d3
leaq 0x3ba5ae(%rip), %rcx    # 0x558600
leaq 0x3ba29b(%rip), %r8     # 0x5582f4
movl $0x21a, %r9d            # imm = 0x21A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19e06d
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x19e0d6
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x19e076
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_set_edge
GtAffineAlignEdge gt_linearalign_affinegapcost_set_edge(GtWord Rdist,
                                                        GtWord Ddist,
                                                        GtWord Idist)
{
  GtUword minvalue = GT_MIN3(Rdist, Ddist, Idist);

  if (Rdist == minvalue)
    return Affine_R;
  else if (Ddist == minvalue)
    return Affine_D;
  else if (Idist == minvalue)
    return Affine_I;

  return Affine_X;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
jge 0x19e6c9
movq -0x10(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x19e6b3
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
jmp 0x19e6bd
movq -0x20(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
jmp 0x19e6f5
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jge 0x19e6e1
movq -0x18(%rsp), %rax
movq %rax, -0x40(%rsp)
jmp 0x19e6eb
movq -0x20(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x28(%rsp), %rax
jne 0x19e715
movl $0x0, -0x4(%rsp)
jmp 0x19e74d
movq -0x18(%rsp), %rax
cmpq -0x28(%rsp), %rax
jne 0x19e72b
movl $0x1, -0x4(%rsp)
jmp 0x19e74d
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jne 0x19e741
movl $0x2, -0x4(%rsp)
jmp 0x19e74d
jmp 0x19e743
jmp 0x19e745
movl $0x3, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_minAdditionalCosts
GtAffineAlignEdge gt_linearalign_affinegapcost_minAdditionalCosts(
                                              const GtAffinealignDPentry *entry,
                                              const GtAffineAlignEdge edge,
                                              GtUword gap_opening)
{
  GtUword rdist, ddist, idist;

  switch (edge) {
    case Affine_D:
      rdist = add_safe_max(entry->Rvalue, gap_opening);
      ddist = entry->Dvalue;
      idist = add_safe_max(entry->Ivalue, gap_opening);
     break;
    case Affine_I:
      rdist = add_safe_max(entry->Rvalue, gap_opening);
      ddist = add_safe_max(entry->Dvalue, gap_opening);
      idist = entry->Ivalue;
      break;
    default:
      rdist = entry->Rvalue;
      ddist = entry->Dvalue;
      idist = entry->Ivalue;
  }

  return gt_linearalign_affinegapcost_set_edge(rdist, ddist, idist);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x24(%rsp)
subl $0x1, %eax
je 0x19e793
jmp 0x19e781
movl 0x24(%rsp), %eax
subl $0x2, %eax
je 0x19e82e
jmp 0x19e8c3
movq 0x50(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, (%rax)
je 0x19e7bb
movq 0x50(%rsp), %rax
movq (%rax), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x19e7cc
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x18(%rsp)
jmp 0x19e7cc
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
je 0x19e80e
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x19e81f
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x10(%rsp)
jmp 0x19e81f
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x19e8ec
movq 0x50(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, (%rax)
je 0x19e856
movq 0x50(%rsp), %rax
movq (%rax), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x19e867
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x8(%rsp)
jmp 0x19e867
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x8(%rax)
je 0x19e89a
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
addq 0x40(%rsp), %rax
movq %rax, (%rsp)
jmp 0x19e8aa
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, (%rsp)
jmp 0x19e8aa
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x19e8ec
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x19e680
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: affine_determineCtab0
static void affine_determineCtab0(GtUword *Ctab,
                                  GtLinspaceManagement *spacemanager,
                                  const GtScoreHandler *scorehandler,
                                  const GtUchar *useq,
                                  GtUword ustart,
                                  const GtUchar *vseq,
                                  GtUword vstart)
{
  GtAffinealignDPentry *Atabcolumn;

    if (Ctab[1]== 1 || Ctab[1] == 0)
      Ctab[0] = 0;
    else
    {
      gt_linspace_management_check(spacemanager,2*(Ctab[1]+1),Ctab[1],
                                   sizeof (*Atabcolumn),sizeof (Atabcolumn),0);
      /*gt_assert(vlen > 1);*/
      GtAffineAlignEdge to_edge_test = Affine_X;
      if (Ctab[1] == Ctab[2])
        to_edge_test = Affine_I;
      else
        to_edge_test = Affine_R;
      gt_affinealign_ctab(spacemanager, scorehandler, Ctab,
                          useq, ustart, Ctab[1], vseq, vstart,
                          1, 0, Affine_X, to_edge_test);
    }
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq 0x80(%rsp), %rax
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movq 0x68(%rsp), %rax
cmpq $0x1, 0x8(%rax)
je 0x19f9b3
movq 0x68(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x19f9c4
movq 0x68(%rsp), %rax
movq $0x0, (%rax)
jmp 0x19fa86
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rsi
addq $0x1, %rsi
shlq %rsi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdx
movl $0x30, %ecx
movl $0x8, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x1a3160
movl $0x3, 0x34(%rsp)
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x19fa1d
movl $0x2, 0x34(%rsp)
jmp 0x19fa25
movl $0x0, 0x34(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x68(%rsp), %rax
movq 0x8(%rax), %r9
movq 0x40(%rsp), %r11
movq 0x80(%rsp), %r10
movl 0x34(%rsp), %eax
xorl %ebx, %ebx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x3, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x4852f0
addq $0x70, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute_generic
GtUword gt_linearalign_affinegapcost_compute_generic(
                                            GtLinspaceManagement *spacemanager,
                                            const GtScoreHandler *scorehandler,
                                            GtAlignment *align,
                                            const GtUchar *useq,
                                            GtUword ustart,
                                            GtUword ulen,
                                            const GtUchar *vseq,
                                            GtUword vstart,
                                            GtUword vlen)
{
  GtUword distance;
  gt_assert(spacemanager && scorehandler && align);

  gt_alignment_set_seqs(align,useq+ustart, ulen, vseq+vstart, vlen);
  distance = gt_calc_affinealign_linear(spacemanager, scorehandler, align,
                                        useq, ustart, ulen,
                                        vseq, vstart, vlen);
  return distance;
}

// Assembly:
subq $0x58, %rsp
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x19fad9
cmpq $0x0, 0x48(%rsp)
je 0x19fad9
cmpq $0x0, 0x40(%rsp)
jne 0x19fb11
movq 0x49c4c0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x376529(%rip), %rsi    # 0x516013
leaq 0x3ad981(%rip), %rdx    # 0x54d472
leaq 0x3b8b7c(%rip), %rcx    # 0x558674
leaq 0x3b8ba2(%rip), %r8     # 0x5586a1
movl $0x2bf, %r9d            # imm = 0x2BF
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x19fb13
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x60(%rsp), %rcx
addq 0x68(%rsp), %rcx
movq 0x70(%rsp), %r8
callq 0x129f60
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r11
movq 0x68(%rsp), %r10
movq 0x70(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x19e910
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute
GtUword gt_linearalign_affinegapcost_compute(GtLinspaceManagement *spacemanager,
                                             GtAlignment *align,
                                             const GtUchar *useq,
                                             GtUword ustart,
                                             GtUword ulen,
                                             const GtUchar *vseq,
                                             GtUword vstart,
                                             GtUword vlen,
                                             GtUword matchcost,
                                             GtUword mismatchcost,
                                             GtUword gap_opening,
                                             GtUword gap_extension)
{
  GtUword distance;
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchcost,
                                                     mismatchcost,
                                                     gap_opening,
                                                     gap_extension);

  gt_alignment_set_seqs(align,useq+ustart, ulen, vseq+vstart, vlen);
  distance = gt_linearalign_affinegapcost_compute_generic(spacemanager,
                                                          scorehandler, align,
                                                          useq, ustart, ulen,
                                                          vseq, vstart, vlen);
  gt_scorehandler_delete(scorehandler);
  return distance;
}

// Assembly:
subq $0x58, %rsp
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rcx
callq 0x1d0fb0
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
addq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r8
callq 0x129f60
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r11
movq 0x60(%rsp), %r10
movq 0x68(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x19fa90
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1d1150
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)