LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lzio.c
// Function: luaZ_read
size_t luaZ_read (ZIO *z, void *b, size_t n) {
  while (n) {
    size_t m;
    if (luaZ_lookahead(z) == EOZ)
      return n;  /* return number of missing bytes */
    m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
    memcpy(b, z->p, m);
    z->n -= m;
    z->p += m;
    b = (char *)b + m;
    n -= m;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x107bc
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %r15, %rdi
callq 0x10727
cmpl $-0x1, %eax
je 0x107be
movq (%r15), %r12
movq 0x8(%r15), %rsi
cmpq %r12, %rbx
cmovbq %rbx, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x4300
subq %r12, (%r15)
addq %r12, 0x8(%r15)
addq %r12, %r14
subq %r12, %rbx
jne 0x10787
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_argerror
LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
  lua_Debug ar;
  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
  lua_getinfo(L, "n", &ar);
  if (strcmp(ar.namewhat, "method") == 0) {
    narg--;  /* do not count `self' */
    if (narg == 0)  /* error is in the self argument itself? */
      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
                           ar.name, extramsg);
  }
  if (ar.name == NULL)
    ar.name = "?";
  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
                        narg, ar.name, extramsg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %rdx
xorl %esi, %esi
callq 0x6851
testl %eax, %eax
je 0x1089b
leaq 0xb41b(%rip), %rsi      # 0x1bc62
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x69ca
movq 0x10(%r15), %rdi
leaq 0xacd9(%rip), %rsi      # 0x1b539
callq 0x4290
testl %eax, %eax
jne 0x1086d
decl %ebp
je 0x108bc
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
jne 0x10883
leaq 0xbffa(%rip), %rcx      # 0x1c878
movq %rcx, 0x8(%rsp)
leaq 0xb6d5(%rip), %rsi      # 0x1bf5f
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0x108d7
jmp 0x108b1
leaq 0xb689(%rip), %rsi      # 0x1bf2b
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x108d7
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdx
leaq 0xb679(%rip), %rsi      # 0x1bf41
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x108d7
jmp 0x108b1
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_newmetatable
LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
  lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get registry.name */
  if (!lua_isnil(L, -1))  /* name already in use? */
    return 0;  /* leave previous value on top, but return 0 */
  lua_pop(L, 1);
  lua_newtable(L);  /* create metatable */
  lua_pushvalue(L, -1);
  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %rbx, %rdx
callq 0x5eef
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x10bc5
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5fa8
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x582a
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %rbx, %rdx
callq 0x60cb
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_checkudata
LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
  void *p = lua_touserdata(L, ud);
  if (p != NULL) {  /* value is a userdata? */
    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
        lua_pop(L, 2);  /* remove both metatables */
        return p;
      }
    }
  }
  luaL_typerror(L, ud, tname);  /* else error */
  return NULL;  /* to avoid warnings */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x5b7b
testq %rax, %rax
je 0x10c2c
movq %rax, %rbx
movq %r15, %rdi
movl %ebp, %esi
callq 0x5ff9
testl %eax, %eax
je 0x10c2c
movq %r15, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r14, %rdx
callq 0x5eef
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x5916
testl %eax, %eax
je 0x10c2c
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x54e9
jmp 0x10c3b
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x10993
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_checknumber
LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
  lua_Number d = lua_tonumber(L, narg);
  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x5a04
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10d37
jp 0x10d37
movq %r14, %rdi
movl %ebx, %esi
movsd %xmm0, (%rsp)
callq 0x58a3
movsd (%rsp), %xmm0
testl %eax, %eax
jne 0x10d37
movq %r14, %rdi
movl $0x3, %esi
callq 0x5868
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x10993
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_checkinteger
LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
  lua_Integer d = lua_tointeger(L, narg);
  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
callq 0x5a33
movq %rax, %r14
testq %rax, %rax
jne 0x10db3
movq %r15, %rdi
movl %ebx, %esi
callq 0x58a3
testl %eax, %eax
jne 0x10db3
movq %r15, %rdi
movl $0x3, %esi
callq 0x5868
movq %r15, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x10993
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_callmeta
LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
  obj = abs_index(L, obj);
  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
    return 0;
  lua_pushvalue(L, obj);
  lua_call(L, 1, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
leal -0x1(%r14), %eax
cmpl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
jb 0x10e78
movq %rbx, %rdi
callq 0x54dc
addl %eax, %r14d
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x10dea
testl %eax, %eax
je 0x10eae
movq %rbx, %rdi
movl %r14d, %esi
callq 0x582a
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x6305
jmp 0x10eb0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_openlib
LUALIB_API void luaI_openlib (lua_State *L, const char *libname,
                              const luaL_Reg *l, int nup) {
  if (libname) {
    int size = libsize(l);
    /* check whether lib already exists */
    luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);
    lua_getfield(L, -1, libname);  /* get _LOADED[libname] */
    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, libname, size) != NULL)
        luaL_error(L, "name conflict for module " LUA_QS, libname);
      lua_pushvalue(L, -1);
      lua_setfield(L, -3, libname);  /* _LOADED[libname] = new table */
    }
    lua_remove(L, -2);  /* remove _LOADED table */
    lua_insert(L, -(nup+1));  /* move library table to below upvalues */
  }
  for (; l->name; l++) {
    int i;
    for (i=0; i<nup; i++)  /* copy upvalues to the top */
      lua_pushvalue(L, -nup);
    lua_pushcclosure(L, l->func, nup);
    lua_setfield(L, -(nup+2), l->name);
  }
  lua_pop(L, nup);  /* remove upvalues */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %r14
