LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x83b5e
movq %rdi, %rbx
cmpb $0x1, 0x29(%rdi)
jne 0x83b5c
movq 0x30(%rbx), %rdi
callq 0x5b20f
testq %rax, %rax
je 0x83b41
movq 0x30(%rbx), %rdi
callq 0x5b26f
testq %rax, %rax
je 0x83b58
movq 0x30(%rbx), %rdi
callq 0x5b195
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
subq %rax, %rdx
movq %rdx, 0x8(%rbx)
leaq (%rdi,%rax), %rsi
cmpq %rax, %rdx
jae 0x83b48
callq 0xb520
jmp 0x83b4d
andq $0x0, 0x8(%rbx)
jmp 0x83b58
callq 0xba50
movq 0x30(%rbx), %rdi
xorl %esi, %esi
callq 0x5b055
movb $0x0, 0x29(%rbx)
popq %rbx
retq
movq 0xaa453(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x464f7(%rip), %rsi     # 0xca066
leaq 0x586f4(%rip), %rdx     # 0xdc26a
leaq 0x5f978(%rip), %rcx     # 0xe34f5
leaq 0x5f8eb(%rip), %r8      # 0xe346f
pushq $0x78
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x83bfb
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testl %eax, %eax
je 0x83c03
decl %eax
movl %eax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0x5f862(%rip), %r14     # 0xe346f
movq %r14, %rsi
movl $0xa4, %edx
callq 0xd249
movq 0x30(%rbx), %rdi
callq 0x5b761
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/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 0x5f8dc(%rip), %rdi     # 0xe3524
xorl %eax, %eax
callq 0xb070
leaq 0x5f8d7(%rip), %rdi     # 0xe352d
xorl %eax, %eax
callq 0xb070
movq 0x30(%rbx), %rdi
leaq 0x12(%rip), %rsi        # 0x83c7a
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5b494
pushq $0xa
popq %rdi
popq %rbx
jmp 0xb860
// File: /workspace/github_c_makefile_star2_O2/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 0x8429f
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x842de
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb720
movq %rax, %r15
testq %rax, %rax
jne 0x842d5
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x5f3b3(%rip), %rsi     # 0xe3678
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc007
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa9cd3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45d77(%rip), %rsi     # 0xca066
leaq 0x46363(%rip), %rdx     # 0xca659
leaq 0x5f360(%rip), %rcx     # 0xe365d
leaq 0x5f363(%rip), %r8      # 0xe3667
pushq $0x17
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x84333
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x84372
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79c97
movq %rax, %r15
testq %rax, %rax
jne 0x84369
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x5f35f(%rip), %rsi     # 0xe36b8
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc007
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa9c3f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45ce3(%rip), %rsi     # 0xca066
leaq 0x462cf(%rip), %rdx     # 0xca659
leaq 0x5f30a(%rip), %rcx     # 0xe369b
leaq 0x5f30e(%rip), %r8      # 0xe36a6
pushq $0x19
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x843c7
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x84406
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7a2ea
movq %rax, %r15
testq %rax, %rax
jne 0x843fd
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x5f30f(%rip), %rsi     # 0xe36fc
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc007
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa9bab(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45c4f(%rip), %rsi     # 0xca066
leaq 0x4623b(%rip), %rdx     # 0xca659
leaq 0x5f2bb(%rip), %rcx     # 0xe36e0
leaq 0x5f2bf(%rip), %r8      # 0xe36eb
pushq $0x19
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x844d6
movq %rsi, %r14
cmpb $0x72, (%rsi)
jne 0x844ac
cmpb $0x0, 0x1(%r14)
jne 0x844ac
movq %rdi, %rbx
leaq 0x5f2c7(%rip), %rsi     # 0xe372a
pushq $0x20
popq %rdi
pushq $0x23
popq %rdx
callq 0xccb0
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x540ec
movq %rax, (%r15)
testq %rbx, %rbx
leaq 0x5270b(%rip), %rdi     # 0xd6b94
cmovneq %rbx, %rdi
callq 0x13da9
movq %rax, 0x8(%r15)
movq $0x1, 0x10(%r15)
movb $0x1, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa9b05(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45ba9(%rip), %rsi     # 0xca066
leaq 0x5f274(%rip), %rdx     # 0xe3738
leaq 0x5f255(%rip), %rcx     # 0xe3720
leaq 0x5f258(%rip), %r8      # 0xe372a
pushq $0x22
jmp 0x844fe
movq 0xa9adb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45b7f(%rip), %rsi     # 0xca066
leaq 0x5536e(%rip), %rdx     # 0xd985c
leaq 0x5f22b(%rip), %rcx     # 0xe3720
leaq 0x5f22e(%rip), %r8      # 0xe372a
pushq $0x20
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x84539
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x548ae
movq 0x8(%rbx), %rdi
callq 0x152db
leaq 0x5f1fd(%rip), %rsi     # 0xe372a
pushq $0x30
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8457f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x8457f
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x541f3
cmpl $0xa, %eax
jne 0x84563
incq 0x10(%r14)
movb $0x1, %cl
jmp 0x84565
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
movq 0xa9a32(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45ad6(%rip), %rsi     # 0xca066
leaq 0x5f1b4(%rip), %rdx     # 0xe374b
leaq 0x5f1b5(%rip), %rcx     # 0xe3753
leaq 0x5f185(%rip), %r8      # 0xe372a
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movb $0x0, 0xf(%rsp)
testq %rdi, %rdi
je 0x8467b
movq %rdi, %rbx
leaq 0xf(%rsp), %r14
movq %r14, %rsi
callq 0x8453a
movl %eax, %ebp
movsbl (%r14), %esi
movq %rbx, %rdi
callq 0x845b5
testl %ebp, %ebp
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xa9936(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x459da(%rip), %rsi     # 0xca066
leaq 0x513fc(%rip), %rdx     # 0xd5a8f
leaq 0x5f0ea(%rip), %rcx     # 0xe3784
leaq 0x5f089(%rip), %r8      # 0xe372a
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x846e1
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movq %r14, %rsi
callq 0x8453a
movsbl (%r14), %esi
movq %rbx, %rdi
callq 0x845b5
movb (%r14), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa98d0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45974(%rip), %rsi     # 0xca066
leaq 0x51396(%rip), %rdx     # 0xd5a8f
leaq 0x5f093(%rip), %rcx     # 0xe3793
leaq 0x5f023(%rip), %r8      # 0xe372a
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x10, %rsp
testq %rdi, %rdi
je 0x84736
leaq 0xf(%rsp), %rbx
movq %rbx, %rsi
callq 0x8453a
movb (%rbx), %al
addq $0x10, %rsp
popq %rbx
retq
movq 0xa987b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4591f(%rip), %rsi     # 0xca066
leaq 0x51341(%rip), %rdx     # 0xd5a8f
leaq 0x5f049(%rip), %rcx     # 0xe379e
leaq 0x5efce(%rip), %r8      # 0xe372a
pushq $0x66
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x84862
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x8494f
movq %r14, %rdi
callq 0x84717
xorl %ebp, %ebp
cmpb %r15b, %al
je 0x84944
movl %r15d, %ecx
xorb $0xa, %cl
movl %eax, %edx
xorb $0xd, %dl
orb %cl, %dl
jne 0x848a1
movq %r14, %rdi
callq 0x846b1
cmpb $0xa, %al
jne 0x84944
movq %r14, %rdi
callq 0x84717
jmp 0x84944
movsbl %al, %ebp
cmpb $-0x1, %r15b
je 0x848e2
movsbl %r15b, %r15d
cmpb $0xd, %al
je 0x848ba
movzbl %al, %eax
cmpl $0xa, %eax
jne 0x84911
movq %r14, %rdi
callq 0x847ad
movq %rax, %r12
movq %r14, %rdi
callq 0x8476c
leaq 0x5ef65(%rip), %rsi     # 0xe3839
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %r15d, %r8d
jmp 0x84908
movq %r14, %rdi
callq 0x847ad
movq %rax, %r15
movq %r14, %rdi
callq 0x8476c
leaq 0x5ef09(%rip), %rsi     # 0xe3805
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0xc007
jmp 0x84941
movq %r14, %rdi
callq 0x847ad
movq %rax, %r12
movq %r14, %rdi
callq 0x8476c
leaq 0x5ef48(%rip), %rsi     # 0xe3873
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %r15d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xa9662(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45706(%rip), %rsi     # 0xca066
leaq 0x45cf2(%rip), %rdx     # 0xca659
leaq 0x5ee8a(%rip), %rcx     # 0xe37f8
leaq 0x5edb5(%rip), %r8      # 0xe372a
movl $0x80, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x84a48
movq %rdi, %r15
leaq 0x5ef04(%rip), %r14     # 0xe38be
pushq $0x18
popq %rdi
pushq $0x28
popq %rdx
movq %r14, %rsi
callq 0xccb0
movq %rax, %rbx
movq %r15, %rdi
callq 0x9ad5a
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x9b5de
movl %eax, 0x8(%rbx)
movl %eax, %edi
shlq $0x3, %rdi
pushq $0x2b
popq %rbp
movq %r14, %rsi
movl %ebp, %edx
callq 0xccb0
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %edi
imull %edi, %edi
pushq $0x4
popq %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0xce9a
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl 0x8(%rbx), %eax
pushq $0x1
popq %rcx
leaq (,%rax,4), %rdx
cmpq %rax, %rcx
jae 0x84a3a
movq 0x10(%rbx), %rsi
movq -0x8(%rsi,%rcx,8), %rdi
addq %rdx, %rdi
movq %rdi, (%rsi,%rcx,8)
incq %rcx
jmp 0x84a20
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xa9569(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4560d(%rip), %rsi     # 0xca066
leaq 0x5eeb8(%rip), %rdx     # 0xe3918
leaq 0x5ee43(%rip), %rcx     # 0xe38aa
leaq 0x5ee50(%rip), %r8      # 0xe38be
pushq $0x27
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x84aa5
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x84b1f
testq %r14, %r14
je 0x84af1
callq 0x9b369
movq %rax, %r12
movq %rax, %rdi
callq 0x849a0
movq %rax, %r15
movq %r12, %rdi
callq 0x9b1c1
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x84b57
testl %eax, %eax
je 0x84ae2
movq %r15, %rdi
callq 0x8516d
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xa94c0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45564(%rip), %rsi     # 0xca066
leaq 0x551a1(%rip), %rdx     # 0xd9caa
leaq 0x5edc6(%rip), %rcx     # 0xe38d6
leaq 0x5eda7(%rip), %r8      # 0xe38be
movl $0xe5, %r9d
jmp 0x84b4b
movq 0xa9492(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45536(%rip), %rsi     # 0xca066
leaq 0x45b22(%rip), %rdx     # 0xca659
leaq 0x5ed98(%rip), %rcx     # 0xe38d6
leaq 0x5ed79(%rip), %r8      # 0xe38be
movl $0xe4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x851c4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x9b1c1
movq 0x10(%rbx), %rax
movq (%rax), %rdi
leaq 0x5e72f(%rip), %r14     # 0xe38be
movq %r14, %rsi
movl $0x13c, %edx            # imm = 0x13C
callq 0xd249
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x13c, %edx            # imm = 0x13C
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0x13d, %edx            # imm = 0x13D
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x851e4
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x8524d
testq %r14, %r14
je 0x8521f
testq %r15, %r15
je 0x8521f
movq %r15, %rdi
callq 0x849a0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x84b57
testl %eax, %eax
je 0x85216
movq %r15, %rdi
callq 0x8516d
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa8d92(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44e36(%rip), %rsi     # 0xca066
leaq 0x5e6d9(%rip), %rdx     # 0xe3910
leaq 0x5e6b9(%rip), %rcx     # 0xe38f7
leaq 0x5e679(%rip), %r8      # 0xe38be
movl $0xfb, %r9d
jmp 0x85279
movq 0xa8d64(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44e08(%rip), %rsi     # 0xca066
leaq 0x453f4(%rip), %rdx     # 0xca659
leaq 0x5e68b(%rip), %rcx     # 0xe38f7
leaq 0x5e64b(%rip), %r8      # 0xe38be
movl $0xfa, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x85302
cmpl $0xfe, %esi
jne 0x852da
movl 0x8(%rdi), %esi
decl %esi
movl 0x8(%rdi), %ecx
leal -0x1(%rcx), %eax
cmpl $0xfe, %edx
cmovnel %edx, %eax
cmpl %ecx, %esi
jae 0x85330
cmpl %ecx, %eax
jae 0x85330
movq 0x10(%rdi), %rcx
movl %esi, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %eax
popq %rcx
retq
movq 0xa8caf(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44d53(%rip), %rsi     # 0xca066
leaq 0x59c3c(%rip), %rdx     # 0xdef56
leaq 0x5e61e(%rip), %rcx     # 0xe393f
leaq 0x5e596(%rip), %r8      # 0xe38be
movl $0x10d, %r9d            # imm = 0x10D
jmp 0x8535c
movq 0xa8c81(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44d25(%rip), %rsi     # 0xca066
leaq 0x5e611(%rip), %rdx     # 0xe3959
leaq 0x5e5f0(%rip), %rcx     # 0xe393f
leaq 0x5e568(%rip), %r8      # 0xe38be
movl $0x111, %r9d            # imm = 0x111
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x853a7
cmpl $0xfe, %esi
jne 0x8537b
movl 0x8(%rdi), %esi
decl %esi
movl 0x8(%rdi), %r8d
leal -0x1(%r8), %eax
cmpl $0xfe, %edx
cmovnel %edx, %eax
cmpl %r8d, %esi
jae 0x853d5
cmpl %r8d, %eax
jae 0x853d5
movq 0x10(%rdi), %rdx
movl %esi, %esi
movq (%rdx,%rsi,8), %rdx
movl %eax, %eax
movl %ecx, (%rdx,%rax,4)
popq %rax
retq
movq 0xa8c0a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44cae(%rip), %rsi     # 0xca066
leaq 0x59b97(%rip), %rdx     # 0xdef56
leaq 0x5e5c0(%rip), %rcx     # 0xe3986
leaq 0x5e4f1(%rip), %r8      # 0xe38be
movl $0x118, %r9d            # imm = 0x118
jmp 0x85401
movq 0xa8bdc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44c80(%rip), %rsi     # 0xca066
leaq 0x5e56c(%rip), %rdx     # 0xe3959
leaq 0x5e592(%rip), %rcx     # 0xe3986
leaq 0x5e4c3(%rip), %r8      # 0xe38be
movl $0x11c, %r9d            # imm = 0x11C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8553e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x8553e
movq %rdi, %r14
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x1640e
leaq 0x5e554(%rip), %r15     # 0xe39d9
xorl %ebp, %ebp
movq (%r14), %rdi
callq 0x9b5de
cmpl %eax, %ebp
jae 0x854b3
movq (%r14), %rdi
movzbl %bpl, %esi
callq 0x9bed8
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb8c0
incl %ebp
jmp 0x85487
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1640e
leaq 0x5e517(%rip), %r15     # 0xe39de
xorl %r12d, %r12d
movq (%r14), %rdi
callq 0x9b5de
cmpl %eax, %r12d
jae 0x8552f
movq (%r14), %rdi
movzbl %r12b, %esi
callq 0x9bed8
movsbl %al, %edi
movq %rbx, %rsi
callq 0x1640e
xorl %r13d, %r13d
movq (%r14), %rdi
callq 0x9b5de
cmpl %eax, %r13d
jae 0x85520
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x852c7
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0xb8c0
incl %r13d
jmp 0x854f1
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1640e
incl %r12d
jmp 0x854ca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa8a73(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44b17(%rip), %rsi     # 0xca066
leaq 0x5e465(%rip), %rdx     # 0xe39bb
leaq 0x5e467(%rip), %rcx     # 0xe39c4
leaq 0x5e35a(%rip), %r8      # 0xe38be
movl $0x129, %r9d            # imm = 0x129
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rdi
callq 0x4f148
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_O2/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 0x855f4
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x855f4
leaq 0x5e5eb(%rip), %rdx     # 0xe3bcf
pushq $0x1
popq %rdi
pushq $0x3d
popq %rcx
callq 0xce9a
movq %rbx, (%rax)
popq %rbx
retq
movq 0xa89bd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44a61(%rip), %rsi     # 0xca066
leaq 0x56a5e(%rip), %rdx     # 0xdc06a
leaq 0x5e5a5(%rip), %rcx     # 0xe3bb8
leaq 0x5e5b5(%rip), %r8      # 0xe3bcf
pushq $0x3c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x857cc
movq (%rdi), %rax
testq %rax, %rax
je 0x857c9
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x857c9
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0xa87e4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44888(%rip), %rsi     # 0xca066
leaq 0x5e417(%rip), %rdx     # 0xe3bfc
leaq 0x5e4d4(%rip), %rcx     # 0xe3cc0
leaq 0x5e3dc(%rip), %r8      # 0xe3bcf
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x8581e
movq (%rdi), %rax
testq %rax, %rax
je 0x8581b
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x8581b
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0xa8792(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44836(%rip), %rsi     # 0xca066
leaq 0x5e3c5(%rip), %rdx     # 0xe3bfc
leaq 0x5e497(%rip), %rcx     # 0xe3cd5
leaq 0x5e38a(%rip), %r8      # 0xe3bcf
pushq $0x76
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x85889
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x8588b
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x85874
movq %rbx, %rdi
callq *%rax
leaq 0x5e354(%rip), %rsi     # 0xe3bcf
movq %rbx, %rdi
movl $0x83, %edx
popq %rbx
jmp 0xd249
popq %rbx
retq
movq 0xa8726(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x447ca(%rip), %rsi     # 0xca066
leaq 0x5e454(%rip), %rdx     # 0xe3cf7
leaq 0x5e45c(%rip), %rcx     # 0xe3d06
leaq 0x5e31e(%rip), %r8      # 0xe3bcf
movl $0x80, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x85934
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8596c
movq %rax, %rdi
movq %r14, %rsi
callq 0x8562a
movq %rbx, 0x20a8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa867d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44721(%rip), %rsi     # 0xca066
leaq 0x6d808(%rip), %rdx     # 0xf3154
leaq 0x5e40d(%rip), %rcx     # 0xe3d60
leaq 0x5e3e8(%rip), %r8      # 0xe3d42
movl $0x13f, %r9d            # imm = 0x13F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4f21f
cmpq $0x0, 0xaa3de(%rip)     # 0x12fd58
jne 0x859b6
leaq 0x8db(%rip), %rax       # 0x8625e
movq %rax, (%rsp)
leaq 0x36(%rip), %rsi        # 0x859c4
leaq 0x154(%rip), %rcx       # 0x85ae9
leaq 0x856(%rip), %r8        # 0x861f2
leaq -0x9d(%rip), %r9        # 0x85906
movl $0x20b0, %edi           # imm = 0x20B0
xorl %edx, %edx
callq 0x85578
movq %rax, 0xaa3a2(%rip)     # 0x12fd58
callq 0x4f266
movq 0xaa396(%rip), %rax     # 0x12fd58
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x859f2
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8596c
movq %rax, %rdi
movq %r14, %rsi
callq 0x8562a
movq %rbx, 0x20a0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa85bf(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x44663(%rip), %rsi     # 0xca066
leaq 0x6d74a(%rip), %rdx     # 0xf3154
leaq 0x5e378(%rip), %rcx     # 0xe3d89
leaq 0x5e32a(%rip), %r8      # 0xe3d42
movl $0x148, %r9d            # imm = 0x148
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x85a5a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x85a5a
movq %rdi, %r14
callq 0x8596c
movq %rax, %rdi
movq %r14, %rsi
callq 0x8562a
movq %rbx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa8557(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x445fb(%rip), %rsi     # 0xca066
leaq 0x5e33b(%rip), %rdx     # 0xe3dad
leaq 0x5e343(%rip), %rcx     # 0xe3dbc
leaq 0x5e2c2(%rip), %r8      # 0xe3d42
movl $0x151, %r9d            # imm = 0x151
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x85ab1
movq %rdi, %rbx
callq 0x8596c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8562a
movq 0x78(%rax), %rax
popq %rbx
retq
movq 0xa8500(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x445a4(%rip), %rsi     # 0xca066
leaq 0x6d68b(%rip), %rdx     # 0xf3154
leaq 0x5e312(%rip), %rcx     # 0xe3de2
leaq 0x5e26b(%rip), %r8      # 0xe3d42
movl $0x159, %r9d            # imm = 0x159
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x86226
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8596c
movq %rax, %rdi
movq %r14, %rsi
callq 0x8562a
movq %rbx, 0x80(%rax)
addq $0x88, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa7d8b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x43e2f(%rip), %rsi     # 0xca066
leaq 0x6cf16(%rip), %rdx     # 0xf3154
leaq 0x5dbf9(%rip), %rcx     # 0xe3e3e
leaq 0x5daf6(%rip), %r8      # 0xe3d42
movl $0x19e, %r9d            # imm = 0x19E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x862bb
pushq %rbx
movq %rdi, %rbx
callq 0x8596c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8562a
movq %rax, %rbx
movq 0x40(%rax), %rdi
callq 0x152db
movq 0x28(%rbx), %rdi
callq 0x152db
movq 0x38(%rbx), %rdi
callq 0x152db
movq 0x30(%rbx), %rdi
callq 0x152db
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x862ac
callq 0x548ae
movq 0x80(%rbx), %rax
movq %rax, 0x88(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x863ad
movl %esi, %ebx
movq %rdi, %r15
callq 0x8596c
movq %rax, %rdi
callq 0x855cc
movq %rax, %r14
callq 0x8596c
movq %rax, %rdi
movq %r14, %rsi
callq 0x8562a
movq %rax, %r12
callq 0x13d5c
movq %rax, 0x40(%r12)
movq %r15, %rdi
xorl %esi, %esi
callq 0x1555e
leaq 0x51aae(%rip), %rsi     # 0xd7e05
movq %rax, %rdi
callq 0x540ec
movq %rax, 0x48(%r12)
movq %r15, 0x90(%r12)
movq $0x1, 0x68(%r12)
callq 0x13d5c
movq %rax, 0x28(%r12)
callq 0x13d5c
movq %rax, 0x38(%r12)
callq 0x13d5c
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
movq 0xa7c04(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x43ca8(%rip), %rsi     # 0xca066
leaq 0x6889b(%rip), %rdx     # 0xeec60
leaq 0x5dded(%rip), %rcx     # 0xe41b9
leaq 0x5d96f(%rip), %r8      # 0xe3d42
movl $0x1c9, %r9d            # imm = 0x1C9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: parse_fastq_seqname
static inline int parse_fastq_seqname(GtSeqIteratorFastQ *seqit,
                                      GtStr *buffer,
                                      char startchar,
                                      GtError *err)
{
  char currentchar;
  bool firstsymbol = true;
  gt_error_check(err);
  gt_assert(seqit && buffer);
  gt_assert(gt_str_length(buffer) == 0);
  if ((currentchar = fastq_buf_getchar(seqit)) == EOF)
    return EOF;
  seqit->currentread++;
  if (currentchar != startchar) {
    gt_error_set(err, "'%c' expected, '%c' encountered instead in line "GT_WU"",
                      startchar,
                      currentchar,
                      seqit->curline);
    return -2;
  }
  while (currentchar != GT_FASTQ_NEWLINESYMBOL) {
    if (!firstsymbol)
      gt_str_append_char(buffer, currentchar);
    else
      firstsymbol = false;
    if ((currentchar = fastq_buf_getchar(seqit)) == EOF)
      return EOF;
    seqit->currentread++;
  }
  seqit->curline++;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x86416
movq %r15, %rdi
callq 0xc103
testb %al, %al
jne 0x86506
testq %r14, %r14
je 0x864b2
movq %r14, %rdi
callq 0x14461
testq %rax, %rax
jne 0x864dc
movq %rbx, %rdi
callq 0x8653c
movl %eax, %ecx
shll $0x18, %ecx
pushq $-0x1
popq %rbp
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x864a7
incq 0x88(%rbx)
movsbl %al, %ecx
movzbl %r12b, %edx
cmpl %edx, %ecx
jne 0x86487
movb $0x1, %cl
cmpb $0xa, %al
je 0x864a1
testb $0x1, %cl
jne 0x86470
movsbl %al, %esi
movq %r14, %rdi
callq 0x140b1
movq %rbx, %rdi
callq 0x8653c
cmpb $-0x1, %al
je 0x864a7
incq 0x88(%rbx)
xorl %ecx, %ecx
jmp 0x8645c
movq 0x68(%rbx), %r8
leaq 0x5db4f(%rip), %rsi     # 0xe3fe1
movq %r15, %rdi
xorl %eax, %eax
callq 0xc007
pushq $-0x2
popq %rbp
jmp 0x864a7
incq 0x68(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xa7aff(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x43ba3(%rip), %rsi     # 0xca066
leaq 0x5daec(%rip), %rdx     # 0xe3fb6
leaq 0x5dad1(%rip), %rcx     # 0xe3fa2
leaq 0x5d86a(%rip), %r8      # 0xe3d42
pushq $0x65
jmp 0x8652e
movq 0xa7ad5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x43b79(%rip), %rsi     # 0xca066
leaq 0x5dad2(%rip), %rdx     # 0xe3fc6
leaq 0x5daa7(%rip), %rcx     # 0xe3fa2
leaq 0x5d840(%rip), %r8      # 0xe3d42
pushq $0x66
jmp 0x8652e
movq 0xa7aab(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x43b4f(%rip), %rsi     # 0xca066
leaq 0x4413b(%rip), %rdx     # 0xca659
leaq 0x5da7d(%rip), %rcx     # 0xe3fa2
leaq 0x5d816(%rip), %r8      # 0xe3d42
pushq $0x64
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: fastq_buf_getchar
static inline int fastq_buf_getchar(GtSeqIteratorFastQ *seqit)
{
  if (seqit->use_ungetchar) {
    seqit->use_ungetchar = false;
    return seqit->ungetchar;
  } else {
    if (seqit->currentinpos >= seqit->currentfillpos) {
      seqit->currentfillpos = gt_file_xread(seqit->curfile, seqit->inbuf,
                                             GT_SEQIT_QUAL_INBUFSIZE);
      if (seqit->currentfillpos == 0)
         return EOF;
      seqit->currentinpos = 0;
    }
    seqit->ungetchar = seqit->inbuf[seqit->currentinpos++];
    return seqit->ungetchar;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x21(%rdi)
jne 0x86553
movb $0x0, 0x21(%rbx)
movzbl 0x98(%rbx), %eax
jmp 0x86594
movq 0x60(%rbx), %rax
cmpq 0x58(%rbx), %rax
jb 0x8657e
movq 0x48(%rbx), %rdi
leaq 0x99(%rbx), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x54709
cltq
movq %rax, 0x58(%rbx)
testl %eax, %eax
je 0x86596
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x60(%rbx)
movzbl 0x99(%rbx,%rax), %eax
movb %al, 0x98(%rbx)
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0x86594
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x865bf
movq %rdi, %rbx
leaq 0x5dc38(%rip), %rdx     # 0xe41e4
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x23
popq %rcx
callq 0xce9a
movq %rbx, (%rax)
popq %rbx
retq
movq 0xa79f2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x43a96(%rip), %rsi     # 0xca066
leaq 0x4f4b8(%rip), %rdx     # 0xd5a8f
leaq 0x5dbf5(%rip), %rcx     # 0xe41d3
leaq 0x5dbff(%rip), %r8      # 0xe41e4
pushq $0x22
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/tokenizer.c
// Function: gt_tokenizer_has_token
bool gt_tokenizer_has_token(GtTokenizer *t)
{
  bool has_token = false;
  GtStr *token;
  gt_assert(t);
  token = gt_tokenizer_get_token(t);
  if (token) {
    has_token = true;
    gt_str_delete(token);
  }
  return has_token;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x86826
callq 0x86636
movq %rax, %rbx
testq %rax, %rax
je 0x8681e
movq %rbx, %rdi
callq 0x152db
testq %rbx, %rbx
setne %al
popq %rbx
retq
movq 0xa778b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4382f(%rip), %rsi     # 0xca066
leaq 0x4d410(%rip), %rdx     # 0xd3c4e
leaq 0x5da0c(%rip), %rcx     # 0xe4251
leaq 0x5d998(%rip), %r8      # 0xe41e4
pushq $0x6f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/tokenizer.c
// Function: gt_tokenizer_delete
void gt_tokenizer_delete(GtTokenizer *t)
{
  if (!t) return;
  gt_io_delete(t->io);
  gt_str_delete(t->token);
  gt_free(t);
}

// Assembly:
testq %rdi, %rdi
je 0x86dd1
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8450c
movq 0x10(%rbx), %rdi
callq 0x152db
leaq 0x5d421(%rip), %rsi     # 0xe41e4
movq %rbx, %rdi
movl $0xd1, %edx
popq %rbx
jmp 0xd249
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_new_with_table
GtTranslator* gt_translator_new_with_table(GtTransTable *tt,
                                           GtCodonIterator *ci)
{
  GtTranslator *tr;
  gt_assert(tt && ci);
  tr = gt_calloc((size_t) 1, sizeof (GtTranslator));
  tr->transtable = tt;
  tr->ci = ci;
  tr->owntable = false;
  return tr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x86e10
movq %rsi, %rbx
testq %rsi, %rsi
je 0x86e10
movq %rdi, %r14
leaq 0x5d608(%rip), %rdx     # 0xe43f7
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x26
popq %rcx
callq 0xce9a
movq %r14, (%rax)
movq %rbx, 0x10(%rax)
movb $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa71a1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x43245(%rip), %rsi     # 0xca066
leaq 0x5d5a9(%rip), %rdx     # 0xe43d1
leaq 0x5d5ab(%rip), %rcx     # 0xe43da
leaq 0x5d5c1(%rip), %r8      # 0xe43f7
pushq $0x25
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_new
GtTranslator* gt_translator_new(GtCodonIterator *ci)
{
  GtTranslator *tr;
  gt_assert(ci);
  tr = gt_translator_new_with_table(gt_trans_table_new_standard(NULL), ci);
  tr->owntable = true;
  return tr;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x86e67
movq %rdi, %rbx
xorl %edi, %edi
callq 0xc0f0b
movq %rax, %rdi
movq %rbx, %rsi
callq 0x86dd4
movb $0x1, 0x8(%rax)
popq %rbx
retq
movq 0xa714a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x431ee(%rip), %rsi     # 0xca066
leaq 0x5d5ae(%rip), %rdx     # 0xe442d
leaq 0x5d587(%rip), %rcx     # 0xe440d
leaq 0x5d56a(%rip), %r8      # 0xe43f7
pushq $0x30
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_set_translation_table
void gt_translator_set_translation_table(GtTranslator *translator,
                                         GtTransTable *tt)
{
  gt_assert(translator && tt);
  if (translator->owntable) {
    gt_trans_table_delete(translator->transtable);
    translator->owntable = false;
  }
  translator->transtable = tt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x86f5b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x86f5b
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0x86f50
movq (%r14), %rdi
callq 0xc129e
movb $0x0, 0x8(%r14)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa7056(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x430fa(%rip), %rsi     # 0xca066
leaq 0x5d4f2(%rip), %rdx     # 0xe4465
leaq 0x5d4fc(%rip), %rcx     # 0xe4476
leaq 0x5d476(%rip), %r8      # 0xe43f7
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300