LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltm.c
// Function: luaT_gettmbyobj
const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
  Table *mt;
  switch (ttype(o)) {
    case LUA_TTABLE:
      mt = hvalue(o)->metatable;
      break;
    case LUA_TUSERDATA:
      mt = uvalue(o)->metatable;
      break;
    default:
      mt = G(L)->mt[ttype(o)];
  }
  return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
}

// Assembly:
movslq 0x8(%rsi), %rax
cmpq $0x7, %rax
je 0xd1fe
cmpl $0x5, %eax
jne 0xd207
movq (%rsi), %rax
addq $0x10, %rax
jmp 0xd215
movq 0x20(%rdi), %rcx
leaq (%rcx,%rax,8), %rax
addq $0xe0, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xd233
movq 0x20(%rdi), %rcx
movl %edx, %edx
movq 0x128(%rcx,%rdx,8), %rsi
movq %rax, %rdi
jmp 0xcb97
leaq 0xc406(%rip), %rax      # 0x19640
retq
nop
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lundump.c
// Function: luaU_undump
Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
{
 LoadState S;
 if (*name=='@' || *name=='=')
  S.name=name+1;
 else if (*name==LUA_SIGNATURE[0])
  S.name="binary string";
 else
  S.name=name;
 S.L=L;
 S.Z=Z;
 S.b=buff;
 LoadHeader(&S);
 return LoadFunction(&S,luaS_newliteral(L,"=?"));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movzbl (%rcx), %eax
cmpl $0x1b, %eax
je 0xd261
cmpl $0x40, %eax
je 0xd25c
cmpl $0x3d, %eax
jne 0xd268
incq %rcx
jmp 0xd268
leaq 0xca7c(%rip), %rcx      # 0x19ce4
movq %rsp, %rdi
movq %rcx, 0x18(%rdi)
movq %rbx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
leaq 0x20(%rsp), %r14
movl $0x61754c1b, (%r14)     # imm = 0x61754C1B
movabsq $0x8040804010051, %rax  # imm = 0x8040804010051
movq %rax, 0x4(%r14)
leaq 0x2c(%rsp), %r15
pushq $0xc
popq %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0xd704
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4370
testl %eax, %eax
je 0xd2c9
leaq 0xca34(%rip), %rsi      # 0x19cf5
movq %rsp, %rdi
callq 0xd725
leaq 0xca22(%rip), %rsi      # 0x19cf2
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0xc466
movq %rsp, %rdi
movq %rax, %rsi
callq 0xd2f2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: luaV_tonumber
const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
  lua_Number num;
  if (ttisnumber(obj)) return obj;
  if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {
    setnvalue(n, num);
    return n;
  }
  else
    return NULL;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0xd841
cmpl $0x4, %eax
jne 0xd83d
movq %rsi, %rbx
movq (%rdi), %rdi
addq $0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0x98ad
testl %eax, %eax
je 0xd83d
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movl $0x3, 0x8(%rbx)
jmp 0xd844
xorl %ebx, %ebx
jmp 0xd844
movq %rdi, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: luaV_tostring
int luaV_tostring (lua_State *L, StkId obj) {
  if (!ttisnumber(obj))
    return 0;
  else {
    char s[LUAI_MAXNUMBER2STR];
    lua_Number n = nvalue(obj);
    lua_number2str(s, n);
    setsvalue2s(L, obj, luaS_new(L, s));
    return 1;
  }
}

// Assembly:
xorl %eax, %eax
cmpl $0x3, 0x8(%rsi)
jne 0xd8a8
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm0
leaq 0xc5d1(%rip), %rsi      # 0x19e40
movq %rsp, %r15
movq %r15, %rdi
movb $0x1, %al
callq 0x44b0
movq %r15, %rdi
callq 0x4140
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc466
movq %rax, (%rbx)
movl $0x4, 0x8(%rbx)
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: luaV_gettable
void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
  int loop;
  for (loop = 0; loop < MAXTAGLOOP; loop++) {
    const TValue *tm;
    if (ttistable(t)) {  /* `t' is a table? */
      Table *h = hvalue(t);
      const TValue *res = luaH_get(h, key); /* do a primitive get */
      if (!ttisnil(res) ||  /* result is no nil? */
          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
        setobj2s(L, val, res);
        return;
      }
      /* else will try the tag method */
    }
    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
      luaG_typeerror(L, t, "index");
    if (ttisfunction(tm)) {
      callTMres(L, val, tm, t, key);
      return;
    }
    t = tm;  /* else repeat with `tm' */ 
  }
  luaG_runerror(L, "loop in gettable");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r15
pushq $0x65
popq %rbx
decl %ebx
je 0xd98b
movq %rbp, %r12
cmpl $0x5, 0x8(%rbp)
jne 0xd918
movq (%r12), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0xcbcc
movq %rax, %r13
cmpl $0x0, 0x8(%rax)
jne 0xd96a
movq 0x10(%rbp), %rdi
testq %rdi, %rdi
je 0xd96a
testb $0x1, 0xa(%rdi)
jne 0xd96a
movq 0x20(%r15), %rax
movq 0x128(%rax), %rdx
xorl %esi, %esi
callq 0xd1c6
movq %rax, %rbp
testq %rax, %rax
jne 0xd940
jmp 0xd96a
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xd1ef
movq %rax, %rbp
cmpl $0x0, 0x8(%rax)
jne 0xd940
movq %r15, %rdi
movq %r12, %rsi
leaq 0xd4ea(%rip), %rdx      # 0x1ae25
callq 0x6f53
cmpl $0x6, 0x8(%rbp)
jne 0xd8c4
movq %r15, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd9aa
movq (%r13), %rax
movq (%rsp), %rcx
movq %rax, (%rcx)
movl 0x8(%r13), %eax
movl %eax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc4b4(%rip), %rsi      # 0x19e46
movq %r15, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7165
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: callTMres
static void callTMres (lua_State *L, StkId res, const TValue *f,
                        const TValue *p1, const TValue *p2) {
  ptrdiff_t result = savestack(L, res);
  setobj2s(L, L->top, f);  /* push function */
  setobj2s(L, L->top+1, p1);  /* 1st argument */
  setobj2s(L, L->top+2, p2);  /* 2nd argument */
  luaD_checkstack(L, 3);
  L->top += 3;
  luaD_call(L, L->top - 3, 1);
  res = restorestack(L, result);
  L->top--;
  setobjs2s(L, res, L->top);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x40(%rdi), %r15
movq (%rdx), %rsi
movq %rsi, (%rax)
movl 0x8(%rdx), %edx
movl %edx, 0x8(%rax)
movq 0x10(%rdi), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rdi), %rax
movq (%r8), %rcx
movq %rcx, 0x20(%rax)
movl 0x8(%r8), %ecx
movl %ecx, 0x28(%rax)
movq 0x10(%rdi), %rsi
movq 0x38(%rdi), %rax
subq %rsi, %rax
cmpq $0x30, %rax
jg 0xda0c
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x7732
movq 0x10(%r14), %rsi
subq %r15, %rbx
leaq 0x30(%rsi), %rax
movq %rax, 0x10(%r14)
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x7d4b
movq 0x10(%r14), %rax
movq 0x40(%r14), %rcx
leaq -0x10(%rax), %rdx
movq %rdx, 0x10(%r14)
movq -0x10(%rax), %rdx
movq %rdx, (%rcx,%rbx)
movl -0x8(%rax), %eax
movl %eax, 0x8(%rcx,%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: luaV_settable
void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
  int loop;
  TValue temp;
  for (loop = 0; loop < MAXTAGLOOP; loop++) {
    const TValue *tm;
    if (ttistable(t)) {  /* `t' is a table? */
      Table *h = hvalue(t);
      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
      if (!ttisnil(oldval) ||  /* result is no nil? */
          (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
        setobj2t(L, oldval, val);
        h->flags = 0;
        luaC_barriert(L, h, val);
        return;
      }
      /* else will try the tag method */
    }
    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
      luaG_typeerror(L, t, "index");
    if (ttisfunction(tm)) {
      callTM(L, tm, t, key, val);
      return;
    }
    /* else repeat with `tm' */
    setobj(L, &temp, tm);  /* avoid pointing inside table (may rehash) */
    t = &temp;
  }
  luaG_runerror(L, "loop in settable");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x64
popq %r15
subl $0x1, %r15d
jb 0xdb54
cmpl $0x5, 0x8(%r12)
jne 0xdac4
movq (%r12), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
callq 0xccb1
movq %rax, %r14
cmpl $0x0, 0x8(%rax)
jne 0xdb0c
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xdb0c
testb $0x2, 0xa(%rdi)
jne 0xdb0c
movq 0x20(%rbx), %rax
movq 0x130(%rax), %rdx
pushq $0x1
popq %rsi
callq 0xd1c6
movq %rax, %rbp
testq %rax, %rax
jne 0xdaed
jmp 0xdb0c
movq %rbx, %rdi
movq %r12, %rsi
pushq $0x1
popq %rdx
callq 0xd1ef
movq %rax, %rbp
cmpl $0x0, 0x8(%rax)
jne 0xdaed
movq %rbx, %rdi
movq %r12, %rsi
leaq 0xd33d(%rip), %rdx      # 0x1ae25
callq 0x6f53
movl 0x8(%rbp), %eax
cmpl $0x6, %eax
je 0xdb6a
movq (%rbp), %rcx
movq %rcx, 0x18(%rsp)
movl %eax, 0x20(%rsp)
leaq 0x18(%rsp), %r12
jmp 0xda69
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movq %rax, (%r14)
movl 0x8(%rcx), %eax
movl %eax, 0x8(%r14)
movb $0x0, 0xa(%r13)
cmpl $0x4, %eax
jl 0xdbed
movq (%rcx), %rax
testb $0x3, 0x9(%rax)
je 0xdbed
testb $0x4, 0x9(%r13)
je 0xdbed
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9143
jmp 0xdbed
leaq 0xc2fc(%rip), %rsi      # 0x19e57
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7165
jmp 0xdbed
movq 0x10(%rbx), %rax
movq (%rbp), %rcx
movq %rcx, (%rax)
movl 0x8(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
movq (%r12), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%r12), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rbx), %rax
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x20(%rax)
movl 0x8(%rdx), %ecx
movl %ecx, 0x28(%rax)
movq 0x10(%rbx), %rax
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x30(%rax)
movl 0x8(%rdx), %ecx
movl %ecx, 0x38(%rax)
movq 0x10(%rbx), %rsi
movq 0x38(%rbx), %rax
subq %rsi, %rax
cmpq $0x40, %rax
jg 0xdbdb
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x7732
movq 0x10(%rbx), %rsi
leaq 0x40(%rsi), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7d4b
addq $0x28, %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/lvm.c
// Function: luaV_lessthan
int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
  int res;
  if (ttype(l) != ttype(r))
    return luaG_ordererror(L, l, r);
  else if (ttisnumber(l))
    return luai_numlt(nvalue(l), nvalue(r));
  else if (ttisstring(l))
    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
  else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
    return res;
  return luaG_ordererror(L, l, r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0xdc58
cmpl $0x4, %eax
je 0xdc2c
cmpl $0x3, %eax
jne 0xdc3c
movsd (%rbx), %xmm0
xorl %eax, %eax
ucomisd (%r14), %xmm0
seta %al
jmp 0xdc52
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0xdc6b
shrl $0x1f, %eax
jmp 0xdc52
pushq $0xd
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xdcde
cmpl $-0x1, %eax
je 0xdc58
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x72c5
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: call_orderTM
static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
                         TMS event) {
  const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
  const TValue *tm2;
  if (ttisnil(tm1)) return -1;  /* no metamethod? */
  tm2 = luaT_gettmbyobj(L, p2, event);
  if (!luaO_rawequalObj(tm1, tm2))  /* different metamethods? */
    return -1;
  callTMres(L, L->top, tm1, p1, p2);
  return !l_isfalse(L->top);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl %ecx, %edx
callq 0xd1ef
pushq $-0x1
popq %rbx
cmpl $0x0, 0x8(%rax)
je 0xdd55
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xd1ef
movq %r13, %rdi
movq %rax, %rsi
callq 0x9860
testl %eax, %eax
je 0xdd55
movq 0x10(%r14), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xd9aa
movq 0x10(%r14), %rax
movl 0x8(%rax), %ebx
testl %ebx, %ebx
je 0xdd55
cmpl $0x1, %ebx
jne 0xdd52
xorl %ebx, %ebx
cmpl $0x0, (%rax)
setne %bl
jmp 0xdd55
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: luaV_equalval
int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {
  const TValue *tm;
  lua_assert(ttype(t1) == ttype(t2));
  switch (ttype(t1)) {
    case LUA_TNIL: return 1;
    case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
    case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */
    case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
    case LUA_TUSERDATA: {
      if (uvalue(t1) == uvalue(t2)) return 1;
      tm = get_compTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable,
                         TM_EQ);
      break;  /* will try TM */
    }
    case LUA_TTABLE: {
      if (hvalue(t1) == hvalue(t2)) return 1;
      tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
      break;  /* will try TM */
    }
    default: return gcvalue(t1) == gcvalue(t2);
  }
  if (tm == NULL) return 0;  /* no TM? */
  callTMres(L, L->top, tm, t1, t2);  /* call TM */
  return !l_isfalse(L->top);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0x8(%rsi), %eax
cmpq $0x7, %rax
ja 0xdde1
movq %rdi, %r15
movb $0x1, %r12b
leaq 0xbfd2(%rip), %rcx      # 0x19d5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rax
movq (%rbx), %rcx
cmpq %rcx, %rax
je 0xde0c
movq 0x10(%rax), %rsi
movq 0x10(%rcx), %rdx
movq %r15, %rdi
callq 0xde1c
testq %rax, %rax
je 0xde09
movq 0x10(%r15), %rsi
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xd9aa
movq 0x10(%r15), %rax
movl 0x8(%rax), %ecx
testl %ecx, %ecx
je 0xde09
cmpl $0x1, %ecx
jne 0xde0c
cmpl $0x0, (%rax)
setne %r12b
jmp 0xde0c
movq (%r14), %rax
cmpq (%rbx), %rax
jmp 0xddee
movl (%r14), %eax
cmpl (%rbx), %eax
sete %r12b
jmp 0xde0c
movsd (%rbx), %xmm0
cmpeqsd (%r14), %xmm0
movq %xmm0, %r12
andl $0x1, %r12d
jmp 0xde0c
xorl %r12d, %r12d
movzbl %r12b, %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/lvm.c
// Function: get_compTM
static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
                                  TMS event) {
  const TValue *tm1 = fasttm(L, mt1, event);
  const TValue *tm2;
  if (tm1 == NULL) return NULL;  /* no metamethod */
  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
  tm2 = fasttm(L, mt2, event);
  if (tm2 == NULL) return NULL;  /* no metamethod */
  if (luaO_rawequalObj(tm1, tm2))  /* same metamethods? */
    return tm1;
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xde97
movq %rsi, %r12
testb $0x10, 0xa(%rsi)
jne 0xde97
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%rdi), %rax
movq 0x148(%rax), %rdx
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0xd1c6
testq %rax, %rax
je 0xde97
movq %rax, %rbx
cmpq %r14, %r12
je 0xde99
testq %r14, %r14
je 0xde97
testb $0x10, 0xa(%r14)
jne 0xde97
movq 0x20(%r15), %rax
movq 0x148(%rax), %rdx
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0xd1c6
testq %rax, %rax
je 0xde97
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9860
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rcx, %rbx
jmp 0xde99
xorl %ebx, %ebx
movq %rbx, %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/lvm.c
// Function: call_binTM
static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
                       StkId res, TMS event) {
  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
  if (ttisnil(tm))
    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
  if (ttisnil(tm)) return 0;
  callTMres(L, res, tm, p1, p2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl %r8d, %edx
callq 0xd1ef
cmpl $0x0, 0x8(%rax)
jne 0xe0fe
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xd1ef
cmpl $0x0, 0x8(%rax)
je 0xe11e
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xd9aa
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xe115
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: Arith
static void Arith (lua_State *L, StkId ra, const TValue *rb,
                   const TValue *rc, TMS op) {
  TValue tempb, tempc;
  const TValue *b, *c;
  if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
      (c = luaV_tonumber(rc, &tempc)) != NULL) {
    lua_Number nb = nvalue(b), nc = nvalue(c);
    switch (op) {
      case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
      case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
      case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
      case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;
      case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;
      case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
      case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
      default: lua_assert(0); break;
    }
  }
  else if (!call_binTM(L, rb, rc, ra, op))
    luaG_aritherror(L, rb, rc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r15d
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x38(%rsp), %rsi
movq %rdx, %rdi
callq 0xd800
testq %rax, %rax
je 0xf200
movq %rax, %rbp
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xd800
testq %rax, %rax
je 0xf200
movsd (%rbp), %xmm0
movsd (%rax), %xmm1
addl $-0x5, %r15d
leaq 0xac23(%rip), %rax      # 0x19e14
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
addsd %xmm1, %xmm0
jmp 0xf26a
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %r15d, %r8d
callq 0xe0c6
testl %eax, %eax
jne 0xf275
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7285
jmp 0xf275
movapd %xmm0, 0x10(%rsp)
divsd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x4470
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
jmp 0xf26e
mulsd %xmm1, %xmm0
jmp 0xf26a
divsd %xmm1, %xmm0
jmp 0xf26a
subsd %xmm1, %xmm0
jmp 0xf26a
callq 0x4110
movsd %xmm0, (%rbx)
movl $0x3, 0x8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorpd 0xaba4(%rip), %xmm0     # 0x19e30
movlpd %xmm0, (%rbx)
jmp 0xf26e
nop
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lzio.c
// Function: luaZ_fill
int luaZ_fill (ZIO *z) {
  size_t size;
  lua_State *L = z->L;
  const char *buff;
  lua_unlock(L);
  buff = z->reader(L, z->data, &size);
  lua_lock(L);
  if (buff == NULL || size == 0) return EOZ;
  z->n = size - 1;
  z->p = buff;
  return char2int(*(z->p++));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdi
movq %rsp, %r14
movq %r14, %rdx
callq *0x10(%rbx)
testq %rax, %rax
sete %dl
movq (%r14), %rcx
testq %rcx, %rcx
sete %sil
orb %dl, %sil
je 0xf2c6
pushq $-0x1
popq %rax
jmp 0xf2d9
decq %rcx
movq %rcx, (%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x8(%rbx)
movzbl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lzio.c
// Function: luaZ_lookahead
int luaZ_lookahead (ZIO *z) {
  if (z->n == 0) {
    if (luaZ_fill(z) == EOZ)
      return EOZ;
    else {
      z->n++;  /* luaZ_fill removed first byte; put back it */
      z->p--;
    }
  }
  return char2int(*z->p);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0xf2f1
movq 0x8(%rbx), %rax
jmp 0xf30c
movq %rbx, %rdi
callq 0xf294
cmpl $-0x1, %eax
je 0xf311
incq (%rbx)
movq 0x8(%rbx), %rax
decq %rax
movq %rax, 0x8(%rbx)
movzbl (%rax), %eax
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0xf30f
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rbx, %rbx
je 0xf374
movq %r15, %rdi
callq 0xf2e1
cmpl $-0x1, %eax
je 0xf374
movq (%r15), %r12
movq 0x8(%r15), %rsi
cmpq %r12, %rbx
cmovbq %rbx, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x42f0
subq %r12, (%r15)
addq %r12, 0x8(%r15)
addq %r12, %r14
subq %r12, %rbx
jmp 0xf33a
movq %rbx, %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/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 0x63ff
testl %eax, %eax
je 0xf44f
leaq 0xa847(%rip), %rsi      # 0x19c42
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x656c
movq 0x10(%r15), %rdi
leaq 0xa105(%rip), %rsi      # 0x19519
callq 0x4280
testl %eax, %eax
jne 0xf421
decl %ebp
je 0xf470
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
jne 0xf437
leaq 0xb406(%rip), %rcx      # 0x1a838
movq %rcx, 0x8(%rsp)
leaq 0xaae1(%rip), %rsi      # 0x19f1f
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0xf48b
jmp 0xf465
leaq 0xaa95(%rip), %rsi      # 0x19eeb
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xf48b
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdx
leaq 0xaa85(%rip), %rsi      # 0x19f01
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xf48b
jmp 0xf465
// File: /workspace/github_c_makefile_star2_O2/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 0x5aa6
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x543c
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xf74c
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x51fc
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5b5f
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x541c
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %rbx, %rdx
callq 0x5c7e
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/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, %r15
movl %esi, %ebp
movq %rdi, %r14
callq 0x5755
testq %rax, %rax
je 0xf7ad
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x5bb0
testl %eax, %eax
je 0xf7ad
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r15, %rdx
callq 0x5aa6
pushq $-0x1
popq %rsi
pushq $-0x2
popq %rdx
movq %r14, %rdi
callq 0x54f5
testl %eax, %eax
je 0xf7ad
pushq $-0x3
popq %rsi
movq %r14, %rdi
callq 0x51fc
jmp 0xf7bc
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xf543
xorl %ebx, %ebx
movq %rbx, %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/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 0x55e3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf8c1
jp 0xf8c1
movq %r14, %rdi
movl %ebx, %esi
movsd %xmm0, (%rsp)
callq 0x5493
movsd (%rsp), %xmm0
testl %eax, %eax
jne 0xf8c1
pushq $0x3
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0xf826
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5612
movq %rax, %r14
testq %rax, %rax
jne 0xf930
movq %r15, %rdi
movl %ebx, %esi
callq 0x5493
testl %eax, %eax
jne 0xf930
pushq $0x3
popq %rdx
movq %r15, %rdi
movl %ebx, %esi
callq 0xf826
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf9ee
movq %rbx, %rdi
callq 0x51ef
addl %eax, %r14d
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0xf967
testl %eax, %eax
je 0xfa1c
movq %rbx, %rdi
movl %r14d, %esi
callq 0x541c
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x5eb4
jmp 0xfa1e
xorl %ebp, %ebp
movl %ebp, %eax
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/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, %ebx
movq %rdx, %r14
movq %rdi, %r15
pushq $-0x2
popq %rax
movl %eax, (%rsp)
movl %ecx, %r12d
notl %r12d
testq %rsi, %rsi
je 0xfb0a
movq %rsi, %r13
xorl %ebp, %ebp
movq %r14, %rax
cmpq $0x0, (%rax)
je 0xfa70
incl %ebp
addq $0x10, %rax
jmp 0xfa62
leaq 0xa51c(%rip), %rdx      # 0x19f93
pushq $0x1
popq %rcx
movq %r15, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0xfb76
pushq $-0x1
popq %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x5aa6
movq %r15, %rdi
pushq $-0x1
popq %rsi
callq 0x543c
cmpl $0x5, %eax
je 0xfaf4
pushq $-0x2
popq %rsi
movq %r15, %rdi
callq 0x51fc
movq %r15, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r13, %rdx
movl %ebp, %ecx
callq 0xfb76
testq %rax, %rax
je 0xfadb
leaq 0xa4cd(%rip), %rsi      # 0x19f9b
movq %r15, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0xf48b
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x541c
pushq $-0x3
popq %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x5c7e
pushq $-0x2
popq %rsi
movq %r15, %rdi
callq 0x523b
movq %r15, %rdi
movl %r12d, %esi
callq 0x5329
movl %r12d, 0x4(%rsp)
movl %ebx, %ebp
negl %ebp
subl %ebx, (%rsp)
xorl %r12d, %r12d
testl %ebx, %ebx
cmovgl %ebx, %r12d
cmpq $0x0, (%r14)
je 0xfb5c
movl %r12d, %r13d
subl $0x1, %r13d
jb 0xfb3a
movq %r15, %rdi
movl %ebp, %esi
callq 0x541c
jmp 0xfb28
movq 0x8(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x599b
movq (%r14), %rdx
movq %r15, %rdi
movl (%rsp), %esi
callq 0x5c7e
addq $0x10, %r14
jmp 0xfb1f
movq %r15, %rdi
movl 0x4(%rsp), %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x51fc
// File: /workspace/github_c_makefile_star2_O2/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, 0x4(%rsp)
movq %rdx, %r12
movq %rdi, %rbx
callq 0x541c
pushq $-0x2
popq %r15
pushq $-0x1
popq %r13
movq %r12, %rdi
pushq $0x2e
popq %rsi
callq 0x4160
movq %rax, %r14
testq %rax, %rax
jne 0xfbb9
movq %r12, %rdi
callq 0x4140
movq %rax, %r14
addq %r12, %r14
movq %r14, %rbp
subq %r12, %rbp
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x5819
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5afe
movq %rbx, %rdi
movl %r13d, %esi
callq 0x543c
movq %rbx, %rdi
testl %eax, %eax
je 0xfbf9
movl %r13d, %esi
callq 0x543c
cmpl $0x5, %eax
je 0xfc3d
jmp 0xfc5b
movl %r15d, %esi
callq 0x51fc
cmpb $0x2e, (%r14)
movl 0x4(%rsp), %edx
pushq $0x1
popq %rax
cmovel %eax, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b5f
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x5819
movq %rbx, %rdi
movl %r15d, %esi
callq 0x541c
movq %rbx, %rdi
pushq $-0x4
popq %rsi
callq 0x5c57
movq %rbx, %rdi
movl %r15d, %esi
callq 0x523b
leaq 0x1(%r14), %r12
cmpb $0x2e, (%r14)
je 0xfb98
xorl %r12d, %r12d
jmp 0xfc66
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x51fc
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/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 0xfe18
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %r14, %rsi
callq 0x5819
movq %r14, (%rbx)
incl 0x8(%rbx)
pushq $0x1
popq %rax
jmp 0xfe1a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfebe
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
pushq $-0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x56d3
movq %rax, %r15
xorl %r13d, %r13d
movl %ebp, %r12d
leal -0x1(%r12), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x56d3
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 0xfe92
addl $0x2, %r13d
addq %rax, %r15
cmpl %edx, %r13d
movl %r12d, %r13d
jl 0xfe51
negl %ebp
testb %cl, %cl
cmovnel %ebp, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x61ac
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_O2/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
pushq $-0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x5665
movq (%r15), %rdx
movq (%rbx), %rdi
movq %rbx, %rcx
subq %rdi, %rcx
addq $0x2018, %rcx           # imm = 0x2018
cmpq %rcx, %rdx
jbe 0xff1e
movq %rbx, %rdi
callq 0xfdee
testl %eax, %eax
je 0xff11
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x5329
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfe22
jmp 0xff39
movq %rax, %rsi
callq 0x42f0
movq 0x8(%rsp), %rax
addq %rax, (%rbx)
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x51fc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xff67
movq %rbx, %rdi
callq 0x51ef
addl %eax, %r14d
incl %r14d
pushq $-0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x543c
testl %eax, %eax
je 0xffc2
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x5b2a
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5612
movq %rax, %r15
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
movq %rbx, %rdi
movl %r14d, %esi
testl %r15d, %r15d
je 0xffcf
movl %r15d, %edx
callq 0x5b2a
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x5d42
jmp 0xffda
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
jmp 0xffe8
callq 0x56d3
movq %rax, %r15
incl %r15d
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x5d42
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10048
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 0x10016
movq %r14, %rdi
callq 0x51ef
addl %eax, %ebx
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x5b2a
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x5d42
movl %ebp, %esi
movq %r14, %rdi
callq 0x57ff
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x5d42
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1027a
andl $0x0, (%rbx)
movq $0x1, (%r14)
leaq 0x9d90(%rip), %rbx      # 0x1a008
jmp 0x102ad
movq 0x8(%rbx), %rdi
callq 0x42d0
testl %eax, %eax
je 0x1028b
xorl %ebx, %ebx
jmp 0x102ad
movq 0x8(%rbx), %rcx
addq $0x10, %rbx
pushq $0x1
popq %rsi
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_O2/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         # 0x102dc
movq %rax, %rdx
callq 0x6026
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10359
movq %rcx, %rsi
jmp 0x43d0
pushq %rax
callq 0x4050
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: panic
static int panic (lua_State *L) {
  (void)L;  /* to avoid warnings */
  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
                   lua_tostring(L, -1));
  return 0;
}

// Assembly:
pushq %rbx
movq 0x16c8d(%rip), %rax     # 0x26ff8
movq (%rax), %rbx
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x5665
leaq 0x9c59(%rip), %rsi      # 0x19fd8
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x42b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x15eba(%rip), %r14     # 0x26258
pushq $0x1
popq %rbp
movq (%r14), %rsi
testq %rsi, %rsi
je 0x103d1
movq %rbx, %rdi
xorl %edx, %edx
callq 0x599b
movq -0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x5870
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x5eb4
addq $0x10, %r14
jmp 0x103a1
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %eax
movslq 0x30(%rdi), %rcx
cmpl 0x34(%rdi), %ecx
jle 0x1044d
testl %ecx, %ecx
je 0x10445
movq (%rdi), %rsi
movq 0x18(%rsi), %rsi
movl -0x4(%rsi,%rcx,4), %r8d
movl %r8d, %r9d
andl $0x3f, %r9d
cmpl $0x3, %r9d
jne 0x1044d
movl %r8d, %r9d
shrl $0x6, %r9d
movzbl %r9b, %r10d
movl %r8d, %r9d
shrl $0x17, %r9d
cmpl %eax, %r10d
setg %r10b
leal 0x1(%r9), %r11d
cmpl %eax, %r11d
setl %r11b
orb %r10b, %r11b
jne 0x1044d
addl %edx, %eax
decl %eax
cmpl %r9d, %eax
jle 0x1045f
andl $0x7fffc3, %r8d         # imm = 0x7FFFC3
shll $0x17, %eax
orl %r8d, %eax
movl %eax, -0x4(%rsi,%rcx,4)
jmp 0x1045f
movzbl 0x4a(%rdi), %ecx
cmpl %eax, %ecx
jle 0x1045f
leal (%rax,%rdx), %ecx
decl %ecx
pushq $0x3
popq %rsi
movl %eax, %edx
xorl %r8d, %r8d
jmp 0x10460
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: addk
static int addk (FuncState *fs, TValue *k, TValue *v) {
  lua_State *L = fs->L;
  TValue *idx = luaH_set(L, fs->h, k);
  Proto *f = fs->f;
  int oldsize = f->sizek;
  if (ttisnumber(idx)) {
    lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
    return cast_int(nvalue(idx));
  }
  else {  /* constant not found; create a new entry */
    setnvalue(idx, cast_num(fs->nk));
    luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
                    MAXARG_Bx, "constant table overflow");
    while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
    setobj(L, &f->k[fs->nk], v);
    luaC_barrier(L, f, v);
    return fs->nk++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0xccb1
cmpl $0x3, 0x8(%rax)
jne 0x106d8
cvttsd2si (%rax), %eax
jmp 0x1078b
movq (%rbx), %r12
leaq 0x4c(%r12), %rdx
movslq 0x4c(%r12), %r13
cvtsi2sdl 0x40(%rbx), %xmm0
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
movl (%rdx), %eax
cmpl %eax, 0x40(%rbx)
jl 0x10723
movq 0x10(%r12), %rsi
leaq 0x9378(%rip), %r9       # 0x19a80
pushq $0x10
popq %rcx
movq %r14, %rdi
movl $0x3ffff, %r8d          # imm = 0x3FFFF
callq 0x9718
movq %rax, 0x10(%r12)
movl 0x4c(%r12), %eax
movslq %eax, %rcx
movq 0x10(%r12), %rax
movq %r13, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $0x8, %rdx
cmpq %rcx, %r13
jge 0x1074a
incq %r13
andl $0x0, (%rdx)
addq $0x10, %rdx
jmp 0x10739
movslq 0x40(%rbx), %rcx
shlq $0x4, %rcx
movq (%r15), %rdx
movq %rdx, (%rax,%rcx)
movl 0x8(%r15), %edx
movl %edx, 0x8(%rax,%rcx)
cmpl $0x4, %edx
jl 0x10782
movq (%r15), %rdx
testb $0x3, 0x9(%rdx)
je 0x10782
testb $0x4, 0x9(%r12)
je 0x10782
movq %r14, %rdi
movq %r12, %rsi
callq 0x9066
movl 0x40(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x40(%rbx)
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/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 %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x8, %eax
ja 0x10915
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x977b(%rip), %rcx      # 0x1a018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10831
movl 0x8(%rbx), %ecx
pushq $0x5
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x104c0
jmp 0x1090c
movl $0xc, (%rbx)
jmp 0x10915
movl 0x8(%rbx), %ecx
pushq $0x4
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
jmp 0x10907
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0x1091d
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x1091d
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
pushq $0x6
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x10460
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq