LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_compare
int gt_kmer_database_compare(GtKmerDatabase *a, GtKmerDatabase *b, GtError *err)
{
  int had_err = 0;
  GtUword i;

  gt_error_check(err);

  if (a->nu_kmer_codes != b->nu_kmer_codes) {
    gt_error_set(err, "Kmer Dtaatabases not identical. Alphabet sizes are"
                 ": " GT_WU " and " GT_WU, a->nu_kmer_codes, b->nu_kmer_codes);
    had_err = -1;
  }

  if (!had_err && a->offset[a->nu_kmer_codes] !=
      b->offset[b->nu_kmer_codes]) {
    gt_error_set(err, "Kmer Databases not identical. Number of inserted kmers: "
                 GT_WU " and " GT_WU,
                 a->offset[a->nu_kmer_codes], b->offset[b->nu_kmer_codes]);
    had_err = -1;
  }

  for (i = 0; !had_err && i <= a->nu_kmer_codes; i++) {
    if (!had_err && a->offset[i] != b->offset[i]) {
      gt_error_set(err, "Kmer Databases not identical. Offset at " GT_WU
                   " are: " GT_WU " and " GT_WU, i, a->offset[i], b->offset[i]);
      had_err = -1;
    }
  }
  for (i = 0; !had_err && i < a->offset[a->nu_kmer_codes]; i++) {
    if (!had_err && a->positions[i] != b->positions[i]) {
      gt_error_set(err, "Kmer Databases not identical. Positions at " GT_WU
                   " are: "GT_WU " and " GT_WU, i, a->positions[i],
                   b->positions[i]);
      had_err = -1;
    }
    if (!had_err && a->unique_ids[i] != b->unique_ids[i]) {
      gt_error_set(err, "Kmer Databases not identical. Ids at " GT_WU
                   " are: "GT_WU " and " GT_WU,
                   i, a->unique_ids[i], b->unique_ids[i]);
      had_err = -1;
    }
  }

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x157d1a
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x157df7
movq 0x28(%r15), %rdx
movq 0x28(%r14), %rcx
cmpq %rcx, %rdx
jne 0x157da3
movq (%r15), %rax
movq (%rax,%rdx,8), %rax
movq (%r14), %rcx
movq (%rcx,%rdx,8), %rcx
cmpq %rcx, %rax
jne 0x157daf
movq (%r15), %rax
movq 0x28(%r15), %rsi
movq (%r14), %rdi
xorl %edx, %edx
movq (%rax,%rdx,8), %rcx
movq (%rdi,%rdx,8), %r8
cmpq %r8, %rcx
jne 0x157dce
incq %rdx
cmpq %rsi, %rdx
jbe 0x157d46
movq (%r15), %rax
movq 0x28(%r15), %rcx
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
je 0x157de1
movq 0x10(%r15), %rdi
movq 0x10(%r14), %r9
xorl %edx, %edx
movq (%rdi,%rdx,8), %rcx
movq (%r9,%rdx,8), %r8
cmpq %r8, %rcx
jne 0x157de5
movq 0x18(%r15), %rax
movq (%rax,%rdx,8), %rcx
movq 0x18(%r14), %rax
movq (%rax,%rdx,8), %r8
cmpq %r8, %rcx
jne 0x157dee
incq %rdx
xorl %eax, %eax
cmpq %rsi, %rdx
jb 0x157d75
jmp 0x157dc8
leaq 0x22d679(%rip), %rsi    # 0x385423
movq %rbx, %rdi
jmp 0x157dbc
leaq 0x22d6ad(%rip), %rsi    # 0x385463
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
leaq 0x22d6d2(%rip), %rsi    # 0x3854a7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
jmp 0x157dc3
xorl %eax, %eax
jmp 0x157dc8
leaq 0x22d6f8(%rip), %rsi    # 0x3854e4
jmp 0x157dd5
leaq 0x22d72f(%rip), %rsi    # 0x385524
jmp 0x157dd5
callq 0x4a5df
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/kmer_database.c
// Function: gt_kmer_database_check_consistency
int gt_kmer_database_check_consistency(GtKmerDatabase *kdb, GtError *err)
{
  int had_err = 0;
  GtUword i,
          j,
          end,
          start = (GtUword) 0;

  gt_error_check(err);

  for (i = 0; !had_err && i < kdb->nu_kmer_codes; i++) {
    end = kdb->offset[i + 1];
    if (start > end) {
      gt_error_set(err, "Kmer Database is inconsistent in offset at kmer: "
          GT_WU ", start: " GT_WU ", end: " GT_WU, i, start, end);
      had_err = - 1;
    }
    for (j = start + 1; !had_err && j < end; j++) {
      if (kdb->positions[j - 1] >= kdb->positions[j]) {
        gt_error_set(err, "Kmer Database is inconsistent in positions at "
            "kmer: " GT_WU ", last startposition: " GT_WU
            ", current startposition " GT_WU, i, kdb->positions[j - 1],
            kdb->positions[j]);
        had_err = -1;
      }
      if (kdb->unique_ids[j - 1] > kdb->unique_ids[j]) {
        gt_error_set(err, "Kmer Database is inconsistent in unique_ids at "
            "kmer: " GT_WU ", last startposition: " GT_WU ", current "
            "startposition " GT_WU,
            i, kdb->unique_ids[j - 1], kdb->unique_ids[j]);
        had_err = -1;
      }
    }
    start = end;
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movq %rdi, %r14
testq %rsi, %rsi
movq %rsi, 0x8(%rsp)
je 0x157e2f
movq %rdx, %rdi
callq 0xfcc32
movq 0x8(%rsp), %rdx
testb %al, %al
jne 0x157f19
xorl %r15d, %r15d
xorl %esi, %esi
cmpq 0x28(%r14), %rsi
jae 0x157f00
movq %rsi, %r12
movq %r15, %r13
movq (%r14), %rax
incq %rsi
movq 0x8(%rax,%r12,8), %r15
cmpq %r15, %r13
ja 0x157f04
seta %al
leaq 0x1(%r13), %rcx
cmpq %r15, %rcx
setae %cl
orb %al, %cl
jne 0x157e34
movq %rsi, 0x10(%rsp)
addq $0x2, %r13
movq 0x10(%r14), %rax
movq -0x10(%rax,%r13,8), %rbp
movq -0x8(%rax,%r13,8), %rbx
cmpq %rbx, %rbp
jb 0x157ea4
movq %rdx, %rdi
leaq 0x22d73d(%rip), %rsi    # 0x3855cc
movq %r12, %rdx
movq %rbp, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0xfcb67
movq 0x8(%rsp), %rdx
movq 0x18(%r14), %rax
movq -0x10(%rax,%r13,8), %rcx
movq -0x8(%rax,%r13,8), %r8
cmpq %r8, %rcx
ja 0x157ed8
cmpq %rbx, %rbp
jae 0x157ec8
leaq 0x1(%r13), %rax
cmpq %r15, %r13
movq %rax, %r13
jb 0x157e72
cmpq %rbx, %rbp
movq 0x10(%rsp), %rsi
jb 0x157e34
jmp 0x157eec
leaq 0x22d759(%rip), %rsi    # 0x385638
movq %rdx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x157ef1
leaq 0x22d676(%rip), %rsi    # 0x385581
movq %rdx, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
jmp 0x157ee5
callq 0x4a618
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x157f3b
movq 0x28(%rdi), %rax
movq 0x38(%rdi), %rcx
shlq $0x4, %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $0xf, %rax
retq
pushq %rax
callq 0x4a651
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x157f5e
movq (%rdi), %rax
movq 0x28(%rdi), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x4, %rcx
leaq (%rcx,%rax,8), %rax
addq $0xf, %rax
retq
pushq %rax
callq 0x4a68a
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1581df
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1581df
movq %rdi, %r14
movq %rbx, %rdi
callq 0x103eac
testb %al, %al
je 0x158160
cmpb $0x0, 0xd4(%r14)
je 0x15816a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, 0xb0(%r14)
je 0x1581bb
leaq 0x22d660(%rip), %r15    # 0x3857db
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0xa0(%r14), %rax
movq (%rax,%r12), %rdx
movl %edx, %ecx
shrq $0x20, %rdx
addq 0xc0(%r14), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x103fe1
incq %r13
movq 0xb0(%r14), %rdx
addq $0x10, %r12
cmpq %rdx, %r13
jb 0x158181
jmp 0x1581bd
xorl %edx, %edx
movb $0x1, 0xd4(%r14)
leaq 0x22d628(%rip), %rsi    # 0x3857f4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x103fe1
callq 0x4a6fc
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1592e6
movq %rsi, %r13
testq %rsi, %rsi
je 0x1592e6
movq %rdx, %r12
testq %rdx, %rdx
je 0x1592e6
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbp
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %rcx
leaq (%r15,%r14), %rsi
addq 0x40(%rsp), %rcx
movq %r12, %rdi
movq %r9, %rdx
callq 0x120e01
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1589a8
callq 0x4a819
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
testq %rdi, %rdi
je 0x159374
movq %rsi, %r13
testq %rsi, %rsi
je 0x159374
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbp
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0x17137c
movq %rax, %rbx
subq $0x8, %rsp
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x18(%rsp)
callq 0x159277
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x1713ff
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4a852
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
testq %rdi, %rdi
je 0x159842
movq %rsi, %r13
testq %rsi, %rsi
je 0x159842
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbp
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0x17137c
movq %rax, %rbx
subq $0x8, %rsp
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq 0x18(%rsp)
callq 0x159379
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x1713ff
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4a936
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x38, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %r8
movq 0x18(%rdi), %r9
movups 0x30(%rdi), %xmm0
movups 0x40(%rdi), %xmm1
movups 0x50(%rdi), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0x158c4e
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq %rsi, %rdi
movq %rsi, %rcx
cmovlq %rdi, %rcx
cmpq %rdx, %rcx
movq %rdx, %r8
cmovlq %rcx, %r8
xorl %eax, %eax
cmpq %rdi, %r8
je 0x159dd4
movl $0x1, %eax
cmpq %rsi, %r8
je 0x159dd4
xorl %eax, %eax
cmpq %rdx, %rcx
setl %al
orl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rcx
cmpl $0x2, %esi
je 0x159e0b
cmpl $0x1, %esi
jne 0x159e3a
leaq (%rcx,%rdx), %rax
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
cmpq %r8, %rcx
cmovneq %rax, %rcx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rax
addq %rax, %rdx
cmpq %r8, %rax
cmoveq %rax, %rdx
jmp 0x159e42
leaq (%rcx,%rdx), %rax
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rsi, %rcx
cmovneq %rax, %rcx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
addq %rax, %rdx
cmpq %rsi, %rax
cmoveq %rax, %rdx
movq %rdx, %rsi
movq %rdi, %rdx
jmp 0x159e42
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
cmpq %rsi, %rcx
movq %rsi, %rdi
cmovlq %rcx, %rdi
cmpq %rdx, %rdi
movq %rdx, %r8
cmovlq %rdi, %r8
xorl %eax, %eax
cmpq %rcx, %r8
je 0x159e72
movl $0x1, %eax
cmpq %rsi, %r8
je 0x159e72
xorl %eax, %eax
cmpq %rdx, %rdi
setl %al
orl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15aea6
movq %rsi, %r13
testq %rsi, %rsi
je 0x15aea6
movq %rdx, %r12
testq %rdx, %rdx
je 0x15aea6
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbp
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %rcx
leaq (%r15,%r14), %rsi
addq 0x40(%rsp), %rcx
movq %r12, %rdi
movq %r9, %rdx
callq 0x120e01
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x159e73
callq 0x4ac10
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, (%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0x17137c
movq %rax, %r13
leaq (%r12,%r15), %rsi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax), %rcx
movq %rbp, %rdi
movq %r14, %rdx
movq 0x48(%rsp), %r8
callq 0x120e01
subq $0x8, %rsp
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq %rbx
callq 0x15ae37
addq $0x20, %rsp
movq %rax, %rbx
movq %r13, %rdi
callq 0x1713ff
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute_local
GtWord gt_linearalign_affinegapcost_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 gap_opening,
                                             GtWord gap_extension)
{
  GtWord score;

  GtScoreHandler *scorehandler = gt_scorehandler_new(matchscore,
                                                     mismatchscore,
                                                     gap_opening,
                                                     gap_extension);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rcx
callq 0x17137c
movq %rax, %r14
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq %rbx, (%rsp)
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x20(%rsp), %r9
callq 0x15af49
movq %rax, %rbx
movq %r14, %rdi
callq 0x1713ff
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_delete
void gt_linspace_management_delete(GtLinspaceManagement *spacemanager)
{
  if (spacemanager != NULL)
  {
    gt_free(spacemanager->valueTabspace);
    gt_free(spacemanager->rTabspace);
    if (spacemanager->crosspointTabspace != NULL)
      gt_free(spacemanager->crosspointTabspace);
    gt_maxcoordvalue_delete(spacemanager->maxscoordvaluespace);
    gt_free(spacemanager);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x15bc2d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x22a573(%rip), %r14    # 0x386144
movq %r14, %rsi
movl $0x3a, %edx
callq 0x1045eb
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x3b, %edx
callq 0x1045eb
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x15bc09
leaq 0x22a545(%rip), %rsi    # 0x386144
movl $0x3d, %edx
callq 0x1045eb
movq 0x48(%rbx), %rdi
callq 0x1605c0
leaq 0x22a52b(%rip), %rsi    # 0x386144
movq %rbx, %rdi
movl $0x3f, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/linspace_management.c
// Function: checksquare
static bool checksquare(GtLinspaceManagement *spacemanager,
                        GtUword ulen, GtUword vlen,
                        size_t valuesize, size_t rsize,
                        bool local)
{
  GtUword TSfactor;
  gt_assert(spacemanager);

  TSfactor = spacemanager->timesquarefactor;
  if ((ulen+1)*(vlen+1)*valuesize <= spacemanager->valueTabsize)
  {
    if (local)
      gt_maxcoordvalue_reset(spacemanager->maxscoordvaluespace);
    return true;
  }
  else if ((ulen+1)*(vlen+1) <= (spacemanager->ulen+1)*TSfactor)
  {
    if (!local)
    {
      gt_linspace_management_check_generic(spacemanager,(ulen+1)*(vlen+1)-1,
                                           vlen,valuesize,rsize,0,false);
    }
    else
    {
       gt_linspace_management_check_generic(spacemanager,(ulen+1)*(vlen+1)-1,
                                            vlen,valuesize,rsize,0,true);
    }
    return true;
  }
  return false;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x15be08
movq %rsi, %rax
incq %rax
leaq 0x1(%rdx), %rsi
imulq %rax, %rsi
movq %rsi, %rax
imulq %rcx, %rax
cmpq 0x28(%rdi), %rax
jbe 0x15bdcc
movq 0x18(%rdi), %rax
incq %rax
imulq 0x20(%rdi), %rax
cmpq %rax, %rsi
jbe 0x15bdde
xorl %ebx, %ebx
jmp 0x15be00
movb $0x1, %bl
testb %r9b, %r9b
je 0x15be00
movq 0x48(%rdi), %rdi
callq 0x1606e6
jmp 0x15be00
decq %rsi
testb %r9b, %r9b
je 0x15bdef
movl $0x1, (%rsp)
jmp 0x15bdf6
movl $0x0, (%rsp)
xorl %r9d, %r9d
callq 0x15bc60
movb $0x1, %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x4ae8c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_change_to_square
GtUword **gt_linspace_management_change_to_square(GtLinspaceManagement
                                                 *spacemanager,
                                                 GtUword ulen, GtUword vlen)
{
  GtUword **E;
  GtUword idx;
  gt_assert(gt_linspace_management_check_space(spacemanager, ulen, vlen));

  E = gt_linspace_management_get_rTabspace(spacemanager);
  *E = gt_linspace_management_get_valueTabspace(spacemanager);

  for (idx=1;idx<ulen+1;idx++)
    E[idx]=E[idx-1]+vlen+1;

  return E;
}

// Assembly:
pushq %rax
leaq 0x1(%rdx), %rax
leaq 0x8(,%rsi,8), %rcx
imulq %rax, %rcx
cmpq 0x28(%rdi), %rcx
ja 0x15beb8
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rcx, (%rax)
leaq -0x1(%rsi), %rcx
cmpq $-0x3, %rcx
ja 0x15beb6
leaq 0x8(,%rdx,8), %rcx
movq (%rax), %rdx
addq %rcx, %rdx
xorl %edi, %edi
movq %rdx, 0x8(%rax,%rdi,8)
addq %rcx, %rdx
incq %rdi
cmpq %rdi, %rsi
jne 0x15bea6
popq %rcx
retq
callq 0x4af37
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_class
const GtNodeStreamClass* gt_load_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtLoadStream),
                                   gt_load_stream_free,
                                   gt_load_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x3628aa(%rip)    # 0x4be788
jne 0x15beff
leaq 0x26(%rip), %rsi        # 0x15bf0d
leaq 0x81(%rip), %rdx        # 0x15bf6f
movl $0x30, %edi
callq 0x162d34
movq %rax, 0x362889(%rip)    # 0x4be788
callq 0xe2545
movq 0x36287d(%rip), %rax    # 0x4be788
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_free
static void gt_load_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtLoadStream *load_stream = gt_load_stream_cast(ns);
  for (i = load_stream->idx; i < gt_array_size(load_stream->nodes); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                          gt_array_get(load_stream->nodes, i));
  }
  gt_array_delete(load_stream->nodes);
  gt_node_stream_delete(load_stream->in_stream);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x15bed0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x18(%rax), %r14
movq 0x20(%rax), %rdi
callq 0xd24e0
cmpq %rax, %r14
jae 0x15bf56
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x1451a0
incq %r14
movq 0x20(%rbx), %rdi
jmp 0x15bf2f
movq 0x20(%rbx), %rdi
callq 0xd2938
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x162dee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_next
static int gt_load_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                               GtError *err)
{
  GtLoadStream *load_stream;
  GtEOFNode *eofn;
  GtGenomeNode *node;
  int had_err = 0;
  gt_error_check(err);
  load_stream = gt_load_stream_cast(ns);

  if (!load_stream->full) {
    while (!(had_err = gt_node_stream_next(load_stream->in_stream, &node,
                                           err)) && node) {
      if ((eofn = gt_eof_node_try_cast(node)))
        gt_genome_node_delete(node); /* get rid of EOF nodes */
      else
        gt_array_add(load_stream->nodes, node);
    }
    if (!had_err) {
      load_stream->full = true;
    }
  }

  if (!had_err) {
    gt_assert(load_stream->full);
    if (load_stream->idx < gt_array_size(load_stream->nodes)) {
      *gn = *(GtGenomeNode**) gt_array_get(load_stream->nodes,
                                           load_stream->idx);
      load_stream->idx++;
      return 0;
    }
  }

  if (!had_err) {
    gt_array_reset(load_stream->nodes);
    *gn = NULL;
  }

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x15bf95
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x15c073
callq 0x15bed0
movq %rax, %rdi
movq %r14, %rsi
callq 0x162ff7
movq %rax, %r14
cmpb $0x0, 0x28(%rax)
je 0x15bfb5
jne 0x15c02e
callq 0x4afe0
movq 0x10(%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
movq %r15, %rdx
callq 0x162e68
testl %eax, %eax
sete %cl
movq (%r12), %rdi
testq %rdi, %rdi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x15c025
movq %rsp, %r12
callq 0x2fda49
testq %rax, %rax
je 0x15bff5
movq (%rsp), %rdi
callq 0x1451a0
jmp 0x15c006
movq 0x20(%r14), %rdi
movl $0x8, %edx
movq %r12, %rsi
callq 0xd2410
movq 0x10(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x162e68
testl %eax, %eax
sete %cl
jne 0x15c025
movq (%rsp), %rdi
testq %rdi, %rdi
jne 0x15bfe0
testb %cl, %cl
je 0x15c067
movb $0x1, 0x28(%r14)
movq 0x18(%r14), %r15
movq 0x20(%r14), %rdi
callq 0xd24e0
movq 0x20(%r14), %rdi
cmpq %rax, %r15
jae 0x15c059
movq 0x18(%r14), %rsi
callq 0xd2207
movq (%rax), %rax
movq %rax, (%rbx)
incq 0x18(%r14)
jmp 0x15c065
callq 0xd2519
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4afa9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_new
GtNodeStream* gt_load_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns = gt_node_stream_create(gt_load_stream_class(), true);
  GtLoadStream *load_stream = gt_load_stream_cast(ns);
  gt_assert(in_stream);
  load_stream->in_stream = gt_node_stream_ref(in_stream);
  load_stream->full = false;
  load_stream->idx = 0;
  load_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x15bed0
movq %rax, %rdi
movl $0x1, %esi
callq 0x162d6c
movq %rax, %rbx
callq 0x15bed0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
testq %r14, %r14
je 0x15c0dd
movq %rax, %r15
movq %r14, %rdi
callq 0x162dd8
movq %rax, 0x10(%r15)
movb $0x0, 0x28(%r15)
movq $0x0, 0x18(%r15)
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x20(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x4b017
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_class_new
const GtMatchClass* gt_match_class_new(size_t size,
                                       GtMatchFreeFunc free,
                                       GtMatchAcceptFunc accept)
{
  GtMatchClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->accept = accept;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15d80e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x2f7c10
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x4b8cb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_create
GtMatch* gt_match_create(const GtMatchClass *matchc,
                         GtUword start1, GtUword end1,
                         GtUword start2, GtUword end2,
                         const char *seqid1, const char *seqid2,
                         GtMatchDirection dir)
{
  GtMatch *match;
  gt_assert(matchc && matchc->size);
  match = gt_malloc(matchc->size);
  match->c_class = matchc;
  if (seqid1)
    match->seqid1 = gt_str_new_cstr(seqid1);
  else
    match->seqid1 = NULL;
  if (seqid2)
    match->seqid2 = gt_str_new_cstr(seqid2);
  else
    match->seqid2 = NULL;
  match->range_seq1.start = start1;
  match->range_seq1.end = end1;
  match->range_seq2.start = start2;
  match->range_seq2.end = end2;
  match->direction = dir;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
testq %rdi, %rdi
je 0x15d8b3
movq %rdi, %rbp
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x15d8b3
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x22932f(%rip), %rsi    # 0x386b78
movl $0x32, %edx
callq 0x104226
movq %rax, %r13
movq %rbp, (%rax)
testq %rbx, %rbx
je 0x15d868
movq %rbx, %rdi
callq 0x11acc9
jmp 0x15d86a
xorl %eax, %eax
movl 0x48(%rsp), %ebx
movq %rax, 0x8(%r13)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x15d883
callq 0x11acc9
jmp 0x15d885
xorl %eax, %eax
movq %rax, 0x10(%r13)
movq %r12, 0x18(%r13)
movq %r15, 0x20(%r13)
movq %r14, 0x28(%r13)
movq (%rsp), %rax
movq %rax, 0x30(%r13)
movl %ebx, 0x38(%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4b902
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid1
void gt_match_set_seqid1(GtMatch *match, const char *seqid)
{
  gt_assert(match && seqid);
  if (!match->seqid1)
    match->seqid1 = gt_str_new_cstr(seqid);
  else {
    gt_str_reset(match->seqid1);
    gt_str_append_cstr(match->seqid1, seqid);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15d934
movq %rsi, %r14
testq %rsi, %rsi
je 0x15d934
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x15d920
callq 0x11b132
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11acf3
movq %r14, %rdi
callq 0x11acc9
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4b9a7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid2
void gt_match_set_seqid2(GtMatch *match, const char *seqid)
{
  gt_assert(match && seqid);
  if (!match->seqid2)
    match->seqid2 = gt_str_new_cstr(seqid);
  else {
    gt_str_reset(match->seqid2);
    gt_str_append_cstr(match->seqid2, seqid);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15d982
movq %rsi, %r14
testq %rsi, %rsi
je 0x15d982
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x15d96e
callq 0x11b132
movq 0x10(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11acf3
movq %r14, %rdi
callq 0x11acc9
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4b9de
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid1_nt
void gt_match_set_seqid1_nt(GtMatch *match, const char *seqid,
                            GtUword len)
{
  gt_assert(match && seqid);
  if (!match->seqid1)
    match->seqid1 = gt_str_new();
  else
    gt_str_reset(match->seqid1);
  gt_str_append_cstr_nt(match->seqid1, seqid, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15d9cf
movq %rsi, %r14
testq %rsi, %rsi
je 0x15d9cf
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x15d9b3
callq 0x11b132
movq 0x8(%r15), %rdi
jmp 0x15d9bf
callq 0x11ac6c
movq %rax, %rdi
movq %rax, 0x8(%r15)
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x11ae1b
callq 0x4ba15
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid2_nt
void gt_match_set_seqid2_nt(GtMatch *match, const char *seqid,
                            GtUword len)
{
  gt_assert(match && seqid);
  if (!match->seqid2)
    match->seqid2 = gt_str_new();
  else
    gt_str_reset(match->seqid2);
  gt_str_append_cstr_nt(match->seqid2, seqid, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15da1c
movq %rsi, %r14
testq %rsi, %rsi
je 0x15da1c
movq %rdx, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x15da00
callq 0x11b132
movq 0x10(%r15), %rdi
jmp 0x15da0c
callq 0x11ac6c
movq %rax, %rdi
movq %rax, 0x10(%r15)
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x11ae1b
callq 0x4ba4c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_range_seq1
void gt_match_set_range_seq1(GtMatch *match, GtUword start,
                             GtUword end)
{
  gt_assert(match);
  gt_assert(start <= end);
  match->range_seq1.start = start;
  match->range_seq1.end = end;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15da8e
cmpq %rdx, %rsi
ja 0x15da93
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
popq %rax
retq
callq 0x4bba0
callq 0x4bb67
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_range_seq2
void gt_match_set_range_seq2(GtMatch *match, GtUword start,
                             GtUword end)
{
  gt_assert(match);
  gt_assert(start <= end);
  match->range_seq2.start = start;
  match->range_seq2.end = end;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15daad
cmpq %rdx, %rsi
ja 0x15dab2
movq %rsi, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
popq %rax
retq
callq 0x4bc12
callq 0x4bbd9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match.c
// Function: gt_match_delete
void gt_match_delete(GtMatch *match)
{
  if (!match) return;
  gt_assert(match->c_class);
  if (match->c_class->free)
    match->c_class->free(match);
  if (match->seqid1)
    gt_str_delete(match->seqid1);
  if (match->seqid2)
    gt_str_delete(match->seqid2);
  gt_free(match);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x15db16
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x15db18
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x15dae5
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x15daf3
callq 0x11bdbf
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x15db01
callq 0x11bdbf
leaq 0x229070(%rip), %rsi    # 0x386b78
movq %rbx, %rdi
movl $0xba, %edx
popq %rbx
jmp 0x1045eb
popq %rbx
retq
callq 0x4bc84
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_class
const GtMatchClass* gt_match_blast_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchBlast),
                                NULL,
                                match_blast_accept);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x360c62(%rip)    # 0x4be790
jne 0x15db4a
leaq 0x21(%rip), %rdx        # 0x15db58
movl $0x70, %edi
xorl %esi, %esi
callq 0x15d7e0
movq %rax, 0x360c46(%rip)    # 0x4be790
callq 0xe2545
movq 0x360c3a(%rip), %rax    # 0x4be790
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_blast.c
// Function: match_blast_accept
static int match_blast_accept(GtMatch *match, GtMatchVisitor *mv, GtError *err)
{
  GtMatchBlast *mb;
  gt_assert(match && mv);
  gt_error_check(err);
  mb = gt_match_blast_cast(match);
  return gt_match_visitor_visit_match_blast(mv, mb, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15dba4
movq %rsi, %r14
testq %rsi, %rsi
je 0x15dba4
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x15db81
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x15dba9
callq 0x15db20
movq %rax, %rdi
movq %r15, %rsi
callq 0x15d8b8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1604ad
callq 0x4bcbd
callq 0x4bcf4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_new
GtMatch* gt_match_blast_new(char *seqid1,
                            char *seqid2,
                            GtUword start_seq1,
                            GtUword end_seq1,
                            GtUword start_seq2,
                            GtUword end_seq2,
                            double evalue,
                            float bitscore,
                            GtUword length,
                            double similarity,
                            GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchBlast *matchb;
  match = gt_match_create(gt_match_blast_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchb = gt_match_blast_cast(match);
  matchb->evalue = evalue;
  matchb->bitscore = bitscore;
  matchb->ali_length = length;
  matchb->similarity = similarity;
  matchb->mm_num = 0;
  matchb->gap_open_num = 0;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm2, 0x10(%rsp)
movss %xmm1, 0x4(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x15db20
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %rbp, %r9
movl 0x58(%rsp), %eax
pushq %rax
pushq %r13
callq 0x15d813
addq $0x10, %rsp
movq %rax, %rbx
callq 0x15db20
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15d8b8
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x48(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x50(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x68(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_new_extended
GtMatch* gt_match_blast_new_extended(char *seqid1,
                                     char *seqid2,
                                     GtUword start_seq1,
                                     GtUword end_seq1,
                                     GtUword start_seq2,
                                     GtUword end_seq2,
                                     double evalue,
                                     float bitscore,
                                     GtUword length,
                                     double similarity,
                                     GtUword mm_num,
                                     GtUword gap_open_num,
                                     GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchBlast *matchb;
  match = gt_match_create(gt_match_blast_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchb = gt_match_blast_cast(match);
  matchb->evalue = evalue;
  matchb->bitscore = bitscore;
  matchb->ali_length = length;
  matchb->similarity = similarity;
  matchb->mm_num = mm_num;
  matchb->gap_open_num = gap_open_num;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm2, 0x10(%rsp)
movss %xmm1, 0x4(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x15db20
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %rbp, %r9
movl 0x68(%rsp), %eax
pushq %rax
pushq %r13
callq 0x15d813
addq $0x10, %rsp
movq %rax, %rbx
callq 0x15db20
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15d8b8
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x48(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x50(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x68(%rax)
movups 0x58(%rsp), %xmm0
movups %xmm0, 0x58(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_create
GtMatchIterator* gt_match_iterator_create(const GtMatchIteratorClass *mpc)
{
  GtMatchIterator *mp;
  gt_assert(mpc && mpc->size);
  mp = gt_calloc(1, mpc->size);
  mp->c_class = mpc;
  return mp;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x15de29
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x15de29
leaq 0x2290eb(%rip), %rdx    # 0x386f00
movl $0x1, %edi
movl $0x28, %ecx
callq 0x10436a
movq %rbx, (%rax)
popq %rbx
retq
callq 0x4bfd5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_next
GtMatchIteratorStatus gt_match_iterator_next(GtMatchIterator *mp,
                                             GtMatch **match, GtError *err)
{
  gt_assert(mp);
  if (mp->c_class->next)
    return mp->c_class->next(mp, match, err);
  return GT_MATCHER_STATUS_END;
}

// Assembly:
testq %rdi, %rdi
je 0x15de47
movq (%rdi), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x15de41
jmpq *%rax
movl $0x1, %eax
retq
pushq %rax
callq 0x4c00c