LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_add_unique_to_db
void gt_condenseq_add_unique_to_db(GtCondenseq *condenseq,
                                   GtUword orig_startpos,
                                   ces_unsigned len)
{
  gt_assert(len != 0);
  /* if previous unique and this one are not consecutive, add the new one */
  if (condenseq->uds_nelems == 0 ||
      condenseq->uniques[condenseq->uds_nelems - 1].orig_startpos +
      condenseq->uniques[condenseq->uds_nelems - 1].len != orig_startpos) {
    gt_assert(condenseq->uds_nelems == 0 ||
              condenseq->uniques[condenseq->uds_nelems - 1].orig_startpos +
              condenseq->uniques[condenseq->uds_nelems - 1].len <
              orig_startpos);
    gt_assert(condenseq->lds_nelems == 0 ||
              condenseq->links[condenseq->lds_nelems - 1].orig_startpos +
              condenseq->links[condenseq->lds_nelems - 1].len <=
              orig_startpos);
    condenseq_uds_resize(condenseq);
    condenseq->uniques[condenseq->uds_nelems].orig_startpos = orig_startpos;
    condenseq->uniques[condenseq->uds_nelems].len = len;
    condenseq->uniques[condenseq->uds_nelems].links.spaceuint32_t = NULL;
    condenseq->uds_nelems++;
  }
  else {
    condenseq->uniques[condenseq->uds_nelems - 1].len += len;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testl %edx, %edx
je 0x1322ca
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x98(%rdi), %rax
testq %rax, %rax
je 0x1321ef
movq 0x10(%r14), %rsi
leaq (%rax,%rax,4), %rcx
movl -0x8(%rsi,%rcx,8), %edx
movq -0x10(%rsi,%rcx,8), %rdi
addq %rdx, %rdi
cmpq %r15, %rdi
jne 0x1321d4
leaq (%rsi,%rcx,8), %rax
addl %ebx, %edx
movl %edx, -0x8(%rax)
jmp 0x1322c4
testq %rax, %rax
je 0x1321ef
movq 0x10(%r14), %rdx
movl -0x8(%rdx,%rcx,8), %esi
addq -0x10(%rdx,%rcx,8), %rsi
cmpq %r15, %rsi
jae 0x1322d4
movq 0x70(%r14), %rcx
testq %rcx, %rcx
je 0x132212
movq 0x8(%r14), %rdx
shlq $0x5, %rcx
movl -0x10(%rdx,%rcx), %esi
addq -0x18(%rdx,%rcx), %rsi
cmpq %r15, %rsi
ja 0x1322cf
movq 0x90(%r14), %rcx
cmpq %rcx, %rax
jne 0x13229a
movq %rcx, %xmm0
punpckldq 0x21e6b5(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x21e6bd(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x21ead1(%rip), %xmm1   # 0x350d18
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
subsd 0x21eac5(%rip), %xmm1   # 0x350d20
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rax, %rsi
testq %rcx, %rcx
movl $0x64, %eax
cmovneq %rsi, %rax
movq %rax, 0x90(%r14)
movq 0x10(%r14), %rdi
shlq $0x3, %rax
leaq (%rax,%rax,4), %rsi
leaq 0x24fcb8(%rip), %rdx    # 0x381f44
movl $0x13f, %ecx            # imm = 0x13F
callq 0x1094e6
movq %rax, 0x10(%r14)
movq 0x10(%r14), %rax
movq 0x98(%r14), %rcx
leaq (%rcx,%rcx,4), %rdx
movq %r15, 0x18(%rax,%rdx,8)
movl %ebx, 0x20(%rax,%rdx,8)
movq $0x0, (%rax,%rdx,8)
incq %rcx
movq %rcx, 0x98(%r14)
popq %rbx
popq %r14
popq %r15
retq
callq 0x3da60
callq 0x3da27
callq 0x3d9ee
// File: /workspace/github_c_makefile_star2_O1/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 0x68(%rdi), %rax
cmpq %rax, 0x70(%rdi)
jne 0x13235c
movq %rax, %xmm0
punpckldq 0x21e5ec(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x21e5f4(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x21ea08(%rip), %xmm1   # 0x350d18
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x21e9fc(%rip), %xmm1   # 0x350d20
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 0x24fbf6(%rip), %rdx    # 0x381f44
movl $0x14a, %ecx            # imm = 0x14A
callq 0x1094e6
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1323c7
leaq 0x10(%rsp), %rdx
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0x132389
movq %rcx, %rsi
shlq $0x5, %rsi
movl -0x10(%rax,%rsi), %edi
addq -0x18(%rax,%rsi), %rdi
cmpq 0x8(%rdx), %rdi
ja 0x1323cc
movq 0x98(%rbx), %rsi
testq %rsi, %rsi
je 0x1323ad
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 0x1323d1
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 0x3db0b
callq 0x3da99
callq 0x3dad2
// File: /workspace/github_c_makefile_star2_O1/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 0x132512
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
je 0x132411
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x13de54
incq %r15
addq $0x20, %r14
cmpq 0x70(%rbx), %r15
jb 0x1323f7
cmpq $0x0, 0x98(%rbx)
je 0x132467
xorl %r15d, %r15d
leaq 0x24fb1f(%rip), %r14    # 0x381f44
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0x132457
movq %r14, %rsi
movl $0x182, %edx            # imm = 0x182
callq 0x109670
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%r15)
movq $0x0, 0x10(%rax,%r15)
incq %r12
addq $0x28, %r15
cmpq 0x98(%rbx), %r12
jb 0x132428
movq (%rbx), %rdi
callq 0xd335d
movq 0x18(%rbx), %rdi
callq 0xee90c
movq 0x38(%rbx), %rdi
leaq 0x24fac1(%rip), %r14    # 0x381f44
movq %r14, %rsi
movl $0x186, %edx            # imm = 0x186
callq 0x109670
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x187, %edx            # imm = 0x187
callq 0x109670
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x188, %edx            # imm = 0x188
callq 0x109670
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movl $0x189, %edx            # imm = 0x189
callq 0x109670
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x18a, %edx            # imm = 0x18A
callq 0x109670
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x18b, %edx            # imm = 0x18B
callq 0x109670
movq 0x20(%rbx), %rdi
callq 0x15e488
movq 0x28(%rbx), %rdi
callq 0x15e488
movq %rbx, %rdi
movq %r14, %rsi
movl $0x18f, %edx            # imm = 0x18F
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x132fda
callq 0xd6450
movq %rax, %rbx
movq %rax, %rdi
callq 0x172f0
cmpq $0x2, %rax
jb 0x132fdc
movq %rbx, %rdi
incq %rdi
movl $0x2e, %esi
callq 0x17880
testq %rax, %rax
je 0x132fdc
movb $0x0, (%rax)
jmp 0x132fdc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x133010
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x133009
callq 0x120955
movq %rax, %rbx
leaq 0x296643(%rip), %rsi    # 0x3c9642
movq %rax, %rdi
callq 0x12097f
jmp 0x13300b
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
callq 0x3ddf0
// File: /workspace/github_c_makefile_star2_O1/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 0x13307d
movq 0x98(%rdi), %rcx
testq %rcx, %rcx
je 0x13307d
jle 0x133082
leaq -0x1(%rcx), %rax
sarq %rax
movq 0x10(%rdi), %rdx
movq $-0x1, %r8
movq %rcx, %r9
leaq (%rax,%rax,4), %r10
cmpq %rsi, 0x18(%rdx,%r10,8)
ja 0x13304e
movq %rax, %r8
jmp 0x133051
movq %rax, %r9
leaq (%r8,%r9), %rax
sarq %rax
movq %r9, %r10
subq %r8, %r10
cmpq $0x1, %r10
jg 0x13303e
testq %r8, %r8
js 0x133078
movq 0x10(%rdi), %rdx
leaq (%rax,%rax,4), %rdi
cmpq %rsi, 0x18(%rdx,%rdi,8)
jbe 0x13307b
movq %rcx, %rax
popq %rcx
retq
callq 0x3de56
callq 0x3de29
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x2, 0x80(%rdi)
jb 0x133568
movq 0x28(%rbx), %rdi
callq 0x15e36d
jmp 0x13356a
xorl %eax, %eax
movq 0x80(%rbx), %rcx
decq %rcx
cmpq %rcx, %rax
jae 0x133586
movq 0x28(%rbx), %rdi
movq %rax, %rsi
popq %rbx
jmp 0x15e2ef
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1335b6
movq 0x28(%rbx), %rdi
leaq -0x1(%r12), %rsi
callq 0x15e2ef
movq %rax, %r15
incq %r15
jmp 0x1335b9
xorl %r15d, %r15d
movq 0x80(%rbx), %rax
decq %rax
cmpq %r12, %rax
jbe 0x1335d6
movq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x15e2ef
jmp 0x1335da
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 0x133087
// File: /workspace/github_c_makefile_star2_O1/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 0x133689
movl %ecx, %ebx
movq %rdi, %r14
leaq 0x1(%rax), %r15
callq 0x133087
movq %rax, %r12
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x13362d
cmpq %r15, 0x50(%r14)
jae 0x133649
leaq 0x24e910(%rip), %rdx    # 0x381f44
movq %r15, %rsi
movl $0x359, %ecx            # imm = 0x359
callq 0x1094e6
movq %rax, 0x38(%r14)
movq %r15, 0x50(%r14)
movq 0x38(%r14), %r13
testq %r15, %r15
je 0x133677
xorl %ebp, %ebp
movb (%r12,%rbp), %cl
movl %ebx, %eax
cmpb $-0x1, %cl
je 0x13366a
movq (%r14), %rdi
movzbl %cl, %esi
callq 0xd3da7
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %r15
jne 0x133654
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3e24c
// File: /workspace/github_c_makefile_star2_O1/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 0x1336ba
movq 0x28(%rbx), %rdi
leaq -0x1(%r12), %rsi
callq 0x15e2ef
movq %rax, %r15
incq %r15
jmp 0x1336bd
xorl %r15d, %r15d
movq 0x80(%rbx), %rax
decq %rax
cmpq %r12, %rax
jbe 0x1336da
movq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x15e2ef
jmp 0x1336de
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 0x1335fa
// File: /workspace/github_c_makefile_star2_O1/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 0x13374d
leaq (%rcx,%rax,8), %rax
movq 0x18(%rax), %rsi
movq 0x28(%r12), %rdi
callq 0x15e36d
movq %rax, %rsi
jmp 0x13374f
xorl %esi, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq *%r15
movl $0x1, %ecx
testl %eax, %eax
sete %dl
jne 0x1337be
testq %rbp, %rbp
je 0x1337be
movl $0x1, %r13d
cmpq $0x2, 0x80(%r12)
jb 0x1337a0
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 0x15e36d
movq %rax, %rsi
jmp 0x1337a2
xorl %esi, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq *%r15
leaq 0x1(%r13), %rcx
testl %eax, %eax
sete %dl
jne 0x1337be
cmpq %rbp, %r13
movq %rcx, %r13
jb 0x13376f
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_O1/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 0xe99dc
movq %rax, %r14
cmpq $0x0, 0x98(%rbx)
je 0x134104
movl $0x20, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0xe99f7
incq %r12
addq $0x28, %r15
cmpq 0x98(%rbx), %r12
jb 0x1340e4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe99dc
movq %rax, %r14
cmpq $0x0, 0x70(%rbx)
je 0x134153
movl $0x10, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0xe99f7
incq %r12
addq $0x20, %r15
cmpq 0x70(%rbx), %r12
jb 0x134136
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe99dc
movq %rax, %r14
cmpq $0x0, 0x70(%rbx)
je 0x134229
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r13), %r15
movq %r15, %rdi
callq 0x13e8e1
movq %rax, %r12
movq %r15, %rdi
callq 0x13f58b
movq %rax, %xmm0
movq 0x21c730(%rip), %xmm2   # 0x3508e0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x21c734(%rip), %xmm3   # 0x3508f0
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 0x21e5ff(%rip), %xmm1   # 0x3527f0
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x21cb1b(%rip), %xmm1   # 0x350d20
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
callq 0xe99f7
incq %rbp
addq $0x20, %r13
cmpq 0x70(%rbx), %rbp
jb 0x134188
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/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 0x1342c7
movq %rdi, %r12
cmpq %rsi, 0x98(%rdi)
jbe 0x1342cc
movq %rdx, %rbx
leaq (%rsi,%rsi,4), %rax
movq 0x10(%r12), %rcx
movq 0x18(%rcx,%rax,8), %r14
cmpq $0x2, 0x80(%r12)
jb 0x134282
movq 0x28(%r12), %rdi
movq %r14, %rsi
callq 0x15e36d
movq %rax, %r15
jmp 0x134285
xorl %r15d, %r15d
testq %r15, %r15
je 0x13429d
movq 0x28(%r12), %rdi
leaq -0x1(%r15), %rsi
callq 0x15e2ef
notq %rax
jmp 0x13429f
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 0x3e414
callq 0x3e3db
// File: /workspace/github_c_makefile_star2_O1/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 0x134318
movq 0x10(%rdi), %rdx
addq $0x20, %rdx
xorl %eax, %eax
cmpl %esi, (%rdx)
sbbq $-0x1, %rax
addq $0x28, %rdx
decq %rcx
jne 0x134308
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13437b
movq 0x10(%rbp), %rax
addq $0x8, %rax
xorl %ecx, %ecx
movq (%rax), %rsi
shlq $0x2, %rsi
addq %rsi, (%r13)
incq %rcx
addq $0x28, %rax
cmpq 0x98(%rbp), %rcx
jb 0x134360
movq 0x70(%rbp), %rax
shlq $0x5, %rax
movq %rdx, 0x10(%rsp)
movq %rax, (%rdx)
movq $0x0, (%r14)
cmpq $0x0, 0x70(%rbp)
je 0x1343bc
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbp), %rax
movq (%rax,%r15), %rdi
callq 0x13f58b
addq %rax, (%r14)
incq %r12
addq $0x20, %r15
cmpq 0x70(%rbp), %r12
jb 0x13439f
movq 0x60(%rbp), %rax
movq %rax, (%rbx)
movq 0x20(%rbp), %rdi
callq 0x15e3f9
addq %rax, (%rbx)
movq 0x20(%rbp), %rdi
callq 0x15e3c5
addq %rax, (%rbx)
movq 0x28(%rbp), %rdi
callq 0x15e3f9
movq 0x8(%rsp), %r15
movq %rax, (%r15)
movq 0x28(%rbp), %rdi
callq 0x15e3c5
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x1356f9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
leaq 0x24d365(%rip), %r14    # 0x3829a4
movq %r14, %rsi
movl $0x47b, %edx            # imm = 0x47B
callq 0x109670
movq 0xb0(%rbx), %rdi
movq %r14, %rsi
movl $0x47c, %edx            # imm = 0x47C
callq 0x109670
movq 0x8(%rbx), %rdi
callq 0x15eade
movq 0x80(%rbx), %rdi
callq 0x1ec2af
movq 0x78(%rbx), %rdi
callq 0x1ec2af
movq 0x90(%rbx), %rdi
callq 0x1ec2af
movq 0x88(%rbx), %rdi
callq 0x1ec2af
movq 0x68(%rbx), %rdi
callq 0x20ce46
movq 0x70(%rbx), %rdi
callq 0x20ce46
movq 0x58(%rbx), %rdi
callq 0x20ce46
movq 0x60(%rbx), %rdi
callq 0x20ce46
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x486, %edx            # imm = 0x486
callq 0x109670
movq 0xa0(%rbx), %rdi
movq %r14, %rsi
movl $0x487, %edx            # imm = 0x487
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x489, %edx            # imm = 0x489
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq 0x80(%rdi), %rsi
jae 0x136cf3
callq 0x131b97
movq %rax, 0xd0(%rbx)
cmpq 0x100(%rbx), %rax
jae 0x136cf3
movq 0x28(%rbx), %rdi
movq 0xf8(%rbx), %rsi
callq 0x131b7a
movq 0x28(%rbx), %rdi
movl 0xd0(%rbx), %edx
movq %rax, %rsi
callq 0x13218c
movq 0x28(%rbx), %rdi
movq 0xf8(%rbx), %rsi
incq %rsi
movq %rsi, 0xf8(%rbx)
jmp 0x136c9c
movq 0x28(%rbx), %rcx
movq 0xf8(%rbx), %rdx
xorl %eax, %eax
cmpq 0x80(%rcx), %rdx
setae %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x136d39
callq 0x131b7a
movq %rax, 0xe0(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x136d78
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x136d72
movq 0x100(%rdi), %rax
addq %rsi, %rax
cmpq %rdx, %rax
jbe 0x136d55
retq
decq %rdx
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rcx
movq 0x98(%rcx), %rcx
decq %rcx
movq %rax, %rdi
jmp 0x15f35d
pushq %rax
callq 0x3ee50
// File: /workspace/github_c_makefile_star2_O1/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 0x136e86
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 0x136e72
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 0x22ac7b(%rip), %xmm1   # 0x361a70
xorl %esi, %esi
movdqa 0x22ac81(%rip), %xmm2   # 0x361a80
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x22ac81(%rip), %xmm4   # 0x361a90
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 0x136e4c
movq $0x0, 0x10(%rax,%rsi)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %r8d
testb $0x1, %r8b
je 0x136e65
movq $0x0, 0x28(%rax,%rsi)
paddq %xmm4, %xmm1
addq $0x30, %rsi
cmpq %rsi, %rcx
jne 0x136e0f
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0x1f7b10
movl $0x2, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd0(%rdi), %rax
subq 0xd8(%rdi), %rax
movq 0xf0(%rdi), %r14
subq 0xc8(%rdi), %r14
addq %rax, %r14
je 0x136f1d
xorl %ebp, %ebp
movq %r14, %r15
shrq $0x20, %r15
je 0x136ede
leaq 0x24c1c6(%rip), %rax    # 0x38308a
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0x3, %ebp
movl $0x3, %ecx
testq %r15, %r15
jne 0x136f1f
movq 0x28(%rbx), %rdi
movq 0xc8(%rbx), %rsi
movl %r14d, %edx
callq 0x13218c
cmpq 0x100(%rbx), %r14
jb 0x136f19
movq 0xc8(%rbx), %rsi
addq %rsi, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x136d40
movl %ebp, %ecx
jmp 0x136f1f
xorl %ecx, %ecx
movl $0x3, %eax
cmpl $0x3, %ecx
je 0x136f43
incq 0xf8(%rbx)
movq %rbx, %rdi
callq 0x136c8d
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x136f4e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x136d0c
// File: /workspace/github_c_makefile_star2_O1/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 0x24778b(%rip), %rdi    # 0x37e779
leaq 0x24c6fc(%rip), %rsi    # 0x3836f1
callq 0x10f9c6
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
addq $0x8, %r14
leaq 0x2190d2(%rip), %rdi    # 0x3500ed
leaq 0x21abdc(%rip), %rsi    # 0x351bfe
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10cd10
// File: /workspace/github_c_makefile_star2_O1/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 0x179740
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 0x138d80
movq %rax, %r14
movq %rbx, %rdi
callq 0x1797c3
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_O1/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 0x1392f4
testq %rsi, %rsi
je 0x1392f4
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 0x126bf9
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 0x1392f9
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3fa6f
// File: /workspace/github_c_makefile_star2_O1/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 0x1395b0
movq %rsi, %r13
testq %rsi, %rsi
je 0x1395b0
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 0x179740
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 0x139206
addq $0x30, %rsp
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1797c3
callq 0x3fb1a
// File: /workspace/github_c_makefile_star2_O1/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 0x179740
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 0x13a8f8
movq %rax, %rbx
movq %r14, %rdi
callq 0x1797c3
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq