LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_uniques_position_binsearch
GtUword gt_condenseq_uniques_position_binsearch(const GtCondenseq *condenseq,
                                                GtUword position)
{
  GtWord idx, low, high;
  gt_assert(condenseq && condenseq->uds_nelems > 0);
  low = (GtWord) -1;
  gt_safe_assign(high, condenseq->uds_nelems);
  idx = GT_DIV2(low + high);
  while (high - low > (GtWord) 1) {
    if (position < condenseq->uniques[idx].orig_startpos) {
      high = idx;
    }
    else {
      low = idx;
    }
    idx = GT_DIV2(low + high);
  }
  if (low > (GtWord) -1 && condenseq->uniques[idx].orig_startpos <= position)
    return (GtUword) idx;
  return condenseq->uds_nelems;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xc24ec
movq 0x98(%rdi), %rcx
testq %rcx, %rcx
je 0xc24ec
jle 0xc2524
leaq -0x1(%rcx), %rax
pushq $-0x1
popq %rdx
movq %rcx, %r8
sarq %rax
movq %r8, %r9
subq %rdx, %r9
cmpq $0x2, %r9
jl 0xc24d3
movq 0x10(%rdi), %r9
imulq $0x28, %rax, %r10
cmpq %rsi, 0x18(%r9,%r10)
ja 0xc24c8
movq %rax, %rdx
jmp 0xc24ce
movq %rax, %r8
movq %rdx, %rax
addq %r8, %rax
jmp 0xc24a5
testq %rdx, %rdx
js 0xc24e7
movq 0x10(%rdi), %rdx
imulq $0x28, %rax, %rdi
cmpq %rsi, 0x18(%rdx,%rdi)
jbe 0xc24ea
movq %rcx, %rax
popq %rcx
retq
movq 0x375a75(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x222b16(%rip), %rsi    # 0x2e5013
leaq 0x256ee2(%rip), %rdx    # 0x3193e6
leaq 0x256f02(%rip), %rcx    # 0x31940d
leaq 0x256a62(%rip), %r8     # 0x318f74
movl $0x28b, %r9d            # imm = 0x28B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x375a3d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x226882(%rip), %rsi    # 0x2e8db7
leaq 0x256a38(%rip), %rdx    # 0x318f74
movl $0x28d, %ecx            # imm = 0x28D
xorl %eax, %eax
callq 0x17a50
pushq $0x1
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_extract_encoded
const GtUchar *gt_condenseq_extract_encoded(GtCondenseq *condenseq,
                                            GtUword *length,
                                            GtUword id)
{
  GtRange range;
  range.start = gt_condenseq_seqstartpos(condenseq, id);
  if (id < condenseq->orig_num_seq - 1)
    /* -2 because of seperator */
    range.end = gt_condenseq_seqstartpos(condenseq, id + 1) - 2;
  else
    range.end = condenseq->orig_len - 1;
  *length = range.end - range.start + 1;
  return gt_condenseq_extract_encoded_range(condenseq, range);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0xc1196
movq %rax, %r15
movq 0x80(%rbx), %rax
decq %rax
cmpq %r12, %rax
jbe 0xc2dcd
incq %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc1196
movq %rax, %rdx
addq $-0x2, %rdx
jmp 0xc2dd4
movq 0x78(%rbx), %rdx
decq %rdx
movq %rdx, %rax
subq %r15, %rax
incq %rax
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc2550
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_extract_decoded_range
const char *gt_condenseq_extract_decoded_range(GtCondenseq *condenseq,
                                               GtRange range,
                                               char separator)
{
  GtUword length = range.end - range.start + 1,
          idx;
  const GtUchar *ubuf;
  char *buf;
  gt_assert(range.start <= range.end);
  ubuf = gt_condenseq_extract_encoded_range(condenseq, range);
  if (condenseq->buffer == NULL || condenseq->buffsize < length) {
    condenseq->buffer = gt_realloc(condenseq->buffer,
                                   sizeof (*condenseq->buffer) * length);
    condenseq->buffsize = length;
  }
  buf = condenseq->buffer;
  for (idx = 0; idx < length; ++idx) {
    if (ubuf[idx] == GT_SEPARATOR) {
      buf[idx] = separator;
    }
    else {
      buf[idx] = gt_alphabet_decode(condenseq->alphabet, ubuf[idx]);
    }
  }
  return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
subq %rsi, %rax
jb 0xc2e84
movl %ecx, %ebx
movq %rdi, %r14
leaq 0x1(%rax), %r15
callq 0xc2550
movq %rax, %r12
movq 0x38(%r14), %r13
testq %r13, %r13
je 0xc2e29
cmpq %r15, 0x50(%r14)
jae 0xc2e4b
leaq 0x256144(%rip), %rdx    # 0x318f74
movq %r13, %rdi
movq %r15, %rsi
movl $0x359, %ecx            # imm = 0x359
callq 0x93472
movq %rax, %r13
movq %rax, 0x38(%r14)
movq %r15, 0x50(%r14)
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0xc2e72
movb (%r12,%rbp), %cl
movl %ebx, %eax
cmpb $-0x1, %cl
je 0xc2e68
movq (%r14), %rdi
movzbl %cl, %esi
callq 0x575cc
movb %al, (%r13,%rbp)
incq %rbp
jmp 0xc2e4d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3750dd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22217e(%rip), %rsi    # 0x2e5013
leaq 0x252190(%rip), %rdx    # 0x31502c
leaq 0x2566e1(%rip), %rcx    # 0x319584
leaq 0x2560ca(%rip), %r8     # 0x318f74
movl $0x355, %r9d            # imm = 0x355
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_extract_decoded
const char *gt_condenseq_extract_decoded(GtCondenseq *condenseq,
                                         GtUword *length,
                                         GtUword id)
{
  GtRange range;
  range.start = gt_condenseq_seqstartpos(condenseq, id);
  if (id < condenseq->orig_num_seq - 1)
    /* -2 because of seperator */
    range.end = gt_condenseq_seqstartpos(condenseq, id + 1) - 2;
  else
    range.end = condenseq->orig_len - 1;
  *length = range.end - range.start + 1;
  return gt_condenseq_extract_decoded_range(condenseq, range, '\0');
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0xc1196
movq %rax, %r15
movq 0x80(%rbx), %rax
decq %rax
cmpq %r12, %rax
jbe 0xc2efe
incq %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc1196
movq %rax, %rdx
addq $-0x2, %rdx
jmp 0xc2f05
movq 0x78(%rbx), %rdx
decq %rdx
movq %rdx, %rax
subq %r15, %rax
incq %rax
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc2df6
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_each_redundant_seq
GtUword gt_condenseq_each_redundant_seq(
                                       const GtCondenseq *condenseq,
                                       GtUword uid,
                                       GtCondenseqProcessExtractedSeqs callback,
                                       void *callback_data,
                                       GtError *err)
{
  int had_err = 0;
  GtUword num_seqs = (GtUword) 1, linkidx,
          orig_seqnum;
  const GtCondenseqUnique unique = condenseq->uniques[uid];

  orig_seqnum = gt_condenseq_pos2seqnum(condenseq, unique.orig_startpos);

  had_err = callback(callback_data, orig_seqnum, err);

  for (linkidx = 0;
       !had_err && linkidx < unique.links.nextfreeuint32_t;
       ++linkidx) {
    GtUword linkid = (GtUword) unique.links.spaceuint32_t[linkidx];
    const GtCondenseqLink link = condenseq->links[linkid];
    orig_seqnum = gt_condenseq_pos2seqnum(condenseq, link.orig_startpos);
    had_err = callback(callback_data, orig_seqnum, err);
    num_seqs++;
  }
  if (!had_err)
    return num_seqs;
  return (GtUword) had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rax
imulq $0x28, %rsi, %rcx
movq (%rax,%rcx), %rdx
movq %rdx, (%rsp)
movq 0x10(%rax,%rcx), %rbp
movq 0x18(%rax,%rcx), %rsi
callq 0xc1180
movq %r14, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %r14
movq %r13, %rdx
movq %rbx, %r13
callq *%rbx
xorl %ebx, %ebx
testl %eax, %eax
jne 0xc2fac
cmpq %rbp, %rbx
jae 0xc2fac
movq (%rsp), %rax
movl (%rax,%rbx,4), %eax
movq 0x8(%r12), %rcx
shlq $0x5, %rax
movq 0x8(%rcx,%rax), %rsi
movq %r12, %rdi
callq 0xc1180
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq *%r13
incq %rbx
jmp 0xc2f75
incq %rbx
testl %eax, %eax
cltq
cmoveq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_unique_length_dist
GtDiscDistri *gt_condenseq_unique_length_dist(const GtCondenseq *condenseq)
{
  GtUword idx;
  GtDiscDistri *res = gt_disc_distri_new();

  for (idx = 0; idx < condenseq->uds_nelems; idx++) {
    gt_disc_distri_add(res, condenseq->uniques[idx].len);
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x20
popq %r15
xorl %r12d, %r12d
callq 0x6d958
movq %rax, %r14
cmpq 0x98(%rbx), %r12
jae 0xc38f1
movq 0x10(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x6d96d
incq %r12
addq $0x28, %r15
jmp 0xc38cf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_link_length_dist
GtDiscDistri *gt_condenseq_link_length_dist(const GtCondenseq *condenseq)
{
  GtUword idx;
  GtDiscDistri *res = gt_disc_distri_new();

  for (idx = 0; idx < condenseq->lds_nelems; idx++) {
    gt_disc_distri_add(res, condenseq->links[idx].len);
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %r15
xorl %r12d, %r12d
callq 0x6d958
movq %rax, %r14
cmpq 0x70(%rbx), %r12
jae 0xc3939
movq 0x8(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x6d96d
incq %r12
addq $0x20, %r15
jmp 0xc391a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_link_comp_dist
GtDiscDistri *gt_condenseq_link_comp_dist(const GtCondenseq *condenseq)
{
  GtUword idx;
  GtDiscDistri *res = gt_disc_distri_new();

  for (idx = 0; idx < condenseq->lds_nelems; idx++) {
    GtEditscript *es = condenseq->links[idx].editscript;
    GtUword vlen;
    size_t size;
    vlen = gt_editscript_get_target_len(es);
    size = gt_editscript_size(es);
    gt_disc_distri_add(res, (GtUword) ((double) size/(double) vlen * 100));
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
callq 0x6d958
movq %rax, %r14
xorl %ebp, %ebp
cmpq 0x70(%rbx), %rbp
jae 0xc3a09
movq 0x8(%rbx), %rax
movq (%rax,%r13), %r15
movq %r15, %rdi
callq 0xcedcd
movq %rax, %r12
movq %r15, %rdi
callq 0xcf913
movq %rax, %xmm0
movq 0x223f4b(%rip), %xmm2   # 0x2e78e0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x223f4f(%rip), %xmm3   # 0x2e78f0
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq %r12, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm3, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
divsd %xmm2, %xmm1
mulsd 0x225e0a(%rip), %xmm1   # 0x2e97e0
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x224336(%rip), %xmm1   # 0x2e7d20
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
callq 0x6d96d
incq %rbp
addq $0x20, %r13
jmp 0xc3963
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_unique_range_to_seqrange
GtUword gt_condenseq_unique_range_to_seqrange(const GtCondenseq *condenseq,
                                              GtUword uid,
                                              GtRange *urange)
{
  GtUword seqnum = 0, seqstart = 0;
  GtCondenseqUnique uq;

  gt_assert(condenseq != NULL);
  gt_assert(uid < condenseq->uds_nelems);

  uq = condenseq->uniques[uid];
  seqnum = gt_condenseq_pos2seqnum(condenseq, uq.orig_startpos);
  seqstart = gt_condenseq_seqstartpos(condenseq, seqnum);
  urange->start += uq.orig_startpos - seqstart;
  urange->end += uq.orig_startpos - seqstart;
  return seqnum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc3a85
movq %rdi, %r14
cmpq %rsi, 0x98(%rdi)
jbe 0xc3ab3
movq %rdx, %rbx
movq 0x10(%r14), %rax
imulq $0x28, %rsi, %rcx
movq 0x18(%rax,%rcx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc1180
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0xc1196
subq %rax, %r15
movdqu (%rbx), %xmm0
movq %r15, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
paddq %xmm0, %xmm1
movdqu %xmm1, (%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3744dc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22157d(%rip), %rsi    # 0x2e5013
leaq 0x2554ac(%rip), %rdx    # 0x318f49
leaq 0x255b96(%rip), %rcx    # 0x31963a
leaq 0x2554c9(%rip), %r8     # 0x318f74
movl $0x4a4, %r9d            # imm = 0x4A4
jmp 0xc3adf
movq 0x3744ae(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22154f(%rip), %rsi    # 0x2e5013
leaq 0x255878(%rip), %rdx    # 0x319343
leaq 0x255b68(%rip), %rcx    # 0x31963a
leaq 0x25549b(%rip), %r8     # 0x318f74
movl $0x4a5, %r9d            # imm = 0x4A5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_count_relevant_uniques
GtUword gt_condenseq_count_relevant_uniques(const GtCondenseq *condenseq,
                                            unsigned int min_align_len)
{
  GtUword idx, count = 0;
  for (idx = 0; idx < condenseq->uds_nelems; idx++) {
    if (condenseq->uniques[idx].len >= min_align_len)
      count++;
  }
  return count;
}

// Assembly:
movq 0x98(%rdi), %rcx
pushq $0x20
popq %rdx
xorl %eax, %eax
subq $0x1, %rcx
jb 0xc3b63
movq 0x10(%rdi), %r8
cmpl %esi, (%r8,%rdx)
sbbq $-0x1, %rax
addq $0x28, %rdx
jmp 0xc3b4b
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_size
GtUword gt_condenseq_size(const GtCondenseq *condenseq,
                          GtUword *uniques,
                          GtUword *links,
                          GtUword *editscripts,
                          GtUword *descriptions,
                          GtUword *separators) {
  GtUword idx;
  *uniques = condenseq->uds_nelems * sizeof (*condenseq->uniques);
  for (idx = 0; idx < condenseq->uds_nelems; idx++) {
    *uniques += condenseq->uniques[idx].links.allocateduint32_t *
      sizeof (*condenseq->uniques[idx].links.spaceuint32_t);
  }
  *links = condenseq->lds_nelems * sizeof (*condenseq->links);
  *editscripts = 0;
  for (idx = 0; idx < condenseq->lds_nelems; idx++)
    *editscripts += gt_editscript_size(condenseq->links[idx].editscript);
  *descriptions = condenseq->ids_total_len;
  *descriptions += gt_intset_size_of_struct(condenseq->sdstab);
  *descriptions += gt_intset_size_of_rep(condenseq->sdstab);
  *separators = gt_intset_size_of_struct(condenseq->ssptab);
  *separators = gt_intset_size_of_rep(condenseq->ssptab);
  return *uniques + *links + *editscripts + *descriptions + *separators;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %rbp
imulq $0x28, 0x98(%rdi), %rax
movq %rsi, %r13
movq %rax, (%rsi)
pushq $0x8
popq %rcx
xorl %edi, %edi
cmpq 0x98(%rbp), %rdi
jae 0xc3bb5
movq 0x10(%rbp), %rsi
movq (%rsi,%rcx), %rsi
leaq (%rax,%rsi,4), %rax
movq %rax, (%r13)
incq %rdi
addq $0x28, %rcx
jmp 0xc3b93
movq 0x70(%rbp), %rax
shlq $0x5, %rax
movq %rdx, 0x10(%rsp)
movq %rax, (%rdx)
andq $0x0, (%r14)
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq 0x70(%rbp), %r12
jae 0xc3bee
movq 0x8(%rbp), %rax
movq (%rax,%r15), %rdi
callq 0xcf913
addq %rax, (%r14)
incq %r12
addq $0x20, %r15
jmp 0xc3bcf
movq 0x60(%rbp), %rax
movq %rax, (%rbx)
movq 0x20(%rbp), %rdi
callq 0xf3946
addq %rax, (%rbx)
movq 0x20(%rbp), %rdi
callq 0xf38bc
addq %rax, (%rbx)
movq 0x28(%rbp), %rdi
callq 0xf3946
movq 0x8(%rsp), %r15
movq %rax, (%r15)
movq 0x28(%rbp), %rdi
callq 0xf38bc
movq %rax, (%r15)
addq (%r13), %rax
movq 0x10(%rsp), %rcx
addq (%rcx), %rax
addq (%r14), %rax
addq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq_creator.c
// Function: gt_condenseq_creator_delete
void gt_condenseq_creator_delete(GtCondenseqCreator *condenseq_creator)
{
  if (condenseq_creator != NULL) {
#ifdef GT_CONDENSEQ_CREATOR_DIST_DEBUG
    gt_disc_distri_delete(condenseq_creator->add);
    gt_disc_distri_delete(condenseq_creator->replace);
    gt_disc_distri_delete(condenseq_creator->delete);
#endif
    gt_free(condenseq_creator->window.idxs);
    gt_free(condenseq_creator->window.pos_arrs);
    gt_kmer_database_delete(condenseq_creator->kmer_db);
    gt_seqabstract_delete(condenseq_creator->xdrop.current_seq_bwd);
    gt_seqabstract_delete(condenseq_creator->xdrop.current_seq_fwd);
    gt_seqabstract_delete(condenseq_creator->xdrop.unique_seq_bwd);
    gt_seqabstract_delete(condenseq_creator->xdrop.unique_seq_fwd);
    gt_xdrop_resources_delete(condenseq_creator->xdrop.best_left_res);
    gt_xdrop_resources_delete(condenseq_creator->xdrop.best_right_res);
    gt_xdrop_resources_delete(condenseq_creator->xdrop.left_xdrop_res);
    gt_xdrop_resources_delete(condenseq_creator->xdrop.right_xdrop_res);
    gt_free(condenseq_creator->xdrop.left);
    gt_free(condenseq_creator->xdrop.right);

    gt_free(condenseq_creator);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xc5514
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
leaq 0x25457a(%rip), %r14    # 0x3199d4
movq %r14, %rsi
movl $0x47b, %edx            # imm = 0x47B
callq 0x936f9
movq 0xb0(%rbx), %rdi
movq %r14, %rsi
movl $0x47c, %edx            # imm = 0x47C
callq 0x936f9
movq 0x8(%rbx), %rdi
callq 0xf414c
movq 0x80(%rbx), %rdi
callq 0x191a01
movq 0x78(%rbx), %rdi
callq 0x191a01
movq 0x90(%rbx), %rdi
callq 0x191a01
movq 0x88(%rbx), %rdi
callq 0x191a01
movq 0x68(%rbx), %rdi
callq 0x1b7634
movq 0x70(%rbx), %rdi
callq 0x1b7634
movq 0x58(%rbx), %rdi
callq 0x1b7634
movq 0x60(%rbx), %rdi
callq 0x1b7634
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x486, %edx            # imm = 0x486
callq 0x936f9
movq 0xa0(%rbx), %rdi
movq %r14, %rsi
movl $0x487, %edx            # imm = 0x487
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x489, %edx            # imm = 0x489
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq_creator.c
// Function: ces_c_skip_short_seqs
static CesCState ces_c_skip_short_seqs(GtCondenseqCreator *ces_c)
{

  while (ces_c->main_seqnum < ces_c->ces->orig_num_seq) {
    ces_c->current_seq_len = gt_condenseq_seqlength(ces_c->ces,
                                                    ces_c->main_seqnum);
    if (ces_c->current_seq_len < ces_c->min_align_len) {
      GtUword start = gt_condenseq_seqstartpos(ces_c->ces,
                                               ces_c->main_seqnum);
      /* no check for overflow of length necessary, as minalignlength was
         checked not to overflow */
      gt_condenseq_add_unique_to_db(ces_c->ces, start,
                                    ces_c->current_seq_len);
      ces_c->main_seqnum++;
    }
    else
      break;
  }
  return ces_c->main_seqnum >= ces_c->ces->orig_num_seq ?
    GT_CONDENSEQ_CREATOR_EOD : GT_CONDENSEQ_CREATOR_CONT;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xf8(%rdi), %rsi
movq 0x28(%rbx), %rdi
movq 0x80(%rdi), %rcx
cmpq %rcx, %rsi
jae 0xc6b6f
callq 0xc11b3
movq %rax, 0xd0(%rbx)
movq 0x28(%rbx), %rdi
movq 0xf8(%rbx), %rsi
cmpq 0x100(%rbx), %rax
jae 0xc6b68
callq 0xc1196
movq 0x28(%rbx), %rdi
movl 0xd0(%rbx), %edx
movq %rax, %rsi
callq 0xc17d8
movq 0xf8(%rbx), %rsi
incq %rsi
movq %rsi, 0xf8(%rbx)
jmp 0xc6b0e
movq 0x80(%rdi), %rcx
xorl %eax, %eax
cmpq %rcx, %rsi
setae %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq_creator.c
// Function: ces_c_reset_pos_and_iter_to_current_seq
static CesCState
ces_c_reset_pos_and_iter_to_current_seq(GtCondenseqCreator *ces_c)
{
  if (ces_c->main_seqnum >= ces_c->ces->orig_num_seq) {
    return GT_CONDENSEQ_CREATOR_EOD;
  }
  ces_c->current_seq_start =
    gt_condenseq_seqstartpos(ces_c->ces,
                             ces_c->main_seqnum);
  return ces_c_reset_pos_and_iter(ces_c, ces_c->current_seq_start);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq 0xf8(%rbx), %rsi
cmpq 0x80(%rdi), %rsi
jae 0xc6ba6
callq 0xc1196
movq %rax, 0xe0(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xc6c16
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq_creator.c
// Function: ces_c_add_kmers
static void ces_c_add_kmers(GtCondenseqCreator *ces_c,
                            GtUword start,
                            GtUword end)
{
  gt_assert(start < end);
  if (start + ces_c->min_align_len <= end)
    gt_kmer_database_add_interval(ces_c->kmer_db, start, end - 1,
                                  ces_c->ces->uds_nelems - 1);
}

// Assembly:
cmpq %rdx, %rsi
jae 0xc6bdd
movq 0x100(%rdi), %rax
addq %rsi, %rax
cmpq %rdx, %rax
jbe 0xc6bc0
retq
decq %rdx
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rcx
movq 0x98(%rcx), %rcx
decq %rcx
movq %rax, %rdi
jmp 0xf4b05
pushq %rax
movq 0x371383(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21e424(%rip), %rsi    # 0x2e5013
leaq 0x253a31(%rip), %rdx    # 0x31a627
leaq 0x253a36(%rip), %rcx    # 0x31a633
leaq 0x252dd0(%rip), %r8     # 0x3199d4
movl $0x4dc, %r9d            # imm = 0x4DC
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq_creator.c
// Function: ces_c_reset_pos_and_iter
static CesCState ces_c_reset_pos_and_iter(GtCondenseqCreator *ces_c,
                                          GtUword pos)
{
  unsigned int idx;
  if (pos >= ces_c->ces->orig_len) {
    return GT_CONDENSEQ_CREATOR_EOD;
  }
  ces_c->current_orig_start =
    ces_c->main_pos = pos;
  ces_c->current_seq_pos =
    ces_c->main_pos - ces_c->current_seq_start;
  ces_c->window.count = 0;
  ces_c->window.next = 0;
  for (idx = 0; idx < ces_c->windowsize; idx++)
    ces_c->window.pos_arrs[idx].no_positions = 0;
  gt_kmercodeiterator_reset(ces_c->main_kmer_iter,
                            GT_READMODE_FORWARD,
                            ces_c->main_pos);
  return GT_CONDENSEQ_CREATOR_RESET;
}

// Assembly:
movq 0x28(%rdi), %rax
cmpq %rsi, 0x78(%rax)
jbe 0xc6c83
pushq %rax
movq %rsi, %rdx
movq %rsi, 0xf0(%rdi)
movq %rsi, 0xc8(%rdi)
movq %rsi, %rax
subq 0xe0(%rdi), %rax
movq %rax, 0xd8(%rdi)
andq $0x0, 0xc0(%rdi)
movl 0x13c(%rdi), %eax
pushq $0x10
popq %rcx
xorl %esi, %esi
cmpq %rax, %rsi
jae 0xc6c70
movq 0xb0(%rdi), %r8
andq $0x0, (%r8,%rcx)
incq %rsi
addq $0x18, %rcx
jmp 0xc6c56
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0x19eee0
pushq $0x2
popq %rax
addq $0x8, %rsp
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq_creator.c
// Function: ces_c_handle_seqend
static CesCState ces_c_handle_seqend(GtCondenseqCreator *ces_c,
                                     GtError *err)
{
  CesCState state = GT_CONDENSEQ_CREATOR_CONT;
  /* rest of sequence length */
  GtUword length = ces_c->current_seq_len - ces_c->current_seq_pos;
  /* add length of unique before this pos */
  length += ces_c->main_pos - ces_c->current_orig_start;
  if (length != 0) {
    GT_CES_LENCHECK_STATE(length);
    if (state != GT_CONDENSEQ_CREATOR_ERROR) {
      gt_condenseq_add_unique_to_db(ces_c->ces,
                                    ces_c->current_orig_start,
                                    length);
      if (length >= ces_c->min_align_len)
        ces_c_add_kmers(ces_c, ces_c->current_orig_start,
                        ces_c->current_orig_start + length);
    }
  }
  if (state != GT_CONDENSEQ_CREATOR_ERROR) {
    ces_c->main_seqnum++;
    state = ces_c_skip_short_seqs(ces_c);
    if (state == GT_CONDENSEQ_CREATOR_CONT) {
      state = ces_c_reset_pos_and_iter_to_current_seq(ces_c);
    }
  }
  return state;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd0(%rdi), %rcx
subq 0xd8(%rdi), %rcx
movq 0xc8(%rdi), %rax
movq 0xf0(%rdi), %r14
subq %rax, %r14
addq %rcx, %r14
je 0xc6d08
movq %r14, %rcx
shrq $0x20, %rcx
je 0xc6cdb
leaq 0x2533f8(%rip), %rax    # 0x31a0ba
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x89dbb
pushq $0x3
jmp 0xc6d1d
movq 0x28(%rbx), %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0xc17d8
cmpq 0x100(%rbx), %r14
jb 0xc6d08
movq 0xc8(%rbx), %rsi
addq %rsi, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc6bab
incq 0xf8(%rbx)
movq %rbx, %rdi
callq 0xc6b03
testl %eax, %eax
je 0xc6d26
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc6b79
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq_search_arguments.c
// Function: gt_condenseq_search_register_options
void gt_condenseq_search_register_options(
                         GtCondenseqSearchArguments *condenseq_search_arguments,
                         GtOptionParser *option_parser)
{
  GtOption *option;
   /* -db */
  option = gt_option_new_filename("db", "path of (compressed) fasta database",
                                  condenseq_search_arguments->dbpath);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(option_parser, option);

  /* -verbose */
  option = gt_option_new_bool("verbose", "verbose output",
                              &condenseq_search_arguments->verbose, false);
  gt_option_parser_add_option(option_parser, option);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x24ea49(%rip), %rdi    # 0x315809
leaq 0x25395a(%rip), %rsi    # 0x31a721
callq 0x9ad51
movq %rax, %r15
movq %rax, %rdi
callq 0x9ae37
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
addq $0x8, %r14
leaq 0x220300(%rip), %rdi    # 0x2e70ed
leaq 0x221dfa(%rip), %rsi    # 0x2e8bee
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x97f31
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign.c
// Function: gt_diagonalbandalignment_in_square_space
GtUword gt_diagonalbandalignment_in_square_space(GtLinspaceManagement
                                                 *spacemanager,
                                                 GtAlignment *alignment,
                                                 const GtUchar *useq,
                                                 GtUword ustart,
                                                 GtUword ulen,
                                                 const GtUchar *vseq,
                                                 GtUword vstart,
                                                 GtUword vlen,
                                                 GtWord left_dist,
                                                 GtWord right_dist,
                                                 GtUword matchcost,
                                                 GtUword mismatchcost,
                                                 GtUword gapcost)
{
  GtUword distance;
  GtScoreHandler *scorehandler;

  scorehandler = gt_scorehandler_new(matchcost, mismatchcost, 0, gapcost);
  distance = gt_diagonalbandalignment_in_square_space_generic(spacemanager,
                                                           alignment,
                                                           useq, ustart, ulen,
                                                           vseq, vstart, vlen,
                                                           left_dist,
                                                           right_dist,
                                                           scorehandler);
  gt_scorehandler_delete(scorehandler);
  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x30(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rcx
xorl %edx, %edx
callq 0x1148f4
movq %rax, %rbx
movq %rax, 0x20(%rsp)
movaps 0x80(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movaps 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq 0x30(%rsp), %r9
callq 0xc9194
movq %rax, %r14
movq %rbx, %rdi
callq 0x114a03
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign.c
// Function: gt_diagonalbandalign_compute_generic
void gt_diagonalbandalign_compute_generic(GtLinspaceManagement *spacemanager,
                                          const GtScoreHandler *scorehandler,
                                          GtAlignment *align,
                                          const GtUchar *useq,
                                          GtUword ustart, GtUword ulen,
                                          const GtUchar *vseq,
                                          GtUword vstart, GtUword vlen,
                                          GtWord left_dist,
                                          GtWord right_dist)
{

  gt_assert(useq && vseq && align && spacemanager && scorehandler);

  /* set new bounds, if left_dist or right_dist is out of sequence */
  left_dist = GT_MAX(-(GtWord) ulen, left_dist);
  right_dist = GT_MIN((GtWord) vlen, right_dist);

  gt_alignment_set_seqs(align,useq+ustart, ulen, vseq+vstart, vlen);
  gt_calc_diagonalbandalign(spacemanager, scorehandler, align,
                            useq, ustart, ulen, vseq, vstart, vlen,
                            left_dist, right_dist);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq 0x50(%rsp), %rcx
movq %rcx, %xmm0
movq %r12, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rdi, 0x10(%rsp)
movq %rdi, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0xc9753
testq %rsi, %rsi
je 0xc9753
movq 0x70(%rsp), %r13
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %r11
movq 0x58(%rsp), %rdi
movq %r9, %rbx
negq %rbx
cmpq %rax, %rbx
cmovleq %rax, %rbx
cmpq %r13, %r11
cmovlq %r11, %r13
movq %rsi, 0x8(%rsp)
leaq (%r12,%r8), %rsi
addq %rdi, %rcx
movq %rdx, %rdi
movq %rdx, %rbp
movq %r9, %rdx
movq %r8, %r14
movq %r11, %r8
movq %r9, %r15
callq 0xb4f1f
subq $0x8, %rsp
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r14, %r8
movq %r15, %r9
pushq %r13
pushq %rbx
pushq 0x78(%rsp)
pushq 0x78(%rsp)
pushq 0x78(%rsp)
callq 0xc978b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x36e80e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21b8af(%rip), %rsi    # 0x2e5013
leaq 0x251821(%rip), %rdx    # 0x31af8c
leaq 0x251850(%rip), %rcx    # 0x31afc2
leaq 0x2517f2(%rip), %r8     # 0x31af6b
movl $0x3a9, %r9d            # imm = 0x3A9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign.c
// Function: gt_diagonalbandalign_compute
void gt_diagonalbandalign_compute(GtLinspaceManagement *spacemanager,
                                  GtAlignment *align,
                                  const GtUchar *useq,
                                  GtUword ustart, GtUword ulen,
                                  const GtUchar *vseq,
                                  GtUword vstart, GtUword vlen,
                                  GtWord left_dist,
                                  GtWord right_dist,
                                  GtUword matchcost,
                                  GtUword mismatchcost,
                                  GtUword gapcost)
{
  GtScoreHandler *scorehandler;
  gt_assert(spacemanager && align);

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

  gt_diagonalbandalign_compute_generic(spacemanager, scorehandler, align,
                                       useq, ustart, ulen,
                                       vseq, vstart, vlen,
                                       left_dist, right_dist);
  gt_scorehandler_delete(scorehandler);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
testq %rdi, %rdi
je 0xc9a89
movq %rsi, %r13
testq %rsi, %rsi
je 0xc9a89
movq %rdi, %rbp
movq 0x90(%rsp), %rcx
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %r14
movq 0x70(%rsp), %r15
movq 0x68(%rsp), %r12
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
xorl %edx, %edx
callq 0x1148f4
movq %rax, %rbx
subq $0x8, %rsp
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
pushq %r14
pushq %r15
pushq %r12
pushq 0x20(%rsp)
pushq 0x48(%rsp)
callq 0xc9665
addq $0x30, %rsp
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x114a03
movq 0x36e4d8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21b579(%rip), %rsi    # 0x2e5013
leaq 0x251546(%rip), %rdx    # 0x31afe7
leaq 0x251555(%rip), %rcx    # 0x31affd
leaq 0x2514bc(%rip), %r8     # 0x31af6b
movl $0x3c2, %r9d            # imm = 0x3C2
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign_affinegapcost.c
// Function: gt_diagonalbandalign_affinegapcost_in_square_space
GtWord gt_diagonalbandalign_affinegapcost_in_square_space(
                                                    GtLinspaceManagement *space,
                                                    GtAlignment *align,
                                                    const GtUchar *useq,
                                                    GtUword ustart,
                                                    GtUword ulen,
                                                    const GtUchar *vseq,
                                                    GtUword vstart,
                                                    GtUword vlen,
                                                    GtWord left_dist,
                                                    GtWord right_dist,
                                                    GtUword matchcost,
                                                    GtUword mismatchcost,
                                                    GtUword gap_opening,
                                                    GtUword gap_extension)
{
  GtWord distance;
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchcost,mismatchcost,
                                                    gap_opening, gap_extension);

  distance = gt_diagonalbandalign_affinegapcost_in_square_space_generic(space,
                                     scorehandler, align, useq, ustart, ulen,
                                     vseq, vstart, vlen, left_dist, right_dist);
  gt_scorehandler_delete(scorehandler);

  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, 0x30(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
callq 0x1148f4
movq %rax, %r14
movaps 0x80(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movaps 0x70(%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 0x30(%rsp), %r9
callq 0xcae80
movq %rax, %rbx
movq %r14, %rdi
callq 0x114a03
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign_affinegapcost.c
// Function: gt_diagonalbandalign_affinegapcost_compute
void gt_diagonalbandalign_affinegapcost_compute(GtLinspaceManagement
                                                *spacemanager,
                                                GtAlignment *align,
                                                const GtUchar *useq,
                                                GtUword ustart, GtUword ulen,
                                                const GtUchar *vseq,
                                                GtUword vstart, GtUword vlen,
                                                GtWord left_dist,
                                                GtWord right_dist,
                                                GtUword matchcost,
                                                GtUword mismatchcost,
                                                GtUword gap_opening,
                                                GtUword gap_extension)
{
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchcost,
                                                     mismatchcost,
                                                     gap_opening,
                                                     gap_extension);

  gt_diagonalbandalign_affinegapcost_compute_generic(spacemanager, scorehandler,
                                                     align, useq, ustart, ulen,
                                                     vseq, vstart, vlen,
                                                     left_dist, right_dist);

  gt_scorehandler_delete(scorehandler);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, 0x28(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movaps 0x90(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movaps 0xa0(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xc0(%rsp), %rdx
movq 0xc8(%rsp), %rcx
callq 0x1148f4
movq %rax, %r14
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movaps 0x40(%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 0x28(%rsp), %r9
callq 0xcb795
movq %r14, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x114a03
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign_affinegapcost.c
// Function: set_invalid_Diagentry
static void inline  set_invalid_Diagentry(GtDiagAlignentry *node)
{
  gt_assert(node != NULL);
  node->currentrowindex = GT_UWORD_MAX;
  node->last_type = Affine_X;
  node->lastcpoint = GT_UWORD_MAX;
}

// Assembly:
testq %rdi, %rdi
je 0xcdc74
orq $-0x1, 0x8(%rdi)
movl $0x3, 0x10(%rdi)
orq $-0x1, (%rdi)
retq
pushq %rax
movq 0x36a2ec(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21738d(%rip), %rsi    # 0x2e5013
leaq 0x256d63(%rip), %rdx    # 0x3249f0
leaq 0x24d93d(%rip), %rcx    # 0x31b5d1
leaq 0x24d5bf(%rip), %r8     # 0x31b25a
movl $0x24d, %r9d            # imm = 0x24D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign_affinegapcost.c
// Function: set_valid_Diagentry
static void inline set_valid_Diagentry(GtDiagAlignentry *node_to,
                                       const GtAffineAlignRtabentry *entry_from,
                                       GtWord minvalue, GtWord r_dist,
                                       GtWord i_dist, GtWord d_dist)
{
  gt_assert(node_to != NULL && entry_from != NULL);
  if (minvalue == r_dist)
  {
    node_to->last_type = entry_from->val_R.edge;
    node_to->lastcpoint = entry_from->val_R.idx;
  }
  else if (minvalue == i_dist)
  {
    node_to->last_type = entry_from->val_I.edge;
    node_to->lastcpoint = entry_from->val_I.idx;
  }
  else if (minvalue == d_dist)
  {
    node_to->last_type = entry_from->val_D.edge;
    node_to->lastcpoint = entry_from->val_D.idx;
  }

}

// Assembly:
testq %rdi, %rdi
je 0xcdcea
testq %rsi, %rsi
je 0xcdcea
cmpq %rcx, %rdx
jne 0xcdcc4
pushq $0x8
popq %rcx
movq %rsi, %rax
jmp 0xcdcdd
cmpq %r8, %rdx
jne 0xcdcd1
leaq 0x20(%rsi), %rax
pushq $0x28
jmp 0xcdcdc
cmpq %r9, %rdx
jne 0xcdce9
leaq 0x10(%rsi), %rax
pushq $0x18
popq %rcx
movl (%rsi,%rcx), %ecx
movl %ecx, 0x10(%rdi)
movq (%rax), %rax
movq %rax, (%rdi)
retq
pushq %rax
movq 0x36a276(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x217317(%rip), %rsi    # 0x2e5013
leaq 0x24d8e4(%rip), %rdx    # 0x31b5e7
leaq 0x24d903(%rip), %rcx    # 0x31b60d
leaq 0x24d549(%rip), %r8     # 0x31b25a
movl $0x258, %r9d            # imm = 0x258
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign_affinegapcost.c
// Function: set_valid_Rnode
static void inline set_valid_Rnode(GtAffineAlignRnode *node_to,
                                   GtAffineAlignRtabentry *entry_from,
                                   GtWord minvalue, GtWord r_dist,
                                   GtWord i_dist, GtWord d_dist)
{
  gt_assert(node_to != NULL && entry_from != NULL);
  if (minvalue == r_dist)
    *node_to = entry_from->val_R;
  else if (minvalue == i_dist)
     *node_to = entry_from->val_I;
  else if (minvalue == d_dist)
     *node_to = entry_from->val_D;
}

// Assembly:
testq %rdi, %rdi
je 0xcdd4d
testq %rsi, %rsi
je 0xcdd4d
cmpq %rcx, %rdx
je 0xcdd46
cmpq %r8, %rdx
jne 0xcdd3d
addq $0x20, %rsi
jmp 0xcdd46
cmpq %r9, %rdx
jne 0xcdd4c
addq $0x10, %rsi
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
retq
pushq %rax
movq 0x36a213(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2172b4(%rip), %rsi    # 0x2e5013
leaq 0x24d881(%rip), %rdx    # 0x31b5e7
leaq 0x24d8c6(%rip), %rcx    # 0x31b633
leaq 0x24d4e6(%rip), %r8     # 0x31b25a
movl $0x277, %r9d            # imm = 0x277
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/dot_visitor.c
// Function: gt_dot_visitor_class
const GtNodeVisitorClass* gt_dot_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtDotVisitor),
                                    dv_free,
                                    NULL,
                                    dv_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  return nvc;
}

// Assembly:
movq 0x36f921(%rip), %rax    # 0x43d6b0
testq %rax, %rax
je 0xcdd95
retq
pushq %rax
andq $0x0, (%rsp)
leaq 0x23(%rip), %rsi        # 0xcddc5
leaq 0x75(%rip), %rcx        # 0xcde1e
pushq $0x20
popq %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x36f8f0(%rip)    # 0x43d6b0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/dot_visitor.c
// Function: dv_feature_node
static int dv_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                            GtError *err)
{
  GT_UNUSED GtDotVisitor *dv;
  int had_err = 0;
  GtUword pid;
  gt_error_check(err);
  dv = dv_cast(nv);

  if (!(pid = (GtUword) gt_hashmap_get(dv->ids, fn))) {
    pid = dv->idctr++;
    printf("subgraph "GT_WU" {\n", pid);
    gt_hashmap_add(dv->ids, fn, (void*) pid);
  }
  had_err = gt_feature_node_traverse_children(fn, dv,
                                              dv_output_edge,
                                              true, err);
  printf("}\n");
  gt_assert(!had_err);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xcde44
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xcdef7
callq 0xcdd88
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x8f482
testq %rax, %rax
jne 0xcde95
movq 0x18(%r15), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x18(%r15)
leaq 0x24d818(%rip), %rdi    # 0x31b694
movq %r12, %rsi
xorl %eax, %eax
callq 0x17070
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x8f4bd
leaq 0xf2(%rip), %rdx        # 0xcdf8e
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0xdac92
movl %eax, %ebx
leaq 0x29914f(%rip), %rdi    # 0x367005
callq 0x17b60
testl %ebx, %ebx
jne 0xcdecd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x36a094(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x217135(%rip), %rsi    # 0x2e5013
leaq 0x21779a(%rip), %rdx    # 0x2e567f
leaq 0x24d798(%rip), %rcx    # 0x31b684
leaq 0x24d776(%rip), %r8     # 0x31b669
pushq $0x60
jmp 0xcdf1f
movq 0x36a06a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21710b(%rip), %rsi    # 0x2e5013
leaq 0x2172b0(%rip), %rdx    # 0x2e51bf
leaq 0x24d76e(%rip), %rcx    # 0x31b684
leaq 0x24d74c(%rip), %r8     # 0x31b669
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/dot_visitor.c
// Function: gt_dot_visitor_new
GtNodeVisitor* gt_dot_visitor_new()
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_dot_visitor_class());
  GtDotVisitor *dv = dv_cast(nv);

  dv->ids = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
  dv->idctr = 1;
  printf("\ndigraph nodes {\n");

  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0xcdd88
movq %rax, %rdi
callq 0x102da0
movq %rax, %rbx
callq 0xcdd88
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8f330
movq %rax, 0x10(%r14)
movq $0x1, 0x18(%r14)
leaq 0x24d761(%rip), %rdi    # 0x31b6df
callq 0x17b60
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq