LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x14b698(%rip), %rsi    # 0x36b37f
movq %rbx, %rdi
callq 0x17a40
cmpl $0x3, %ebp
je 0x21fd6d
cmpl $0x2, %ebp
jne 0x21fdf4
testl %eax, %eax
je 0x21fe0f
leaq 0x1cea72(%rip), %rsi    # 0x3ee77e
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1ceaca(%rip), %rsi    # 0x3ee7ed
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1abc74(%rip), %rsi    # 0x3cb9ae
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1abc61(%rip), %rsi    # 0x3cb9b2
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1abc4e(%rip), %rsi    # 0x3cb9b6
jmp 0x21fdff
testl %eax, %eax
je 0x21fe0f
leaq 0x1cea02(%rip), %rsi    # 0x3ee77e
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1cea5a(%rip), %rsi    # 0x3ee7ed
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1abc14(%rip), %rsi    # 0x3cb9ba
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1abbf5(%rip), %rsi    # 0x3cb9ae
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1abbe6(%rip), %rsi    # 0x3cb9b2
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1abbd7(%rip), %rsi    # 0x3cb9b6
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
leaq 0x1abbcc(%rip), %rsi    # 0x3cb9be
jmp 0x21fdff
testl %eax, %eax
je 0x21fe0f
leaq 0x1abbaf(%rip), %rsi    # 0x3cb9ae
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x21fe0f
xorl %eax, %eax
jmp 0x21fe13
movw $0x1, %ax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x21fe3e
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x21fea1
testq %r14, %r14
je 0x21fe9c
leaq (%r14,%r15), %r12
decq %r12
cmpq %r14, %r12
jb 0x21fe8e
leaq 0x7(%rsp), %r15
movsbl (%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x21fea6
testl %eax, %eax
jne 0x21fe77
movsbl (%r12), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x21fea6
testl %eax, %eax
jne 0x21fe90
movb 0x7(%rsp), %al
movb %al, (%r12)
incq %r14
decq %r12
cmpq %r12, %r14
jbe 0x21fe54
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x846a0
callq 0x84667
// File: /workspace/github_c_makefile_star2_O1/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 0x22023b
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movzwl 0x220(%rbx), %esi
callq 0x121cfa
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a40
testl %eax, %eax
je 0x2202c5
movq 0x8(%rbx), %rdi
movzwl 0x222(%rbx), %esi
callq 0x121cfa
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a40
testl %eax, %eax
je 0x2202ea
movq 0x10(%rbx), %rdi
movzwl 0x224(%rbx), %esi
callq 0x121cfa
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a40
testl %eax, %eax
jne 0x22030c
movw $0x1, 0xd8(%rbx)
movzwl 0x224(%rbx), %eax
incl %eax
xorl %ecx, %ecx
cmpw $0x9, %ax
cmovnel %eax, %ecx
movw %cx, 0x224(%rbx)
jmp 0x22030c
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 0x22030c
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_O1/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 0x1a8e23(%rip), %rdx    # 0x3ce63f
movl $0x1, %edi
movl $0x40, %esi
movl $0x43, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x20(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22589e
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x20(%rbx), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
leaq 0x1a8daf(%rip), %rsi    # 0x3ce63f
movq %rbx, %rdi
movl $0x53, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x225b9d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x225bda
testq %r14, %r14
je 0x225bd5
movq 0x28(%r14), %rdx
xorl %eax, %eax
cmpq $-0x1, %rdx
je 0x225bcd
movq 0x30(%r14), %rcx
cmpq %rcx, %rdx
jb 0x225bcd
leaq 0x1a8d7a(%rip), %rsi    # 0x3ce938
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x865a2
callq 0x86569
// File: /workspace/github_c_makefile_star2_O1/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 0x1a871d(%rip), %rsi    # 0x3cea90
movl $0x58, %edi
movl $0x41, %edx
callq 0x1092b2
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x38(%rbx)
callq 0x1208f8
movq %rax, 0x30(%rbx)
callq 0x1208f8
movq %rax, 0x48(%rbx)
callq 0x1208f8
movq %rax, 0x40(%rbx)
callq 0x1208f8
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_O1/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 0x226410
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x121b03
movq 0x48(%rbx), %rdi
callq 0x121b03
movq 0x40(%rbx), %rdi
callq 0x121b03
movq 0x50(%rbx), %rdi
callq 0x121b03
leaq 0x1a868e(%rip), %rsi    # 0x3cea90
movq %rbx, %rdi
movl $0x54, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22e8fc
leaq 0x281454(%rip), %rsi    # 0x4c5d60
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2451b8
leaq 0x18de77(%rip), %rsi    # 0x3d2794
movl $0xa, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18de6e(%rip), %rsi    # 0x3d279f
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x18de6d(%rip), %rsi    # 0x3d27bf
movl $0xc, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18de66(%rip), %rsi    # 0x3d27cc
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x18d1db(%rip), %rsi    # 0x3d1b62
movl $0x8, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18de50(%rip), %rsi    # 0x3d27eb
movl $0x7, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x230d0f
movq (%r14), %rsi
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x244498
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22deed
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x230d0f
movq %rax, %rbx
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x230d0f
movq %rax, %r14
movq (%r12), %rax
cmpq (%r13), %rax
je 0x244a66
leaq 0x18dce4(%rip), %rdx    # 0x3d273d
movq %r15, %rdi
movl $0x2, %esi
callq 0x230a08
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x2314e8
subq $0x1, 0x8(%rsp)
jb 0x244abd
leaq 0x2030(%rsp), %r12
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
cmpq %r12, 0x18(%rsp)
jb 0x244a9a
movq %r15, %rdi
callq 0x23159c
movb (%r14,%r13), %al
xorb (%rbx,%r13), %al
movq 0x18(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rsp)
movb %al, (%rcx)
incq %r13
subq $0x1, 0x8(%rsp)
jae 0x244a8b
leaq 0x18(%rsp), %rdi
callq 0x23157e
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_O1/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, %r13
leaq 0x18(%rsp), %rdx
movl $0x1, %esi
callq 0x230d0f
movq %rax, %r14
movq %r13, %rdi
movl $0x3, %esi
callq 0x22d7b8
cmpl $-0x1, %eax
jne 0x244b34
xorl %edi, %edi
callq 0x17740
leaq 0x140(%rsp), %rsi
movq %rax, (%rsi)
movl $0x8, %edx
movq %r13, %rdi
callq 0x22deed
movq %rsp, %rbx
movq %r13, %rdi
movl $0x3, %esi
movq %rbx, %rdx
callq 0x230d0f
movq %rax, %r15
cmpq $0x11, (%rbx)
jb 0x244b66
leaq 0x18dbfc(%rip), %rsi    # 0x3d2753
movq %r13, %rdi
movl $0x10, %edx
xorl %eax, %eax
callq 0x230abd
movq (%rsp), %rbx
leaq 0x31(%rsp), %rdi
movb %bl, -0x1(%rdi)
movq %r15, %rsi
movq %rbx, %rdx
callq 0x17660
incq %rbx
leaq 0x30(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x22deed
movl (%rsp), %edx
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x244d95
movl %eax, %ebx
movq 0x18(%rsp), %rbp
leaq 0x140(%rsp), %rsi
movq %r13, 0x8(%rsp)
movq %r13, %rdi
callq 0x2314e8
testq %rbp, %rbp
je 0x244c3b
movslq %ebx, %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %r13
movq %rdi, %r15
movq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x244498
decq %rbp
cmpq $0xf, %rbp
movl $0xf, %r12d
cmovbq %rbp, %r12
leaq 0x1(%r12), %rax
xorl %ebx, %ebx
movb (%r14,%rbx), %cl
xorb %cl, 0x20(%rsp,%rbx)
incq %rbx
cmpq %rbx, %rax
jne 0x244bff
leaq 0x140(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2314fb
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x17660
movq %r15, %rdi
addq %rbx, %r14
subq %r12, %rbp
jne 0x244bd7
leaq 0x140(%rsp), %rdi
callq 0x23157e
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x22f73e
movl $0x1, %eax
addq $0x2158, %rsp           # imm = 0x2158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rdx
movl $0x1, %esi
callq 0x230d0f
movq %rax, %rbx
movsbq (%rax), %r15
leaq 0x1(%r15), %r12
cmpq $0x10, %r15
ja 0x244ca6
cmpq %r12, (%rsp)
jae 0x244cba
leaq 0x18dacf(%rip), %rdx    # 0x3d277c
movq %r14, %rdi
movl $0x1, %esi
callq 0x230a08
leaq 0x1(%rbx), %rsi
subq %r12, (%rsp)
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movl %r15d, %edx
callq 0x244d95
movl %eax, %ebp
movq (%rsp), %r13
leaq 0x130(%rsp), %rsi
movq %r14, %rdi
callq 0x2314e8
testq %r13, %r13
je 0x244d71
addq %r12, %rbx
movslq %ebp, %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %r14
movq %rdi, %r12
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x244498
decq %r13
cmpq $0xf, %r13
movl $0xf, %r15d
cmovbq %r13, %r15
leaq 0x1(%r15), %rax
xorl %ebp, %ebp
movb (%rbx,%rbp), %cl
xorb %cl, 0x10(%rsp,%rbp)
incq %rbp
cmpq %rbp, %rax
jne 0x244d2d
leaq 0x130(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x2314fb
leaq (%rbx,%rbp), %r14
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x17660
movq %r12, %rdi
movq %r14, %rbx
leaq 0x10(%rsp), %r14
subq %r15, %r13
jne 0x244d06
leaq 0x130(%rsp), %rdi
callq 0x23157e
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_O1/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, %r15
movq %rdi, %r12
movq %rsp, %r13
movl $0x2, %esi
movq %r13, %rdx
callq 0x230d0f
movq %rax, %r14
cmpq $0x101, (%r13)          # imm = 0x101
jb 0x244dde
leaq 0x18d999(%rip), %rsi    # 0x3d2768
movq %r12, %rdi
movl $0x100, %edx            # imm = 0x100
xorl %eax, %eax
callq 0x230abd
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movslq %ebp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17660
addq $0x10, %rbx
movq (%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x17660
addl $0x10, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x22e8fc
leaq 0x27b92c(%rip), %rsi    # 0x4c0760
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2451b8
leaq 0x18d94f(%rip), %rsi    # 0x3d2794
movl $0xa, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18da36(%rip), %rsi    # 0x3d288f
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x18d945(%rip), %rsi    # 0x3d27bf
movl $0xc, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18da21(%rip), %rsi    # 0x3d28af
movl $0x27, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x18ccb3(%rip), %rsi    # 0x3d1b62
movl $0x8, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18da14(%rip), %rsi    # 0x3d28d7
movl $0x9, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x230d0f
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x230cab
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 0x2450db
leaq 0x18d776(%rip), %rsi    # 0x3d2841
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
callq 0x22f4f8
testq %r12, %r12
je 0x245112
movq %r12, %rdi
callq 0x172f0
cmpq $0x8, %rax
jb 0x245112
xorl %eax, %eax
movb (%r12,%rax), %cl
movb %cl, 0x10(%rsp,%rax)
incq %rax
cmpq $0x8, %rax
jne 0x2450f0
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x33dcc8
jmp 0x245129
leaq 0x18d752(%rip), %rsi    # 0x3d286b
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
callq 0x22f4f8
cmpl $0x0, (%rsp)
jle 0x24517c
movq %r13, 0x8(%rsp)
movq %r14, %r12
addq $-0x7, %r12
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
xorl %eax, %eax
movb (%r15,%rbp), %cl
movb %cl, 0x7(%r12)
incl %eax
cmpl $0x8, %eax
jne 0x245166
movq %r12, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x33e32c
xorl %eax, %eax
incq %rbp
movslq (%rsp), %rcx
incq %r12
cmpq %rcx, %rbp
jl 0x245144
movq 0x8(%rsp), %r13
jmp 0x24517e
xorl %ebp, %ebp
movl %ebp, %eax
movb $0x0, (%r14,%rax)
movslq %ebp, %rdx
subq %r13, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22deed
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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, %ebx
movq %rsi, %r15
movq %rdi, %r14
leal 0x1(%rbx), %esi
leaq 0x18d70c(%rip), %rdx    # 0x3d28e1
callq 0x230e39
movq (%r15), %rsi
movl %ebx, %ebp
notl %ebp
testq %rsi, %rsi
je 0x245233
movl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
subl %ebx, %r12d
movq %r14, %rdi
callq 0x22e0c4
testl %ebx, %ebx
jle 0x24520d
movl %ebx, %r13d
movq %r14, %rdi
movl %ebp, %esi
callq 0x22d798
decl %r13d
jne 0x2451fe
movq 0x8(%r15), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x22e48c
movq %r14, %rdi
movl %r12d, %esi
callq 0x22ea7e
movq 0x10(%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x2451ef
movq %r14, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22d42e
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: luaopen_lfs
int luaopen_lfs (lua_State *L) {
	dir_create_meta (L);
	lock_create_meta (L);
	luaL_register (L, "lfs", fslib);
	set_info (L);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18d5ae(%rip), %rsi    # 0x3d294d
callq 0x230d3b
leaq 0x157b4b(%rip), %r14    # 0x39cef6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22e0c4
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22e8fc
leaq 0x151471(%rip), %rsi    # 0x39683a
movq %rbx, %rdi
callq 0x22e0c4
leaq 0x1b6(%rip), %rsi       # 0x24558e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22e48c
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x18cc0e(%rip), %rsi    # 0x3d2004
movq %rbx, %rdi
callq 0x22e0c4
leaq 0x1fb(%rip), %r12       # 0x245600
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x22e48c
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x1615a0(%rip), %r15    # 0x3a69d3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22e0c4
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x22e48c
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x18d513(%rip), %rsi    # 0x3d2972
movq %rbx, %rdi
callq 0x230d3b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22e8fc
leaq 0x1b1(%rip), %r12       # 0x24562b
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x22e48c
leaq 0x1346c4(%rip), %rdx    # 0x379b52
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22ec93
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r14, %rdx
callq 0x22ec93
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x22e48c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x22ec93
leaq 0x18d5cb(%rip), %rsi    # 0x3d2a9a
leaq 0x27b2ba(%rip), %rdx    # 0x4c0790
movq %rbx, %rdi
callq 0x2310ec
leaq 0x18d2af(%rip), %rsi    # 0x3d2794
movl $0xa, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18d5a5(%rip), %rsi    # 0x3d2a9e
movl $0x26, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x18d2a5(%rip), %rsi    # 0x3d27bf
movl $0xc, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18d597(%rip), %rsi    # 0x3d2ac5
movl $0x8c, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
leaq 0x18c613(%rip), %rsi    # 0x3d1b62
movl $0x8, %edx
movq %rbx, %rdi
callq 0x22deed
leaq 0x18d5ef(%rip), %rsi    # 0x3d2b52
movl $0x13, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ea7e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: dir_close
static int dir_close (lua_State *L) {
	dir_data *d = (dir_data *)lua_touserdata (L, 1);
#ifdef _WIN32
	if (!d->closed && d->hFile) {
		_findclose (d->hFile);
		d->closed = 1;
	}
#else
	if (!d->closed && d->dir) {
		closedir (d->dir);
		d->closed = 1;
	}
#endif
	return 0;
}

// Assembly:
pushq %rbx
movl $0x1, %esi
callq 0x22de0e
cmpl $0x0, (%rax)
jne 0x245627
movq %rax, %rbx
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x245627
callq 0x17c80
movl $0x1, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: lfs_unlock_dir
static int lfs_unlock_dir(lua_State *L) {
  lfs_Lock *lock = luaL_checkudata(L, 1, LOCK_METATABLE);
  if(lock->ln) {
    unlink(lock->ln);
    free(lock->ln);
    lock->ln = NULL;
  }
  return 0;
}

// Assembly:
pushq %rbx
leaq 0x18d33f(%rip), %rdx    # 0x3d2972
movl $0x1, %esi
callq 0x230dae
movq (%rax), %rdi
testq %rdi, %rdi
je 0x24565c
movq %rax, %rbx
callq 0x17320
movq (%rbx), %rdi
callq 0x17fe8
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: change_dir
static int change_dir (lua_State *L) {
	const char *path = luaL_checkstring(L, 1);
	if (chdir(path)) {
		lua_pushnil (L);
		lua_pushfstring (L,"Unable to change working directory to '%s'\n%s\n",
				path, chdir_error);
		return 2;
	} else {
		lua_pushboolean (L, 1);
		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %r14
movq %rax, %rdi
callq 0x17b10
testl %eax, %eax
je 0x2456c5
movq %rbx, %rdi
callq 0x22deaa
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18d349(%rip), %rsi    # 0x3d29f7
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x22e3dc
movl $0x2, %ebp
jmp 0x2456d2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22e570
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: get_dir
static int get_dir (lua_State *L) {
  char *path;
  if ((path = getcwd(NULL, 0)) == NULL) {
    lua_pushnil(L);
    lua_pushstring(L, getcwd_error);
    return 2;
  }
  else {
    lua_pushstring(L, path);
    free(path);
    return 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x17360
testq %rax, %rax
je 0x24570b
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22e0c4
movq %r14, %rdi
callq 0x17fe8
movl $0x1, %eax
jmp 0x24572f
movq %rbx, %rdi
callq 0x22deaa
callq 0x17060
movl (%rax), %edi
callq 0x17240
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22e0c4
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: dir_iter_factory
static int dir_iter_factory (lua_State *L) {
	const char *path = luaL_checkstring (L, 1);
	dir_data *d;
	lua_pushcfunction (L, dir_iter);
	d = (dir_data *) lua_newuserdata (L, sizeof(dir_data));
	d->closed = 0;
#ifdef _WIN32
	d->hFile = 0L;
	luaL_getmetatable (L, DIR_METATABLE);
	lua_setmetatable (L, -2);
	if (strlen(path) > MAX_DIR_LENGTH)
		luaL_error (L, "path too long: %s", path);
	else
		sprintf (d->pattern, "%s/*", path);
#else
	luaL_getmetatable (L, DIR_METATABLE);
	lua_setmetatable (L, -2);
	d->dir = opendir (path);
	if (d->dir == NULL)
		luaL_error (L, "cannot open %s: %s", path, strerror (errno));
#endif
	return 2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %r14
leaq -0x1c7(%rip), %rsi      # 0x24558e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22e48c
movl $0x10, %esi
movq %rbx, %rdi
callq 0x22f9f1
movq %rax, %r15
movl $0x0, (%rax)
leaq 0x18d1d1(%rip), %rdx    # 0x3d294d
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e6f4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22ee93
movq %r14, %rdi
callq 0x17b60
movq %rax, 0x8(%r15)
testq %rax, %rax
jne 0x2457ca
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18d26c(%rip), %rsi    # 0x3d2a26
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x230abd
movl $0x2, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_lock
static int file_lock (lua_State *L) {
	FILE *fh = check_file (L, 1, "lock");
	const char *mode = luaL_checkstring (L, 2);
	const long start = luaL_optlong (L, 3, 0);
	long len = luaL_optlong (L, 4, 0);
	if (_file_lock (L, fh, mode, start, len, "lock")) {
		lua_pushboolean (L, 1);
		return 1;
	} else {
		lua_pushnil (L);
		lua_pushfstring (L, "%s", strerror(errno));
		return 2;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x199b9b(%rip), %r15    # 0x3df385
movq %r15, %rsi
callq 0x245dc8
movq %rax, %r12
movl $0x2, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %r13
movq %r14, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x230fba
movq %rax, %rbp
movq %r14, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x230fba
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
movq %r15, %r9
callq 0x245e1a
testl %eax, %eax
je 0x24585c
movl $0x1, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x22e570
jmp 0x245884
movq %r14, %rdi
callq 0x22deaa
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18c95a(%rip), %rsi    # 0x3d21d1
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22e3dc
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: make_dir
static int make_dir (lua_State *L) {
	const char *path = luaL_checkstring (L, 1);
	int fail;
#ifdef _WIN32
	int oldmask = umask (0);
	fail = _mkdir (path);
#else
	mode_t oldmask = umask( (mode_t)0 );
	fail =  mkdir (path, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP |
	                     S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH );
#endif
	if (fail) {
		lua_pushnil (L);
        lua_pushfstring (L, "%s", strerror(errno));
		return 2;
	}
	umask (oldmask);
	lua_pushboolean (L, 1);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %r15
xorl %edi, %edi
callq 0x17e00
movl %eax, %r14d
movq %r15, %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x17310
testl %eax, %eax
je 0x2458fd
movq %rbx, %rdi
callq 0x22deaa
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18c8e8(%rip), %rsi    # 0x3d21d1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22e3dc
movl $0x2, %ebp
jmp 0x245912
movl %r14d, %edi
callq 0x17e00
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22e570
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: remove_dir
static int remove_dir (lua_State *L) {
	const char *path = luaL_checkstring (L, 1);
	int fail;

	fail = rmdir (path);

	if (fail) {
		lua_pushnil (L);
		lua_pushfstring (L, "%s", strerror(errno));
		return 2;
	}
	lua_pushboolean (L, 1);
	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %rdi
callq 0x172d0
testl %eax, %eax
je 0x245971
movq %rbx, %rdi
callq 0x22deaa
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18c874(%rip), %rsi    # 0x3d21d1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22e3dc
movl $0x2, %ebp
jmp 0x24597e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22e570
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_utime
static int file_utime (lua_State *L) {
	const char *file = luaL_checkstring (L, 1);
	struct utimbuf utb, *buf;

	if (lua_gettop (L) == 1) /* set to current date/time */
		buf = NULL;
	else {
		utb.actime = (time_t)luaL_optnumber (L, 2, 0);
		utb.modtime = (time_t)luaL_optnumber (L, 3, utb.actime);
		buf = &utb;
	}
	if (utime (file, buf)) {
		lua_pushnil (L);
		lua_pushfstring (L, "%s", strerror (errno));
		return 2;
	}
	lua_pushboolean (L, 1);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %r14
movq %rbx, %rdi
callq 0x22d421
cmpl $0x1, %eax
je 0x245a30
xorpd %xmm0, %xmm0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x230f3b
cvttsd2si %xmm0, %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x230f3b
cvttsd2si %xmm0, %rax
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x17380
testl %eax, %eax
je 0x245a6e
movq %rbx, %rdi
callq 0x22deaa
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18c777(%rip), %rsi    # 0x3d21d1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22e3dc
movl $0x2, %ebp
jmp 0x245a80
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22e570
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_unlock
static int file_unlock (lua_State *L) {
	FILE *fh = check_file (L, 1, "unlock");
	const long start = luaL_optlong (L, 2, 0);
	long len = luaL_optlong (L, 3, 0);
	if (_file_lock (L, fh, "u", start, len, "unlock")) {
		lua_pushboolean (L, 1);
		return 1;
	} else {
		lua_pushnil (L);
		lua_pushfstring (L, "%s", strerror(errno));
		return 2;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x18cf1e(%rip), %r15    # 0x3d29be
movq %r15, %rsi
callq 0x245dc8
movq %rax, %r12
movl $0x2, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x230fba
movq %rax, %r13
movq %r14, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x230fba
leaq 0x152e0d(%rip), %rdx    # 0x3988e5
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
movq %rax, %r8
movq %r15, %r9
callq 0x245e1a
testl %eax, %eax
je 0x245b04
movl $0x1, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x22e570
jmp 0x245b2c
movq %r14, %rdi
callq 0x22deaa
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x18c6b2(%rip), %rsi    # 0x3d21d1
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22e3dc
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: lfs_lock_dir
static int lfs_lock_dir(lua_State *L) {
  lfs_Lock *lock;
  size_t pathl;
  char *ln;
  const char *lockfile = "/lockfile.lfs";
  const char *path = luaL_checklstring(L, 1, &pathl);
  lock = (lfs_Lock*)lua_newuserdata(L, sizeof(lfs_Lock));
  ln = (char*)malloc(pathl + strlen(lockfile) + 1);
  if(!ln) { 
    lua_pushnil(L); lua_pushstring(L, strerror(errno)); return 2;
  }
  strcpy(ln, path); strcat(ln, lockfile);
  if(symlink("lock", ln) == -1) {
    free(ln); lua_pushnil(L); 
    lua_pushstring(L, strerror(errno)); return 2;
  }
  lock->ln = ln;
  luaL_getmetatable (L, LOCK_METATABLE);
  lua_setmetatable (L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x230d0f
movq %rax, %r12
movl $0x8, %esi
movq %rbx, %rdi
callq 0x22f9f1
movq %rax, %r14
movq (%r15), %rdi
addq $0xe, %rdi
callq 0x17ff0
testq %rax, %rax
je 0x245bf1
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x17770
movq %r15, %rdi
callq 0x172f0
movabsq $0x6c69666b636f6c2f, %rcx # imm = 0x6C69666B636F6C2F
movq %rcx, (%r15,%rax)
movabsq $0x73666c2e656c69, %rcx # imm = 0x73666C2E656C69
movq %rcx, 0x6(%r15,%rax)
leaq 0x1997d4(%rip), %rdi    # 0x3df385
movq %r15, %rsi
callq 0x17080
cmpl $-0x1, %eax
je 0x245be9
movq %r15, (%r14)
leaq 0x18cdaa(%rip), %rdx    # 0x3d2972
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e6f4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22ee93
movl $0x1, %eax
jmp 0x245c15
movq %r15, %rdi
callq 0x17fe8
movq %rbx, %rdi
callq 0x22deaa
callq 0x17060
movl (%rax), %edi
callq 0x17240
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22e0c4
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: file_info_
static int _file_info_ (lua_State *L, int (*st)(const char*, STAT_STRUCT*)) {
	int i;
	STAT_STRUCT info;
	const char *file = luaL_checkstring (L, 1);

	if (st(file, &info)) {
		lua_pushnil (L);
		lua_pushfstring (L, "cannot obtain information from file `%s'", file);
		return 2;
	}
	if (lua_isstring (L, 2)) {
		int v;
		const char *member = lua_tostring (L, 2);
		if (strcmp (member, "mode") == 0) v = 0;
#ifndef _WIN32
		else if (strcmp (member, "blocks")  == 0) v = 11;
		else if (strcmp (member, "blksize") == 0) v = 12;
#endif
		else /* look for member */
			for (v = 1; members[v].name; v++)
				if (*members[v].name == *member)
					break;
		/* push member value and return */
		members[v].push (L, &info);
		return 1;
	} else if (!lua_istable (L, 2))
		/* creates a table if none is given */
		lua_newtable (L);
	/* stores all members in table on top of the stack */
	for (i = 0; members[i].name; i++) {
		lua_pushstring (L, members[i].name);
		members[i].push (L, &info);
		lua_rawset (L, -3);
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *%r15
movq %rbx, %rdi
testl %eax, %eax
je 0x245c78
callq 0x22deaa
leaq 0x18cd6d(%rip), %rsi    # 0x3d29ce
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22e3dc
movl $0x2, %ebp
jmp 0x245db8
movl $0x2, %esi
callq 0x22d88c
testl %eax, %eax
je 0x245d1d
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x22db9e
movq %rax, %r14
leaq 0x12d4a6(%rip), %rsi    # 0x37314c
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0x245d9b
leaq 0x10937f(%rip), %rsi    # 0x34f03c
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x245d85
leaq 0x18cc2f(%rip), %rsi    # 0x3d2903
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x245d8d
leaq 0x2800c5(%rip), %rax    # 0x4c5db0
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0x245d95
addq $0x20, %rax
movb (%r14), %sil
movl $0x1, %ecx
cmpb %sil, (%rdx)
je 0x245d18
incq %rcx
movq (%rax), %rdx
addq $0x10, %rax
testq %rdx, %rdx
jne 0x245d04
movl %ecx, %r15d
jmp 0x245d9b
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22d7b8
cmpl $0x5, %eax
je 0x245d3b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22e8fc
leaq 0x28006e(%rip), %r15    # 0x4c5db0
movq (%r15), %rsi
movl $0x1, %ebp
testq %rsi, %rsi
je 0x245db8
addq $0x10, %r15
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movq %r14, %rsi
callq *-0x8(%r15)
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ecef
movq (%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x245d58
jmp 0x245db8
movl $0xb, %r15d
jmp 0x245d9b
movl $0xc, %r15d
jmp 0x245d9b
movl $0x1, %r15d
shlq $0x4, %r15
leaq 0x28000a(%rip), %rax    # 0x4c5db0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x8(%rax,%r15)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/luafilesystem-1.5.0/src/lfs.c
// Function: check_file
static FILE *check_file (lua_State *L, int idx, const char *funcname) {
	FILE **fh = (FILE **)luaL_checkudata (L, idx, "FILE*");
	if (fh == NULL) {
		luaL_error (L, "%s: not a file", funcname);
		return 0;
	} else if (*fh == NULL) {
		luaL_error (L, "%s: closed file", funcname);
		return 0;
	} else
		return *fh;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18c1f8(%rip), %rdx    # 0x3d1fd2
movl $0x1, %esi
callq 0x230dae
testq %rax, %rax
je 0x245dfa
movq (%rax), %r15
testq %r15, %r15
jne 0x245e11
leaq 0x18cc50(%rip), %rsi    # 0x3d2a48
jmp 0x245e01
leaq 0x18cc38(%rip), %rsi    # 0x3d2a39
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x230abd
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: luaopen_lpeg
int luaopen_lpeg (lua_State *L) {
  lua_pushcfunction(L, (lua_CFunction)&l_newpf);  /* new-pattern function */
  lua_setfield(L, LUA_REGISTRYINDEX, KEYNEWPATT);  /* register it */
  luaL_newmetatable(L, PATTERN_T);
  lua_pushnumber(L, MAXBACK);
  lua_setfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX);
  luaL_register(L, NULL, metapattreg);
  luaL_register(L, "lpeg", pattreg);
  lua_pushliteral(L, "__index");
  lua_pushvalue(L, -2);
  lua_settable(L, -4);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xaa(%rip), %rsi        # 0x245f4d
xorl %edx, %edx
callq 0x22e48c
leaq 0x18cef7(%rip), %rdx    # 0x3d2da8
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22ec93
leaq 0x18ceee(%rip), %rsi    # 0x3d2db3
movq %rbx, %rdi
callq 0x230d3b
movsd 0x10c91b(%rip), %xmm0   # 0x3527f0
movq %rbx, %rdi
callq 0x22debe
leaq 0x18cedc(%rip), %rdx    # 0x3d2dc0
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22ec93
leaq 0x27ff98(%rip), %rdx    # 0x4c5e90
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2310ec
leaq 0x1082ab(%rip), %rsi    # 0x34e1b4
leaq 0x280000(%rip), %rdx    # 0x4c5f10
movq %rbx, %rdi
callq 0x2310ec
leaq 0x156fd7(%rip), %rsi    # 0x39cef6
movl $0x7, %edx
movq %rbx, %rdi
callq 0x22deed
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d798
movq %rbx, %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x22ea7e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: l_newpf
static void l_newpf (lua_State *L, PattFunc f, const void *ud, size_t l) {
  int n = instsize(l) + 1;
  Instruction *p = newpatt(L, n);
  if (n > MAXAUX) luaL_error(L, "pattern data too long");
  p[0].i.code = IFunc;
  p[0].i.aux = n - 2;
  p[0].i.offset = 0;
  p[1].f = f;
  memcpy(p[2].buff, ud, l);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x7(%rcx), %r14
shrq $0x3, %r14
leal 0x2(%r14), %eax
movslq %eax, %rbp
movq %rbp, %rsi
callq 0x245fcd
movq %rax, %r13
cmpl $0x100, %ebp            # imm = 0x100
jl 0x245f98
leaq 0x18ce40(%rip), %rsi    # 0x3d2dce
movq %r12, %rdi
xorl %eax, %eax
callq 0x230abd
movb $0x11, (%r13)
movb %r14b, 0x1(%r13)
movw $0x0, 0x2(%r13)
movq %r15, 0x8(%r13)
addq $0x10, %r13
movq %r13, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17660