LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: lua_newstate
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
  void *l = (*f)(ud, NULL, 0, state_size(LG));
  if (l == NULL) return NULL;
  L = tostate(l);
  g = &((LG *)L)->g;
  L->next = NULL;
  L->tt = LUA_TTHREAD;
  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
  L->marked = luaC_white(g);
  set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
  preinit_state(L, g);
  g->frealloc = f;
  g->ud = ud;
  g->mainthread = L;
  g->uvhead.u.l.prev = &g->uvhead;
  g->uvhead.u.l.next = &g->uvhead;
  g->GCthreshold = 0;  /* mark it as unfinished state */
  g->strt.size = 0;
  g->strt.nuse = 0;
  g->strt.hash = NULL;
  setnilvalue(registry(L));
  luaZ_initbuffer(L, &g->buff);
  g->panic = NULL;
  g->gcstate = GCSpause;
  g->rootgc = obj2gco(L);
  g->sweepstrgc = 0;
  g->sweepgc = &g->rootgc;
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  g->tmudata = NULL;
  g->totalbytes = sizeof(LG);
  g->gcpause = LUAI_GCPAUSE;
  g->gcstepmul = LUAI_GCMUL;
  g->gcdept = 0;
  for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
  if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
    /* memory allocation error: free partial state */
    close_state(L);
    L = NULL;
  }
  else
    luai_userstateopen(L);
  return L;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
movl $0x268, %ecx            # imm = 0x268
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *%r12
testq %rax, %rax
je 0xd00e
movq %rax, %r14
addq $0xb8, %rax
movq %rbx, (%r14)
movb $0x8, 0x8(%r14)
movb $0x21, 0xd8(%r14)
movw $0x61, 0x9(%r14)
movq %rax, 0x20(%r14)
movq %rbx, 0x40(%r14)
movl %ebx, 0x58(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%r14)
movw $0x100, 0x64(%r14)      # imm = 0x100
movups %xmm0, 0x68(%r14)
movq %rbx, 0x98(%r14)
movq %rbx, 0x50(%r14)
movl %ebx, 0x80(%r14)
movups %xmm0, 0x28(%r14)
movq %rbx, 0x5c(%r14)
movq %r12, 0xc8(%r14)
movq %r15, 0xd0(%r14)
movq %r14, 0x168(%r14)
leaq 0x170(%r14), %rax
movq %rax, 0x188(%r14)
movq %rax, 0x190(%r14)
movl %ebx, 0x160(%r14)
movq %rbx, 0x110(%r14)
movq %rbx, 0x150(%r14)
movb $0x0, 0xd9(%r14)
movq %r14, %rax
addq $0xe0, %rax
movups %xmm0, 0xb8(%r14)
movups %xmm0, 0x120(%r14)
movq %r14, 0xe0(%r14)
movl %ebx, 0xdc(%r14)
movq %rax, 0xe8(%r14)
movups %xmm0, 0xf0(%r14)
movups %xmm0, 0x100(%r14)
movq $0x268, 0x130(%r14) # imm = 0x268
movabsq $0xc8000000c8, %rax     # imm = 0xC8000000C8
movq %rax, 0x148(%r14)
movq %rbx, 0x140(%r14)
movups %xmm0, 0x198(%r14)
movups %xmm0, 0x1a8(%r14)
movups %xmm0, 0x1b8(%r14)
movups %xmm0, 0x1c8(%r14)
movq %rbx, 0x1d8(%r14)
leaq 0x2c(%rip), %rsi        # 0xd01d
movq %r14, %rdi
xorl %edx, %edx
callq 0x7a4e
testl %eax, %eax
je 0xd00b
movq %r14, %rdi
callq 0xd0be
xorl %ebx, %ebx
jmp 0xd00e
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: f_luaopen
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
  luaS_fix(luaS_newliteral(L, MEMERRMSG));
  g->GCthreshold = 4*g->totalbytes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq %rdi, %rsi
