LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x210224
movq %rdi, %rbx
callq 0x20f4a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq 0xd8(%rax), %rax
popq %rbx
retq
callq 0x819f4
// File: /workspace/github_c_makefile_star2_O3/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 0x21047f
movq %r9, %rdi
callq 0xfcc32
testb %al, %al
jne 0x21056e
movq %rbp, %r12
subq %r14, %r12
jbe 0x210569
movq 0x38(%r15), %rax
testq %rax, %rax
jne 0x21049b
cmpq $0x0, 0x40(%r15)
je 0x2104b5
cmpq %r14, %rax
ja 0x210558
leaq (%rbx,%rbp), %rax
decq %rax
cmpq 0x40(%r15), %rax
ja 0x210558
cmpq %rbx, 0x20(%r15)
jb 0x210558
cmpq %r12, 0x28(%r15)
ja 0x210558
cmpq 0x30(%r15), %r12
ja 0x210558
cmpb $0x0, (%r13)
je 0x210573
movq 0x8(%r13), %rdi
movq %r14, %rsi
callq 0xeb655
movq 0x8(%r13), %rdi
movq %rax, %r13
movq %rbp, %rsi
callq 0xeb655
cmpq %rax, %r13
jne 0x210558
movq 0x8(%r15), %rsi
cmpq %rsi, 0x10(%r15)
jae 0x21050d
movq (%r15), %rax
jmp 0x210530
addq $0x20, %rsi
movq %rsi, 0x8(%r15)
movq (%r15), %rdi
shlq $0x5, %rsi
leaq 0x1b0a71(%rip), %rdx    # 0x3c0f94
movl $0xdd, %ecx
callq 0x104461
movq %rax, (%r15)
testq %rax, %rax
je 0x210578
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 0x81b4a
callq 0x81b11
callq 0x81b83
callq 0x81bbc
// File: /workspace/github_c_makefile_star2_O3/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 0x2116a9
movq (%r14), %r15
jmp 0x2116cf
addq $0xa, %rsi
movq %rsi, 0x8(%r14)
movq (%r14), %rdi
shlq $0x5, %rsi
leaq 0x1af8d5(%rip), %rdx    # 0x3c0f94
movl $0xed, %ecx
callq 0x104461
movq %rax, %r15
movq %rax, (%r14)
testq %r15, %r15
je 0x21173c
movq 0x10(%r14), %r13
movq 0x28(%r14), %r12
leaq 0x1(%r13), %rax
movq %rax, 0x10(%r14)
shlq $0x5, %r13
movq %rbx, %rdi
callq 0x1bac26
addq %r12, %rax
movq %rax, (%r15,%r13)
movq 0x30(%r14), %rbp
movq %rbx, %rdi
callq 0x1bac39
movq %rax, %r12
movq 0x28(%r14), %r14
movq %rbx, %rdi
callq 0x1bac26
addq %rbp, %r12
addq %r14, %rax
subq %rax, %r12
movq %r12, 0x8(%r15,%r13)
movq %rbx, %rdi
callq 0x1bac21
movq %rax, 0x10(%r15,%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x81df6
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1afc6e(%rip), %rdi    # 0x3c13bf
callq 0x17bd0
leaq 0x1afc09(%rip), %rdi    # 0x3c1366
callq 0x17bd0
leaq 0x1afc87(%rip), %rdi    # 0x3c13f0
callq 0x17bd0
leaq 0x1afc84(%rip), %rdi    # 0x3c13f9
callq 0x17bd0
leaq 0x1afc90(%rip), %rdi    # 0x3c1411
callq 0x17bd0
leaq 0x1afc9a(%rip), %rdi    # 0x3c1427
callq 0x17bd0
leaq 0x1afca7(%rip), %rdi    # 0x3c1440
callq 0x17bd0
leaq 0x1afcb7(%rip), %rdi    # 0x3c145c
callq 0x17bd0
leaq 0x1afcbd(%rip), %rdi    # 0x3c146e
callq 0x17bd0
leaq 0x1afce4(%rip), %rdi    # 0x3c14a1
callq 0x17bd0
leaq 0x1afceb(%rip), %rdi    # 0x3c14b4
popq %rax
jmp 0x17bd0
// File: /workspace/github_c_makefile_star2_O3/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 0x1afbdd(%rip), %rdi    # 0x3c13bf
callq 0x17bd0
leaq 0x1afafe(%rip), %rdi    # 0x3c12ec
xorl %eax, %eax
callq 0x17070
leaq 0x1afb08(%rip), %rdi    # 0x3c1304
xorl %eax, %eax
callq 0x17070
testl %ebx, %ebx
je 0x211815
leaq 0x1afb0e(%rip), %rdi    # 0x3c131c
xorl %eax, %eax
callq 0x17070
testb %bpl, %bpl
je 0x211828
leaq 0x1afb07(%rip), %rdi    # 0x3c1328
xorl %eax, %eax
callq 0x17070
leaq 0x1afb02(%rip), %rdi    # 0x3c1331
xorl %eax, %eax
callq 0x17070
testb %bl, %bl
je 0x211848
leaq 0x1afadb(%rip), %rdi    # 0x3c131c
xorl %eax, %eax
callq 0x17070
testb %bpl, %bpl
je 0x2118a1
leaq 0x1afaf6(%rip), %rdi    # 0x3c134a
xorl %eax, %eax
callq 0x17070
leaq 0x1afaf1(%rip), %rdi    # 0x3c1353
xorl %eax, %eax
callq 0x17070
leaq 0x1afaee(%rip), %rdi    # 0x3c135e
xorl %eax, %eax
callq 0x17070
leaq 0x1afb71(%rip), %rdi    # 0x3c13ef
callq 0x17bd0
leaq 0x1afbaa(%rip), %r14    # 0x3c1434
leaq 0x1afb96(%rip), %r15    # 0x3c1427
leaq 0x1afb79(%rip), %r12    # 0x3c1411
leaq 0x1afb5a(%rip), %rdi    # 0x3c13f9
jmp 0x2118d9
leaq 0x1afaab(%rip), %rdi    # 0x3c1353
xorl %eax, %eax
callq 0x17070
leaq 0x1afaa8(%rip), %rdi    # 0x3c135e
xorl %eax, %eax
callq 0x17070
leaq 0x1afb63(%rip), %r14    # 0x3c1427
leaq 0x1afb46(%rip), %r15    # 0x3c1411
leaq 0x1afb27(%rip), %r12    # 0x3c13f9
leaq 0x1afb16(%rip), %rdi    # 0x3c13ef
callq 0x17bd0
movq %r12, %rdi
callq 0x17bd0
movq %r15, %rdi
callq 0x17bd0
movq %r14, %rdi
callq 0x17bd0
leaq 0x1afb43(%rip), %rdi    # 0x3c1440
callq 0x17bd0
leaq 0x1afb53(%rip), %rdi    # 0x3c145c
callq 0x17bd0
leaq 0x1afb59(%rip), %rdi    # 0x3c146e
callq 0x17bd0
testb %bl, %bl
je 0x21192a
leaq 0x1afb5c(%rip), %rdi    # 0x3c1481
callq 0x17bd0
leaq 0x1afb70(%rip), %rdi    # 0x3c14a1
callq 0x17bd0
leaq 0x1afb77(%rip), %rdi    # 0x3c14b4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17bd0
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xe252f
cmpq $0x0, 0x2ad06e(%rip)    # 0x4be9c8
jne 0x211986
movq $0x0, (%rsp)
leaq 0x29(%rip), %rcx        # 0x211994
movl $0x20, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x2ad042(%rip)    # 0x4be9c8
callq 0xe2545
movq 0x2ad036(%rip), %rax    # 0x4be9c8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21194c
movq %rax, %rdi
callq 0x163080
movq %rax, %rbx
callq 0x21194c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
testq %rax, %rax
je 0x212061
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rbx, %rax
popq %rbx
retq
callq 0x81f81
// File: /workspace/github_c_makefile_star2_O3/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 0x2120aa
movq %rdi, %rbx
callq 0x21194c
movq %rax, %rdi
callq 0x163080
movq %rax, %r14
callq 0x21194c
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
testq %rax, %rax
je 0x2120af
movb $0x1, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x81ff3
callq 0x81fba
// File: /workspace/github_c_makefile_star2_O3/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 0x212162
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x144679
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %r13, %rdi
callq 0x112233
leaq 0x1(%rax), %rdi
leaq 0x1af405(%rip), %r15    # 0x3c1501
movl $0x1, %esi
movq %r15, %rdx
movl $0x35, %ecx
callq 0x10436a
movq %rax, %rbp
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0xeb6ee
movq 0x18(%r14), %rdi
leaq -0x1(%rax), %rcx
movq (%r13), %rdx
addq %rcx, %rdx
addq 0x8(%r13), %rcx
movq %rbp, %rsi
callq 0xe92be
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x11acf3
movq %rbp, %rdi
movq %r15, %rsi
movl $0x3b, %edx
callq 0x1045eb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8202c
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x21279b
movq %rdi, %rbx
callq 0x17320
leaq 0x1af29f(%rip), %rdx    # 0x3c19af
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 0x1af282(%rip), %rdx    # 0x3c19b6
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17c60
movq %r14, %rdi
callq 0x17320
leaq 0x1af268(%rip), %rdx    # 0x3c19bd
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17c60
movq %r14, %rdi
callq 0x17320
leaq 0x1af24e(%rip), %rdx    # 0x3c19c4
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 0x820d1
// File: /workspace/github_c_makefile_star2_O3/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 0x213aa2
movq %rsi, %rbx
testq %rsi, %rsi
je 0x213aa2
movq %rdi, %r14
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x213aa2
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x213aa2
movq 0x200(%rcx), %rdx
movq (%r14), %rsi
movq (%rsi), %rsi
movsd (%rdx,%rsi,8), %xmm1
movsd 0x133ef3(%rip), %xmm2   # 0x3478e0
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x133ef8(%rip), %xmm3   # 0x3478f0
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 0x135db1(%rip), %xmm4   # 0x3497e0
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 0x105c1c
testl %eax, %eax
je 0x213a8e
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 0x821ea
// File: /workspace/github_c_makefile_star2_O3/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 0x213b17
movq %rdx, %rbx
testq %rdx, %rdx
je 0x213b17
cmpq $0x0, 0xc0(%rbx)
je 0x213b17
movq %rsi, %r15
movq %rdi, %r14
testq %rcx, %rcx
je 0x213ada
movq %rcx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x213b1c
leaq 0x1adf1d(%rip), %rdx    # 0x3c19fe
movl $0x1, %edi
movl $0x18, %esi
movl $0x10d, %ecx            # imm = 0x10D
callq 0x10436a
movq %rbx, 0x10(%rax)
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq 0xc0(%rbx), %rdi
movq %rax, %rsi
callq 0xe5c3d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x8225c
callq 0x82223
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x215946
cmpl $0x3, %eax
jne 0x2159b8
leaq 0x1accfe(%rip), %rsi    # 0x3c2642
jmp 0x2159bf
leaq 0x1acd65(%rip), %rsi    # 0x3c26b2
xorl %eax, %eax
callq 0xfee51
movq 0x90(%rbx), %rdi
leaq 0x1acd09(%rip), %rsi    # 0x3c266b
xorl %eax, %eax
callq 0xfee51
movq 0x90(%rbx), %rdi
leaq 0x1acd0a(%rip), %rsi    # 0x3c2681
xorl %eax, %eax
callq 0xfee51
movq 0x90(%rbx), %rdi
leaq 0x1acd23(%rip), %rsi    # 0x3c26af
xorl %eax, %eax
callq 0xfee51
movq 0x90(%rbx), %rdi
leaq 0x1acd1a(%rip), %rsi    # 0x3c26bb
xorl %eax, %eax
callq 0xfee51
movq 0x90(%rbx), %rdi
leaq 0x1acd65(%rip), %rsi    # 0x3c271b
jmp 0x2159bf
leaq 0x1acd69(%rip), %rsi    # 0x3c2728
xorl %eax, %eax
popq %rbx
jmp 0xfee51
// File: /workspace/github_c_makefile_star2_O3/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 0x215c45
movq %rcx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x215c61
movq 0x78(%rbx), %rdi
addq $0x218, %rbx            # imm = 0x218
movl $0x8, %edx
movq %rbx, %rsi
callq 0xd2410
xorl %eax, %eax
popq %rbx
retq
callq 0x82541
// File: /workspace/github_c_makefile_star2_O3/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 %edi, %ebp
leaq 0x14c2d3(%rip), %rsi    # 0x36226f
movq %rbx, %rdi
callq 0x17a40
cmpl $0x3, %ebp
je 0x216022
cmpl $0x2, %ebp
jne 0x2160a9
testl %eax, %eax
je 0x2160c4
leaq 0x1ceff9(%rip), %rsi    # 0x3e4fba
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1cf051(%rip), %rsi    # 0x3e5029
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1ac297(%rip), %rsi    # 0x3c2286
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1ac284(%rip), %rsi    # 0x3c228a
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1ac271(%rip), %rsi    # 0x3c228e
jmp 0x2160b4
testl %eax, %eax
je 0x2160c4
leaq 0x1cef89(%rip), %rsi    # 0x3e4fba
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1cefe1(%rip), %rsi    # 0x3e5029
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1ac237(%rip), %rsi    # 0x3c2292
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1ac218(%rip), %rsi    # 0x3c2286
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1ac209(%rip), %rsi    # 0x3c228a
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1ac1fa(%rip), %rsi    # 0x3c228e
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
leaq 0x1ac1ef(%rip), %rsi    # 0x3c2296
jmp 0x2160b4
testl %eax, %eax
je 0x2160c4
leaq 0x1ac1d2(%rip), %rsi    # 0x3c2286
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x2160c4
xorl %eax, %eax
jmp 0x2160c8
movw $0x1, %ax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x2160f6
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x216161
testq %r14, %r14
je 0x21615c
leaq (%r14,%r15), %r12
decq %r12
cmpq %r14, %r12
jb 0x21614b
leaq 0xf(%rsp), %r15
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movsbl (%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x216166
testl %eax, %eax
jne 0x21614d
movsbl (%r12), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x216166
testl %eax, %eax
jne 0x21614d
movb 0xf(%rsp), %al
movb %al, (%r12)
incq %r14
decq %r12
cmpq %r12, %r14
jbe 0x216111
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x825b3
callq 0x8257a
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x0, 0xd0(%rdi)
je 0x2164fa
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movzwl 0x220(%rbx), %esi
callq 0x11bfb3
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a40
testl %eax, %eax
je 0x216584
movq 0x8(%rbx), %rdi
movzwl 0x222(%rbx), %esi
callq 0x11bfb3
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a40
testl %eax, %eax
je 0x2165a9
movq 0x10(%rbx), %rdi
movzwl 0x224(%rbx), %esi
callq 0x11bfb3
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a40
testl %eax, %eax
jne 0x2165cb
movw $0x1, 0xd8(%rbx)
movzwl 0x224(%rbx), %eax
incl %eax
xorl %ecx, %ecx
cmpw $0x9, %ax
cmovnel %eax, %ecx
movw %cx, 0x224(%rbx)
jmp 0x2165cb
movw $0x1, 0xd4(%rbx)
movzwl 0x220(%rbx), %eax
movl %eax, %ecx
incl %ecx
xorl %edx, %edx
testw %ax, %ax
cmovnel %ecx, %edx
movw %dx, 0x220(%rbx)
jmp 0x2165cb
movw $0x1, 0xd6(%rbx)
movzwl 0x222(%rbx), %eax
incl %eax
xorl %ecx, %ecx
cmpw $0x3, %ax
cmovnel %eax, %ecx
movw %cx, 0x222(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a9453(%rip), %rdx    # 0x3c4f17
movl $0x1, %edi
movl $0x40, %esi
movl $0x43, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x20(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21bb46
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
leaq 0x1a93df(%rip), %rsi    # 0x3c4f17
movq %rbx, %rdi
movl $0x53, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21be45
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x21be82
testq %r14, %r14
je 0x21be7d
movq 0x28(%r14), %rdx
xorl %eax, %eax
cmpq $-0x1, %rdx
je 0x21be75
movq 0x30(%r14), %rcx
cmpq %rcx, %rdx
jb 0x21be75
leaq 0x1a93aa(%rip), %rsi    # 0x3c5210
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x844b5
callq 0x8447c
// File: /workspace/github_c_makefile_star2_O3/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 0x1a8c89(%rip), %rsi    # 0x3c5368
movl $0x58, %edi
movl $0x41, %edx
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x38(%rbx)
callq 0x11ac6c
movq %rax, 0x30(%rbx)
callq 0x11ac6c
movq %rax, 0x48(%rbx)
callq 0x11ac6c
movq %rax, 0x40(%rbx)
callq 0x11ac6c
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_O3/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 0x21c77c
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
movq 0x48(%rbx), %rdi
callq 0x11bdbf
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x50(%rbx), %rdi
callq 0x11bdbf
leaq 0x1a8bfa(%rip), %rsi    # 0x3c5368
movq %rbx, %rdi
movl $0x54, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x224be0
leaq 0x27eeb8(%rip), %rsi    # 0x4bad60
movq %rbx, %rdi
xorl %edx, %edx
callq 0x23c7c0
leaq 0x18d1bb(%rip), %rsi    # 0x3c9074
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18d1b2(%rip), %rsi    # 0x3c907f
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x18d1b1(%rip), %rsi    # 0x3c909f
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18d1aa(%rip), %rsi    # 0x3c90ac
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x18c517(%rip), %rsi    # 0x3c843a
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18d194(%rip), %rsi    # 0x3c90cb
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x22708d
movq (%r14), %rsi
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x23ba2c
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2241f7
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
leaq 0x8(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x22708d
movq %rax, %rbx
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x22708d
movq %rax, %r14
movq (%r12), %rax
cmpq (%r13), %rax
je 0x23c002
leaq 0x18d028(%rip), %rdx    # 0x3c901d
movq %r15, %rdi
movl $0x2, %esi
callq 0x226d91
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x227963
subq $0x1, 0x8(%rsp)
jb 0x23c05c
leaq 0x2030(%rsp), %r12
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
movq 0x18(%rsp), %rax
cmpq %r12, %rax
jb 0x23c03e
movq %r15, %rdi
callq 0x227a17
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
subq $0x1, 0x8(%rsp)
jae 0x23c027
leaq 0x18(%rsp), %rdi
callq 0x2279f9
movl $0x1, %eax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x2168, %rsp           # imm = 0x2168
movq %rdi, %r13
leaq 0x28(%rsp), %rdx
movl $0x1, %esi
callq 0x22708d
movq %rax, %r14
movq %r13, %rdi
movl $0x3, %esi
callq 0x223a4b
cmpl $-0x1, %eax
jne 0x23c0d3
xorl %edi, %edi
callq 0x17740
leaq 0x150(%rsp), %rsi
movq %rax, (%rsi)
movl $0x8, %edx
movq %r13, %rdi
callq 0x2241f7
leaq 0x8(%rsp), %rbx
movq %r13, %rdi
movl $0x3, %esi
movq %rbx, %rdx
callq 0x22708d
movq %rax, %r15
movq (%rbx), %r12
cmpq $0x11, %r12
jb 0x23c10f
leaq 0x18cf38(%rip), %rsi    # 0x3c9033
movq %r13, %rdi
movl $0x10, %edx
xorl %eax, %eax
callq 0x226e43
movq 0x8(%rsp), %r12
leaq 0x41(%rsp), %rdi
movb %r12b, -0x1(%rdi)
movq %r15, %rsi
movq %r12, %rdx
callq 0x17660
incq %r12
leaq 0x40(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2241f7
movl 0x8(%rsp), %edx
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x23c36c
movl %eax, %ebx
movq 0x28(%rsp), %rbp
leaq 0x150(%rsp), %rsi
movq %r13, 0x10(%rsp)
movq %r13, %rdi
callq 0x227963
testq %rbp, %rbp
je 0x23c1f3
movslq %ebx, %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rbx
movq %rdi, %r13
movq 0x18(%rsp), %rsi
movq %rbx, %r12
movq %rbx, %rdx
callq 0x23ba2c
decq %rbp
cmpq $0xf, %rbp
movl $0xf, %eax
cmovbq %rbp, %rax
movq %rax, 0x20(%rsp)
leaq 0x1(%rax), %rbx
xorl %r15d, %r15d
movb (%r14,%r15), %al
xorb %al, 0x30(%rsp,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x23c1b1
leaq 0x150(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x227976
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r12, %rbx
callq 0x17660
movq %r13, %rdi
addq %r15, %r14
subq 0x20(%rsp), %rbp
jne 0x23c182
leaq 0x150(%rsp), %rdi
callq 0x2279f9
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x225a4f
movl $0x1, %eax
addq $0x2168, %rsp           # imm = 0x2168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/md5-1.2/src/md5lib.c
// Function: decrypt
static int decrypt (lua_State *L) {
  size_t lcyphertext;
  const char *cyphertext = luaL_checklstring(L, 1, &lcyphertext);
  size_t lseed = cyphertext[0];
  const char *seed = cyphertext+1;
  int lblock;
  char block[BLOCKSIZE+MAXKEY];
  luaL_argcheck(L, lcyphertext >= lseed+1 && lseed <= BLOCKSIZE, 1,
                 "invalid cyphered string");
  cyphertext += lseed+1;
  lcyphertext -= lseed+1;
  lblock = initblock(L, seed, lseed, block);
  decodestream(L, cyphertext, lcyphertext, block, lblock);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2148, %rsp           # imm = 0x2148
movq %rdi, %r14
movq %rsp, %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x22708d
movq %rax, %rbx
movsbq (%rax), %r15
cmpq $0x11, %r15
setb %cl
movq (%r12), %rax
movq %r15, %r12
incq %r12
cmpq %r12, %rax
setae %dl
testb %dl, %cl
jne 0x23c284
leaq 0x18cde9(%rip), %rdx    # 0x3c905c
movq %r14, %rdi
movl $0x1, %esi
callq 0x226d91
movq (%rsp), %rax
leaq 0x1(%rbx), %rsi
subq %r12, %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movl %r15d, %edx
callq 0x23c36c
movl %eax, %ebp
movq (%rsp), %r13
leaq 0x130(%rsp), %rsi
movq %r14, %rdi
callq 0x227963
testq %r13, %r13
je 0x23c348
addq %r12, %rbx
movslq %ebp, %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %r12
movq %rdi, %r14
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x23ba2c
decq %r13
cmpq $0xf, %r13
movl $0xf, %r15d
cmovbq %r13, %r15
movq %r15, %rax
negq %rax
movq $-0x1, %rcx
movb (%rbx), %dl
xorb %dl, 0x11(%rsp,%rcx)
incq %rbx
incq %rcx
movq %rax, %rdx
addq %rcx, %rdx
jne 0x23c301
leaq 0x1(%r15), %rbp
leaq 0x130(%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x227976
movq %r15, %rsi
notq %rsi
addq %rbx, %rsi
movq %r14, %rdi
movq %rbp, %rdx
callq 0x17660
movq %r14, %rdi
subq %r15, %r13
jne 0x23c2d3
leaq 0x130(%rsp), %rdi
callq 0x2279f9
movl $0x1, %eax
addq $0x2148, %rsp           # imm = 0x2148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/md5-1.2/src/md5lib.c
// Function: initblock
static int initblock (lua_State *L, const char *seed, int lseed, char *block) {
  size_t lkey;
  const char *key = luaL_checklstring(L, 2, &lkey);
  if (lkey > MAXKEY)
    luaL_error(L, "key too long (> %d)", MAXKEY);
  memset(block, 0, BLOCKSIZE);
  memcpy(block, seed, lseed);
  memcpy(block+BLOCKSIZE, key, lkey);
  return (int)lkey+BLOCKSIZE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r13
movq %rsp, %r12
movl $0x2, %esi
movq %r12, %rdx
callq 0x22708d
movq %rax, %r15
movq (%r12), %r12
cmpq $0x101, %r12            # imm = 0x101
jb 0x23c3bc
leaq 0x18cc9f(%rip), %rsi    # 0x3c9048
movq %r13, %rdi
movl $0x100, %edx            # imm = 0x100
xorl %eax, %eax
callq 0x226e43
movq (%rsp), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movslq %ebp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17660
addq $0x10, %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x17660
addl $0x10, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/md5-1.2/src/ldes56.c
// Function: luaopen_des56
int luaopen_des56 (lua_State *L) {
  lua_newtable(L);
  luaL_setfuncs(L, des56lib, 0);
  set_info (L);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x224be0
leaq 0x279344(%rip), %rsi    # 0x4b5750
movq %rbx, %rdi
xorl %edx, %edx
callq 0x23c7c0
leaq 0x18cc57(%rip), %rsi    # 0x3c9074
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18cd3e(%rip), %rsi    # 0x3c916f
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x18cc4d(%rip), %rsi    # 0x3c909f
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18cd29(%rip), %rsi    # 0x3c918f
movl $0x27, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
leaq 0x18bfb3(%rip), %rsi    # 0x3c843a
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2241f7
leaq 0x18cd1c(%rip), %rsi    # 0x3c91b7
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2241f7
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224d62
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/md5-1.2/src/ldes56.c
// Function: des56_decrypt
static int des56_decrypt( lua_State *L )
{
  char* decypheredText;
  keysched KS;
  int rel_index, abs_index;
  size_t cypherlen;
  const char *cypheredText = 
    luaL_checklstring( L, 1, &cypherlen );
  const char *key = luaL_optstring( L, 2, NULL );
  int padinfo;

  padinfo = cypheredText[cypherlen-1];
  cypherlen--;

  /* Aloca array */
  decypheredText = 
    (char *) malloc( (cypherlen+1) * sizeof(char));
  if(decypheredText == NULL) {
    lua_pushstring(L, "Error decrypting file. Not enough memory.");
    lua_error(L);
  }

  /* Inicia decifragem */
  if (key && strlen(key) >= 8)
  {
    char k[8];
    int i;

    for (i=0; i<8; i++)
      k[i] = (unsigned char)key[i];
    fsetkey(k, &KS);
  } else {
    lua_pushstring(L, "Error decrypting file. Invalid key.");
    lua_error(L);
  }

  rel_index = 0;
  abs_index = 0;

  while (abs_index < (int) cypherlen)
  {
    decypheredText[abs_index] = cypheredText[abs_index];
    abs_index++;
    rel_index++;
    if( rel_index == 8 )
    {
      rel_index = 0;
      fencrypt(&(decypheredText[abs_index - 8]), 1, &KS);
    }
  }
  decypheredText[abs_index] = 0;

  lua_pushlstring(L, decypheredText, (abs_index-padinfo));
  free( decypheredText );
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x22708d
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x227029
movq %rax, %r12
movq (%r14), %rdi
movsbq -0x1(%r15,%rdi), %r13
leaq -0x1(%rdi), %rax
movq %rax, (%r14)
callq 0x17ff0
movq %rax, %r14
testq %rax, %rax
jne 0x23c6e1
leaq 0x18ca50(%rip), %rsi    # 0x3c9121
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
callq 0x225800
testq %r12, %r12
je 0x23c718
movq %r12, %rdi
callq 0x172f0
cmpq $0x8, %rax
jb 0x23c718
xorl %eax, %eax
movb (%r12,%rax), %cl
movb %cl, 0x10(%rsp,%rax)
incq %rax
cmpq $0x8, %rax
jne 0x23c6f6
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x332f78
jmp 0x23c72f
leaq 0x18ca2c(%rip), %rsi    # 0x3c914b
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
callq 0x225800
movq (%rsp), %rax
testl %eax, %eax
jle 0x23c787
movq %r13, 0x8(%rsp)
movq %r14, %r12
addq $-0x7, %r12
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
xorl %ecx, %ecx
movb (%r15,%rbp), %dl
movb %dl, 0x7(%r12)
incl %ecx
cmpl $0x8, %ecx
jne 0x23c772
movq %r12, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x3335a6
xorl %ecx, %ecx
movq (%rsp), %rax
incq %rbp
movslq %eax, %rdx
incq %r12
cmpq %rdx, %rbp
jl 0x23c74c
movq 0x8(%rsp), %r13
jmp 0x23c789
xorl %ebp, %ebp
movl %ebp, %eax
movb $0x0, (%r14,%rax)
movslq %ebp, %rdx
subq %r13, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2241f7
movq %r14, %rdi
callq 0x17fe8
movl $0x1, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/md5-1.2/src/compat-5.2.c
// Function: luaL_setfuncs
void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
  luaL_checkstack(L, nup+1, "too many upvalues");
  for (; l->name != NULL; l++) {  /* fill the table with given functions */
    int i;
    lua_pushstring(L, l->name);
    for (i = 0; i < nup; i++)  /* copy upvalues to the top */
      lua_pushvalue(L, -(nup + 1));
    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
    lua_settable(L, -(nup + 3)); /* table must be below the upvalues, the name and the closure */
  }
  lua_pop(L, nup);  /* remove upvalues */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leal 0x1(%r14), %esi
leaq 0x18c9e2(%rip), %rdx    # 0x3c91c1
callq 0x2271b2
movq (%r15), %rsi
testq %rsi, %rsi
je 0x23c842
movl %r14d, %ebp
notl %ebp
movl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
subl %r14d, %r12d
movq %rbx, %rdi
callq 0x2243ba
testl %r14d, %r14d
jle 0x23c819
movl %r14d, %r13d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x223a2b
decl %r13d
jne 0x23c80a
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x2247b8
movq %rbx, %rdi
movl %r12d, %esi
callq 0x224d62
movq 0x10(%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x23c7fa
jmp 0x23c848
notl %r14d
movl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2235b9