LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_next
static int gt_load_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                               GtError *err)
{
  GtLoadStream *load_stream;
  GtEOFNode *eofn;
  GtGenomeNode *node;
  int had_err = 0;
  gt_error_check(err);
  load_stream = gt_load_stream_cast(ns);

  if (!load_stream->full) {
    while (!(had_err = gt_node_stream_next(load_stream->in_stream, &node,
                                           err)) && node) {
      if ((eofn = gt_eof_node_try_cast(node)))
        gt_genome_node_delete(node); /* get rid of EOF nodes */
      else
        gt_array_add(load_stream->nodes, node);
    }
    if (!had_err) {
      load_stream->full = true;
    }
  }

  if (!had_err) {
    gt_assert(load_stream->full);
    if (load_stream->idx < gt_array_size(load_stream->nodes)) {
      *gn = *(GtGenomeNode**) gt_array_get(load_stream->nodes,
                                           load_stream->idx);
      load_stream->idx++;
      return 0;
    }
  }

  if (!had_err) {
    gt_array_reset(load_stream->nodes);
    *gn = NULL;
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x163d15
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x163e0c
callq 0x163c4c
movq %rax, %rdi
movq %r14, %rsi
callq 0x16ae64
movq %rax, %r14
xorl %ebp, %ebp
cmpb $0x0, 0x28(%rax)
jne 0x163db9
movq 0x10(%r14), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
movq %r15, %rdx
callq 0x16ace8
movl %eax, %ebp
testl %eax, %eax
sete %al
movq (%r12), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x163dae
leaq 0x8(%rsp), %r12
callq 0x30774f
testq %rax, %rax
je 0x163d7b
movq 0x8(%rsp), %rdi
callq 0x14c43a
jmp 0x163d8c
movq 0x20(%r14), %rdi
movl $0x8, %edx
movq %r12, %rsi
callq 0xd49ce
movq 0x10(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x16ace8
movl %eax, %ebp
testl %eax, %eax
sete %al
jne 0x163dae
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x163d65
testb %al, %al
je 0x163db9
movb $0x1, 0x28(%r14)
xorl %ebp, %ebp
testl %ebp, %ebp
jne 0x163dfd
cmpb $0x0, 0x28(%r14)
je 0x163e11
movq 0x18(%r14), %r15
movq 0x20(%r14), %rdi
callq 0xd4a9a
movq 0x20(%r14), %rdi
cmpq %rax, %r15
jae 0x163df1
movq 0x18(%r14), %rsi
callq 0xd47ba
movq (%rax), %rax
movq %rax, (%rbx)
incq 0x18(%r14)
xorl %ebp, %ebp
jmp 0x163dfd
callq 0xd4ad3
movq $0x0, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x4bdbc
callq 0x4bdf3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_new
GtNodeStream* gt_load_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns = gt_node_stream_create(gt_load_stream_class(), true);
  GtLoadStream *load_stream = gt_load_stream_cast(ns);
  gt_assert(in_stream);
  load_stream->in_stream = gt_node_stream_ref(in_stream);
  load_stream->full = false;
  load_stream->idx = 0;
  load_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x163c4c
movq %rax, %rdi
movl $0x1, %esi
callq 0x16abec
movq %rax, %rbx
callq 0x163c4c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
testq %r14, %r14
je 0x163e7b
movq %rax, %r15
movq %r14, %rdi
callq 0x16ac58
movq %rax, 0x10(%r15)
movb $0x0, 0x28(%r15)
movq $0x0, 0x18(%r15)
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x20(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x4be2a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_class_new
const GtMatchClass* gt_match_class_new(size_t size,
                                       GtMatchFreeFunc free,
                                       GtMatchAcceptFunc accept)
{
  GtMatchClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->accept = accept;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x16553e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x301854
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x4c6de
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_create
GtMatch* gt_match_create(const GtMatchClass *matchc,
                         GtUword start1, GtUword end1,
                         GtUword start2, GtUword end2,
                         const char *seqid1, const char *seqid2,
                         GtMatchDirection dir)
{
  GtMatch *match;
  gt_assert(matchc && matchc->size);
  match = gt_malloc(matchc->size);
  match->c_class = matchc;
  if (seqid1)
    match->seqid1 = gt_str_new_cstr(seqid1);
  else
    match->seqid1 = NULL;
  if (seqid2)
    match->seqid2 = gt_str_new_cstr(seqid2);
  else
    match->seqid2 = NULL;
  match->range_seq1.start = start1;
  match->range_seq1.end = end1;
  match->range_seq2.start = start2;
  match->range_seq2.end = end2;
  match->direction = dir;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
testq %rdi, %rdi
je 0x1655e3
movq %rdi, %rbp
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1655e3
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x22a9df(%rip), %rsi    # 0x38ff58
movl $0x32, %edx
callq 0x1092b2
movq %rax, %r13
movq %rbp, (%rax)
testq %rbx, %rbx
je 0x165598
movq %rbx, %rdi
callq 0x120955
jmp 0x16559a
xorl %eax, %eax
movl 0x48(%rsp), %ebx
movq %rax, 0x8(%r13)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1655b3
callq 0x120955
jmp 0x1655b5
xorl %eax, %eax
movq %rax, 0x10(%r13)
movq %r12, 0x18(%r13)
movq %r15, 0x20(%r13)
movq %r14, 0x28(%r13)
movq (%rsp), %rax
movq %rax, 0x30(%r13)
movl %ebx, 0x38(%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4c715
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid1
void gt_match_set_seqid1(GtMatch *match, const char *seqid)
{
  gt_assert(match && seqid);
  if (!match->seqid1)
    match->seqid1 = gt_str_new_cstr(seqid);
  else {
    gt_str_reset(match->seqid1);
    gt_str_append_cstr(match->seqid1, seqid);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x165664
movq %rsi, %r14
testq %rsi, %rsi
je 0x165664
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x165650
callq 0x120db4
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12097f
movq %r14, %rdi
callq 0x120955
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4c7ba
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid2
void gt_match_set_seqid2(GtMatch *match, const char *seqid)
{
  gt_assert(match && seqid);
  if (!match->seqid2)
    match->seqid2 = gt_str_new_cstr(seqid);
  else {
    gt_str_reset(match->seqid2);
    gt_str_append_cstr(match->seqid2, seqid);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1656b2
movq %rsi, %r14
testq %rsi, %rsi
je 0x1656b2
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x16569e
callq 0x120db4
movq 0x10(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12097f
movq %r14, %rdi
callq 0x120955
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4c7f1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid1_nt
void gt_match_set_seqid1_nt(GtMatch *match, const char *seqid,
                            GtUword len)
{
  gt_assert(match && seqid);
  if (!match->seqid1)
    match->seqid1 = gt_str_new();
  else
    gt_str_reset(match->seqid1);
  gt_str_append_cstr_nt(match->seqid1, seqid, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1656fc
movq %rsi, %r14
testq %rsi, %rsi
je 0x1656fc
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1656df
callq 0x120db4
jmp 0x1656e8
callq 0x1208f8
movq %rax, 0x8(%r15)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x120a9d
callq 0x4c828
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid2_nt
void gt_match_set_seqid2_nt(GtMatch *match, const char *seqid,
                            GtUword len)
{
  gt_assert(match && seqid);
  if (!match->seqid2)
    match->seqid2 = gt_str_new();
  else
    gt_str_reset(match->seqid2);
  gt_str_append_cstr_nt(match->seqid2, seqid, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x165746
movq %rsi, %r14
testq %rsi, %rsi
je 0x165746
movq %rdx, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x165729
callq 0x120db4
jmp 0x165732
callq 0x1208f8
movq %rax, 0x10(%r15)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x120a9d
callq 0x4c85f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_range_seq1
void gt_match_set_range_seq1(GtMatch *match, GtUword start,
                             GtUword end)
{
  gt_assert(match);
  gt_assert(start <= end);
  match->range_seq1.start = start;
  match->range_seq1.end = end;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1657b8
cmpq %rdx, %rsi
ja 0x1657bd
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
popq %rax
retq
callq 0x4c9b3
callq 0x4c97a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_range_seq2
void gt_match_set_range_seq2(GtMatch *match, GtUword start,
                             GtUword end)
{
  gt_assert(match);
  gt_assert(start <= end);
  match->range_seq2.start = start;
  match->range_seq2.end = end;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1657d7
cmpq %rdx, %rsi
ja 0x1657dc
movq %rsi, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
popq %rax
retq
callq 0x4ca25
callq 0x4c9ec
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match.c
// Function: gt_match_delete
void gt_match_delete(GtMatch *match)
{
  if (!match) return;
  gt_assert(match->c_class);
  if (match->c_class->free)
    match->c_class->free(match);
  if (match->seqid1)
    gt_str_delete(match->seqid1);
  if (match->seqid2)
    gt_str_delete(match->seqid2);
  gt_free(match);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x165840
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x165842
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x16580f
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x16581d
callq 0x121b03
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x16582b
callq 0x121b03
leaq 0x22a726(%rip), %rsi    # 0x38ff58
movq %rbx, %rdi
movl $0xba, %edx
popq %rbx
jmp 0x109670
popq %rbx
retq
callq 0x4ca97
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_class
const GtMatchClass* gt_match_blast_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchBlast),
                                NULL,
                                match_blast_accept);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x363f3a(%rip)    # 0x4c9790
jne 0x165872
leaq 0x21(%rip), %rdx        # 0x165880
movl $0x70, %edi
xorl %esi, %esi
callq 0x165510
movq %rax, 0x363f1e(%rip)    # 0x4c9790
callq 0xe6a19
movq 0x363f12(%rip), %rax    # 0x4c9790
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_blast.c
// Function: match_blast_accept
static int match_blast_accept(GtMatch *match, GtMatchVisitor *mv, GtError *err)
{
  GtMatchBlast *mb;
  gt_assert(match && mv);
  gt_error_check(err);
  mb = gt_match_blast_cast(match);
  return gt_match_visitor_visit_match_blast(mv, mb, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1658cc
movq %rsi, %r14
testq %rsi, %rsi
je 0x1658cc
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x1658a9
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1658d1
callq 0x165848
movq %rax, %rdi
movq %r15, %rsi
callq 0x1655e8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x16826d
callq 0x4cad0
callq 0x4cb07
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_new
GtMatch* gt_match_blast_new(char *seqid1,
                            char *seqid2,
                            GtUword start_seq1,
                            GtUword end_seq1,
                            GtUword start_seq2,
                            GtUword end_seq2,
                            double evalue,
                            float bitscore,
                            GtUword length,
                            double similarity,
                            GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchBlast *matchb;
  match = gt_match_create(gt_match_blast_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchb = gt_match_blast_cast(match);
  matchb->evalue = evalue;
  matchb->bitscore = bitscore;
  matchb->ali_length = length;
  matchb->similarity = similarity;
  matchb->mm_num = 0;
  matchb->gap_open_num = 0;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm2, 0x10(%rsp)
movss %xmm1, 0x4(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x165848
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %rbp, %r9
movl 0x58(%rsp), %eax
pushq %rax
pushq %r13
callq 0x165543
addq $0x10, %rsp
movq %rax, %rbx
callq 0x165848
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1655e8
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x48(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x50(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x68(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_new_extended
GtMatch* gt_match_blast_new_extended(char *seqid1,
                                     char *seqid2,
                                     GtUword start_seq1,
                                     GtUword end_seq1,
                                     GtUword start_seq2,
                                     GtUword end_seq2,
                                     double evalue,
                                     float bitscore,
                                     GtUword length,
                                     double similarity,
                                     GtUword mm_num,
                                     GtUword gap_open_num,
                                     GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchBlast *matchb;
  match = gt_match_create(gt_match_blast_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchb = gt_match_blast_cast(match);
  matchb->evalue = evalue;
  matchb->bitscore = bitscore;
  matchb->ali_length = length;
  matchb->similarity = similarity;
  matchb->mm_num = mm_num;
  matchb->gap_open_num = gap_open_num;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm2, 0x10(%rsp)
movss %xmm1, 0x4(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x165848
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %rbp, %r9
movl 0x68(%rsp), %eax
pushq %rax
pushq %r13
callq 0x165543
addq $0x10, %rsp
movq %rax, %rbx
callq 0x165848
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1655e8
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x48(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x50(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x68(%rax)
movups 0x58(%rsp), %xmm0
movups %xmm0, 0x58(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_create
GtMatchIterator* gt_match_iterator_create(const GtMatchIteratorClass *mpc)
{
  GtMatchIterator *mp;
  gt_assert(mpc && mpc->size);
  mp = gt_calloc(1, mpc->size);
  mp->c_class = mpc;
  return mp;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x165b51
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x165b51
leaq 0x22a7a3(%rip), %rdx    # 0x3902e0
movl $0x1, %edi
movl $0x28, %ecx
callq 0x1093ef
movq %rbx, (%rax)
popq %rbx
retq
callq 0x4cde8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_next
GtMatchIteratorStatus gt_match_iterator_next(GtMatchIterator *mp,
                                             GtMatch **match, GtError *err)
{
  gt_assert(mp);
  if (mp->c_class->next)
    return mp->c_class->next(mp, match, err);
  return GT_MATCHER_STATUS_END;
}

// Assembly:
testq %rdi, %rdi
je 0x165b6f
movq (%rdi), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x165b69
jmpq *%rax
movl $0x1, %eax
retq
pushq %rax
callq 0x4ce1f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_delete
void gt_match_iterator_delete(GtMatchIterator *mp)
{
  if (!mp) return;
  if (mp->c_class->free)
    mp->c_class->free(mp);
  gt_free(mp);
}

// Assembly:
testq %rdi, %rdi
je 0x165bbd
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x165ba8
movq %rbx, %rdi
callq *%rax
leaq 0x22a731(%rip), %rsi    # 0x3902e0
movq %rbx, %rdi
movl $0x42, %edx
popq %rbx
jmp 0x109670
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blast_file_new
GtMatchIterator* gt_match_iterator_blast_file_new(const char *matchfile,
                                                  GtError *err)
{
  GtMatchIterator *mp;
  GtMatchIteratorBlast *mpb;
  mp = gt_match_iterator_create(gt_match_iterator_blast_class());
  mpb = gt_match_iterator_blast_cast(mp);
  mpb->pvt = gt_calloc(1, sizeof (GtMatchIteratorBlastMembers));
  GtFileMode mode;

  if (gt_file_exists(matchfile)) {
    mode = gt_file_mode_determine(matchfile);
    if (mode == GT_FILE_MODE_UNCOMPRESSED) {
      mpb->pvt->matchfilep = fopen(matchfile, "r");
      mpb->pvt->gtmatchfilep = NULL;
      if (!mpb->pvt->matchfilep) {
        gt_error_set(err, "could not open %s", matchfile);
        gt_match_iterator_delete(mp);
        return NULL;
      }
    } else {
      mpb->pvt->gtmatchfilep = gt_file_open(mode, matchfile, "r", err);
      mpb->pvt->matchfilep = NULL;
      if (!mpb->pvt->gtmatchfilep) {
        gt_match_iterator_delete(mp);
        return NULL;
      }
    }
    mpb->pvt->matchfile = matchfile;
    mpb->pvt->process = false;
    return mp;
  } else {
    gt_error_set(err, "no such file or directory %s", matchfile);
    gt_match_iterator_delete(mp);
    return NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x165cbf
movq %rax, %rdi
callq 0x165b25
movq %rax, %rbx
callq 0x165cbf
movq %rax, %rdi
movq %rbx, %rsi
callq 0x165b75
movq %rax, %r12
leaq 0x22a750(%rip), %rdx    # 0x390348
movl $0x1, %edi
movl $0x28, %esi
movl $0xb9, %ecx
callq 0x1093ef
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0x10415c
testb %al, %al
je 0x165c55
movq %r14, %rdi
callq 0x103868
testl %eax, %eax
je 0x165c75
leaq 0x1fe299(%rip), %rdx    # 0x363ec9
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rcx
callq 0x1039a2
movq 0x8(%r12), %rcx
movq %rax, 0x10(%rcx)
movq $0x0, 0x8(%rcx)
testq %rax, %rax
jne 0x165c9a
jmp 0x165c69
leaq 0x22a722(%rip), %rsi    # 0x39037e
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1019cf
movq %rbx, %rdi
callq 0x165b8e
xorl %ebx, %ebx
jmp 0x165ca7
leaq 0x1fe24d(%rip), %rsi    # 0x363ec9
movq %r14, %rdi
callq 0x178b0
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
movq $0x0, 0x10(%rcx)
testq %rax, %rax
je 0x165cb6
movq 0x8(%r12), %rax
movq %r14, 0x18(%rax)
movb $0x0, 0x20(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x22a6af(%rip), %rsi    # 0x39036c
jmp 0x165c5c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blast_class
const GtMatchIteratorClass* gt_match_iterator_blast_class(void)
{
  static const GtMatchIteratorClass *mpc;
  gt_class_alloc_lock_enter();
  if (!mpc) {
    mpc = gt_match_iterator_class_new(sizeof (GtMatchIteratorBlast),
                                      gt_match_iterator_blast_next,
                                      gt_match_iterator_blast_free);
  }
  gt_class_alloc_lock_leave();
  return mpc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x363acb(%rip)    # 0x4c9798
jne 0x165cee
leaq 0x5c3(%rip), %rsi       # 0x166299
leaq 0x8ef(%rip), %rdx       # 0x1665cc
movl $0x10, %edi
callq 0x165afc
movq %rax, 0x363aaa(%rip)    # 0x4c9798
callq 0xe6a19
movq 0x363a9e(%rip), %rax    # 0x4c9798
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blast_process_new
GtMatchIterator *gt_match_iterator_blast_process_new(GtBlastProcessCall *call,
                                                     GtError *err)
{
  GtMatchIterator *mp;
  GtMatchIteratorBlast *mpb;
  mp = gt_match_iterator_create(gt_match_iterator_blast_class());
  mpb = gt_match_iterator_blast_cast(mp);
  mpb->pvt = gt_calloc(1, sizeof (GtMatchIteratorBlastMembers));
  mpb->pvt->matchfile = "stdin";
  mpb->pvt->process = true;

  gt_blast_process_call_set_outfmt_tabular(call);

  mpb->pvt->matchfilep = gt_blast_process_call_run(call, err);
  if (mpb->pvt->matchfilep == NULL)
    return NULL;
  mpb->pvt->gtmatchfilep = NULL;
  return mp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x165cbf
movq %rax, %rdi
callq 0x165b25
movq %rax, %rbx
callq 0x165cbf
movq %rax, %rdi
movq %rbx, %rsi
callq 0x165b75
movq %rax, %r12
leaq 0x22a614(%rip), %rdx    # 0x390348
movl $0x1, %edi
movl $0x28, %esi
movl $0xdf, %ecx
callq 0x1093ef
movq %rax, 0x8(%r12)
leaq 0x1e91ad(%rip), %rcx    # 0x34ef01
movq %rcx, 0x18(%rax)
movb $0x1, 0x20(%rax)
movq %r15, %rdi
callq 0x12ddbf
movq %r15, %rdi
movq %r14, %rsi
callq 0x12de1b
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
testq %rax, %rax
je 0x165d87
movq $0x0, 0x10(%rcx)
jmp 0x165d89
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blastallp_process_new
GtMatchIterator* gt_match_iterator_blastallp_process_new(const char *query,
                                                         const char *db_name,
                                                         double evalue,
                                                         int word_size,
                                                         int gapopen,
                                                         int gapextend,
                                                         int xdrop_gap_final,
                                                         GtError *err)
{
  GtBlastProcessCall *call = gt_blast_process_call_new_all_prot();

  gt_blast_process_call_set_query(call, query);
  gt_blast_process_call_set_db(call, db_name);
  if (evalue != GT_UNDEF_DOUBLE)
    gt_blast_process_call_set_evalue(call, evalue);
  if (word_size != GT_UNDEF_INT)
    gt_blast_process_call_set_wordsize(call, word_size);
  if (gapopen != GT_UNDEF_INT)
    gt_blast_process_call_set_gapopen(call, gapopen);
  if (gapextend != GT_UNDEF_INT)
    gt_blast_process_call_set_gapextend(call, gapextend);
  if (xdrop_gap_final != GT_UNDEF_INT)
    gt_blast_process_call_set_xdrop_gap_final(call, xdrop_gap_final);

  return gt_match_iterator_blast_process_new(call, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x12da28
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x12da6c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12dab6
movsd 0x8(%rsp), %xmm0
ucomisd 0x1ead9d(%rip), %xmm0   # 0x350d10
jne 0x165f77
jnp 0x165f7f
movq %r14, %rdi
callq 0x12db00
movl %r13d, %eax
negl %eax
jo 0x165f91
movq %r14, %rdi
movl %r13d, %esi
callq 0x12db53
movl %r12d, %eax
negl %eax
jo 0x165fa3
movq %r14, %rdi
movl %r12d, %esi
callq 0x12db9b
movl %r15d, %eax
negl %eax
jo 0x165fb5
movq %r14, %rdi
movl %r15d, %esi
callq 0x12dbe3
movl 0x4(%rsp), %ecx
movl %ecx, %eax
negl %eax
jo 0x165fce
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movq %r14, %rdi
callq 0x12dd19
movq %r14, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x165cfc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blastp_process_new
GtMatchIterator* gt_match_iterator_blastp_process_new(const char *query,
                                                      const char *db_name,
                                                      double evalue,
                                                      int word_size,
                                                      int gapopen,
                                                      int gapextend,
                                                      int num_threads,
                                                      double xdrop_gap_final,
                                                      GtError *err)
{
  GtBlastProcessCall *call = gt_blast_process_call_new_all_prot();

  gt_blast_process_call_set_query(call, query);
  gt_blast_process_call_set_db(call, db_name);
  if (evalue != GT_UNDEF_DOUBLE)
    gt_blast_process_call_set_evalue(call, evalue);
  if (word_size != GT_UNDEF_INT)
    gt_blast_process_call_set_wordsize(call, word_size);
  if (gapopen != GT_UNDEF_INT)
    gt_blast_process_call_set_gapopen(call, gapopen);
  if (gapextend != GT_UNDEF_INT)
    gt_blast_process_call_set_gapextend(call, gapextend);
  if (num_threads != GT_UNDEF_INT)
    gt_blast_process_call_set_num_threads(call, num_threads);
  if (xdrop_gap_final != GT_UNDEF_DOUBLE)
    gt_blast_process_call_set_xdrop_gap_final(call, xdrop_gap_final);

  return gt_match_iterator_blast_process_new(call, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x20(%rsp)
movl %r9d, 0xc(%rsp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x12da28
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x12da6c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12dab6
movsd 0x10(%rsp), %xmm0
ucomisd 0x1eab00(%rip), %xmm0   # 0x350d10
jne 0x166214
jnp 0x16621c
movq %r14, %rdi
callq 0x12db00
movl %r13d, %eax
negl %eax
jo 0x16622e
movq %r14, %rdi
movl %r13d, %esi
callq 0x12db53
movl %r12d, %eax
negl %eax
jo 0x166240
movq %r14, %rdi
movl %r12d, %esi
callq 0x12db9b
movl %r15d, %eax
negl %eax
jo 0x166252
movq %r14, %rdi
movl %r15d, %esi
callq 0x12dbe3
movl 0xc(%rsp), %esi
movl %esi, %eax
negl %eax
jo 0x166264
movq %r14, %rdi
callq 0x12dcd1
movsd 0x20(%rsp), %xmm0
ucomisd 0x1eaa9e(%rip), %xmm0   # 0x350d10
jne 0x166276
jnp 0x16627e
movq %r14, %rdi
callq 0x12dd19
movq %r14, %rdi
movq 0x18(%rsp), %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x165cfc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blast_free
static void gt_match_iterator_blast_free(GtMatchIterator *mp)
{
  GtMatchIteratorBlast *mpb;
  if (!mp) return;
  mpb = gt_match_iterator_blast_cast(mp);
  if (mpb->pvt->matchfilep) {
    if (mpb->pvt->process) {
      pclose(mpb->pvt->matchfilep);
    } else {
      fclose(mpb->pvt->matchfilep);
    }
    mpb->pvt->matchfilep = NULL;
  }
  if (mpb->pvt->gtmatchfilep != NULL)
    gt_file_delete(mpb->pvt->gtmatchfilep);
  gt_free(mpb->pvt);
}

// Assembly:
testq %rdi, %rdi
je 0x166602
pushq %rbx
movq %rdi, %rbx
callq 0x165cbf
movq %rax, %rdi
movq %rbx, %rsi
callq 0x165b75
movq %rax, %rbx
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x166614
cmpb $0x1, 0x20(%rax)
jne 0x166603
callq 0x17a70
jmp 0x166608
retq
callq 0x17800
movq 0x8(%rbx), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x166626
callq 0x1040fc
movq 0x8(%rbx), %rdi
leaq 0x229d17(%rip), %rsi    # 0x390348
movl $0x197, %edx            # imm = 0x197
popq %rbx
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_last.c
// Function: gt_match_iterator_last_class
const GtMatchIteratorClass* gt_match_iterator_last_class(void)
{
  static const GtMatchIteratorClass *mpc;
  gt_class_alloc_lock_enter();
  if (!mpc) {
    mpc = gt_match_iterator_class_new(sizeof (GtMatchIteratorLast),
                               gt_match_iterator_last_next,
                               gt_match_iterator_last_free);
  }
  gt_class_alloc_lock_leave();
  return mpc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x362cfa(%rip)    # 0x4c97a0
jne 0x166ac7
leaq 0x26(%rip), %rsi        # 0x166ad5
leaq 0x86b(%rip), %rdx       # 0x167321
movl $0x10, %edi
callq 0x165afc
movq %rax, 0x362cd9(%rip)    # 0x4c97a0
callq 0xe6a19
movq 0x362ccd(%rip), %rax    # 0x4c97a0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_last.c
// Function: gt_match_iterator_last_free
static void gt_match_iterator_last_free(GtMatchIterator *mp)
{
  GtMatchIteratorLast *mil;
  if (!mp) return;
  mil = gt_match_iterator_last_cast(mp);
  gt_file_delete(mil->pvt->matchfile);
  gt_str_delete(mil->pvt->matchfilename);
  gt_str_delete(mil->pvt->idxfilename);
  gt_str_delete(mil->pvt->queryfilename);
  gt_str_delete(mil->pvt->linebuf);
  gt_encseq_delete(mil->pvt->es1);
  gt_encseq_delete(mil->pvt->es2);
  gt_hashmap_delete(mil->pvt->desc_to_seqno);
  gt_free(mil->pvt);
}

// Assembly:
testq %rdi, %rdi
je 0x1673be
pushq %rbx
movq %rdi, %rbx
callq 0x166a98
movq %rax, %rdi
movq %rbx, %rsi
callq 0x165b75
movq %rax, %rbx
movq 0x8(%rax), %rax
movq 0x60(%rax), %rdi
callq 0x1040fc
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
callq 0x121b03
movq 0x8(%rbx), %rax
movq 0x40(%rax), %rdi
callq 0x121b03
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rdi
callq 0x121b03
movq 0x8(%rbx), %rax
movq 0x58(%rax), %rdi
callq 0x121b03
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0xee90c
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xee90c
movq 0x8(%rbx), %rax
movq 0x68(%rax), %rdi
callq 0x105f7d
movq 0x8(%rbx), %rdi
leaq 0x22914b(%rip), %rsi    # 0x3904fe
movl $0x204, %edx            # imm = 0x204
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_open.c
// Function: gt_match_iterator_open_new
GtMatchIterator* gt_match_iterator_open_new(const char *matchfile, GtError *err)
{
  GtMatchIterator *mp;
  GtMatchIteratorOpen *mpo;
  mp = gt_match_iterator_create(gt_match_iterator_open_class());
  mpo = (GtMatchIteratorOpen*) mp;
  mpo->pvt = gt_calloc(1, sizeof (GtMatchIteratorOpenMembers));
  GtFileMode mode;
  if (gt_file_exists(matchfile)) {
    mode = gt_file_mode_determine(matchfile);
    if (mode == GT_FILE_MODE_UNCOMPRESSED) {
      mpo->pvt->matchfilep = fopen(matchfile, "r");
      mpo->pvt->gtmatchfilep = NULL;
      if (!mpo->pvt->matchfilep) {
        gt_error_set(err, "Could not open %s", matchfile);
        return NULL;
      }
    } else {
      mpo->pvt->gtmatchfilep = gt_file_open(mode, matchfile, "r", err);
      mpo->pvt->matchfilep = NULL;
      if (!mpo->pvt->gtmatchfilep)
        return NULL;
    }
    mpo->pvt->matchfile = matchfile;
    return mp;
  } else {
    gt_error_set(err, "No such file or directory %s", matchfile);
    return NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x167669
movq %rax, %rdi
callq 0x165b25
movq %rax, %rbx
leaq 0x22922f(%rip), %rdx    # 0x3907e5
movl $0x1, %edi
movl $0x20, %esi
movl $0x9e, %ecx
callq 0x1093ef
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x10415c
testb %al, %al
je 0x167613
movq %r14, %rdi
callq 0x103868
testl %eax, %eax
je 0x16762b
leaq 0x1fc8dc(%rip), %rdx    # 0x363ec9
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rcx
callq 0x1039a2
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq $0x0, 0x8(%rcx)
testq %rax, %rax
jne 0x16764f
xorl %ebx, %ebx
jmp 0x167657
leaq 0x229200(%rip), %rsi    # 0x39081a
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1019cf
jmp 0x167657
leaq 0x1fc897(%rip), %rsi    # 0x363ec9
movq %r14, %rdi
callq 0x178b0
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq $0x0, 0x10(%rcx)
testq %rax, %rax
je 0x167660
movq 0x8(%rbx), %rax
movq %r14, 0x18(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2291a1(%rip), %rsi    # 0x390808
jmp 0x16761a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_open.c
// Function: gt_match_iterator_open_class
const GtMatchIteratorClass* gt_match_iterator_open_class(void)
{
  static const GtMatchIteratorClass *mpc;
  gt_class_alloc_lock_enter();
  if (!mpc) {
    mpc = gt_match_iterator_class_new(sizeof (GtMatchIteratorOpen),
                               gt_match_iterator_open_next,
                               gt_match_iterator_open_free);
  }
  gt_class_alloc_lock_leave();
  return mpc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x362131(%rip)    # 0x4c97a8
jne 0x167698
leaq 0x26(%rip), %rsi        # 0x1676a6
leaq 0x2db(%rip), %rdx       # 0x167962
movl $0x10, %edi
callq 0x165afc
movq %rax, 0x362110(%rip)    # 0x4c97a8
callq 0xe6a19
movq 0x362104(%rip), %rax    # 0x4c97a8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_open.c
// Function: gt_match_iterator_open_free
static void gt_match_iterator_open_free(GtMatchIterator *mp)
{
  GtMatchIteratorOpen *mpo;
  if (!mp) return;
  mpo = gt_match_iterator_open_cast(mp);
  if (mpo->pvt->matchfilep != NULL)
    fclose(mpo->pvt->matchfilep);
  if (mpo->pvt->gtmatchfilep != NULL)
    gt_file_delete(mpo->pvt->gtmatchfilep);
  gt_free(mpo->pvt);
}

// Assembly:
testq %rdi, %rdi
je 0x1679b8
pushq %rbx
movq %rdi, %rbx
callq 0x167669
movq %rax, %rdi
movq %rbx, %rsi
callq 0x165b75
movq %rax, %rbx
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x167990
callq 0x17800
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x1679a2
callq 0x1040fc
movq 0x8(%rbx), %rdi
leaq 0x228e38(%rip), %rsi    # 0x3907e5
movl $0xc0, %edx
popq %rbx
jmp 0x109670
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_sw.c
// Function: gt_match_iterator_sw_new
GtMatchIterator* gt_match_iterator_sw_new(GtEncseq *es1, GtEncseq *es2,
                                          GtScoreFunction *sf,
                                          GtUword min_len,
                                          GtUword max_edist,
                                          GT_UNUSED GtError *err)
{
  GtMatchIterator *mi;
  GtMatchIteratorSW *mis;
  gt_assert(es1 && es2 && sf);
  gt_error_check(err);

  mi = gt_match_iterator_create(gt_match_iterator_sw_class());
  mis = (GtMatchIteratorSW*) mi;
  mis->pvt = gt_calloc(1, sizeof (GtMatchIteratorSWMembers));
  mis->pvt->es1 = gt_encseq_ref(es1);
  mis->pvt->es2 = gt_encseq_ref(es2);
  mis->pvt->sf = gt_score_function_ref(sf);
  mis->pvt->min_len = min_len;
  mis->pvt->max_edist = max_edist;
  mis->pvt->firstali = true;
  return mi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x167aaa
movq %rsi, %r12
testq %rsi, %rsi
je 0x167aaa
movq %rdx, %r15
testq %rdx, %rdx
je 0x167aaa
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r13
testq %r9, %r9
je 0x167a06
movq %r9, %rdi
callq 0x101a9a
testb %al, %al
jne 0x167aaf
cmpq $0x0, 0x361da2(%rip)    # 0x4c97b0
jne 0x167a2f
leaq 0xd3(%rip), %rsi        # 0x167aea
leaq 0x44c(%rip), %rdx       # 0x167e6a
movl $0x10, %edi
callq 0x165afc
movq %rax, 0x361d81(%rip)    # 0x4c97b0
movq 0x361d7a(%rip), %rdi    # 0x4c97b0
callq 0x165b25
movq %rax, %rbp
leaq 0x228e93(%rip), %rdx    # 0x3908d8
movl $0x1, %edi
movl $0x40, %esi
movl $0x85, %ecx
callq 0x1093ef
movq %rax, 0x8(%rbp)
movq %r13, %rdi
callq 0xeef4f
movq 0x8(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq %r12, %rdi
callq 0xeef4f
movq 0x8(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %r15, %rdi
callq 0x1189bd
movq 0x8(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, 0x28(%rcx)
movq %rbx, 0x30(%rcx)
movb $0x1, 0x38(%rcx)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4d486
callq 0x4d4bf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_iterator_sw.c
// Function: gt_match_iterator_sw_free
static void gt_match_iterator_sw_free(GtMatchIterator *mi)
{
  GtMatchIteratorSW *mis;
  if (!mi) return;
  mis = gt_match_iterator_sw_cast(mi);
  gt_encseq_delete(mis->pvt->es1);
  gt_encseq_delete(mis->pvt->es2);
  gt_score_function_delete(mis->pvt->sf);
  gt_free(mis->pvt);
}

// Assembly:
testq %rdi, %rdi
je 0x167eea
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x361935(%rip)    # 0x4c97b0
jne 0x167e9c
leaq -0x39a(%rip), %rsi      # 0x167aea
leaq -0x21(%rip), %rdx       # 0x167e6a
movl $0x10, %edi
callq 0x165afc
movq %rax, 0x361914(%rip)    # 0x4c97b0
movq 0x36190d(%rip), %rdi    # 0x4c97b0
movq %rbx, %rsi
callq 0x165b75
movq %rax, %rbx
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xee90c
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0xee90c
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x118a11
movq 0x8(%rbx), %rdi
leaq 0x2289f9(%rip), %rsi    # 0x3908d8
movl $0x97, %edx
popq %rbx
jmp 0x109670
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_last.c
// Function: gt_match_last_class
const GtMatchClass* gt_match_last_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchLAST),
                                NULL,
                                NULL);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x3618be(%rip)    # 0x4c97b8
jne 0x167f11
movl $0x58, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x165510
movq %rax, 0x3618a7(%rip)    # 0x4c97b8
callq 0xe6a19
movq 0x36189b(%rip), %rax    # 0x4c97b8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_last.c
// Function: gt_match_last_new
GtMatch* gt_match_last_new(const char *seqid1,
                           const char *seqid2,
                           GtUword score,
                           GtUword seqno1,
                           GtUword seqno2,
                           GtUword start_seq1,
                           GtUword start_seq2,
                           GtUword end_seq1,
                           GtUword end_seq2,
                           GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchLAST *matchs;
  match = gt_match_create(gt_match_last_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchs = gt_match_last_cast(match);
  matchs->seqno1 = seqno1;
  matchs->seqno2 = seqno2;
  matchs->score = score;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbp
callq 0x167eec
movq %rax, %rdi
movq %r12, %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %r8
movq %rbp, %r9
movl 0x58(%rsp), %eax
pushq %rax
pushq %r13
callq 0x165543
addq $0x10, %rsp
movq %rax, %r12
callq 0x167eec
movq %rax, %rdi
movq %r12, %rsi
callq 0x1655e8
movq %r15, 0x40(%rax)
movq %rbx, 0x48(%rax)
movq %r14, 0x50(%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_open.c
// Function: gt_match_open_class
const GtMatchClass* gt_match_open_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchOpen),
                                NULL,
                                match_open_accept);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x3617e6(%rip)    # 0x4c97c0
jne 0x167ff6
leaq 0x21(%rip), %rdx        # 0x168004
movl $0x48, %edi
xorl %esi, %esi
callq 0x165510
movq %rax, 0x3617ca(%rip)    # 0x4c97c0
callq 0xe6a19
movq 0x3617be(%rip), %rax    # 0x4c97c0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_open.c
// Function: match_open_accept
static int match_open_accept(GtMatch *match, GtMatchVisitor *mv, GtError *err)
{
  GtMatchOpen *mo;
  gt_assert(match && mv);
  gt_error_check(err);
  mo = gt_match_open_cast(match);
  return gt_match_visitor_visit_match_open(mv, mo, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x168050
movq %rsi, %r14
testq %rsi, %rsi
je 0x168050
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x16802d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x168055
callq 0x167fcc
movq %rax, %rdi
movq %r15, %rsi
callq 0x1655e8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1682c1
callq 0x4d5d4
callq 0x4d60b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_open.c
// Function: gt_match_open_new
GtMatch* gt_match_open_new(char *seqid1,
                           char *seqid2,
                           GtUword start_seq1,
                           GtUword end_seq1,
                           GtUword start_seq2,
                           GtUword end_seq2,
                           GtWord weight,
                           GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchOpen *matcho;
  match = gt_match_create(gt_match_open_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matcho = gt_match_open_cast(match);
  matcho->weight = weight;
  return match;
}

// 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
callq 0x167fcc
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %rbp, %r9
movl 0x48(%rsp), %eax
pushq %rax
pushq %r13
callq 0x165543
addq $0x10, %rsp
movq %rax, %rbx
callq 0x167fcc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1655e8
movq 0x40(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_sw.c
// Function: gt_match_sw_class
const GtMatchClass* gt_match_sw_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchSW),
                                NULL,
                                NULL);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x3616ce(%rip)    # 0x4c97c8
jne 0x168111
movl $0x60, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x165510
movq %rax, 0x3616b7(%rip)    # 0x4c97c8
callq 0xe6a19
movq 0x3616ab(%rip), %rax    # 0x4c97c8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_sw.c
// Function: gt_match_sw_new
GtMatch* gt_match_sw_new(const char *seqid1,
                         const char *seqid2,
                         GtUword seqno1,
                         GtUword seqno2,
                         GtUword length,
                         GtUword edist,
                         GtUword start_seq1,
                         GtUword start_seq2,
                         GtUword end_seq1,
                         GtUword end_seq2,
                         GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchSW *matchs;
  match = gt_match_create(gt_match_sw_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchs = gt_match_sw_cast(match);
  matchs->alilen = length;
  matchs->seqno1 = seqno1;
  matchs->seqno2 = seqno2;
  matchs->edist = edist;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x1680ec
movq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x58(%rsp), %r8
movq %rbp, %r9
movl 0x60(%rsp), %eax
pushq %rax
pushq %r13
callq 0x165543
addq $0x10, %rsp
movq %rax, %r13
callq 0x1680ec
movq %rax, %rdi
movq %r13, %rsi
callq 0x1655e8
movq %r15, 0x58(%rax)
movq %r12, 0x40(%rax)
movq %r14, 0x48(%rax)
movq %rbx, 0x50(%rax)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_visitor.c
// Function: gt_match_visitor_class_new
const GtMatchVisitorClass*
gt_match_visitor_class_new(size_t size,
                           GtMatchVisitorFreeFunc free,
                           GtMatchVisitorBlastFunc match_blast,
                           GtMatchVisitorOpenFunc match_open)
{
  GtMatchVisitorClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->match_blast = match_blast;
  c_class->match_open = match_open;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16821e
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x301854
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4d78c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_visitor.c
// Function: gt_match_visitor_create
GtMatchVisitor* gt_match_visitor_create(const GtMatchVisitorClass *mvc)
{
  GtMatchVisitor *mv;
  gt_assert(mvc && mvc->size);
  mv = gt_calloc(1, mvc->size);
  mv->c_class = mvc;
  return mv;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x16824f
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x16824f
leaq 0x228841(%rip), %rdx    # 0x390a7c
movl $0x1, %edi
movl $0x33, %ecx
callq 0x1093ef
movq %rbx, (%rax)
popq %rbx
retq
callq 0x4d7c3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/match_visitor.c
// Function: gt_match_visitor_delete
void gt_match_visitor_delete(GtMatchVisitor *mv)
{
  if (!mv) return;
  gt_assert(mv->c_class);
  if (mv->c_class->free)
    mv->c_class->free(mv);
  gt_free(mv);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x168349
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x16834b
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x168334
movq %rbx, %rdi
callq *%rax
leaq 0x228741(%rip), %rsi    # 0x390a7c
movq %rbx, %rdi
movl $0x55, %edx
popq %rbx
jmp 0x109670
popq %rbx
retq
callq 0x4d90d