callq 0xcd92
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xd77c
movq %rax, 0x78(%rbx)
movl $0x5, %ebp
movl %ebp, 0x80(%rbx)
movq 0x20(%rbx), %r15
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xd77c
movq %rax, 0xa0(%r15)
movl %ebp, 0xa8(%r15)
movq %rbx, %rdi
movl $0x20, %esi
callq 0xd1b0
movq %rbx, %rdi
callq 0xe1a0
movq %rbx, %rdi
callq 0x12f28
leaq 0xdf83(%rip), %rsi      # 0x1b019
movl $0x11, %edx
movq %rbx, %rdi
callq 0xd282
orb $0x20, 0x9(%rax)
movq 0x78(%r14), %rax
shlq $0x2, %rax
movq %rax, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: close_state
static void close_state (lua_State *L) {
  global_State *g = G(L);
  luaF_close(L, L->stack);  /* close all upvalues for this thread */
  luaC_freeall(L);  /* collect all objects */
  lua_assert(g->rootgc == obj2gco(L));
  lua_assert(g->strt.nuse == 0);
  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
  luaZ_freebuffer(L, &g->buff);
  freestack(L, L);
  lua_assert(g->totalbytes == sizeof(LG));
  (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x40(%rdi), %rsi
callq 0x8e9c
movq %rbx, %rdi
callq 0x9264
movq 0x20(%rbx), %rax
movq (%rax), %rsi
movslq 0xc(%rax), %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movq 0x58(%r14), %rsi
movq 0x68(%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movq %rax, 0x58(%r14)
movq $0x0, 0x68(%r14)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xce57
movq 0x10(%r14), %rax
movq 0x18(%r14), %rdi
movl $0x268, %edx            # imm = 0x268
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: lua_close
LUA_API void lua_close (lua_State *L) {
  L = G(L)->mainthread;  /* only the main thread can be closed */
  lua_lock(L);
  luaF_close(L, L->stack);  /* close all upvalues for this thread */
  luaC_separateudata(L, 1);  /* separate udata that have GC metamethods */
  L->errfunc = 0;  /* no error function during GC metamethods */
  do {  /* repeat until no more errors */
    L->ci = L->base_ci;
    L->base = L->top = L->ci->base;
    L->nCcalls = L->baseCcalls = 0;
  } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
  lua_assert(G(L)->tmudata == NULL);
  luai_userstateclose(L);
  close_state(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
movq 0xb0(%rax), %rbx
movq 0x40(%rbx), %rsi
movq %rbx, %rdi
callq 0x8e9c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9088
movq $0x0, 0xb0(%rbx)
leaq 0x3a(%rip), %r14        # 0xd1ab
movq 0x50(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x0, 0x60(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7a4e
testl %eax, %eax
jne 0xd171
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd0be
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lstring.c
// Function: luaS_resize
void luaS_resize (lua_State *L, int newsize) {
  GCObject **newhash;
  stringtable *tb;
  int i;
  if (G(L)->gcstate == GCSsweepstring)
    return;  /* cannot resize during GC traverse */
  newhash = luaM_newvector(L, newsize, GCObject *);
  tb = &G(L)->strt;
  for (i=0; i<newsize; i++) newhash[i] = NULL;
  /* rehash */
  for (i=0; i<tb->size; i++) {
    GCObject *p = tb->hash[i];
    while (p) {  /* for each node in the list */
      GCObject *next = p->gch.next;  /* save next */
      unsigned int h = gco2ts(p)->hash;
      int h1 = lmod(h, newsize);  /* new position */
      lua_assert(cast_int(h%newsize) == lmod(h, newsize));
      p->gch.next = newhash[h1];  /* chain it */
      newhash[h1] = p;
      p = next;
    }
  }
  luaM_freearray(L, tb->hash, tb->size, TString *);
  tb->size = newsize;
  tb->hash = newhash;
}

// Assembly:
movq 0x20(%rdi), %rax
cmpb $0x2, 0x21(%rax)
je 0xd281
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r12
cmpl $-0x2, %esi
jle 0xd206
leaq (,%r12,8), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
movq %rax, %r15
movq 0x20(%r14), %r13
testl %r12d, %r12d
jle 0xd215
movl %ebx, %edx
shlq $0x3, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x41b0
jmp 0xd215
movq %r14, %rdi
callq 0xa242
movq %rax, %r15
movq 0x20(%r14), %r13
movslq 0xc(%r13), %rdx
testq %rdx, %rdx
jle 0xd25e
decq %r12
xorl %eax, %eax
movl %edx, %ecx
movq (%r13), %rdx
movq (%rdx,%rax,8), %rdx
testq %rdx, %rdx
je 0xd253
movq (%rdx), %rcx
movslq 0xc(%rdx), %rsi
andq %r12, %rsi
movq (%r15,%rsi,8), %rdi
movq %rdi, (%rdx)
movq %rdx, (%r15,%rsi,8)
movq %rcx, %rdx
testq %rcx, %rcx
jne 0xd232
movl 0xc(%r13), %ecx
incq %rax
movslq %ecx, %rdx
cmpq %rdx, %rax
jl 0xd225
movq (%r13), %rsi
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movl %ebx, 0xc(%r13)
movq %r15, (%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xd2ce
movq %r14, %rax
shrq $0x5, %rax
movq %rax, %rcx
notq %rcx
movq %r14, %rdx
movl %r14d, %ebp
movl %ebp, %esi
shll $0x5, %esi
movl %ebp, %edi
shrl $0x2, %edi
addl %esi, %edi
movzbl -0x1(%r15,%rdx), %esi
addl %edi, %esi
xorl %esi, %ebp
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0xd2ae
jmp 0xd2d0
xorl %ebp, %ebp
movq 0x20(%rbx), %r13
movq (%r13), %rax
movslq 0xc(%r13), %rcx
decq %rcx
movslq %ebp, %rdx
andq %rcx, %rdx
movq (%rax,%rdx,8), %r12
testq %r12, %r12
je 0xd313
cmpq %r14, 0x10(%r12)
jne 0xd30d
leaq 0x18(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4380
testl %eax, %eax
je 0xd3b6
movq (%r12), %r12
jmp 0xd2e9
leaq 0x1b(%r14), %rax
cmpq $0x19, %rax
ja 0xd325
movq %rbx, %rdi
callq 0xa242
leaq 0x19(%r14), %rcx
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
movq %rax, %r12
movq %r14, 0x10(%rax)
movl %ebp, 0xc(%rax)
movq 0x20(%rbx), %rax
movb 0x20(%rax), %al
andb $0x3, %al
movb %al, 0x9(%r12)
movb $0x4, 0x8(%r12)
movb %r13b, 0xa(%r12)
leaq 0x18(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4300
movb %r13b, 0x18(%r12,%r14)
movq 0x20(%rbx), %rax
movl 0xc(%rax), %ecx
decl %ecx
andl %ebp, %ecx
movq (%rax), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%r12)
movq (%rax), %rdx
movq %r12, (%rdx,%rcx,8)
movl 0x8(%rax), %ecx
movl 0xc(%rax), %esi
incl %ecx
cmpl %esi, %ecx
setbe %dl
movl %ecx, 0x8(%rax)
cmpl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
setge %al
orb %dl, %al
jne 0xd3cf
addl %esi, %esi
movq %rbx, %rdi
callq 0xd1b0
jmp 0xd3cf
movb 0x9(%r12), %al
movb 0x20(%r13), %cl
notb %cl
andb %al, %cl
testb $0x3, %cl
je 0xd3cf
xorb $0x3, %al
movb %al, 0x9(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $-0x2a, %rsi
jb 0xd3fd
movq %rbx, %rdi
callq 0xa242
leaq 0x28(%r15), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
movq 0x20(%rbx), %rcx
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0x7, 0x8(%rax)
movq %r15, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq %r14, 0x18(%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq %rax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: resize
static void resize (lua_State *L, Table *t, int nasize, int nhsize) {
  int i;
  int oldasize = t->sizearray;
  int oldhsize = t->lsizenode;
  Node *nold = t->node;  /* save old hash ... */
  if (nasize > oldasize)  /* array part must grow? */
    setarrayvector(L, t, nasize);
  /* create new hash part with appropriate size */
  setnodevector(L, t, nhsize);  
  if (nasize < oldasize) {  /* array part must shrink? */
    t->sizearray = nasize;
    /* re-insert elements from vanishing slice */
    for (i=nasize; i<oldasize; i++) {
      if (!ttisnil(&t->array[i]))
        setobjt2t(L, luaH_setnum(L, t, i+1), &t->array[i]);
    }
    /* shrink array */
    luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
  }
  /* re-insert elements from hash part */
  for (i = twoto(oldhsize) - 1; i >= 0; i--) {
    Node *old = nold+i;
    if (!ttisnil(gval(old)))
      setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));
  }
  if (nold != dummynode)
    luaM_freearray(L, nold, twoto(oldhsize), Node);  /* free old array */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x38(%rsi), %r12
movzbl 0xb(%rsi), %r14d
movq 0x20(%rsi), %rbp
cmpl %edx, %r12d
jge 0xd623
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %ecx, 0x8(%rsp)
callq 0xd7f5
movl 0x8(%rsp), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movl %ecx, %edx
callq 0xd943
cmpl %r13d, %r12d
jle 0xd6df
movl %r14d, 0x4(%rsp)
movq %rbp, 0x8(%rsp)
movl %r13d, 0x38(%r15)
movslq %r13d, %rax
movq %r12, 0x18(%rsp)
negl %r12d
movq %r13, 0x20(%rsp)
leal 0x1(%r13), %ebp
shlq $0x4, %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rax), %r14
movq 0x18(%r15), %r13
cmpl $0x0, (%r13,%r14)
je 0xd691
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xdf96
movq -0x8(%r13,%r14), %rcx
movq %rcx, (%rax)
movl (%r13,%r14), %ecx
movl %ecx, 0x8(%rax)
leal (%r12,%rbp), %eax
incl %eax
movl %ebp, %ecx
incl %ecx
addq $0x10, %r14
movl %ecx, %ebp
cmpl $0x1, %eax
jne 0xd668
cmpl $-0x1, 0x20(%rsp)
jl 0xd6c9
movq 0x18(%r15), %rsi
movq 0x18(%rsp), %rdx
shlq $0x4, %rdx
movq %rbx, %rdi
movq 0x10(%rsp), %rcx
callq 0xa1f6
jmp 0xd6d1
movq %rbx, %rdi
callq 0xa242
movq 0x8(%rsp), %rbp
movl 0x4(%rsp), %r14d
movq %rax, 0x18(%r15)
movl $0x1, %r12d
movl %r14d, %ecx
shll %cl, %r12d
cmpl $0x1f, %r14d
movq %rbp, %r13
je 0xd73b
leal 0x1(%r12), %ebp
leal -0x1(%r12), %eax
leaq (%rax,%rax,4), %rax
leaq 0x10(,%rax,8), %r14
addq %r13, %r14
cmpl $0x0, -0x8(%r14)
je 0xd730
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xdc86
movq -0x10(%r14), %rcx
movq %rcx, (%rax)
movl -0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
decl %ebp
addq $-0x28, %r14
cmpl $0x1, %ebp
jg 0xd70d
leaq 0xe4b6(%rip), %rax      # 0x1bbf8
cmpq %rax, %r13
je 0xd76d
movslq %r12d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movq %rbx, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa1f6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x40, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movl $0x5, %edx
callq 0x9a82
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movw $0xff, 0xa(%r15)
movl $0x0, 0x38(%r15)
leaq 0xe42f(%rip), %rax      # 0x1bbf8
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xd7f5
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0xd943
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: setarrayvector
static void setarrayvector (lua_State *L, Table *t, int size) {
  int i;
  luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
  for (i=t->sizearray; i<size; i++)
     setnilvalue(&t->array[i]);
  t->sizearray = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movslq %edx, %r15
cmpl $-0x1, %edx
jl 0xd821
movq 0x18(%r14), %rsi
movslq 0x38(%r14), %rdx
shlq $0x4, %rdx
movq %r15, %rcx
shlq $0x4, %rcx
callq 0xa1f6
jmp 0xd826
callq 0xa242
movq %rax, 0x18(%r14)
movslq 0x38(%r14), %rdx
cmpl %ebx, %edx
jge 0xd939
subq %rdx, %r15
leaq 0x3(%r15), %rcx
andq $-0x4, %rcx
decq %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shlq $0x4, %rdx
addq %rdx, %rax
addq $0x38, %rax
xorl %edx, %edx
movdqa 0xda0d(%rip), %xmm1     # 0x1b270
movdqa 0xda15(%rip), %xmm2     # 0x1b280
movdqa 0xda1d(%rip), %xmm3     # 0x1b290
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0xd8c5
movl $0x0, -0x30(%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0xd8db
movl $0x0, -0x20(%rax)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0xd917
movl $0x0, -0x10(%rax)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0xd928
movl $0x0, (%rax)
addq $0x4, %rdx
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0xd87b
movl %ebx, 0x38(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
leaq 0xe1c8(%rip), %rax      # 0x1bbf8
cmpq %rax, %rsi
je 0xda53
movb 0xb(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
cltq
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movq 0x18(%rbx), %rsi
movslq 0x38(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa1f6
movl $0x40, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa1f6
// File: /workspace/github_c_makefile_star2_O3/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:
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rsi), %eax
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x20(%rdi), %rax
leaq 0xdb47(%rip), %rcx      # 0x1b660
cmpl $0x4, 0x18(%rax)
jne 0xdb25
cmpq %rsi, 0x10(%rax)
je 0xdb31
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xdb19
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl 0x8(%rsi), %eax
leaq 0xdb1f(%rip), %rbx      # 0x1b660
testl %eax, %eax
je 0xdbdc
movq %rsi, %r14
cmpl $0x3, %eax
je 0xdb8b
cmpl $0x4, %eax
jne 0xdbae
movb 0xb(%rdi), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
movq (%r14), %rax
notl %edx
andl 0xc(%rax), %edx
leaq (%rdx,%rdx,4), %rcx
shlq $0x3, %rcx
addq 0x20(%rdi), %rcx
cmpl $0x4, 0x18(%rcx)
jne 0xdb80
cmpq %rax, 0x10(%rcx)
je 0xdbd9
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
jne 0xdb74
jmp 0xdbdc
movsd (%r14), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xdbae
jp 0xdbae
cvttsd2si %xmm0, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xda82
movq %r14, %rsi
callq 0xdbe5
movq %rax, %r15
leaq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0xa2d1
testl %eax, %eax
jne 0xdbd4
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0xdbb9
jmp 0xdbdc
movq %r15, %rbx
jmp 0xdbdc
movq %rcx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x8(%rsi), %eax
decl %eax
cmpl $0x3, %eax
ja 0xdc0f
leaq 0xdff2(%rip), %rcx      # 0x1bbe8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl (%rsi), %eax
jmp 0xdc56
movb 0xb(%rdi), %cl
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
shll %cl, %r8d
movl (%rsi), %eax
notl %r8d
orl $0x1, %r8d
xorl %edx, %edx
divl %r8d
leaq (%rdx,%rdx,4), %rax
jmp 0xdc5a
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xdc63
jp 0xdc63
movq 0x20(%rdi), %rax
retq
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
movq (%rsi), %rcx
notl %eax
andl 0xc(%rcx), %eax
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x20(%rdi), %rax
retq
movq %xmm0, %rdx
movq %rdx, %rax
movb 0xb(%rdi), %cl
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shll %cl, %esi
shrq $0x20, %rax
addl %edx, %eax
notl %esi
orl $0x1, %esi
xorl %edx, %edx
divl %esi
jmp 0xdc29
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xdb32
movb $0x0, 0xa(%r14)
leaq 0xd9b5(%rip), %rcx      # 0x1b660
cmpq %rcx, %rax
je 0xdcb6
popq %rbx
popq %r14
popq %r15
retq
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xdcd5
cmpl $0x3, %eax
jne 0xdce6
movsd (%rbx), %xmm0
ucomisd %xmm0, %xmm0
jnp 0xdce6
leaq 0xdf60(%rip), %rsi      # 0x1bc33
jmp 0xdcdc
leaq 0xdf44(%rip), %rsi      # 0x1bc20
movq %r15, %rdi
xorl %eax, %eax
callq 0x7672
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xdcf6
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0xda82
leaq 0xd6a9(%rip), %rcx      # 0x1b660
cmpq %rcx, %rax
jne 0xdfd9
cvtsi2sd %ebp, %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdcf6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x18, %rsp
movb 0xb(%rsi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rdx), %eax
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x20(%rsi), %rax
cmpl $0x4, 0x18(%rax)
jne 0xe00d
cmpq %rdx, 0x10(%rax)
je 0xe02f
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xe001
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movl $0x4, 0x8(%rax)
movq %rax, %rdx
callq 0xdcf6
jmp 0xe03b
leaq 0xd62a(%rip), %rcx      # 0x1b660
cmpq %rcx, %rax
je 0xe016
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl $0x3, 0x8(%rdi)
jne 0xe17b
movsd (%rdi), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe17b
jnp 0xe17c
retq
cvttsd2si %xmm0, %edi
decl %edi
cmpl $0x3ffffff, %edi        # imm = 0x3FFFFFF
ja 0xe17b
pushq %rbx
movq %rsi, %rbx
callq 0xa29e
cltq
incl 0x4(%rbx,%rax,4)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe23e
cmpl $0x5, %eax
jne 0xe247
movq (%rsi), %rax
addq $0x10, %rax
jmp 0xe255
movq 0x20(%rdi), %rcx
leaq (%rcx,%rax,8), %rax
addq $0xe0, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xe273
movq 0x20(%rdi), %rcx
movl %edx, %edx
movq 0x128(%rcx,%rdx,8), %rsi
movq %rax, %rdi
jmp 0xdaf7
leaq 0xd3e6(%rip), %rax      # 0x1b660
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movzbl (%rcx), %eax
cmpl $0x1b, %eax
je 0xe2a2
movq %rcx, %r14
cmpl $0x40, %eax
je 0xe29d
cmpl $0x3d, %eax
jne 0xe2a9
incq %r14
jmp 0xe2a9
leaq 0xda7b(%rip), %r14      # 0x1bd24
leaq 0x20(%rsp), %rdi
movq %r14, 0x18(%rdi)
movq %rbx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movl $0x61754c1b, 0x8(%rsp)  # imm = 0x61754C1B
movabsq $0x8040804010051, %rax  # imm = 0x8040804010051
movq %rax, 0xc(%rsp)
leaq 0x14(%rsp), %r15
movl $0xc, %edx
movq %r15, %rsi
callq 0xe9c5
movq 0x8(%rsp), %rax
xorq (%r15), %rax
movl 0x10(%rsp), %ecx
xorl 0x8(%r15), %ecx
orq %rax, %rcx
je 0xe323
leaq 0xda4d(%rip), %rsi      # 0x1bd4f
leaq 0xda2c(%rip), %rcx      # 0x1bd35
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa6eb
movq %rbx, %rdi
movl $0x3, %esi
callq 0x79b5
leaq 0xda08(%rip), %rsi      # 0x1bd32
movl $0x2, %edx
movq %rbx, %rdi
callq 0xd282
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xe34e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lundump.c
// Function: LoadInt
static int LoadInt(LoadState* S)
{
 int x;
 LoadVar(S,x);
 IF (x<0, "bad integer");
 return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x4, %edx
movq %r14, %rsi
callq 0xe9c5
movl (%r14), %eax
testl %eax, %eax
jns 0xeaab
movq (%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0xd2c3(%rip), %rsi      # 0x1bd4f
leaq 0xd2ef(%rip), %rcx      # 0x1bd82
xorl %eax, %eax
callq 0xa6eb
movq (%rbx), %rdi
movl $0x3, %esi
callq 0x79b5
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xeaf5
cmpl $0x4, %eax
jne 0xeaf1
movq %rsi, %rbx
movq (%rdi), %rdi
addq $0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0xa31e
testl %eax, %eax
je 0xeaf1
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movl $0x3, 0x8(%rbx)
jmp 0xeaf8
xorl %ebx, %ebx
jmp 0xeaf8
movq %rdi, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeb5e
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm0
leaq 0xd35d(%rip), %rsi      # 0x1be80
movq %rsp, %r15
movq %r15, %rdi
movb $0x1, %al
callq 0x44c0
movq %r15, %rdi
callq 0x4140
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd282
movq %rax, (%rbx)
movl $0x4, 0x8(%rbx)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq %rdi, %r15
movl 0x8(%rsi), %eax
movl $0x64, %ebx
cmpl $0x5, %eax
jne 0xebcb
movq (%r12), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0xdb32
movq %rax, %r13
cmpl $0x0, 0x8(%rax)
jne 0xec25
movq 0x10(%rbp), %rdi
testq %rdi, %rdi
je 0xec25
testb $0x1, 0xa(%rdi)
jne 0xec25
movq 0x20(%r15), %rax
movq 0x128(%rax), %rdx
xorl %esi, %esi
callq 0xe204
movq %rax, %rbp
testq %rax, %rax
jne 0xebf3
jmp 0xec25
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xe22f
movq %rax, %rbp
cmpl $0x0, 0x8(%rax)
jne 0xebf3
movq %r15, %rdi
movq %r12, %rsi
leaq 0xe25f(%rip), %rdx      # 0x1ce4d
callq 0x7450
movl 0x8(%rbp), %eax
cmpl $0x6, %eax
je 0xec46
movq %rbp, %r12
decl %ebx
jne 0xeb7f
leaq 0xd279(%rip), %rsi      # 0x1be86
movq %r15, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7672
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
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 0xec66
// File: /workspace/github_c_makefile_star2_O3/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 0xecca
movq %r14, %rdi
movl $0x3, %esi
callq 0x7c11
movq 0x10(%r14), %rsi
subq %r15, %rbx
leaq 0x30(%rsi), %rax
movq %rax, 0x10(%r14)
movq %r14, %rdi
movl $0x1, %edx
callq 0x83a9
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_O3/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
movl 0x8(%rsi), %eax
movl $0x64, %r15d
cmpl $0x5, %eax
jne 0xed8a
movq (%r12), %rbp
movq %rbx, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
callq 0xdc86
movq %rax, %r13
cmpl $0x0, 0x8(%rax)
jne 0xedee
movq 0x10(%rbp), %rdi
testq %rdi, %rdi
je 0xedee
testb $0x2, 0xa(%rdi)
jne 0xedee
movq 0x20(%rbx), %rax
movq 0x130(%rax), %rdx
movl $0x1, %esi
callq 0xe204
movq %rax, %r14
testq %rax, %rax
jne 0xedb5
jmp 0xedee
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xe22f
movq %rax, %r14
cmpl $0x0, 0x8(%rax)
jne 0xedb5
movq %rbx, %rdi
movq %r12, %rsi
leaq 0xe09d(%rip), %rdx      # 0x1ce4d
callq 0x7450
movl 0x8(%r14), %eax
cmpl $0x6, %eax
je 0xee35
movq (%r14), %rcx
movq %rcx, 0x18(%rsp)
movl %eax, 0x20(%rsp)
leaq 0x18(%rsp), %r12
decl %r15d
jne 0xed2e
leaq 0xd0b8(%rip), %rsi      # 0x1be97
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7672
jmp 0xeeba
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movq %rax, (%r13)
movl 0x8(%rcx), %eax
movl %eax, 0x8(%r13)
movb $0x0, 0xa(%rbp)
cmpl $0x4, %eax
jl 0xeeba
movq (%rcx), %rax
testb $0x3, 0x9(%rax)
je 0xeeba
testb $0x4, 0x9(%rbp)
je 0xeeba
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x9a6d
jmp 0xeeba
movq 0x10(%rbx), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
movl 0x8(%r14), %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 0xeea8
movq %rbx, %rdi
movl $0x4, %esi
callq 0x7c11
movq 0x10(%rbx), %rsi
leaq 0x40(%rsi), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x83a9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/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 0xef27
cmpl $0x4, %eax
je 0xeef9
cmpl $0x3, %eax
jne 0xef09
movsd (%rbx), %xmm0
xorl %eax, %eax
ucomisd (%r14), %xmm0
seta %al
jmp 0xef21
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0xef3a
shrl $0x1f, %eax
jmp 0xef21
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0xd, %ecx
callq 0xefbe
cmpl $-0x1, %eax
je 0xef27
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x77f2
// File: /workspace/github_c_makefile_star2_O3/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 0xe22f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x8(%rax)
je 0xf039
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xe22f
movq %r13, %rdi
movq %rax, %rsi
callq 0xa2d1
testl %eax, %eax
je 0xf039
movq 0x10(%r14), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xec66
movq 0x10(%r14), %rax
movl 0x8(%rax), %ebx
testl %ebx, %ebx
je 0xf039
cmpl $0x1, %ebx
jne 0xf034
xorl %ebx, %ebx
cmpl $0x0, (%rax)
setne %bl
jmp 0xf039
movl $0x1, %ebx
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_O3/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 0xf0c5
movq %rdi, %r15
movb $0x1, %r12b
leaq 0xcd2e(%rip), %rcx      # 0x1bd9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rax
movq (%rbx), %rcx
cmpq %rcx, %rax
je 0xf0f0
movq 0x10(%rax), %rsi
movq 0x10(%rcx), %rdx
movq %r15, %rdi
callq 0xf100
testq %rax, %rax
je 0xf0ed
movq 0x10(%r15), %rsi
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xec66
movq 0x10(%r15), %rax
movl 0x8(%rax), %ecx
testl %ecx, %ecx
je 0xf0ed
cmpl $0x1, %ecx
jne 0xf0f0
cmpl $0x0, (%rax)
setne %r12b
jmp 0xf0f0
movq (%r14), %rax
cmpq (%rbx), %rax
jmp 0xf0d2
movl (%r14), %eax
cmpl (%rbx), %eax
sete %r12b
jmp 0xf0f0
movsd (%rbx), %xmm0
cmpeqsd (%r14), %xmm0
movq %xmm0, %r12
andl $0x1, %r12d
jmp 0xf0f0
xorl %r12d, %r12d
movzbl %r12b, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/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 0xf17f
movq %rsi, %r12
testb $0x10, 0xa(%rsi)
jne 0xf17f
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%rdi), %rax
movq 0x148(%rax), %rdx
movq %r12, %rdi
movl $0x4, %esi
callq 0xe204
testq %rax, %rax
je 0xf17f
movq %rax, %rbx
cmpq %r14, %r12
je 0xf181
testq %r14, %r14
je 0xf17f
testb $0x10, 0xa(%r14)
jne 0xf17f
movq 0x20(%r15), %rax
movq 0x148(%rax), %rdx
movq %r14, %rdi
movl $0x4, %esi
callq 0xe204
testq %rax, %rax
je 0xf17f
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa2d1
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rcx, %rbx
jmp 0xf181
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/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 0xe22f
cmpl $0x0, 0x8(%rax)
jne 0xf3c9
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xe22f
cmpl $0x0, 0x8(%rax)
je 0xf3eb
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xec66
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xf3e2
// File: /workspace/github_c_makefile_star2_O3/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 0xeab4
testq %rax, %rax
je 0x10645
movq %rax, %rbp
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xeab4
testq %rax, %rax
je 0x10645
movsd (%rbp), %xmm0
movsd (%rax), %xmm1
addl $-0x5, %r15d
leaq 0xb81e(%rip), %rax      # 0x1be54
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
addsd %xmm1, %xmm0
jmp 0x106af
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %r15d, %r8d
callq 0xf391
testl %eax, %eax
jne 0x106ba
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x77b2
jmp 0x106ba
movapd %xmm0, 0x10(%rsp)
divsd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x4480
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
jmp 0x106b3
mulsd %xmm1, %xmm0
jmp 0x106af
divsd %xmm1, %xmm0
jmp 0x106af
subsd %xmm1, %xmm0
jmp 0x106af
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 0xb79f(%rip), %xmm0     # 0x1be70
movlpd %xmm0, (%rbx)
jmp 0x106b3
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x10737
movq 0x8(%rbx), %rax
jmp 0x10752
movq %rbx, %rdi
callq 0x106d8
cmpl $-0x1, %eax
je 0x10757
incq (%rbx)
movq 0x8(%rbx), %rax
decq %rax
movq %rax, 0x8(%rbx)
movzbl (%rax), %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x10755