LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_header_size
static size_t
gt_compressed_bitsequence_header_size(const GtCompressedBitsequence *cbs)
{
  size_t size = 0;
  gt_assert(cbs != NULL);
  size += sizeof (cbs->c_offsets_size);
  size += sizeof (cbs->classes_size);
  size += sizeof (cbs->num_of_bits);
  size += sizeof (cbs->num_of_blocks);
  size += sizeof (cbs->num_of_superblocks);
  size += sizeof (cbs->superblockoffsets_size);
  size += sizeof (cbs->superblockranks_size);

  size += sizeof (cbs->blocksize);
  size += sizeof (cbs->class_bits);
  size += sizeof (cbs->last_block_len);
  size += sizeof (cbs->superblockoffsets_bits);
  size += sizeof (cbs->superblockranks_bits);
  size += sizeof (cbs->superblocksize);

  return size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x13c712
movq 0x4ff8bf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d9928(%rip), %rsi    # 0x516013
leaq 0x40e17e(%rip), %rdx    # 0x54a870
leaq 0x40e5d7(%rip), %rcx    # 0x54acd0
leaq 0x40e106(%rip), %r8     # 0x54a806
movl $0x37f, %r9d            # imm = 0x37F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13c714
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_size
size_t gt_compressed_bitsequence_size(const GtCompressedBitsequence *cbs)
{
  size_t size =  sizeof (cbs) +
    gt_popcount_tab_calculate_size(cbs->blocksize) +
    sizeof (cbs->cbs_bi) +
    sizeof (cbs->c_offsets[0]) * cbs->c_offsets_size +
    sizeof (cbs->classes[0]) * cbs->classes_size +
    sizeof (cbs->superblockoffsets[0]) * cbs->superblockoffsets_size +
    sizeof (cbs->superblockranks[0]) * cbs->superblockranks_size;

  return size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0xd8(%rax), %edi
callq 0x1b4a00
addq $0x8, %rax
addq $0x8, %rax
movq 0x10(%rsp), %rcx
movq 0xa0(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movq 0xa8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movq 0xc8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movq 0xd0(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_write
int gt_compressed_bitsequence_write(GtCompressedBitsequence *cbs,
                                    char *filename,
                                    GtError *err)
{
  int had_err = 0;
  GtUword expectedsize = 0;
  FILE *fp = NULL;

  fp = gt_fa_fopen(filename, "w", err);
  if (fp == NULL)
    had_err = -1;

  if (!had_err) {
    expectedsize = (GtUword) gt_compressed_bitsequence_file_size(cbs);
    had_err = gt_mapspec_write(gt_compressed_bitsequence_data_setup_mapspec,
                               fp, cbs, expectedsize, err);
  }
  if (!had_err) {
    gt_log_log("blocksize: %u\n"
           "class_offsets_size: " GT_WU "\n"
           "class_bits: %u\n"
           "classes_size: " GT_WU "\n"
           "last_block_len: %u\n"
           "num_of_bits: " GT_WU "\n"
           "num_of_blocks: " GT_WU "\n"
           "num_of_superblocks: " GT_WU "\n"
           "superblocksize: %u\n"
           "size: " GT_WU "\n",
           cbs->blocksize,
           cbs->c_offsets_size,
           cbs->class_bits,
           cbs->classes_size,
           cbs->last_block_len,
           cbs->num_of_bits,
           cbs->num_of_blocks,
           cbs->num_of_superblocks,
           cbs->superblocksize,
           expectedsize);
  }
  gt_fa_fclose(fp);

  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %r8
leaq 0x429624(%rip), %rsi    # 0x565ec5
leaq 0x40df5e(%rip), %rdx    # 0x54a806
movl $0x3b3, %ecx            # imm = 0x3B3
callq 0xd8df0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x13c8c7
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x3c(%rsp)
jne 0x13c901
movq 0x50(%rsp), %rdi
callq 0x13c630
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %r8
leaq 0xc8(%rip), %rdi        # 0x13c9c0
callq 0xea260
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x13c9a1
movq 0x50(%rsp), %rax
movl 0xd8(%rax), %esi
movq 0x50(%rsp), %rax
movq 0xa0(%rax), %rdx
movq 0x50(%rsp), %rax
movl 0xdc(%rax), %ecx
movq 0x50(%rsp), %rax
movq 0xa8(%rax), %r8
movq 0x50(%rsp), %rax
movl 0xe0(%rax), %r9d
movq 0x50(%rsp), %rax
movq 0xb0(%rax), %r14
movq 0x50(%rsp), %rax
movq 0xb8(%rax), %rbx
movq 0x50(%rsp), %rax
movq 0xc0(%rax), %r11
movq 0x50(%rsp), %rax
movl 0xec(%rax), %r10d
movq 0x30(%rsp), %rax
leaq 0x40dffb(%rip), %rdi    # 0x54a97d
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0xe7740
movq 0x28(%rsp), %rdi
callq 0xd9390
movl 0x3c(%rsp), %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_data_setup_mapspec
static void gt_compressed_bitsequence_data_setup_mapspec(GtMapspec *mapspec,
                                                         void *data,
                                                         GT_UNUSED bool write)
{
  GtCompressedBitsequence *cbs = data;

  /* this makes writing easy, and solves the problem of knowing where the data
     starts within the file/mapped area */
  gt_compressed_bitsequence_header_setup_mapspec(mapspec, data, write);

  gt_mapspec_add_bitsequence(mapspec, cbs->c_offsets, cbs->c_offsets_size);
  gt_mapspec_add_bitsequence(mapspec, cbs->classes, cbs->classes_size);
  gt_mapspec_add_bitsequence(mapspec, cbs->superblockoffsets,
                             cbs->superblockoffsets_size);
  gt_mapspec_add_bitsequence(mapspec, cbs->superblockranks,
                             cbs->superblockranks_size);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x13ce10
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x70, %rsi
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdx
callq 0xeb410
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x78, %rsi
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rdx
callq 0xeb410
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x80, %rsi
movq 0x8(%rsp), %rax
movq 0xc8(%rax), %rdx
callq 0xeb410
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x88, %rsi
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %rdx
callq 0xeb410
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_delete
void gt_compressed_bitsequence_delete(GtCompressedBitsequence *cbs)
{
  if (cbs != NULL) {
    gt_popcount_tab_delete(cbs->popcount_tab);
    if (cbs->from_file) {
      gt_fa_xmunmap(cbs->mmapped);
    }
    else {
      gt_free(cbs->classes);
      gt_free(cbs->c_offsets);
      gt_free(cbs->superblockranks);
      gt_free(cbs->superblockoffsets);
    }
    gt_free(cbs->cbs_bi);
    gt_free(cbs);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x13d167
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1b47b0
movq (%rsp), %rax
testb $0x1, 0xf0(%rax)
je 0x13d0cc
movq (%rsp), %rax
movq 0x98(%rax), %rdi
callq 0xdb2a0
jmp 0x13d136
movq (%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x40d72b(%rip), %rsi    # 0x54a806
movl $0x429, %edx            # imm = 0x429
callq 0xe88c0
movq (%rsp), %rax
movq 0x70(%rax), %rdi
leaq 0x40d712(%rip), %rsi    # 0x54a806
movl $0x42a, %edx            # imm = 0x42A
callq 0xe88c0
movq (%rsp), %rax
movq 0x88(%rax), %rdi
leaq 0x40d6f6(%rip), %rsi    # 0x54a806
movl $0x42b, %edx            # imm = 0x42B
callq 0xe88c0
movq (%rsp), %rax
movq 0x80(%rax), %rdi
leaq 0x40d6da(%rip), %rsi    # 0x54a806
movl $0x42c, %edx            # imm = 0x42C
callq 0xe88c0
movq (%rsp), %rax
movq 0x90(%rax), %rdi
leaq 0x40d6be(%rip), %rsi    # 0x54a806
movl $0x42e, %edx            # imm = 0x42E
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x40d6a9(%rip), %rsi    # 0x54a806
movl $0x42f, %edx            # imm = 0x42F
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_set_class
static inline void
gt_compressed_bitsequence_set_class(GtCompressedBitsequence *cbs,
                                    unsigned int class,
                                    GtUword idx)
{
  gt_compressed_bitsequence_set_variable_field(cbs->classes,
                                               cbs->classes_size,
                                               idx * cbs->class_bits,
                                               cbs->class_bits,
                                               (GtBitsequence) class);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0xa8(%rax), %rsi
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movl 0xdc(%rax), %eax
imulq %rax, %rdx
movq 0x10(%rsp), %rax
movl 0xdc(%rax), %ecx
movl 0xc(%rsp), %eax
movl %eax, %r8d
callq 0x13e200
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_pos2seqnum
GtUword gt_condenseq_pos2seqnum(const GtCondenseq *condenseq, GtUword pos)
{
  GtUword ret = 0;
  if (condenseq->orig_num_seq > (GtUword) 1)
    ret = gt_intset_get_idx_smallest_geq(condenseq->ssptab, pos);
  return ret;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rax
cmpq $0x1, 0x80(%rax)
jbe 0x13e45c
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x196cb0
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_seqstartpos
GtUword gt_condenseq_seqstartpos(const GtCondenseq *condenseq, GtUword seqnum)
{
  GtUword ret = 0;
  if (seqnum != 0)
    ret = gt_intset_get(condenseq->ssptab, seqnum - 1) + 1;
  return ret;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x13e4ad
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x8(%rsp), %rsi
subq $0x1, %rsi
callq 0x196a20
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_seqlength_help
static inline GtUword condenseq_seqlength_help(const GtCondenseq *condenseq,
                                               GtUword seqnum,
                                               GtUword seqstart)
{
  GtUword end = condenseq->orig_len;
  if (seqnum < condenseq->orig_num_seq - 1)
    end = gt_intset_get(condenseq->ssptab, seqnum);
  return end - seqstart;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x80(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x13e553
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x196a20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
subq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_new
GtCondenseq *gt_condenseq_new(const GtEncseq *orig_es, GtLogger *logger)
{
  GtCondenseq *condenseq;
  condenseq = condenseq_new_empty(gt_encseq_alphabet(orig_es));

  condenseq->orig_num_seq = gt_encseq_num_of_sequences(orig_es);

  condenseq->ssptab = condenseq_fill_tab(condenseq, orig_es);
  condenseq->orig_len = gt_encseq_total_length(orig_es);

  condenseq_process_descriptions(condenseq, orig_es, logger);
  return condenseq;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb0f00
movq %rax, %rdi
callq 0x13e810
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xa9d50
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x80(%rax)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x13e950
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rdi
callq 0xa9d00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x78(%rax)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x13ea60
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_new_empty
static GtCondenseq *condenseq_new_empty(const GtAlphabet *alph)
{
  GtCondenseq *condenseq = gt_malloc(sizeof (*condenseq));
  condenseq->alphabet = gt_alphabet_ref((GtAlphabet *) alph);

  condenseq->buffsize =
    condenseq->lds_allocated =
    condenseq->lds_nelems =
    condenseq->orig_len =
    condenseq->orig_num_seq =
    condenseq->ubuffsize =
    condenseq->uds_allocated =
    condenseq->uds_nelems = 0;

  condenseq->id_len = GT_UNDEF_UWORD;

  condenseq->buffer = NULL;
  condenseq->filename = NULL;
  condenseq->links = NULL;
  condenseq->orig_ids = NULL;
  condenseq->sdstab = NULL;
  condenseq->ssptab = NULL;
  condenseq->ubuffer = NULL;
  condenseq->unique_es = NULL;
  condenseq->uniques = NULL;

  return condenseq;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0xa0, %edi
leaq 0x40c71f(%rip), %rsi    # 0x54af44
movl $0xdf, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x7dc50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x98(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x90(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x88(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x80(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x78(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x70(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq $-0x1, 0x58(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_fill_tab
static GtIntset *condenseq_fill_tab(GtCondenseq *condenseq,
                                    const GtEncseq *orig_es)
{
  GtIntset *ssptab = NULL;
  GtUword max, idx;
  if (condenseq->orig_num_seq > (GtUword) 1) {
    max = gt_encseq_seqstartpos(orig_es, condenseq->orig_num_seq - 1);
    /* we store the internal separators, the end is explicit */
    ssptab = gt_intset_best_new(max - 1, condenseq->orig_num_seq - 1);
    for (idx = (GtUword) 1; idx < condenseq->orig_num_seq; ++idx) {
      GtUword pos = gt_encseq_seqstartpos(orig_es, idx) - 1;
      gt_assert(pos != 0);
      gt_intset_add(ssptab, pos);
    }
  }
  return ssptab;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x1, 0x80(%rax)
jbe 0x13ea56
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x80(%rax), %rsi
subq $0x1, %rsi
callq 0xb0530
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
subq $0x1, %rdi
movq 0x30(%rsp), %rax
movq 0x80(%rax), %rsi
subq $0x1, %rsi
callq 0x197390
movq %rax, 0x20(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x13ea54
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb0530
subq $0x1, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x13ea30
movq 0x4fd5a1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d760a(%rip), %rsi    # 0x516013
leaq 0x40cc59(%rip), %rdx    # 0x54b669
leaq 0x40cc5b(%rip), %rcx    # 0x54b672
leaq 0x40c526(%rip), %r8     # 0x54af44
movl $0x59, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13ea32
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x196950
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x13e9c5
jmp 0x13ea56
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_total_link_len
GtUword gt_condenseq_total_link_len(const GtCondenseq *condenseq)
{
  GtUword total = 0,
          i;

  for (i = 0; i < condenseq->lds_nelems; i++) {
    total += condenseq->links[i].len;
  }

  return total;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x13efd9
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x13ef97
movq -0x10(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_array_size_increase
GtUword gt_condenseq_array_size_increase(GtUword allocated)
{
  if (allocated != 0) {
    allocated *= 1.2;
  }
  else
    allocated = GT_CONDENSEQ_ARRAY_INIT;
  return allocated;
}

// Assembly:
movq %rdi, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x13f09e
movaps 0x3d98ec(%rip), %xmm1   # 0x518930
movq -0x8(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x3d98ea(%rip), %xmm1   # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x3d9cfb(%rip), %xmm1   # 0x518d68
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x3d9ce8(%rip), %xmm1   # 0x518d70
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x13f0a7
movq $0x64, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_uds_resize
static inline void condenseq_uds_resize(GtCondenseq *condenseq)
{
  if (condenseq->uds_nelems == condenseq->uds_allocated) {
    condenseq->uds_allocated =
      gt_condenseq_array_size_increase(condenseq->uds_allocated);
    condenseq->uniques = gt_realloc(condenseq->uniques,
                              (size_t) condenseq->uds_allocated *
                              sizeof (*condenseq->uniques));
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x98(%rax), %rax
movq (%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x13f3cb
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x13f030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rax
imulq $0x28, 0x90(%rax), %rsi
leaq 0x40bb8e(%rip), %rdx    # 0x54af44
movl $0x13f, %ecx            # imm = 0x13F
callq 0xe8540
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_lds_resize
static inline void condenseq_lds_resize(GtCondenseq *condenseq)
{
  if (condenseq->lds_nelems == condenseq->lds_allocated) {
    condenseq->lds_allocated =
      gt_condenseq_array_size_increase(condenseq->lds_allocated);
    condenseq->links = gt_realloc(condenseq->links,
                            (size_t) condenseq->lds_allocated *
                            sizeof (*condenseq->links));
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x70(%rax), %rax
movq (%rsp), %rcx
cmpq 0x68(%rcx), %rax
jne 0x13f62f
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x13f030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x68(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rsp), %rax
movq 0x68(%rax), %rsi
shlq $0x5, %rsi
leaq 0x40b92a(%rip), %rdx    # 0x54af44
movl $0x14a, %ecx            # imm = 0x14A
callq 0xe8540
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x140357
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x83ee0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x192b0
cmpq $0x1, %rax
jbe 0x140355
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
movl $0x2e, %esi
callq 0x197d0
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x140355
movq (%rsp), %rax
movb $0x0, (%rax)
jmp 0x140357
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1403c2
movq 0x4fbc0f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d5c78(%rip), %rsi    # 0x516013
leaq 0x40ab77(%rip), %rdx    # 0x54af19
leaq 0x40afee(%rip), %rcx    # 0x54b397
leaq 0x40ab94(%rip), %r8     # 0x54af44
movl $0x269, %r9d            # imm = 0x269
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1403c4
movq 0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1403f4
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11d510
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x452da7(%rip), %rsi    # 0x593196
callq 0x11d550
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x140425
movq 0x38(%rsp), %rax
cmpq $0x0, 0x98(%rax)
ja 0x14045d
movq 0x4fbb74(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d5bdd(%rip), %rsi    # 0x516013
leaq 0x40af79(%rip), %rdx    # 0x54b3b6
leaq 0x40af99(%rip), %rcx    # 0x54b3dd
leaq 0x40aaf9(%rip), %r8     # 0x54af44
movl $0x28b, %r9d            # imm = 0x28B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x14045f
movq $-0x1, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x1404c1
cmpq $0x1, 0x10(%rsp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x1, 0x8(%rsp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1404c1
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x1404cb
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1404cb
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x140507
movq 0x4fbac0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d7b3b(%rip), %rsi    # 0x518025
leaq 0x40aa53(%rip), %rdx    # 0x54af44
movl $0x28d, %ecx            # imm = 0x28D
movb $0x0, %al
callq 0x199f0
movl $0x1, %edi
callq 0x19890
jmp 0x140509
movq 0x20(%rsp), %rax
addq 0x18(%rsp), %rax
sarq %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
subq 0x20(%rsp), %rax
cmpq $0x1, %rax
jle 0x140572
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x10(%rcx), %rcx
imulq $0x28, 0x28(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x18(%rcx), %rax
jae 0x140554
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x14055e
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq 0x18(%rsp), %rax
sarq %rax
movq %rax, 0x28(%rsp)
jmp 0x14051b
cmpq $-0x1, 0x20(%rsp)
jle 0x1405a3
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
imulq $0x28, 0x28(%rsp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
cmpq 0x30(%rsp), %rax
ja 0x1405a3
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1405b4
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x13e420
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x80(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x140d36
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x196a20
movq %rax, 0x20(%rsp)
jmp 0x140d3f
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_links_position_binsearch
static GtUword condenseq_links_position_binsearch(const GtCondenseq *condenseq,
                                                  GtUword position)
{
  GtWord idx, low, high;
  gt_assert(condenseq && condenseq->lds_nelems > 0);
  low = (GtWord) -1;
  gt_safe_assign(high, condenseq->lds_nelems);
  idx = GT_DIV2(low + high);
  while (high - low > (GtWord) 1) {
    if (position < condenseq->links[idx].orig_startpos) {
      high = idx;
    }
    else {
      low = idx;
    }
    idx = GT_DIV2(low + high);
  }
  if (low > (GtWord) -1 && condenseq->links[idx].orig_startpos <= position)
    return (GtUword) idx;
  return condenseq->lds_nelems;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x140d72
movq 0x38(%rsp), %rax
cmpq $0x0, 0x70(%rax)
ja 0x140daa
movq 0x4fb227(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d5290(%rip), %rsi    # 0x516013
leaq 0x40ab48(%rip), %rdx    # 0x54b8d2
leaq 0x40ab68(%rip), %rcx    # 0x54b8f9
leaq 0x40a1ac(%rip), %r8     # 0x54af44
movl $0x275, %r9d            # imm = 0x275
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x140dac
movq $-0x1, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x140e0b
cmpq $0x1, 0x10(%rsp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x1, 0x8(%rsp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x140e0b
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x140e15
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0x140e15
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x140e51
movq 0x4fb176(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d71f1(%rip), %rsi    # 0x518025
leaq 0x40a109(%rip), %rdx    # 0x54af44
movl $0x277, %ecx            # imm = 0x277
movb $0x0, %al
callq 0x199f0
movl $0x1, %edi
callq 0x19890
jmp 0x140e53
movq 0x20(%rsp), %rax
addq 0x18(%rsp), %rax
sarq %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
subq 0x20(%rsp), %rax
cmpq $0x1, %rax
jle 0x140ebf
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x28(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jae 0x140ea1
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x140eab
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq 0x18(%rsp), %rax
sarq %rax
movq %rax, 0x28(%rsp)
jmp 0x140e65
cmpq $-0x1, 0x20(%rsp)
jle 0x140ef3
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq 0x30(%rsp), %rax
ja 0x140ef3
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x140f01
movq 0x38(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_unique_extract_encoded
static GtUword condenseq_unique_extract_encoded(const GtCondenseq *cs,
                                                GtUword id,
                                                GtUchar *buffer,
                                                GtUword frompos,
                                                GtUword topos)
{
  GtCondenseqUnique unique = cs->uniques[id];
  GtUword startoffset,
          startpos,
          uniquelength,
          targetlength,
          endpos;
  gt_assert(unique.orig_startpos <= frompos);
  startoffset = frompos - unique.orig_startpos;
  gt_assert(startoffset < unique.len);
  startpos = gt_encseq_seqstartpos(cs->unique_es, id) + startoffset;
  uniquelength = unique.len - startoffset;
  targetlength = topos - frompos + 1;
  if (uniquelength < targetlength)
    endpos = startpos + uniquelength - 1;
  else
    endpos = startpos + targetlength - 1;

  gt_encseq_extract_encoded(cs->unique_es, buffer, startpos, endpos);
  return endpos - startpos + 1;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rsi
imulq $0x28, 0x68(%rsp), %rax
addq %rax, %rsi
leaq 0x28(%rsp), %rdi
movl $0x28, %edx
callq 0x19610
movq 0x40(%rsp), %rax
cmpq 0x58(%rsp), %rax
jbe 0x140f92
movq 0x4fb03f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d50a8(%rip), %rsi    # 0x516013
leaq 0x40a9aa(%rip), %rdx    # 0x54b91c
leaq 0x40a9c3(%rip), %rcx    # 0x54b93c
leaq 0x409fc4(%rip), %r8     # 0x54af44
movl $0x2a9, %r9d            # imm = 0x2A9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x140f94
movq 0x58(%rsp), %rax
subq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x48(%rsp), %ecx
cmpq %rcx, %rax
jb 0x140fe9
movq 0x4fafe8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d5051(%rip), %rsi    # 0x516013
leaq 0x40a994(%rip), %rdx    # 0x54b95d
leaq 0x40a96c(%rip), %rcx    # 0x54b93c
leaq 0x409f6d(%rip), %r8     # 0x54af44
movl $0x2ab, %r9d            # imm = 0x2AB
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x140feb
movq 0x70(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0xb0530
addq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x48(%rsp), %eax
subq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
subq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x141049
movq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, (%rsp)
jmp 0x14105b
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
subq $0x1, %rax
movq %rax, (%rsp)
movq 0x70(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x60(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rsp), %rcx
callq 0xac280
movq (%rsp), %rax
subq 0x18(%rsp), %rax
addq $0x1, %rax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x13e470
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x80(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1412fe
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x13e470
subq $0x2, %rax
movq %rax, 0x8(%rsp)
jmp 0x141310
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
addq $0x1, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1405c0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %cl, %al
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
jbe 0x1413b0
movq 0x4fac21(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d4c8a(%rip), %rsi    # 0x516013
leaq 0x405bd4(%rip), %rdx    # 0x546f64
leaq 0x40a1bd(%rip), %rcx    # 0x54b554
leaq 0x409ba6(%rip), %r8     # 0x54af44
movl $0x355, %r9d            # imm = 0x355
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1413b2
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x1405c0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1413e7
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
cmpq 0x20(%rsp), %rax
jae 0x141424
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x20(%rsp), %rsi
shlq $0x0, %rsi
leaq 0x409b44(%rip), %rdx    # 0x54af44
movl $0x359, %ecx            # imm = 0x359
callq 0xe8540
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x1414ab
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jne 0x14146f
movb 0x2f(%rsp), %dl
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x141499
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x7f7b0
movb %al, %dl
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x14149b
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x14143b
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x13e470
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x80(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x14151e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x13e470
subq $0x2, %rax
movq %rax, 0x8(%rsp)
jmp 0x141530
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
addq $0x1, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x141340
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq %r8, 0x78(%rsp)
movl $0x0, 0x74(%rsp)
movq $0x1, 0x68(%rsp)
movq 0x98(%rsp), %rax
movq 0x10(%rax), %rsi
imulq $0x28, 0x90(%rsp), %rax
addq %rax, %rsi
leaq 0x30(%rsp), %rdi
movl $0x28, %edx
callq 0x19610
movq 0x98(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x13e420
movq %rax, 0x58(%rsp)
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq *%rax
movl %eax, 0x74(%rsp)
movq $0x0, 0x60(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x74(%rsp)
movb %al, 0x7(%rsp)
jne 0x141622
movq 0x60(%rsp), %rax
cmpq 0x40(%rsp), %rax
setb %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x14162f
jmp 0x1416d4
movq 0x30(%rsp), %rax
movq 0x60(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x13e420
movq %rax, 0x58(%rsp)
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq *%rax
movl %eax, 0x74(%rsp)
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x141604
cmpl $0x0, 0x74(%rsp)
jne 0x1416ea
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x1416f7
movslq 0x74(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0xa5080
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x98(%rcx), %rax
jae 0x1427ae
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
imulq $0x28, 0x8(%rsp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
movl %eax, %esi
callq 0xa50a0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x14276b
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0xa5080
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x14281e
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, %esi
callq 0xa50a0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1427db
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
callq 0xa5080
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x14292d
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x15b1f0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x15c340
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movaps 0x3d608b(%rip), %xmm3   # 0x518930
movq 0x8(%rsp), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x3d6089(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x10(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x3d7f4d(%rip), %xmm1   # 0x51a838
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
movsd 0x3d646a(%rip), %xmm1   # 0x518d70
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rsi
callq 0xa50a0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x14284c
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x1429a5
movq 0x4f962c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d3695(%rip), %rsi    # 0x516013
leaq 0x408594(%rip), %rdx    # 0x54af19
leaq 0x408c7e(%rip), %rcx    # 0x54b60a
leaq 0x4085b1(%rip), %r8     # 0x54af44
movl $0x4a4, %r9d            # imm = 0x4A4
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1429a7
jmp 0x1429a9
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
cmpq 0x98(%rcx), %rax
jb 0x1429f4
movq 0x4f95dd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3d3646(%rip), %rsi    # 0x516013
leaq 0x40893f(%rip), %rdx    # 0x54b313
leaq 0x408c2f(%rip), %rcx    # 0x54b60a
leaq 0x408562(%rip), %r8     # 0x54af44
movl $0x4a5, %r9d            # imm = 0x4A5
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1429f6
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rsi
imulq $0x28, 0x48(%rsp), %rax
addq %rax, %rsi
leaq 0x8(%rsp), %rdi
movl $0x28, %edx
callq 0x19610
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x13e420
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x13e470
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rcx
subq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
subq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq $0x0, -0x20(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
jae 0x142b89
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x18(%rsp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
cmpl -0xc(%rsp), %eax
jb 0x142b77
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x142b79
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x142b3b
movq -0x20(%rsp), %rax
retq
nop