LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x19da24(%rip), %rdx    # 0x360ed6
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
pushq $0x68
popq %rcx
callq 0x9334a
testq %rax, %rax
je 0x1c34d8
movl %ebp, 0x28(%rax)
movq %rbx, 0x30(%rax)
andq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x274a89(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x121b2a(%rip), %rsi    # 0x2e5013
leaq 0x189520(%rip), %rdx    # 0x34ca10
leaq 0x19db63(%rip), %rcx    # 0x36105a
leaq 0x19d9d8(%rip), %r8     # 0x360ed6
pushq $0x69
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/ltr/ltrdigest_strand_assign_visitor.c
// Function: gt_ltrdigest_strand_assign_visitor_class
const GtNodeVisitorClass* gt_ltrdigest_strand_assign_visitor_class(void)
{
  static const GtNodeVisitorClass *nvc = NULL;
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtLTRdigestStrandAssignVisitor),
                                NULL,
                                NULL,
                                gt_ltrdigest_strand_assign_visitor_feature_node,
                                NULL,
                                NULL,
                                NULL);
  }
  return nvc;
}

// Assembly:
movq 0x27a3e2(%rip), %rax    # 0x43d960
testq %rax, %rax
je 0x1c3584
retq
pushq %rax
andq $0x0, (%rsp)
leaq 0x1e(%rip), %rcx        # 0x1c35af
pushq $0x18
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x27a3b6(%rip)    # 0x43d960
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c3577
movq %rax, %rdi
callq 0x102da0
movq %rax, %rbx
callq 0x1c3577
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
movl $0x3, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x27a1b2(%rip)    # 0x43d968
jne 0x1c37dd
andq $0x0, (%rsp)
leaq 0x27(%rip), %rcx        # 0x1c37eb
pushq $0x30
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x27a18b(%rip)    # 0x43d968
callq 0x69ede
movq 0x27a17f(%rip), %rax    # 0x43d968
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c3ce8
movq %rcx, %r14
testq %rcx, %rcx
je 0x1c3ce8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x1c37a8
movq %rax, %rdi
callq 0x102da0
movq %rax, %r12
callq 0x1c37a8
movq %rax, %rdi
movq %r12, %rsi
callq 0x102dfe
testq %rax, %rax
je 0x1c3d16
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
movq 0x274279(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x12131a(%rip), %rsi    # 0x2e5013
leaq 0x19d4a6(%rip), %rdx    # 0x3611a6
leaq 0x19d4af(%rip), %rcx    # 0x3611b6
leaq 0x19d4cc(%rip), %r8     # 0x3611da
movl $0xc0, %r9d
jmp 0x1c3d42
movq 0x27424b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1212ec(%rip), %rsi    # 0x2e5013
leaq 0x19c613(%rip), %rdx    # 0x360341
leaq 0x19d481(%rip), %rcx    # 0x3611b6
leaq 0x19d49e(%rip), %r8     # 0x3611da
movl $0xc3, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x279c12(%rip)    # 0x43d970
jne 0x1c3d7f
leaq 0x26(%rip), %rsi        # 0x1c3d8d
leaq 0xae(%rip), %rdx        # 0x1c3e1c
movl $0x100, %edi            # imm = 0x100
callq 0x102838
movq %rax, 0x279bf1(%rip)    # 0x43d970
callq 0x69ede
movq 0x279be5(%rip), %rax    # 0x43d970
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c3d50
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0xc0(%rax), %rdi
testq %rdi, %rdi
je 0x1c3dd7
leaq 0xc0(%rbx), %r14
leaq 0x19d5e3(%rip), %rsi    # 0x3613a4
movl $0x666, %edx            # imm = 0x666
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
cmpq $0x0, 0xe0(%rbx)
je 0x1c3df0
movq %rbx, %rdi
addq $0xe0, %rdi
callq 0x1517e5
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x1c3e14
leaq 0x19d5a1(%rip), %rsi    # 0x3613a4
movl $0x66a, %edx            # imm = 0x66A
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c4ad5
movq %rdi, %rbx
callq 0x1c3d50
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq 0xd8(%rax), %rax
popq %rbx
retq
movq 0x27348c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x12052d(%rip), %rsi    # 0x2e5013
leaq 0x19c883(%rip), %rdx    # 0x361370
leaq 0x19c890(%rip), %rcx    # 0x361384
leaq 0x19c8a9(%rip), %r8     # 0x3613a4
movl $0x67d, %r9d            # imm = 0x67D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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)
jae 0x1c6298
movq (%r14), %r15
jmp 0x1c62be
addq $0xa, %rsi
movq %rsi, 0x8(%r14)
movq (%r14), %rdi
shlq $0x5, %rsi
leaq 0x19b0f6(%rip), %rdx    # 0x3613a4
movl $0xed, %ecx
callq 0x93472
movq %rax, %r15
movq %rax, (%r14)
testq %r15, %r15
je 0x1c632b
movq 0x10(%r14), %r13
movq 0x28(%r14), %r12
leaq 0x1(%r13), %rax
movq %rax, 0x10(%r14)
shlq $0x5, %r13
movq %rbx, %rdi
callq 0x16a061
addq %r12, %rax
movq %rax, (%r15,%r13)
movq 0x30(%r14), %rbp
movq %rbx, %rdi
callq 0x16a074
movq %rax, %r12
movq 0x28(%r14), %r14
movq %rbx, %rdi
callq 0x16a061
addq %rbp, %r12
addq %r14, %rax
subq %rax, %r12
movq %r12, 0x8(%r15,%r13)
movq %rbx, %rdi
callq 0x16a05c
movq %rax, 0x10(%r15,%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x271c36(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11ecd7(%rip), %rsi    # 0x2e5013
leaq 0x19b320(%rip), %rdx    # 0x361663
leaq 0x19b2f9(%rip), %rcx    # 0x361643
leaq 0x19b053(%rip), %r8     # 0x3613a4
movl $0xed, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x19b45e(%rip), %rdi    # 0x3617cf
callq 0x17b60
leaq 0x19b3f9(%rip), %rdi    # 0x361776
callq 0x17b60
leaq 0x19b477(%rip), %rdi    # 0x361800
callq 0x17b60
leaq 0x19b474(%rip), %rdi    # 0x361809
callq 0x17b60
leaq 0x19b480(%rip), %rdi    # 0x361821
callq 0x17b60
leaq 0x19b48a(%rip), %rdi    # 0x361837
callq 0x17b60
leaq 0x19b497(%rip), %rdi    # 0x361850
callq 0x17b60
leaq 0x19b4a7(%rip), %rdi    # 0x36186c
callq 0x17b60
leaq 0x19b4ad(%rip), %rdi    # 0x36187e
callq 0x17b60
leaq 0x19b4d4(%rip), %rdi    # 0x3618b1
callq 0x17b60
leaq 0x19b4db(%rip), %rdi    # 0x3618c4
popq %rax
jmp 0x17b60
// File: /workspace/github_c_makefile_star2_O2/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 0x19b3cd(%rip), %rdi    # 0x3617cf
callq 0x17b60
leaq 0x19b2ee(%rip), %rdi    # 0x3616fc
xorl %eax, %eax
callq 0x17070
leaq 0x19b2f8(%rip), %rdi    # 0x361714
xorl %eax, %eax
callq 0x17070
testl %ebx, %ebx
je 0x1c6435
leaq 0x19b2fe(%rip), %rdi    # 0x36172c
xorl %eax, %eax
callq 0x17070
testb %bpl, %bpl
je 0x1c6448
leaq 0x19b2f7(%rip), %rdi    # 0x361738
xorl %eax, %eax
callq 0x17070
leaq 0x19b2f2(%rip), %rdi    # 0x361741
xorl %eax, %eax
callq 0x17070
testb %bl, %bl
je 0x1c6468
leaq 0x19b2cb(%rip), %rdi    # 0x36172c
xorl %eax, %eax
callq 0x17070
testb %bpl, %bpl
je 0x1c64c1
leaq 0x19b2e6(%rip), %rdi    # 0x36175a
xorl %eax, %eax
callq 0x17070
leaq 0x19b2e1(%rip), %rdi    # 0x361763
xorl %eax, %eax
callq 0x17070
leaq 0x19b2de(%rip), %rdi    # 0x36176e
xorl %eax, %eax
callq 0x17070
leaq 0x19b361(%rip), %rdi    # 0x3617ff
callq 0x17b60
leaq 0x19b39a(%rip), %r14    # 0x361844
leaq 0x19b386(%rip), %r15    # 0x361837
leaq 0x19b369(%rip), %r12    # 0x361821
leaq 0x19b34a(%rip), %rdi    # 0x361809
jmp 0x1c64f9
leaq 0x19b29b(%rip), %rdi    # 0x361763
xorl %eax, %eax
callq 0x17070
leaq 0x19b298(%rip), %rdi    # 0x36176e
xorl %eax, %eax
callq 0x17070
leaq 0x19b353(%rip), %r14    # 0x361837
leaq 0x19b336(%rip), %r15    # 0x361821
leaq 0x19b317(%rip), %r12    # 0x361809
leaq 0x19b306(%rip), %rdi    # 0x3617ff
callq 0x17b60
movq %r12, %rdi
callq 0x17b60
movq %r15, %rdi
callq 0x17b60
movq %r14, %rdi
callq 0x17b60
leaq 0x19b333(%rip), %rdi    # 0x361850
callq 0x17b60
leaq 0x19b343(%rip), %rdi    # 0x36186c
callq 0x17b60
leaq 0x19b349(%rip), %rdi    # 0x36187e
callq 0x17b60
testb %bl, %bl
je 0x1c654a
leaq 0x19b34c(%rip), %rdi    # 0x361891
callq 0x17b60
leaq 0x19b360(%rip), %rdi    # 0x3618b1
callq 0x17b60
leaq 0x19b367(%rip), %rdi    # 0x3618c4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17b60
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x2773fe(%rip)    # 0x43d978
jne 0x1c65a1
andq $0x0, (%rsp)
leaq 0x27(%rip), %rcx        # 0x1c65af
pushq $0x20
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x2773d7(%rip)    # 0x43d978
callq 0x69ede
movq 0x2773cb(%rip), %rax    # 0x43d978
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c656c
movq %rax, %rdi
callq 0x102da0
movq %rax, %rbx
callq 0x1c656c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
testq %rax, %rax
je 0x1c6d62
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq %rbx, %rax
popq %rbx
retq
movq 0x2711ff(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11e2a0(%rip), %rsi    # 0x2e5013
leaq 0x1995c7(%rip), %rdx    # 0x360341
leaq 0x19ab6f(%rip), %rcx    # 0x3618f0
leaq 0x19ab89(%rip), %r8     # 0x361911
movl $0x116, %r9d            # imm = 0x116
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1c6dde
movq %rdi, %rbx
callq 0x1c656c
movq %rax, %rdi
callq 0x102da0
movq %rax, %r14
callq 0x1c656c
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
testq %rax, %rax
je 0x1c6e0c
movb $0x1, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x271183(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11e224(%rip), %rsi    # 0x2e5013
leaq 0x1607fc(%rip), %rdx    # 0x3275f2
leaq 0x19ab38(%rip), %rcx    # 0x361935
leaq 0x19ab0d(%rip), %r8     # 0x361911
movl $0x121, %r9d            # imm = 0x121
jmp 0x1c6e38
movq 0x271155(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11e1f6(%rip), %rsi    # 0x2e5013
leaq 0x19951d(%rip), %rdx    # 0x360341
leaq 0x19ab0a(%rip), %rcx    # 0x361935
leaq 0x19aadf(%rip), %r8     # 0x361911
movl $0x124, %r9d            # imm = 0x124
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1c6eec
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0xdd1f4
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %r13, %rdi
callq 0xa31ee
leaq 0x1(%rax), %rdi
leaq 0x19aa85(%rip), %r14    # 0x361911
pushq $0x1
popq %rsi
pushq $0x35
popq %rcx
movq %r14, %rdx
callq 0x9334a
movq %rax, %rbp
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0x74d9c
movq 0x18(%r15), %rdi
leaq -0x1(%rax), %rcx
movq (%r13), %rdx
addq %rcx, %rdx
addq 0x8(%r13), %rcx
movq %rbp, %rsi
callq 0x7239d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xacbfb
pushq $0x3b
popq %rdx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x936f9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x271075(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11e116(%rip), %rsi    # 0x2e5013
leaq 0x19ab92(%rip), %rdx    # 0x361a96
leaq 0x19ab9b(%rip), %rcx    # 0x361aa6
leaq 0x19a9ff(%rip), %r8     # 0x361911
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1c750c
movq %rdi, %rbx
callq 0x17300
leaq 0x19a93e(%rip), %rdx    # 0x361dbf
movq %rsp, %r14
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17bf0
movq %r14, %rdi
callq 0x17300
leaq 0x19a921(%rip), %rdx    # 0x361dc6
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17bf0
movq %r14, %rdi
callq 0x17300
leaq 0x19a907(%rip), %rdx    # 0x361dcd
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17bf0
movq %r14, %rdi
callq 0x17300
leaq 0x19a8ed(%rip), %rdx    # 0x361dd4
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17bf0
movq %r14, %rdi
callq 0x17300
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
movq 0x270a55(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11daf6(%rip), %rsi    # 0x2e5013
leaq 0x19a874(%rip), %rdx    # 0x361d98
leaq 0x19a875(%rip), %rcx    # 0x361da0
leaq 0x19a5b9(%rip), %r8     # 0x361aeb
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1c874e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c874e
movq %rdi, %r14
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x1c874e
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1c874e
movq 0x200(%rcx), %rdx
movq (%r14), %rsi
movq (%rsi), %rsi
movsd (%rdx,%rsi,8), %xmm1
movsd 0x11f247(%rip), %xmm2   # 0x2e78e0
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x11f24c(%rip), %xmm3   # 0x2e78f0
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 0x121105(%rip), %xmm4   # 0x2e97e0
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 0x955a7
testl %eax, %eax
je 0x1c873a
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 0x179e0
movq 0x26f813(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11c8b4(%rip), %rsi    # 0x2e5013
leaq 0x199b59(%rip), %rdx    # 0x3622bf
leaq 0x199b7d(%rip), %rcx    # 0x3622ea
leaq 0x19969a(%rip), %r8     # 0x361e0e
movl $0xf2, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1c87f2
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1c87f2
cmpq $0x0, 0xc0(%rbx)
je 0x1c87f2
movq %rsi, %r15
movq %rdi, %r14
testq %rcx, %rcx
je 0x1c87b9
movq %rcx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1c8820
leaq 0x19964e(%rip), %rdx    # 0x361e0e
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
movl $0x10d, %ecx            # imm = 0x10D
callq 0x9334a
movq %rbx, 0x10(%rax)
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq 0xc0(%rbx), %rdi
movq %rax, %rsi
callq 0x6e34e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x26f76f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11c810(%rip), %rsi    # 0x2e5013
leaq 0x199aee(%rip), %rdx    # 0x3622f8
leaq 0x199b1a(%rip), %rcx    # 0x36232b
leaq 0x1995f6(%rip), %r8     # 0x361e0e
movl $0x109, %r9d            # imm = 0x109
jmp 0x1c884c
movq 0x26f741(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11c7e2(%rip), %rsi    # 0x2e5013
leaq 0x11c987(%rip), %rdx    # 0x2e51bf
leaq 0x199aec(%rip), %rcx    # 0x36232b
leaq 0x1995c8(%rip), %r8     # 0x361e0e
movl $0x10a, %r9d            # imm = 0x10A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1ca780
cmpl $0x3, %eax
jne 0x1ca7f2
leaq 0x1982d4(%rip), %rsi    # 0x362a52
jmp 0x1ca7f9
leaq 0x19833b(%rip), %rsi    # 0x362ac2
xorl %eax, %eax
callq 0x8d432
movq 0x90(%rbx), %rdi
leaq 0x1982df(%rip), %rsi    # 0x362a7b
xorl %eax, %eax
callq 0x8d432
movq 0x90(%rbx), %rdi
leaq 0x1982e0(%rip), %rsi    # 0x362a91
xorl %eax, %eax
callq 0x8d432
movq 0x90(%rbx), %rdi
leaq 0x1982f9(%rip), %rsi    # 0x362abf
xorl %eax, %eax
callq 0x8d432
movq 0x90(%rbx), %rdi
leaq 0x1982f0(%rip), %rsi    # 0x362acb
xorl %eax, %eax
callq 0x8d432
movq 0x90(%rbx), %rdi
leaq 0x19833b(%rip), %rsi    # 0x362b2b
jmp 0x1ca7f9
leaq 0x19833f(%rip), %rsi    # 0x362b38
xorl %eax, %eax
popq %rbx
jmp 0x8d432
// File: /workspace/github_c_makefile_star2_O2/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 0x1caa9b
movq %rcx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1caab5
movq 0x78(%rbx), %rdi
addq $0x218, %rbx            # imm = 0x218
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x5851d
xorl %eax, %eax
popq %rbx
retq
movq 0x26d4ac(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x11a54d(%rip), %rsi    # 0x2e5013
leaq 0x11a6f2(%rip), %rdx    # 0x2e51bf
leaq 0x197d9c(%rip), %rcx    # 0x362870
leaq 0x1978c5(%rip), %r8     # 0x3623a0
movl $0x554, %r9d            # imm = 0x554
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/mgth/mg_outputwriter.c
// Function: check_startcodon
static short check_startcodon(const ParseStruct *parsestruct_ptr,
                              const char *contig_seq_ptrfct)
{
  unsigned short codon_status = 0;

  /* jeder if-Zweig ueberprueft entsprechend des
     Metagenomethreader-Arguments zur Verwendung alternativer Start-Codons
     auf Start-Codons */
  if (ARGUMENTSSTRUCT(codon_mode) == 2)
  {
    if (!strcmp(contig_seq_ptrfct, "atg")
        || !strcmp(contig_seq_ptrfct, "ctg")
        || !strcmp(contig_seq_ptrfct, "gtg")
        || !strcmp(contig_seq_ptrfct, "aug")
        || !strcmp(contig_seq_ptrfct, "cug")
        || !strcmp(contig_seq_ptrfct, "gug"))
    {
      codon_status = 1;
    }
  }
  else if (ARGUMENTSSTRUCT(codon_mode) == 3)
  {
    if (!strcmp(contig_seq_ptrfct, "atg")
        || !strcmp(contig_seq_ptrfct, "ctg")
        || !strcmp(contig_seq_ptrfct, "gtg")
        || !strcmp(contig_seq_ptrfct, "ttg")
        || !strcmp(contig_seq_ptrfct, "aug")
        || !strcmp(contig_seq_ptrfct, "cug")
        || !strcmp(contig_seq_ptrfct, "gug")
        || !strcmp(contig_seq_ptrfct, "uug"))
    {
      codon_status = 1;
    }
  }
  else
  {
    if (!strcmp(contig_seq_ptrfct, "atg")
        || !strcmp(contig_seq_ptrfct, "aug"))
    {
      codon_status = 1;
    }
  }

  return codon_status;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x1e4(%rdi), %ebp
leaq 0x13736b(%rip), %rsi    # 0x3021c6
movq %rbx, %rdi
callq 0x179e0
cmpl $0x3, %ebp
je 0x1caee1
cmpl $0x2, %ebp
jne 0x1caf68
testl %eax, %eax
je 0x1caf83
leaq 0x1ba51a(%rip), %rsi    # 0x38539a
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x1ba572(%rip), %rsi    # 0x385409
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x1977e8(%rip), %rsi    # 0x362696
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x1977d5(%rip), %rsi    # 0x36269a
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x1977c2(%rip), %rsi    # 0x36269e
jmp 0x1caf73
testl %eax, %eax
je 0x1caf83
leaq 0x1ba4aa(%rip), %rsi    # 0x38539a
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x1ba502(%rip), %rsi    # 0x385409
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x197788(%rip), %rsi    # 0x3626a2
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x197769(%rip), %rsi    # 0x362696
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x19775a(%rip), %rsi    # 0x36269a
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x19774b(%rip), %rsi    # 0x36269e
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
leaq 0x197740(%rip), %rsi    # 0x3626a6
jmp 0x1caf73
testl %eax, %eax
je 0x1caf83
leaq 0x197723(%rip), %rsi    # 0x362696
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x1caf83
xorl %eax, %eax
jmp 0x1caf87
movw $0x1, %ax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/mgth/mg_reverse.c
// Function: mg_reverse_complement
int mg_reverse_complement(char *dna_seq, GtUword seqlen, GtError * err)
{
  char *front_char,
   *back_char,
    tmp_char;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(dna_seq);

  for (front_char = dna_seq, back_char = dna_seq + seqlen - 1;
       front_char <= back_char; front_char++, back_char--)
  {
    had_err = mg_complement(&tmp_char, *front_char, err);
    if (!had_err)
      had_err = mg_complement(front_char, *back_char, err);
    if (!had_err)
      *back_char = tmp_char;
    if (had_err)
      break;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x1cafba
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1cb049
testq %r14, %r14
je 0x1cb01b
leaq (%r15,%r14), %r12
decq %r12
leaq 0xf(%rsp), %r15
pushq $-0x1
popq %rbp
cmpq %r12, %r14
ja 0x1cb00a
movsbl (%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1cb081
testl %eax, %eax
jne 0x1cb00c
movsbl (%r12), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1cb081
testl %eax, %eax
jne 0x1cb00c
movb 0xf(%rsp), %al
movb %al, (%r12)
incq %r14
decq %r12
jmp 0x1cafce
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x26cf46(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x119fe7(%rip), %rsi    # 0x2e5013
leaq 0x16586c(%rip), %rdx    # 0x33089f
leaq 0x198dfe(%rip), %rcx    # 0x363e38
leaq 0x198e0d(%rip), %r8     # 0x363e4e
movl $0x92, %r9d
jmp 0x1cb075
movq 0x26cf18(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x119fb9(%rip), %rsi    # 0x2e5013
leaq 0x11a15e(%rip), %rdx    # 0x2e51bf
leaq 0x198dd0(%rip), %rcx    # 0x363e38
leaq 0x198ddf(%rip), %r8     # 0x363e4e
movl $0x91, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/mgth/mg_xmlparser.c
// Function: startElement
static void XMLCALL startElement(void *data, const char *name,
                                 GT_UNUSED const char **atts)
{
  ParseStruct *parsestruct_ptr = (ParseStruct *) data;

  if (!PARSESTRUCT(had_err))
  {
    /* Vergleich des aktuellen XML-Tags mit dem aktuellen Tag-Namen im
       jew. GtArray bei Uebereinstimmung wird das jeweilige Flag gesetzt */
    if (strcmp
        (name,
         gt_str_array_get(PARSESTRUCT(query_array),
                      XMLPARSERSTRUCT(query_array_index_start))) == 0)
    {
      flag_setting(&XMLPARSERSTRUCT(query_array_index_start),
                   &PARSESTRUCT(def_flag), 'q');
    }
    else
      if (strcmp
          (name,
           gt_str_array_get(PARSESTRUCT(hit_array),
                        XMLPARSERSTRUCT(hit_array_index_start))) == 0)
    {
      flag_setting(&XMLPARSERSTRUCT(hit_array_index_start),
                   &PARSESTRUCT(hit_flag), 'h');
    }
    else
      if (strcmp
          (name,
           gt_str_array_get(PARSESTRUCT(hit_hsp_array),
                        XMLPARSERSTRUCT(hit_hsp_array_index_start))) == 0)
    {
      flag_setting(&XMLPARSERSTRUCT(hit_hsp_array_index_start),
                   &PARSESTRUCT(hit_hsp_flag), 't');
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0xd0(%rdi)
je 0x1cb456
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movzwl 0x220(%rbx), %esi
callq 0xae386
movq %r14, %rdi
movq %rax, %rsi
callq 0x179e0
testl %eax, %eax
je 0x1cb4ca
movq 0x8(%rbx), %rdi
movzwl 0x222(%rbx), %esi
callq 0xae386
movq %r14, %rdi
movq %rax, %rsi
callq 0x179e0
testl %eax, %eax
je 0x1cb4dc
movq 0x10(%rbx), %rdi
movzwl 0x224(%rbx), %esi
callq 0xae386
movq %r14, %rdi
movq %rax, %rsi
callq 0x179e0
testl %eax, %eax
jne 0x1cb44e
leaq 0x224(%rbx), %rdi
addq $0xd8, %rbx
pushq $0x74
jmp 0x1cb4ec
leaq 0x220(%rbx), %rdi
addq $0xd4, %rbx
pushq $0x71
jmp 0x1cb4ec
leaq 0x222(%rbx), %rdi
addq $0xd6, %rbx
pushq $0x68
popq %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1cc178
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/gt_sketch.c
// Function: gt_sketch_arguments_new
static void* gt_sketch_arguments_new(void)
{
  GtSketchArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->seqid = gt_str_new();
  arguments->format = gt_str_new();
  arguments->input = gt_str_new();
  arguments->stylefile = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x19310f(%rip), %rdx    # 0x365327
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
pushq $0x43
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/gt_sketch.c
// Function: gt_sketch_arguments_delete
static void gt_sketch_arguments_delete(void *tool_arguments)
{
  GtSketchArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->seqid);
  gt_str_delete(arguments->format);
  gt_str_delete(arguments->input);
  gt_str_delete(arguments->stylefile);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x1d2292
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
leaq 0x1930a1(%rip), %rsi    # 0x365327
pushq $0x53
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/gt_sketch.c
// Function: gt_sketch_arguments_check
static int gt_sketch_arguments_check(GT_UNUSED int rest_argc,
                                     void *tool_arguments,
                                     GT_UNUSED GtError *err)
{
  GtSketchArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (arguments->start != GT_UNDEF_UWORD &&
      arguments->end != GT_UNDEF_UWORD &&
      !(arguments->start < arguments->end)) {
    gt_error_set(err, "start of query range ("GT_WU") must be before "
                      "end of query range ("GT_WU")",
                      arguments->start, arguments->end);
    had_err = -1;
  }

  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0x1d25b6
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1d261a
testq %r14, %r14
je 0x1d25ec
movq 0x28(%r14), %rdx
xorl %eax, %eax
cmpq $-0x1, %rdx
je 0x1d25e4
movq 0x30(%r14), %rcx
cmpq %rcx, %rdx
jb 0x1d25e4
leaq 0x193049(%rip), %rsi    # 0x365620
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x265975(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x112a16(%rip), %rsi    # 0x2e5013
leaq 0x17604f(%rip), %rdx    # 0x348653
leaq 0x192ffb(%rip), %rcx    # 0x365606
leaq 0x192d15(%rip), %r8     # 0x365327
movl $0xe5, %r9d
jmp 0x1d2646
movq 0x265947(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1129e8(%rip), %rsi    # 0x2e5013
leaq 0x112b8d(%rip), %rdx    # 0x2e51bf
leaq 0x192fcd(%rip), %rcx    # 0x365606
leaq 0x192ce7(%rip), %r8     # 0x365327
movl $0xe4, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/gt_sketch_page.c
// Function: gt_sketch_page_arguments_new
static void *gt_sketch_page_arguments_new(void)
{
  SketchPageArguments *arguments = gt_malloc(sizeof *arguments);
  arguments->format = gt_str_new();
  arguments->seqid = gt_str_new();
  arguments->text = gt_str_new();
  arguments->stylefile = gt_str_new();
  arguments->seqfile = gt_str_new();
  arguments->range.start = arguments->range.end == GT_UNDEF_UWORD;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x192895(%rip), %rsi    # 0x365778
pushq $0x58
popq %rdi
pushq $0x41
popq %rdx
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x38(%rbx)
callq 0xacb84
movq %rax, 0x30(%rbx)
callq 0xacb84
movq %rax, 0x48(%rbx)
callq 0xacb84
movq %rax, 0x40(%rbx)
callq 0xacb84
movq %rax, 0x50(%rbx)
xorl %eax, %eax
cmpq $-0x1, 0x28(%rbx)
sete %al
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/gt_sketch_page.c
// Function: gt_sketch_page_arguments_delete
static void gt_sketch_page_arguments_delete(void *tool_arguments)
{
  SketchPageArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->seqid);
  gt_str_delete(arguments->format);
  gt_str_delete(arguments->text);
  gt_str_delete(arguments->stylefile);
  gt_str_delete(arguments->seqfile);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x1d2f7a
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
movq 0x48(%rbx), %rdi
callq 0xae103
movq 0x40(%rbx), %rdi
callq 0xae103
movq 0x50(%rbx), %rdi
callq 0xae103
leaq 0x19280a(%rip), %rsi    # 0x365778
pushq $0x54
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/md5-1.2/src/md5lib.c
// Function: luaopen_md5_core
int luaopen_md5_core (lua_State *L) {
  lua_newtable(L);
  luaL_setfuncs(L, md5lib, 0);
  set_info (L);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x1dc7bd
leaq 0x24a94e(%rip), %rsi    # 0x439d10
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1efc24
leaq 0x17a0a1(%rip), %rsi    # 0x369474
pushq $0xa
popq %rdx
movq %rbx, %rdi
callq 0x1dbe62
leaq 0x17a09a(%rip), %rsi    # 0x36947f
pushq $0x1f
popq %rdx
movq %rbx, %rdi
callq 0x1dbe62
pushq $-0x3
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1dc936
leaq 0x17a09b(%rip), %rsi    # 0x36949f
pushq $0xc
popq %rdx
movq %rbx, %rdi
callq 0x1dbe62
leaq 0x17a096(%rip), %rsi    # 0x3694ac
pushq $0x1e
popq %rdx
movq %rbx, %rdi
callq 0x1dbe62
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1dc936
leaq 0x179408(%rip), %rsi    # 0x36883a
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x1dbe62
leaq 0x17a087(%rip), %rsi    # 0x3694cb
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x1dbe62
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1dc936
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/md5-1.2/src/md5lib.c
// Function: lmd5
static int lmd5 (lua_State *L) {
  char buff[16];
  size_t l;
  const char *message = luaL_checklstring(L, 1, &l);
  md5(message, l, buff);
  lua_pushlstring(L, buff, 16L);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r14
movl %ebp, %esi
movq %r14, %rdx
callq 0x1de9c6
movq (%r14), %rsi
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x1eef58
pushq $0x10
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1dbe62
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/md5-1.2/src/md5lib.c
// Function: ex_or
static int ex_or (lua_State *L) {
  size_t l1, l2;
  const char *s1 = luaL_checklstring(L, 1, &l1);
  const char *s2 = luaL_checklstring(L, 2, &l2);
  luaL_Buffer b;
  luaL_argcheck( L, l1 == l2, 2, "lengths must be equal" );
  luaL_buffinit(L, &b);
  while (l1--) luaL_addchar(&b, (*s1++)^(*s2++));
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, %r12
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1de9c6
movq %rax, %rbx
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x1de9c6
movq %rax, %r14
movq (%r15), %rax
cmpq (%r13), %rax
je 0x1ef503
leaq 0x179f25(%rip), %rdx    # 0x36941d
pushq $0x2
popq %rsi
movq %r12, %rdi
callq 0x1de6f4
leaq 0x18(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1defee
leaq 0x2030(%rsp), %r12
xorl %r13d, %r13d
subq $0x1, 0x8(%rsp)
jb 0x1ef555
movq 0x18(%rsp), %rax
cmpq %r12, %rax
jb 0x1ef53d
movq %r15, %rdi
callq 0x1df093
movq 0x18(%rsp), %rax
movb (%r14,%r13), %cl
xorb (%rbx,%r13), %cl
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rsp)
movb %cl, (%rax)
incq %r13
jmp 0x1ef51e
leaq 0x18(%rsp), %rdi
callq 0x1df075
pushq $0x1
popq %rax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/md5-1.2/src/md5lib.c
// Function: crypt
static int crypt (lua_State *L) {
  size_t lmsg;
  const char *msg = luaL_checklstring(L, 1, &lmsg);
  size_t lseed;
  const char *seed;
  int lblock;
  char block[BLOCKSIZE+MAXKEY];
  checkseed(L);
  seed = luaL_checklstring(L, 3, &lseed);
  if (lseed > BLOCKSIZE)
    luaL_error(L, "seed too long (> %d)", BLOCKSIZE);
  /* put seed and seed length at the beginning of result */
  block[0] = (char)lseed;
  memcpy(block+1, seed, lseed);
  lua_pushlstring(L, block, lseed+1);  /* to concat with result */
  lblock = initblock(L, seed, lseed, block);
  codestream(L, msg, lmsg, block, lblock);
  lua_concat(L, 2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2158, %rsp           # imm = 0x2158
movq %rdi, %r15
pushq $0x1
popq %rsi
leaq 0x18(%rsp), %rdx
callq 0x1de9c6
movq %rax, %r14
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x1db731
cmpl $-0x1, %eax
jne 0x1ef5c4
xorl %edi, %edi
callq 0x17710
leaq 0x140(%rsp), %rsi
movq %rax, (%rsi)
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x1dbe62
pushq $0x3
popq %rsi
leaq 0x8(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1de9c6
movq %rax, %r12
movq (%rbx), %rbx
cmpq $0x11, %rbx
jb 0x1ef5fc
leaq 0x179e49(%rip), %rsi    # 0x369433
pushq $0x10
popq %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1de79c
movq 0x8(%rsp), %rbx
leaq 0x31(%rsp), %rdi
movb %bl, -0x1(%rdi)
movq %r12, %rsi
movq %rbx, %rdx
callq 0x17630
incq %rbx
leaq 0x30(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1dbe62
movl 0x8(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x1ef818
movl %eax, %ebx
movq 0x18(%rsp), %r12
leaq 0x140(%rsp), %rsi
movq %r15, 0x10(%rsp)
movq %r15, %rdi
callq 0x1defee
movslq %ebx, %r13
leaq 0x20(%rsp), %rbp
testq %r12, %r12
je 0x1ef6bc
leaq 0x30(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1eef58
cmpq $0x10, %r12
pushq $0x10
popq %rbx
cmovbq %r12, %rbx
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x1ef691
movb (%r14,%r15), %al
xorb %al, 0x20(%rsp,%r15)
incq %r15
jmp 0x1ef67e
subq %rbx, %r12
leaq 0x140(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1deffe
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x17630
addq %r15, %r14
jmp 0x1ef65b
leaq 0x140(%rsp), %rdi
callq 0x1df075
pushq $0x2
popq %rsi
movq 0x10(%rsp), %rdi
callq 0x1dd50a
pushq $0x1
popq %rax
addq $0x2158, %rsp           # imm = 0x2158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq