LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_add_link_to_db
void gt_condenseq_add_link_to_db(GtCondenseq *condenseq, GtCondenseqLink link)
{
  condenseq_lds_resize(condenseq);
  gt_assert(condenseq->links != NULL);
  gt_assert(condenseq->lds_nelems == 0 ||
            condenseq->links[condenseq->lds_nelems - 1].orig_startpos +
            condenseq->links[condenseq->lds_nelems - 1].len <=
            link.orig_startpos);
  gt_assert(condenseq->uds_nelems == 0 ||
            condenseq->uniques[condenseq->uds_nelems - 1].orig_startpos +
            condenseq->uniques[condenseq->uds_nelems - 1].len <=
            link.orig_startpos);
  condenseq->links[condenseq->lds_nelems] = link;
  condenseq->lds_nelems++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq 0x68(%rdi), %rax
jne 0x12c32d
movq %rax, %xmm0
punpckldq 0x21b61d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x21b625(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x21ba39(%rip), %xmm1   # 0x347d18
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x21ba2d(%rip), %xmm1   # 0x347d20
cvttsd2si %xmm1, %rdi
andq %rdx, %rdi
orq %rcx, %rdi
testq %rax, %rax
movl $0x64, %esi
cmovneq %rdi, %rsi
movq %rsi, 0x68(%rbx)
movq 0x8(%rbx), %rdi
shlq $0x5, %rsi
leaq 0x24c909(%rip), %rdx    # 0x378c26
movl $0x14a, %ecx            # imm = 0x14A
callq 0x104461
movq %rax, 0x8(%rbx)
jmp 0x12c331
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x12c398
leaq 0x10(%rsp), %rdx
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0x12c35a
movq %rcx, %rsi
shlq $0x5, %rsi
movl -0x10(%rax,%rsi), %edi
addq -0x18(%rax,%rsi), %rdi
cmpq 0x8(%rdx), %rdi
ja 0x12c39d
movq 0x98(%rbx), %rsi
testq %rsi, %rsi
je 0x12c37e
movq 0x10(%rbx), %rdi
leaq (%rsi,%rsi,4), %rsi
movl -0x8(%rdi,%rsi,8), %r8d
addq -0x10(%rdi,%rsi,8), %r8
cmpq 0x8(%rdx), %r8
ja 0x12c3a2
shlq $0x5, %rcx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
incq 0x70(%rbx)
popq %rbx
retq
callq 0x3d0c6
callq 0x3d054
callq 0x3d08d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_delete
void gt_condenseq_delete(GtCondenseq *condenseq)
{
  if (condenseq != NULL) {
    GtUword i;
    for (i = 0; i < condenseq->lds_nelems; i++) {
      gt_editscript_delete(condenseq->links[i].editscript);
    }
    for (i = 0; i < condenseq->uds_nelems; i++) {
      GT_FREEARRAY(&(condenseq->uniques[i].links), uint32_t);
    }
    gt_alphabet_delete(condenseq->alphabet);
    gt_encseq_delete(condenseq->unique_es);
    gt_free(condenseq->buffer);
    gt_free(condenseq->filename);
    gt_free(condenseq->links);
    gt_free(condenseq->orig_ids);
    gt_free(condenseq->ubuffer);
    gt_free(condenseq->uniques);
    gt_intset_delete(condenseq->sdstab);
    gt_intset_delete(condenseq->ssptab);

    gt_free(condenseq);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x12c4e8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
je 0x12c3e2
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x137778
incq %r15
addq $0x20, %r14
cmpq 0x70(%rbx), %r15
jb 0x12c3c8
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0x12c43d
movq 0x10(%rbx), %rcx
xorl %r15d, %r15d
leaq 0x24c82a(%rip), %r14    # 0x378c26
xorl %r12d, %r12d
movq (%rcx,%r15), %rdi
testq %rdi, %rdi
je 0x12c431
movq %r14, %rsi
movl $0x182, %edx            # imm = 0x182
callq 0x1045eb
movq 0x10(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rcx,%r15)
movq $0x0, 0x10(%rcx,%r15)
movq 0x98(%rbx), %rax
incq %r12
addq $0x28, %r15
cmpq %rax, %r12
jb 0x12c3ff
movq (%rbx), %rdi
callq 0xd0e1c
movq 0x18(%rbx), %rdi
callq 0xea375
movq 0x38(%rbx), %rdi
leaq 0x24c7cd(%rip), %r14    # 0x378c26
movq %r14, %rsi
movl $0x186, %edx            # imm = 0x186
callq 0x1045eb
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x187, %edx            # imm = 0x187
callq 0x1045eb
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x188, %edx            # imm = 0x188
callq 0x1045eb
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movl $0x189, %edx            # imm = 0x189
callq 0x1045eb
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x18a, %edx            # imm = 0x18A
callq 0x1045eb
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x18b, %edx            # imm = 0x18B
callq 0x1045eb
movq 0x20(%rbx), %rdi
callq 0x1568d4
movq 0x28(%rbx), %rdi
callq 0x1568d4
movq %rbx, %rdi
movq %r14, %rsi
movl $0x18f, %edx            # imm = 0x18F
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_basefilename
char *gt_condenseq_basefilename(const GtCondenseq *condenseq)
{
  char *basename = NULL,
       *suffix_ptr;
  if (condenseq->filename != NULL) {
    basename = gt_basename(condenseq->filename);
    if (strlen(basename) > (size_t) 1 &&
        (suffix_ptr = strrchr(basename + 1, '.')) != NULL) {
      /* remove suffix */
      *suffix_ptr = '\0';
    }
  }
  return basename;
}

// Assembly:
pushq %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x12cf7f
callq 0xd3e84
movq %rax, %rbx
movq %rax, %rdi
callq 0x172f0
cmpq $0x2, %rax
jb 0x12cf81
movq %rbx, %rdi
incq %rdi
movl $0x2e, %esi
callq 0x17880
testq %rax, %rax
je 0x12cf81
movb $0x0, (%rax)
jmp 0x12cf81
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_unique_fasta_file
GtStr *gt_condenseq_unique_fasta_file(const GtCondenseq *condenseq)
{
  GtStr *unique = NULL;
  gt_assert(condenseq != NULL);
  if (condenseq->filename != NULL) {
    unique = gt_str_new_cstr(condenseq->filename);
    gt_str_append_cstr(unique, ".fas");
  }
  return unique;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x12cfb5
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x12cfae
callq 0x11acc9
movq %rax, %rbx
leaq 0x29301e(%rip), %rsi    # 0x3bffc2
movq %rax, %rdi
callq 0x11acf3
jmp 0x12cfb0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
callq 0x3d372
// File: /workspace/github_c_makefile_star2_O3/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 0x12d022
movq 0x98(%rdi), %rcx
testq %rcx, %rcx
je 0x12d022
jle 0x12d027
leaq -0x1(%rcx), %rax
shrq %rax
movq 0x10(%rdi), %rdx
movq $-0x1, %r8
movq %rcx, %r9
leaq (%rax,%rax,4), %r10
cmpq %rsi, 0x18(%rdx,%r10,8)
ja 0x12cff3
movq %rax, %r8
jmp 0x12cff6
movq %rax, %r9
leaq (%r8,%r9), %rax
sarq %rax
movq %r9, %r10
subq %r8, %r10
cmpq $0x1, %r10
jg 0x12cfe3
testq %r8, %r8
js 0x12d01d
movq 0x10(%rdi), %rdx
leaq (%rax,%rax,4), %rdi
cmpq %rsi, 0x18(%rdx,%rdi,8)
jbe 0x12d020
movq %rcx, %rax
popq %rcx
retq
callq 0x3d3d8
callq 0x3d3ab
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_next_sep
static GtUword condenseq_next_sep(const GtCondenseq *ces, GtUword pos)
{
  GtUword seqidx = gt_condenseq_pos2seqnum(ces, pos);
  if (seqidx < ces->orig_num_seq - 1)
    return gt_intset_get(ces->ssptab, seqidx);
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %rcx
cmpq $0x2, %rcx
jb 0x12d517
movq 0x28(%rbx), %rdi
callq 0x1567b9
movq 0x80(%rbx), %rcx
jmp 0x12d519
xorl %eax, %eax
decq %rcx
cmpq %rcx, %rax
jae 0x12d52e
movq 0x28(%rbx), %rdi
movq %rax, %rsi
popq %rbx
jmp 0x15673b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdx, %rdx
je 0x12d55e
movq 0x28(%rbx), %rdi
leaq -0x1(%r12), %rsi
callq 0x15673b
movq %rax, %r15
incq %r15
jmp 0x12d561
xorl %r15d, %r15d
movq 0x80(%rbx), %rax
decq %rax
cmpq %r12, %rax
jbe 0x12d57e
movq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x15673b
jmp 0x12d582
movq 0x78(%rbx), %rax
leaq -0x1(%rax), %rdx
subq %r15, %rax
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12d02c
// File: /workspace/github_c_makefile_star2_O3/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 0x12d633
movl %ecx, %ebx
movq %rdi, %r14
leaq 0x1(%rax), %r15
callq 0x12d02c
movq %rax, %r12
movq 0x38(%r14), %r13
testq %r13, %r13
je 0x12d5d5
cmpq %r15, 0x50(%r14)
jae 0x12d5f7
leaq 0x24b64a(%rip), %rdx    # 0x378c26
movq %r13, %rdi
movq %r15, %rsi
movl $0x359, %ecx            # imm = 0x359
callq 0x104461
movq %rax, %r13
movq %rax, 0x38(%r14)
movq %r15, 0x50(%r14)
testq %r15, %r15
je 0x12d621
xorl %ebp, %ebp
movb (%r12,%rbp), %cl
movl %ebx, %eax
cmpb $-0x1, %cl
je 0x12d614
movq (%r14), %rdi
movzbl %cl, %esi
callq 0xd187b
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %r15
jne 0x12d5fe
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3d7ce
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdx, %rdx
je 0x12d664
movq 0x28(%rbx), %rdi
leaq -0x1(%r12), %rsi
callq 0x15673b
movq %rax, %r15
incq %r15
jmp 0x12d667
xorl %r15d, %r15d
movq 0x80(%rbx), %rax
decq %rax
cmpq %r12, %rax
jbe 0x12d684
movq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x15673b
jmp 0x12d688
movq 0x78(%rbx), %rax
leaq -0x1(%rax), %rdx
subq %r15, %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 0x12d5a2
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
leaq (%rsi,%rsi,4), %rax
movq 0x10(%rdi), %rcx
movq (%rcx,%rax,8), %rdx
movq %rdx, (%rsp)
movq 0x10(%rcx,%rax,8), %rbp
cmpq $0x2, 0x80(%rdi)
jb 0x12d6f7
leaq (%rcx,%rax,8), %rax
movq 0x18(%rax), %rsi
movq 0x28(%r12), %rdi
callq 0x1567b9
movq %rax, %rsi
jmp 0x12d6f9
xorl %esi, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq *%r15
movl $0x1, %ecx
testl %eax, %eax
sete %dl
jne 0x12d768
testq %rbp, %rbp
je 0x12d768
movl $0x1, %r13d
cmpq $0x2, 0x80(%r12)
jb 0x12d74a
movq (%rsp), %rax
movl -0x4(%rax,%r13,4), %eax
shlq $0x5, %rax
movq 0x8(%r12), %rcx
movq 0x28(%r12), %rdi
movq 0x8(%rcx,%rax), %rsi
callq 0x1567b9
movq %rax, %rsi
jmp 0x12d74c
xorl %esi, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq *%r15
leaq 0x1(%r13), %rcx
testl %eax, %eax
sete %dl
jne 0x12d768
cmpq %rbp, %r13
movq %rcx, %r13
jb 0x12d719
cltq
testb %dl, %dl
cmovneq %rcx, %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/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
callq 0xe54e0
movq %rax, %r14
cmpq $0x0, 0x98(%rbx)
je 0x12e0ab
movl $0x20, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0xe54fb
incq %r12
addq $0x28, %r15
cmpq 0x98(%rbx), %r12
jb 0x12e08b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
callq 0xe54e0
movq %rax, %r14
cmpq $0x0, 0x70(%rbx)
je 0x12e0fa
movl $0x10, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0xe54fb
incq %r12
addq $0x20, %r15
cmpq 0x70(%rbx), %r12
jb 0x12e0dd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
callq 0xe54e0
movq %rax, %r14
cmpq $0x0, 0x70(%rbx)
je 0x12e1d0
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r13), %r15
movq %r15, %rdi
callq 0x1381ec
movq %rax, %r12
movq %r15, %rdi
callq 0x138dee
movq %rax, %xmm0
movq 0x219789(%rip), %xmm2   # 0x3478e0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x21978d(%rip), %xmm3   # 0x3478f0
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 0x21b648(%rip), %xmm1   # 0x3497e0
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x219b74(%rip), %xmm1   # 0x347d20
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
callq 0xe54fb
incq %rbp
addq $0x20, %r13
cmpq 0x70(%rbx), %rbp
jb 0x12e12f
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_O3/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 0x12e26e
movq %rdi, %r12
cmpq %rsi, 0x98(%rdi)
jbe 0x12e273
movq %rdx, %rbx
leaq (%rsi,%rsi,4), %rax
movq 0x10(%r12), %rcx
movq 0x18(%rcx,%rax,8), %r14
cmpq $0x2, 0x80(%r12)
jb 0x12e241
movq 0x28(%r12), %rdi
movq %r14, %rsi
callq 0x1567b9
testq %rax, %rax
je 0x12e241
movq %rax, %r15
movq 0x28(%r12), %rdi
movq %rax, %rsi
decq %rsi
callq 0x15673b
notq %rax
jmp 0x12e246
xorl %r15d, %r15d
xorl %eax, %eax
addq %r14, %rax
movdqu (%rbx), %xmm0
movq %rax, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
paddq %xmm0, %xmm1
movdqu %xmm1, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3d996
callq 0x3d95d
// File: /workspace/github_c_makefile_star2_O3/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
testq %rcx, %rcx
je 0x12e2bf
movq 0x10(%rdi), %rdx
addq $0x20, %rdx
xorl %eax, %eax
cmpl %esi, (%rdx)
sbbq $-0x1, %rax
addq $0x28, %rdx
decq %rcx
jne 0x12e2af
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %r13
movq %rdi, %rbp
movq 0x98(%rdi), %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rax
movq %rax, (%rsi)
cmpq $0x0, 0x98(%rdi)
je 0x12e322
movq 0x10(%rbp), %rcx
addq $0x8, %rcx
xorl %edi, %edi
movq (%rcx), %rsi
leaq (%rax,%rsi,4), %rax
movq %rax, (%r13)
incq %rdi
addq $0x28, %rcx
cmpq 0x98(%rbp), %rdi
jb 0x12e307
movq 0x70(%rbp), %rax
shlq $0x5, %rax
movq %rdx, 0x10(%rsp)
movq %rax, (%rdx)
movq $0x0, (%r14)
cmpq $0x0, 0x70(%rbp)
je 0x12e363
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbp), %rax
movq (%rax,%r15), %rdi
callq 0x138dee
addq %rax, (%r14)
incq %r12
addq $0x20, %r15
cmpq 0x70(%rbp), %r12
jb 0x12e346
movq 0x60(%rbp), %rax
movq %rax, (%rbx)
movq 0x20(%rbp), %rdi
callq 0x156845
addq %rax, (%rbx)
movq 0x20(%rbp), %rdi
callq 0x156811
addq %rax, (%rbx)
movq 0x28(%rbp), %rdi
callq 0x156845
movq 0x8(%rsp), %r15
movq %rax, (%r15)
movq 0x28(%rbp), %rdi
callq 0x156811
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_O3/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 0x12f5b8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
leaq 0x24a188(%rip), %r14    # 0x379686
movq %r14, %rsi
movl $0x47b, %edx            # imm = 0x47B
callq 0x1045eb
movq 0xb0(%rbx), %rdi
movq %r14, %rsi
movl $0x47c, %edx            # imm = 0x47C
callq 0x1045eb
movq 0x8(%rbx), %rdi
callq 0x156f2a
movq 0x80(%rbx), %rdi
callq 0x1e2a17
movq 0x78(%rbx), %rdi
callq 0x1e2a17
movq 0x90(%rbx), %rdi
callq 0x1e2a17
movq 0x88(%rbx), %rdi
callq 0x1e2a17
movq 0x68(%rbx), %rdi
callq 0x2034b4
movq 0x70(%rbx), %rdi
callq 0x2034b4
movq 0x58(%rbx), %rdi
callq 0x2034b4
movq 0x60(%rbx), %rdi
callq 0x2034b4
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x486, %edx            # imm = 0x486
callq 0x1045eb
movq 0xa0(%rbx), %rdi
movq %r14, %rsi
movl $0x487, %edx            # imm = 0x487
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x489, %edx            # imm = 0x489
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x28(%rdi), %rdi
movq 0xf8(%rbx), %rsi
movq 0x80(%rdi), %rcx
cmpq %rcx, %rsi
jae 0x130abc
callq 0x12bb4b
movq %rax, 0xd0(%rbx)
movq 0x28(%rbx), %rdi
movq 0xf8(%rbx), %rsi
cmpq 0x100(%rbx), %rax
jae 0x130ab5
callq 0x12bb2e
movq 0x28(%rbx), %rdi
movl 0xd0(%rbx), %edx
movq %rax, %rsi
callq 0x12c16d
movq 0x28(%rbx), %rdi
movq 0xf8(%rbx), %rsi
incq %rsi
movq %rsi, 0xf8(%rbx)
jmp 0x130a5b
movq 0x80(%rdi), %rcx
xorl %eax, %eax
cmpq %rcx, %rsi
setae %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x130af3
callq 0x12bb2e
movq %rax, 0xe0(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x130b32
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x130b2c
movq 0x100(%rdi), %rax
addq %rsi, %rax
cmpq %rdx, %rax
jbe 0x130b0f
retq
decq %rdx
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rcx
movq 0x98(%rcx), %rcx
decq %rcx
movq %rax, %rdi
jmp 0x15776e
pushq %rax
callq 0x3e3d2
// File: /workspace/github_c_makefile_star2_O3/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), %rcx
movl $0x1, %eax
cmpq %rsi, 0x78(%rcx)
jbe 0x130c40
pushq %rax
movq %rsi, %rdx
movq %rsi, 0xf0(%rdi)
movq %rsi, 0xc8(%rdi)
movq %rsi, %rax
subq 0xe0(%rdi), %rax
movq %rax, 0xd8(%rdi)
movq $0x0, 0xc0(%rdi)
movl 0x13c(%rdi), %ecx
testq %rcx, %rcx
je 0x130c2c
movq 0xb0(%rdi), %rax
leaq -0x1(%rcx), %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq 0x8(,%rcx,8), %rcx
andq $-0x10, %rcx
leaq (%rcx,%rcx,2), %rcx
movdqa 0x227e71(%rip), %xmm1   # 0x358a20
xorl %esi, %esi
movdqa 0x227e77(%rip), %xmm2   # 0x358a30
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x227e77(%rip), %xmm4   # 0x358a40
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %r8d
notl %r8d
testb $0x1, %r8b
je 0x130c06
movq $0x0, 0x10(%rax,%rsi)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %r8d
testb $0x1, %r8b
je 0x130c1f
movq $0x0, 0x28(%rax,%rsi)
paddq %xmm4, %xmm1
addq $0x30, %rsi
cmpq %rsi, %rcx
jne 0x130bc9
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0x1ee34c
movl $0x2, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x130cc5
movq %r14, %rcx
shrq $0x20, %rcx
je 0x130c98
leaq 0x2490f0(%rip), %rax    # 0x379d6c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0x3, %eax
jmp 0x130cdf
movq 0x28(%rbx), %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x12c16d
cmpq 0x100(%rbx), %r14
jb 0x130cc5
movq 0xc8(%rbx), %rsi
addq %rsi, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x130afa
incq 0xf8(%rbx)
movq %rbx, %rdi
callq 0x130a4c
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x130ce7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x130ac6
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x244773(%rip), %rdi    # 0x3754f9
leaq 0x249646(%rip), %rsi    # 0x37a3d3
callq 0x10a7af
movq %rax, %r15
movq %rax, %rdi
callq 0x10a87b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
addq $0x8, %r14
leaq 0x21633a(%rip), %rdi    # 0x3470ed
leaq 0x217e34(%rip), %rsi    # 0x348bee
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x107cc0
// File: /workspace/github_c_makefile_star2_O3/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 0x1331fd
movq %rsi, %r13
testq %rsi, %rsi
je 0x1331fd
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 0x17137c
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 0x132e53
addq $0x30, %rsp
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1713ff
callq 0x3f031
// File: /workspace/github_c_makefile_star2_O3/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 0x17137c
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 0x13452c
movq %rax, %rbx
movq %r14, %rdi
callq 0x1713ff
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_O3/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 0x387599(%rip), %rax    # 0x4be700
testq %rax, %rax
je 0x13716d
retq
pushq %rax
movq $0x0, (%rsp)
leaq 0x25(%rip), %rsi        # 0x1371a2
leaq 0x46(%rip), %rcx        # 0x1371ca
movl $0x20, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x387563(%rip)    # 0x4be700
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1371f0
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x137280
callq 0x137160
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x100add
testq %rax, %rax
jne 0x137241
movq 0x18(%r15), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x18(%r15)
leaq 0x2440d2(%rip), %rdi    # 0x37b2fa
movq %r12, %rsi
xorl %eax, %eax
callq 0x17070
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x100b18
leaq 0x9e(%rip), %rdx        # 0x1372e6
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %ecx
movq %rbx, %r8
callq 0x142d9d
movl %eax, %ebx
leaq 0x28f991(%rip), %rdi    # 0x3c6bf5
callq 0x17bd0
testl %ebx, %ebx
jne 0x13727b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3f9db
callq 0x3f9a4
// File: /workspace/github_c_makefile_star2_O3/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 0x137160
movq %rax, %rdi
callq 0x163080
movq %rax, %rbx
callq 0x137160
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1008fc
movq %rax, 0x10(%r14)
movq $0x1, 0x18(%r14)
leaq 0x24406f(%rip), %rdi    # 0x37b345
callq 0x17bd0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/dot_visitor.c
// Function: dv_output_edge
static int dv_output_edge(GtFeatureNode *fn, void *data,
                          GT_UNUSED GtError *err)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *curnode = NULL;
  GtUword pid, cid;
  int had_err = 0;
  GtDotVisitor *dv = (GtDotVisitor*) data;

  if (!(pid = (GtUword) gt_hashmap_get(dv->ids, fn))) {
    pid = dv->idctr++;
    gt_hashmap_add(dv->ids, fn, (void*) pid);
  }
  printf(""GT_WU" [shape=record, label=\"{ "GT_WU" | %s | %p }\"]\n",
             pid, pid, gt_feature_node_get_type(fn), fn);

  fni = gt_feature_node_iterator_new_direct(fn);
  while ((curnode = gt_feature_node_iterator_next(fni))) {
    if (!(cid = (GtUword) gt_hashmap_get(dv->ids, curnode))) {
      cid = dv->idctr++;
      gt_hashmap_add(dv->ids, curnode, (void*) cid);
    }
    printf(""GT_WU" [shape=record, label=\"{ "GT_WU" | %s | %p }\"]\n",
             cid, cid, gt_feature_node_get_type(curnode), curnode);
    printf(""GT_WU" -> "GT_WU"\n", pid, cid);
  }
  gt_feature_node_iterator_delete(fni);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rdi
movq %r15, %rsi
callq 0x100add
movq %rax, %r14
testq %rax, %rax
jne 0x137326
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r14
leaq 0x1(%r14), %rax
movq %rax, 0x18(%rbx)
movq %r15, %rsi
movq %r14, %rdx
callq 0x100b18
movq %r15, %rdi
callq 0x142988
leaq 0x243fd5(%rip), %rdi    # 0x37b30a
movq %r14, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x17070
movq %r15, %rdi
callq 0x144041
movq %rax, %r15
movq %rax, %rdi
callq 0x1440ea
testq %rax, %rax
je 0x1373dc
movq %rax, %rbp
leaq 0x243fcf(%rip), %r13    # 0x37b339
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x100add
movq %rax, %r12
testq %rax, %rax
jne 0x13739a
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x18(%rbx)
movq %rbp, %rsi
movq %r12, %rdx
callq 0x100b18
movq %rbp, %rdi
callq 0x142988
leaq 0x243f61(%rip), %rdi    # 0x37b30a
movq %r12, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x17070
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x17070
movq %r15, %rdi
callq 0x1440ea
movq %rax, %rbp
testq %rax, %rax
jne 0x13736a
movq %r15, %rdi
callq 0x14417c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/dup_feature_stream.c
// Function: gt_dup_feature_stream_new
GtNodeStream* gt_dup_feature_stream_new(GtNodeStream *in_stream,
                                        const char *dest_type,
                                        const char *source_type)
{
  GtNodeVisitor *nv;
  gt_assert(in_stream);
  nv = gt_dup_feature_visitor_new(dest_type, source_type);
  return gt_visitor_stream_new(in_stream, nv);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x137418
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1376b0
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x1841d5
callq 0x3fa12
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/dup_feature_visitor.c
// Function: gt_dup_feature_visitor_class
const GtNodeVisitorClass* gt_dup_feature_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtDupFeatureVisitor),
                                    dup_feature_visitor_free,
                                    NULL,
                                    dup_feature_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x3872da(%rip)    # 0x4be708
jne 0x13745f
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x13746d
leaq 0x71(%rip), %rcx        # 0x1374b7
movl $0x20, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x3872a9(%rip)    # 0x4be708
callq 0xe2545
movq 0x38729d(%rip), %rax    # 0x4be708
popq %rcx
retq