movl %ecx, %ebx
notl %ebx
testq %rsi, %rsi
je 0x10fae
movq %rsi, %r12
cmpq $0x0, (%r15)
je 0x10f03
leaq 0x10(%r15), %rax
xorl %r13d, %r13d
incl %r13d
cmpq $0x0, (%rax)
leaq 0x10(%rax), %rax
jne 0x10ef4
jmp 0x10f06
xorl %r13d, %r13d
leaq 0xb0c6(%rip), %rdx      # 0x1bfd3
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movl $0x1, %ecx
callq 0x1101d
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r12, %rdx
callq 0x5eef
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
cmpl $0x5, %eax
je 0x10f97
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
movq %r14, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r12, %rdx
movl %r13d, %ecx
callq 0x1101d
testq %rax, %rax
je 0x10f7a
leaq 0xb06e(%rip), %rsi      # 0x1bfdb
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x108d7
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x582a
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movq %r12, %rdx
callq 0x60cb
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5640
movq %r14, %rdi
movl %ebx, %esi
callq 0x572e
movl %ebx, 0x4(%rsp)
cmpq $0x0, (%r15)
je 0x11003
movl %ebp, %r12d
negl %r12d
movl $0xfffffffe, %r13d      # imm = 0xFFFFFFFE
subl %ebp, %r13d
testl %ebp, %ebp
jle 0x10fdc
movl %ebp, %ebx
movq %r14, %rdi
movl %r12d, %esi
callq 0x582a
decl %ebx
jne 0x10fcd
movq 0x8(%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x5ddf
movq (%r15), %rdx
movq %r14, %rdi
movl %r13d, %esi
callq 0x60cb
cmpq $0x0, 0x10(%r15)
leaq 0x10(%r15), %r15
jne 0x10fc7
movq %r14, %rdi
movl 0x4(%rsp), %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x54e9
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_findtable
LUALIB_API const char *luaL_findtable (lua_State *L, int idx,
                                       const char *fname, int szhint) {
  const char *e;
  lua_pushvalue(L, idx);
  do {
    e = strchr(fname, '.');
    if (e == NULL) e = fname + strlen(fname);
    lua_pushlstring(L, fname, e - fname);
    lua_rawget(L, -2);
    if (lua_isnil(L, -1)) {  /* no such field? */
      lua_pop(L, 1);  /* remove this nil */
      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
      lua_pushlstring(L, fname, e - fname);
      lua_pushvalue(L, -2);
      lua_settable(L, -4);  /* set new table into field */
    }
    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */
      lua_pop(L, 2);  /* remove table and value */
      return fname;  /* return problematic part of the name */
    }
    lua_remove(L, -2);  /* remove previous table */
    fname = e + 1;
  } while (*e == '.');
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r14
callq 0x582a
movl $0x1, %ebp
movq %r15, %rdi
movl $0x2e, %esi
callq 0x4160
movq %rax, %r12
testq %rax, %rax
jne 0x1105d
movq %r15, %rdi
callq 0x4140
movq %rax, %r12
addq %r15, %r12
movq %r12, %r13
subq %r15, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5c5a
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5f47
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
movq %r14, %rdi
testl %eax, %eax
je 0x110a3
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
cmpl $0x5, %eax
je 0x110e9
jmp 0x1110b
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
cmpb $0x2e, (%r12)
movl %ebx, %edx
cmovel %ebp, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x5fa8
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5c5a
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x582a
movq %r14, %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x60a4
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5640
leaq 0x1(%r12), %r15
cmpb $0x2e, (%r12)
je 0x1103a
xorl %r15d, %r15d
jmp 0x11118
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x54e9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: emptybuffer
static int emptybuffer (luaL_Buffer *B) {
  size_t l = bufflen(B);
  if (l == 0) return 0;  /* put nothing on stack */
  else {
    lua_pushlstring(B->L, B->buffer, l);
    B->p = B->buffer;
    B->lvl++;
    return 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rdx
leaq 0x18(%rdi), %r14
subq %r14, %rdx
je 0x1131a
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %r14, %rsi
callq 0x5c5a
movq %r14, (%rbx)
incl 0x8(%rbx)
movl $0x1, %eax
jmp 0x1131c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: adjuststack
static void adjuststack (luaL_Buffer *B) {
  if (B->lvl > 1) {
    lua_State *L = B->L;
    int toget = 1;  /* number of levels to concat */
    size_t toplen = lua_strlen(L, -1);
    do {
      size_t l = lua_strlen(L, -(toget+1));
      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
        toplen += l;
        toget++;
      }
      else break;
    } while (toget < B->lvl);
    lua_concat(L, toget);
    B->lvl = B->lvl - toget + 1;
  }
}

// Assembly:
cmpl $0x2, 0x8(%rdi)
jl 0x113c5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5af9
movq %rax, %r15
xorl %r13d, %r13d
movl %ebp, %r12d
leal -0x1(%r12), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x5af9
movl 0x8(%rbx), %edx
addl %edx, %r12d
cmpl $0x9, %r12d
setge %sil
cmpq %rax, %r15
seta %cl
orb %sil, %cl
leal 0x1(%r13), %r12d
cmpb $0x1, %cl
jne 0x11399
addl $0x2, %r13d
addq %rax, %r15
cmpl %edx, %r13d
movl %r12d, %r13d
jl 0x11358
negl %ebp
testb %cl, %cl
cmovnel %ebp, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x65fa
movl 0x8(%rbx), %eax
subl %r12d, %eax
incl %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_addvalue
LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
  lua_State *L = B->L;
  size_t vl;
  const char *s = lua_tolstring(L, -1, &vl);
  if (vl <= bufffree(B)) {  /* fit into buffer? */
    memcpy(B->p, s, vl);  /* put it there */
    B->p += vl;
    lua_pop(L, 1);  /* remove from stack */
  }
  else {
    if (emptybuffer(B))
      lua_insert(L, -2);  /* put buffer before new value */
    B->lvl++;  /* add new value into B stack */
    adjuststack(B);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x5a88
movq (%r15), %rdx
movq (%rbx), %rdi
movq %rbx, %rcx
subq %rdi, %rcx
addq $0x2018, %rcx           # imm = 0x2018
cmpq %rcx, %rdx
jbe 0x11429
movq %rbx, %rdi
callq 0x112ee
testl %eax, %eax
je 0x1141c
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x572e
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0x11324
jmp 0x11446
movq %rax, %rsi
callq 0x4300
movq 0x8(%rsp), %rax
addq %rax, (%rbx)
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_ref
LUALIB_API int luaL_ref (lua_State *L, int t) {
  int ref;
  t = abs_index(L, t);
  if (lua_isnil(L, -1)) {
    lua_pop(L, 1);  /* remove from stack */
    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
  }
  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */
  lua_pop(L, 1);  /* remove it from stack */
  if (ref != 0) {  /* any free element? */
    lua_rawgeti(L, t, ref);  /* remove it from list */
    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
  }
  else {  /* no free elements */
    ref = (int)lua_objlen(L, t);
    ref++;  /* create new reference */
  }
  lua_rawseti(L, t, ref);
  return ref;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal -0x1(%r14), %eax
cmpl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
jb 0x11474
movq %rbx, %rdi
callq 0x54dc
addl %eax, %r14d
incl %r14d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
testl %eax, %eax
je 0x114d7
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x5f73
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a33
movq %rax, %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
movq %rbx, %rdi
movl %r14d, %esi
testl %r15d, %r15d
je 0x114e6
movl %r15d, %edx
callq 0x5f73
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x618f
jmp 0x114f1
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
jmp 0x114ff
callq 0x5af9
movq %rax, %r15
incl %r15d
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x618f
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_unref
LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
  if (ref >= 0) {
    t = abs_index(L, t);
    lua_rawgeti(L, t, FREELIST_REF);
    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
    lua_pushinteger(L, ref);
    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
  }
}

// Assembly:
testl %edx, %edx
js 0x1155f
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %eax
cmpl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
jb 0x1152d
movq %r14, %rdi
callq 0x54dc
addl %eax, %ebx
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x5f73
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x618f
movl %ebp, %esi
movq %r14, %rdi
callq 0x5c40
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x618f
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: getF
static const char *getF (lua_State *L, void *ud, size_t *size) {
  LoadF *lf = (LoadF *)ud;
  (void)L;
  if (lf->extraline) {
    lf->extraline = 0;
    *size = 1;
    return "\n";
  }
  if (feof(lf->f)) return NULL;
  *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);
  return (*size > 0) ? lf->buff : NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpl $0x0, (%rsi)
je 0x1179c
movl $0x0, (%rbx)
movq $0x1, (%r14)
leaq 0xa8ae(%rip), %rbx      # 0x1c048
jmp 0x117d1
movq 0x8(%rbx), %rdi
callq 0x42e0
testl %eax, %eax
je 0x117ad
xorl %ebx, %ebx
jmp 0x117d1
movq 0x8(%rbx), %rcx
addq $0x10, %rbx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %rbx, %rdi
callq 0x40d0
movq %rax, (%r14)
testq %rax, %rax
cmoveq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: luaL_loadbuffer
LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
                                const char *name) {
  LoadS ls;
  ls.s = buff;
  ls.size = size;
  return lua_load(L, getS, &ls, name);
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0xd(%rip), %rsi         # 0x11800
movq %rax, %rdx
callq 0x6477
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: l_alloc
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  (void)ud;
  (void)osize;
  if (nsize == 0) {
    free(ptr);
    return NULL;
  }
  else
    return realloc(ptr, nsize);
}

// Assembly:
movq %rsi, %rdi
testq %rcx, %rcx
je 0x11891
movq %rcx, %rsi
jmp 0x43e0
pushq %rax
callq 0x4050
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/linit.c
// Function: luaL_openlibs
LUALIB_API void luaL_openlibs (lua_State *L) {
  const luaL_Reg *lib = lualibs;
  for (; lib->func; lib++) {
    lua_pushcfunction(L, lib->func);
    lua_pushstring(L, lib->name);
    lua_call(L, 1, 0);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x149a5(%rip), %r15     # 0x26250
leaq 0x263a(%rip), %r14      # 0x13eec
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5ddf
movq (%r15), %rsi
movq 0x18(%r15), %r14
movq %rbx, %rdi
callq 0x5cb1
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x6305
addq $0x10, %r15
testq %r14, %r14
jne 0x118b2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_nil
void luaK_nil (FuncState *fs, int from, int n) {
  Instruction *previous;
  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
    if (fs->pc == 0) {  /* function start? */
      if (from >= fs->nactvar)
        return;  /* positions are already clean */
    }
    else {
      previous = &fs->f->code[fs->pc-1];
      if (GET_OPCODE(*previous) == OP_LOADNIL) {
        int pfrom = GETARG_A(*previous);
        int pto = GETARG_B(*previous);
        if (pfrom <= from && from <= pto+1) {  /* can connect both? */
          if (from+n-1 > pto)
            SETARG_B(*previous, from+n-1);
          return;
        }
      }
    }
  }
  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
}

// Assembly:
movslq 0x30(%rdi), %rax
cmpl 0x34(%rdi), %eax
jle 0x1195f
testl %eax, %eax
je 0x11957
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movl -0x4(%rcx,%rax,4), %r8d
movl %r8d, %r9d
andl $0x3f, %r9d
cmpl $0x3, %r9d
jne 0x1195f
movl %r8d, %r9d
shrl $0x6, %r9d
movzbl %r9b, %r10d
movl %r8d, %r9d
shrl $0x17, %r9d
cmpl %esi, %r10d
setg %r10b
leal 0x1(%r9), %r11d
cmpl %esi, %r11d
setl %r11b
orb %r10b, %r11b
jne 0x1195f
addl %esi, %edx
decl %edx
cmpl %r9d, %edx
jle 0x11982
andl $0x7fffc3, %r8d         # imm = 0x7FFFC3
shll $0x17, %edx
orl %r8d, %edx
movl %edx, -0x4(%rcx,%rax,4)
jmp 0x11982
movzbl 0x4a(%rdi), %eax
cmpl %esi, %eax
jle 0x11982
addl %esi, %edx
shll $0x6, %esi
shll $0x17, %edx
addl $0xff800000, %edx       # imm = 0xFF800000
orl %esi, %edx
orl $0x3, %edx
movq 0x18(%rdi), %rax
movl 0x8(%rax), %eax
movl %edx, %esi
movl %eax, %edx
jmp 0x12ba4
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_dischargevars
void luaK_dischargevars (FuncState *fs, expdesc *e) {
  switch (e->k) {
    case VLOCAL: {
      e->k = VNONRELOC;
      break;
    }
    case VUPVAL: {
      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    case VGLOBAL: {
      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
      e->k = VRELOCABLE;
      break;
    }
    case VINDEXED: {
      freereg(fs, e->u.s.aux);
      freereg(fs, e->u.s.info);
      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
      e->k = VRELOCABLE;
      break;
    }
    case VVARARG:
    case VCALL: {
      luaK_setoneret(fs, e);
      break;
    }
    default: break;  /* there is one value available (somewhere) */
  }
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x8, %eax
ja 0x11f4f
movq %rsi, %rbx
leaq 0xa187(%rip), %rcx      # 0x1c058
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rsi
popq %rbx
jmp 0x11e6b
movl 0x8(%rbx), %esi
shll $0xe, %esi
orl $0x5, %esi
jmp 0x11f3a
movl $0xc, (%rbx)
jmp 0x11f4f
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x4, %esi
jmp 0x11f3a
movl 0xc(%rbx), %eax
btl $0x8, %eax
jb 0x11f15
movzbl 0x4a(%rdi), %ecx
cmpl %ecx, %eax
jl 0x11f15
decl 0x3c(%rdi)
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x11f2c
movzbl 0x4a(%rdi), %ecx
cmpl %ecx, %eax
jl 0x11f2c
decl 0x3c(%rdi)
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %esi
shll $0x17, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x6, %esi
movq 0x18(%rdi), %rax
movl 0x8(%rax), %edx
callq 0x12ba4
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_exp2RK
int luaK_exp2RK (FuncState *fs, expdesc *e) {
  luaK_exp2val(fs, e);
  switch (e->k) {
    case VKNUM:
    case VTRUE:
    case VFALSE:
    case VNIL: {
      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
                                        boolK(fs, (e->k == VTRUE));
        e->k = VK;
        return RKASK(e->u.s.info);
      }
      else break;
    }
    case VK: {
      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
        return RKASK(e->u.s.info);
      else break;
    }
    default: break;
  }
  /* not a constant in the right range: put it in a register */
  return luaK_exp2anyreg(fs, e);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1212d
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0x12164
cmpl $0x4, %eax
je 0x1219c
cmpl $0x5, %eax
jne 0x121a6
cmpl $0xff, 0x40(%r14)
jg 0x121a6
cmpl $0x5, %eax
je 0x121b8
cmpl $0x1, %eax
jne 0x121cf
leaq 0x18(%rsp), %rdx
movl $0x0, 0x8(%rdx)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
movq %r14, %rdi
jmp 0x121eb
movl 0x8(%rbx), %eax
cmpl $0xff, %eax
jle 0x121f9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x120d8
movsd 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
jmp 0x121e5
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x11be5
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
orl $0x100, %eax            # imm = 0x100
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_storevar
void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
      exp2reg(fs, ex, var->u.s.info);
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
      break;
    }
    case VGLOBAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
      break;
    }
    case VINDEXED: {
      int e = luaK_exp2RK(fs, ex);
      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
      break;
    }
    default: {
      lua_assert(0);  /* invalid var kind to store */
      break;
    }
  }
  freeexp(fs, ex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x3, %eax
ja 0x122cd
movq %rsi, %r15
leaq 0x9e53(%rip), %rcx      # 0x1c07c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0xc, (%r14)
jne 0x1224d
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x1224d
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x1224d
decl 0x3c(%rbx)
movl 0x8(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x11fa2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x120d8
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x7, %esi
jmp 0x122be
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1213e
movl %eax, %esi
movl 0x8(%r15), %eax
movl 0xc(%r15), %ecx
shll $0x6, %eax
shll $0x17, %ecx
shll $0xe, %esi
orl %eax, %esi
orl %ecx, %esi
orl $0x9, %esi
jmp 0x122be
movq %rbx, %rdi
movq %r14, %rsi
callq 0x120d8
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
orl $0x8, %esi
movq 0x18(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
callq 0x12ba4
cmpl $0xc, (%r14)
jne 0x122e8
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x122e8
movzbl 0x4a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x122e8
decl 0x3c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_self
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  int func;
  luaK_exp2anyreg(fs, e);
  freeexp(fs, e);
  func = fs->freereg;
  luaK_reserveregs(fs, 2);
  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
  freeexp(fs, key);
  e->u.s.info = func;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x120d8
cmpl $0xc, (%rbx)
jne 0x1231f
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x1231f
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %eax
jl 0x1231f
decl 0x3c(%r14)
movl 0x3c(%r14), %r12d
movq %r14, %rdi
movl $0x2, %esi
callq 0x11b6e
addl $0x2, 0x3c(%r14)
movl 0x8(%rbx), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x1213e
movl %r12d, %ecx
shll $0x6, %ecx
shll $0x17, %ebp
orl %ecx, %ebp
shll $0xe, %eax
orl %eax, %ebp
orl $0xb, %ebp
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x12ba4
cmpl $0xc, (%r15)
jne 0x12384
movl 0x8(%r15), %eax
btl $0x8, %eax
jb 0x12384
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %eax
jl 0x12384
decl 0x3c(%r14)
movl %r12d, 0x8(%rbx)
movl $0xc, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
  expdesc e2;
  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
  switch (op) {
    case OPR_MINUS: {
      if (!isnumeral(e))
        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
      codearith(fs, OP_UNM, e, &e2);
      break;
    }
    case OPR_NOT: codenot(fs, e); break;
    case OPR_LEN: {
      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
      codearith(fs, OP_LEN, e, &e2);
      break;
    }
    default: lua_assert(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq $-0x1, 0x10(%rsp)
movl $0x5, (%rsp)
movq $0x0, 0x8(%rsp)
cmpl $0x2, %esi
je 0x1259f
cmpl $0x1, %esi
je 0x1256c
testl %esi, %esi
jne 0x125bd
cmpl $0x5, (%rbx)
jne 0x12554
cmpl $-0x1, 0x10(%rbx)
jne 0x12554
cmpl $-0x1, 0x14(%rbx)
je 0x1255f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x120d8
movq %rsp, %rcx
movq %r14, %rdi
movl $0x12, %esi
jmp 0x125b5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11eb8
movl (%rbx), %eax
decl %eax
cmpl $0xb, %eax
ja 0x12669
leaq 0x9b01(%rip), %rcx      # 0x1c08c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%rbx)
jmp 0x12669
movq %r14, %rdi
movq %rbx, %rsi
callq 0x120d8
movq %rsp, %rcx
movq %r14, %rdi
movl $0x14, %esi
movq %rbx, %rdx
callq 0x1268f
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x2, (%rbx)
jmp 0x12669
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12e9f
cmpl $0xc, (%rbx)
jne 0x125f6
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x125f6
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %eax
jl 0x125f6
decl 0x3c(%r14)
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x13, %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x12ba4
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
jmp 0x12669
movq (%r14), %rcx
movslq 0x8(%rbx), %rdx
leaq (,%rdx,4), %rax
addq 0x18(%rcx), %rax
testq %rdx, %rdx
jle 0x12646
movl -0x4(%rax), %ecx
movl %ecx, %edx
andl $0x3f, %edx
leaq 0x9250(%rip), %rsi      # 0x1b890
cmpb $0x0, (%rdx,%rsi)
js 0x1264a
movl (%rax), %ecx
jmp 0x1264e
addq $-0x4, %rax
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %eax
movl %esi, 0x14(%rbx)
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x12ed6
movl 0x10(%rbx), %esi
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x12ed6
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: codearith
static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
  if (constfolding(op, e1, e2))
    return;
  else {
    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
    int o1 = luaK_exp2RK(fs, e1);
    if (o1 > o2) {
      freeexp(fs, e1);
      freeexp(fs, e2);
    }
    else {
      freeexp(fs, e2);
      freeexp(fs, e1);
    }
    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
    e1->k = VRELOCABLE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x5, (%rdx)
jne 0x126d3
cmpl $-0x1, 0x10(%rbx)
jne 0x126d3
cmpl $-0x1, 0x14(%rbx)
jne 0x126d3
cmpl $0x5, (%r12)
jne 0x126d3
cmpl $-0x1, 0x10(%r12)
jne 0x126d3
cmpl $-0x1, 0x14(%r12)
je 0x12792
xorl %ebp, %ebp
cmpl $0x12, %r15d
je 0x126ee
cmpl $0x14, %r15d
je 0x126ee
movq %r14, %rdi
movq %r12, %rsi
callq 0x1213e
movl %eax, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1213e
cmpl %ebp, %eax
jle 0x12726
cmpl $0xc, (%rbx)
jne 0x12718
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x12718
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0x12718
decl 0x3c(%r14)
cmpl $0xc, (%r12)
jne 0x12760
movl 0x8(%r12), %ecx
jmp 0x1274d
cmpl $0xc, (%r12)
jne 0x12745
movl 0x8(%r12), %ecx
btl $0x8, %ecx
jb 0x12745
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0x12745
decl 0x3c(%r14)
cmpl $0xc, (%rbx)
jne 0x12760
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x12760
movzbl 0x4a(%r14), %edx
cmpl %edx, %ecx
jl 0x12760
decl 0x3c(%r14)
shll $0x17, %eax
shll $0xe, %ebp
orl %eax, %ebp
orl %r15d, %ebp
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x12ba4
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorpd %xmm0, %xmm0
leal -0xc(%r15), %eax
cmpl $0x8, %eax
ja 0x12807
movsd 0x8(%rbx), %xmm2
movsd 0x8(%r12), %xmm1
leaq 0x990a(%rip), %rcx      # 0x1c0bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
jmp 0x127f9
movapd %xmm2, %xmm0
callq 0x4110
jmp 0x127fd
subsd %xmm1, %xmm2
jmp 0x127f9
xorpd 0x9696(%rip), %xmm2     # 0x1be70
jmp 0x127f9
xorl %ebp, %ebp
jmp 0x126ee
mulsd %xmm1, %xmm2
jmp 0x127f9
ucomisd %xmm0, %xmm1
jne 0x127f5
jnp 0x126e1
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
ucomisd %xmm0, %xmm0
jp 0x126d3
movsd %xmm0, 0x8(%rbx)
jmp 0x12785
ucomisd %xmm0, %xmm1
jne 0x1281d
jnp 0x126e1
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x4480
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x127fd
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_infix
void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
  switch (op) {
    case OPR_AND: {
      luaK_goiftrue(fs, v);
      break;
    }
    case OPR_OR: {
      luaK_goiffalse(fs, v);
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
      break;
    }
    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
    case OPR_MOD: case OPR_POW: {
      if (!isnumeral(v)) luaK_exp2RK(fs, v);
      break;
    }
    default: {
      luaK_exp2RK(fs, v);
      break;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0xe, %esi
ja 0x12882
movl %esi, %eax
leaq 0x987c(%rip), %rcx      # 0x1c0e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x5, (%rbx)
jne 0x12882
cmpl $-0x1, 0x10(%rbx)
jne 0x12882
cmpl $-0x1, 0x14(%rbx)
je 0x1291a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1213e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f51
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12397
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11eb8
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x128f0
cmpl $0x3, %eax
je 0x128f0
cmpl $0xa, %eax
jne 0x128de
movl 0x8(%rbx), %edx
jmp 0x128f0
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x12455
movl %eax, %edx
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x119fe
movl 0x14(%rbx), %edx
movl 0x30(%r14), %eax
movl %eax, 0x34(%r14)
leaq 0x38(%r14), %rsi
movq %r14, %rdi
callq 0x119fe
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_code
static int luaK_code (FuncState *fs, Instruction i, int line) {
  Proto *f = fs->f;
  dischargejpc(fs);  /* `pc' will change */
  /* put new instruction in code array */
  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
                  MAX_INT, "code size overflow");
  f->code[fs->pc] = i;
  /* save corresponding line information */
  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
                  MAX_INT, "code size overflow");
  f->lineinfo[fs->pc] = line;
  return fs->pc++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r15
movl 0x38(%rdi), %esi
movl 0x30(%rdi), %edx
movl $0xff, %ecx
movl %edx, %r8d
callq 0x11a97
movl $0xffffffff, 0x38(%rbx) # imm = 0xFFFFFFFF
movl 0x30(%rbx), %ecx
cmpl 0x50(%r15), %ecx
jge 0x12bdf
movq 0x18(%r15), %rax
jmp 0x12c09
leaq 0x50(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x18(%r15), %rsi
leaq 0x95d4(%rip), %r9       # 0x1c1c6
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xa150
movq %rax, 0x18(%r15)
movl 0x30(%rbx), %ecx
movslq %ecx, %rcx
movl %r14d, (%rax,%rcx,4)
movl 0x30(%rbx), %ecx
cmpl 0x54(%r15), %ecx
jge 0x12c1f
movq 0x28(%r15), %rax
jmp 0x12c49
leaq 0x54(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x28(%r15), %rsi
leaq 0x9594(%rip), %r9       # 0x1c1c6
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xa150
movq %rax, 0x28(%r15)
movl 0x30(%rbx), %ecx
movslq %ecx, %rcx
movl %ebp, (%rax,%rcx,4)
movl 0x30(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_setlist
void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
  lua_assert(tostore != 0);
  if (c <= MAXARG_C)
    luaK_codeABC(fs, OP_SETLIST, base, b, c);
  else {
    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
  }
  fs->freereg = base + 1;  /* free registers with list values */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rdx), %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rsi
sarq $0x24, %rsi
shrq $0x3f, %rax
leal (%rsi,%rax), %ebp
incl %ebp
movl %ecx, %edi
shll $0x17, %edi
movl %ebx, %esi
shll $0x6, %esi
xorl %eax, %eax
cmpl $-0x1, %ecx
cmovnel %edi, %eax
cmpl $0x63ce, %edx           # imm = 0x63CE
jg 0x12cb0
shll $0xe, %ebp
orl %esi, %eax
orl %ebp, %eax
orl $0x22, %eax
movl %eax, %ebp
jmp 0x12cc4
orl %eax, %esi
orl $0x22, %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x12ba4
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x12ba4
incl %ebx
movl %ebx, 0x3c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: discharge2reg
static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: {
      luaK_nil(fs, reg, 1);
      break;
    }
    case VFALSE:  case VTRUE: {
      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
      break;
    }
    case VK: {
      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
      break;
    }
    case VKNUM: {
      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VRELOCABLE: {
      Instruction *pc = &getcode(fs, e);
      SETARG_A(*pc, reg);
      break;
    }
    case VNONRELOC: {
      if (reg != e->u.s.info)
        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
      break;
    }
    default: {
      lua_assert(e->k == VVOID || e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.s.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11eb8
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0x12e32
leaq 0x93df(%rip), %rdx      # 0x1c158
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %ebp, %ecx
shll $0x6, %ecx
cmpl $0x2, %eax
movl $0x800000, %eax         # imm = 0x800000
movl $0x2, %esi
cmovel %eax, %esi
orl %ecx, %esi
orl $0x2, %esi
jmp 0x12e1a
movq (%r14), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rbx), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movzbl %bpl, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
jmp 0x12e29
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0x12e29
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
jmp 0x12e1a
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x118ec
jmp 0x12e29
movl 0x8(%rbx), %esi
movl %ebp, %eax
shll $0x6, %eax
shll $0xe, %esi
jmp 0x12e16
movsd 0x8(%rbx), %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x11be5
movl %ebp, %esi
shll $0x6, %esi
shll $0xe, %eax
orl %eax, %esi
incl %esi
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x12ba4
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_init
void luaX_init (lua_State *L) {
  int i;
  for (i=0; i<NUM_RESERVED; i++) {
    TString *ts = luaS_new(L, luaX_tokens[i]);
    luaS_fix(ts);  /* reserved words are never collected */
    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
    ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb $0x1, %bpl
xorl %r15d, %r15d
leaq 0x133a0(%rip), %r12     # 0x262e0
movq (%r15,%r12), %r14
movq %r14, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd282
orb $0x20, 0x9(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %r15
incb %bpl
cmpq $0xa8, %r15
jne 0x12f40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_token2str
const char *luaX_token2str (LexState *ls, int token) {
  if (token < FIRST_RESERVED) {
    lua_assert(token == cast(unsigned char, token));
    return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
                              luaO_pushfstring(ls->L, "%c", token);
  }
  else
    return luaX_tokens[token-FIRST_RESERVED];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl $0x100, %esi            # imm = 0x100
jg 0x12faa
movq %rdi, %r14
callq 0x4580
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x2, (%rax,%rcx,2)
movq 0x38(%r14), %rdi
jne 0x12fc3
leaq 0x92ca(%rip), %rsi      # 0x1c272
jmp 0x12fca
addl $0xfffffeff, %ebx       # imm = 0xFFFFFEFF
leaq 0x13329(%rip), %rax     # 0x262e0
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x929f(%rip), %rsi      # 0x1c269
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa6eb
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_lexerror
void luaX_lexerror (LexState *ls, const char *msg, int token) {
  char buff[MAXSRC];
  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
  if (token)
    luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
  luaD_throw(ls->L, LUA_ERRSYNTAX);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
addq $0x18, %rsi
movq %rsp, %r12
movl $0x50, %edx
movq %r12, %rdi
callq 0xa76f
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x852c(%rip), %rsi      # 0x1b540
movq %r12, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0xa6eb
testl %r14d, %r14d
je 0x1306b
movq %rax, %r15
movq 0x38(%rbx), %r12
leal -0x11c(%r14), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0x1304c
xorl %esi, %esi
callq 0x13978
movq 0x48(%rbx), %rax
movq (%rax), %rcx
jmp 0x13057
movl %r14d, %esi
callq 0x12f7b
movq %rax, %rcx
leaq 0x9217(%rip), %rsi      # 0x1c275
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa6eb
movq 0x38(%rbx), %rdi
movl $0x3, %esi
callq 0x79b5
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_newstring
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
  lua_State *L = ls->L;
  TString *ts = luaS_newlstr(L, str, l);
  TValue *o = luaH_setstr(L, ls->fs->h, ts);  /* entry for `str' */
  if (ttisnil(o)) {
    setbvalue(o, 1);  /* make sure `str' will not be collected */
    luaC_checkGC(L);
  }
  return ts;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0xd282
movq %rax, %r14
movq 0x30(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xdfe2
cmpl $0x0, 0x8(%rax)
jne 0x130dd
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x130dd
movq %rbx, %rdi
callq 0x93fe
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: save
static void save (LexState *ls, int c) {
  Mbuffer *b = ls->buff;
  if (b->n + 1 > b->buffsize) {
    size_t newsize;
    if (b->buffsize >= MAX_SIZET/2)
      luaX_lexerror(ls, "lexical element too long", 0);
    newsize = b->buffsize * 2;
    luaZ_resizebuffer(ls->L, b, newsize);
  }
  b->buffer[b->n++] = cast(char, c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x48(%rdi), %r12
movq 0x8(%r12), %rcx
movq 0x10(%r12), %rdx
leaq 0x1(%rcx), %rsi
cmpq %rdx, %rsi
jbe 0x139d6
movq %rdi, %r15
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rax, %rdx
jb 0x139c1
leaq 0x88d0(%rip), %rsi      # 0x1c282
movq %r15, %rdi
xorl %edx, %edx
callq 0x12fda
movq 0x10(%r12), %rdx
leaq (%rdx,%rdx), %r14
movq 0x38(%r15), %rdi
cmpq $-0x2, %r14
jne 0x139dc
callq 0xa242
jmp 0x139e8
movq (%r12), %rax
jmp 0x139fa
movq (%r12), %rsi
movq %r14, %rcx
callq 0xa1f6
movq %rax, (%r12)
movq %r14, 0x10(%r12)
movq 0x8(%r12), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x8(%r12)
movb %bl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq