LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xa3e4a
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbp
movl $0x30, %edi
callq 0x71ca4
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 0x21ee0
// File: /workspace/github_c_makefile_star2_O1/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 0xa3ea7
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xa3ea7
leaq 0x560f1(%rip), %r14     # 0xf9f5c
movl $0x1, %edi
movq %r14, %rdx
movl $0x3a, %ecx
callq 0x3601f
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x20, %esi
movq %r14, %rdx
movl $0x3c, %ecx
callq 0x3601f
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x21f17
// File: /workspace/github_c_makefile_star2_O1/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 0xa3efa
movq (%rdi), %rax
testq %rax, %rax
je 0xa3efa
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xa3ef7
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x21fbc
// File: /workspace/github_c_makefile_star2_O1/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 0xa3f1a
movq (%rdi), %rax
testq %rax, %rax
je 0xa3f1a
cmpq $0x0, 0x10(%rax)
je 0xa3f17
jmpq *0x18(%rax)
xorl %eax, %eax
retq
pushq %rax
callq 0x21ff3
// File: /workspace/github_c_makefile_star2_O1/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 0xa3f5c
movq (%rdi), %rax
testq %rax, %rax
je 0xa3f5c
cmpq $0x0, 0x10(%rax)
je 0xa3f59
movq 0x28(%rax), %rax
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x22061
// File: /workspace/github_c_makefile_star2_O1/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 0xa3fb3
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xa3fbb
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xa3f84
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x55fcd(%rip), %r14     # 0xf9f5c
movq %r14, %rsi
movl $0x78, %edx
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x79, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22098
// File: /workspace/github_c_makefile_star2_O1/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 0x71d9b
cmpq $0x0, 0xaed92(%rip)     # 0x152d60
jne 0xa3fff
leaq 0x36(%rip), %rdx        # 0xa400d
leaq 0x43(%rip), %rcx        # 0xa4021
leaq 0x4f(%rip), %r8         # 0xa4034
leaq 0x55(%rip), %r9         # 0xa4041
movl $0x18, %edi
xorl %esi, %esi
callq 0xa3df8
movq %rax, 0xaed61(%rip)     # 0x152d60
callq 0x71db1
movq 0xaed55(%rip), %rax     # 0x152d60
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa4147
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
testq %r9, %r9
je 0xa40b0
movq %r9, %rdi
callq 0x3566a
testb %al, %al
jne 0xa414c
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %rdx
addq $0x2, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq (%rcx), %rdx
jae 0xa413d
callq 0xa3fc0
movq %rax, %rdi
movq %r15, %rsi
callq 0xa3eac
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 0x2213d
callq 0x22174
// File: /workspace/github_c_makefile_star2_O1/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 0xa41b3
movq %rsi, %rbx
cmpq $0x2, %rsi
jbe 0xa41b3
movq %rdi, %r14
testq %rdx, %rdx
je 0xa4178
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa41b8
callq 0xa3fc0
movq %rax, %rdi
callq 0xa3e4f
movq %rax, %r15
callq 0xa3fc0
movq %rax, %rdi
movq %r15, %rsi
callq 0xa3eac
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 0x221ab
callq 0x221e2
// File: /workspace/github_c_makefile_star2_O1/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 0xa41e3
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0xa438c
leaq 0x55f08(%rip), %rdi     # 0xfa0f2
xorl %r15d, %r15d
movl $0x1a, %esi
xorl %edx, %edx
callq 0xa4151
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 0xa3f3f
movl $0x0, %ebx
testl %eax, %eax
jne 0xa4336
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 0xa4305
movb 0x7(%rsp), %al
leaq 0x55e94(%rip), %rcx     # 0xfa0f2
cmpb -0x2(%r12,%rcx), %al
jne 0xa42a9
movb 0x6(%rsp), %al
cmpb -0x1(%r12,%rcx), %al
jne 0xa42d2
movb 0x5(%rsp), %al
xorl %ebx, %ebx
cmpb (%r12,%rcx), %al
je 0xa4305
movq 0x8(%rsp), %rdi
leaq 0x3eeed(%rip), %rsi     # 0xe3179
leaq 0x55ec1(%rip), %rdx     # 0xfa154
leaq 0x55e73(%rip), %rcx     # 0xfa10d
leaq 0x55e30(%rip), %r8      # 0xfa0d1
movl $0x7b, %r9d
jmp 0xa42f9
movq 0x8(%rsp), %rdi
leaq 0x3eec4(%rip), %rsi     # 0xe3179
leaq 0x55e74(%rip), %rdx     # 0xfa130
leaq 0x55e4a(%rip), %rcx     # 0xfa10d
leaq 0x55e07(%rip), %r8      # 0xfa0d1
movl $0x79, %r9d
jmp 0xa42f9
movq 0x8(%rsp), %rdi
leaq 0x3ee9b(%rip), %rsi     # 0xe3179
leaq 0x55e5c(%rip), %rdx     # 0xfa141
leaq 0x55e21(%rip), %rcx     # 0xfa10d
leaq 0x55dde(%rip), %r8      # 0xfa0d1
movl $0x7a, %r9d
xorl %eax, %eax
callq 0x3559f
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 0xa3f3f
incq %r12
testl %eax, %eax
je 0xa4244
cmpq $0x1a, %r12
sete %r15b
movq 0x8(%rsp), %r12
testl %ebx, %ebx
setne %al
orb %r15b, %al
testb $0x1, %al
jne 0xa4373
leaq 0x3ee30(%rip), %rsi     # 0xe3179
leaq 0x55e17(%rip), %rdx     # 0xfa167
leaq 0x55db6(%rip), %rcx     # 0xfa10d
leaq 0x55d73(%rip), %r8      # 0xfa0d1
movq %r12, %rdi
movl $0x7e, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0xa3f62
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x22219
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x55e40(%rip), %rbx     # 0xfa1ef
movl $0x40, %edi
movq %rbx, %rsi
movl $0x30, %edx
callq 0x35ee2
movq %rax, %r14
movl $0x2000, %edi           # imm = 0x2000
movl $0x1, %esi
movq %rbx, %rdx
movl $0x31, %ecx
callq 0x3601f
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 0x7c028
movq %rax, 0x30(%r14)
movq %rax, %rdi
xorl %esi, %esi
callq 0x7c043
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa44c1
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x1, 0x2a(%rdi)
jne 0xa4466
cmpb $0x0, 0x2b(%r14)
jne 0xa44b2
callq 0xb6e0
movq (%rax), %rax
movsbq %bl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xa44ba
cmpb $0x1, 0x28(%r14)
jne 0xa447f
movq 0x8(%r14), %rsi
movq 0x30(%r14), %rdi
callq 0x7c043
movb $0x0, 0x28(%r14)
movq 0x8(%r14), %rdx
addq $0x2, %rdx
cmpq 0x20(%r14), %rdx
jbe 0xa449c
leaq 0x20(%r14), %rsi
movq (%r14), %rdi
callq 0x73b98
movq %rax, (%r14)
incq 0x18(%r14)
movq (%r14), %rax
movq 0x8(%r14), %rcx
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 0xa44b2
callq 0x22287
// File: /workspace/github_c_makefile_star2_O1/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 0xa44e1
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x7c132
movb $0x1, 0x29(%rbx)
addq (%rbx), %rax
popq %rbx
retq
callq 0x222be
// File: /workspace/github_c_makefile_star2_O1/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 0xa4516
movq %rdi, %rbx
movb $0x0, 0x2b(%rdi)
xorl %esi, %esi
callq 0xa4434
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jbe 0xa4508
movq %rax, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movb $0x1, 0x28(%rbx)
popq %rbx
retq
callq 0x222f5
// File: /workspace/github_c_makefile_star2_O1/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 0xa459a
movq %rdi, %rbx
cmpb $0x1, 0x29(%rdi)
jne 0xa4598
movq 0x30(%rbx), %rdi
callq 0x7c194
testq %rax, %rax
je 0xa457a
movq 0x30(%rbx), %rdi
callq 0x7c1c1
testq %rax, %rax
je 0xa4594
movq 0x30(%rbx), %rdi
callq 0x7c132
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
subq %rax, %rdx
movq %rdx, 0x8(%rbx)
leaq (%rdi,%rax), %rsi
cmpq %rax, %rdx
jae 0xa4584
callq 0xb520
jmp 0xa4589
movq $0x0, 0x8(%rbx)
jmp 0xa4594
callq 0xba60
movq 0x30(%rbx), %rdi
xorl %esi, %esi
callq 0x7c043
movb $0x0, 0x29(%rbx)
popq %rbx
retq
callq 0x2232c
// File: /workspace/github_c_makefile_star2_O1/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 0xa45d6
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testl %eax, %eax
je 0xa45de
decl %eax
movl %eax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0x55c07(%rip), %r14     # 0xfa1ef
movq %r14, %rsi
movl $0xa4, %edx
callq 0x362a0
movq 0x30(%rbx), %rdi
callq 0x7c623
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/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 0x55c81(%rip), %rdi     # 0xfa2a4
xorl %eax, %eax
callq 0xb070
leaq 0x55c7c(%rip), %rdi     # 0xfa2ad
xorl %eax, %eax
callq 0xb070
movq 0x30(%rbx), %rdi
leaq 0x14(%rip), %rsi        # 0xa4657
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7c3d1
movl $0xa, %edi
popq %rbx
jmp 0xb870
// File: /workspace/github_c_makefile_star2_O1/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 0xa4c57
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xa4c96
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb720
movq %rax, %r15
testq %rax, %rax
jne 0xa4c8d
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x5577b(%rip), %rsi     # 0xfa3f8
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3559f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x223d5
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa4cbb
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xa4cfa
movq %rbx, %rdi
movq %r15, %rsi
callq 0x99eff
movq %rax, %r15
testq %rax, %rax
jne 0xa4cf1
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x55757(%rip), %rsi     # 0xfa438
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3559f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2240c
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa4d1f
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xa4d5e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9a5bf
movq %rax, %r15
testq %rax, %rax
jne 0xa4d55
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x55737(%rip), %rsi     # 0xfa47c
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3559f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x22443
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa4ddb
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4a12d(%rip), %rsi     # 0xeeea8
movq %r14, %rdi
callq 0xb890
testl %eax, %eax
jne 0xa4de0
leaq 0x5571c(%rip), %rsi     # 0xfa4aa
movl $0x20, %edi
movl $0x23, %edx
callq 0x35ee2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x756a8
movq %rax, (%r15)
testq %rbx, %rbx
leaq 0x48e7c(%rip), %rdi     # 0xedc34
cmovneq %rbx, %rdi
callq 0x3c03d
movq %rax, 0x8(%r15)
movq $0x1, 0x10(%r15)
movb $0x1, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x224b1
callq 0x2247a
// File: /workspace/github_c_makefile_star2_O1/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 0xa4e14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x75b7c
movq 0x8(%rbx), %rdi
callq 0x3d1eb
leaq 0x556a4(%rip), %rsi     # 0xfa4aa
movq %rbx, %rdi
movl $0x30, %edx
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa4e5a
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa4e5a
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x75720
cmpl $0xa, %eax
jne 0xa4e3e
incq 0x10(%r14)
movb $0x1, %cl
jmp 0xa4e40
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 0x224e8
// File: /workspace/github_c_makefile_star2_O1/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 0xa4ec5
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x75720
cmpl $0xa, %eax
jne 0xa4ea5
incq 0x10(%rbx)
movb $0x1, %cl
jmp 0xa4ea7
xorl %ecx, %ecx
movb %cl, 0x18(%rbx)
cmpl $-0x1, %eax
setne %bpl
movq (%rbx), %rdi
movsbl %al, %esi
callq 0x75774
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2258d
// File: /workspace/github_c_makefile_star2_O1/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 0xa4efe
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x75720
cmpl $0xa, %eax
jne 0xa4ee8
incq 0x10(%rbx)
movb $0x1, %cl
jmp 0xa4eea
xorl %ecx, %ecx
movb %cl, 0x18(%rbx)
movq (%rbx), %rdi
movsbl %al, %ebx
movl %ebx, %esi
callq 0x75774
movl %ebx, %eax
popq %rbx
retq
callq 0x225c4
// File: /workspace/github_c_makefile_star2_O1/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 0xa4f28
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x75720
cmpl $0xa, %eax
jne 0xa4f21
incq 0x10(%rbx)
movb $0x1, %cl
jmp 0xa4f23
xorl %ecx, %ecx
movb %cl, 0x18(%rbx)
popq %rbx
retq
callq 0x225fb
// File: /workspace/github_c_makefile_star2_O1/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 0xa4f90
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa507f
movq %r14, %rdi
callq 0xa4f03
xorl %ebp, %ebp
cmpb %r15b, %al
je 0xa5074
movl %r15d, %ecx
xorb $0xa, %cl
movl %eax, %edx
xorb $0xd, %dl
orb %cl, %dl
jne 0xa4fcf
movq %r14, %rdi
callq 0xa4eca
cmpb $0xa, %al
jne 0xa5074
movq %r14, %rdi
callq 0xa4f03
jmp 0xa5074
movsbl %al, %ebp
cmpb $-0x1, %r15b
je 0xa5010
movsbl %r15b, %r15d
cmpb $0xd, %al
je 0xa4fe8
movzbl %al, %eax
cmpl $0xa, %eax
jne 0xa503f
movq %r14, %rdi
callq 0xa4f3d
movq %rax, %r12
movq %r14, %rdi
callq 0xa4f2d
leaq 0x555b7(%rip), %rsi     # 0xfa5b9
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %r15d, %r8d
jmp 0xa5036
movq %r14, %rdi
callq 0xa4f3d
movq %rax, %r15
movq %r14, %rdi
callq 0xa4f2d
leaq 0x5555b(%rip), %rsi     # 0xfa585
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3559f
jmp 0xa506f
movq %r14, %rdi
callq 0xa4f3d
movq %rax, %r12
movq %r14, %rdi
callq 0xa4f2d
leaq 0x5559a(%rip), %rsi     # 0xfa5f3
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %r15d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x226d7
// File: /workspace/github_c_makefile_star2_O1/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 0xa5150
movq %rdi, %r15
leaq 0x55586(%rip), %r14     # 0xfa63e
movl $0x18, %edi
movq %r14, %rsi
movl $0x28, %edx
callq 0x35ee2
movq %rax, %rbx
movq %r15, %rdi
callq 0xb8fab
movq %rax, (%rbx)
movq %r15, %rdi
callq 0xb96c8
movl %eax, 0x8(%rbx)
movl %eax, %edi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x2b, %edx
callq 0x35ee2
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %edi
imull %edi, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x2b, %ecx
callq 0x3601f
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl 0x8(%rbx), %eax
cmpq $0x2, %rax
jb 0xa5147
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 0xa512f
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x22710
// File: /workspace/github_c_makefile_star2_O1/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 0xa517c
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa51cd
testq %r14, %r14
je 0xa51c8
callq 0xb94cc
movq %rax, %r12
movq %rax, %rdi
callq 0xa50a0
movq %rax, %r15
movq %r12, %rdi
callq 0xb9301
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa51d2
testl %eax, %eax
je 0xa51b9
movq %r15, %rdi
callq 0xa573d
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x22780
callq 0x22747
// File: /workspace/github_c_makefile_star2_O1/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 0xa5794
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xb9301
movq 0x10(%rbx), %rax
movq (%rax), %rdi
leaq 0x54edf(%rip), %r14     # 0xfa63e
movq %r14, %rsi
movl $0x13c, %edx            # imm = 0x13C
callq 0x362a0
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x13c, %edx            # imm = 0x13C
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x13d, %edx            # imm = 0x13D
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa57b4
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa57f4
testq %r14, %r14
je 0xa57ef
testq %r15, %r15
je 0xa57ef
movq %r15, %rdi
callq 0xa50a0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa51d2
testl %eax, %eax
je 0xa57e6
movq %r15, %rdi
callq 0xa573d
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x22979
callq 0x22940
// File: /workspace/github_c_makefile_star2_O1/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 0xa5844
cmpl $0xfe, %esi
jne 0xa581b
movl 0x8(%rdi), %esi
decl %esi
cmpl $0xfe, %edx
jne 0xa5828
movl 0x8(%rdi), %edx
decl %edx
movl 0x8(%rdi), %eax
cmpl %eax, %esi
jae 0xa5849
cmpl %eax, %edx
jae 0xa5849
movq 0x10(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %eax
popq %rcx
retq
callq 0x22a24
callq 0x229eb
// File: /workspace/github_c_makefile_star2_O1/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 0xa588a
cmpl $0xfe, %esi
jne 0xa5861
movl 0x8(%rdi), %esi
decl %esi
cmpl $0xfe, %edx
jne 0xa586e
movl 0x8(%rdi), %edx
decl %edx
movl 0x8(%rdi), %eax
cmpl %eax, %esi
jae 0xa588f
cmpl %eax, %edx
jae 0xa588f
movq 0x10(%rdi), %rax
movl %esi, %esi
movq (%rax,%rsi,8), %rax
movl %edx, %edx
movl %ecx, (%rax,%rdx,4)
popq %rax
retq
callq 0x22a96
callq 0x22a5d
// File: /workspace/github_c_makefile_star2_O1/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 0xa59a8
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa59a8
movq %rdi, %r14
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3dc12
movq (%r14), %rdi
callq 0xb96c8
testl %eax, %eax
je 0xa5910
leaq 0x54e75(%rip), %r15     # 0xfa759
xorl %ebp, %ebp
movq (%r14), %rdi
movzbl %bpl, %esi
callq 0xb9d4b
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb8d0
incl %ebp
movq (%r14), %rdi
callq 0xb96c8
cmpl %eax, %ebp
jb 0xa58e6
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3dc12
movq (%r14), %rdi
callq 0xb96c8
testl %eax, %eax
je 0xa599f
leaq 0x54e2e(%rip), %r15     # 0xfa75e
xorl %ebp, %ebp
movq (%r14), %rdi
movzbl %bpl, %esi
callq 0xb9d4b
movsbl %al, %edi
movq %rbx, %rsi
callq 0x3dc12
movq (%r14), %rdi
callq 0xb96c8
testl %eax, %eax
je 0xa5984
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0xa5808
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0xb8d0
incl %r12d
movq (%r14), %rdi
callq 0xb96c8
cmpl %eax, %r12d
jb 0xa5958
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3dc12
incl %ebp
movq (%r14), %rdi
callq 0xb96c8
cmpl %eax, %ebp
jb 0xa5932
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x22b08
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_iterator.c
// Function: gt_seq_iterator_class_new
const GtSeqIteratorClass*
gt_seq_iterator_class_new(size_t size,
                         GtSeqIteratorSetSymbolmapFunc set_symbolmap,
                         GtSeqIteratorSetSequenceOutFunc set_seqout,
                         GtSeqIteratorNextFunc next_func,
                         GtSeqIteratorGetCurrCounterFunc get_curr_counter_func,
                         GtSeqIteratorSetQualBufferFunc set_qual_buffer_func,
                         GtSeqIteratorFreeFunc free_func)
{
  GtSeqIteratorClass *c_class;
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->set_symbolmap = set_symbolmap;
  c_class->set_seqout = set_seqout;
  c_class->next_func = next_func;
  c_class->get_curr_counter_func = get_curr_counter_func;
  c_class->set_qual_buffer_func = set_qual_buffer_func;
  c_class->free_func = free_func;
  return c_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x38, %edi
callq 0x71ca4
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/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 0xa5a32
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xa5a32
leaq 0x54f31(%rip), %rdx     # 0xfa94f
movl $0x1, %edi
movl $0x3d, %ecx
callq 0x3601f
movq %rbx, (%rax)
popq %rbx
retq
callq 0x22b41
// File: /workspace/github_c_makefile_star2_O1/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 0xa5ae4
movq (%rdi), %rax
testq %rax, %rax
je 0xa5ae1
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xa5ae1
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x22c8b
// File: /workspace/github_c_makefile_star2_O1/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 0xa5b05
movq (%rdi), %rax
testq %rax, %rax
je 0xa5b02
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa5b02
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x22cc2
// File: /workspace/github_c_makefile_star2_O1/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 0xa5b3f
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xa5b41
movq 0x30(%rax), %rax
testq %rax, %rax
je 0xa5b2a
movq %rbx, %rdi
callq *%rax
leaq 0x54e1e(%rip), %rsi     # 0xfa94f
movq %rbx, %rdi
movl $0x83, %edx
popq %rbx
jmp 0x362a0
popq %rbx
retq
callq 0x22cf9
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa5b85
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5b8a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa5a37
movq %rbx, 0x20a8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22d6b
// File: /workspace/github_c_makefile_star2_O1/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 0x71d9b
cmpq $0x0, 0xad1d0(%rip)     # 0x152d68
jne 0xa5bd4
leaq 0x882(%rip), %rax       # 0xa6423
movq %rax, (%rsp)
leaq 0x36(%rip), %rsi        # 0xa5be2
leaq 0xbb(%rip), %rcx        # 0xa5c6e
leaq 0x830(%rip), %r8        # 0xa63ea
leaq -0x6a(%rip), %r9        # 0xa5b57
movl $0x20b0, %edi           # imm = 0x20B0
xorl %edx, %edx
callq 0xa59b0
movq %rax, 0xad194(%rip)     # 0x152d68
callq 0x71db1
movq 0xad188(%rip), %rax     # 0x152d68
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa5c10
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5b8a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa5a37
movq %rbx, 0x20a0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22da4
// File: /workspace/github_c_makefile_star2_O1/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 0xa5c45
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa5c45
movq %rdi, %r14
callq 0xa5b8a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa5a37
movq %rbx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22ddd
// File: /workspace/github_c_makefile_star2_O1/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 0xa5c69
movq %rdi, %rbx
callq 0xa5b8a
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa5a37
movq 0x78(%rax), %rax
popq %rbx
retq
callq 0x22e16
// File: /workspace/github_c_makefile_star2_O1/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 0xa641e
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5b8a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa5a37
movq %rbx, 0x80(%rax)
addq $0x88, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22fdc
// File: /workspace/github_c_makefile_star2_O1/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 0xa6480
pushq %rbx
movq %rdi, %rbx
callq 0xa5b8a
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa5a37
movq %rax, %rbx
movq 0x40(%rax), %rdi
callq 0x3d1eb
movq 0x28(%rbx), %rdi
callq 0x3d1eb
movq 0x38(%rbx), %rdi
callq 0x3d1eb
movq 0x30(%rbx), %rdi
callq 0x3d1eb
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xa6471
callq 0x75b7c
movq 0x80(%rbx), %rax
movq %rax, 0x88(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa653f
movl %esi, %ebx
movq %rdi, %r15
callq 0xa5b8a
movq %rax, %rdi
callq 0xa5a06
movq %rax, %r14
callq 0xa5b8a
movq %rax, %rdi
movq %r14, %rsi
callq 0xa5a37
movq %rax, %r12
callq 0x3bfe0
movq %rax, 0x40(%r12)
movq %r15, %rdi
xorl %esi, %esi
callq 0x3d3e2
leaq 0x489bf(%rip), %rsi     # 0xeeea8
movq %rax, %rdi
callq 0x756a8
movq %rax, 0x48(%r12)
movq %r15, 0x90(%r12)
movq $0x1, 0x68(%r12)
callq 0x3bfe0
movq %rax, 0x28(%r12)
callq 0x3bfe0
movq %rax, 0x38(%r12)
callq 0x3bfe0
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 0x2304e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tokenizer.c
// Function: gt_tokenizer_new
GtTokenizer* gt_tokenizer_new(GtIO *io)
{
  GtTokenizer *t;
  gt_assert(io);
  t = gt_calloc(1, sizeof *t);
  t->io = io;
  return t;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa6729
movq %rdi, %rbx
leaq 0x54854(%rip), %rdx     # 0xfaf64
movl $0x1, %edi
movl $0x18, %esi
movl $0x23, %ecx
callq 0x3601f
movq %rbx, (%rax)
popq %rbx
retq
callq 0x2312c