LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltr_input_check_visitor.c
// Function: gt_ltr_input_check_visitor_new
GtNodeVisitor* gt_ltr_input_check_visitor_new(void)
{
  GtNodeVisitor *nv = NULL;
  GtLTRInputCheckVisitor *lv;
  nv = gt_node_visitor_create(gt_ltr_input_check_visitor_class());
  gt_assert(nv);
  lv = gt_ltr_input_check_visitor_cast(nv);
  lv->only_ltrs = false;
  return nv;
}

// Assembly:
pushq %rbx
callq 0x211cec
movq %rax, %rdi
callq 0x16aef0
testq %rax, %rax
je 0x211f53
movq %rax, %rbx
callq 0x211cec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movb $0x0, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
callq 0x82426
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltr_refseq_match_stream.c
// Function: gt_ltr_refseq_match_stream_class
const GtNodeStreamClass* gt_ltr_refseq_match_stream_class(void)
{
  static const GtNodeStreamClass *gsc = NULL;
  gt_class_alloc_lock_enter();
  if (!gsc) {
    gsc = gt_node_stream_class_new(sizeof (GtLTRRefseqMatchStream),
                                   gt_ltr_refseq_match_stream_free,
                                   gt_ltr_refseq_match_stream_next);
  }
  gt_class_alloc_lock_leave();
  return gsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x2b7a1a(%rip)    # 0x4c9980
jne 0x211f87
leaq 0x26(%rip), %rsi        # 0x211f95
leaq 0x49(%rip), %rdx        # 0x211fbf
movl $0xa8, %edi
callq 0x16abb4
movq %rax, 0x2b79f9(%rip)    # 0x4c9980
callq 0xe6a19
movq 0x2b79ed(%rip), %rax    # 0x4c9980
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_file_out_stream.c
// Function: gt_ltr_visitor_class
const GtNodeVisitorClass* gt_ltr_visitor_class(void)
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtLTRVisitor),
                                    NULL,
                                    NULL,
                                    gt_ltr_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x2b6c3e(%rip)    # 0x4c9988
