LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: maxn
static int maxn (lua_State *L) {
  lua_Number max = 0;
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushnil(L);  /* first key */
  while (lua_next(L, 1)) {
    lua_pop(L, 1);  /* remove value */
    if (lua_type(L, -1) == LUA_TNUMBER) {
      lua_Number v = lua_tonumber(L, -1);
      if (v > max) max = v;
    }
  }
  lua_pushnumber(L, max);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xf800
movq %rbx, %rdi
callq 0x57d9
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
pushq $-0x2
popq %r14
pushq $-0x1
popq %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6175
testl %eax, %eax
je 0x16241
movq %rbx, %rdi
movl %r14d, %esi
callq 0x51fc
movq %rbx, %rdi
movl %r15d, %esi
callq 0x543c
cmpl $0x3, %eax
jne 0x16201
movq %rbx, %rdi
movl %r15d, %esi
callq 0x55e3
maxsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x16201
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x57ea
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: tinsert
static int tinsert (lua_State *L) {
  int e = aux_getn(L, 1) + 1;  /* first empty element */
  int pos;  /* where to insert new element */
  switch (lua_gettop(L)) {
    case 2: {  /* called with only 2 arguments */
      pos = e;  /* insert new element at the end */
      break;
    }
    case 3: {
      int i;
      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
      if (pos > e) e = pos;  /* `grow' array if necessary */
      for (i = e; i > pos; i--) {  /* move up elements */
        lua_rawgeti(L, 1, i-1);
        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
      }
      break;
    }
    default: {
      return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
    }
  }
  luaL_setn(L, 1, e);  /* new size */
  lua_rawseti(L, 1, pos);  /* t[pos] = v */
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xf800
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56d3
movq %rax, %r14
incl %r14d
movq %rbx, %rdi
callq 0x51ef
cmpl $0x2, %eax
je 0x162d9
cmpl $0x3, %eax
jne 0x162f2
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8fe
movq %rax, %r15
cmpl %r15d, %r14d
cmovlel %r15d, %r14d
pushq $0x1
popq %rbp
cmpl %r15d, %r14d
jle 0x162d6
leal -0x1(%r14), %r12d
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x5b2a
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x5d42
movl %r12d, %r14d
jmp 0x162ae
movl %r15d, %r14d
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x5d42
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48e0(%rip), %rsi      # 0x1abd9
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf48b
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: tremove
static int tremove (lua_State *L) {
  int e = aux_getn(L, 1);
  int pos = luaL_optint(L, 2, e);
  if (!(1 <= pos && pos <= e))  /* position is outside bounds? */
   return 0;  /* nothing to remove */
  luaL_setn(L, 1, e - 1);  /* t.n = n-1 */
  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
  for ( ;pos<e; pos++) {
    lua_rawgeti(L, 1, pos+1);
    lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
  }
  lua_pushnil(L);
  lua_rawseti(L, 1, e);  /* t[e] = nil */
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xf800
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56d3
movq %rax, %r14
movslq %r14d, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xf939
movq %rax, %r15
testl %r15d, %r15d
setle %al
cmpl %r12d, %r15d
setg %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x163a3
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x5b2a
cmpl %r15d, %r14d
je 0x1638e
leal 0x1(%r15), %r12d
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x5b2a
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x5d42
movl %r12d, %r15d
jmp 0x16366
movq %rbx, %rdi
callq 0x57d9
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x5d42
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: setn
static int setn (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
#ifndef luaL_setn
  luaL_setn(L, 1, luaL_checkint(L, 2));
#else
  luaL_error(L, LUA_QL("setn") " is obsolete");
#endif
  lua_pushvalue(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xf800
leaq 0x4837(%rip), %rsi      # 0x1abff
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: sort_comp
static int sort_comp (lua_State *L, int a, int b) {
  if (!lua_isnil(L, 2)) {  /* function? */
    int res;
    lua_pushvalue(L, 2);
    lua_pushvalue(L, a-1);  /* -1 to compensate function */
    lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
    lua_call(L, 2, 1);
    res = lua_toboolean(L, -1);
    lua_pop(L, 1);
    return res;
  }
  else  /* a < b? */
    return lua_lessthan(L, a, b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x543c
testl %eax, %eax
je 0x167e2
pushq $0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x541c
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x541c
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5eb4
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5641
movl %eax, %ebp
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5598
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: luaopen_string
LUALIB_API int luaopen_string (lua_State *L) {
  luaL_register(L, LUA_STRLIBNAME, strlib);
#if defined(LUA_COMPAT_GFIND)
  lua_getfield(L, -1, "gmatch");
  lua_setfield(L, -2, "gfind");
#endif
  createmetatable(L);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x48d5(%rip), %rsi      # 0x1b103
leaq 0x1040b(%rip), %rdx     # 0x26c40
callq 0xfa2b
leaq 0x44ab(%rip), %rdx      # 0x1acec
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5aa6
leaq 0x44a0(%rip), %rdx      # 0x1acf3
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c7e
pushq $0x1
popq %r14
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x5b5f
leaq 0x4902(%rip), %rsi      # 0x1b17a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5819
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5db1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
leaq 0x33af(%rip), %rdx      # 0x19c60
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c7e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_byte
static int str_byte (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
  ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
  int n, i;
  if (posi <= 0) posi = 1;
  if ((size_t)pose > l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
  n = (int)(pose -  posi + 1);
  if (posi + n <= pose)  /* overflow? */
    luaL_error(L, "string slice too long");
  luaL_checkstack(L, n, "string slice too long");
  for (i=0; i<n; i++)
    lua_pushinteger(L, uchar(s[posi+i-1]));
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %r13
movq %r13, %rdx
callq 0xf6c0
movq %rax, %r15
pushq $0x2
popq %rsi
pushq $0x1
popq %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0xf939
movq (%r13), %rcx
incq %rcx
movq %rax, %rbp
sarq $0x3f, %rbp
andq %rcx, %rbp
addq %rax, %rbp
xorl %r14d, %r14d
testq %rbp, %rbp
movl $0x0, %edx
cmovgq %rbp, %rdx
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xf939
movq (%r13), %rdx
leaq 0x1(%rdx), %rsi
movq %rax, %rcx
sarq $0x3f, %rcx
andq %rsi, %rcx
addq %rax, %rcx
testq %rcx, %rcx
cmovleq %r14, %rcx
cmpq $0x2, %rbp
cmovlq %r12, %rbp
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
cmpq %rbp, %rcx
jae 0x1696e
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %r14d
subl %ebp, %r14d
incl %r14d
movslq %r14d, %rax
addq %rbp, %rax
cmpq %rcx, %rax
jg 0x16993
leaq 0x439c(%rip), %rsi      # 0x1ad25
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
leaq 0x438b(%rip), %rdx      # 0x1ad25
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf7ca
addq %rbp, %r15
decq %r15
xorl %r12d, %r12d
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
cmpq %r12, %r13
je 0x1695c
movzbl (%r15,%r12), %esi
movq %rbx, %rdi
callq 0x57ff
incq %r12
jmp 0x169bb
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_char
static int str_char (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  for (i=1; i<=n; i++) {
    int c = luaL_checkint(L, i);
    luaL_argcheck(L, uchar(c) == c, i, "invalid value");
    luaL_addchar(&b, uchar(c));
  }
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rdi, %rbx
callq 0x51ef
movl %eax, %r15d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xfd2b
xorl %ebp, %ebp
testl %r15d, %r15d
cmovgl %r15d, %ebp
leaq 0x2018(%rsp), %r14
negl %ebp
pushq $0x1
popq %r15
leaq 0x4324(%rip), %r12      # 0x1ad3b
leal (%r15,%rbp), %eax
cmpl $0x1, %eax
je 0x16a6a
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf8fe
movq %rax, %r13
testl $0xffffff00, %r13d      # imm = 0xFFFFFF00
je 0x16a45
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0xf3d4
movq (%rsp), %rax
cmpq %r14, %rax
jb 0x16a5a
movq %rsp, %rdi
callq 0xfdd0
movq (%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movb %r13b, (%rax)
incl %r15d
jmp 0x16a17
movq %rsp, %rdi
callq 0xfdb2
pushq $0x1
popq %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_dump
static int str_dump (lua_State *L) {
  luaL_Buffer b;
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 1);
  luaL_buffinit(L,&b);
  if (lua_dump(L, writer, &b) != 0)
    luaL_error(L, "unable to dump given function");
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x6
popq %rdx
movl %ebp, %esi
callq 0xf800
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd2b
leaq 0xc56(%rip), %rsi       # 0x17719
movq %rbx, %rdi
movq %r14, %rdx
callq 0x606e
testl %eax, %eax
je 0x16ae3
leaq 0x4270(%rip), %rsi      # 0x1ad49
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
leaq 0x8(%rsp), %rdi
callq 0xfdb2
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_len
static int str_len (lua_State *L) {
  size_t l;
  luaL_checklstring(L, 1, &l);
  lua_pushinteger(L, l);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r14
movl %ebp, %esi
movq %r14, %rdx
callq 0xf6c0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x57ff
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_lower
static int str_lower (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i=0; i<l; i++)
    luaL_addchar(&b, tolower(uchar(s[i])));
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r15
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0xf6c0
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xfd2b
leaq 0x2020(%rsp), %r15
xorl %r12d, %r12d
cmpq (%rsp), %r12
jae 0x174b3
movq 0x8(%rsp), %r13
cmpq %r15, %r13
jb 0x17491
movq %r14, %rdi
callq 0xfdd0
movq 0x8(%rsp), %r13
callq 0x4560
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
movb (%rax,%rcx,4), %al
leaq 0x1(%r13), %rcx
movq %rcx, 0x8(%rsp)
movb %al, (%r13)
incq %r12
jmp 0x17474
leaq 0x8(%rsp), %rdi
callq 0xfdb2
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_rep
static int str_rep (lua_State *L) {
  size_t l;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  int n = luaL_checkint(L, 2);
  luaL_buffinit(L, &b);
  while (n-- > 0)
    luaL_addlstring(&b, s, l);
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %r12
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0xf6c0
movq %rax, %rbx
pushq $0x2
popq %rsi
movq %r12, %rdi
callq 0xf8fe
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xfd2b
testl %r14d, %r14d
jle 0x17531
decl %r14d
movq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xfd3b
jmp 0x17517
leaq 0x10(%rsp), %rdi
callq 0xfdb2
pushq $0x1
popq %rax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_reverse
static int str_reverse (lua_State *L) {
  size_t l;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  while (l--) luaL_addchar(&b, s[l]);
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r15
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0xf6c0
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xfd2b
leaq 0x2020(%rsp), %r15
movq (%rsp), %rax
subq $0x1, %rax
movq %rax, (%rsp)
jb 0x175bb
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
jb 0x175ab
movq %r14, %rdi
callq 0xfdd0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rbx,%rax), %al
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movb %al, (%rcx)
jmp 0x17582
leaq 0x8(%rsp), %rdi
callq 0xfdb2
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_sub
static int str_sub (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
  ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
  if (start < 1) start = 1;
  if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
  if (start <= end)
    lua_pushlstring(L, s+start-1, end-start+1);
  else lua_pushliteral(L, "");
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0xf6c0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8fe
movq (%r15), %rcx
incq %rcx
movq %rax, %r12
sarq $0x3f, %r12
andq %rcx, %r12
addq %rax, %r12
pushq $0x3
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0xf939
movq (%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rax, %rsi
sarq $0x3f, %rsi
andq %rdx, %rsi
addq %rax, %rsi
xorl %edx, %edx
testq %rsi, %rsi
cmovgq %rsi, %rdx
cmpq $0x2, %r12
pushq $0x1
popq %rax
cmovgeq %r12, %rax
cmpq %rcx, %rdx
cmovgeq %rcx, %rdx
subq %rax, %rdx
jge 0x1765f
leaq 0x3b22(%rip), %rsi      # 0x1b17a
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x1766c
leaq (%r14,%rax), %rsi
decq %rsi
incq %rdx
movq %rbx, %rdi
callq 0x5819
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_upper
static int str_upper (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i=0; i<l; i++)
    luaL_addchar(&b, toupper(uchar(s[i])));
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r15
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0xf6c0
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xfd2b
leaq 0x2020(%rsp), %r15
xorl %r12d, %r12d
cmpq (%rsp), %r12
jae 0x176fb
movq 0x8(%rsp), %r13
cmpq %r15, %r13
jb 0x176d9
movq %r14, %rdi
callq 0xfdd0
movq 0x8(%rsp), %r13
callq 0x4030
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
movb (%rax,%rcx,4), %al
leaq 0x1(%r13), %rcx
movq %rcx, 0x8(%rsp)
movb %al, (%r13)
incq %r12
jmp 0x176bc
leaq 0x8(%rsp), %rdi
callq 0xfdb2
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: classend
static const char *classend (MatchState *ms, const char *p) {
  switch (*p++) {
    case L_ESC: {
      if (*p == '\0')
        luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
      return p+1;
    }
    case '[': {
      if (*p == '^') p++;
      do {  /* look for a `]' */
        if (*p == '\0')
          luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
        if (*(p++) == L_ESC && *p != '\0')
          p++;  /* skip escapes (e.g. `%]') */
      } while (*p != ']');
      return p+1;
    }
    default: {
      return p;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1(%rsi), %rbx
movzbl (%rsi), %eax
cmpl $0x5b, %eax
je 0x17e28
cmpl $0x25, %eax
jne 0x17e7b
cmpb $0x0, (%rbx)
jne 0x17e1f
movq 0x10(%r14), %rdi
leaq 0x2fba(%rip), %rsi      # 0x1add2
xorl %eax, %eax
callq 0xf48b
addq $0x2, %r15
movq %r15, %rbx
jmp 0x17e7b
leaq 0x2(%r15), %rax
xorl %ecx, %ecx
cmpb $0x5e, 0x1(%r15)
sete %cl
cmoveq %rax, %rbx
movb 0x1(%rcx,%r15), %al
leaq 0x2faf(%rip), %r15      # 0x1adf5
testb %al, %al
jne 0x17e5a
movq 0x10(%r14), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xf48b
movb (%rbx), %al
leaq 0x1(%rbx), %rcx
cmpb $0x25, %al
jne 0x17e6f
cmpb $0x0, 0x1(%rbx)
je 0x17e6f
addq $0x2, %rbx
movq %rbx, %rcx
movq %rcx, %rbx
movb (%rcx), %al
cmpb $0x5d, %al
jne 0x17e46
incq %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: singlematch
static int singlematch (int c, const char *p, const char *ep) {
  switch (*p) {
    case '.': return 1;  /* matches any char */
    case L_ESC: return match_class(c, uchar(*(p+1)));
    case '[': return matchbracketclass(c, p, ep-1);
    default:  return (uchar(*p) == c);
  }
}

// Assembly:
movzbl (%rsi), %ecx
cmpl $0x5b, %ecx
je 0x17f24
cmpl $0x2e, %ecx
je 0x17f20
cmpl $0x25, %ecx
jne 0x17f2c
movzbl 0x1(%rsi), %esi
jmp 0x17fa9
pushq $0x1
popq %rax
retq
decq %rdx
jmp 0x17e84
xorl %eax, %eax
cmpl %edi, %ecx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: max_expand
static const char *max_expand (MatchState *ms, const char *s,
                                 const char *p, const char *ep) {
  ptrdiff_t i = 0;  /* counts maximum expand for item */
  while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
    i++;
  /* keeps trying to match with the maximum repetitions */
  while (i>=0) {
    const char *res = match(ms, (s+i), ep+1);
    if (res) return res;
    i--;  /* else didn't match; reduce 1 repetition to try again */
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rbp
xorl %r13d, %r13d
leaq (%r14,%r13), %rax
cmpq %rbp, %rax
jae 0x17f72
movzbl (%rax), %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x17f05
testl %eax, %eax
je 0x17f72
incq %r13
jmp 0x17f52
incq %rbx
xorl %r12d, %r12d
testq %r13, %r13
js 0x17f97
leaq (%r14,%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x17967
decq %r13
testq %rax, %rax
je 0x17f78
movq %rax, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x4140
movb -0x1(%rbx,%rax), %cl
movw $0x6c, -0x1(%rbx,%rax)
movb %cl, (%rbx,%rax)
movb $0x0, 0x1(%rbx,%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq %rsp, %r14
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
movq %r14, %rdx
callq 0x5665
movq %rax, %r15
movq %rbx, %rdi
movl $0xffffd8ec, %esi       # imm = 0xFFFFD8EC
xorl %edx, %edx
callq 0x5665
movq %rax, %r13
leaq 0x8(%rsp), %rbp
movq %rbx, 0x10(%rbp)
movq %r15, (%rbp)
movq (%r14), %r14
addq %r15, %r14
movq %r14, 0x8(%rbp)
movq %rbx, %rdi
movl $0xffffd8eb, %esi       # imm = 0xFFFFD8EB
callq 0x5612
movq %rax, %r12
addq %r15, %r12
cmpq %r14, %r12
ja 0x1822e
andl $0x0, 0x20(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x17967
testq %rax, %rax
jne 0x18232
incq %r12
movq 0x10(%rsp), %r14
jmp 0x18207
xorl %eax, %eax
jmp 0x18269
movq %rax, %r14
subq %r15, %rax
xorl %esi, %esi
cmpq %r14, %r12
sete %sil
addq %rax, %rsi
movq %rbx, %rdi
callq 0x57ff
movq %rbx, %rdi
movl $0xffffd8eb, %esi       # imm = 0xFFFFD8EB
callq 0x5360
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x17d10
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rax
leaq 0x2b0c(%rip), %rdx      # 0x1af29
pushq $0x1
popq %rsi
callq 0xf754
andq $0x0, (%rax)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4040
testq %rax, %rax
je 0x18483
leaq 0x2d23(%rip), %rdx      # 0x1b172
leaq 0x2d1f(%rip), %rcx      # 0x1b175
movq %r14, %rdi
movq %rax, %rsi
callq 0xfc78
leaq 0x2d11(%rip), %rdx      # 0x1b179
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0xfc78
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x523b
jmp 0x1848e
movq %r14, %rdi
movq %r15, %rsi
callq 0x5870
pushq $-0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x5c7e
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xf800
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5bb0
testl %eax, %eax
jne 0x1854c
pushq $0x1
popq %rbp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x5b5f
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x541c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5db1
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x541c
leaq 0x1700(%rip), %rdx      # 0x19c60
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5c7e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2ad5(%rip), %rsi      # 0x1b05d
leaq 0x2ad3(%rip), %rdx      # 0x1b062
movq %r14, %rcx
xorl %eax, %eax
callq 0x58eb
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5a86
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
testl %eax, %eax
je 0x185c5
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5755
movq %rax, %r15
jmp 0x18634
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x624f
movq %rax, %r15
andq $0x0, (%rax)
leaq 0x293e(%rip), %rdx      # 0x1af29
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5aa6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5db1
leaq 0x2a54(%rip), %rsi      # 0x1b05d
leaq 0x2a52(%rip), %rdx      # 0x1b062
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x58eb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x5c57
movq (%r15), %r14
leaq 0x2a2e(%rip), %rsi      # 0x1b06c
pushq $0x3a
popq %rdx
movq %rbx, %rdi
callq 0x5819
testq %r14, %r14
je 0x18652
pushq $0x2
jmp 0x18658
andq $0x0, (%r15)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0xf6c0
movq %rax, %r14
leaq 0x29bb(%rip), %rdx      # 0x1b03a
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x5aa6
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
cmpl $0x5, %eax
je 0x186ad
leaq 0x2a04(%rip), %rsi      # 0x1b0a7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x5aa6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x543c
testl %eax, %eax
jne 0x186df
leaq 0x29f7(%rip), %rsi      # 0x1b0c9
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x58eb
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0xf6c0
leaq 0x28cf(%rip), %rdx      # 0x1afce
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18844
testq %rax, %rax
je 0x1872c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10049
testl %eax, %eax
je 0x1872c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x189a6
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0xf6c0
movq %rax, %r15
leaq 0x287a(%rip), %rdx      # 0x1afcd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18844
testq %rax, %rax
je 0x18787
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x189ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18574
movq %rbx, %rdi
movq %r14, %rsi
callq 0x189a6
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x1
popq %rbx
movl %ebx, %esi
xorl %edx, %edx
callq 0xf6c0
movq %rax, %r15
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0x4160
testq %rax, %rax
je 0x18835
subq %r15, %rax
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5819
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5665
leaq 0x27eb(%rip), %rdx      # 0x1afcd
movq %r14, %rdi
movq %rax, %rsi
callq 0x18844
testq %rax, %rax
je 0x18832
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x189ea
movq %r14, %rdi
movq %r12, %rsi
callq 0x18574
cmpl $0x2, %eax
je 0x1881b
movq %r14, %rdi
movq %r12, %rsi
callq 0x189a6
leaq 0x2932(%rip), %rsi      # 0x1b154
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x58eb
movl %ebx, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x1fa9(%rip), %rdx      # 0x1a805
leaq 0x2887(%rip), %rcx      # 0x1b0ea
callq 0xfc78
movq %rax, %r14
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movq %r15, %rdx
callq 0x5aa6
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5665
movq %rax, %r12
testq %rax, %rax
jne 0x188a4
leaq 0x2855(%rip), %rsi      # 0x1b0ec
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xf48b
leaq 0x28cf(%rip), %rsi      # 0x1b17a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5819
pushq $-0x2
popq %r13
leaq 0x25f4(%rip), %r15      # 0x1aeb4
movzbl (%r12), %eax
cmpl $0x3b, %eax
je 0x1897f
testl %eax, %eax
je 0x18987
movq %r12, %rdi
pushq $0x3b
popq %rsi
callq 0x4160
movq %rax, %rbp
testq %rax, %rax
jne 0x188f7
movq %r12, %rdi
callq 0x4140
movq %rax, %rbp
addq %r12, %rbp
movq %rbp, %rdx
subq %r12, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5819
testq %rbp, %rbp
je 0x18987
movq %rbx, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x5665
movq %rbx, %rdi
movq %rax, %rsi
leaq 0x1f11(%rip), %rdx      # 0x1a838
movq %r14, %rcx
callq 0xfc78
movq %rax, %r12
movq %rbx, %rdi
movl %r13d, %esi
callq 0x523b
movq %r12, %rdi
movq %r15, %rsi
callq 0x4420
testq %rax, %rax
jne 0x1898c
movq %rbx, %rdi
leaq 0x27b3(%rip), %rsi      # 0x1b10a
movq %r12, %rdx
xorl %eax, %eax
callq 0x58eb
movq %rbx, %rdi
movl %r13d, %esi
callq 0x523b
movq %rbx, %rdi
pushq $0x2
popq %rsi
callq 0x61ac
movq %rbp, %r12
jmp 0x188c0
incq %r12
jmp 0x188c0
xorl %r12d, %r12d
jmp 0x18994
movq %rax, %rdi
callq 0x4130
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2d
popq %rsi
movq %r14, %rdi
callq 0x4160
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %r14, %rsi
leaq 0x1df4(%rip), %rdx      # 0x1a805
leaq 0x272f(%rip), %rcx      # 0x1b147
movq %rbx, %rdi
callq 0xfc78
leaq 0x2722(%rip), %rsi      # 0x1b149
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x58eb
pushq $-0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x523b
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x18
popq %r14
movq %r14, %rsi
callq 0x10b0
movq %rax, %r15
movq %r14, %rdi
callq 0x10e0
movq %rax, 0x10(%r15)
movq %rbx, 0x8(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x10b0
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movl $0x10, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x10b0
movq %rax, %r12
movq %r15, 0x18(%rax)
pushq $0x8
popq %rdi
callq 0x10e0
movq %rax, 0x20(%r12)
movq %r14, 0x28(%r12)
movq %rbx, 0x30(%r12)
movl $0x1, (%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10b0
movq %r14, 0x18(%rax)
movb %bl, 0x20(%rax)
movl $0x6, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x10b0
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0x8, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0x7, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x10b0
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movss %xmm0, -0xc(%rbp)
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10b0
movq %rbx, 0x18(%rax)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x20(%rax)
movl $0x4, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/ast_node_foreach.c
// Function: init_ast_node_foreach
ast_node_foreach* init_ast_node_foreach(
    token* tok,
    ast_node* iterable,
    token* value_name,
    ast_node_compound* body
) {
    ast_node_foreach* ast;
    ast = calloc(1, sizeof(ast_node_foreach));
    ast->tok = tok;
    ast->iterable = iterable;
    ast->value_name = value_name;
    ast->body = body;
    ast->base.type = AST_TYPE_FOREACH;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x10b0
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0x12, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/ast_node_function_call.c
// Function: init_ast_node_function_call
ast_node_function_call* init_ast_node_function_call(token* tok, ss_vector* args) {
    ast_node_function_call* ast;
    ast = calloc(1, sizeof(ast_node_function_call));
    ast->tok = tok;
    ast->args = args;
    ast->base.type = AST_TYPE_FUNCTION_CALL;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0xa, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x10b0
movq %r12, 0x18(%rax)
movl %r15d, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0xc, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/ast_node_if.c
// Function: init_ast_node_if
ast_node_if* init_ast_node_if(token* tok, ast_node* expr, ast_node_compound* body, ast_node_else* elsenode) {
    ast_node_if* ast;
    ast = calloc(1, sizeof(ast_node_if));
    ast->tok = tok;
    ast->expr = expr;
    ast->body = body;
    ast->elsenode = elsenode;
    ast->base.type = AST_TYPE_IF;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x10b0
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0xe, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10b0
movq %r14, 0x18(%rax)
movl %ebx, 0x20(%rax)
movl $0x3, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/ast_node_return.c
// Function: init_ast_node_return
ast_node_return* init_ast_node_return(token* tok, ast_node* value) {
    ast_node_return* ast;
    ast = calloc(1, sizeof(ast_node_return));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_RETURN;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0x13, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/ast_node_string.c
// Function: init_ast_node_string
ast_node_string* init_ast_node_string(token* tok, char* value) {
    ast_node_string* ast;
    ast = calloc(1, sizeof(ast_node_string));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_STRING;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0x5, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/ast_node_unaryop.c
// Function: init_ast_node_unaryop
ast_node_unaryop* init_ast_node_unaryop(token* tok, ast_node* right) {
    ast_node_unaryop* ast;
    ast = calloc(1, sizeof(ast_node_unaryop));
    ast->tok = tok;
    ast->right = right;
    ast->base.type = AST_TYPE_UNARYOP;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0x2, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop