LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: min_expand
static const char *min_expand (MatchState *ms, const char *s,
                                 const char *p, const char *ep) {
  for (;;) {
    const char *res = match(ms, s, ep+1);
    if (res != NULL)
      return res;
    else if (s<ms->src_end && singlematch(uchar(*s), p, ep))
      s++;  /* try with one more repetition */
    else return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
callq 0x277b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x282d2
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28315
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x28307
movq -0x18(%rbp), %rax
movzbl (%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x28130
cmpl $0x0, %eax
je 0x28307
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x28311
movq $0x0, -0x8(%rbp)
jmp 0x28315
jmp 0x28313
jmp 0x282a8
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: check_capture
static int check_capture (MatchState *ms, int l) {
  l -= '1';
  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
    return luaL_error(ms->L, "invalid capture index");
  return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x31, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x28584
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x28584
movq -0x10(%rbp), %rax
addq $0x20, %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $-0x1, 0x8(%rax)
jne 0x2859f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x4a1e(%rip), %rsi      # 0x2cfb1
movb $0x0, %al
callq 0x1a8b0
movl %eax, -0x4(%rbp)
jmp 0x285a5
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: addintlen
static void addintlen (char *form) {
  size_t l = strlen(form);
  char spec = form[l - 1];
  strcpy(form + l - 1, LUA_INTFRMLEN);
  form[l + sizeof(LUA_INTFRMLEN) - 2] = spec;
  form[l + sizeof(LUA_INTFRMLEN) - 1] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5150
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
addq -0x10(%rbp), %rdi
addq $-0x1, %rdi
leaq 0x36b0(%rip), %rsi      # 0x2bf8e
callq 0x50a0
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x2, %rcx
subq $0x2, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x2, %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: gmatch_aux
static int gmatch_aux (lua_State *L) {
  MatchState ms;
  size_t ls;
  const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
  const char *p = lua_tostring(L, lua_upvalueindex(2));
  const char *src;
  ms.L = L;
  ms.src_init = s;
  ms.src_end = s+ls;
  for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
       src <= ms.src_end;
       src++) {
    const char *e;
    ms.level = 0;
    if ((e = match(&ms, src, p)) != NULL) {
      lua_Integer newstart = e-s;
      if (e == src) newstart++;  /* empty match? go at least one position */
      lua_pushinteger(L, newstart);
      lua_replace(L, lua_upvalueindex(3));
      return push_captures(&ms, src, e);
    }
  }
  return 0;  /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
leaq -0x238(%rbp), %rdx
callq 0x74a0
movq %rax, -0x240(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffd8ec, %esi       # imm = 0xFFFFD8EC
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq %rax, -0x248(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x240(%rbp), %rax
addq -0x238(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0x268(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffd8eb, %esi       # imm = 0xFFFFD8EB
callq 0x73c0
movq %rax, %rcx
movq -0x268(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x250(%rbp)
movq -0x250(%rbp), %rax
cmpq -0x228(%rbp), %rax
ja 0x28ce7
movl $0x0, -0x218(%rbp)
movq -0x250(%rbp), %rsi
movq -0x248(%rbp), %rdx
leaq -0x230(%rbp), %rdi
callq 0x277b0
movq %rax, -0x258(%rbp)
cmpq $0x0, %rax
je 0x28cce
movq -0x258(%rbp), %rax
movq -0x240(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x260(%rbp)
movq -0x258(%rbp), %rax
cmpq -0x250(%rbp), %rax
jne 0x28c91
movq -0x260(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x260(%rbp)
movq -0x10(%rbp), %rdi
movq -0x260(%rbp), %rsi
callq 0x7880
movq -0x10(%rbp), %rdi
movl $0xffffd8eb, %esi       # imm = 0xFFFFD8EB
callq 0x6df0
movq -0x250(%rbp), %rsi
movq -0x258(%rbp), %rdx
leaq -0x230(%rbp), %rdi
callq 0x27b90
movl %eax, -0x4(%rbp)
jmp 0x28cee
jmp 0x28cd0
movq -0x250(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x250(%rbp)
jmp 0x28c12
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: add_value
static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
                                                       const char *e) {
  lua_State *L = ms->L;
  switch (lua_type(L, 3)) {
    case LUA_TNUMBER:
    case LUA_TSTRING: {
      add_s(ms, b, s, e);
      return;
    }
    case LUA_TFUNCTION: {
      int n;
      lua_pushvalue(L, 3);
      n = push_captures(ms, s, e);
      lua_call(L, n, 1);
      break;
    }
    case LUA_TTABLE: {
      push_onecapture(ms, 0, s, e);
      lua_gettable(L, 3);
      break;
    }
  }
  if (!lua_toboolean(L, -1)) {  /* nil or false? */
    lua_pop(L, 1);
    lua_pushlstring(L, s, e - s);  /* keep original text */
  }
  else if (!lua_isstring(L, -1))
    luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1)); 
  luaL_addvalue(b);  /* add result to accumulator */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0x6fe0
movl %eax, %ecx
movl %ecx, %eax
addl $-0x3, %eax
movl %ecx, -0x30(%rbp)
subl $0x2, %eax
jb 0x28d57
jmp 0x28d43
movl -0x30(%rbp), %eax
subl $0x5, %eax
je 0x28da6
jmp 0x28d4d
movl -0x30(%rbp), %eax
subl $0x6, %eax
je 0x28d71
jmp 0x28dc7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x28e70
jmp 0x28e5e
movq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0x6f80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x27b90
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl $0x1, %edx
callq 0x8680
jmp 0x28dc7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %esi, %esi
callq 0x285b0
movq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0x7d40
movq -0x28(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7440
cmpl $0x0, %eax
jne 0x28e02
movq -0x28(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x78d0
jmp 0x28e55
movq -0x28(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7120
cmpl $0x0, %eax
jne 0x28e53
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x7030
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x4258(%rip), %rsi      # 0x2d0a4
movb $0x0, %al
callq 0x1a8b0
jmp 0x28e55
movq -0x10(%rbp), %rdi
callq 0x1b800
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: add_s
static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
                                                   const char *e) {
  size_t l, i;
  const char *news = lua_tolstring(ms->L, 3, &l);
  for (i = 0; i < l; i++) {
    if (news[i] != L_ESC)
      luaL_addchar(b, news[i]);
    else {
      i++;  /* skip ESC */
      if (!isdigit(uchar(news[i])))
        luaL_addchar(b, news[i]);
      else if (news[i] == '0')
          luaL_addlstring(b, s, e - s);
      else {
        push_onecapture(ms, news[i] - '1', s, e);
        luaL_addvalue(b);  /* add capture to accumulated result */
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x3, %esi
leaq -0x28(%rbp), %rdx
callq 0x74a0
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x29014
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
je 0x28f22
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x39(%rbp)
jb 0x28efc
movq -0x10(%rbp), %rdi
callq 0x1b680
cmpq $0x0, %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x29001
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
callq 0x5570
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x28fa9
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x3a(%rbp)
jb 0x28f86
movq -0x10(%rbp), %rdi
callq 0x1b680
cmpq $0x0, %rax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x28fff
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0x28fd4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x1b570
jmp 0x28ffd
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %esi
subl $0x31, %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x285b0
movq -0x10(%rbp), %rdi
callq 0x1b800
jmp 0x28fff
jmp 0x29001
jmp 0x29003
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x28eaa
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: gctm
static int gctm (lua_State *L) {
  void **lib = (void **)luaL_checkudata(L, 1, "_LOADLIB");
  if (*lib) ll_unloadlib(*lib);
  *lib = NULL;  /* mark library as closed */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x3ea9(%rip), %rdx      # 0x2d0c5
callq 0x1acc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2923b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x292f0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: setpath
static void setpath (lua_State *L, const char *fieldname, const char *envname,
                                   const char *def) {
  const char *path = getenv(envname);
  if (path == NULL)  /* no environment variable? */
    lua_pushstring(L, def);  /* use default */
  else {
    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
    path = luaL_gsub(L, path, LUA_PATHSEP LUA_PATHSEP,
                              LUA_PATHSEP AUXMARK LUA_PATHSEP);
    luaL_gsub(L, path, AUXMARK, def);
    lua_remove(L, -2);
  }
  setprogdir(L);
  lua_setfield(L, -2, fieldname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2928b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7950
jmp 0x292d0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x4074(%rip), %rdx      # 0x2d30e
leaq 0x4070(%rip), %rcx      # 0x2d311
callq 0x1b470
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x4058(%rip), %rdx      # 0x2d315
callq 0x1b470
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x81e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: ll_seeall
static int ll_seeall (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  if (!lua_getmetatable(L, 1)) {
    lua_createtable(L, 0, 1); /* create new metatable */
    lua_pushvalue(L, -1);
    lua_setmetatable(L, 1);
  }
  lua_pushvalue(L, LUA_GLOBALSINDEX);
  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7fa0
cmpl $0x0, %eax
jne 0x2940e
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x7f20
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8420
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x287c(%rip), %rdx      # 0x2bca8
callq 0x81e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: ll_loadfunc
static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
  void **reg = ll_register(L, path);
  if (*reg == NULL) *reg = ll_load(L, path);
  if (*reg == NULL)
    return ERRLIB;  /* unable to load library */
  else {
    lua_CFunction f = ll_sym(L, *reg, sym);
    if (f == NULL)
      return ERRFUNC;  /* unable to find function */
    lua_pushcfunction(L, f);
    return 0;  /* return function */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x294e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x29486
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x295e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x29499
movl $0x1, -0x4(%rbp)
jmp 0x294d7
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x29610
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x294c1
movl $0x2, -0x4(%rbp)
jmp 0x294d7
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x7ae0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: ll_register
static void **ll_register (lua_State *L, const char *path) {
  void **plib;
  lua_pushfstring(L, "%s%s", LIBPREFIX, path);
  lua_gettable(L, LUA_REGISTRYINDEX);  /* check library in registry? */
  if (!lua_isnil(L, -1))  /* is there an entry? */
    plib = (void **)lua_touserdata(L, -1);
  else {  /* no entry yet; create one */
    lua_pop(L, 1);
    plib = (void **)lua_newuserdata(L, sizeof(const void *));
    *plib = NULL;
    luaL_getmetatable(L, "_LOADLIB");
    lua_setmetatable(L, -2);
    lua_pushfstring(L, "%s%s", LIBPREFIX, path);
    lua_pushvalue(L, -2);
    lua_settable(L, LUA_REGISTRYINDEX);
  }
  return plib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x3cfa(%rip), %rsi      # 0x2d1f9
leaq 0x3cf8(%rip), %rdx      # 0x2d1fe
movb $0x0, %al
callq 0x7a10
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x7d40
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x0, %eax
je 0x29545
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x76a0
movq %rax, -0x18(%rbp)
jmp 0x295cc
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x8da0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x3b45(%rip), %rdx      # 0x2d0c5
callq 0x7d90
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8420
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x3c57(%rip), %rsi      # 0x2d1f9
leaq 0x3c55(%rip), %rdx      # 0x2d1fe
movb $0x0, %al
callq 0x7a10
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x8180
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: loader_preload
static int loader_preload (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  lua_getfield(L, LUA_ENVIRONINDEX, "preload");
  if (!lua_istable(L, -1))
    luaL_error(L, LUA_QL("package.preload") " must be a table");
  lua_getfield(L, -1, name);
  if (lua_isnil(L, -1))  /* not found? */
    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
leaq 0x3b54(%rip), %rdx      # 0x2d1d6
callq 0x7d90
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x5, %eax
je 0x296ac
movq -0x8(%rbp), %rdi
leaq 0x3b9e(%rip), %rsi      # 0x2d243
movb $0x0, %al
callq 0x1a8b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7d90
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x0, %eax
jne 0x296e7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3b85(%rip), %rsi      # 0x2d265
movb $0x0, %al
callq 0x7a10
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: loader_Lua
static int loader_Lua (lua_State *L) {
  const char *filename;
  const char *name = luaL_checkstring(L, 1);
  filename = findfile(L, name, "path");
  if (filename == NULL) return 1;  /* library not found in this path */
  if (luaL_loadfile(L, filename) != 0)
    loaderror(L, filename);
  return 1;  /* library loaded successfully */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x3a39(%rip), %rdx      # 0x2d16a
callq 0x29920
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2974a
movl $0x1, -0x4(%rbp)
jmp 0x29770
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ba40
cmpl $0x0, %eax
je 0x29769
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29a70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: loader_C
static int loader_C (lua_State *L) {
  const char *funcname;
  const char *name = luaL_checkstring(L, 1);
  const char *filename = findfile(L, name, "cpath");
  if (filename == NULL) return 1;  /* library not found in this path */
  funcname = mkfuncname(L, name);
  if (ll_loadfunc(L, filename, funcname) != 0)
    loaderror(L, filename);
  return 1;  /* library loaded successfully */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x39b8(%rip), %rdx      # 0x2d169
callq 0x29920
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x297ca
movl $0x1, -0x4(%rbp)
jmp 0x29805
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29be0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29440
cmpl $0x0, %eax
je 0x297fe
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x29a70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: loader_Croot
static int loader_Croot (lua_State *L) {
  const char *funcname;
  const char *filename;
  const char *name = luaL_checkstring(L, 1);
  const char *p = strchr(name, '.');
  int stat;
  if (p == NULL) return 0;  /* is root */
  lua_pushlstring(L, name, p - name);
  filename = findfile(L, lua_tostring(L, -1), "cpath");
  if (filename == NULL) return 1;  /* root not found */
  funcname = mkfuncname(L, name);
  if ((stat = ll_loadfunc(L, filename, funcname)) != 0) {
    if (stat != ERRFUNC) loaderror(L, filename);  /* real error */
    lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
                       name, filename);
    return 1;  /* function not found */
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x2e, %esi
callq 0x5170
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x29857
movl $0x0, -0x4(%rbp)
jmp 0x29917
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
callq 0x78d0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
leaq 0x38d2(%rip), %rdx      # 0x2d169
callq 0x29920
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x298b0
movl $0x1, -0x4(%rbp)
jmp 0x29917
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x29be0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29440
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x29910
cmpl $0x2, -0x34(%rbp)
je 0x298ed
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29a70
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x39f0(%rip), %rsi      # 0x2d2f0
movb $0x0, %al
callq 0x7a10
movl $0x1, -0x4(%rbp)
jmp 0x29917
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: findfile
static const char *findfile (lua_State *L, const char *name,
                                           const char *pname) {
  const char *path;
  name = luaL_gsub(L, name, ".", LUA_DIRSEP);
  lua_getfield(L, LUA_ENVIRONINDEX, pname);
  path = lua_tostring(L, -1);
  if (path == NULL)
    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
  lua_pushliteral(L, "");  /* error accumulator */
  while ((path = pushnexttemplate(L, path)) != NULL) {
    const char *filename;
    filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
    lua_remove(L, -2);  /* remove path template */
    if (readable(filename))  /* does file exist and is readable? */
      return filename;  /* return that file name */
    lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
    lua_remove(L, -2);  /* remove file name */
    lua_concat(L, 2);  /* add entry to possible error message */
  }
  return NULL;  /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2ee2(%rip), %rdx      # 0x2c825
leaq 0x393c(%rip), %rcx      # 0x2d286
callq 0x1b470
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x7d90
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x29998
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x38f7(%rip), %rsi      # 0x2d288
movb $0x0, %al
callq 0x1a8b0
movq -0x10(%rbp), %rdi
leaq 0x3973(%rip), %rsi      # 0x2d316
xorl %eax, %eax
movl %eax, %edx
callq 0x78d0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x29ae0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x29a59
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rcx
leaq 0x2e65(%rip), %rdx      # 0x2c858
callq 0x1b470
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b40
movq -0x30(%rbp), %rdi
callq 0x29b90
cmpl $0x0, %eax
je 0x29a22
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x29a61
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x3875(%rip), %rsi      # 0x2d2a6
movb $0x0, %al
callq 0x7a10
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b40
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x8c40
jmp 0x299ac
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: pushnexttemplate
static const char *pushnexttemplate (lua_State *L, const char *path) {
  const char *l;
  while (*path == *LUA_PATHSEP) path++;  /* skip separators */
  if (*path == '\0') return NULL;  /* no more templates */
  l = strchr(path, *LUA_PATHSEP);  /* find next separator */
  if (l == NULL) l = path + strlen(path);
  lua_pushlstring(L, path, l - path);  /* template */
  return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x3815(%rip), %ecx      # 0x2d313
cmpl %ecx, %eax
jne 0x29b10
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x29af0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x29b26
movq $0x0, -0x8(%rbp)
jmp 0x29b80
movq -0x18(%rbp), %rdi
movsbl 0x37e2(%rip), %esi      # 0x2d313
callq 0x5170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x29b60
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5150
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x78d0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: mkfuncname
static const char *mkfuncname (lua_State *L, const char *modname) {
  const char *funcname;
  const char *mark = strchr(modname, *LUA_IGMARK);
  if (mark) modname = mark + 1;
  funcname = luaL_gsub(L, modname, ".", LUA_OFSEP);
  funcname = lua_pushfstring(L, POF"%s", funcname);
  lua_remove(L, -2);  /* remove 'gsub' result */
  return funcname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movsbl 0x35cb(%rip), %esi      # 0x2d1c6
callq 0x5170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29c17
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x2bff(%rip), %rdx      # 0x2c825
leaq 0x36b6(%rip), %rcx      # 0x2d2e3
callq 0x1b470
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x36a0(%rip), %rsi      # 0x2d2e5
movb $0x0, %al
callq 0x7a10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: ll_module
static int ll_module (lua_State *L) {
  const char *modname = luaL_checkstring(L, 1);
  int loaded = lua_gettop(L) + 1;  /* index of _LOADED table */
  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, loaded, modname);  /* get _LOADED[modname] */
  if (!lua_istable(L, -1)) {  /* not found? */
    lua_pop(L, 1);  /* remove previous result */
    /* try global variable (and create one if it does not exist) */
    if (luaL_findtable(L, LUA_GLOBALSINDEX, modname, 1) != NULL)
      return luaL_error(L, "name conflict for module " LUA_QS, modname);
    lua_pushvalue(L, -1);
    lua_setfield(L, loaded, modname);  /* _LOADED[modname] = new table */
  }
  /* check whether table already has a _NAME field */
  lua_getfield(L, -1, "_NAME");
  if (!lua_isnil(L, -1))  /* is table an initialized module? */
    lua_pop(L, 1);
  else {  /* no; initialize it */
    lua_pop(L, 1);
    modinit(L, modname);
  }
  lua_pushvalue(L, -1);
  setfenv(L);
  dooptions(L, loaded - 1);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a80
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x231e(%rip), %rdx      # 0x2bfcf
callq 0x7d90
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x7d90
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x5, %eax
je 0x29d40
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movl $0x1, %ecx
callq 0x1b2f0
cmpq $0x0, %rax
je 0x29d22
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x22c4(%rip), %rsi      # 0x2bfd7
movb $0x0, %al
callq 0x1a8b0
movl %eax, -0x4(%rbp)
jmp 0x29dc0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x81e0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x35ce(%rip), %rdx      # 0x2d31e
callq 0x7d90
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x0, %eax
je 0x29d78
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
jmp 0x29d93
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a070
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x10(%rbp), %rdi
callq 0x2a130
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl $0x1, %esi
callq 0x2a1d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: modinit
static void modinit (lua_State *L, const char *modname) {
  const char *dot;
  lua_pushvalue(L, -1);
  lua_setfield(L, -2, "_M");  /* module._M = module */
  lua_pushstring(L, modname);
  lua_setfield(L, -2, "_NAME");
  dot = strrchr(modname, '.');  /* look for last dot in module name */
  if (dot == NULL) dot = modname;
  else dot++;
  /* set _PACKAGE as package name (full module name minus last part) */
  lua_pushlstring(L, modname, dot - modname);
  lua_setfield(L, -2, "_PACKAGE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x3286(%rip), %rdx      # 0x2d324
callq 0x81e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7950
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x325e(%rip), %rdx      # 0x2d31e
callq 0x81e0
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x51a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2a0e8
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2a0f4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x78d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x320b(%rip), %rdx      # 0x2d327
callq 0x81e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: setfenv
static void setfenv (lua_State *L) {
  lua_Debug ar;
  if (lua_getstack(L, 1, &ar) == 0 ||
      lua_getinfo(L, "f", &ar) == 0 ||  /* get calling function */
      lua_iscfunction(L, -1))
    luaL_error(L, LUA_QL("module") " not called from a Lua function");
  lua_pushvalue(L, -2);
  lua_setfenv(L, -2);
  lua_pop(L, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x80(%rbp), %rdx
callq 0x9180
cmpl $0x0, %eax
je 0x2a182
movq -0x8(%rbp), %rdi
leaq 0x28da(%rip), %rsi      # 0x2ca3b
leaq -0x80(%rbp), %rdx
callq 0x9480
cmpl $0x0, %eax
je 0x2a182
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7070
cmpl $0x0, %eax
je 0x2a194
movq -0x8(%rbp), %rdi
leaq 0x31a3(%rip), %rsi      # 0x2d330
movb $0x0, %al
callq 0x1a8b0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8560
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loadlib.c
// Function: dooptions
static void dooptions (lua_State *L, int n) {
  int i;
  for (i = 2; i <= n; i++) {
    lua_pushvalue(L, i);  /* get option (a function) */
    lua_pushvalue(L, -2);  /* module */
    lua_call(L, 1, 0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x2a223
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8680
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2a1e6
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node.c
// Function: init_ast_node
ast_node* init_ast_node(token* tok) {
    ast_node* ast;
    ast = calloc(1, sizeof(ast_node));
    ast->sc = malloc(sizeof(scope));
    ast->tok = tok;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x1090
movq %rax, -0x10(%rbp)
movl $0x18, %edi
callq 0x10c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_assign.c
// Function: init_ast_node_assign
ast_node_assign* init_ast_node_assign(token* tok, ast_node* left, ast_node* right) {
    ast_node_assign* ast;
    ast = calloc(1, sizeof(ast_node_assign));
    ast->tok = tok;
    ast->left = left;
    ast->right = right;
    ast->base.type = AST_TYPE_ASSIGN;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x1090
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x10, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_binop.c
// Function: init_ast_node_binop
ast_node_binop* init_ast_node_binop(token* tok, ast_node* left, ast_node* right) {
    ast_node_binop* ast;
    ast = calloc(1, sizeof(ast_node_binop));
    ast->tok = tok;
    ast->value = malloc(sizeof(char*));
    ast->left = left;
    ast->right = right;
    ast->base.type = AST_TYPE_BINOP;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x1090
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x8, %edi
callq 0x10c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_char.c
// Function: init_ast_node_char
ast_node_char* init_ast_node_char(token* tok, char value) {
    ast_node_char* ast;
    ast = calloc(1, sizeof(ast_node_char));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_CHAR;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x1090
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_component.c
// Function: init_ast_node_component
ast_node_component* init_ast_node_component(token* tok, token* name, ast_node_compound* body, ss_vector* deps) {
    ast_node_component* ast;
    ast = calloc(1, sizeof(ast_node_component));
    ast->tok = tok;
    ast->name = name;
    ast->body = body;
    ast->deps = deps;
    ast->base.type = AST_TYPE_COMPONENT;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x1090
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0x8, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_compound.c
// Function: init_ast_node_compound
ast_node_compound* init_ast_node_compound(token* tok, ss_vector* nodes) {
    ast_node_compound* ast;
    ast = calloc(1, sizeof(ast_node_compound));
    ast->tok = tok;
    ast->nodes = nodes;
    ast->base.type = AST_TYPE_COMPOUND;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x1090
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x7, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_empty.c
// Function: init_ast_node_empty
ast_node_empty* init_ast_node_empty(token* tok) {
    ast_node_empty* ast;
    ast = calloc(1, sizeof(ast_node_empty));
    ast->tok = tok;
    ast->base.type = AST_TYPE_EMPTY;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x1090
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_float.c
// Function: init_ast_node_float
ast_node_float* init_ast_node_float(token* tok, float value) {
    ast_node_float* ast;
    ast = calloc(1, sizeof(ast_node_float));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_FLOAT;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x1090
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_function_definition.c
// Function: init_ast_node_function_definition
ast_node_function_definition* init_ast_node_function_definition(
    token* tok,
    int data_type,
    ss_vector* args,
    ast_node_compound* body
) {
    ast_node_function_definition* ast;
    ast = calloc(1, sizeof(ast_node_function_definition));
    ast->tok = tok;
    ast->data_type = data_type;
    ast->args = args;
    ast->body = body;
    ast->base.type = AST_TYPE_FUNCTION_DEFINITION;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, %edi
movl $0x40, %esi
callq 0x1090
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0xc, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_integer.c
// Function: init_ast_node_integer
ast_node_integer* init_ast_node_integer(token* tok, int value) {
    ast_node_integer* ast;
    ast = calloc(1, sizeof(ast_node_integer));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_INTEGER;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x1090
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/ast_node_variable_definition.c
// Function: init_ast_node_variable_definition
ast_node_variable_definition* init_ast_node_variable_definition(token* tok, int data_type, ast_node* value) {
    ast_node_variable_definition* ast;
    ast = calloc(1, sizeof(ast_node_variable_definition));
    ast->tok = tok;
    ast->data_type = data_type;
    ast->value = value;
    ast->base.type = AST_TYPE_VARIABLE_DEFINITION;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x1090
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0xb, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sebbekarlsson[P]cola/src/data_type_utils.c
// Function: name_to_data_type
int name_to_data_type(char* name) {
    if (strcmp(name, "int") == 0) {
        return _DATA_TYPE_INTEGER;
    } else if (strcmp(name, "float") == 0) {
        return _DATA_TYPE_FLOAT;
    } else if (strcmp(name, "void") == 0) {
        return _DATA_TYPE_VOID;
    } else if (strcmp(name, "char") == 0) {
        return _DATA_TYPE_CHAR;
    } else if (strcmp(name, "string") == 0) {
        return _DATA_TYPE_STRING;
    } else if (strcmp(name, "vector") == 0) {
        return _DATA_TYPE_VECTOR;
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x550f(%rip), %rsi      # 0x7036
callq 0x10a0
cmpl $0x0, %eax
jne 0x1b3d
movl $0x29, -0x4(%rbp)
jmp 0x1bda
movq -0x10(%rbp), %rdi
leaq 0x54bc(%rip), %rsi      # 0x7004
callq 0x10a0
cmpl $0x0, %eax
jne 0x1b5b
movl $0x2a, -0x4(%rbp)
jmp 0x1bda
movq -0x10(%rbp), %rdi
leaq 0x54a4(%rip), %rsi      # 0x700a
callq 0x10a0
cmpl $0x0, %eax
jne 0x1b79
movl $0x2b, -0x4(%rbp)
jmp 0x1bda
movq -0x10(%rbp), %rdi
leaq 0x548b(%rip), %rsi      # 0x700f
callq 0x10a0
cmpl $0x0, %eax
jne 0x1b97
movl $0x28, -0x4(%rbp)
jmp 0x1bda
movq -0x10(%rbp), %rdi
leaq 0x5472(%rip), %rsi      # 0x7014
callq 0x10a0
cmpl $0x0, %eax
jne 0x1bb5
movl $0x2d, -0x4(%rbp)
jmp 0x1bda
movq -0x10(%rbp), %rdi
leaq 0x545b(%rip), %rsi      # 0x701b
callq 0x10a0
cmpl $0x0, %eax
jne 0x1bd3
movl $0x2e, -0x4(%rbp)
jmp 0x1bda
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)