jne 0x212d76
movq $0x0, (%rsp)
leaq 0x29(%rip), %rcx        # 0x212d84
movl $0x18, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x2b6c12(%rip)    # 0x4c9988
callq 0xe6a19
movq 0x2b6c06(%rip), %rax    # 0x4c9988
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_file_out_stream.c
// Function: gt_ltrdigest_file_out_stream_class
const GtNodeStreamClass* gt_ltrdigest_file_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtLTRdigestFileOutStream),
                                   gt_ltrfileout_stream_free,
                                   gt_ltrfileout_stream_next );
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x2b5a4d(%rip)    # 0x4c9990
jne 0x213f64
leaq 0x26(%rip), %rsi        # 0x213f72
leaq -0xf65(%rip), %rdx      # 0x212fee
movl $0xe0, %edi
callq 0x16abb4
movq %rax, 0x2b5a2c(%rip)    # 0x4c9990
callq 0xe6a19
movq 0x2b5a20(%rip), %rax    # 0x4c9990
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_file_out_stream.c
// Function: gt_ltrfileout_stream_free
void gt_ltrfileout_stream_free(GtNodeStream *ns)
{
  GtLTRdigestFileOutStream *ls = gt_ltrdigest_file_out_stream_cast(ns);
  if (ls->tabout_file != NULL)
    gt_file_delete(ls->tabout_file);
  if (ls->pbsout_file != NULL)
    gt_file_delete(ls->pbsout_file);
  if (ls->pptout_file != NULL)
    gt_file_delete(ls->pptout_file);
  if (ls->ltr5out_file != NULL)
    gt_file_delete(ls->ltr5out_file);
  if (ls->ltr3out_file != NULL)
    gt_file_delete(ls->ltr3out_file);
  if (ls->elemout_file != NULL)
    gt_file_delete(ls->elemout_file);
  gt_node_visitor_delete((GtNodeVisitor*) ls->lv);
  gt_node_stream_delete(ls->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x213f35
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x213f97
callq 0x1040fc
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x213fa5
callq 0x1040fc
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x213fb3
callq 0x1040fc
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x213fc1
callq 0x1040fc
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x213fcf
callq 0x1040fc
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x213fdd
callq 0x1040fc
movq 0x58(%rbx), %rdi
callq 0x16b162
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x16ac6e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_file_out_stream.c
// Function: gt_ltrdigest_file_out_stream_enable_pdom_alignment_output
void gt_ltrdigest_file_out_stream_enable_pdom_alignment_output(GtNodeStream *ns)
{
  GtLTRdigestFileOutStream *ls;
  gt_assert(ns);
  ls = gt_ltrdigest_file_out_stream_cast(ns);
  ls->write_pdom_alignments = true;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x214012
movq %rdi, %rbx
callq 0x213f35
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movb $0x1, 0xd8(%rax)
popq %rbx
retq
callq 0x828c9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_file_out_stream.c
// Function: gt_ltrdigest_file_out_stream_enable_aa_sequence_output
void gt_ltrdigest_file_out_stream_enable_aa_sequence_output(GtNodeStream *ns)
{
  GtLTRdigestFileOutStream *ls;
  gt_assert(ns);
  ls = gt_ltrdigest_file_out_stream_cast(ns);
  ls->write_pdom_aaseqs = true;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x214039
movq %rdi, %rbx
callq 0x213f35
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movb $0x1, 0xd9(%rax)
popq %rbx
retq
callq 0x82902
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_pbs_visitor.c
// Function: gt_ltrdigest_pbs_visitor_new
GtNodeVisitor* gt_ltrdigest_pbs_visitor_new(GtRegionMapping *rmap,
                                            unsigned int radius,
                                            unsigned int max_edist,
                                            GtRange alilen,
                                            GtRange offsetlen,
                                            GtRange trnaoffsetlen,
                                            int ali_score_match,
                                            int ali_score_mismatch,
                                            int ali_score_insertion,
                                            int ali_score_deletion,
                                            GtBioseq *trna_lib,
                                            GT_UNUSED GtError *err)
{
  GtNodeVisitor *nv = NULL;
  GtLTRdigestPBSVisitor *lv;
  gt_assert(rmap && trna_lib);
  nv = gt_node_visitor_create(gt_ltrdigest_pbs_visitor_class());
  lv = gt_ltrdigest_pbs_visitor_cast(nv);
  lv->tag = gt_str_new_cstr(GT_LTRDIGEST_TAG);
  lv->rmap = rmap;
  lv->radius = radius;
  lv->max_edist = max_edist;
  lv->alilen = alilen;
  lv->offsetlen = offsetlen;
  lv->trnaoffsetlen = trnaoffsetlen;
  lv->ali_score_match = ali_score_match;
  lv->ali_score_mismatch = ali_score_mismatch;
  lv->ali_score_insertion = ali_score_insertion;
  lv->ali_score_deletion = ali_score_deletion;
  lv->trna_lib = trna_lib;
  return nv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, 0x10(%rsp)
testq %rdi, %rdi
je 0x215105
cmpq $0x0, 0x88(%rsp)
je 0x215105
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r13
callq 0x2146ec
movq %rax, %rdi
callq 0x16aef0
movq %rax, %rbx
callq 0x2146ec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %r14
leaq 0x1b31fb(%rip), %rdi    # 0x3c8274
callq 0x120955
movq %rax, 0x18(%r14)
movq %r13, 0x10(%r14)
movl %r12d, 0x48(%r14)
movl %ebp, 0x4c(%r14)
movq %r15, 0x50(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x58(%r14)
leaq 0x50(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x60(%r14)
leaq 0x60(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x70(%r14)
movl 0xc(%rsp), %eax
movl %eax, 0x80(%r14)
movl 0x70(%rsp), %eax
movl %eax, 0x84(%r14)
movl 0x78(%rsp), %eax
movl %eax, 0x88(%r14)
movl 0x80(%rsp), %eax
movl %eax, 0x8c(%r14)
movq 0x88(%rsp), %rax
movq %rax, 0x90(%r14)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x82b73
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_pdom_visitor.c
// Function: gt_ltrdigest_pdom_visitor_free
void gt_ltrdigest_pdom_visitor_free(GtNodeVisitor *nv)
{
  GtLTRdigestPdomVisitor *lv;
  GtUword i;
  if (!nv) return;
  lv = gt_ltrdigest_pdom_visitor_cast(nv);
  for (i = 0UL; i < 3UL; i++) {
    gt_str_delete(lv->fwd[i]);
    gt_str_delete(lv->rev[i]);
  }
  gt_str_delete(lv->cmdline);
  gt_str_delete(lv->tag);
  gt_cstr_array_delete(lv->args);
}

// Assembly:
testq %rdi, %rdi
je 0x2153db
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2153dc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq $-0x18, %r14
movq 0x48(%rbx,%r14), %rdi
callq 0x121b03
movq 0x60(%rbx,%r14), %rdi
callq 0x121b03
addq $0x8, %r14
jne 0x215396
movq 0x80(%rbx), %rdi
callq 0x121b03
movq 0x88(%rbx), %rdi
callq 0x121b03
movq 0x98(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe8d46
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_pdom_visitor.c
// Function: gt_ltrdigest_checkpipe
static int gt_ltrdigest_checkpipe(int *fdpair, GtError *err)
{
  int had_err = 0;
  if (pipe(fdpair)) {
    gt_error_set(err, "could not create pipe, please check for number of "
                      "allowed file descriptors: %s", strerror(errno));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x179f0
testl %eax, %eax
je 0x215d41
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x1b3e36(%rip), %rsi    # 0x3c9b63
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x215d43
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_pdom_visitor.c
// Function: gt_ltrdigest_hmmscan_send_thread
static void* gt_ltrdigest_hmmscan_send_thread(void *data) {
  GtUword i;
  GtLTRdigestHMMscanThreadData *d = (GtLTRdigestHMMscanThreadData*) data;
  for (i = 0UL; i < 3UL; i++) {
    char buf[5];
    GT_UNUSED ssize_t written;
    (void) sprintf(buf, ">"GT_WU"%c\n", i, '+');
    written = write(d->pc[1], buf, 4 * sizeof (char));
    written = write(d->pc[1], gt_str_get(d->lv->fwd[i]),
                   (size_t) gt_str_length(d->lv->fwd[i]) * sizeof (char));
    written = write(d->pc[1], "\n", 1 * sizeof (char));
    (void) sprintf(buf, ">"GT_WU"%c\n", i, '-');
    written = write(d->pc[1], buf, 4 * sizeof (char));
    written = write(d->pc[1], gt_str_get(d->lv->rev[i]),
                   (size_t) gt_str_length(d->lv->rev[i]) * sizeof (char));
  }
  (void) close(d->pc[0]);
  (void) close(d->pc[1]);
  (void) close(d->cp[1]);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b3e9f(%rip), %r14    # 0x3c9c0b
leaq 0x3(%rsp), %r15
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0x2b, %ecx
xorl %eax, %eax
callq 0x17130
movq (%rbx), %rax
movl 0x4(%rax), %edi
movl $0x4, %edx
movq %r15, %rsi
callq 0x17270
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movl 0x4(%rax), %ebp
movq 0x30(%rcx,%r13,8), %rdi
callq 0x120d23
movq %rax, %r12
movq 0x18(%rbx), %rax
movq 0x30(%rax,%r13,8), %rdi
callq 0x120d4c
movl %ebp, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x17270
movq (%rbx), %rax
movl 0x4(%rax), %edi
movl $0x1, %edx
leaq 0x1b393f(%rip), %rsi    # 0x3c971f
callq 0x17270
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0x2d, %ecx
xorl %eax, %eax
callq 0x17130
movq (%rbx), %rax
movl 0x4(%rax), %edi
movl $0x4, %edx
movq %r15, %rsi
callq 0x17270
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movl 0x4(%rax), %ebp
movq 0x48(%rcx,%r13,8), %rdi
callq 0x120d23
movq %rax, %r12
movq 0x18(%rbx), %rax
movq 0x48(%rax,%r13,8), %rdi
callq 0x120d4c
movl %ebp, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x17270
incq %r13
cmpq $0x3, %r13
jne 0x215d74
movq (%rbx), %rax
movl (%rax), %edi
callq 0x17fc0
movq (%rbx), %rax
movl 0x4(%rax), %edi
callq 0x17fc0
movq 0x8(%rbx), %rax
movl 0x4(%rax), %edi
callq 0x17fc0
xorl %eax, %eax
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/ltr/ltrdigest_pdom_visitor.c
// Function: gt_hmmer_model_hit_delete
static void gt_hmmer_model_hit_delete(GtHMMERModelHit *mh)
{
  GtUword i;
  if (!mh) return;
  for (i = 0; i < gt_array_size(mh->fwd_hits); i++) {
    GtHMMERSingleHit *h = *(GtHMMERSingleHit**)  gt_array_get(mh->fwd_hits, i);
    gt_str_delete(h->alignment);
    gt_str_delete(h->aastring);
    gt_array_delete(h->chains);
    gt_free(h);
  }
  gt_array_delete(mh->fwd_hits);
  for (i = 0; i < gt_array_size(mh->rev_hits); i++) {
    GtHMMERSingleHit *h = *(GtHMMERSingleHit**)  gt_array_get(mh->rev_hits, i);
    gt_str_delete(h->alignment);
    gt_str_delete(h->aastring);
    gt_array_delete(h->chains);
    gt_free(h);
  }
  gt_array_delete(mh->rev_hits);
  gt_free(mh);
}

// Assembly:
testq %rdi, %rdi
je 0x217188
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x2170f2
xorl %r14d, %r14d
leaq 0x1b28b6(%rip), %r15    # 0x3c995c
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %r12
movq 0x50(%r12), %rdi
callq 0x121b03
movq 0x58(%r12), %rdi
callq 0x121b03
movq 0x40(%r12), %rdi
callq 0xd4ef4
movq %r12, %rdi
movq %r15, %rsi
movl $0xd8, %edx
callq 0x109670
incq %r14
movq (%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x2170a6
movq (%rbx), %rdi
callq 0xd4ef4
movq 0x8(%rbx), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x217160
xorl %r14d, %r14d
leaq 0x1b284a(%rip), %r15    # 0x3c995c
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %r12
movq 0x50(%r12), %rdi
callq 0x121b03
movq 0x58(%r12), %rdi
callq 0x121b03
movq 0x40(%r12), %rdi
callq 0xd4ef4
movq %r12, %rdi
movq %r15, %rsi
movl $0xe0, %edx
callq 0x109670
incq %r14
movq 0x8(%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x217112
movq 0x8(%rbx), %rdi
callq 0xd4ef4
leaq 0x1b27ec(%rip), %rsi    # 0x3c995c
movq %rbx, %rdi
movl $0xe3, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_pdom_visitor.c
// Function: gt_ltrdigest_pdom_visitor_chainproc
static void gt_ltrdigest_pdom_visitor_chainproc(GtChain *c, GtFragment *f,
                                             GT_UNUSED GtUword nof_frags,
                                             GT_UNUSED GtUword gap_length,
                                             void *data)
{
  GtUword i,
                *chainno = (GtUword*) data;
  gt_log_log("resulting chain has "GT_WD" GtFragments, score "GT_WD"",
             gt_chain_size(c),
             gt_chain_get_score(c));
  for (i = 0; i < gt_chain_size(c); i++) {
    GtFragment frag;
    frag = f[gt_chain_get_fragnum(c, i)];
    gt_log_log("("GT_WU" "GT_WU") ("GT_WU" "GT_WU")", frag.startpos1,
               frag.endpos1, frag.startpos2, frag.endpos2);
    gt_array_add(((GtHMMERSingleHit*) frag.data)->chains, *chainno);
  }
  (*chainno)++;
  gt_log_log("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x3059fd
movq %rax, %r12
movq %r15, %rdi
callq 0x305944
leaq 0x1b2cc7(%rip), %rdi    # 0x3ca053
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x108e02
movq %r15, %rdi
callq 0x3059fd
testq %rax, %rax
je 0x217406
leaq 0x1b2cd5(%rip), %r12    # 0x3ca082
xorl %r13d, %r13d
movq %r15, %rdi
movq %r13, %rsi
callq 0x3059c1
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq (%r14,%rax), %rsi
movq 0x8(%r14,%rax), %rdx
movq 0x10(%r14,%rax), %rcx
movq 0x18(%r14,%rax), %r8
movq 0x28(%r14,%rax), %rbp
movq %r12, %rdi
xorl %eax, %eax
callq 0x108e02
movq 0x40(%rbp), %rdi
movl $0x8, %edx
movq %rbx, %rsi
callq 0xd49ce
incq %r13
movq %r15, %rdi
callq 0x3059fd
cmpq %rax, %r13
jb 0x2173b0
incq (%rbx)
leaq 0x1b230f(%rip), %rdi    # 0x3c971f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x108e02
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_ppt_visitor.c
// Function: gt_ppt_hit_get_coords
GtRange gt_ppt_hit_get_coords(const GtPPTHit *h,
                                     GtLTRdigestPPTVisitor *lv)
{
  GtRange rng;
  gt_assert(h);
  rng.start = h->rng.start;
  rng.end = h->rng.end;
  switch (h->strand)
  {
    case GT_STRAND_FORWARD:
    default:
      rng.start = h->res->rightltrrng.start - 2 - lv->radius
                    + rng.start;
      rng.end = rng.start + (gt_range_length(&h->rng) - 1);
      break;
    case GT_STRAND_REVERSE:
      rng.end = h->res->leftltrrng.end + lv->radius - rng.start;
      rng.start = rng.end - (gt_range_length(&h->rng) - 1);
      break;
  }
  gt_assert(gt_range_length(&rng) == gt_range_length(&h->rng));
  return rng;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x217731
movq %rdi, %rbx
movdqu (%rdi), %xmm0
movdqa %xmm0, (%rsp)
cmpl $0x1, 0x28(%rdi)
movq 0x30(%rdi), %rcx
movl 0x88(%rsi), %eax
jne 0x2176e0
movq 0x10(%rcx), %r14
movq %xmm0, %rcx
subq %rcx, %r14
addq %rax, %r14
movq %r14, 0x8(%rsp)
movq %rbx, %rdi
callq 0x117813
subq %rax, %r14
incq %r14
movq %r14, (%rsp)
jmp 0x217708
movq %xmm0, %r14
addq 0x18(%rcx), %r14
subq %rax, %r14
leaq -0x2(%r14), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x117813
addq %r14, %rax
addq $-0x3, %rax
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
callq 0x117813
movq %rax, %r14
movq %rbx, %rdi
callq 0x117813
cmpq %rax, %r14
jne 0x217736
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x8347c
callq 0x83443
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_ppt_visitor.c
// Function: gt_ppt_results_delete
void gt_ppt_results_delete(GtPPTResults *results)
{
  GtUword i;
  if (results == NULL) return;

  if (results->hits != NULL)
  {
    for (i=0;i<gt_array_size(results->hits);i++)
    {
      GtPPTHit * hit = *(GtPPTHit**) gt_array_get(results->hits,i);
      if (hit->ubox != NULL)
        gt_free(hit->ubox);
      gt_free(hit);
    }
    gt_array_delete(results->hits);
  }
  gt_free(results);
}

// Assembly:
testq %rdi, %rdi
je 0x2177d8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2177b9
movq (%rbx), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x2177b1
xorl %r14d, %r14d
leaq 0x1b29fa(%rip), %r15    # 0x3ca166
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %r12
movq 0x20(%r12), %rdi
testq %rdi, %rdi
je 0x217791
movq %r15, %rsi
movl $0x1ca, %edx            # imm = 0x1CA
callq 0x109670
movq %r12, %rdi
movq %r15, %rsi
movl $0x1cb, %edx            # imm = 0x1CB
callq 0x109670
incq %r14
movq (%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x21776c
movq (%rbx), %rdi
callq 0xd4ef4
leaq 0x1b29a6(%rip), %rsi    # 0x3ca166
movq %rbx, %rdi
movl $0x1cf, %edx            # imm = 0x1CF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_ppt_visitor.c
// Function: gt_ltrdigest_ppt_visitor_free
void gt_ltrdigest_ppt_visitor_free(GtNodeVisitor *nv)
{
  GT_UNUSED GtLTRdigestPPTVisitor *lv;
  if (!nv) return;
  lv = gt_ltrdigest_ppt_visitor_cast(nv);
  gt_str_delete(lv->tag);
  gt_alphabet_delete(lv->alpha);
  gt_hmm_delete(lv->hmm);
}

// Assembly:
testq %rdi, %rdi
je 0x217811
pushq %rbx
movq %rdi, %rbx
callq 0x217812
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x121b03
movq 0x28(%rbx), %rdi
callq 0xd335d
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x159bba
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_ppt_visitor.c
// Function: gt_ppt_hit_new
static GtPPTHit* gt_ppt_hit_new(GtStrand strand, GtPPTResults *r)
{
  GtPPTHit *h = gt_calloc((size_t) 1, sizeof (GtPPTHit));
  gt_assert(h);
  h->strand = strand;
  h->res = r;
  h->score = 0.0;
  return h;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1b19c2(%rip), %rdx    # 0x3ca166
movl $0x1, %edi
movl $0x38, %esi
movl $0x68, %ecx
callq 0x1093ef
testq %rax, %rax
je 0x2187d3
movl %ebp, 0x28(%rax)
movq %rbx, 0x30(%rax)
movq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x836ed
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrdigest_strand_assign_visitor.c
// Function: gt_ltrdigest_strand_assign_visitor_new
GtNodeVisitor* gt_ltrdigest_strand_assign_visitor_new()
{
  GtNodeVisitor *nv = NULL;
  GtLTRdigestStrandAssignVisitor *sav;
  nv = gt_node_visitor_create(gt_ltrdigest_strand_assign_visitor_class());
  sav = gt_ltrdigest_strand_assign_visitor_cast(nv);
  sav->strand = GT_STRAND_UNKNOWN;
  return nv;
}

// Assembly:
pushq %rbx
callq 0x21880b
movq %rax, %rdi
callq 0x16aef0
movq %rax, %rbx
callq 0x21880b
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movl $0x3, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_fasta_out_visitor.c
// Function: gt_ltrharvest_fasta_out_visitor_class
const GtNodeVisitorClass* gt_ltrharvest_fasta_out_visitor_class(void)
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtLTRharvestFastaOutVisitor),
                                   NULL,
                                   NULL,
                                   gt_ltrharvest_fasta_out_visitor_feature_node,
                                   NULL,
                                   NULL,
                                   NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x2b0faa(%rip)    # 0x4c99b8
jne 0x218a3a
movq $0x0, (%rsp)
leaq 0x29(%rip), %rcx        # 0x218a48
movl $0x30, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x2b0f7e(%rip)    # 0x4c99b8
callq 0xe6a19
movq 0x2b0f72(%rip), %rax    # 0x4c99b8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_fasta_out_visitor.c
// Function: gt_ltrharvest_fasta_out_visitor_new
GtNodeVisitor* gt_ltrharvest_fasta_out_visitor_new(const GtEncseq *encseq,
                                                   bool inner,
                                                   GtUword width,
                                                   GtFile *outfp)
{
  GtNodeVisitor *nv;
  GtLTRharvestFastaOutVisitor *lv;
  gt_assert(encseq && outfp);
  nv = gt_node_visitor_create(gt_ltrharvest_fasta_out_visitor_class());
  lv = gt_ltrharvest_fasta_out_visitor_cast(nv);
  gt_assert(lv);
  lv->inner = inner;
  lv->outfp = outfp;
  lv->width = width;
  lv->encseq = encseq;
  return nv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x218e7c
movq %rcx, %r14
testq %rcx, %rcx
je 0x218e7c
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x218a00
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r12
callq 0x218a00
movq %rax, %rdi
movq %r12, %rsi
callq 0x16af21
testq %rax, %rax
je 0x218e81
movb %bpl, 0x20(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x28(%rax)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x838e0
callq 0x83919
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_stream.c
// Function: gt_ltrharvest_stream_class
const GtNodeStreamClass* gt_ltrharvest_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtLTRharvestStream),
                                   gt_ltrharvest_stream_free,
                                   gt_ltrharvest_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x2b0b2a(%rip)    # 0x4c99c0
jne 0x218eb7
leaq 0x26(%rip), %rsi        # 0x218ec5
leaq 0xb1(%rip), %rdx        # 0x218f57
movl $0x100, %edi            # imm = 0x100
callq 0x16abb4
movq %rax, 0x2b0b09(%rip)    # 0x4c99c0
callq 0xe6a19
movq 0x2b0afd(%rip), %rax    # 0x4c99c0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_stream.c
// Function: gt_ltrharvest_stream_free
static void gt_ltrharvest_stream_free(GtNodeStream *ns)
{
  GtLTRharvestStream *ltrh_stream = gt_ltrharvest_stream_cast(ns);
  GT_FREEARRAY(&ltrh_stream->arrayLTRboundaries, LTRboundaries);
  if (ltrh_stream->ssar != NULL)
    gt_freeSequentialsuffixarrayreader(&ltrh_stream->ssar);
  if (ltrh_stream->bdptrtab != NULL)
    gt_free(ltrh_stream->bdptrtab);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x218e88
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0xc0(%rax), %rdi
testq %rdi, %rdi
je 0x218f12
leaq 0xc0(%rbx), %r14
leaq 0x1b175f(%rip), %rsi    # 0x3ca658
movl $0x666, %edx            # imm = 0x666
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
cmpq $0x0, 0xe0(%rbx)
je 0x218f2b
movq %rbx, %rdi
addq $0xe0, %rdi
callq 0x1ae1ac
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x218f4f
leaq 0x1b171a(%rip), %rsi    # 0x3ca658
movl $0x66a, %edx            # imm = 0x66A
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_stream.c
// Function: gt_ltrharvest_stream_get_encseq
const GtEncseq* gt_ltrharvest_stream_get_encseq(GtNodeStream *ltrh_stream)
{
  GtLTRharvestStream *stream;
  gt_assert(ltrh_stream != NULL);
  stream = gt_ltrharvest_stream_cast(ltrh_stream);
  return stream->encseq;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x219cb9
movq %rdi, %rbx
callq 0x218e88
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq 0xd8(%rax), %rax
popq %rbx
retq
callq 0x83a36
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_stream.c
// Function: gt_simpleexactselfmatchstore
static int gt_simpleexactselfmatchstore(void *info,
                                        const GtGenericEncseq *genericencseq,
                                        GtUword len, GtUword pos1,
                                        GtUword pos2,
                                        GT_UNUSED GtError *err)
{
  GtUword distance;
  RepeatInfo *repeatinfo = (RepeatInfo *) info;

  gt_error_check(err);
  gt_assert(pos1 < pos2);
  if (repeatinfo->ltrsearchseqrange.start > 0 ||
      repeatinfo->ltrsearchseqrange.end > 0)
  {
    if (pos1 < repeatinfo->ltrsearchseqrange.start  ||
        pos2 + len - 1 > repeatinfo->ltrsearchseqrange.end)
    {
      return 0;
    }
  }
  distance = pos2 - pos1;
  /*test maximal length of candidate pair and distance constraints*/
  if (len <= repeatinfo->lmax && repeatinfo->dmin <= distance
                              && distance <= repeatinfo->dmax)
  {
    GtUword seqnum1, seqnum2;

    gt_assert(genericencseq->hasencseq);
    seqnum1 = gt_encseq_seqnum(genericencseq->seqptr.encseq,pos1);
    seqnum2 = gt_encseq_seqnum(genericencseq->seqptr.encseq,pos2);
    if (seqnum1 == seqnum2)
    {
      Repeat *nextfreerepeatptr;

      GT_GETNEXTFREEINARRAY(nextfreerepeatptr,&repeatinfo->repeats,Repeat,32);
      nextfreerepeatptr->pos1 = pos1;
      nextfreerepeatptr->offset = distance;
      nextfreerepeatptr->len = len;
      nextfreerepeatptr->contignumber = seqnum1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
testq %r9, %r9
je 0x219f14
movq %r9, %rdi
callq 0x101a9a
testb %al, %al
jne 0x21a001
movq %rbp, %r12
subq %r14, %r12
jbe 0x219ffc
movq 0x38(%r15), %rax
testq %rax, %rax
jne 0x219f30
cmpq $0x0, 0x40(%r15)
je 0x219f4a
cmpq %r14, %rax
ja 0x219feb
leaq (%rbx,%rbp), %rax
decq %rax
cmpq 0x40(%r15), %rax
ja 0x219feb
cmpq %rbx, 0x20(%r15)
jb 0x219feb
cmpq %r12, 0x28(%r15)
ja 0x219feb
cmpq 0x30(%r15), %r12
ja 0x219feb
cmpb $0x0, (%r13)
je 0x21a006
movq 0x8(%r13), %rdi
movq %r14, %rsi
callq 0xefc48
movq 0x8(%r13), %rdi
movq %rax, %r13
movq %rbp, %rsi
callq 0xefc48
cmpq %rax, %r13
jne 0x219feb
movq 0x8(%r15), %rsi
cmpq %rsi, 0x10(%r15)
jb 0x219fc0
addq $0x20, %rsi
movq %rsi, 0x8(%r15)
movq (%r15), %rdi
shlq $0x5, %rsi
leaq 0x1b06a5(%rip), %rdx    # 0x3ca658
movl $0xdd, %ecx
callq 0x1094e6
movq %rax, (%r15)
movq (%r15), %rax
testq %rax, %rax
je 0x21a00b
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
shlq $0x5, %rcx
movq %r14, (%rax,%rcx)
movq %r12, 0x8(%rax,%rcx)
movq %rbx, 0x10(%rax,%rcx)
movq %r13, 0x18(%rax,%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x83b8c
callq 0x83b53
callq 0x83bc5
callq 0x83bfe
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_stream.c
// Function: gt_subsimpleexactselfmatchstore
static void gt_subsimpleexactselfmatchstore(void *info,
                                            const GtQuerymatch *querymatch)
{
  Repeat *nextfreerepeatptr;
  SubRepeatInfo *sri = (SubRepeatInfo *) info;

  GT_GETNEXTFREEINARRAY (nextfreerepeatptr, &sri->repeats, Repeat, 10);
  nextfreerepeatptr->pos1 = sri->offset1 + gt_querymatch_dbstart(querymatch);
  nextfreerepeatptr->offset = sri->offset2 +
                              gt_querymatch_querystart(querymatch) -
                              (sri->offset1 +
                               gt_querymatch_dbstart(querymatch));
  nextfreerepeatptr->len = gt_querymatch_querylen(querymatch);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
cmpq %rsi, 0x10(%rdi)
jb 0x21b38d
addq $0xa, %rsi
movq %rsi, 0x8(%r14)
movq (%r14), %rdi
shlq $0x5, %rsi
leaq 0x1af2d8(%rip), %rdx    # 0x3ca658
movl $0xed, %ecx
callq 0x1094e6
movq %rax, (%r14)
movq (%r14), %r12
testq %r12, %r12
je 0x21b3fd
movq 0x10(%r14), %r13
movq 0x28(%r14), %r15
leaq 0x1(%r13), %rax
movq %rax, 0x10(%r14)
shlq $0x5, %r13
movq %rbx, %rdi
callq 0x1c3985
addq %r15, %rax
movq %rax, (%r12,%r13)
movq 0x30(%r14), %rbp
movq %rbx, %rdi
callq 0x1c3998
movq %rax, %r15
movq 0x28(%r14), %r14
movq %rbx, %rdi
callq 0x1c3985
addq %rbp, %r15
addq %r14, %rax
subq %rax, %r15
movq %r15, 0x8(%r12,%r13)
movq %rbx, %rdi
callq 0x1c3980
movq %rax, 0x10(%r12,%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x83ee3
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_tabout_stream.c
// Function: gt_ltrharvest_tabout_stream_printshortheader
void gt_ltrharvest_tabout_stream_printshortheader(void)
{
  printf("# predictions are reported in the following way\n");
  printf("# s(ret) e(ret) l(ret) s(lLTR) e(lLTR) l(lLTR)"
      " s(rLTR) e(rLTR) l(rLTR) sim(LTRs) seq-nr \n");
  printf("# where:\n");
  printf("# s = starting position\n");
  printf("# e = ending position\n");
  printf("# l = length\n");
  printf("# ret = LTR-retrotransposon\n");
  printf("# lLTR = left LTR\n");
  printf("# rLTR = right LTR\n");
  printf("# sim = similarity\n");
  printf("# seq-nr = sequence number\n");
}

// Assembly:
pushq %rax
leaq 0x1af6da(%rip), %rdi    # 0x3caaeb
callq 0x17bd0
leaq 0x1af675(%rip), %rdi    # 0x3caa92
callq 0x17bd0
leaq 0x1af6f3(%rip), %rdi    # 0x3cab1c
callq 0x17bd0
leaq 0x1af6f0(%rip), %rdi    # 0x3cab25
callq 0x17bd0
leaq 0x1af6fc(%rip), %rdi    # 0x3cab3d
callq 0x17bd0
leaq 0x1af706(%rip), %rdi    # 0x3cab53
callq 0x17bd0
leaq 0x1af713(%rip), %rdi    # 0x3cab6c
callq 0x17bd0
leaq 0x1af723(%rip), %rdi    # 0x3cab88
callq 0x17bd0
leaq 0x1af729(%rip), %rdi    # 0x3cab9a
callq 0x17bd0
leaq 0x1af750(%rip), %rdi    # 0x3cabcd
callq 0x17bd0
leaq 0x1af757(%rip), %rdi    # 0x3cabe0
popq %rax
jmp 0x17bd0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_tabout_stream.c
// Function: gt_ltrharvest_tabout_stream_printlongheader
void gt_ltrharvest_tabout_stream_printlongheader(bool withtsd, bool withmotif)
{
  printf("# predictions are reported in the following way\n");
  printf("# s(ret) e(ret) l(ret) ");
  printf("s(lLTR) e(lLTR) l(lLTR)");
  if (withtsd)
  {
    printf(" TSD l(TSD)");
  }
  if (withmotif)
  {
    printf(" m(lLTR)");
  }
  printf(" s(rLTR) e(rLTR) l(rLTR)");
  if (withtsd)
  {
    printf(" TSD l(TSD)");
  }
  if (withmotif)
  {
    printf(" m(rLTR)");
  }
  printf(" sim(LTRs)");
  printf(" seq-nr");
  printf("\n# where:\n");
  printf("# s = starting position\n");
  printf("# e = ending position\n");
  printf("# l = length\n");
  if (withmotif)
  {
    printf("# m = motif\n");
  }
  printf("# ret = LTR-retrotransposon\n");
  printf("# lLTR = left LTR\n");
  printf("# rLTR = right LTR\n");
  if (withtsd)
  {
    printf("# TSD = target site duplication\n");
  }
  printf("# sim = similarity\n");
  printf("# seq-nr = sequence number\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movl %edi, %ebx
leaq 0x1af649(%rip), %rdi    # 0x3caaeb
callq 0x17bd0
leaq 0x1af56a(%rip), %rdi    # 0x3caa18
xorl %eax, %eax
callq 0x17070
leaq 0x1af574(%rip), %rdi    # 0x3caa30
xorl %eax, %eax
callq 0x17070
testl %ebx, %ebx
je 0x21b4d5
leaq 0x1af57a(%rip), %rdi    # 0x3caa48
xorl %eax, %eax
callq 0x17070
testb %bpl, %bpl
je 0x21b4e8
leaq 0x1af573(%rip), %rdi    # 0x3caa54
xorl %eax, %eax
callq 0x17070
leaq 0x1af56e(%rip), %rdi    # 0x3caa5d
xorl %eax, %eax
callq 0x17070
testb %bl, %bl
je 0x21b508
leaq 0x1af547(%rip), %rdi    # 0x3caa48
xorl %eax, %eax
callq 0x17070
testb %bpl, %bpl
je 0x21b561
leaq 0x1af562(%rip), %rdi    # 0x3caa76
xorl %eax, %eax
callq 0x17070
leaq 0x1af55d(%rip), %rdi    # 0x3caa7f
xorl %eax, %eax
callq 0x17070
leaq 0x1af55a(%rip), %rdi    # 0x3caa8a
xorl %eax, %eax
callq 0x17070
leaq 0x1af5dd(%rip), %rdi    # 0x3cab1b
callq 0x17bd0
leaq 0x1af616(%rip), %r14    # 0x3cab60
leaq 0x1af602(%rip), %r15    # 0x3cab53
leaq 0x1af5e5(%rip), %r12    # 0x3cab3d
leaq 0x1af5c6(%rip), %rdi    # 0x3cab25
jmp 0x21b599
leaq 0x1af517(%rip), %rdi    # 0x3caa7f
xorl %eax, %eax
callq 0x17070
leaq 0x1af514(%rip), %rdi    # 0x3caa8a
xorl %eax, %eax
callq 0x17070
leaq 0x1af5cf(%rip), %r14    # 0x3cab53
leaq 0x1af5b2(%rip), %r15    # 0x3cab3d
leaq 0x1af593(%rip), %r12    # 0x3cab25
leaq 0x1af582(%rip), %rdi    # 0x3cab1b
callq 0x17bd0
movq %r12, %rdi
callq 0x17bd0
movq %r15, %rdi
callq 0x17bd0
movq %r14, %rdi
callq 0x17bd0
leaq 0x1af5af(%rip), %rdi    # 0x3cab6c
callq 0x17bd0
leaq 0x1af5bf(%rip), %rdi    # 0x3cab88
callq 0x17bd0
leaq 0x1af5c5(%rip), %rdi    # 0x3cab9a
callq 0x17bd0
testb %bl, %bl
je 0x21b5ea
leaq 0x1af5c8(%rip), %rdi    # 0x3cabad
callq 0x17bd0
leaq 0x1af5dc(%rip), %rdi    # 0x3cabcd
callq 0x17bd0
leaq 0x1af5e3(%rip), %rdi    # 0x3cabe0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17bd0
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_tabout_visitor.c
// Function: gt_ltrharvest_tabout_visitor_class
const GtNodeVisitorClass* gt_ltrharvest_tabout_visitor_class(void)
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtLTRharvestTaboutVisitor),
                                    NULL,
                                    NULL,
                                    gt_ltrharvest_tabout_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x2ae3ae(%rip)    # 0x4c99c8
jne 0x21b646
movq $0x0, (%rsp)
leaq 0x29(%rip), %rcx        # 0x21b654
movl $0x20, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x2ae382(%rip)    # 0x4c99c8
callq 0xe6a19
movq 0x2ae376(%rip), %rax    # 0x4c99c8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_tabout_visitor.c
// Function: gt_ltrharvest_tabout_visitor_new
GtNodeVisitor* gt_ltrharvest_tabout_visitor_new(void)
{
  GtNodeVisitor *nv;
  GtLTRharvestTaboutVisitor *lv;
  nv = gt_node_visitor_create(gt_ltrharvest_tabout_visitor_class());
  lv = gt_ltrharvest_tabout_visitor_cast(nv);
  gt_assert(lv);
  lv->longoutput = false;
  lv->encseq = NULL;
  return nv;
}

// Assembly:
pushq %rbx
callq 0x21b60c
movq %rax, %rdi
callq 0x16aef0
movq %rax, %rbx
callq 0x21b60c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
testq %rax, %rax
je 0x21bd48
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rbx, %rax
popq %rbx
retq
callq 0x8406e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_tabout_visitor.c
// Function: gt_ltrharvest_tabout_visitor_new_longoutput
GtNodeVisitor* gt_ltrharvest_tabout_visitor_new_longoutput(const GtEncseq
                                                                        *encseq)
{
  GtNodeVisitor *nv;
  GtLTRharvestTaboutVisitor *lv;
  gt_assert(encseq);
  nv = gt_node_visitor_create(gt_ltrharvest_tabout_visitor_class());
  lv = gt_ltrharvest_tabout_visitor_cast(nv);
  gt_assert(lv);
  lv->longoutput = true;
  lv->encseq = encseq;
  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x21bd91
movq %rdi, %rbx
callq 0x21b60c
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r14
callq 0x21b60c
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
testq %rax, %rax
je 0x21bd96
movb $0x1, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x840e0
callq 0x840a7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltrharvest_tabout_visitor.c
// Function: gt_ltrharvest_tabout_visitor_seq4feat
static inline void
gt_ltrharvest_tabout_visitor_seq4feat(GtLTRharvestTaboutVisitor *nv,
                                      GtFeatureNode *fn, GtStr *out,
                                      GtUword seqnum)
{
  char *buf;
  GtRange rng;
  GtUword startpos;
  gt_assert(nv && fn && out);
  rng = gt_genome_node_get_range((GtGenomeNode*) fn);
  buf = gt_calloc((size_t) (gt_range_length(&rng)+1), sizeof (char));
  startpos = gt_encseq_seqstartpos(nv->encseq, seqnum);
  gt_encseq_extract_decoded(nv->encseq, buf,
                            startpos + rng.start - 1,
                            startpos + rng.end - 1);
  gt_str_append_cstr(out, buf);
  gt_free(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0x21be49
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x14b8df
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %r13, %rdi
callq 0x117813
leaq 0x1(%rax), %rdi
leaq 0x1aee4a(%rip), %r15    # 0x3cac2d
movl $0x1, %esi
movq %r15, %rdx
movl $0x35, %ecx
callq 0x1093ef
movq %rax, %rbp
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0xefce0
movq 0x18(%r14), %rdi
leaq -0x1(%rax), %rcx
movq (%r13), %rdx
addq %rcx, %rdx
addq 0x8(%r13), %rcx
movq %rbp, %rsi
callq 0xed87b
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x12097f
movq %rbp, %rdi
movq %r15, %rsi
movl $0x3b, %edx
callq 0x109670
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x84119
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/pdom_model_set.c
// Function: gt_pdom_model_set_delete_index
static void gt_pdom_model_set_delete_index(const char *idxname)
{
  char filename[BUFSIZ];
  gt_assert(idxname);
  (void) unlink(idxname);
  (void) snprintf(filename, BUFSIZ, "%s.h3f", idxname);
  (void) unlink(filename);
  (void) snprintf(filename, BUFSIZ, "%s.h3i", idxname);
  (void) unlink(filename);
  (void) snprintf(filename, BUFSIZ, "%s.h3m", idxname);
  (void) unlink(filename);
  (void) snprintf(filename, BUFSIZ, "%s.h3p", idxname);
  (void) unlink(filename);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
testq %rdi, %rdi
je 0x21c49c
movq %rdi, %rbx
callq 0x17320
leaq 0x1aecca(%rip), %rdx    # 0x3cb0db
movq %rsp, %r14
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17c60
movq %r14, %rdi
callq 0x17320
leaq 0x1aecad(%rip), %rdx    # 0x3cb0e2
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17c60
movq %r14, %rdi
callq 0x17320
leaq 0x1aec93(%rip), %rdx    # 0x3cb0e9
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17c60
movq %r14, %rdi
callq 0x17320
leaq 0x1aec79(%rip), %rdx    # 0x3cb0f0
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17c60
movq %r14, %rdi
callq 0x17320
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
callq 0x841be
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/mgth/metagenomethreader.c
// Function: statspair_cmp
static int statspair_cmp(const void *y, const void *z)
{
  const GtMgthStatsPair *a = (const GtMgthStatsPair*) y;
  const GtMgthStatsPair *b = (const GtMgthStatsPair*) z;
  double val_a, val_b;
  int ret;
  gt_assert(a && b && a->parsestruct && b->parsestruct);

  /* calculate result values to sort by */
  val_a = (double) (*(a->parsestruct->hits_statistics.hitsnum
                        + *(a->statpos)) /
                   ((double) a->parsestruct->hits_statistics.hitsnumber) * 100);
  val_b = (double) (*(b->parsestruct->hits_statistics.hitsnum
                        + *(b->statpos)) /
                   ((double) b->parsestruct->hits_statistics.hitsnumber) * 100);

  if ((ret = gt_double_compare(val_a, val_b) * -1) == 0) {
    /* tie breaking, we need canonical ordering!
       if two entries have the same numerical value, let strings decide */
    return strcmp(a->string, b->string);
  }
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x21d7ba
movq %rsi, %rbx
testq %rsi, %rsi
je 0x21d7ba
movq %rdi, %r14
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x21d7ba
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x21d7ba
movq 0x200(%rcx), %rdx
movq (%r14), %rsi
movq (%rsi), %rsi
movsd (%rdx,%rsi,8), %xmm1
movsd 0x1331db(%rip), %xmm2   # 0x3508e0
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1331e0(%rip), %xmm3   # 0x3508f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x210(%rcx), %xmm1
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm4
unpckhpd %xmm1, %xmm4            # xmm4 = xmm4[1],xmm1[1]
addsd %xmm1, %xmm4
divsd %xmm4, %xmm0
movsd 0x1350a9(%rip), %xmm4   # 0x3527f0
mulsd %xmm4, %xmm0
movq 0x200(%rax), %rcx
movq (%rbx), %rdx
movq (%rdx), %rdx
movsd (%rcx,%rdx,8), %xmm5
unpcklps %xmm2, %xmm5            # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm1
unpckhpd %xmm5, %xmm1            # xmm1 = xmm1[1],xmm5[1]
addsd %xmm5, %xmm1
movsd 0x210(%rax), %xmm5
unpcklps %xmm2, %xmm5            # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm2
unpckhpd %xmm5, %xmm2            # xmm2 = xmm2[1],xmm5[1]
addsd %xmm5, %xmm2
divsd %xmm2, %xmm1
mulsd %xmm4, %xmm1
callq 0x10acd4
testl %eax, %eax
je 0x21d7a6
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17a40
callq 0x842d7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/mgth/metagenomethreader.c
// Function: insert_into_outlist
static enum iterator_op
insert_into_outlist(char *key, GtUword *value, void *data,
                    GT_UNUSED GtError *err)
{
  ParseStruct *parsestruct_ptr = (ParseStruct *) data;
  gt_assert(key && parsestruct_ptr && parsestruct_ptr->outlist);
  gt_error_check(err);

  /* create new output entry and store in sorted list */
  GtMgthStatsPair *pair = gt_calloc(1, sizeof (GtMgthStatsPair));
  pair->parsestruct = parsestruct_ptr;
  pair->statpos = value;
  pair->string = key;
  gt_dlist_add(parsestruct_ptr->outlist, pair);

  return CONTINUE_ITERATION;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x21d82f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x21d82f
cmpq $0x0, 0xc0(%rbx)
je 0x21d82f
movq %rsi, %r15
movq %rdi, %r14
testq %rcx, %rcx
je 0x21d7f2
movq %rcx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x21d834
leaq 0x1ad92d(%rip), %rdx    # 0x3cb126
movl $0x1, %edi
movl $0x18, %esi
movl $0x10d, %ecx            # imm = 0x10D
callq 0x1093ef
movq %rbx, 0x10(%rax)
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq 0xc0(%rbx), %rdi
movq %rax, %rsi
callq 0xea1a1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x84349
callq 0x84310
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/mgth/mg_outputwriter.c
// Function: output_statistics_header
static void output_statistics_header(const ParseStruct *parsestruct_ptr)
{
  /* Statistik-Bereich-Header schreiben */
  if (ARGUMENTSSTRUCT(outputfile_format) == 3)
  {
    gt_file_xprintf(FILEPOINTEROUT,
                    "  <MetagenomethreaderOutput_statistics>\n");
  }
  else if (ARGUMENTSSTRUCT(outputfile_format) == 2)
  {
    gt_file_xprintf(FILEPOINTEROUT, "   <tr>\n");
    gt_file_xprintf(FILEPOINTEROUT,
                    "    <td colspan=\"2\">\n");
    gt_file_xprintf(FILEPOINTEROUT, "     <table cellspacing=\"1\" "
                                    "cellpadding=\"3\">\n");
    gt_file_xprintf(FILEPOINTEROUT, "      <tr>\n");
    gt_file_xprintf(FILEPOINTEROUT,
                    "       <td colspan=\"2\"><font class=\"font_header\">"
                    "<br><br>"
                    "Statistic-Section<br><br></font></td>\n");
    gt_file_xprintf(FILEPOINTEROUT, "      </tr>\n");
  }
  else
  {
    gt_file_xprintf(FILEPOINTEROUT, "Statistic-Section\n\n");
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x1e0(%rdi), %eax
movq 0x90(%rdi), %rdi
cmpl $0x2, %eax
je 0x21f68d
cmpl $0x3, %eax
jne 0x21f6ff
leaq 0x1ac6df(%rip), %rsi    # 0x3cbd6a
jmp 0x21f706
leaq 0x1ac746(%rip), %rsi    # 0x3cbdda
xorl %eax, %eax
callq 0x103d21
movq 0x90(%rbx), %rdi
leaq 0x1ac6ea(%rip), %rsi    # 0x3cbd93
xorl %eax, %eax
callq 0x103d21
movq 0x90(%rbx), %rdi
leaq 0x1ac6eb(%rip), %rsi    # 0x3cbda9
xorl %eax, %eax
callq 0x103d21
movq 0x90(%rbx), %rdi
leaq 0x1ac704(%rip), %rsi    # 0x3cbdd7
xorl %eax, %eax
callq 0x103d21
movq 0x90(%rbx), %rdi
leaq 0x1ac6fb(%rip), %rsi    # 0x3cbde3
xorl %eax, %eax
callq 0x103d21
movq 0x90(%rbx), %rdi
leaq 0x1ac746(%rip), %rsi    # 0x3cbe43
jmp 0x21f706
leaq 0x1ac74a(%rip), %rsi    # 0x3cbe50
xorl %eax, %eax
popq %rbx
jmp 0x103d21
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/mgth/mg_outputwriter.c
// Function: newmemory_hash
static enum iterator_op
newmemory_hash(GT_UNUSED char *key, GtUword *value, void *data,
               GT_UNUSED GtError * err)
{
  /* Parsestruct-Struktur */
  ParseStruct *parsestruct_ptr = (ParseStruct *) data;

  /* Position des aktuell betrachteten Schluessels */
  HITSTRUCT(stat_pos) = *value;

  gt_error_check(err);

  gt_array_add(parsestruct_ptr->value_tmp, HITSTRUCT(stat_pos));

  return 0;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq (%rsi), %rax
movq %rax, 0x218(%rdx)
testq %rcx, %rcx
je 0x21f98c
movq %rcx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x21f9a8
movq 0x78(%rbx), %rdi
addq $0x218, %rbx            # imm = 0x218
movl $0x8, %edx
movq %rbx, %rsi
callq 0xd49ce
xorl %eax, %eax
popq %rbx
retq
callq 0x8462e