LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstring.c
// Function: luaS_newlstr
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
  GCObject *o;
  unsigned int h = cast(unsigned int, l);  /* seed */
  size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
  size_t l1;
  for (l1=l; l1>=step; l1-=step)  /* compute hash */
    h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
  for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
       o != NULL;
       o = o->gch.next) {
    TString *ts = rawgco2ts(o);
    if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
      /* string may be dead */
      if (isdead(G(L), o)) changewhite(o);
      return ts;
    }
  }
  return newlstr(L, str, l, h);  /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
shrq $0x5, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x14146
movl -0x2c(%rbp), %eax
movl -0x2c(%rbp), %ecx
shll $0x5, %ecx
movl -0x2c(%rbp), %edx
shrl $0x2, %edx
addl %edx, %ecx
movq -0x18(%rbp), %rdx
movq -0x40(%rbp), %rsi
subq $0x1, %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x14103
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
movl 0xc(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x141ee
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x141df
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0x5250
cmpl $0x0, %eax
jne 0x141df
movq -0x28(%rbp), %rax
movzbl 0x9(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movzbl 0x20(%rcx), %ecx
xorl $0x3, %ecx
andl %ecx, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x141d5
movq -0x28(%rbp), %rax
movzbl 0x9(%rax), %ecx
xorl $0x3, %ecx
movb %cl, 0x9(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14206
jmp 0x141e1
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1416f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x14210
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstring.c
// Function: newlstr
static TString *newlstr (lua_State *L, const char *str, size_t l,
                                       unsigned int h) {
  TString *ts;
  stringtable *tb;
  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
    luaM_toobig(L);
  ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
  ts->tsv.len = l;
  ts->tsv.hash = h;
  ts->tsv.marked = luaC_white(G(L));
  ts->tsv.tt = LUA_TSTRING;
  ts->tsv.reserved = 0;
  memcpy(ts+1, str, l*sizeof(char));
  ((char *)(ts+1))[l] = '\0';  /* ending 0 */
  tb = &G(L)->strt;
  h = lmod(h, tb->size);
  ts->tsv.next = tb->hash[h];  /* chain new entry */
  tb->hash[h] = obj2gco(ts);
  tb->nuse++;
  if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
    luaS_resize(L, tb->size*2);  /* too crowded */
  return ts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq $-0x1b, %rax
jbe 0x1423e
movq -0x8(%rbp), %rdi
callq 0xf500
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
shlq $0x0, %rcx
addq $0x18, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xf470
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movzbl 0x20(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x28(%rbp), %rax
movb $0x4, 0x8(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0xa(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5310
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x18(%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x14347
movq -0x30(%rbp), %rax
cmpl $0x3ffffffe, 0xc(%rax)  # imm = 0x3FFFFFFE
jg 0x14347
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0xc(%rax), %esi
shll %esi
callq 0x13f60
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstring.c
// Function: luaS_newudata
Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
  Udata *u;
  if (s > MAX_SIZET - sizeof(Udata))
    luaM_toobig(L);
  u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
  u->uv.marked = luaC_white(G(L));  /* is not finalized */
  u->uv.tt = LUA_TUSERDATA;
  u->uv.len = s;
  u->uv.metatable = NULL;
  u->uv.env = e;
  /* chain it on udata list (after main thread) */
  u->uv.next = G(L)->mainthread->next;
  G(L)->mainthread->next = obj2gco(u);
  return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $-0x2b, -0x10(%rbp)
jbe 0x14384
movq -0x8(%rbp), %rdi
callq 0xf500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0x28, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xf470
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movzbl 0x20(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x20(%rbp), %rax
movb $0x7, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0xb0(%rax), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0xb0(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: findindex
static int findindex (lua_State *L, Table *t, StkId key) {
  int i;
  if (ttisnil(key)) return -1;  /* first iteration */
  i = arrayindex(key);
  if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
    return i-1;  /* yes; that's the index (corrected to C) */
  else {
    Node *n = mainposition(t, key);
    do {  /* check whether `key' is somewhere in the chain */
      /* key may be dead already, but it is ok to use it in `next' */
      if (luaO_rawequalObj(key2tval(n), key) ||
            (ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
             gcvalue(gkey(n)) == gcvalue(key))) {
        i = cast_int(n - gnode(t, 0));  /* key index in hash table */
        /* hash elements are numbered after array ones */
        return i + t->sizearray;
      }
      else n = gnext(n);
    } while (n);
    luaG_runerror(L, "invalid key to " LUA_QL("next"));  /* key not found */
    return 0;  /* to avoid warnings */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1461a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x146ec
movq -0x20(%rbp), %rdi
callq 0x155d0
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
jge 0x14647
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jg 0x14647
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x146ec
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14f80
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0xf620
cmpl $0x0, %eax
jne 0x14693
movq -0x30(%rbp), %rax
cmpl $0xb, 0x18(%rax)
jne 0x146be
movq -0x20(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jl 0x146be
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x146be
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
addl 0x38(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x146ec
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x146cc
cmpq $0x0, -0x30(%rbp)
jne 0x14658
movq -0x10(%rbp), %rdi
leaq 0x17590(%rip), %rsi     # 0x2bc6e
movb $0x0, %al
callq 0xa410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_new
Table *luaH_new (lua_State *L, int narray, int nhash) {
  Table *t = luaM_new(L, Table);
  luaC_link(L, obj2gco(t), LUA_TTABLE);
  t->metatable = NULL;
  t->flags = cast_byte(~0);
  /* temporary values (kept only if some malloc fails) */
  t->array = NULL;
  t->sizearray = 0;
  t->lsizenode = 0;
  t->node = cast(Node *, dummynode);
  setarrayvector(L, t, narray);
  setnodevector(L, t, nhash);
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x40, %ecx
movq %rdx, %rsi
callq 0xf470
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x5, %edx
callq 0xe100
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movb $-0x1, 0xa(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0xb(%rax)
movq -0x18(%rbp), %rax
leaq 0x17245(%rip), %rcx     # 0x2bc20
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x14a10
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x14ad0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_free
void luaH_free (lua_State *L, Table *t) {
  if (t->node != dummynode)
    luaM_freearray(L, t->node, sizenode(t), Node);
  luaM_freearray(L, t->array, t->sizearray, TValue);
  luaM_free(L, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x16ff5(%rip), %rcx     # 0x2bc20
cmpq %rcx, 0x20(%rax)
je 0x14c5b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
imulq $0x28, %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xf470
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xf470
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0xf470
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: hashnum
static Node *hashnum (const Table *t, lua_Number n) {
  unsigned int a[numints];
  int i;
  if (luai_numeq(n, 0))  /* avoid problems with -0 */
    return gnode(t, 0);
  memcpy(a, &n, sizeof(a));
  for (i = 1; i < numints; i++) a[0] += a[i];
  return hashmod(t, a[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14d7b
jp 0x14d7b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x14de4
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jge 0x14da9
movslq -0x24(%rbp), %rax
movl -0x20(%rbp,%rax,4), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14d8a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
orl $0x1, %ecx
xorl %edx, %edx
divl %ecx
movq -0x30(%rbp), %rax
movl %edx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_getstr
const TValue *luaH_getstr (Table *t, TString *key) {
  Node *n = hashstr(t, key);
  do {  /* check whether `key' is somewhere in the chain */
    if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
      return gval(n);  /* that's it */
    else n = gnext(n);
  } while (n);
  return luaO_nilobject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x24(%rbp), %ecx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x14e55
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x14e55
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14e75
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x14e63
cmpq $0x0, -0x20(%rbp)
jne 0x14e33
leaq 0x1688f(%rip), %rax     # 0x2b700
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_get
const TValue *luaH_get (Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TNIL: return luaO_nilobject;
    case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
    case LUA_TNUMBER: {
      int k;
      lua_Number n = nvalue(key);
      lua_number2int(k, n);
      if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */
        return luaH_getnum(t, k);  /* use specialized version */
      /* else go through */
    }
    default: {
      Node *n = mainposition(t, key);
      do {  /* check whether `key' is somewhere in the chain */
        if (luaO_rawequalObj(key2tval(n), key))
          return gval(n);  /* that's it */
        else n = gnext(n);
      } while (n);
      return luaO_nilobject;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x14eb4
jmp 0x14ea0
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x14edd
jmp 0x14eaa
movl -0x34(%rbp), %eax
subl $0x4, %eax
je 0x14ec4
jmp 0x14f17
leaq 0x16845(%rip), %rax     # 0x2b700
movq %rax, -0x8(%rbp)
jmp 0x14f68
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x14df0
movq %rax, -0x8(%rbp)
jmp 0x14f68
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
cvttsd2si -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jne 0x14f15
jp 0x14f15
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x14ca0
movq %rax, -0x8(%rbp)
jmp 0x14f68
jmp 0x14f17
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14f80
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0xf620
cmpl $0x0, %eax
je 0x14f48
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14f68
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x14f56
cmpq $0x0, -0x30(%rbp)
jne 0x14f28
leaq 0x1679c(%rip), %rax     # 0x2b700
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: mainposition
static Node *mainposition (const Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TNUMBER:
      return hashnum(t, nvalue(key));
    case LUA_TSTRING:
      return hashstr(t, rawtsvalue(key));
    case LUA_TBOOLEAN:
      return hashboolean(t, bvalue(key));
    case LUA_TLIGHTUSERDATA:
      return hashpointer(t, pvalue(key));
    default:
      return hashpointer(t, gcvalue(key));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x15091
movq -0x20(%rbp), %rax
leaq 0x16c5d(%rip), %rcx     # 0x2bc10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x14d50
movq %rax, -0x8(%rbp)
jmp 0x150d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x24(%rbp), %ecx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x150d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x28(%rbp), %ecx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x150d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
orl $0x1, %ecx
xorl %edx, %edx
divl %ecx
movq -0x30(%rbp), %rax
movl %edx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x150d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
orl $0x1, %ecx
xorl %edx, %edx
divl %ecx
movq -0x38(%rbp), %rax
movl %edx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_set
TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
  const TValue *p = luaH_get(t, key);
  t->flags = 0;
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
    else if (ttisnumber(key) && luai_numisnan(nvalue(key)))
      luaG_runerror(L, "table index is NaN");
    return newkey(L, t, key);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14e80
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0xa(%rax)
leaq 0x165ec(%rip), %rax     # 0x2b700
cmpq %rax, -0x28(%rbp)
je 0x15124
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1518b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x15142
movq -0x10(%rbp), %rdi
leaq 0x16b0f(%rip), %rsi     # 0x2bc48
movb $0x0, %al
callq 0xa410
jmp 0x15176
movq -0x20(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x15174
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
ucomisd (%rax), %xmm0
jne 0x15162
jp 0x15162
jmp 0x15174
movq -0x10(%rbp), %rdi
leaq 0x16aee(%rip), %rsi     # 0x2bc5b
movb $0x0, %al
callq 0xa410
jmp 0x15176
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x151a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_setnum
TValue *luaH_setnum (lua_State *L, Table *t, int key) {
  const TValue *p = luaH_getnum(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    TValue k;
    setnvalue(&k, cast_num(key));
    return newkey(L, t, &k);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x14ca0
movq %rax, -0x28(%rbp)
leaq 0x163a6(%rip), %rax     # 0x2b700
cmpq %rax, -0x28(%rbp)
je 0x1536a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1539f
leaq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rax
movl $0x3, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x151a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_setstr
TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {
  const TValue *p = luaH_getstr(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    TValue k;
    setsvalue(L, &k, key);
    return newkey(L, t, &k);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14df0
movq %rax, -0x28(%rbp)
leaq 0x16324(%rip), %rax     # 0x2b700
cmpq %rax, -0x28(%rbp)
je 0x153ec
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1541f
leaq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl $0x4, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x151a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: unbound_search
static int unbound_search (Table *t, unsigned int j) {
  unsigned int i = j;  /* i is zero or a present index */
  j++;
  /* find `i' and `j' such that i is present and j is not */
  while (!ttisnil(luaH_getnum(t, j))) {
    i = j;
    j *= 2;
    if (j > cast(unsigned int, MAX_INT)) {  /* overflow? */
      /* table was built with bad purposes: resort to linear search */
      i = 1;
      while (!ttisnil(luaH_getnum(t, i))) i++;
      return i - 1;
    }
  }
  /* now do a binary search between them */
  while (j - i > 1) {
    unsigned int m = (i+j)/2;
    if (ttisnil(luaH_getnum(t, m))) j = m;
    else i = m;
  }
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x14ca0
cmpl $0x0, 0x8(%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15529
jmp 0x1557a
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
cmpl $0x7ffffffd, -0x14(%rbp) # imm = 0x7FFFFFFD
jbe 0x15578
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x14ca0
cmpl $0x0, 0x8(%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15562
jmp 0x1556d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15547
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x155ba
jmp 0x1550e
jmp 0x1557c
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x1, %eax
jbe 0x155b4
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x14ca0
cmpl $0x0, 0x8(%rax)
jne 0x155ac
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x155b2
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1557c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: rehash
static void rehash (lua_State *L, Table *t, const TValue *ek) {
  int nasize, na;
  int nums[MAXBITS+1];  /* nums[i] = number of keys between 2^(i-1) and 2^i */
  int i;
  int totaluse;
  for (i=0; i<=MAXBITS; i++) nums[i] = 0;  /* reset counts */
  nasize = numusearray(t, nums);  /* count keys in array part */
  totaluse = nasize;  /* all those keys are integer keys */
  totaluse += numusehash(t, nums, &nasize);  /* count keys in hash part */
  /* count extra key */
  nasize += countint(ek, nums);
  totaluse++;
  /* compute new size for array part */
  na = computesizes(nums, &nasize);
  /* resize the table to new computed sizes */
  resize(L, t, nasize, totaluse - na);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x94(%rbp)
cmpl $0x1a, -0x94(%rbp)
jg 0x156cd
movslq -0x94(%rbp), %rax
movl $0x0, -0x90(%rbp,%rax,4)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x156a1
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x15770
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x15850
addl -0x98(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x158f0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x15960
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x98(%rbp), %ecx
subl -0x20(%rbp), %ecx
callq 0x14760
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: numusehash
static int numusehash (const Table *t, int *nums, int *pnasize) {
  int totaluse = 0;  /* total number of elements */
  int ause = 0;  /* summation of `nums' */
  int i = sizenode(t);
  while (i--) {
    Node *n = &t->node[i];
    if (!ttisnil(gval(n))) {
      ause += countint(key2tval(n), nums);
      totaluse++;
    }
  }
  *pnasize += ause;
  return totaluse;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xb(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
je 0x158d7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x158d5
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x158f0
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15884
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: countint
static int countint (const TValue *key, int *nums) {
  int k = arrayindex(key);
  if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
    nums[ceillog2(k)]++;  /* count as such */
    return 1;
  }
  else
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x155d0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jge 0x1594d
cmpl $0x4000000, -0x1c(%rbp) # imm = 0x4000000
jg 0x1594d
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
subl $0x1, %edi
callq 0xf5d0
movl %eax, %ecx
movq -0x28(%rbp), %rax
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl $0x1, -0x4(%rbp)
jmp 0x15954
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x5, %eax
je 0x15b6e
jmp 0x15b64
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x15b7f
jmp 0x15b90
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x15bac
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x15bac
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq 0xe0(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x15bd5
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
movq 0x128(%rax,%rcx,8), %rsi
callq 0x14df0
movq %rax, -0x30(%rbp)
jmp 0x15be2
leaq 0x15b24(%rip), %rax     # 0x2b700
movq %rax, -0x30(%rbp)
jmp 0x15be2
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
je 0x15c20
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x15c2e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15c57
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x160f0(%rip), %ecx     # 0x2bd2c
cmpl %ecx, %eax
jne 0x15c4d
leaq 0x160ea(%rip), %rax     # 0x2bd31
movq %rax, -0x28(%rbp)
jmp 0x15c55
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x15c57
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x15ca0
movq -0x8(%rbp), %rdi
leaq 0x160bc(%rip), %rsi     # 0x2bd3f
movl $0x2, %edx
callq 0x140d0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x15d00
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lundump.c
// Function: LoadFunction
static Proto* LoadFunction(LoadState* S, TString* p)
{
 Proto* f;
 if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
 f=luaF_newproto(S->L);
 setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
 f->source=LoadString(S); if (f->source==NULL) f->source=p;
 f->linedefined=LoadInt(S);
 f->lastlinedefined=LoadInt(S);
 f->nups=LoadByte(S);
 f->numparams=LoadByte(S);
 f->is_vararg=LoadByte(S);
 f->maxstacksize=LoadByte(S);
 LoadCode(S,f);
 LoadConstants(S,f);
 LoadDebug(S,f);
 IF (!luaG_checkcode(f), "bad code");
 S->L->top--;
 S->L->nCcalls--;
 return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movw 0x60(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x60(%rcx)
movzwl %ax, %eax
cmpl $0xc8, %eax
jle 0x15d3d
movq -0x8(%rbp), %rdi
leaq 0x16040(%rip), %rsi     # 0x2bd78
callq 0x15fe0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd0e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x9, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jg 0x15da4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xb380
jmp 0x15da6
jmp 0x15da6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x16030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x15de4
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x160c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rdi
callq 0x160c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x8(%rbp), %rdi
callq 0x16100
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x70(%rax)
movq -0x8(%rbp), %rdi
callq 0x16100
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x71(%rax)
movq -0x8(%rbp), %rdi
callq 0x16100
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x72(%rax)
movq -0x8(%rbp), %rdi
callq 0x16100
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x73(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16130
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x161d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16470
movq -0x18(%rbp), %rdi
callq 0x98c0
cmpl $0x0, %eax
jne 0x15e95
movq -0x8(%rbp), %rdi
leaq 0x15ef6(%rip), %rsi     # 0x2bd86
callq 0x15fe0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movw 0x60(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x60(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lundump.c
// Function: luaU_header
void luaU_header (char* h)
{
 int x=1;
 memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
 h+=sizeof(LUA_SIGNATURE)-1;
 *h++=(char)LUAC_VERSION;
 *h++=(char)LUAC_FORMAT;
 *h++=(char)*(char*)&x;				/* endianness */
 *h++=(char)sizeof(int);
 *h++=(char)sizeof(size_t);
 *h++=(char)sizeof(Instruction);
 *h++=(char)sizeof(lua_Number);
 *h++=(char)(((lua_Number)0.5)==0);		/* is lua_Number integral? */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x15e43(%rip), %ecx     # 0x2bd2c
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x51, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
movb -0xc(%rbp), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x4, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x8, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x4, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x8, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x16754
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x167a9
movq -0x10(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x167a1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0xf6f0
cmpl $0x0, %eax
je 0x167a1
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movl $0x3, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x167a9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0x167e3
movl $0x0, -0x4(%rbp)
jmp 0x16854
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
leaq 0x1567c(%rip), %rsi     # 0x2be7c
movb $0x1, %al
callq 0x54c0
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5150
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x140d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movl $0x4, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x64, -0x24(%rbp)
jge 0x169be
movq -0x10(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x16954
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14e80
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x16924
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x168d0
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x16916
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0xa(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x168ec
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x1690e
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x128(%rax), %rdx
xorl %esi, %esi
callq 0x15ad0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x16952
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x169d0
jmp 0x16983
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x15b40
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x8(%rax)
jne 0x16981
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x16645(%rip), %rdx     # 0x2cfc1
callq 0xa0a0
jmp 0x16983
movq -0x30(%rbp), %rax
cmpl $0x6, 0x8(%rax)
jne 0x169a8
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x169e0
jmp 0x169d0
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1687f
movq -0x8(%rbp), %rdi
leaq 0x154b9(%rip), %rsi     # 0x2be82
movb $0x0, %al
callq 0xa410
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x58(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x30, %rax
jg 0x16ad0
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xb380
jmp 0x16ad2
jmp 0x16ad2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x30, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
addq $-0x30, %rsi
movl $0x1, %edx
callq 0xbf20
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lvm.c
// Function: callTM
static void callTM (lua_State *L, const TValue *f, const TValue *p1,
                    const TValue *p2, const TValue *p3) {
  setobj2s(L, L->top, f);  /* push function */
  setobj2s(L, L->top+1, p1);  /* 1st argument */
  setobj2s(L, L->top+2, p2);  /* 2nd argument */
  setobj2s(L, L->top+3, p3);  /* 3th argument */
  luaD_checkstack(L, 4);
  L->top += 4;
  luaD_call(L, L->top - 4, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x30, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x40, %rax
jg 0x16e71
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0xb380
jmp 0x16e73
jmp 0x16e73
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
addq $-0x40, %rsi
xorl %edx, %edx
callq 0xbf20
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x16edd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa570
movl %eax, -0x4(%rbp)
jmp 0x16f75
movq -0x18(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x16f08
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x16f75
movq -0x18(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x16f35
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x16f80
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x16f75
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0xd, %ecx
callq 0x17080
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x16f5b
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16f75
jmp 0x16f5d
jmp 0x16f5f
jmp 0x16f61
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa570
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop