LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: inflateCodesUsed
unsigned long ZEXPORT inflateCodesUsed(z_streamp strm) {
    struct inflate_state FAR *state;
    if (inflateStateCheck(strm)) return (unsigned long)-1;
    state = (struct inflate_state FAR *)strm->state;
    return (unsigned long)(state->next - state->codes);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xa0909
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
jne 0xa2ccf
movq 0x38(%rbx), %rcx
movq 0x90(%rcx), %rax
subq %rcx, %rax
addq $-0x558, %rax           # imm = 0xFAA8
sarq $0x2, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_class_new
const GtCodonIteratorClass* gt_codon_iterator_class_new(size_t size,
                                        CodonIteratorFreeFunc free,
                                        CodonIteratorCurrentPosFunc current_pos,
                                        CodonIteratorLengthFunc length,
                                        CodonIteratorRewindFunc rewind,
                                        CodonIteratorNextFunc next)
{
  GtCodonIteratorClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->next = next;
  c_class->length = length;
  c_class->rewind = rewind;
  c_class->current_pos = current_pos;
  return c_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa3636
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbp
movl $0x30, %edi
callq 0x72274
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq %r15, 0x28(%rax)
movq %r12, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x21e08
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_create
GtCodonIterator* gt_codon_iterator_create(const GtCodonIteratorClass *cic)
{
  GtCodonIterator *ci;
  gt_assert(cic && cic->size);
  ci = gt_calloc(1, cic->size);
  ci->c_class = cic;
  ci->pvt = gt_calloc(1, sizeof (GtCodonIteratorMembers));
  return ci;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa3693
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xa3693
leaq 0x56875(%rip), %r14     # 0xf9ecc
movl $0x1, %edi
movq %r14, %rdx
movl $0x3a, %ecx
callq 0x359a6
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x20, %esi
movq %r14, %rdx
movl $0x3c, %ecx
callq 0x359a6
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x21e3f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_current_position
GtUword gt_codon_iterator_current_position(GtCodonIterator *ci)
{
  gt_assert(ci && ci->c_class);
  if (ci->c_class->current_pos)
    return ci->c_class->current_pos(ci);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xa36e6
movq (%rdi), %rax
testq %rax, %rax
je 0xa36e6
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xa36e3
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x21ee4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_length
GtUword gt_codon_iterator_length(GtCodonIterator *ci)
{
  gt_assert(ci && ci->c_class);
  if (ci->c_class->current_pos)
    return ci->c_class->length(ci);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xa3706
movq (%rdi), %rax
testq %rax, %rax
je 0xa3706
cmpq $0x0, 0x10(%rax)
je 0xa3703
jmpq *0x18(%rax)
xorl %eax, %eax
retq
pushq %rax
callq 0x21f1b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_next
GtCodonIteratorStatus gt_codon_iterator_next(GtCodonIterator *ci,
                                             char *n1, char *n2, char *n3,
                                             unsigned int *frame,
                                             GtError *err)
{
  gt_assert(ci && ci->c_class);
  if (ci->c_class->current_pos)
    return ci->c_class->next(ci, n1, n2, n3, frame, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xa3748
movq (%rdi), %rax
testq %rax, %rax
je 0xa3748
cmpq $0x0, 0x10(%rax)
je 0xa3745
movq 0x28(%rax), %rax
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x21f89
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_delete
void gt_codon_iterator_delete(GtCodonIterator *ci)
{
  if (!ci) return;
  gt_assert(ci->c_class);
  if (ci->c_class->free)
    ci->c_class->free(ci);
  gt_free(ci->pvt);
  gt_free(ci);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa379f
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xa37a7
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xa3770
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x56751(%rip), %r14     # 0xf9ecc
movq %r14, %rsi
movl $0x78, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x79, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x21fc0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator_simple.c
// Function: gt_codon_iterator_simple_class
const GtCodonIteratorClass* gt_codon_iterator_simple_class(void)
{
  static const GtCodonIteratorClass *cic = NULL;
  gt_class_alloc_lock_enter();
  if (!cic)
  {
    cic = gt_codon_iterator_class_new(sizeof (GtCodonIteratorSimple),
                                      NULL,
                                      gt_codon_iterator_simple_current_position,
                                      gt_codon_iterator_simple_length,
                                      gt_codon_iterator_simple_rewind,
                                      gt_codon_iterator_simple_next);
  }
  gt_class_alloc_lock_leave();
  return cic;
}

// Assembly:
pushq %rax
callq 0x72367
cmpq $0x0, 0xaf5a6(%rip)     # 0x152d60
jne 0xa37eb
leaq 0x36(%rip), %rdx        # 0xa37f9
leaq 0x43(%rip), %rcx        # 0xa380d
leaq 0x4f(%rip), %r8         # 0xa3820
leaq 0x55(%rip), %r9         # 0xa382d
movl $0x18, %edi
xorl %esi, %esi
callq 0xa35e4
movq %rax, 0xaf575(%rip)     # 0x152d60
callq 0x7237d
movq 0xaf569(%rip), %rax     # 0x152d60
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator_simple.c
// Function: gt_codon_iterator_simple_next
static GtCodonIteratorStatus gt_codon_iterator_simple_next(GtCodonIterator *ci,
                                                           char *n1,
                                                           char *n2,
                                                           char *n3,
                                                           unsigned int *frame,
                                                           GT_UNUSED GtError
                                                                           *err)
{
  GtCodonIteratorSimple *cis;
  gt_assert(n1 && n2 && n3 && frame);
  gt_error_check(err);
  if (ci->pvt->curpos+2 >= ci->pvt->length)
    return GT_CODON_ITERATOR_END;
  cis = gt_codon_iterator_simple_cast(ci);
  *n1 = *(cis->dnaseq+ci->pvt->curpos);
  *n2 = *(cis->dnaseq+ci->pvt->curpos+1);
  *n3 = *(cis->dnaseq+ci->pvt->curpos+2);
  *frame = ci->pvt->curpos % GT_CODON_LENGTH;
  ci->pvt->curpos++;
  return GT_CODON_ITERATOR_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %xmm0
movq %rsi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %r8, %xmm0
movq %rcx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0xa3933
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
testq %r9, %r9
je 0xa389c
movq %r9, %rdi
callq 0x34fea
testb %al, %al
jne 0xa3938
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %rdx
addq $0x2, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq (%rcx), %rdx
jae 0xa3929
callq 0xa37ac
movq %rax, %rdi
movq %r15, %rsi
callq 0xa3698
movq 0x10(%rax), %rcx
movq 0x8(%r15), %rdx
movq 0x8(%rdx), %rdx
movb (%rcx,%rdx), %cl
movb %cl, (%r13)
movq 0x10(%rax), %rcx
movq 0x8(%r15), %rdx
movq 0x8(%rdx), %rdx
movb 0x1(%rcx,%rdx), %cl
movb %cl, (%r12)
movq 0x10(%rax), %rax
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %rcx
movb 0x2(%rax,%rcx), %al
movb %al, (%r14)
movq 0x8(%r15), %rsi
movq 0x8(%rsi), %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, %rax
mulq %rdx
shrq %rdx
leal (%rdx,%rdx,2), %eax
movl %ecx, %edx
subl %eax, %edx
movl %edx, (%rbx)
incq %rcx
movq %rcx, 0x8(%rsi)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x22065
callq 0x2209c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator_simple.c
// Function: gt_codon_iterator_simple_new
GtCodonIterator* gt_codon_iterator_simple_new(const char *seq,
                                              GtUword length,
                                              GT_UNUSED GtError *err)
{
  GtCodonIteratorSimple *cis;
  GtCodonIterator *ci;
  gt_assert(seq && length >= GT_CODON_LENGTH);
  gt_error_check(err);
  ci = gt_codon_iterator_create(gt_codon_iterator_simple_class());
  cis = gt_codon_iterator_simple_cast(ci);
  cis->dnaseq = seq;
  ci->pvt->length = length;
  ci->pvt->curpos = 0;
  ci->pvt->startpos = 0;
  return ci;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa399f
movq %rsi, %rbx
cmpq $0x2, %rsi
jbe 0xa399f
movq %rdi, %r14
testq %rdx, %rdx
je 0xa3964
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa39a4
callq 0xa37ac
movq %rax, %rdi
callq 0xa363b
movq %rax, %r15
callq 0xa37ac
movq %rax, %rdi
movq %r15, %rsi
callq 0xa3698
movq %r14, 0x10(%rax)
movq 0x8(%r15), %rax
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x220d3
callq 0x2210a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/codon_iterator_simple.c
// Function: gt_codon_iterator_simple_unit_test
int gt_codon_iterator_simple_unit_test(GtError *err)
{
  int had_err = 0,
      i;
  const char *testseq = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  GtCodonIterator *ci;
  char n1, n2, n3;
  unsigned int frame;
  gt_error_check(err);

  ci = gt_codon_iterator_simple_new(testseq, 26, NULL);
  i = 0;
  while (!gt_codon_iterator_next(ci, &n1, &n2, &n3, &frame, NULL)) {
    gt_ensure(n1 == testseq[i]);
    gt_ensure(n2 == testseq[i+1]);
    gt_ensure(n3 == testseq[i+2]);
    i++;
  }
  gt_ensure(i == 24);
  gt_codon_iterator_delete(ci);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
testq %rdi, %rdi
je 0xa39cf
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0xa3b78
leaq 0x5668c(%rip), %rdi     # 0xfa062
xorl %r15d, %r15d
movl $0x1a, %esi
xorl %edx, %edx
callq 0xa393d
movq %rax, %r14
leaq 0x7(%rsp), %rsi
leaq 0x6(%rsp), %rdx
leaq 0x5(%rsp), %rcx
leaq 0x14(%rsp), %r8
movq %rax, %rdi
xorl %r9d, %r9d
callq 0xa372b
movl $0x0, %ebx
testl %eax, %eax
jne 0xa3b22
movq %r12, 0x8(%rsp)
movl $0x2, %r12d
leaq 0x6(%rsp), %rbp
leaq 0x5(%rsp), %r13
leaq 0x14(%rsp), %r15
xorl %ebx, %ebx
movl %ebx, %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xa3af1
movb 0x7(%rsp), %al
leaq 0x56618(%rip), %rcx     # 0xfa062
cmpb -0x2(%r12,%rcx), %al
jne 0xa3a95
movb 0x6(%rsp), %al
cmpb -0x1(%r12,%rcx), %al
jne 0xa3abe
movb 0x5(%rsp), %al
xorl %ebx, %ebx
cmpb (%r12,%rcx), %al
je 0xa3af1
movq 0x8(%rsp), %rdi
leaq 0x3f6e1(%rip), %rsi     # 0xe3159
leaq 0x56645(%rip), %rdx     # 0xfa0c4
leaq 0x565f7(%rip), %rcx     # 0xfa07d
leaq 0x565b4(%rip), %r8      # 0xfa041
movl $0x7b, %r9d
jmp 0xa3ae5
movq 0x8(%rsp), %rdi
leaq 0x3f6b8(%rip), %rsi     # 0xe3159
leaq 0x565f8(%rip), %rdx     # 0xfa0a0
leaq 0x565ce(%rip), %rcx     # 0xfa07d
leaq 0x5658b(%rip), %r8      # 0xfa041
movl $0x79, %r9d
jmp 0xa3ae5
movq 0x8(%rsp), %rdi
leaq 0x3f68f(%rip), %rsi     # 0xe3159
leaq 0x565e0(%rip), %rdx     # 0xfa0b1
leaq 0x565a5(%rip), %rcx     # 0xfa07d
leaq 0x56562(%rip), %r8      # 0xfa041
movl $0x7a, %r9d
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
leaq 0x7(%rsp), %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0xa372b
incq %r12
testl %eax, %eax
je 0xa3a30
cmpq $0x1a, %r12
sete %r15b
movq 0x8(%rsp), %r12
testl %ebx, %ebx
setne %al
orb %r15b, %al
testb $0x1, %al
jne 0xa3b5f
leaq 0x3f624(%rip), %rsi     # 0xe3159
leaq 0x5659b(%rip), %rdx     # 0xfa0d7
leaq 0x5653a(%rip), %rcx     # 0xfa07d
leaq 0x564f7(%rip), %r8      # 0xfa041
movq %r12, %rdi
movl $0x7e, %r9d
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0xa374e
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x22141
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_new
GtDescBuffer* gt_desc_buffer_new(void)
{
  GtDescBuffer *db = gt_malloc(sizeof *db);
  db->buf = gt_calloc(GT_DESC_BUFFER_INIT_SIZE, sizeof (char));
  db->length = 0;
  db->maxlength = db->curlength = 0;
  db->allocated = GT_DESC_BUFFER_INIT_SIZE;
  db->finished = false;
  db->dirty = true;
  db->shorten = false;
  db->seen_whitespace = false;
  db->reference_count = 0;
  db->startqueue = gt_queue_new();
  gt_queue_add(db->startqueue, (void*) 0);
  return db;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x565c4(%rip), %rbx     # 0xfa15f
movl $0x40, %edi
movq %rbx, %rsi
movl $0x30, %edx
callq 0x35862
movq %rax, %r14
movl $0x2000, %edi           # imm = 0x2000
movl $0x1, %esi
movq %rbx, %rdx
movl $0x31, %ecx
callq 0x359a6
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq $0x2000, 0x20(%r14)     # imm = 0x2000
movl $0x100, 0x28(%r14)      # imm = 0x100
movl $0x0, 0x38(%r14)
callq 0x7c464
movq %rax, 0x30(%r14)
movq %rax, %rdi
xorl %esi, %esi
callq 0x7c47f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_append_char
void gt_desc_buffer_append_char(GtDescBuffer *db, char c)
{
  gt_assert(db);
  if (db->shorten) {
    if (db->seen_whitespace)
      return;
    if (isspace(c)) {
      db->seen_whitespace = true;
      return;
    }
  }
  if (db->finished) {
    gt_queue_add(db->startqueue, (void*) (db->length));
    db->finished = false;
  }
  if (db->length + 2 > db->allocated) {
    db->buf = gt_dynalloc(db->buf, &db->allocated,
                          (db->length + 2) * sizeof (char));
  }
  db->curlength++;
  db->buf[db->length++] = c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa3cad
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x1, 0x2a(%rdi)
jne 0xa3c52
cmpb $0x0, 0x2b(%r14)
jne 0xa3c9e
callq 0xb6e0
movq (%rax), %rax
movsbq %bl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xa3ca6
cmpb $0x1, 0x28(%r14)
jne 0xa3c6b
movq 0x8(%r14), %rsi
movq 0x30(%r14), %rdi
callq 0x7c47f
movb $0x0, 0x28(%r14)
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x2(%rcx), %rdx
cmpq 0x20(%r14), %rdx
jbe 0xa3c8f
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x74134
movq %rax, (%r14)
movq 0x8(%r14), %rcx
incq 0x18(%r14)
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb %bl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x2b(%r14)
jmp 0xa3c9e
callq 0x221af
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_get_next
const char* gt_desc_buffer_get_next(GtDescBuffer *db)
{
  gt_assert(db);
  GtUword startpos = (GtUword) gt_queue_get(db->startqueue);
  db->dirty = true;
  return db->buf + startpos;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa3ccd
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x7c56e
movb $0x1, 0x29(%rbx)
addq (%rbx), %rax
popq %rbx
retq
callq 0x221e6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_finish
void gt_desc_buffer_finish(GtDescBuffer *db)
{
  gt_assert(db);
  db->seen_whitespace = false;
  /* XXX: maybe do a gt_cstr_rtrim(..., ' ') equivalent? */
  gt_desc_buffer_append_char(db, '\0');
  if (db->curlength > db->maxlength)
    db->maxlength = db->curlength;
  db->curlength = 0;
  db->finished = true;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa3d02
movq %rdi, %rbx
movb $0x0, 0x2b(%rdi)
xorl %esi, %esi
callq 0xa3c20
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jbe 0xa3cf4
movq %rax, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movb $0x1, 0x28(%rbx)
popq %rbx
retq
callq 0x2221d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_reset
void gt_desc_buffer_reset(GtDescBuffer *db)
{
  GtUword laststartpos;
  gt_assert(db);

  if (!db->dirty) return;
  if (gt_queue_size(db->startqueue) == 0) {
    db->length = 0;
    db->dirty = false;
    return;
  }
  laststartpos = (GtUword) gt_queue_head(db->startqueue);
  if (laststartpos != 0) {
    laststartpos = (GtUword) gt_queue_get(db->startqueue);
    db->length = db->length - laststartpos;
    if (db->length >= laststartpos) {
      /* strings overlap */
      memmove(db->buf, db->buf + laststartpos, db->length * sizeof (char));
    } else {
      /* no overlap */
      memcpy(db->buf, db->buf + laststartpos, db->length * sizeof (char));
    }
    gt_queue_add(db->startqueue, (void*) 0);
  }
  db->dirty = false;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa3d86
movq %rdi, %rbx
cmpb $0x1, 0x29(%rdi)
jne 0xa3d84
movq 0x30(%rbx), %rdi
callq 0x7c5d0
testq %rax, %rax
je 0xa3d66
movq 0x30(%rbx), %rdi
callq 0x7c5fd
testq %rax, %rax
je 0xa3d80
movq 0x30(%rbx), %rdi
callq 0x7c56e
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
subq %rax, %rdx
movq %rdx, 0x8(%rbx)
leaq (%rdi,%rax), %rsi
cmpq %rax, %rdx
jae 0xa3d70
callq 0xb520
jmp 0xa3d75
movq $0x0, 0x8(%rbx)
jmp 0xa3d80
callq 0xba60
movq 0x30(%rbx), %rdi
xorl %esi, %esi
callq 0x7c47f
movb $0x0, 0x29(%rbx)
popq %rbx
retq
callq 0x22254
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_delete
void gt_desc_buffer_delete(GtDescBuffer *db)
{
  if (!db) return;
  if (db->reference_count) {
    db->reference_count--;
    return;
  }
  gt_free(db->buf);
  gt_queue_delete(db->startqueue);
  gt_free(db);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa3dbf
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testl %eax, %eax
je 0xa3dc7
decl %eax
movl %eax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0x5638e(%rip), %r14     # 0xfa15f
movq %r14, %rsi
movl $0xa4, %edx
callq 0x35c27
movq 0x30(%rbx), %rdi
callq 0x7ca47
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_show
void gt_desc_buffer_show(GtDescBuffer *db)
{
  printf("str: %s\n", db->buf);
  printf("queue: ");
  gt_queue_iterate(db->startqueue, queueprinter, NULL, NULL);
  printf("\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x56408(%rip), %rdi     # 0xfa214
xorl %eax, %eax
callq 0xb070
leaq 0x56403(%rip), %rdi     # 0xfa21d
xorl %eax, %eax
callq 0xb070
movq 0x30(%rbx), %rdi
leaq 0x14(%rip), %rsi        # 0xa3e40
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7c7fe
movl $0xa, %edi
popq %rbx
jmp 0xb870
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/eansi.c
// Function: gt_efopen
FILE* gt_efopen(const char *path, const char *mode, GtError *err)
{
  FILE *file;
  gt_error_check(err);
  if ((file = fopen(path, mode)) == NULL) {
    gt_error_set(err, "fopen(): cannot open file '%s': %s", path,
              strerror(errno));
  }
  return file;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xa4423
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xa4462
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb720
movq %rax, %r15
testq %rax, %rax
jne 0xa4459
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x55f1f(%rip), %rsi     # 0xfa368
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x34f1f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x222fd
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ebzlib.c
// Function: gt_ebzopen
BZFILE* gt_ebzopen(const char *path, const char *mode, GtError *err)
{
  BZFILE* file;
  gt_error_check(err);
  if (!(file = BZ2_bzopen(path, mode))) {
    gt_error_set(err, "BZ2_bzopen(): cannot open file '%s': %s", path,
              strerror(errno));
  }
  return file;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xa4487
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xa44c6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x994a5
movq %rax, %r15
testq %rax, %rax
jne 0xa44bd
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x55efb(%rip), %rsi     # 0xfa3a8
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x34f1f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x22334
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ezlib.c
// Function: gt_egzopen
gzFile gt_egzopen(const char *path, const char *mode, GtError *err)
{
  gzFile file;
  gt_error_check(err);
  if (!(file = gzopen(path, mode))) {
    gt_error_set(err, "gzopen(): cannot open file '%s': %s", path,
              strerror(errno));
  }
  return file;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xa44eb
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xa452a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x99b73
movq %rax, %r15
testq %rax, %rax
jne 0xa4521
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x55edb(%rip), %rsi     # 0xfa3ec
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x34f1f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2236b
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/io.c
// Function: gt_io_new
GtIO* gt_io_new(const char *path, const char *mode)
{
  GtIO *io;
  gt_assert(mode);
  /* XXX: only the read mode has been implemented */
  gt_assert(!strcmp(mode, "r"));
  io = gt_malloc(sizeof *io);
  io->fp = gt_file_xopen(path, mode);
  io->path = path ? gt_str_new_cstr(path) : gt_str_new_cstr("stdin");
  io->line_number = 1;
  io->line_start = true;
  return io;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xa45a5
movq %rsi, %r14
cmpb $0x72, (%rsi)
jne 0xa45a0
cmpb $0x0, 0x1(%r14)
jne 0xa45a0
movq %rdi, %rbx
leaq 0x55ec7(%rip), %rsi     # 0xfa41a
movl $0x20, %edi
movl $0x23, %edx
callq 0x35862
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x75bec
movq %rax, (%r15)
testq %rbx, %rbx
leaq 0x4966f(%rip), %rdi     # 0xedbec
cmovneq %rbx, %rdi
callq 0x3b785
movq %rax, 0x8(%r15)
movq $0x1, 0x10(%r15)
movb $0x1, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x223a2
callq 0x223d9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/io.c
// Function: gt_io_delete
void gt_io_delete(GtIO *io)
{
  if (!io) return;
  gt_file_delete(io->fp);
  gt_str_delete(io->path);
  gt_free(io);
}

// Assembly:
testq %rdi, %rdi
je 0xa45d9
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x760c0
movq 0x8(%rbx), %rdi
callq 0x3c87b
leaq 0x55e4f(%rip), %rsi     # 0xfa41a
movq %rbx, %rdi
movl $0x30, %edx
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/io.c
// Function: gt_io_get_char
int gt_io_get_char(GtIO *io, char *c)
{
  int cc;
  gt_assert(io && c);
  cc = gt_file_xfgetc(io->fp);
  if (cc == '\n') {
    io->line_number++;
    io->line_start = true;
  }
  else
    io->line_start = false;
  *c = cc;
  if (cc == EOF)
    return -1; /* no character left */
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa461f
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa461f
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x75c64
cmpl $0xa, %eax
jne 0xa4603
incq 0x10(%r14)
movb $0x1, %cl
jmp 0xa4605
xorl %ecx, %ecx
movb %cl, 0x18(%r14)
movb %al, (%rbx)
xorl %ecx, %ecx
cmpl $-0x1, %eax
sete %cl
negl %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22410
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/io.c
// Function: gt_io_has_char
bool gt_io_has_char(GtIO *io)
{
  int rval;
  char c = 0;
  gt_assert(io);
  rval = gt_io_get_char(io, &c);
  gt_io_unget_char(io, c);
  return rval ? false : true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa468a
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x75c64
cmpl $0xa, %eax
jne 0xa466a
incq 0x10(%rbx)
movb $0x1, %cl
jmp 0xa466c
xorl %ecx, %ecx
movb %cl, 0x18(%rbx)
cmpl $-0x1, %eax
setne %bpl
movq (%rbx), %rdi
movsbl %al, %esi
callq 0x75cb8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x224b5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/io.c
// Function: gt_io_peek
signed char gt_io_peek(GtIO *io)
{
  char c;
  gt_assert(io);
  gt_io_get_char(io, &c);
  gt_io_unget_char(io, c);
  return c;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa46c3
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x75c64
cmpl $0xa, %eax
jne 0xa46ad
incq 0x10(%rbx)
movb $0x1, %cl
jmp 0xa46af
xorl %ecx, %ecx
movb %cl, 0x18(%rbx)
movq (%rbx), %rdi
movsbl %al, %ebx
movl %ebx, %esi
callq 0x75cb8
movl %ebx, %eax
popq %rbx
retq
callq 0x224ec
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/io.c
// Function: gt_io_next
signed char gt_io_next(GtIO *io)
{
  char c;
  gt_assert(io);
  gt_io_get_char(io, &c);
  return c;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa46ed
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x75c64
cmpl $0xa, %eax
jne 0xa46e6
incq 0x10(%rbx)
movb $0x1, %cl
jmp 0xa46e8
xorl %ecx, %ecx
movb %cl, 0x18(%rbx)
popq %rbx
retq
callq 0x22523
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/io.c
// Function: gt_io_expect
int gt_io_expect(GtIO *io, char expected_char, GtError *err)
{
  char cc;
  gt_error_check(err);
  cc = gt_io_next(io);
  if (cc != expected_char) {
    if (expected_char == GT_END_OF_LINE && cc == GT_CARRIAGE_RETURN) {
      if (gt_io_peek(io) == GT_END_OF_LINE)
        gt_io_next(io);
      return 0;
    }
    if (expected_char == GT_END_OF_FILE) {
      gt_error_set(err, "file \"%s\": line "GT_WU": expected end-of-file, got "
                   "'%c'",
                   gt_io_get_filename(io), gt_io_get_line_number(io), cc);
    }
    else if ((cc == GT_CARRIAGE_RETURN) || (cc == GT_END_OF_LINE)) {
      gt_error_set(err, "file \"%s\": line "GT_WU": expected character '%c', "
                   "got newline",
                   gt_io_get_filename(io), gt_io_get_line_number(io),
                   expected_char);
    }
    else {
      gt_error_set(err, "file \"%s\": line "GT_WU": expected character '%c', "
                   "got '%c'",
                   gt_io_get_filename(io), gt_io_get_line_number(io),
                   expected_char, cc);
    }
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
testq %rdx, %rdx
je 0xa4755
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa4844
movq %r14, %rdi
callq 0xa46c8
xorl %ebp, %ebp
cmpb %r15b, %al
je 0xa4839
movl %r15d, %ecx
xorb $0xa, %cl
movl %eax, %edx
xorb $0xd, %dl
orb %cl, %dl
jne 0xa4794
movq %r14, %rdi
callq 0xa468f
cmpb $0xa, %al
jne 0xa4839
movq %r14, %rdi
callq 0xa46c8
jmp 0xa4839
movsbl %al, %ebp
cmpb $-0x1, %r15b
je 0xa47d5
movsbl %r15b, %r15d
cmpb $0xd, %al
je 0xa47ad
movzbl %al, %eax
cmpl $0xa, %eax
jne 0xa4804
movq %r14, %rdi
callq 0xa4702
movq %rax, %r12
movq %r14, %rdi
callq 0xa46f2
leaq 0x55d62(%rip), %rsi     # 0xfa529
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %r15d, %r8d
jmp 0xa47fb
movq %r14, %rdi
callq 0xa4702
movq %rax, %r15
movq %r14, %rdi
callq 0xa46f2
leaq 0x55d06(%rip), %rsi     # 0xfa4f5
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x34f1f
jmp 0xa4834
movq %r14, %rdi
callq 0xa4702
movq %rax, %r12
movq %r14, %rdi
callq 0xa46f2
leaq 0x55d45(%rip), %rsi     # 0xfa563
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %r15d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x225ff
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/score_matrix.c
// Function: gt_score_matrix_new
GtScoreMatrix* gt_score_matrix_new(GtAlphabet *alphabet)
{
  GtScoreMatrix *sm;
  gt_assert(alphabet);
  sm = gt_malloc(sizeof (GtScoreMatrix));
  sm->alphabet = gt_alphabet_ref(alphabet);
  sm->dimension = gt_alphabet_size(alphabet);
  gt_array2dim_calloc(sm->scores, sm->dimension, sm->dimension);
  return sm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa4918
movq %rdi, %r15
leaq 0x55d2e(%rip), %r14     # 0xfa5ae
movl $0x18, %edi
movq %r14, %rsi
movl $0x28, %edx
callq 0x35862
movq %rax, %rbx
movq %r15, %rdi
callq 0xba023
movq %rax, (%rbx)
movq %r15, %rdi
callq 0xba7b3
movl %eax, 0x8(%rbx)
movl %eax, %edi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x2b, %edx
callq 0x35862
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %edi
imull %edi, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x2b, %ecx
callq 0x359a6
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl 0x8(%rbx), %eax
cmpq $0x2, %rax
jb 0xa490f
movl $0x1, %ecx
leaq (,%rax,4), %rdx
movq 0x10(%rbx), %rsi
movq -0x8(%rsi,%rcx,8), %rdi
addq %rdx, %rdi
movq %rdi, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xa48f7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x22638
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/score_matrix.c
// Function: gt_score_matrix_new_read_protein
GtScoreMatrix* gt_score_matrix_new_read_protein(const char *path, GtError *err)
{
  GtAlphabet *protein_alpha;
  GtScoreMatrix *sm;
  int had_err;

  gt_error_check(err);
  gt_assert(path);

  /* create score matrix */
  protein_alpha = gt_alphabet_new_protein();
  sm = gt_score_matrix_new(protein_alpha);
  gt_alphabet_delete(protein_alpha);

  /* parse matrix file */
  had_err = parse_score_matrix(sm, path, err);

  if (had_err) {
    gt_score_matrix_delete(sm);
    return NULL;
  }
  return sm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xa4944
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa4995
testq %r14, %r14
je 0xa4990
callq 0xba5c1
movq %rax, %r12
movq %rax, %rdi
callq 0xa4868
movq %rax, %r15
movq %r12, %rdi
callq 0xba400
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa499a
testl %eax, %eax
je 0xa4981
movq %r15, %rdi
callq 0xa4ece
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x226a8
callq 0x2266f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/score_matrix.c
// Function: gt_score_matrix_delete
void gt_score_matrix_delete(GtScoreMatrix *sm)
{
  if (!sm) return;
  gt_alphabet_delete(sm->alphabet);
  gt_array2dim_delete(sm->scores);
  gt_free(sm);
}

// Assembly:
testq %rdi, %rdi
je 0xa4f25
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xba400
movq 0x10(%rbx), %rax
movq (%rax), %rdi
leaq 0x556be(%rip), %r14     # 0xfa5ae
movq %r14, %rsi
movl $0x13c, %edx            # imm = 0x13C
callq 0x35c27
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x13c, %edx            # imm = 0x13C
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x13d, %edx            # imm = 0x13D
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/score_matrix.c
// Function: gt_score_matrix_new_read
GtScoreMatrix* gt_score_matrix_new_read(const char *path, GtAlphabet *alphabet,
                                        GtError *err)
{
  GtScoreMatrix *sm;
  gt_error_check(err);
  gt_assert(path && alphabet);
  sm = gt_score_matrix_new(alphabet);
  if (parse_score_matrix(sm, path, err)) {
    gt_score_matrix_delete(sm);
    return NULL;
  }
  return sm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0xa4f45
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa4f85
testq %r14, %r14
je 0xa4f80
testq %r15, %r15
je 0xa4f80
movq %r15, %rdi
callq 0xa4868
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa499a
testl %eax, %eax
je 0xa4f77
movq %r15, %rdi
callq 0xa4ece
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x228a1
callq 0x22868
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/score_matrix.c
// Function: gt_score_matrix_get_score
int gt_score_matrix_get_score(const GtScoreMatrix *sm,
                              unsigned int idx1, unsigned int idx2)
{
  gt_assert(sm);
  idx1 = (idx1 == GT_WILDCARD) ? sm->dimension - 1 : idx1;
  idx2 = (idx2 == GT_WILDCARD) ? sm->dimension - 1 : idx2;
  /* indices are valid */
  gt_assert(idx1 < sm->dimension && idx2 < sm->dimension);
  return sm->scores[idx1][idx2];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xa4fd4
cmpl $0xfe, %esi
jne 0xa4fac
movl 0x8(%rdi), %esi
decl %esi
movl 0x8(%rdi), %ecx
leal -0x1(%rcx), %eax
cmpl $0xfe, %edx
cmovnel %edx, %eax
cmpl %ecx, %esi
jae 0xa4fd9
cmpl %ecx, %eax
jae 0xa4fd9
movq 0x10(%rdi), %rcx
movl %esi, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %eax
popq %rcx
retq
callq 0x2294c
callq 0x22913
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/score_matrix.c
// Function: gt_score_matrix_set_score
void gt_score_matrix_set_score(GtScoreMatrix *sm,
                               unsigned int idx1, unsigned int idx2, int score)
{
  gt_assert(sm);
  idx1 = (idx1 == GT_WILDCARD) ? sm->dimension - 1 : idx1;
  idx2 = (idx2 == GT_WILDCARD) ? sm->dimension - 1 : idx2;
  /* indices are valid */
  gt_assert(idx1 < sm->dimension && idx2 < sm->dimension);
  sm->scores[idx1][idx2] = score;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xa501d
cmpl $0xfe, %esi
jne 0xa4ff1
movl 0x8(%rdi), %esi
decl %esi
movl 0x8(%rdi), %r8d
leal -0x1(%r8), %eax
cmpl $0xfe, %edx
cmovnel %edx, %eax
cmpl %r8d, %esi
jae 0xa5022
cmpl %r8d, %eax
jae 0xa5022
movq 0x10(%rdi), %rdx
movl %esi, %esi
movq (%rdx,%rsi,8), %rdx
movl %eax, %eax
movl %ecx, (%rdx,%rax,4)
popq %rax
retq
callq 0x229be
callq 0x22985
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/score_matrix.c
// Function: gt_score_matrix_show
void gt_score_matrix_show(const GtScoreMatrix *sm, FILE *fp)
{
  unsigned i, j;
  gt_assert(sm && fp);
  /* show alphabet line */
  gt_xfputc(' ', fp);
  for (i = 0; i < gt_alphabet_size(sm->alphabet); i++)
    fprintf(fp, "  %c", gt_alphabet_decode(sm->alphabet, i));
  gt_xfputc('\n', fp);
  /* show score lines */
  for (i = 0; i < gt_alphabet_size(sm->alphabet); i++) {
    gt_xfputc(gt_alphabet_decode(sm->alphabet, i), fp);
    for (j = 0; j < gt_alphabet_size(sm->alphabet); j++)
      fprintf(fp, " %2d", gt_score_matrix_get_score(sm, i, j));
    gt_xfputc('\n', fp);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xa513b
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa513b
movq %rdi, %r14
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3d29e
movq (%r14), %rdi
callq 0xba7b3
testl %eax, %eax
je 0xa50a3
leaq 0x55652(%rip), %r15     # 0xfa6c9
xorl %ebp, %ebp
movq (%r14), %rdi
movzbl %bpl, %esi
callq 0xbae5f
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb8d0
incl %ebp
movq (%r14), %rdi
callq 0xba7b3
cmpl %eax, %ebp
jb 0xa5079
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3d29e
movq (%r14), %rdi
callq 0xba7b3
testl %eax, %eax
je 0xa5132
leaq 0x5560b(%rip), %r15     # 0xfa6ce
xorl %ebp, %ebp
movq (%r14), %rdi
movzbl %bpl, %esi
callq 0xbae5f
movsbl %al, %edi
movq %rbx, %rsi
callq 0x3d29e
movq (%r14), %rdi
callq 0xba7b3
testl %eax, %eax
je 0xa5117
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0xa4f99
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0xb8d0
incl %r12d
movq (%r14), %rdi
callq 0xba7b3
cmpl %eax, %r12d
jb 0xa50eb
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3d29e
incl %ebp
movq (%r14), %rdi
callq 0xba7b3
cmpl %eax, %ebp
jb 0xa50c5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x22a30
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator.c
// Function: gt_seq_iterator_create
GtSeqIterator* gt_seq_iterator_create(const GtSeqIteratorClass *sic)
{
  GtSeqIterator *si;
  gt_assert(sic && sic->size);
  si = gt_calloc((size_t) 1, sic->size);
  si->c_class = sic;
  return si;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa51c2
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xa51c2
leaq 0x55711(%rip), %rdx     # 0xfa8bf
movl $0x1, %edi
movl $0x3d, %ecx
callq 0x359a6
movq %rbx, (%rax)
popq %rbx
retq
callq 0x22a69
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator.c
// Function: gt_seq_iterator_next
int gt_seq_iterator_next(GtSeqIterator *seqit,
                        const GtUchar **sequence,
                        GtUword *len,
                        char **description,
                        GtError *err)
{
  gt_assert(seqit);
  if (seqit->c_class && seqit->c_class->next_func)
    return seqit->c_class->next_func(seqit, sequence, len, description, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xa5274
movq (%rdi), %rax
testq %rax, %rax
je 0xa5271
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xa5271
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x22bb3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator.c
// Function: gt_seq_iterator_getcurrentcounter
const GtUint64 *gt_seq_iterator_getcurrentcounter(GtSeqIterator *seqit,
                                                  GtUint64 maxread)
{
  gt_assert(seqit);
  if (seqit->c_class && seqit->c_class->get_curr_counter_func)
    return seqit->c_class->get_curr_counter_func(seqit, maxread);
  else
    return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0xa5295
movq (%rdi), %rax
testq %rax, %rax
je 0xa5292
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa5292
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x22bea
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator.c
// Function: gt_seq_iterator_delete
void gt_seq_iterator_delete(GtSeqIterator *seqit)
{
  if (!seqit) return;
  gt_assert(seqit->c_class);
  if (seqit->c_class->free_func != NULL)
    seqit->c_class->free_func(seqit);
  gt_free(seqit);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa52cf
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xa52d1
movq 0x30(%rax), %rax
testq %rax, %rax
je 0xa52ba
movq %rbx, %rdi
callq *%rax
leaq 0x555fe(%rip), %rsi     # 0xfa8bf
movq %rbx, %rdi
movl $0x83, %edx
popq %rbx
jmp 0x35c27
popq %rbx
retq
callq 0x22c21
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: gt_seq_iterator_fastq_set_quality_buffer
void gt_seq_iterator_fastq_set_quality_buffer(GtSeqIterator *si,
                                             const GtUchar **qualities)
{
  GtSeqIteratorFastQ *seqit;
  gt_assert(si);
  seqit = gt_seq_iterator_fastq_cast(si);
  seqit->qualities = qualities;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa5315
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa531a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa51c7
movq %rbx, 0x20a8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22c93
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: gt_seq_iterator_fastq_class
const GtSeqIteratorClass* gt_seq_iterator_fastq_class(void)
{
  static const GtSeqIteratorClass *sic = NULL;
  gt_class_alloc_lock_enter();
  if (!sic) {
    sic = gt_seq_iterator_class_new(sizeof (GtSeqIteratorFastQ),
                             gt_seq_iterator_fastq_set_symbolmap,
                             NULL,
                             gt_seq_iterator_fastq_next,
                             gt_seq_iterator_fastq_getcurrentcounter,
                             gt_seq_iterator_fastq_set_quality_buffer,
                             gt_seq_iterator_fastq_delete);
  }
  gt_class_alloc_lock_leave();
  return sic;
}

// Assembly:
pushq %rax
callq 0x72367
cmpq $0x0, 0xada40(%rip)     # 0x152d68
jne 0xa5364
leaq 0x846(%rip), %rax       # 0xa5b77
movq %rax, (%rsp)
leaq 0x36(%rip), %rsi        # 0xa5372
leaq 0xbb(%rip), %rcx        # 0xa53fe
leaq 0x7f4(%rip), %r8        # 0xa5b3e
leaq -0x6a(%rip), %r9        # 0xa52e7
movl $0x20b0, %edi           # imm = 0x20B0
xorl %edx, %edx
callq 0xa5140
movq %rax, 0xada04(%rip)     # 0x152d68
callq 0x7237d
movq 0xad9f8(%rip), %rax     # 0x152d68
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: gt_seq_iterator_fastq_set_symbolmap
void gt_seq_iterator_fastq_set_symbolmap(GtSeqIterator *si,
                                        const GtUchar *symbolmap)
{
  GtSeqIteratorFastQ *seqit;
  gt_assert(si);
  seqit = gt_seq_iterator_fastq_cast(si);
  seqit->symbolmap = symbolmap;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa53a0
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa531a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa51c7
movq %rbx, 0x20a0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22ccc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: gt_seq_iterator_fastq_set_chardisttab
void gt_seq_iterator_fastq_set_chardisttab(GtSeqIterator *si,
                                          GtUword *chardist)
{
  GtSeqIteratorFastQ *seqit;
  gt_assert(si && chardist);
  seqit = gt_seq_iterator_fastq_cast(si);
  seqit->chardisttab = chardist;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa53d5
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa53d5
movq %rdi, %r14
callq 0xa531a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa51c7
movq %rbx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22d05
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: gt_seq_iterator_fastq_get_lastspeciallength
uint64_t gt_seq_iterator_fastq_get_lastspeciallength(const GtSeqIterator *si)
{
  GtSeqIteratorFastQ *seqit;
  gt_assert(si);
  seqit = gt_seq_iterator_fastq_cast((GtSeqIterator*) si);
  return seqit->lastspeciallength;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa53f9
movq %rdi, %rbx
callq 0xa531a
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa51c7
movq 0x78(%rax), %rax
popq %rbx
retq
callq 0x22d3e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: gt_seq_iterator_fastq_getcurrentcounter
const GtUint64*
gt_seq_iterator_fastq_getcurrentcounter(GtSeqIterator *si,
                                       GtUint64 maxread)
{
  GtSeqIteratorFastQ *seqit;
  gt_assert(si);
  seqit = gt_seq_iterator_fastq_cast(si);
  seqit->maxread = maxread;
  return &seqit->currentread;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa5b72
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa531a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa51c7
movq %rbx, 0x80(%rax)
addq $0x88, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22f04
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: gt_seq_iterator_fastq_delete
void gt_seq_iterator_fastq_delete(GtSeqIterator *si)
{
  GtSeqIteratorFastQ *seqit;
  if (!si) return;
  seqit = gt_seq_iterator_fastq_cast(si);
  gt_str_delete(seqit->qdescbuffer);
  gt_str_delete(seqit->sequencebuffer);
  gt_str_delete(seqit->qualsbuffer);
  gt_str_delete(seqit->descbuffer);
  if (seqit->curfile)
    gt_file_delete(seqit->curfile);
  seqit->currentread = seqit->maxread;
}

// Assembly:
testq %rdi, %rdi
je 0xa5bd4
pushq %rbx
movq %rdi, %rbx
callq 0xa531a
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa51c7
movq %rax, %rbx
movq 0x40(%rax), %rdi
callq 0x3c87b
movq 0x28(%rbx), %rdi
callq 0x3c87b
movq 0x38(%rbx), %rdi
callq 0x3c87b
movq 0x30(%rbx), %rdi
callq 0x3c87b
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xa5bc5
callq 0x760c0
movq 0x80(%rbx), %rax
movq %rax, 0x88(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: seqiterator_fastq_new_gen
static GtSeqIterator* seqiterator_fastq_new_gen(const GtStrArray *filenametab,
                                                bool is_color_space,
                                                GT_UNUSED GtError *err)
{
  GtSeqIterator *seqit;
  GtSeqIteratorFastQ *seqitf;
  gt_assert(filenametab);
  seqit = gt_seq_iterator_create(gt_seq_iterator_fastq_class());
  seqitf = gt_seq_iterator_fastq_cast(seqit);
  seqitf->qdescbuffer = gt_str_new();
  seqitf->curfile = gt_file_xopen(gt_str_array_get(filenametab, 0), "r");
  seqitf->filenametab = filenametab;
  seqitf->curline = 1;
  seqitf->sequencebuffer = gt_str_new();
  seqitf->qualsbuffer = gt_str_new();
  seqitf->descbuffer = gt_str_new();
  seqitf->is_color_space = is_color_space;
  seqitf->relax_qualdesc_check = false;
  return seqit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa5c93
movl %esi, %ebx
movq %rdi, %r15
callq 0xa531a
movq %rax, %rdi
callq 0xa5196
movq %rax, %r14
callq 0xa531a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa51c7
movq %rax, %r12
callq 0x3b728
movq %rax, 0x40(%r12)
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ca6f
leaq 0x49220(%rip), %rsi     # 0xeee5d
movq %rax, %rdi
callq 0x75bec
movq %rax, 0x48(%r12)
movq %r15, 0x90(%r12)
movq $0x1, 0x68(%r12)
callq 0x3b728
movq %rax, 0x28(%r12)
callq 0x3b728
movq %rax, 0x38(%r12)
callq 0x3b728
movq %rax, 0x30(%r12)
movb %bl, 0x22(%r12)
movb $0x0, 0x23(%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x22f76