LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdfc1c
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xdfc54
movq 0xd43b5(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7e439(%rip), %rsi     # 0x15e066
leaq 0x98778(%rip), %rdx     # 0x1783ac
leaq 0x987a6(%rip), %rcx     # 0x1783e1
leaq 0x986ca(%rip), %r8      # 0x17830c
movl $0x5a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdfc56
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xdfc7f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0xdfc88
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %r9, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xdfd54
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xdfd8c
movq 0xd427d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7e301(%rip), %rsi     # 0x15e066
leaq 0x98640(%rip), %rdx     # 0x1783ac
leaq 0x986a0(%rip), %rcx     # 0x178413
leaq 0x98592(%rip), %r8      # 0x17830c
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdfd8e
movq 0x28(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xdfdce
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0xdfdd6
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xdfdf1
jmp 0xdfe84
jmp 0xdfdf3
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xdfe35
movq 0xd41d4(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7e258(%rip), %rsi     # 0x15e066
leaq 0x9859d(%rip), %rdx     # 0x1783b2
leaq 0x9860e(%rip), %rcx     # 0x17842a
leaq 0x984e9(%rip), %r8      # 0x17830c
movl $0x75, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdfe37
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xdfe56
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x984a7(%rip), %rsi     # 0x17830c
movl $0x78, %edx
callq 0xdab0
movq (%rsp), %rdi
leaq 0x98492(%rip), %rsi     # 0x17830c
movl $0x79, %edx
callq 0xdab0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x7b730
cmpq $0x0, 0xd67a2(%rip)     # 0x1b6640
jne 0xdfed1
movl $0x18, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x30(%rip), %rdx        # 0xdfee0
leaq 0x89(%rip), %rcx        # 0xdff40
leaq 0xe2(%rip), %r8         # 0xdffa0
leaq 0xfb(%rip), %r9         # 0xdffc0
callq 0xdf8c0
movq %rax, 0xd676f(%rip)     # 0x1b6640
callq 0x7b790
movq 0xd6763(%rip), %rax     # 0x1b6640
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xe01a3
cmpq $0x3, 0x18(%rsp)
jae 0xe01db
movq 0xd3e2e(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7deb2(%rip), %rsi     # 0x15e066
leaq 0x98288(%rip), %rdx     # 0x178443
leaq 0x982a2(%rip), %rcx     # 0x178464
leaq 0x982b8(%rip), %r8      # 0x178481
movl $0x61, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe01dd
jmp 0xe01df
cmpq $0x0, 0x10(%rsp)
je 0xe022f
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xe01f7
jmp 0xe022f
movq 0xd3dda(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7de5e(%rip), %rsi     # 0x15e066
leaq 0x7e439(%rip), %rdx     # 0x15e648
leaq 0x9824e(%rip), %rcx     # 0x178464
leaq 0x98264(%rip), %r8      # 0x178481
movl $0x62, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe0231
callq 0xdfe90
movq %rax, %rdi
callq 0xdf990
movq %rax, (%rsp)
callq 0xdfe90
movq %rax, %rdi
movq (%rsp), %rsi
callq 0xdfa50
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x40, %edi
leaq 0x98082(%rip), %rsi     # 0x17859f
movl $0x30, %edx
callq 0xd2e0
movq %rax, (%rsp)
movl $0x2000, %edi           # imm = 0x2000
movl $0x1, %esi
leaq 0x98063(%rip), %rdx     # 0x17859f
movl $0x31, %ecx
callq 0xd5b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x2000, 0x20(%rax)     # imm = 0x2000
movq (%rsp), %rax
movb $0x0, 0x28(%rax)
movq (%rsp), %rax
movb $0x1, 0x29(%rax)
movq (%rsp), %rax
movb $0x0, 0x2a(%rax)
movq (%rsp), %rax
movb $0x0, 0x2b(%rax)
movq (%rsp), %rax
movl $0x0, 0x38(%rax)
callq 0x909b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
movq 0x30(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x909d0
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe0680
movq 0xd3989(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7da0d(%rip), %rsi     # 0x15e066
leaq 0x909ca(%rip), %rdx     # 0x17102a
leaq 0x97f75(%rip), %rcx     # 0x1785dc
leaq 0x97f31(%rip), %r8      # 0x17859f
movl $0x47, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe0682
movq 0x10(%rsp), %rax
testb $0x1, 0x2a(%rax)
je 0xe06cb
movq 0x10(%rsp), %rax
testb $0x1, 0x2b(%rax)
je 0xe069d
jmp 0xe0774
callq 0xb6b0
movq (%rax), %rax
movsbl 0xf(%rsp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xe06c9
movq 0x10(%rsp), %rax
movb $0x1, 0x2b(%rax)
jmp 0xe0774
jmp 0xe06cb
movq 0x10(%rsp), %rax
testb $0x1, 0x28(%rax)
je 0xe06f6
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x909d0
movq 0x10(%rsp), %rax
movb $0x0, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x2, %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0xe0740
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
addq $0x2, %rdx
shlq $0x0, %rdx
callq 0x7f2b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movb 0xf(%rsp), %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe07c9
movq 0xd3840(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7d8c4(%rip), %rsi     # 0x15e066
leaq 0x90881(%rip), %rdx     # 0x17102a
leaq 0x97e47(%rip), %rcx     # 0x1785f7
leaq 0x97de8(%rip), %r8      # 0x17859f
movl $0x5e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe07cb
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x90c50
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movb $0x1, 0x29(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xe0844
movq 0xd37c5(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7d849(%rip), %rsi     # 0x15e066
leaq 0x90806(%rip), %rdx     # 0x17102a
leaq 0x97de4(%rip), %rcx     # 0x17860f
leaq 0x97d6d(%rip), %r8      # 0x17859f
movl $0x66, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe0846
movq (%rsp), %rax
movb $0x0, 0x2b(%rax)
movq (%rsp), %rdi
xorl %esi, %esi
callq 0xe0630
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xe087b
movq (%rsp), %rax
movq 0x18(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movb $0x1, 0x28(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe0919
movq 0xd36f0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7d774(%rip), %rsi     # 0x15e066
leaq 0x90731(%rip), %rdx     # 0x17102a
leaq 0x97d25(%rip), %rcx     # 0x178625
leaq 0x97c98(%rip), %r8      # 0x17859f
movl $0x78, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe091b
movq 0x10(%rsp), %rax
testb $0x1, 0x29(%rax)
jne 0xe092b
jmp 0xe0a1e
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x90d30
cmpq $0x0, %rax
jne 0xe095a
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x29(%rax)
jmp 0xe0a1e
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x90df0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xe0a15
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x90c50
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
subq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
jb 0xe09dc
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
addq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
shlq $0x0, %rdx
callq 0xba20
jmp 0xe0a03
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
addq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
shlq $0x0, %rdx
callq 0xb500
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x909d0
movq 0x10(%rsp), %rax
movb $0x0, 0x29(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xe0ace
jmp 0xe0b21
movq (%rsp), %rax
cmpl $0x0, 0x38(%rax)
je 0xe0ae7
movq (%rsp), %rax
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0xe0b21
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x97aaa(%rip), %rsi     # 0x17859f
movl $0xa4, %edx
callq 0xdab0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x91770
movq (%rsp), %rdi
leaq 0x97a88(%rip), %rsi     # 0x17859f
movl $0xa6, %edx
callq 0xdab0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0x97b11(%rip), %rdi     # 0x178654
movb $0x0, %al
callq 0xb070
leaq 0x97b0c(%rip), %rdi     # 0x17865d
movb $0x0, %al
callq 0xb070
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x29(%rip), %rsi        # 0xe0b90
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x912f0
leaq 0x9506b(%rip), %rdi     # 0x175be5
movb $0x0, %al
callq 0xb070
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xe14e3
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xe14ab
jmp 0xe14e3
movq 0xd2b26(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7cbaa(%rip), %rsi     # 0x15e066
leaq 0x7d185(%rip), %rdx     # 0x15e648
leaq 0x972c3(%rip), %rcx     # 0x17878d
leaq 0x972c6(%rip), %r8      # 0x178797
movl $0x17, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe14e5
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xb6f0
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0xe153a
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xb060
movl (%rax), %edi
callq 0xb1b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x97275(%rip), %rsi     # 0x1787a8
movb $0x0, %al
callq 0xc0d0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xe15b3
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xe157b
jmp 0xe15b3
movq 0xd2a56(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7cada(%rip), %rsi     # 0x15e066
leaq 0x7d0b5(%rip), %rdx     # 0x15e648
leaq 0x97231(%rip), %rcx     # 0x1787cb
leaq 0x97235(%rip), %r8      # 0x1787d6
movl $0x19, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe15b5
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xcbaa0
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0xe160a
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xb060
movl (%rax), %edi
callq 0xb1b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x971e5(%rip), %rsi     # 0x1787e8
movb $0x0, %al
callq 0xc0d0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xe1683
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xe164b
jmp 0xe1683
movq 0xd2986(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7ca0a(%rip), %rsi     # 0x15e066
leaq 0x7cfe5(%rip), %rdx     # 0x15e648
leaq 0x971a6(%rip), %rcx     # 0x178810
leaq 0x971aa(%rip), %r8      # 0x17881b
movl $0x19, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe1685
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xccbe0
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0xe16da
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xb060
movl (%rax), %edi
callq 0xb1b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x97159(%rip), %rsi     # 0x17882c
movb $0x0, %al
callq 0xc0d0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xe173e
movq 0xd28cb(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7c94f(%rip), %rsi     # 0x15e066
leaq 0x8c96e(%rip), %rdx     # 0x16e08c
leaq 0x9712b(%rip), %rcx     # 0x178850
leaq 0x9712e(%rip), %r8      # 0x17885a
movl $0x20, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe1740
jmp 0xe1742
movq 0x18(%rsp), %rdi
leaq 0x8aabe(%rip), %rsi     # 0x16c20c
callq 0xb850
cmpl $0x0, %eax
je 0xe1790
movq 0xd2879(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7c8fd(%rip), %rsi     # 0x15e066
leaq 0x970f8(%rip), %rdx     # 0x178868
leaq 0x970d9(%rip), %rcx     # 0x178850
leaq 0x970dc(%rip), %r8      # 0x17885a
movl $0x22, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe1792
movl $0x20, %edi
leaq 0x970bc(%rip), %rsi     # 0x17885a
movl $0x23, %edx
callq 0xd2e0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x834c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x20(%rsp)
je 0xe17e0
movq 0x20(%rsp), %rdi
callq 0x18f70
movq %rax, 0x8(%rsp)
jmp 0xe17f1
leaq 0x897b5(%rip), %rdi     # 0x16af9c
callq 0x18f70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x1, 0x10(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xe182e
jmp 0xe185c
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x83f40
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1afc0
movq (%rsp), %rdi
leaq 0x97008(%rip), %rsi     # 0x17885a
movl $0x30, %edx
callq 0xdab0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xe187e
cmpq $0x0, 0x10(%rsp)
jne 0xe18b6
movq 0xd2753(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7c7d7(%rip), %rsi     # 0x15e066
leaq 0x96fe5(%rip), %rdx     # 0x17887b
leaq 0x96fe6(%rip), %rcx     # 0x178883
leaq 0x96fb6(%rip), %r8      # 0x17885a
movl $0x36, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe18b8
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x83620
movl %eax, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jne 0xe18ec
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movb $0x1, 0x18(%rax)
jmp 0xe18f5
movq 0x18(%rsp), %rax
movb $0x0, 0x18(%rax)
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
cmpl $-0x1, 0xc(%rsp)
jne 0xe1913
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xe191b
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x0, 0xb(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe1a4e
movq 0xd25bb(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7c63f(%rip), %rsi     # 0x15e066
leaq 0x88279(%rip), %rdx     # 0x169ca7
leaq 0x96e7f(%rip), %rcx     # 0x1788b4
leaq 0x96e1e(%rip), %r8      # 0x17885a
movl $0x54, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe1a50
movq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0xe1860
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movsbl 0xb(%rsp), %esi
callq 0xe1930
movl 0xc(%rsp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe1ad9
movq 0xd2530(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7c5b4(%rip), %rsi     # 0x15e066
leaq 0x881ee(%rip), %rdx     # 0x169ca7
leaq 0x96e03(%rip), %rcx     # 0x1788c3
leaq 0x96d93(%rip), %r8      # 0x17885a
movl $0x5d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe1adb
movq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0xe1860
movq 0x10(%rsp), %rdi
movsbl 0xf(%rsp), %esi
callq 0xe1930
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe1ee9
movq 0xd2120(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7c1a4(%rip), %rsi     # 0x15e066
leaq 0x96b7f(%rip), %rdx     # 0x178a48
leaq 0x96b0a(%rip), %rcx     # 0x1789da
leaq 0x96b17(%rip), %r8      # 0x1789ee
movl $0x27, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe1eeb
movl $0x18, %edi
leaq 0x96af7(%rip), %rsi     # 0x1789ee
movl $0x28, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x109130
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x109e00
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x96aaa(%rip), %rsi     # 0x1789ee
movl $0x2b, %edx
callq 0xd2e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rsp), %rcx
imull 0x8(%rcx), %eax
movl %eax, %eax
movl %eax, %edi
movl $0x4, %esi
leaq 0x96a73(%rip), %rdx     # 0x1789ee
movl $0x2b, %ecx
callq 0xd5b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq $0x1, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
jae 0xe1ff0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
shlq $0x2, %rax
addq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0xe1f9c
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xe207e
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xe2046
jmp 0xe207e
movq 0xd1f8b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7c00f(%rip), %rsi     # 0x15e066
leaq 0x7c5ea(%rip), %rdx     # 0x15e648
leaq 0x969a1(%rip), %rcx     # 0x178a06
leaq 0x96982(%rip), %r8      # 0x1789ee
movl $0xe4, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe2080
jmp 0xe2082
cmpq $0x0, 0x28(%rsp)
jne 0xe20c2
movq 0xd1f47(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7bfcb(%rip), %rsi     # 0x15e066
leaq 0x8c052(%rip), %rdx     # 0x16e0f4
leaq 0x9695d(%rip), %rcx     # 0x178a06
leaq 0x9693e(%rip), %r8      # 0x1789ee
movl $0xe5, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe20c4
callq 0x109af0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe1ea0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1098b0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xe2130
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xe211b
movq 0x10(%rsp), %rdi
callq 0xe2370
movq $0x0, 0x30(%rsp)
jmp 0xe2125
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xe237e
jmp 0xe23d4
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1098b0
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
leaq 0x96652(%rip), %rsi     # 0x1789ee
movl $0x13c, %edx            # imm = 0x13C
callq 0xdab0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x96639(%rip), %rsi     # 0x1789ee
movl $0x13c, %edx            # imm = 0x13C
callq 0xdab0
movq (%rsp), %rdi
leaq 0x96624(%rip), %rsi     # 0x1789ee
movl $0x13d, %edx            # imm = 0x13D
callq 0xdab0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xe2443
movq 0x8(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xe240b
jmp 0xe2443
movq 0xd1bc6(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7bc4a(%rip), %rsi     # 0x15e066
leaq 0x7c225(%rip), %rdx     # 0x15e648
leaq 0x965fd(%rip), %rcx     # 0x178a27
leaq 0x965bd(%rip), %r8      # 0x1789ee
movl $0xfa, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe2445
jmp 0xe2447
cmpq $0x0, 0x18(%rsp)
je 0xe2457
cmpq $0x0, 0x10(%rsp)
jne 0xe248f
movq 0xd1b7a(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7bbfe(%rip), %rsi     # 0x15e066
leaq 0x965d1(%rip), %rdx     # 0x178a40
leaq 0x965b1(%rip), %rcx     # 0x178a27
leaq 0x96571(%rip), %r8      # 0x1789ee
movl $0xfb, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe2491
movq 0x10(%rsp), %rdi
callq 0xe1ea0
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe2130
cmpl $0x0, %eax
je 0xe24cb
movq (%rsp), %rdi
callq 0xe2370
movq $0x0, 0x20(%rsp)
jmp 0xe24d4
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe2581
movq 0xd1a88(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7bb0c(%rip), %rsi     # 0x15e066
leaq 0x918a5(%rip), %rdx     # 0x173e06
leaq 0x96507(%rip), %rcx     # 0x178a6f
leaq 0x9647f(%rip), %r8      # 0x1789ee
movl $0x10d, %r9d            # imm = 0x10D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe2583
cmpl $0xfe, 0xc(%rsp)
jne 0xe259e
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe25a6
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0xfe, 0x8(%rsp)
jne 0xe25c8
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, (%rsp)
jmp 0xe25cf
movl 0x8(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0xe25f2
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jb 0xe262a
movq 0xd19df(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7ba63(%rip), %rsi     # 0x15e066
leaq 0x9647f(%rip), %rdx     # 0x178a89
leaq 0x9645e(%rip), %rcx     # 0x178a6f
leaq 0x963d6(%rip), %r8      # 0x1789ee
movl $0x111, %r9d            # imm = 0x111
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe262c
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xe26a5
movq 0xd1964(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7b9e8(%rip), %rsi     # 0x15e066
leaq 0x91781(%rip), %rdx     # 0x173e06
leaq 0x9642a(%rip), %rcx     # 0x178ab6
leaq 0x9635b(%rip), %r8      # 0x1789ee
movl $0x118, %r9d            # imm = 0x118
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe26a7
cmpl $0xfe, 0x1c(%rsp)
jne 0xe26c2
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xe26ca
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0xfe, 0x18(%rsp)
jne 0xe26ed
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xe26f5
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0xe2719
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jb 0xe2751
movq 0xd18b8(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7b93c(%rip), %rsi     # 0x15e066
leaq 0x96358(%rip), %rdx     # 0x178a89
leaq 0x9637e(%rip), %rcx     # 0x178ab6
leaq 0x962af(%rip), %r8      # 0x1789ee
movl $0x11c, %r9d            # imm = 0x11C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe2753
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x18(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0xe27ee
cmpq $0x0, 0x28(%rsp)
jne 0xe2826
movq 0xd17e3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7b867(%rip), %rsi     # 0x15e066
leaq 0x962e5(%rip), %rdx     # 0x178aeb
leaq 0x962e7(%rip), %rcx     # 0x178af4
leaq 0x961da(%rip), %r8      # 0x1789ee
movl $0x129, %r9d            # imm = 0x129
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe2828
movq 0x28(%rsp), %rsi
movl $0x20, %edi
callq 0x1c8f0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x109e00
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jae 0xe289f
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movl 0x24(%rsp), %eax
movzbl %al, %esi
callq 0x10ac90
movq 0x10(%rsp), %rdi
movsbl %al, %edx
leaq 0x9627e(%rip), %rsi     # 0x178b09
movb $0x0, %al
callq 0xb890
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xe283f
movq 0x28(%rsp), %rsi
movl $0xa, %edi
callq 0x1c8f0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x109e00
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0xe297c
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movl 0x24(%rsp), %eax
movzbl %al, %esi
callq 0x10ac90
movsbl %al, %edi
movq 0x28(%rsp), %rsi
callq 0x1c8f0
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x109e00
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jae 0xe295d
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
callq 0xe2530
movq (%rsp), %rdi
movl %eax, %edx
leaq 0x961c5(%rip), %rsi     # 0x178b0e
movb $0x0, %al
callq 0xb890
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xe2902
movq 0x28(%rsp), %rsi
movl $0xa, %edi
callq 0x1c8f0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xe28b6
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movl $0x38, %edi
callq 0x7b610
movq %rax, (%rsp)
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xe337c
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xe33b4
movq 0xd0c55(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7acd9(%rip), %rsi     # 0x15e066
leaq 0x8da96(%rip), %rdx     # 0x170e2a
leaq 0x95975(%rip), %rcx     # 0x178d10
leaq 0x95985(%rip), %r8      # 0x178d27
movl $0x3c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe33b6
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0x9595d(%rip), %rdx     # 0x178d27
movl $0x3d, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xe36dd
movq 0xd092c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7a9b0(%rip), %rsi     # 0x15e066
leaq 0x95697(%rip), %rdx     # 0x178d54
leaq 0x95754(%rip), %rcx     # 0x178e18
leaq 0x9565c(%rip), %r8      # 0x178d27
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe36df
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0xe3726
movq 0x28(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0xe3726
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0xe372e
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xe378d
movq 0xd087c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7a900(%rip), %rsi     # 0x15e066
leaq 0x955e7(%rip), %rdx     # 0x178d54
leaq 0x956b9(%rip), %rcx     # 0x178e2d
leaq 0x955ac(%rip), %r8      # 0x178d27
movl $0x76, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe378f
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0xe37c7
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0xe37c7
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0xe37d0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0xe37ee
jmp 0xe3868
jmp 0xe37f0
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xe3832
movq 0xd07d7(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7a85b(%rip), %rsi     # 0x15e066
leaq 0x9563d(%rip), %rdx     # 0x178e4f
leaq 0x95645(%rip), %rcx     # 0x178e5e
leaq 0x95507(%rip), %r8      # 0x178d27
movl $0x80, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe3834
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0xe3853
movq (%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rdi
leaq 0x954c9(%rip), %rsi     # 0x178d27
movl $0x83, %edx
callq 0xdab0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x7b730
cmpq $0x0, 0xd2cfa(%rip)     # 0x1b6648
jne 0xe398c
movl $0x20b0, %edi           # imm = 0x20B0
leaq 0x44(%rip), %rsi        # 0xe39a0
xorl %eax, %eax
movl %eax, %edx
leaq 0x1a9(%rip), %rcx       # 0xe3b10
leaq 0x7b2(%rip), %r8        # 0xe4120
leaq -0xb5(%rip), %r9        # 0xe38c0
leaq 0x834(%rip), %rax       # 0xe41b0
movq %rax, (%rsp)
callq 0xe32c0
movq %rax, 0xd2cbc(%rip)     # 0x1b6648
callq 0x7b790
movq 0xd2cb0(%rip), %rax     # 0x1b6648
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe416e
movq 0xcfe9b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x79f1f(%rip), %rsi     # 0x15e066
leaq 0xa8d83(%rip), %rdx     # 0x18ced1
leaq 0x94e41(%rip), %rcx     # 0x178f96
leaq 0x94d3e(%rip), %r8      # 0x178e9a
movl $0x19e, %r9d            # imm = 0x19E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe4170
callq 0xe3940
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0xe33f0
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x80(%rax)
movq (%rsp), %rax
addq $0x88, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)