LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute
GtUword gt_linearalign_affinegapcost_compute(GtLinspaceManagement *spacemanager,
                                             GtAlignment *align,
                                             const GtUchar *useq,
                                             GtUword ustart,
                                             GtUword ulen,
                                             const GtUchar *vseq,
                                             GtUword vstart,
                                             GtUword vlen,
                                             GtUword matchcost,
                                             GtUword mismatchcost,
                                             GtUword gap_opening,
                                             GtUword gap_extension)
{
  GtUword distance;
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchcost,
                                                     mismatchcost,
                                                     gap_opening,
                                                     gap_extension);

  gt_alignment_set_seqs(align,useq+ustart, ulen, vseq+vstart, vlen);
  distance = gt_linearalign_affinegapcost_compute_generic(spacemanager,
                                                          scorehandler, align,
                                                          useq, ustart, ulen,
                                                          vseq, vstart, vlen);
  gt_scorehandler_delete(scorehandler);
  return distance;
}

// 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, %rbp
movq %rdi, (%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0x1148f4
movq %rax, %r13
leaq (%r12,%r15), %rsi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax), %rcx
movq %rbp, %rdi
movq %r14, %rdx
movq 0x48(%rsp), %r8
callq 0xb4f1f
subq $0x8, %rsp
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq %rbx
callq 0xf8699
addq $0x20, %rsp
movq %rax, %rbx
movq %r13, %rdi
callq 0x114a03
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_O2/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute_local
GtWord gt_linearalign_affinegapcost_compute_local(
                                             GtLinspaceManagement *spacemanager,
                                             GtAlignment *align,
                                             const GtUchar *useq,
                                             GtUword ustart,
                                             GtUword ulen,
                                             const GtUchar *vseq,
                                             GtUword vstart,
                                             GtUword vlen,
                                             GtWord matchscore,
                                             GtWord mismatchscore,
                                             GtWord gap_opening,
                                             GtWord gap_extension)
{
  GtWord score;

  GtScoreHandler *scorehandler = gt_scorehandler_new(matchscore,
                                                     mismatchscore,
                                                     gap_opening,
                                                     gap_extension);

  score = gt_linearalign_affinegapcost_compute_local_generic(spacemanager,
                                                            scorehandler, align,
                                                            useq, ustart, ulen,
                                                            vseq, vstart, vlen);
  gt_scorehandler_delete(scorehandler);
  return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rcx
callq 0x1148f4
movq %rax, %r14
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq %rbx, (%rsp)
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x20(%rsp), %r9
callq 0xf87de
movq %rax, %rbx
movq %r14, %rdi
callq 0x114a03
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: evaluateaffinecrosspoints_thread_caller
static void *evaluateaffinecrosspoints_thread_caller(void *data)
{
  GtAffineCrosspointthreadinfo *threadinfo =
                                         (GtAffineCrosspointthreadinfo *) data;
  (void) evaluateaffinecrosspoints(threadinfo->spacemanager,
                                   threadinfo->scorehandler,
                                   threadinfo->useq,
                                   threadinfo->ustart,
                                   threadinfo-> ulen,
                                   threadinfo->vseq,
                                   threadinfo->vstart,
                                   threadinfo->vlen,
                                   threadinfo->Ctab,
                                   threadinfo->rowoffset,
                                   threadinfo->from_edge,
                                   threadinfo->to_edge,
                                   threadinfo->threadcount);
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %r8
movq 0x18(%rdi), %r9
movups 0x30(%rdi), %xmm0
movups 0x40(%rdi), %xmm1
movl 0x58(%rdi), %r10d
movl 0x5c(%rdi), %r11d
movq 0x50(%rdi), %rdi
movq %rdi, 0x30(%rsp)
movl %r11d, 0x28(%rsp)
movl %r10d, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0xf7b8c
xorl %eax, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: get_Rtabentry
static inline GtAffineAlignRnode get_Rtabentry(const GtAffineAlignRtabentry
                                                *rtab, GtAffineAlignEdge edge)
{
  if (edge == Affine_R)
  {
    return rtab->val_R;
  }
  if (edge == Affine_D)
  {
    return rtab->val_D;
  }
  gt_assert(edge == Affine_I);
  return rtab->val_I;
}

// Assembly:
testl %esi, %esi
je 0xf954a
cmpl $0x2, %esi
je 0xf9541
cmpl $0x1, %esi
jne 0xf9557
leaq 0x10(%rdi), %rax
pushq $0x18
jmp 0xf9547
leaq 0x20(%rdi), %rax
pushq $0x28
popq %rcx
jmp 0xf9550
pushq $0x8
popq %rcx
movq %rdi, %rax
movl (%rdi,%rcx), %edx
movq (%rax), %rax
retq
pushq %rax
movq 0x33ea09(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ebaaa(%rip), %rsi    # 0x2e5013
leaq 0x22cfb5(%rip), %rdx    # 0x326525
leaq 0x22cfbf(%rip), %rcx    # 0x326536
leaq 0x22cdb7(%rip), %r8     # 0x326335
pushq $0x44
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: setStarttabentry
static GtUwordPair setStarttabentry(GtWord entry, GtAffinealignDPentry *Atab,
                                    Starttabentry *Stab,
                                    GtWord replacement,
                                    GtWord gap_opening,
                                    GtWord gap_extension,
                                    const GtAffineAlignEdge edge)
{
  GtUwordPair start;
  switch (edge) {
    case Affine_R:
      if (entry == Atab->Rvalue + replacement)
         start = Stab->Rstart;
      else if (entry == Atab->Dvalue + replacement)
         start = Stab->Dstart;
      else if (entry == Atab->Ivalue + replacement)
         start = Stab->Istart;
      else
        start = Stab->Rstart;
      break;
    case Affine_D:
      if (entry == Atab->Rvalue + gap_opening + gap_extension)
         start = Stab->Rstart;
      else if (entry == Atab->Dvalue + gap_extension)
         start = Stab->Dstart;
      else if (entry == Atab->Ivalue + gap_opening + gap_extension)
         start = Stab->Istart;
      else
        start = Stab->Rstart;
      break;
    case Affine_I:
      if (entry == Atab->Rvalue + gap_opening + gap_extension)
         start = Stab->Rstart;
      else if (entry == Atab->Dvalue + gap_opening + gap_extension)
         start = Stab->Dstart;
      else if (entry == Atab->Ivalue + gap_extension)
         start = Stab->Istart;
      else
        start = Stab->Rstart;
      break;
    default:
      start.a = 0;
      start.b = 0;
  }
  return start;
}

// Assembly:
movl 0x8(%rsp), %r10d
movq (%rsi), %rax
cmpl $0x2, %r10d
je 0xf95c1
cmpl $0x1, %r10d
jne 0xf95e0
addq %r9, %r8
addq %r8, %rax
cmpq %rdi, %rax
je 0xf95e8
addq 0x8(%rsi), %r9
cmpq %rdi, %r9
je 0xf95fc
addq 0x10(%rsi), %r8
xorl %eax, %eax
cmpq %rdi, %r8
jmp 0xf960e
addq %r9, %r8
addq %r8, %rax
cmpq %rdi, %rax
je 0xf95e8
addq 0x8(%rsi), %r8
cmpq %rdi, %r8
je 0xf95fc
addq 0x10(%rsi), %r9
xorl %eax, %eax
cmpq %rdi, %r9
jmp 0xf960e
addq %rcx, %rax
cmpq %rdi, %rax
jne 0xf95f0
pushq $0x8
popq %rax
movq %rdx, %rcx
jmp 0xf961c
movq 0x8(%rsi), %rax
addq %rcx, %rax
cmpq %rdi, %rax
jne 0xf9605
leaq 0x10(%rdx), %rcx
pushq $0x18
popq %rax
jmp 0xf961c
addq 0x10(%rsi), %rcx
xorl %eax, %eax
cmpq %rdi, %rcx
sete %al
shll $0x5, %eax
leaq (%rdx,%rax), %rcx
orq $0x8, %rax
movq (%rdx,%rax), %rdx
movq (%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_new
GtLinspaceManagement* gt_linspace_management_new()
{
  GtLinspaceManagement *spacemanager;
  spacemanager = gt_malloc(sizeof(*spacemanager));
  spacemanager->valueTabspace = NULL;
  spacemanager->rTabspace = NULL;
  spacemanager->crosspointTabspace = NULL;
  spacemanager->maxscoordvaluespace = NULL;
  spacemanager->valueTabsize = 0;
  spacemanager->rTabsize = 0;
  spacemanager->crosspointTabsize = 0;
  spacemanager->timesquarefactor = 1;
  spacemanager->ulen = 0;
  spacemanager->spacepeak = 0;
  return spacemanager;
}

// Assembly:
pushq %rax
leaq 0x22cf18(%rip), %rsi    # 0x326544
pushq $0x50
popq %rdi
pushq $0x28
popq %rdx
callq 0x93160
andq $0x0, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movq $0x1, 0x20(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_delete
void gt_linspace_management_delete(GtLinspaceManagement *spacemanager)
{
  if (spacemanager != NULL)
  {
    gt_free(spacemanager->valueTabspace);
    gt_free(spacemanager->rTabspace);
    if (spacemanager->crosspointTabspace != NULL)
      gt_free(spacemanager->crosspointTabspace);
    gt_maxcoordvalue_delete(spacemanager->maxscoordvaluespace);
    gt_free(spacemanager);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xf96c2
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x22ced6(%rip), %r14    # 0x326544
pushq $0x3a
popq %rdx
movq %r14, %rsi
callq 0x936f9
movq 0x8(%rbx), %rdi
pushq $0x3b
popq %rdx
movq %r14, %rsi
callq 0x936f9
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xf96a0
leaq 0x22ceac(%rip), %rsi    # 0x326544
pushq $0x3d
popq %rdx
callq 0x936f9
movq 0x48(%rbx), %rdi
callq 0xff5bf
leaq 0x22ce94(%rip), %rsi    # 0x326544
pushq $0x3f
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linspace_management.c
// Function: checksquare
static bool checksquare(GtLinspaceManagement *spacemanager,
                        GtUword ulen, GtUword vlen,
                        size_t valuesize, size_t rsize,
                        bool local)
{
  GtUword TSfactor;
  gt_assert(spacemanager);

  TSfactor = spacemanager->timesquarefactor;
  if ((ulen+1)*(vlen+1)*valuesize <= spacemanager->valueTabsize)
  {
    if (local)
      gt_maxcoordvalue_reset(spacemanager->maxscoordvaluespace);
    return true;
  }
  else if ((ulen+1)*(vlen+1) <= (spacemanager->ulen+1)*TSfactor)
  {
    if (!local)
    {
      gt_linspace_management_check_generic(spacemanager,(ulen+1)*(vlen+1)-1,
                                           vlen,valuesize,rsize,0,false);
    }
    else
    {
       gt_linspace_management_check_generic(spacemanager,(ulen+1)*(vlen+1)-1,
                                            vlen,valuesize,rsize,0,true);
    }
    return true;
  }
  return false;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xf98f1
movq %rsi, %rax
incq %rax
leaq 0x1(%rdx), %rsi
imulq %rax, %rsi
movq %rsi, %rax
imulq %rcx, %rax
cmpq 0x28(%rdi), %rax
jbe 0xf98b8
movq 0x18(%rdi), %rax
incq %rax
imulq 0x20(%rdi), %rax
cmpq %rax, %rsi
jbe 0xf98ca
xorl %ebx, %ebx
jmp 0xf98e9
movb $0x1, %bl
testb %r9b, %r9b
je 0xf98e9
movq 0x48(%rdi), %rdi
callq 0xff8f2
jmp 0xf98e9
decq %rsi
testb %r9b, %r9b
je 0xf98db
movl $0x1, (%rsp)
jmp 0xf98df
andl $0x0, (%rsp)
xorl %r9d, %r9d
callq 0xf9723
movb $0x1, %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq 0x33e670(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1eb711(%rip), %rsi    # 0x2e5013
leaq 0x22c6ca(%rip), %rdx    # 0x325fd3
leaq 0x22cd87(%rip), %rcx    # 0x326697
leaq 0x22cc2d(%rip), %r8     # 0x326544
movl $0xa1, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_change_to_square
GtUword **gt_linspace_management_change_to_square(GtLinspaceManagement
                                                 *spacemanager,
                                                 GtUword ulen, GtUword vlen)
{
  GtUword **E;
  GtUword idx;
  gt_assert(gt_linspace_management_check_space(spacemanager, ulen, vlen));

  E = gt_linspace_management_get_rTabspace(spacemanager);
  *E = gt_linspace_management_get_valueTabspace(spacemanager);

  for (idx=1;idx<ulen+1;idx++)
    E[idx]=E[idx-1]+vlen+1;

  return E;
}

// Assembly:
pushq %rax
leaq 0x1(%rdx), %rax
leaq 0x8(,%rsi,8), %rcx
imulq %rax, %rcx
cmpq 0x28(%rdi), %rcx
ja 0xf9a2f
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rcx, (%rax)
incq %rsi
pushq $0x1
popq %rcx
cmpq %rsi, %rcx
jae 0xf9a2d
movq -0x8(%rax,%rcx,8), %rdi
leaq (%rdi,%rdx,8), %rdi
addq $0x8, %rdi
movq %rdi, (%rax,%rcx,8)
incq %rcx
jmp 0xf9a12
popq %rcx
retq
movq 0x33e532(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1eb5d3(%rip), %rsi    # 0x2e5013
leaq 0x22cba2(%rip), %rdx    # 0x3265e9
leaq 0x22cbd8(%rip), %rcx    # 0x326626
leaq 0x22caef(%rip), %r8     # 0x326544
movl $0x10c, %r9d            # imm = 0x10C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_class
const GtNodeStreamClass* gt_load_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtLoadStream),
                                   gt_load_stream_free,
                                   gt_load_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x343c7e(%rip)    # 0x43d738
jne 0xf9ad9
leaq 0x24(%rip), %rsi        # 0xf9ae7
leaq 0x77(%rip), %rdx        # 0xf9b41
pushq $0x30
popq %rdi
callq 0x102838
movq %rax, 0x343c5f(%rip)    # 0x43d738
callq 0x69ede
movq 0x343c53(%rip), %rax    # 0x43d738
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_free
static void gt_load_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtLoadStream *load_stream = gt_load_stream_cast(ns);
  for (i = load_stream->idx; i < gt_array_size(load_stream->nodes); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                          gt_array_get(load_stream->nodes, i));
  }
  gt_array_delete(load_stream->nodes);
  gt_node_stream_delete(load_stream->in_stream);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf9aac
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0x18(%rax), %r14
movq 0x20(%rbx), %rdi
callq 0x586a4
movq 0x20(%rbx), %rdi
cmpq %rax, %r14
jae 0xf9b2c
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0xde013
incq %r14
jmp 0xf9b05
callq 0x58eb9
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10297b
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xf9b6c
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0xf9c52
callq 0xf9aac
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
movq %rax, %r14
cmpb $0x0, 0x28(%rax)
je 0xf9bb8
jne 0xf9c0e
movq 0x33e3d6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1eb477(%rip), %rsi    # 0x2e5013
leaq 0x22cb42(%rip), %rdx    # 0x3266e5
leaq 0x22cb27(%rip), %rcx    # 0x3266d1
leaq 0x22cb05(%rip), %r8     # 0x3266b6
pushq $0x3f
jmp 0xf9c7a
leaq 0x8(%rsp), %r12
pushq $0x8
popq %r13
movq 0x10(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x102a22
testl %eax, %eax
jne 0xf9c05
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf9c05
callq 0x29a8bb
testq %rax, %rax
je 0xf9bf4
movq 0x8(%rsp), %rdi
callq 0xde013
jmp 0xf9bc1
movq 0x20(%r14), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5851d
jmp 0xf9bc1
testl %eax, %eax
jne 0xf9c44
movb $0x1, 0x28(%r14)
movq 0x18(%r14), %r15
movq 0x20(%r14), %rdi
callq 0x586a4
movq 0x20(%r14), %rdi
cmpq %rax, %r15
jae 0xf9c39
movq 0x18(%r14), %rsi
callq 0x581aa
movq (%rax), %rax
movq %rax, (%rbx)
incq 0x18(%r14)
jmp 0xf9c42
callq 0x5876c
andq $0x0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x33e30f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1eb3b0(%rip), %rsi    # 0x2e5013
leaq 0x1eb555(%rip), %rdx    # 0x2e51bf
leaq 0x22ca60(%rip), %rcx    # 0x3266d1
leaq 0x22ca3e(%rip), %r8     # 0x3266b6
pushq $0x2e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xf9aac
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x10289f
movq %rax, %rbx
callq 0xf9aac
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
testq %r14, %r14
je 0xf9ce6
movq %rax, %r15
movq %r14, %rdi
callq 0x102934
movq %rax, 0x10(%r15)
movb $0x0, 0x28(%r15)
andq $0x0, 0x18(%r15)
pushq $0x8
popq %rdi
callq 0x5809c
movq %rax, 0x20(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x33e27b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1eb31c(%rip), %rsi    # 0x2e5013
leaq 0x1f5695(%rip), %rdx    # 0x2ef393
leaq 0x22c99e(%rip), %rcx    # 0x3266a3
leaq 0x22c9aa(%rip), %r8     # 0x3266b6
pushq $0x6d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfba10
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x292a70
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0x33c551(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e95f2(%rip), %rsi    # 0x2e5013
leaq 0x207dc5(%rip), %rdx    # 0x3037ed
leaq 0x22b536(%rip), %rcx    # 0x326f65
leaq 0x22b542(%rip), %r8     # 0x326f78
pushq $0x22
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfbae4
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfbae4
movq %r9, %rbp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x22b4fc(%rip), %rsi    # 0x326f78
pushq $0x32
popq %rdx
callq 0x93160
movq %rax, %r13
movq %rbx, (%rax)
testq %rbp, %rbp
je 0xfba99
movq %rbp, %rdi
callq 0xacbd1
jmp 0xfba9b
xorl %eax, %eax
movl 0x48(%rsp), %ebx
movq %rax, 0x8(%r13)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xfbab4
callq 0xacbd1
jmp 0xfbab6
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
movq 0x33c47d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e951e(%rip), %rsi    # 0x2e5013
leaq 0x22b491(%rip), %rdx    # 0x326f8d
leaq 0x22b4a1(%rip), %rcx    # 0x326fa4
leaq 0x22b46e(%rip), %r8     # 0x326f78
pushq $0x31
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfbbf8
movq %rsi, %r14
testq %rsi, %rsi
je 0xfbbf8
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xfbbe4
callq 0xad357
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xacbfb
movq %r14, %rdi
callq 0xacbd1
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x33c369(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e940a(%rip), %rsi    # 0x2e5013
leaq 0x22b400(%rip), %rdx    # 0x327010
leaq 0x22b408(%rip), %rcx    # 0x32701f
leaq 0x22b35a(%rip), %r8     # 0x326f78
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfbc77
movq %rsi, %r14
testq %rsi, %rsi
je 0xfbc77
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xfbc63
callq 0xad357
movq 0x10(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xacbfb
movq %r14, %rdi
callq 0xacbd1
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x33c2ea(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e938b(%rip), %rsi    # 0x2e5013
leaq 0x22b381(%rip), %rdx    # 0x327010
leaq 0x22b39d(%rip), %rcx    # 0x327033
leaq 0x22b2db(%rip), %r8     # 0x326f78
pushq $0x5f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfbcf5
movq %rsi, %r14
testq %rsi, %rsi
je 0xfbcf5
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xfbcd9
callq 0xad357
movq 0x8(%r15), %rdi
jmp 0xfbce5
callq 0xacb84
movq %rax, %rdi
movq %rax, 0x8(%r15)
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xacd9e
movq 0x33c26c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e930d(%rip), %rsi    # 0x2e5013
leaq 0x22b303(%rip), %rdx    # 0x327010
leaq 0x22b333(%rip), %rcx    # 0x327047
leaq 0x22b25d(%rip), %r8     # 0x326f78
pushq $0x6b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfbd73
movq %rsi, %r14
testq %rsi, %rsi
je 0xfbd73
movq %rdx, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xfbd57
callq 0xad357
movq 0x10(%r15), %rdi
jmp 0xfbd63
callq 0xacb84
movq %rax, %rdi
movq %rax, 0x10(%r15)
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xacd9e
movq 0x33c1ee(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e928f(%rip), %rsi    # 0x2e5013
leaq 0x22b285(%rip), %rdx    # 0x327010
leaq 0x22b2cc(%rip), %rcx    # 0x32705e
leaq 0x22b1df(%rip), %r8     # 0x326f78
pushq $0x76
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfbee2
cmpq %rdx, %rsi
ja 0xfbf10
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
popq %rax
retq
movq 0x33c07f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e9120(%rip), %rsi    # 0x2e5013
leaq 0x22b0fe(%rip), %rdx    # 0x326ff8
leaq 0x22b1db(%rip), %rcx    # 0x3270dc
leaq 0x22b070(%rip), %r8     # 0x326f78
movl $0x9b, %r9d
jmp 0xfbf3c
movq 0x33c051(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e90f2(%rip), %rsi    # 0x2e5013
leaq 0x20f24d(%rip), %rdx    # 0x30b175
leaq 0x22b1ad(%rip), %rcx    # 0x3270dc
leaq 0x22b042(%rip), %r8     # 0x326f78
movl $0x9c, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfbf5d
cmpq %rdx, %rsi
ja 0xfbf8b
movq %rsi, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
popq %rax
retq
movq 0x33c004(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e90a5(%rip), %rsi    # 0x2e5013
leaq 0x22b083(%rip), %rdx    # 0x326ff8
leaq 0x22b178(%rip), %rcx    # 0x3270f4
leaq 0x22aff5(%rip), %r8     # 0x326f78
movl $0xa4, %r9d
jmp 0xfbfb7
movq 0x33bfd6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e9077(%rip), %rsi    # 0x2e5013
leaq 0x20f1d2(%rip), %rdx    # 0x30b175
leaq 0x22b14a(%rip), %rcx    # 0x3270f4
leaq 0x22afc7(%rip), %r8     # 0x326f78
movl $0xa5, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfc055
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xfc057
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xfc024
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xfc032
callq 0xae103
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xfc040
callq 0xae103
leaq 0x22af31(%rip), %rsi    # 0x326f78
movq %rbx, %rdi
movl $0xba, %edx
popq %rbx
jmp 0x936f9
popq %rbx
retq
movq 0x33bf0a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e8fab(%rip), %rsi    # 0x2e5013
leaq 0x22b0b4(%rip), %rdx    # 0x327123
leaq 0x22b0bc(%rip), %rcx    # 0x327132
leaq 0x22aefb(%rip), %r8     # 0x326f78
movl $0xb3, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x3416a2(%rip)    # 0x43d740
jne 0xfc0b8
leaq 0x1f(%rip), %rdx        # 0xfc0c6
pushq $0x70
popq %rdi
xorl %esi, %esi
callq 0xfb9e4
movq %rax, 0x341688(%rip)    # 0x43d740
callq 0x69ede
movq 0x34167c(%rip), %rax    # 0x43d740
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc112
movq %rsi, %r14
testq %rsi, %rsi
je 0xfc112
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xfc0ef
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xfc13c
callq 0xfc090
movq %rax, %rdi
movq %r15, %rsi
callq 0xfbb1a
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xff3da
movq 0x33be4f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e8ef0(%rip), %rsi    # 0x2e5013
leaq 0x22b18d(%rip), %rdx    # 0x3272b7
leaq 0x22b192(%rip), %rcx    # 0x3272c3
leaq 0x22b024(%rip), %r8     # 0x32715c
pushq $0x32
jmp 0xfc164
movq 0x33be25(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e8ec6(%rip), %rsi    # 0x2e5013
leaq 0x1e906b(%rip), %rdx    # 0x2e51bf
leaq 0x22b168(%rip), %rcx    # 0x3272c3
leaq 0x22affa(%rip), %r8     # 0x32715c
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfc090
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 0xfba46
popq %rcx
popq %rdx
movq %rax, %rbx
callq 0xfc090
movq %rax, %rdi
movq %rbx, %rsi
callq 0xfbb1a
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_O2/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 0xfc090
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 0xfba46
popq %rcx
popq %rdx
movq %rax, %rbx
callq 0xfc090
movq %rax, %rdi
movq %rbx, %rsi
callq 0xfbb1a
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_O2/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 0xfc647
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xfc647
leaq 0x22acc9(%rip), %rdx    # 0x327300
pushq $0x1
popq %rdi
pushq $0x28
popq %rcx
callq 0x9334a
movq %rbx, (%rax)
popq %rbx
retq
movq 0x33b91a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e89bb(%rip), %rsi    # 0x2e5013
leaq 0x22ac77(%rip), %rdx    # 0x3272d6
leaq 0x22ac81(%rip), %rcx    # 0x3272e7
leaq 0x22ac93(%rip), %r8     # 0x327300
pushq $0x27
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfc694
movq (%rdi), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xfc690
jmpq *%rax
pushq $0x1
popq %rax
retq
pushq %rax
movq 0x33b8cc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e896d(%rip), %rsi    # 0x2e5013
leaq 0x204df0(%rip), %rdx    # 0x30149d
leaq 0x22ac6a(%rip), %rcx    # 0x32731e
leaq 0x22ac45(%rip), %r8     # 0x327300
pushq $0x30
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xfc742
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xfc72f
movq %rbx, %rdi
callq *%rax
leaq 0x22abca(%rip), %rsi    # 0x327300
pushq $0x42
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xfc834
movq %rax, %rdi
callq 0xfc61f
movq %rax, %rbx
callq 0xfc834
movq %rax, %rdi
movq %rbx, %rsi
callq 0xfc6cb
movq %rax, %r12
leaq 0x22abec(%rip), %rdx    # 0x327368
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
movl $0xb9, %ecx
callq 0x9334a
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0x8da98
testb %al, %al
je 0xfc7d2
movq %r14, %rdi
callq 0x8ccb0
testl %eax, %eax
je 0xfc7f2
leaq 0x1fe67d(%rip), %rdx    # 0x2fae2d
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rcx
callq 0x8cea6
movq 0x8(%r12), %rcx
movq %rax, 0x10(%rcx)
andq $0x0, 0x8(%rcx)
testq %rax, %rax
jne 0xfc814
jmp 0xfc7e6
leaq 0x22abc5(%rip), %rsi    # 0x32739e
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x89dbb
movq %rbx, %rdi
callq 0xfc715
xorl %ebx, %ebx
jmp 0xfc81c
leaq 0x1fe634(%rip), %rsi    # 0x2fae2d
movq %r14, %rdi
callq 0x17860
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
andq $0x0, 0x10(%rcx)
testq %rax, %rax
je 0xfc82b
movq %r14, 0x18(%rcx)
movb $0x0, 0x20(%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x22ab5a(%rip), %rsi    # 0x32738c
jmp 0xfc7d9
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x340f06(%rip)    # 0x43d748
jne 0xfc861
leaq 0x643(%rip), %rsi       # 0xfce8e
leaq 0x99e(%rip), %rdx       # 0xfd1f0
pushq $0x10
popq %rdi
callq 0xfc5f8
movq %rax, 0x340ee7(%rip)    # 0x43d748
callq 0x69ede
movq 0x340edb(%rip), %rax    # 0x43d748
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfc834
movq %rax, %rdi
callq 0xfc61f
movq %rax, %rbx
callq 0xfc834
movq %rax, %rdi
movq %rbx, %rsi
callq 0xfc6cb
movq %rax, %r12
leaq 0x22aac1(%rip), %rdx    # 0x327368
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
movl $0xdf, %ecx
callq 0x9334a
movq %rax, 0x8(%r12)
leaq 0x1e963e(%rip), %rcx    # 0x2e5f01
movq %rcx, 0x18(%rax)
movb $0x1, 0x20(%rax)
movq %r15, %rdi
callq 0xbd62d
movq %r15, %rdi
movq %r14, %rsi
callq 0xbd6bc
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
testq %rax, %rax
je 0xfc8f3
andq $0x0, 0x10(%rcx)
jmp 0xfc8f5
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbcff0
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0xbd034
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbd0af
movsd 0x8(%rsp), %xmm0
ucomisd 0x1eb201(%rip), %xmm0   # 0x2e7d10
jne 0xfcb13
jnp 0xfcb1b
movq %r14, %rdi
callq 0xbd12c
movl %r13d, %eax
negl %eax
jo 0xfcb2d
movq %r14, %rdi
movl %r13d, %esi
callq 0xbd1b0
movl %r12d, %eax
negl %eax
jo 0xfcb3f
movq %r14, %rdi
movl %r12d, %esi
callq 0xbd22b
movl %r15d, %eax
negl %eax
jo 0xfcb51
movq %r14, %rdi
movl %r15d, %esi
callq 0xbd2a6
movl 0x4(%rsp), %ecx
movl %ecx, %eax
negl %eax
jo 0xfcb67
cvtsi2sd %ecx, %xmm0
movq %r14, %rdi
callq 0xbd4fa
movq %r14, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfc86f