LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_create
GtSequenceBuffer*
gt_sequence_buffer_create(const GtSequenceBufferClass *sic)
{
  GtSequenceBuffer *si;
  gt_assert(sic && sic->size);
  si = gt_calloc(1, sic->size);
  si->c_class = sic;
  si->pvt = gt_calloc(1, sizeof (GtSequenceBufferMembers));
  return si;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5e64e
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x5e64e
leaq 0x7da86(%rip), %r14     # 0xdc095
pushq $0x1
popq %r15
pushq $0x25
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x27
popq %rcx
movl $0x6088, %esi           # imm = 0x6088
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xcf963(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6ba07(%rip), %rsi     # 0xca066
leaq 0x7da04(%rip), %rdx     # 0xdc06a
leaq 0x7da0e(%rip), %rcx     # 0xdc07b
leaq 0x7da21(%rip), %r8      # 0xdc095
pushq $0x24
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_delete
void gt_sequence_buffer_delete(GtSequenceBuffer *si)
{
  if (!si) return;
  if (si->pvt->reference_count) {
    si->pvt->reference_count--;
    return;
  }
  gt_assert(si->c_class && si->c_class->free);
  si->c_class->free(si);
  gt_free(si->pvt);
  gt_free(si);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5e6a4
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x5e6ac
decq %rcx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x5e6ed
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x5e6ed
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x7d9c8(%rip), %r14     # 0xdc095
pushq $0x34
popq %rdx
movq %r14, %rsi
callq 0xd249
pushq $0x35
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0xcf8c4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6b968(%rip), %rsi     # 0xca066
leaq 0x7d9ab(%rip), %rdx     # 0xdc0b0
leaq 0x7d9c5(%rip), %rcx     # 0xdc0d1
leaq 0x7d982(%rip), %r8      # 0xdc095
pushq $0x32
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_next
int gt_sequence_buffer_next(GtSequenceBuffer *sb, GtUchar *val,
                            GtError *err)
{
  GtSequenceBufferMembers *pvt;
  pvt = sb->pvt;
  if (pvt->nextread >= pvt->nextfree) {
    if (pvt->complete) {
      return 0;
    }
    if (pvt->descptr && pvt->nextread > 0)
      gt_desc_buffer_reset(pvt->descptr);
    if (gt_sequence_buffer_advance(sb, err) != 0) {
      return -1;
    }
    pvt->nextread = 0;
    if (pvt->nextfree == 0) {
      return 0;
    }
  }
  *val = pvt->outbuf[pvt->nextread++];
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %r12
movq 0x50(%r12), %rcx
cmpq 0x58(%r12), %rcx
jae 0x5ebbb
leaq 0x1(%rcx), %rax
movq %rax, 0x50(%r12)
movb 0x2079(%r12,%rcx), %al
movb %al, (%rbx)
pushq $0x1
jmp 0x5ebf6
xorl %eax, %eax
cmpb $0x0, 0x18(%r12)
jne 0x5ebf7
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%r12), %rdi
testq %rdi, %rdi
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x5ebe5
callq 0x83aef
movq %r15, %rdi
movq %r14, %rsi
callq 0x5eb38
testl %eax, %eax
je 0x5ec03
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
andq $0x0, 0x50(%r12)
xorl %eax, %eax
cmpq $0x0, 0x58(%r12)
je 0x5ebf7
xorl %ecx, %ecx
jmp 0x5eba4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_next_with_original_raw
int gt_sequence_buffer_next_with_original_raw(GtSequenceBuffer *sb,
                                              GtUchar *val, char *orig,
                                              GtError *err)
{
  GtSequenceBufferMembers *pvt;
  pvt = sb->pvt;
  if (pvt->nextread >= pvt->nextfree) {
    if (pvt->complete) {
      return 0;
    }
    if (pvt->descptr && pvt->nextread > 0)
      gt_desc_buffer_reset(pvt->descptr);
    if (gt_sequence_buffer_advance(sb, err) != 0) {
      return -1;
    }
    pvt->nextread = 0;
    if (pvt->nextfree == 0) {
      return 0;
    }
  }
  *val = pvt->outbuf[pvt->nextread];
  *orig = pvt->outbuforig[pvt->nextread];
  pvt->nextread++;
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %r13
movq 0x50(%r13), %rcx
cmpq 0x58(%r13), %rcx
jae 0x5ec58
movb 0x2079(%r13,%rcx), %al
movb %al, (%r14)
movq 0x50(%r13), %rax
movb 0x4079(%r13,%rax), %al
movb %al, (%rbx)
incq 0x50(%r13)
pushq $0x1
jmp 0x5ec8e
xorl %eax, %eax
cmpb $0x0, 0x18(%r13)
jne 0x5ec8f
movq %rdi, %r12
movq 0x20(%r13), %rdi
testq %rdi, %rdi
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x5ec7d
callq 0x83aef
movq %r12, %rdi
movq %r15, %rsi
callq 0x5eb38
testl %eax, %eax
je 0x5ec99
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
andq $0x0, 0x50(%r13)
xorl %eax, %eax
cmpq $0x0, 0x58(%r13)
je 0x5ec8f
xorl %ecx, %ecx
jmp 0x5ec37
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_dust.c
// Function: gt_dust_masker_new
GtDustMasker* gt_dust_masker_new(bool echo, GtUword windowsize,
                                 double threshold,
                                 GtUword linker)
{
  GtDustMasker *dust_masker = gt_calloc(1, sizeof *dust_masker);
  dust_masker->echo = echo;
  dust_masker->windowsize = windowsize;
  dust_masker->threshold = threshold;
  dust_masker->linker = linker;

  dust_masker->buf_size = windowsize + linker;
  dust_masker->buf = gt_calloc(dust_masker->buf_size,
                               sizeof *(dust_masker->buf));
  dust_masker->buf_initialized = false;
  dust_masker->buf_readpos = 0;
  dust_masker->buf_insertpos = 0;
  dust_masker->buf_remaining = 0;

  dust_masker->nuc_val1 = 0;
  dust_masker->nuc_val2 = 0;

  dust_masker->rv = 0;
  dust_masker->rw = 0;
  dust_masker->L_param = 0;
  dust_masker->w_queue = gt_inl_queue_new(windowsize);

  dust_masker->total_length = 0;
  dust_masker->current_length = 0;
  dust_masker->current_pos_total = 0;
  dust_masker->current_pos_local = 0;

  dust_masker->last_seq_start = 0;

  GT_INITARRAY(&dust_masker->masked_regions,GtDustRange);
  dust_masker->mask_length = 0;
  dust_masker->next_mask = 0;
  dust_masker->current_is_masked = false;
  dust_masker->current_region_index = 0;

  dust_masker->masking_done = false;

  return dust_masker;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x7d429(%rip), %r12     # 0xdc3ea
pushq $0x1
popq %rdi
pushq $0x5f
popq %rcx
movl $0x3d8, %esi            # imm = 0x3D8
movq %r12, %rdx
callq 0xce9a
movq %rax, %r14
movb %bpl, 0x3b8(%rax)
movq %rbx, 0x3c0(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x3d0(%rax)
movq %r15, 0x3c8(%rax)
addq %rbx, %r15
movq %r15, 0x28(%rax)
pushq $0x20
popq %rsi
pushq $0x67
popq %rcx
movq %r15, %rdi
movq %r12, %rdx
callq 0xce9a
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
andw $0x0, 0x30(%r14)
andq $0x0, 0x34(%r14)
andq $0x0, 0x340(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
andq $0x0, 0x20(%r14)
movq %rbx, %rdi
callq 0x5f094
movq %rax, 0x348(%r14)
andq $0x0, 0x3b0(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x350(%r14)
movups %xmm0, 0x360(%r14)
movups %xmm0, 0x370(%r14)
movups %xmm0, 0x37a(%r14)
movups %xmm0, 0x390(%r14)
andq $0x0, 0x3a0(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/queue-inline.h
// Function: gt_inl_queue_new
static inline GtInl_Queue *gt_inl_queue_new(GtUword queuesize)
{
  GtInl_Queue *q;

  q = gt_malloc(sizeof (*q));
  gt_assert(queuesize > 0);
  q->queuespace = gt_malloc(sizeof (*q->queuespace) * queuesize);
  q->noofelements = 0;
  q->queuesize = queuesize;
  q->dequeueindex = q->enqueueindex = queuesize - 1;
  return q;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7d3c3(%rip), %rsi     # 0xdc465
pushq $0x28
popq %rdi
pushq $0x33
popq %rdx
callq 0xccb0
testq %rbx, %rbx
je 0x5f0e9
movq %rax, %r14
leaq 0x7d3a9(%rip), %rsi     # 0xdc465
pushq $0x35
popq %rdx
movq %rbx, %rdi
callq 0xccb0
movq %rax, (%r14)
andq $0x0, 0x20(%r14)
movq %rbx, 0x18(%r14)
decq %rbx
movq %rbx, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xceec8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6af6c(%rip), %rsi     # 0xca066
leaq 0x7d3bd(%rip), %rdx     # 0xdc4be
leaq 0x7d3c4(%rip), %rcx     # 0xdc4cc
leaq 0x7d356(%rip), %r8      # 0xdc465
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_dust.c
// Function: gt_dust_masker_delete
void gt_dust_masker_delete(GtDustMasker *dust_masker)
{
  if (dust_masker) {
    gt_free(dust_masker->buf);
    gt_inl_queue_delete(dust_masker->w_queue);
    GT_FREEARRAY(&dust_masker->masked_regions,GtDustRange);
    gt_free(dust_masker);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x5f196
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x7d2b5(%rip), %rsi     # 0xdc3ea
movl $0x8a, %edx
callq 0xd249
movq 0x348(%rbx), %rdi
callq 0x5f197
movq 0x390(%rbx), %rdi
testq %rdi, %rdi
je 0x5f17b
leaq 0x390(%rbx), %r14
leaq 0x7d285(%rip), %rsi     # 0xdc3ea
movl $0x8c, %edx
callq 0xd249
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x7d268(%rip), %rsi     # 0xdc3ea
movq %rbx, %rdi
movl $0x8d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/queue-inline.h
// Function: gt_inl_queue_get_at_index
static inline GtInl_Queueelem gt_inl_queue_get_at_index(GtInl_Queue *q,
                                                        GtUword n)
{
  GtUword idx;
  gt_assert(q != NULL && q->noofelements > 0 && n < q->noofelements);

  if (n <= q->dequeueindex)
  {
    idx = q->dequeueindex - n;
  } else
  {
    idx= q->queuesize + q->dequeueindex - n;
  }
  return q->queuespace[idx];
}

// Assembly:
testq %rdi, %rdi
je 0x5fc44
cmpq %rsi, 0x20(%rdi)
jbe 0x5fc44
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jae 0x5fc3a
addq 0x18(%rdi), %rax
subq %rsi, %rax
movq (%rdi), %rcx
movb (%rcx,%rax), %al
retq
pushq %rax
movq 0xce36c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6a410(%rip), %rsi     # 0xca066
leaq 0x7c8f2(%rip), %rdx     # 0xdc54f
leaq 0x7c923(%rip), %rcx     # 0xdc587
leaq 0x7c7fa(%rip), %r8      # 0xdc465
movl $0xad, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_embl.c
// Function: gt_sequence_buffer_embl_free
static void gt_sequence_buffer_embl_free(GtSequenceBuffer *sb)
{
  GtSequenceBufferEMBL *sbe = gt_sequence_buffer_embl_cast(sb);
  if (sb->pvt->inputstream)
    gt_file_delete(sb->pvt->inputstream);
  gt_str_delete(sbe->headerbuffer);
  gt_str_delete(sbe->overflowbuffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xcc42b(%rip), %rdi     # 0x12c7c8
movq %r14, %rsi
callq 0x5e96e
movq %rax, %rbx
movq 0x8(%r14), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x603ba
callq 0x548ae
movq 0x10(%rbx), %rdi
callq 0x152db
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x152db
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_embl.c
// Function: gt_sequence_buffer_embl_new
GtSequenceBuffer* gt_sequence_buffer_embl_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferEMBL *sbe;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_embl_class());
  sbe = gt_sequence_buffer_embl_cast(sb);
  sb->pvt->filenametab = sequences;
  sbe->headerbuffer = gt_str_new();
  sbe->overflowbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sb->pvt->linenum = 0;
  sbe->firstoverallentry = true;
  sbe->firstentryinfile = true;
  sbe->desc_spacer_was_set = false;
  sbe->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xcc3d6(%rip), %r14     # 0x12c7c8
movq %r14, %rdi
callq 0x5e5f0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e96e
movq %rax, %r14
movq 0x8(%r15), %rax
movq %rbx, 0x70(%rax)
callq 0x13d5c
movq %rax, 0x10(%r14)
callq 0x13d5c
movq %rax, 0x18(%r14)
movq 0x8(%r15), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movw $0x101, 0x21(%r14)      # imm = 0x101
movb $0x1, 0x20(%r14)
movb $0x0, 0x24(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
andq $0x0, 0x60(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_inline.h
// Function: process_char
static inline int process_char(GtSequenceBuffer *sb,
                                            GtUword currentoutpos,
                                            unsigned char cc,
                                            GtError *err)
{
  GtSequenceBufferMembers *pvt;
  unsigned char charcode;
  pvt = sb->pvt;
  if (pvt->symbolmap != NULL) {
    charcode = pvt->symbolmap[(unsigned int) cc];
    if (charcode == GT_UNDEFCHAR) {
      gt_error_set(err, "illegal character '%c': file \"%s\", line "GT_LLU"",
                        cc,
                        gt_str_array_get(pvt->filenametab,
                                         (GtUword) pvt->filenum),
                        (GtUint64) pvt->linenum);
      return -2;
    }
    if (GT_ISSPECIAL((GtUchar) charcode)) {
      pvt->lastspeciallength++;
    } else {
      if (pvt->lastspeciallength > 0)
        pvt->lastspeciallength = 0;
      if (pvt->chardisttab != NULL)
        pvt->chardisttab[(int) charcode]++;
    }
    pvt->outbuf[currentoutpos] = charcode;
  } else
    pvt->outbuf[currentoutpos] = cc;
  pvt->outbuforig[currentoutpos] = cc;
  pvt->counter++;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq 0x8(%rdi), %r15
movq 0x6080(%r15), %rcx
movl %edx, %eax
testq %rcx, %rcx
je 0x604d9
movzbl %dl, %r14d
movzbl (%rcx,%r14), %eax
cmpq $0xfd, %rax
jne 0x604ae
movq 0x70(%r15), %rdi
movl (%r15), %esi
callq 0x1555e
movq 0x8(%r15), %r8
leaq 0x7c1ca(%rip), %rsi     # 0xdc663
movq %rbx, %rdi
movl %r14d, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc007
pushq $-0x2
popq %rax
jmp 0x604ef
leaq 0x60(%r15), %rcx
movq 0x60(%r15), %rdi
cmpb $-0x3, %al
ja 0x604d3
testq %rdi, %rdi
je 0x604c3
andq $0x0, (%rcx)
movq 0x38(%r15), %rcx
testq %rcx, %rcx
je 0x604d9
leaq (%rcx,%rax,8), %rcx
movq (%rcx), %rdi
incq %rdi
movq %rdi, (%rcx)
movb %al, 0x2079(%r15,%rsi)
movb %dl, 0x4079(%r15,%rsi)
incq 0x68(%r15)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_inline.h
// Function: inlinebuf_getchar
static inline int inlinebuf_getchar(GtSequenceBuffer *sb,
                                                 GtFile *f)
{
  GtSequenceBufferMembers *pvt;
  pvt = sb->pvt;
  if (pvt->use_ungetchar) {
    pvt->use_ungetchar = false;
    return (int) pvt->ungetchar;
  } else {
    if (pvt->currentinpos >= pvt->currentfillpos) {
      pvt->currentfillpos = (GtUword) gt_file_xread(f, pvt->inbuf,
                                                          (size_t) INBUFSIZE);
      if (pvt->currentfillpos == 0)
         return EOF;
      pvt->currentinpos = 0;
    }
    pvt->ungetchar = pvt->inbuf[pvt->currentinpos++];
    return (int) pvt->ungetchar;
  }
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rbx
cmpb $0x1, 0x19(%rbx)
jne 0x6050a
movb $0x0, 0x19(%rbx)
movzbl 0x78(%rbx), %eax
jmp 0x60544
movq 0x48(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x60534
leaq 0x79(%rbx), %rax
movl $0x2000, %edx           # imm = 0x2000
movq %rsi, %rdi
movq %rax, %rsi
callq 0x54709
cltq
movq %rax, 0x40(%rbx)
testl %eax, %eax
je 0x60546
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%rbx)
movzbl 0x79(%rbx,%rax), %eax
movb %al, 0x78(%rbx)
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0x60544
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_fasta.c
// Function: gt_sequence_buffer_fasta_new
GtSequenceBuffer* gt_sequence_buffer_fasta_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferFasta *sbf;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_fasta_class());
  sbf = gt_sequence_buffer_fasta_cast(sb);
  sb->pvt->filenametab = sequences;
  sbf->headerbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sbf->firstoverallseq = true;
  sbf->firstseqinfile = true;
  sbf->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->complete = false;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xcbe91(%rip), %r14     # 0x12c7e8
movq %r14, %rdi
callq 0x5e5f0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e96e
movq %rax, %r14
movq 0x8(%r15), %rax
movq %rbx, 0x70(%rax)
callq 0x13d5c
movq %rax, 0x10(%r14)
movq 0x8(%r15), %rax
andl $0x0, (%rax)
movw $0x101, 0x19(%r14)      # imm = 0x101
movb $0x1, 0x1b(%r14)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
andq $0x0, 0x60(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_fastq.c
// Function: gt_sequence_buffer_fastq_get_file_index
static GtUword
gt_sequence_buffer_fastq_get_file_index(GtSequenceBuffer *sb)
{
  GtSequenceBufferFastQ *sbfq;
  gt_assert(sb);
  sbfq = gt_sequence_buffer_fastq_cast(sb);
  return gt_seq_iterator_fastq_get_file_index((GtSeqIteratorFastQ*)
                                              sbfq->seqit);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x60dbd
movq %rdi, %rsi
leaq 0xcba5a(%rip), %rdi     # 0x12c808
callq 0x5e96e
movq 0x10(%rax), %rdi
popq %rax
jmp 0x858c4
movq 0xcd1f4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x69298(%rip), %rsi     # 0xca066
leaq 0x7b316(%rip), %rdx     # 0xdc0eb
leaq 0x7ba49(%rip), %rcx     # 0xdc825
leaq 0x7b9f8(%rip), %r8      # 0xdc7db
movl $0xcc, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_fastq.c
// Function: gt_sequence_buffer_fastq_new
GtSequenceBuffer* gt_sequence_buffer_fastq_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferFastQ *sbfq;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_fastq_class());
  sbfq = gt_sequence_buffer_fastq_cast(sb);
  sbfq->seqit = NULL;
  sbfq->sequences = sequences;
  sb->pvt->filenametab = sequences;
  sbfq->overflowbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xcb9d7(%rip), %r14     # 0x12c808
movq %r14, %rdi
callq 0x5e5f0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e96e
movq %rax, %r14
andq $0x0, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq 0x8(%r15), %rax
movq %rbx, 0x70(%rax)
callq 0x13d5c
movq %rax, 0x28(%r14)
movq 0x8(%r15), %rax
andl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
andq $0x0, 0x60(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: gt_sequence_buffer_gb_free
static void gt_sequence_buffer_gb_free(GtSequenceBuffer *sb)
{
  GtSequenceBufferGB *sbe = gt_sequence_buffer_gb_cast(sb);
  if (sb->pvt->inputstream)
    gt_file_delete(sb->pvt->inputstream);
  gt_str_delete(sbe->headerbuffer);
  gt_str_delete(sbe->overflowbuffer);
  gt_str_delete(sbe->keywordbuffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xcafe7(%rip), %rdi     # 0x12c828
movq %r14, %rsi
callq 0x5e96e
movq %rax, %rbx
movq 0x8(%r14), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x6185e
callq 0x548ae
movq 0x10(%rbx), %rdi
callq 0x152db
movq 0x18(%rbx), %rdi
callq 0x152db
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x152db
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: gt_sequence_buffer_gb_new
GtSequenceBuffer* gt_sequence_buffer_gb_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferGB *sbe;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_gb_class());
  sb->pvt->filenametab = sequences;
  sb->pvt->filenum = 0;
  sb->pvt->linenum = 0;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  sbe = gt_sequence_buffer_gb_cast(sb);
  sbe->headerbuffer = gt_str_new();
  sbe->overflowbuffer = gt_str_new();
  sbe->keywordbuffer = gt_str_new();
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xcaf6e(%rip), %r14     # 0x12c828
movq %r14, %rdi
callq 0x5e5f0
movq %rax, %r15
movq 0x8(%rax), %rax
movq %rbx, 0x70(%rax)
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
andq $0x0, 0x60(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e96e
movq %rax, %rbx
callq 0x13d5c
movq %rax, 0x10(%rbx)
callq 0x13d5c
movq %rax, 0x18(%rbx)
callq 0x13d5c
movq %rax, 0x20(%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: get_keyword
static inline int get_keyword(GtSequenceBuffer *sb, GtStr *kwbuf,
                              GtUword *currentfileread)
{
  int currentchar;
  currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
  if (currentchar == EOF)
      return EOF;
  (*currentfileread)++;
  while (currentchar != NEWLINESYMBOL && !isspace(currentchar)) {
    gt_str_append_char(kwbuf, currentchar);
    currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
    if (currentchar == EOF)
      return EOF;
    (*currentfileread)++;
  }
  inlinebuf_ungetchar(sb);
  (*currentfileread)--;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rsi
callq 0x61b2f
pushq $-0x1
popq %rbp
cmpl $-0x1, %eax
je 0x61a28
movl %eax, %r12d
incq (%rbx)
cmpl $0xa, %r12d
je 0x61a1b
callq 0xb6e0
movq (%rax), %rax
movl %r12d, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x61a1b
movsbl %r12b, %esi
movq %r15, %rdi
callq 0x140b1
movq 0x8(%r14), %rax
movq 0x28(%rax), %rsi
movq %r14, %rdi
callq 0x61b2f
movl %eax, %r12d
cmpl $-0x1, %eax
jne 0x619da
jmp 0x61a28
movq %r14, %rdi
callq 0x61b85
decq (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: eat_line
static inline int eat_line(GtSequenceBuffer *sb,
                           GtUword *currentfileread)
{
  int currentchar;
  do {
    currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
    if (currentchar == EOF)
      return EOF;
    (*currentfileread)++;
  } while (currentchar != NEWLINESYMBOL);
  inlinebuf_ungetchar(sb);
  (*currentfileread)--;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %rbp
movq 0x8(%r14), %rax
movq 0x28(%rax), %rsi
movq %r14, %rdi
callq 0x61b2f
cmpl $-0x1, %eax
je 0x61a6a
incq (%rbx)
cmpl $0xa, %eax
jne 0x61a40
movq %r14, %rdi
callq 0x61b85
decq (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: eat_whitespace
static inline int eat_whitespace(GtSequenceBuffer *sb,
                                 GtUword *currentfileread)
{
  int currentchar;
  do {
    currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
    if (currentchar == EOF)
      return EOF;
    (*currentfileread)++;
  } while (currentchar != NEWLINESYMBOL && isspace(currentchar));
  inlinebuf_ungetchar(sb);
  (*currentfileread)--;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %rbp
movq 0x8(%r14), %rax
movq 0x28(%rax), %rsi
movq %r14, %rdi
callq 0x61b2f
cmpl $-0x1, %eax
je 0x61ac0
movl %eax, %r15d
incq (%rbx)
cmpl $0xa, %eax
je 0x61ab3
callq 0xb6e0
movq (%rax), %rax
movl %r15d, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x61a81
movq %r14, %rdi
callq 0x61b85
decq (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: get_description
static inline int get_description(GtSequenceBuffer *sb,
                                  GtUword *currentfileread)
{
  int currentchar;
  currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
  if (currentchar == EOF)
      return EOF;
  (*currentfileread)++;
  while (currentchar != NEWLINESYMBOL) {
    if (sb->pvt->descptr)
      gt_desc_buffer_append_char(sb->pvt->descptr, currentchar);
    currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
    if (currentchar == EOF)
      return EOF;
    (*currentfileread)++;
  }
  inlinebuf_ungetchar(sb);
  (*currentfileread)--;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rsi
callq 0x61b2f
pushq $-0x1
popq %rbp
cmpl $-0x1, %eax
je 0x61b28
incq (%rbx)
cmpl $0xa, %eax
je 0x61b1b
movq 0x8(%r14), %rcx
movq 0x20(%rcx), %rdi
testq %rdi, %rdi
je 0x61b0d
movsbl %al, %esi
callq 0x8396b
movq 0x8(%r14), %rcx
movq 0x28(%rcx), %rsi
movq %r14, %rdi
callq 0x61b2f
jmp 0x61ae7
movq %r14, %rdi
callq 0x61b85
decq (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_add
void gt_string_distri_add(GtStringDistri *sd, const char *key)
{
  GtUword *valueptr;
  gt_assert(sd && key);
  valueptr = cstr_ul_gt_hashmap_get(sd->hashdist, key);
  if (!valueptr) {
    cstr_ul_gt_hashmap_add(sd->hashdist, gt_cstr_dup(key), 1);
  }
  else
    (*valueptr)++;
  sd->num_of_occurrences++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x61d30
movq %rsi, %r14
testq %rsi, %rsi
je 0x61d30
movq %rdi, %rbx
movq (%rdi), %rdi
movq %r14, %rsi
callq 0x61d66
testq %rax, %rax
je 0x61ce9
incq (%rax)
jmp 0x61d22
movq (%rbx), %r15
movq %r14, %rdi
callq 0x4f8ae
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq $0x1, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x5697b
testl %eax, %eax
jne 0x61d22
movq 0x8(%rsp), %rax
movq $0x1, 0x8(%rax)
incq 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xcc281(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x68325(%rip), %rsi     # 0xca066
leaq 0x7ae0a(%rip), %rdx     # 0xdcb52
leaq 0x7ae0d(%rip), %rcx     # 0xdcb5c
leaq 0x7ade3(%rip), %r8      # 0xdcb39
pushq $0x2f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_sub
void gt_string_distri_sub(GtStringDistri *sd, const char *key)
{
  GtUword *valueptr;
  gt_assert(sd && key && gt_string_distri_get(sd, key) &&
            sd->num_of_occurrences);
  valueptr = cstr_ul_gt_hashmap_get(sd->hashdist, key);
  (*valueptr)--;
  if (!(*valueptr))
    cstr_ul_gt_hashmap_remove(sd->hashdist, key);
  sd->num_of_occurrences--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x61dd4
movq %rsi, %r14
testq %rsi, %rsi
je 0x61dd4
movq %rdi, %rbx
movq %r14, %rsi
callq 0x61e0a
testq %rax, %rax
je 0x61dd4
cmpq $0x0, 0x8(%rbx)
je 0x61dd4
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x61d66
decq (%rax)
jne 0x61dc8
movq (%rbx), %rdi
movq %rsp, %rsi
movq %r14, (%rsi)
callq 0x56a16
decq 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcc1dd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x68281(%rip), %rsi     # 0xca066
leaq 0x7ad85(%rip), %rdx     # 0xdcb71
leaq 0x7adc3(%rip), %rcx     # 0xdcbb6
leaq 0x7ad3f(%rip), %r8      # 0xdcb39
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_get
GtUword gt_string_distri_get(const GtStringDistri *sd, const char *key)
{
  GtUword *valueptr;
  gt_assert(sd && key);
  if ((valueptr = cstr_ul_gt_hashmap_get(sd->hashdist, key)))
    return *valueptr;
  else
    return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x61e2b
testq %rsi, %rsi
je 0x61e2b
movq (%rdi), %rdi
callq 0x61d66
testq %rax, %rax
je 0x61e27
movq (%rax), %rax
jmp 0x61e29
xorl %eax, %eax
popq %rcx
retq
movq 0xcc186(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6822a(%rip), %rsi     # 0xca066
leaq 0x7ad0f(%rip), %rdx     # 0xdcb52
leaq 0x7ad81(%rip), %rcx     # 0xdcbcb
leaq 0x7ace8(%rip), %r8      # 0xdcb39
pushq $0x48
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_get_prob
double gt_string_distri_get_prob(const GtStringDistri *sd, const char *key)
{
  GtUword occ;
  gt_assert(sd && key);
  if ((occ = gt_string_distri_get(sd, key)))
    return (double) occ / sd->num_of_occurrences;
  return 0.0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x61ec7
testq %rsi, %rsi
je 0x61ec7
movq %rdi, %rbx
callq 0x61e0a
testq %rax, %rax
je 0x61ec1
movq %rax, %xmm1
movq 0x685fa(%rip), %xmm2    # 0xca480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x685fe(%rip), %xmm3    # 0xca490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq 0x8(%rbx), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0x61ec5
xorpd %xmm0, %xmm0
popq %rbx
retq
movq 0xcc0ea(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6818e(%rip), %rsi     # 0xca066
leaq 0x7ac73(%rip), %rdx     # 0xdcb52
leaq 0x7acfa(%rip), %rcx     # 0xdcbe0
leaq 0x7ac4c(%rip), %r8      # 0xdcb39
pushq $0x52
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_foreach
void gt_string_distri_foreach(const GtStringDistri *sd,
                              GtStringDistriIterFunc func, void *data)
{
  StringDistriForeachInfo info;
  GT_UNUSED int rval;
  gt_assert(sd);
  if (sd->hashdist) {
    info.func = func;
    info.data = data;
    info.num_of_occurrences = sd->num_of_occurrences;
    rval = cstr_ul_gt_hashmap_foreach_in_default_order(
      sd->hashdist, string_distri_foreach_iterfunc, &info, NULL);
    gt_assert(!rval); /* string_distri_foreach_iterfunc() is sane */
  }
}

// Assembly:
subq $0x38, %rsp
testq %rdi, %rdi
je 0x61f54
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x61f4f
leaq 0x8(%rsp), %rcx
movq %rsi, (%rcx)
movq %rdx, 0x8(%rcx)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rcx)
leaq 0x20(%rsp), %rdx
movq %rcx, (%rdx)
leaq 0x80(%rip), %rax        # 0x61fb4
movq %rax, 0x8(%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x18e(%rip), %rsi       # 0x620d2
xorl %ecx, %ecx
callq 0x56bef
testl %eax, %eax
jne 0x61f7e
addq $0x38, %rsp
retq
movq 0xcc05d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x68101(%rip), %rsi     # 0xca066
leaq 0x7ac8e(%rip), %rdx     # 0xdcbfa
leaq 0x7ac8a(%rip), %rcx     # 0xdcbfd
leaq 0x7abbf(%rip), %r8      # 0xdcb39
pushq $0x70
jmp 0x61fa6
movq 0xcc033(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x680d7(%rip), %rsi     # 0xca066
leaq 0x68b51(%rip), %rdx     # 0xcaae7
leaq 0x7ac60(%rip), %rcx     # 0xdcbfd
leaq 0x7ab95(%rip), %r8      # 0xdcb39
pushq $0x77
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/string_distri.c
// Function: string_distri_foreach_iterfunc
static enum iterator_op
string_distri_foreach_iterfunc(char *key, GtUword occurrences, void *data,
                               GT_UNUSED GtError *err)
{
  StringDistriForeachInfo *info;
  gt_error_check(err);
  gt_assert(key && data);
  info = (StringDistriForeachInfo*) data;
  info->func(key, occurrences, (double) occurrences / info->num_of_occurrences,
             info->data);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x61fd7
movq %rcx, %rdi
callq 0xc103
testb %al, %al
jne 0x62065
testq %r15, %r15
je 0x6203b
testq %rbx, %rbx
je 0x6203b
movq %r14, %xmm1
movq 0x68492(%rip), %xmm2    # 0xca480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x68496(%rip), %xmm3    # 0xca490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq 0x10(%rbx), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0xcbf76(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6801a(%rip), %rsi     # 0xca066
leaq 0x7abe2(%rip), %rdx     # 0xdcc35
leaq 0x7abbc(%rip), %rcx     # 0xdcc16
leaq 0x7aad8(%rip), %r8      # 0xdcb39
pushq $0x64
jmp 0x6208d
movq 0xcbf4c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x67ff0(%rip), %rsi     # 0xca066
leaq 0x685dc(%rip), %rdx     # 0xca659
leaq 0x7ab92(%rip), %rcx     # 0xdcc16
leaq 0x7aaae(%rip), %r8      # 0xdcb39
pushq $0x63
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xbsd.c
// Function: gt_xflock_with_op
static void gt_xflock_with_op(int fd, short l_type)
{
  struct flock f;
  if (!getenv("GT_NO_FLOCK")) {
    memset(&f, 0, sizeof (f));
    f.l_type = l_type;
    if (fcntl(fd, F_SETLKW, &f)) {
      perror("cannot flock");
      exit(EXIT_FAILURE);
    }
  }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0x7ab40(%rip), %rdi     # 0xdcc41
callq 0xb7c0
testq %rax, %rax
jne 0x6212b
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movw %bp, (%rdx)
pushq $0x7
popq %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0xba20
testl %eax, %eax
jne 0x62132
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7ab14(%rip), %rdi     # 0xdcc4d
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xbzlib.c
// Function: gt_xbzopen
BZFILE* gt_xbzopen(const char *path, const char *mode)
{
  BZFILE* file;
  if (!(file = BZ2_bzopen(path, mode))) {
    fprintf(stderr, "BZ2_bzopen(): cannot open file '%s': %s\n", path,
            strerror(errno));
    exit(EXIT_FAILURE);
  }
  return file;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x79c97
testq %rax, %rax
je 0x62169
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcbe48(%rip), %rax     # 0x12dfb8
movq (%rax), %r14
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x7aad4(%rip), %rsi     # 0xdcc5a
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xbzlib.c
// Function: gt_xbzread
int gt_xbzread(BZFILE *file, void *buf, unsigned len)
{
  int rval;
  if ((rval = BZ2_bzread(file, buf, len)) == -1) {
    fprintf(stderr, "cannot read from compressed file\n");
    exit(EXIT_FAILURE);
  }
  return rval;
}

// Assembly:
pushq %rax
callq 0x79e35
cmpl $-0x1, %eax
je 0x621d4
popq %rcx
retq
movq 0xcbddd(%rip), %rax     # 0x12dfb8
movq (%rax), %rcx
leaq 0x7aaed(%rip), %rdi     # 0xdccd2
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
callq 0xbca0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xbzlib.c
// Function: gt_xbzwrite
void gt_xbzwrite(BZFILE *file, void *buf, unsigned len)
{
  gt_assert(buf);
  if (BZ2_bzwrite(file, buf, len) != len) {
    fprintf(stderr, "cannot write it compressed file\n");
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0x622a7
movl %edx, %ebx
callq 0x79e6f
cmpl %ebx, %eax
jne 0x622dd
popq %rbx
retq
movq 0xcbd0a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x67dae(%rip), %rsi     # 0xca066
leaq 0x72b19(%rip), %rdx     # 0xd4dd8
leaq 0x7aa2e(%rip), %rcx     # 0xdccf4
leaq 0x7aa33(%rip), %r8      # 0xdcd00
pushq $0x52
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0xcbcd4(%rip), %rax     # 0x12dfb8
movq (%rax), %rcx
leaq 0x7aa24(%rip), %rdi     # 0xdcd12
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0xbca0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xposix.c
// Function: gt_xfdopen
FILE* gt_xfdopen(int filedes, const char *mode)
{
  FILE *fp;
  if (!(fp = fdopen(filedes, mode))) {
    perror("cannot fdopen");
    exit(EXIT_FAILURE);
  }
  return fp;
}

// Assembly:
pushq %rax
callq 0xb6d0
testq %rax, %rax
je 0x62359
popq %rcx
retq
leaq 0x7a9f0(%rip), %rdi     # 0xdcd50
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xposix.c
// Function: gt_xglob
void gt_xglob(const char *pattern, int flags,
              int (*errfunc)(const char*, int), glob_t *pglob)
{
  int rval;
  errno = 0;
  if ((rval = glob(pattern, flags, errfunc, pglob))) {
    fprintf(stderr, "cannot glob: ");
    switch (rval) {
      case GLOB_NOSPACE:
        fprintf(stderr, "out of memory");
        break;
#ifdef GLOB_NOMATCH
      case GLOB_NOMATCH:
        fprintf(stderr, "pattern not found");
        break;
#endif
      default:
        fprintf(stderr, "reason unknown");
    }
    if (errno)
      fprintf(stderr, " (%s)\n", strerror(errno));
    else
      (void) fputc('\n', stderr);
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0xb060
movq %rax, %rbx
andl $0x0, (%rax)
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0xb590
testl %eax, %eax
jne 0x623e8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
movq 0xcbbc7(%rip), %r14     # 0x12dfb8
movq (%r14), %rcx
leaq 0x7a981(%rip), %rdi     # 0xdcd7c
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0xbca0
movq (%r14), %rcx
cmpl $0x3, %ebp
je 0x6241e
cmpl $0x1, %ebp
jne 0x62429
leaq 0x7a970(%rip), %rdi     # 0xdcd8a
pushq $0xd
jmp 0x62432
leaq 0x7a973(%rip), %rdi     # 0xdcd98
pushq $0x11
jmp 0x62432
leaq 0x7a97a(%rip), %rdi     # 0xdcdaa
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0xbca0
movl (%rbx), %edi
movq (%r14), %rbx
testl %edi, %edi
je 0x62465
callq 0xb1d0
leaq 0x74f5a(%rip), %rsi     # 0xd73aa
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0xb7d0
jmp 0x6245d
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xposix.c
// Function: gt_xopen
int gt_xopen(const char *path, int flags, mode_t mode)
{
  int fd;

  if ((fd = open(path, flags, mode)) == -1) {
    fprintf(stderr, "open(): cannot open file '%s': %s\n", path,
            strerror(errno));
    exit(EXIT_FAILURE);
  }

  return fd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0xbad0
cmpl $-0x1, %eax
je 0x6248d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcbb24(%rip), %rax     # 0x12dfb8
movq (%rax), %r14
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x6ab2b(%rip), %rsi     # 0xccfd5
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xposix.c
// Function: gt_xmkstemp
int gt_xmkstemp(char *temp)
{
  int fd;
  if ((fd = gt_mkstemp(temp)) == -1) {
    perror("cannot mkstemp");
    exit(EXIT_FAILURE);
  }
  return fd;
}

// Assembly:
pushq %rax
callq 0x838a8
cmpl $-0x1, %eax
je 0x62521
popq %rcx
retq
leaq 0x7a8ba(%rip), %rdi     # 0xdcde2
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xposix.c
// Function: gt_xmmap
void* gt_xmmap(void *addr, size_t len, int prot, int flags, int fd,
               off_t offset)
{
  void *map;
  if ((map = mmap(addr, len, prot, flags, fd, offset)) == MAP_FAILED) {
    perror("cannot mmap");
    exit(EXIT_FAILURE);
  }
  return map;
}

// Assembly:
pushq %rax
callq 0xb660
cmpq $-0x1, %rax
je 0x62543
popq %rcx
retq
leaq 0x7a8a7(%rip), %rdi     # 0xdcdf1
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xposix.c
// Function: gt_xsignal
void (*gt_xsignal(int sigcatch, void (*func)(int sigraised)))(int)
{
  void (*rval)(int);
  if ((rval = signal(sigcatch, func)) == SIG_ERR) {
    perror("cannot register signal");
    exit(EXIT_FAILURE);
  }
  return rval;
}

// Assembly:
pushq %rax
callq 0xb780
cmpq $-0x1, %rax
je 0x625a5
popq %rcx
retq
leaq 0x7a86c(%rip), %rdi     # 0xdce18
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xposix.c
// Function: gt_xtime
time_t gt_xtime(time_t *tloc)
{
  time_t t;
  if ((t = time(tloc)) == -1) {
    perror("cannot determine time");
    exit(EXIT_FAILURE);
  }
  return t;
}

// Assembly:
pushq %rax
callq 0xb5e0
cmpq $-0x1, %rax
je 0x62614
popq %rcx
retq
leaq 0x7a831(%rip), %rdi     # 0xdce4c
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xposix.c
// Function: gt_xwrite
void gt_xwrite(int d, const void *buf, size_t nbytes)
{
  size_t pos = 0;
  ssize_t rval;
  int error = 0;
  while (nbytes > pos) {
    rval = write(d, (char*) buf + pos, nbytes - pos);
    switch (rval) {
      case -1:
        if (errno == EINTR || errno == EAGAIN)
          continue;
        error = 1;
        break;
      case 0:
        errno = EPIPE;
        error = 1;
        break;
      default:
        pos += rval;
    }
    if (error)
      break;
  }
  if (error) {
    perror("cannot write to file descriptor");
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r13d, %r13d
movq %rbx, %r15
subq %r13, %r15
jbe 0x626c7
leaq (%r14,%r13), %r12
movl %ebp, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0xb200
cmpq $-0x1, %rax
jne 0x626bd
callq 0xb060
movl (%rax), %eax
cmpl $0x4, %eax
je 0x62697
cmpl $0xb, %eax
je 0x62697
jmp 0x626e1
testq %rax, %rax
je 0x626d6
addq %rax, %r13
jmp 0x6268b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb060
movl $0x20, (%rax)
leaq 0x7a792(%rip), %rdi     # 0xdce7a
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xzlib.c
// Function: gt_xgzopen
gzFile gt_xgzopen(const char *path, const char *mode)
{
  gzFile file;
  if (!(file = gzopen(path, mode))) {
    fprintf(stderr, "gzopen(): cannot open file '%s': %s\n", path,
            strerror(errno));
    exit(EXIT_FAILURE);
  }
  return file;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7a2ea
testq %rax, %rax
je 0x62711
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcb8a0(%rip), %rax     # 0x12dfb8
movq (%rax), %r14
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x7a76c(%rip), %rsi     # 0xdce9a
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xzlib.c
// Function: gt_xgzread
int gt_xgzread(gzFile file, void *buf, unsigned len)
{
  int errnum, rval;
  if ((rval = gzread(file, buf, len)) == -1) {
    fprintf(stderr, "cannot read from compressed file: %s\n",
            gzerror(file, &errnum));
    exit(EXIT_FAILURE);
  }
  return rval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7a714
cmpl $-0x1, %eax
je 0x62788
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcb829(%rip), %rax     # 0x12dfb8
movq (%rax), %r14
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x7a6ac
leaq 0x7a770(%rip), %rsi     # 0xdcf16
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xzlib.c
// Function: gt_xgzfputc
void gt_xgzfputc(int c, gzFile file)
{
  int errnum;
  if (gzputc(file, c) == -1) {
    fprintf(stderr, "cannot put character to compressed file: %s\n",
            gzerror(file, &errnum));
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %esi
movq %rbx, %rdi
callq 0x7b2fb
cmpl $-0x1, %eax
je 0x627d9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcb7d8(%rip), %rax     # 0x12dfb8
movq (%rax), %r14
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x7a6ac
leaq 0x7a6c8(%rip), %rsi     # 0xdcebf
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xzlib.c
// Function: gt_xgzfputs
void gt_xgzfputs(const char *str, gzFile file)
{
  int errnum;
  if (gzputs(file, str) == -1) {
    fprintf(stderr, "cannot put string to compressed file: %s\n",
            gzerror(file, &errnum));
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x7b44d
cmpl $-0x1, %eax
je 0x6282b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcb786(%rip), %rax     # 0x12dfb8
movq (%rax), %r14
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x7a6ac
leaq 0x7a6a3(%rip), %rsi     # 0xdceec
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/xzlib.c
// Function: gt_xgzwrite
void gt_xgzwrite(gzFile file, void *buf, unsigned len)
{
  int errnum;
  gt_assert(buf);
  if (gzwrite(file, buf, len) != len) {
    fprintf(stderr, "cannot write to compressed file: %s\n",
            gzerror(file, &errnum));
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x62882
movl %edx, %ebp
movq %rdi, %rbx
callq 0x7b12c
cmpl %ebp, %eax
jne 0x628b8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xcb72f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x677d3(%rip), %rsi     # 0xca066
leaq 0x7253e(%rip), %rdx     # 0xd4dd8
leaq 0x7a69b(%rip), %rcx     # 0xdcf3c
leaq 0x7a6a0(%rip), %r8      # 0xdcf48
pushq $0x4c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0xcb6f9(%rip), %rax     # 0x12dfb8
movq (%rax), %r14
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x7a6ac
leaq 0x7a683(%rip), %rsi     # 0xdcf59
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0