LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: GCTM
static void GCTM (lua_State *L) {
  global_State *g = G(L);
  GCObject *o = g->tmudata->gch.next;  /* get first element */
  Udata *udata = rawgco2u(o);
  const TValue *tm;
  /* remove udata from `tmudata' */
  if (o == g->tmudata)  /* last element? */
    g->tmudata = NULL;
  else
    g->tmudata->gch.next = udata->uv.next;
  udata->uv.next = g->mainthread->next;  /* return it to `root' list */
  g->mainthread->next = o;
  makewhite(g, o);
  tm = fasttm(L, udata->uv.metatable, TM_GC);
  if (tm != NULL) {
    lu_byte oldah = L->allowhook;
    lu_mem oldt = g->GCthreshold;
    L->allowhook = 0;  /* stop debug hooks during GC tag method */
    g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
    setobj2s(L, L->top, tm);
    setuvalue(L, L->top+1, udata);
    L->top += 2;
    luaD_call(L, L->top - 2, 0);
    L->allowhook = oldah;  /* restore hooks */
    g->GCthreshold = oldt;  /* restore threshold */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x50(%r14), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x91ac
movq (%r15), %rcx
movq %rcx, (%rax)
jmp 0x91b4
movq $0x0, 0x50(%r14)
movq 0xb0(%r14), %rax
movq (%rax), %rax
movq %rax, (%r15)
movq 0xb0(%r14), %rax
movq %r15, (%rax)
movb 0x9(%r15), %al
andb $-0x8, %al
movb 0x20(%r14), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r15)
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x925b
testb $0x4, 0xa(%rdi)
jne 0x925b
movq 0x20(%rbx), %rax
movq 0x138(%rax), %rdx
movl $0x2, %esi
callq 0xe204
testq %rax, %rax
je 0x925b
movb 0x65(%rbx), %bpl
movq 0x70(%r14), %r12
movb $0x0, 0x65(%rbx)
movq 0x78(%r14), %rcx
addq %rcx, %rcx
movq %rcx, 0x70(%r14)
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq %r15, 0x10(%rax)
movl $0x7, 0x18(%rax)
movq 0x10(%rbx), %rsi
leaq 0x20(%rsi), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x83a9
movb %bpl, 0x65(%rbx)
movq %r12, 0x70(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_freeall
void luaC_freeall (lua_State *L) {
  global_State *g = G(L);
  int i;
  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
  sweepwholelist(L, &g->rootgc);
  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
    sweepwholelist(L, &g->strt.hash[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movb $0x43, 0x20(%r14)
leaq 0x28(%r14), %rsi
movq $-0x3, %rdx
callq 0x92c6
cmpl $0x0, 0xc(%r14)
jle 0x92ba
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq $-0x3, %rdx
callq 0x92c6
incq %r12
movslq 0xc(%r14), %rax
addq $0x8, %r15
cmpq %rax, %r12
jl 0x9295
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/lgc.c
// Function: sweeplist
static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
  GCObject *curr;
  global_State *g = G(L);
  int deadmask = otherwhite(g);
  while ((curr = *p) != NULL && count-- > 0) {
    if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */
      sweepwholelist(L, &gco2th(curr)->openupval);
    if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */
      lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
      makewhite(g, curr);  /* make it white (for next cycle) */
      p = &curr->gch.next;
    }
    else {  /* must erase `curr' */
      lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
      *p = curr->gch.next;
      if (curr == g->rootgc)  /* is the first element of the list? */
        g->rootgc = curr->gch.next;  /* adjust first */
      freeobj(L, curr);
    }
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq (%rsi), %r12
testq %r12, %r12
je 0x93ec
movq %rdx, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r13
movb 0x20(%r13), %bpl
xorb $0x3, %bpl
incq %rbx
decq %rbx
je 0x93ec
cmpb $0x8, 0x8(%r12)
jne 0x931d
leaq 0x98(%r12), %rsi
movq %r14, %rdi
movq $-0x3, %rdx
callq 0x92c6
movb 0x9(%r12), %al
movl %eax, %ecx
xorb $0x3, %cl
testb %bpl, %cl
je 0x9341
andb $-0x8, %al
movb 0x20(%r13), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%r12)
jmp 0x93dc
movq (%r12), %rax
movq %rax, (%r15)
cmpq 0x28(%r13), %r12
jne 0x9352
movq %rax, 0x28(%r13)
movzbl 0x8(%r12), %eax
addl $-0x4, %eax
cmpl $0x6, %eax
ja 0x93d9
leaq 0x12265(%rip), %rcx     # 0x1b5cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%r14), %rax
decl 0x8(%rax)
movq 0x10(%r12), %rdx
addq $0x19, %rdx
jmp 0x93a5
movq %r14, %rdi
movq %r12, %rsi
callq 0xce1d
jmp 0x93d9
movq %r14, %rdi
movq %r12, %rsi
callq 0x9028
jmp 0x93d9
movq 0x20(%r12), %rdx
addq $0x28, %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xa1f6
jmp 0x93d9
movq %r14, %rdi
movq %r12, %rsi
callq 0xda1b
jmp 0x93d9
movq %r14, %rdi
movq %r12, %rsi
callq 0x8f84
jmp 0x93d9
movq %r14, %rdi
movq %r12, %rsi
callq 0x8e72
movq %r15, %r12
movq %r12, %r15
movq (%r12), %r12
testq %r12, %r12
jne 0x92f5
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_step
void luaC_step (lua_State *L) {
  global_State *g = G(L);
  l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
  if (lim == 0)
    lim = (MAX_LUMEM-1)/2;  /* no limit */
  g->gcdept += g->totalbytes - g->GCthreshold;
  do {
    lim -= singlestep(L);
    if (g->gcstate == GCSpause)
      break;
  } while (lim > 0);
  if (g->gcstate != GCSpause) {
    if (g->gcdept < GCSTEPSIZE)
      g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/
    else {
      g->gcdept -= GCSTEPSIZE;
      g->GCthreshold = g->totalbytes;
    }
  }
  else {
    setthreshold(g);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movl 0x94(%r14), %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
testl %eax, %eax
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
cmovneq %rax, %r15
movq 0x78(%r14), %rax
subq 0x70(%r14), %rax
addq %rax, 0x88(%r14)
movq %rbx, %rdi
callq 0x94af
movb 0x21(%r14), %cl
testb %cl, %cl
je 0x944d
subq %rax, %r15
testq %r15, %r15
jg 0x9435
testb %cl, %cl
je 0x946b
movq 0x88(%r14), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x9494
movl $0x400, %eax            # imm = 0x400
addq 0x78(%r14), %rax
jmp 0x94a5
movq 0x80(%r14), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shrq $0x2, %rdx
movslq 0x90(%r14), %rax
imulq %rdx, %rax
jmp 0x94a5
addq $-0x400, %rax           # imm = 0xFC00
movq %rax, 0x88(%r14)
movq 0x78(%r14), %rax
movq %rax, 0x70(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_fullgc
void luaC_fullgc (lua_State *L) {
  global_State *g = G(L);
  if (g->gcstate <= GCSpropagate) {
    /* reset sweep marks to sweep all elements (returning them to white) */
    g->sweepstrgc = 0;
    g->sweepgc = &g->rootgc;
    /* reset other collector lists */
    g->gray = NULL;
    g->grayagain = NULL;
    g->weak = NULL;
    g->gcstate = GCSsweepstring;
  }
  lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
  /* finish any pending sweep phase */
  while (g->gcstate != GCSfinalize) {
    lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
    singlestep(L);
  }
  markroot(L);
  while (g->gcstate != GCSpause) {
    singlestep(L);
  }
  setthreshold(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movb 0x21(%r14), %al
cmpb $0x1, %al
ja 0x98a8
movl $0x0, 0x24(%r14)
leaq 0x28(%r14), %rax
movq %rax, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movq $0x0, 0x48(%r14)
movb $0x2, 0x21(%r14)
jmp 0x98ac
cmpb $0x4, %al
je 0x98bb
movq %rbx, %rdi
callq 0x94af
cmpb $0x4, 0x21(%r14)
jne 0x98ac
movq %rbx, %rdi
callq 0x9907
cmpb $0x0, 0x21(%r14)
je 0x98d4
movq %rbx, %rdi
callq 0x94af
jmp 0x98c3
movq 0x80(%r14), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shrq $0x2, %rdx
movslq 0x90(%r14), %rax
imulq %rdx, %rax
movq %rax, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: markroot
static void markroot (lua_State *L) {
  global_State *g = G(L);
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  markobject(g, g->mainthread);
  /* make global table be traversed before main stack */
  markvalue(g, gt(g->mainthread));
  markvalue(g, registry(L));
  markmt(g);
  g->gcstate = GCSpropagate;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x48(%rbx)
movq 0xb0(%rbx), %rsi
testb $0x3, 0x9(%rsi)
je 0x993d
movq %rbx, %rdi
callq 0x99ae
movq 0xb0(%rbx), %rsi
cmpl $0x4, 0x80(%rsi)
jl 0x9958
movq 0x78(%rsi), %rsi
testb $0x3, 0x9(%rsi)
je 0x9958
movq %rbx, %rdi
callq 0x99ae
movq 0x20(%r14), %rax
cmpl $0x4, 0xa8(%rax)
jl 0x997a
movq 0xa0(%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0x997a
movq %rbx, %rdi
callq 0x99ae
movq %rbx, %rdi
callq 0xa11a
movb $0x1, 0x21(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_barrierf
void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
  global_State *g = G(L);
  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
  lua_assert(ttype(&o->gch) != LUA_TTABLE);
  /* must keep invariant? */
  if (g->gcstate == GCSpropagate)
    reallymarkobject(g, v);  /* restore invariant */
  else  /* don't mind */
    makewhite(g, o);  /* mark as white just to avoid other barriers */
}

// Assembly:
movq 0x20(%rdi), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x999d
movq %rdx, %rsi
jmp 0x99ae
movb 0x9(%rsi), %al
andb $-0x8, %al
movb 0x20(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: reallymarkobject
static void reallymarkobject (global_State *g, GCObject *o) {
  lua_assert(iswhite(o) && !isdead(g, o));
  white2gray(o);
  switch (o->gch.tt) {
    case LUA_TSTRING: {
      return;
    }
    case LUA_TUSERDATA: {
      Table *mt = gco2u(o)->metatable;
      gray2black(o);  /* udata are never gray */
      if (mt) markobject(g, mt);
      markobject(g, gco2u(o)->env);
      return;
    }
    case LUA_TUPVAL: {
      UpVal *uv = gco2uv(o);
      markvalue(g, uv->v);
      if (uv->v == &uv->u.value)  /* closed? */
        gray2black(o);  /* open upvalues are never black */
      return;
    }
    case LUA_TFUNCTION: {
      gco2cl(o)->c.gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TTABLE: {
      gco2h(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TTHREAD: {
      gco2th(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    case LUA_TPROTO: {
      gco2p(o)->gclist = g->gray;
      g->gray = o;
      break;
    }
    default: lua_assert(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x9(%rsi), %al
andb $-0x4, %al
movb %al, 0x9(%rbx)
movzbl 0x8(%rbx), %ecx
cmpl $0x7, %ecx
jne 0x99f2
movq 0x10(%rbx), %rsi
orb $0x4, %al
movb %al, 0x9(%rbx)
testq %rsi, %rsi
je 0x99e5
testb $0x3, 0x9(%rsi)
je 0x99e5
movq %r14, %rdi
callq 0x99ae
movq 0x18(%rbx), %rbx
movb 0x9(%rbx), %al
testb $0x3, %al
jne 0x99bb
jmp 0x9a37
addl $-0x5, %ecx
cmpl $0x5, %ecx
ja 0x9a37
leaq 0x11bfb(%rip), %rax     # 0x1b5fc
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x38(%r14), %rax
movq %rax, 0x30(%rbx)
jmp 0x9a33
movq 0x38(%r14), %rax
movq %rax, 0x68(%rbx)
jmp 0x9a33
movq 0x38(%r14), %rax
movq %rax, 0xa0(%rbx)
jmp 0x9a33
movq 0x38(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rbx, 0x38(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%rbx), %rax
cmpl $0x4, 0x8(%rax)
jl 0x9a5e
movq (%rax), %rsi
testb $0x3, 0x9(%rsi)
je 0x9a5e
movq %r14, %rdi
callq 0x99ae
movq 0x10(%rbx), %rax
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
jne 0x9a37
orb $0x4, 0x9(%rbx)
jmp 0x9a37
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: luaC_linkupval
void luaC_linkupval (lua_State *L, UpVal *uv) {
  global_State *g = G(L);
  GCObject *o = obj2gco(uv);
  o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
  g->rootgc = o;
  if (isgray(o)) { 
    if (g->gcstate == GCSpropagate) {
      gray2black(o);  /* closed upvalues need barrier */
      luaC_barrier(L, uv, uv->v);
    }
    else {  /* sweep phase: sweep it (turning it into white) */
      makewhite(g, o);
      lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
    }
  }
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, (%rsi)
movq %rsi, 0x28(%rax)
movb 0x9(%rsi), %cl
testb $0x7, %cl
je 0x9ab5
retq
cmpb $0x1, 0x21(%rax)
jne 0x9ae7
movl %ecx, %eax
orb $0x4, %al
movb %al, 0x9(%rsi)
movq 0x10(%rsi), %rax
cmpl $0x4, 0x8(%rax)
jl 0x9ab4
movq (%rax), %rax
testb $0x3, 0x9(%rax)
je 0x9ab4
movq 0x20(%rdi), %rdi
cmpb $0x1, 0x21(%rdi)
jne 0x9af2
movq %rax, %rsi
jmp 0x99ae
movb 0x20(%rax), %al
andb $0x3, %al
orb %cl, %al
movb %al, 0x9(%rsi)
retq
movb 0x20(%rdi), %al
jmp 0x9aea
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lmem.c
// Function: luaM_growaux_
void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
                     int limit, const char *errormsg) {
  void *newblock;
  int newsize;
  if (*size >= limit/2) {  /* cannot double it? */
    if (*size >= limit)  /* cannot grow even a little? */
      luaG_runerror(L, errormsg);
    newsize = limit;  /* still have at least one free place */
  }
  else {
    newsize = (*size)*2;
    if (newsize < MINSIZEARRAY)
      newsize = MINSIZEARRAY;  /* minimum size */
  }
  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
  *size = newsize;  /* update only when everything else is OK */
  return newblock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl (%rdx), %eax
movl %r8d, %ecx
shrl $0x1f, %ecx
addl %r8d, %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0xa187
addl %eax, %eax
cmpl $0x5, %eax
movl $0x4, %r14d
cmovgel %eax, %r14d
jmp 0xa19c
movl %r8d, %r14d
cmpl %r8d, %eax
jl 0xa19c
movq %r15, %rdi
movq %r9, %rsi
xorl %eax, %eax
callq 0x7672
leal 0x1(%r14), %eax
movslq %eax, %rcx
movq $-0x3, %rax
xorl %edx, %edx
divq %r13
cmpq %rcx, %rax
jae 0xa1ca
leaq 0x1146d(%rip), %rsi     # 0x1b628
xorl %r12d, %r12d
movq %r15, %rdi
xorl %eax, %eax
callq 0x7672
jmp 0xa1e6
movslq (%rbx), %rdx
imulq %r13, %rdx
movslq %r14d, %rcx
imulq %r13, %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0xa1f6
movq %rax, %r12
movl %r14d, (%rbx)
movq %r12, %rax
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/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  global_State *g = G(L);
  lua_assert((osize == 0) == (block == NULL));
  block = (*g->frealloc)(g->ud, block, osize, nsize);
  if (block == NULL && nsize > 0)
    luaD_throw(L, LUA_ERRMEM);
  lua_assert((nsize == 0) == (block == NULL));
  g->totalbytes = (g->totalbytes - osize) + nsize;
  return block;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%rdi), %r13
movq 0x18(%r13), %rdi
callq *0x10(%r13)
movq %rax, %r12
testq %rbx, %rbx
je 0xa22e
testq %r12, %r12
jne 0xa22e
movq %r15, %rdi
movl $0x4, %esi
callq 0x79b5
subq %r14, %rbx
addq %rbx, 0x78(%r13)
movq %r12, %rax
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/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* expoent */
  while (x >= 16) {
    x = (x+1) >> 1;
    e++;
  }
  if (x < 8) return x;
  else return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
movl $0x8, %ecx
cmpl $0x10, %edi
jb 0xa274
incl %edi
movl %edi, %edx
shrl %edx
addl $0x8, %ecx
cmpl $0x1f, %edi
movl %edx, %edi
ja 0xa262
jmp 0xa276
movl %edi, %edx
leal -0x8(%rdx), %eax
orl %ecx, %eax
cmpl $0x8, %edx
cmovbl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_rawequalObj
int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
  if (ttype(t1) != ttype(t2)) return 0;
  else 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);  /* boolean true must be 1 !! */
    case LUA_TLIGHTUSERDATA:
      return pvalue(t1) == pvalue(t2);
    default:
      lua_assert(iscollectable(t1));
      return gcvalue(t1) == gcvalue(t2);
  }
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0xa2f4
cmpl $0x3, %eax
ja 0xa2f8
movl %eax, %eax
leaq 0x11369(%rip), %rcx     # 0x1b650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %al
jmp 0xa31a
xorl %eax, %eax
jmp 0xa31a
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0xa304
movl (%rdi), %eax
cmpl (%rsi), %eax
sete %al
jmp 0xa31a
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_str2d
int luaO_str2d (const char *s, lua_Number *result) {
  char *endptr;
  *result = lua_str2number(s, &endptr);
  if (endptr == s) return 0;  /* conversion failed */
  if (*endptr == 'x' || *endptr == 'X')  /* maybe an hexadecimal constant? */
    *result = cast_num(strtoul(s, &endptr, 16));
  if (*endptr == '\0') return 1;  /* most common case */
  while (isspace(cast(unsigned char, *endptr))) endptr++;
  if (*endptr != '\0') return 0;  /* invalid trailing characters? */
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x40e0
movsd %xmm0, (%rbx)
movq (%r15), %r15
cmpq %r14, %r15
je 0xa3b7
movzbl (%r15), %eax
movl %eax, %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0xa394
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x10, %edx
callq 0x4470
movq %rax, %xmm0
punpckldq 0x113fa(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x11402(%rip), %xmm0    # 0x1b780
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movq (%r15), %r15
movb (%r15), %al
testb %al, %al
je 0xa3bb
callq 0x4580
movq (%rax), %rax
movzbl (%r15), %ecx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xa3a0
xorl %eax, %eax
testb %cl, %cl
sete %al
jmp 0xa3c0
xorl %eax, %eax
jmp 0xa3c0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_chunkid
void luaO_chunkid (char *out, const char *source, size_t bufflen) {
  if (*source == '=') {
    strncpy(out, source+1, bufflen);  /* remove first char */
    out[bufflen-1] = '\0';  /* ensures null termination */
  }
  else {  /* out = "source", or "...source" */
    if (*source == '@') {
      size_t l;
      source++;  /* skip the `@' */
      bufflen -= sizeof(" '...' ");
      l = strlen(source);
      strcpy(out, "");
      if (l > bufflen) {
        source += (l-bufflen);  /* get last part of file name */
        strcat(out, "...");
      }
      strcat(out, source);
    }
    else {  /* out = [string "string"] */
      size_t len = strcspn(source, "\n\r");  /* stop at first newline */
      bufflen -= sizeof(" [string \"...\"] ");
      if (len > bufflen) len = bufflen;
      strcpy(out, "[string \"");
      if (source[len] != '\0') {  /* must truncate? */
        strncat(out, source, len);
        strcat(out, "...");
      }
      else
        strcat(out, source);
      strcat(out, "\"]");
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x40, %eax
je 0xa7a6
cmpl $0x3d, %eax
jne 0xa7df
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4090
movb $0x0, -0x1(%rbx,%r15)
jmp 0xa850
incq %r14
addq $-0x8, %r15
movq %r14, %rdi
callq 0x4140
movb $0x0, (%rbx)
subq %r15, %rax
jbe 0xa7cf
addq %rax, %r14
movq %rbx, %rdi
callq 0x4140
movl $0x2e2e2e, (%rbx,%rax)  # imm = 0x2E2E2E
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4490
leaq 0x10fb3(%rip), %rsi     # 0x1b799
movq %r14, %rdi
callq 0x4210
addq $-0x11, %r15
cmpq %r15, %rax
cmovbq %rax, %r15
movabsq $0x20676e697274735b, %rax # imm = 0x20676E697274735B
movq %rax, (%rbx)
movw $0x22, 0x8(%rbx)
cmpb $0x0, (%r14,%r15)
je 0xa832
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x41d0
movq %rbx, %rdi
callq 0x4140
movl $0x2e2e2e, (%rbx,%rax)  # imm = 0x2E2E2E
jmp 0xa83d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4490
movq %rbx, %rdi
callq 0x4140
movw $0x5d22, (%rbx,%rax)    # imm = 0x5D22
movb $0x0, 0x2(%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: luaY_parser
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
  struct LexState lexstate;
  struct FuncState funcstate;
  lexstate.buff = buff;
  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
  open_func(&lexstate, &funcstate);
  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
  luaX_next(&lexstate);  /* read first token */
  chunk(&lexstate);
  check(&lexstate, TK_EOS);
  close_func(&lexstate);
  lua_assert(funcstate.prev == NULL);
  lua_assert(funcstate.f->nups == 0);
  lua_assert(lexstate.fs == NULL);
  return funcstate.f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %rbx
movq %rdx, 0x48(%rbx)
movq %rcx, %rdi
callq 0x4140
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd282
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x130e6
leaq 0x60(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa8f6
movq (%r14), %rax
movb $0x2, 0x72(%rax)
movq %rbx, %rdi
callq 0x1315f
movq %rbx, %rdi
callq 0xa9e7
cmpl $0x11f, 0x10(%rbx)      # imm = 0x11F
je 0xa8da
movq %rsp, %rdi
movl $0x11f, %esi            # imm = 0x11F
callq 0xb59b
movq %rsp, %rdi
callq 0xb3b4
movq 0x60(%rsp), %rax
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: open_func
static void open_func (LexState *ls, FuncState *fs) {
  lua_State *L = ls->L;
  Proto *f = luaF_newproto(L);
  fs->f = f;
  fs->prev = ls->fs;  /* linked list of funcstates */
  fs->ls = ls;
  fs->L = L;
  ls->fs = fs;
  fs->pc = 0;
  fs->lasttarget = -1;
  fs->jpc = NO_JUMP;
  fs->freereg = 0;
  fs->nk = 0;
  fs->np = 0;
  fs->nlocvars = 0;
  fs->nactvar = 0;
  fs->bl = NULL;
  f->source = ls->source;
  f->maxstacksize = 2;  /* registers 0/1 are always valid */
  fs->h = luaH_new(L, 0, 0);
  /* anchor table of constants and prototype (to avoid being collected) */
  sethvalue2s(L, L->top, fs->h);
  incr_top(L);
  setptvalue2s(L, L->top, f);
  incr_top(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x8f25
movq %rax, %r14
movq %rax, (%r15)
movq 0x30(%r12), %rax
movq %rax, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %rbx, 0x20(%r15)
movq %r15, 0x30(%r12)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x30(%r15)
movl $0xffffffff, 0x38(%r15) # imm = 0xFFFFFFFF
xorl %eax, %eax
movq %rax, 0x28(%r15)
movq %rax, 0x3c(%r15)
movq %rax, 0x43(%r15)
movq 0x50(%r12), %rax
movq %rax, 0x40(%r14)
movb $0x2, 0x73(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd77c
movq %rax, 0x8(%r15)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x5, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0xa99e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7c11
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, 0x10(%rax)
movl $0x9, 0x18(%rax)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jg 0xa9d3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7c11
movq 0x10(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
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/lparser.c
// Function: check_match
static void check_match (LexState *ls, int what, int who, int where) {
  if (!testnext(ls, what)) {
    if (where == ls->linenumber)
      error_expected(ls, what);
    else {
      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
             LUA_QS " expected (to close " LUA_QS " at line %d)",
              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0x10(%rdi)
jne 0xb630
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1315f
movl %ecx, %ebp
cmpl %ecx, 0x4(%rbx)
jne 0xb647
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb59b
movl %edx, %r14d
movq 0x38(%rbx), %r15
movq %rbx, %rdi
callq 0x12f7b
movq %rax, %r12
movq %rbx, %rdi
movl %r14d, %esi
callq 0x12f7b
leaq 0x104b5(%rip), %rsi     # 0x1bb20
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0xa6eb
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13085
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: breakstat
static void breakstat (LexState *ls) {
  FuncState *fs = ls->fs;
  BlockCnt *bl = fs->bl;
  int upval = 0;
  while (bl && !bl->isbreakable) {
    upval |= bl->upval;
    bl = bl->previous;
  }
  if (!bl)
    luaX_syntaxerror(ls, "no loop to break");
  if (upval)
    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rbx
movq 0x28(%rbx), %r14
xorl %ebp, %ebp
testq %r14, %r14
je 0xb6b7
cmpb $0x0, 0xe(%r14)
jne 0xb6c6
movzbl 0xd(%r14), %eax
orl %eax, %ebp
movq (%r14), %r14
jmp 0xb69f
leaq 0x104ed(%rip), %rsi     # 0x1bbab
callq 0x13085
xorl %r14d, %r14d
testl %ebp, %ebp
je 0xb6e1
movzbl 0xc(%r14), %edx
movq %rbx, %rdi
movl $0x23, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x11983
addq $0x8, %r14
movq %rbx, %rdi
callq 0x119a1
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x119fe
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: primaryexp
static void primaryexp (LexState *ls, expdesc *v) {
  /* primaryexp ->
        prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
  FuncState *fs = ls->fs;
  prefixexp(ls, v);
  for (;;) {
    switch (ls->t.token) {
      case '.': {  /* field */
        field(ls, v);
        break;
      }
      case '[': {  /* `[' exp1 `]' */
        expdesc key;
        luaK_exp2anyreg(fs, v);
        yindex(ls, &key);
        luaK_indexed(fs, v, &key);
        break;
      }
      case ':': {  /* `:' NAME funcargs */
        expdesc key;
        luaX_next(ls);
        checkname(ls, &key);
        luaK_self(fs, v, &key);
        funcargs(ls, v);
        break;
      }
      case '(': case TK_STRING: case '{': {  /* funcargs */
        luaK_exp2nextreg(fs, v);
        funcargs(ls, v);
        break;
      }
      default: return;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %r15
movl 0x10(%rdi), %eax
cmpl $0x11d, %eax            # imm = 0x11D
je 0xc037
cmpl $0x28, %eax
jne 0xc044
movl 0x4(%r14), %ebp
movq %r14, %rdi
callq 0x1315f
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xb756
movq %r14, %rdi
movl $0x29, %esi
movl $0x28, %edx
movl %ebp, %ecx
callq 0xb610
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x11eb8
jmp 0xc053
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc660
jmp 0xc053
leaq 0xfa6d(%rip), %rsi      # 0x1bab8
movq %r14, %rdi
callq 0x13085
leaq 0x8(%rsp), %r12
movl 0x10(%r14), %eax
cmpl $0x5a, %eax
jg 0xc0b9
cmpl $0x28, %eax
je 0xc0ca
cmpl $0x2e, %eax
je 0xc10e
cmpl $0x3a, %eax
jne 0xc11e
movq %r14, %rdi
callq 0x1315f
movq %r14, %rdi
callq 0xc2db
movq 0x30(%r14), %rdi
movq %rax, %rsi
callq 0x11bc5
movq $-0x1, 0x18(%rsp)
movl $0x4, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x122ee
jmp 0xc0d5
cmpl $0x5b, %eax
je 0xc0e5
cmpl $0x7b, %eax
je 0xc0ca
cmpl $0x11e, %eax            # imm = 0x11E
jne 0xc11e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11f51
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc508
jmp 0xc058
movq %r15, %rdi
movq %rbx, %rsi
callq 0x120d8
movq %r14, %rdi
movq %r12, %rsi
callq 0xc29f
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x124f8
jmp 0xc058
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc4a6
jmp 0xc058
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: listfield
static void listfield (LexState *ls, struct ConsControl *cc) {
  expr(ls, &cc->v);
  luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
  cc->na++;
  cc->tostore++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0xb756
movl 0x24(%rbx), %eax
cmpl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
jl 0xc15e
movq 0x30(%r14), %rdi
leaq 0xf8b7(%rip), %rdx      # 0x1ba08
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0xc256
movl 0x24(%rbx), %eax
incl %eax
movl %eax, 0x24(%rbx)
incl 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: errorlimit
static void errorlimit (FuncState *fs, int limit, const char *what) {
  const char *msg = (fs->f->linedefined == 0) ?
    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
                            fs->f->linedefined, limit, what);
  luaX_lexerror(fs->ls, msg, 0);
}

// Assembly:
pushq %rbx
movq %rdx, %r8
movl %esi, %ecx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rdi), %rdi
movl 0x60(%rax), %edx
testl %edx, %edx
je 0xc27d
leaq 0xf7cd(%rip), %rsi      # 0x1ba41
xorl %eax, %eax
callq 0xa6eb
jmp 0xc290
leaq 0xf79b(%rip), %rsi      # 0x1ba1f
movl %ecx, %edx
movq %r8, %rcx
xorl %eax, %eax
callq 0xa6eb
movq 0x18(%rbx), %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
jmp 0x12fda
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: field
static void field (LexState *ls, expdesc *v) {
  /* field -> ['.' | ':'] NAME */
  FuncState *fs = ls->fs;
  expdesc key;
  luaK_exp2anyreg(fs, v);
  luaX_next(ls);  /* skip the dot or colon */
  checkname(ls, &key);
  luaK_indexed(fs, v, &key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x120d8
movq %r14, %rdi
callq 0x1315f
movq %r14, %rdi
callq 0xc2db
movq 0x30(%r14), %rdi
movq %rax, %rsi
callq 0x11bc5
leaq 0x8(%rsp), %rdx
movq $-0x1, 0x10(%rdx)
movl $0x4, (%rdx)
movl %eax, 0x8(%rdx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x124f8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: singlevar
static void singlevar (LexState *ls, expdesc *var) {
  TString *varname = str_checkname(ls);
  FuncState *fs = ls->fs;
  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0xc2db
movq %rax, %r14
movq 0x30(%r15), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xc6a3
cmpl $0x8, %eax
jne 0xc69d
movq %r15, %rdi
movq %r14, %rsi
callq 0x11bc5
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: singlevaraux
static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
  if (fs == NULL) {  /* no more levels? */
    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */
    return VGLOBAL;
  }
  else {
    int v = searchvar(fs, n);  /* look up at current level */
    if (v >= 0) {
      init_exp(var, VLOCAL, v);
      if (!base)
        markupval(fs, v);  /* local will be used as an upval */
      return VLOCAL;
    }
    else {  /* not found at current level; try upper one */
      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
        return VGLOBAL;
      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
      var->k = VUPVAL;  /* upvalue in this level */
      return VUPVAL;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
testq %rdi, %rdi
je 0xc726
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x4a(%rdi), %edx
testq %rdx, %rdx
jle 0xc747
movq (%rbx), %rax
movq 0x30(%rax), %rax
movzwl 0xc2(%rbx,%rdx,2), %esi
decq %rdx
shll $0x4, %esi
cmpq %r15, (%rax,%rsi)
jne 0xc6bd
movq $-0x1, 0x10(%r14)
movl $0x6, (%r14)
movl %edx, 0x8(%r14)
movl $0x6, %eax
testl %ecx, %ecx
jne 0xc87e
incq %rdx
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xc87e
movzbl 0xc(%rbx), %ecx
cmpq %rcx, %rdx
jle 0xc708
movb $0x1, 0xd(%rbx)
jmp 0xc87e
movq $-0x1, 0x10(%r14)
movl $0x8, (%r14)
movl $0xff, 0x8(%r14)
movl $0x8, %eax
jmp 0xc87e
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xc6a3
movl %eax, %ecx
movl $0x8, %eax
cmpl $0x8, %ecx
je 0xc87e
movq (%rbx), %r12
movl 0x48(%r12), %ebp
movzbl 0x70(%r12), %eax
testq %rax, %rax
je 0xc7c4
movl (%r14), %edx
xorl %ecx, %ecx
movzbl 0x4b(%rbx,%rcx,2), %esi
cmpl %esi, %edx
jne 0xc798
movzbl 0x4c(%rbx,%rcx,2), %esi
cmpl %esi, 0x8(%r14)
je 0xc86e
incq %rcx
cmpq %rcx, %rax
jne 0xc780
cmpb $0x3b, %al
jbe 0xc7c6
leaq 0xf31f(%rip), %rdx      # 0x1baca
movq %rbx, %rdi
movl $0x3c, %esi
callq 0xc256
movb 0x70(%r12), %al
movl 0x48(%r12), %ecx
jmp 0xc7c8
xorl %eax, %eax
movl %ebp, %ecx
movzbl %al, %eax
cmpl %eax, %ecx
jg 0xc7fe
leaq 0x48(%r12), %rdx
movq 0x20(%rbx), %rdi
movq 0x38(%r12), %rsi
leaq 0x109be(%rip), %r9      # 0x1d1a2
movl $0x8, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0xa150
movq %rax, 0x38(%r12)
movl 0x48(%r12), %ecx
cmpl %ecx, %ebp
jge 0xc81d
movslq %ebp, %rax
movslq %ecx, %rcx
movq 0x38(%r12), %rdx
movq $0x0, (%rdx,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0xc808
movq 0x38(%r12), %rdx
movzbl 0x70(%r12), %ecx
movl %ecx, %eax
movq %r15, (%rdx,%rcx,8)
testb $0x3, 0x9(%r15)
je 0xc854
testb $0x4, 0x9(%r12)
je 0xc854
movq 0x20(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x998e
movb 0x70(%r12), %al
movzbl %al, %ecx
movb (%r14), %dl
movb %dl, 0x4b(%rbx,%rcx,2)
movb 0x8(%r14), %dl
movb %dl, 0x4c(%rbx,%rcx,2)
leal 0x1(%rax), %ecx
movb %cl, 0x70(%r12)
movzbl %al, %ecx
movl %ecx, 0x8(%r14)
movl $0x7, (%r14)
movl $0x7, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: explist1
static int explist1 (LexState *ls, expdesc *v) {
  /* explist1 -> expr { `,' expr } */
  int n = 1;  /* at least one expression */
  expr(ls, v);
  while (testnext(ls, ',')) {
    luaK_exp2nextreg(ls->fs, v);
    expr(ls, v);
    n++;
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0xb756
movl $0x1, %ebp
cmpl $0x2c, 0x10(%r14)
jne 0xc8c9
movq %r14, %rdi
callq 0x1315f
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x11f51
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xb756
incl %ebp
jmp 0xc89d
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: leaveblock
static void leaveblock (FuncState *fs) {
  BlockCnt *bl = fs->bl;
  fs->bl = bl->previous;
  removevars(fs->ls, bl->nactvar);
  if (bl->upval)
    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
  /* a block either controls scope or breaks (never both) */
  lua_assert(!bl->isbreakable || !bl->upval);
  lua_assert(bl->nactvar == fs->nactvar);
  fs->freereg = fs->nactvar;  /* free registers */
  luaK_patchtohere(fs, bl->breaklist);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %r14
movq (%r14), %rcx
movq %rcx, 0x28(%rdi)
movzbl 0xc(%r14), %edx
movq 0x30(%rax), %rax
movzbl 0x4a(%rax), %ecx
cmpb %dl, %cl
jbe 0xc921
movl 0x30(%rax), %esi
movq (%rax), %rdi
movq 0x30(%rdi), %rdi
movl %edx, %r8d
movzwl 0xc2(%rax,%rcx,2), %r9d
decq %rcx
shll $0x4, %r9d
movl %esi, 0xc(%rdi,%r9)
cmpq %r8, %rcx
ja 0xc904
movb %cl, 0x4a(%rax)
cmpb $0x0, 0xd(%r14)
je 0xc93a
movq %rbx, %rdi
movl $0x23, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x11983
movzbl 0x4a(%rbx), %eax
movl %eax, 0x3c(%rbx)
movl 0x8(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11a86
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: forbody
static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
  /* forbody -> DO block */
  BlockCnt bl;
  FuncState *fs = ls->fs;
  int prep, endfor;
  adjustlocalvars(ls, 3);  /* control variables */
  checknext(ls, TK_DO);
  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
  enterblock(fs, &bl, 0);  /* scope for declared variables */
  adjustlocalvars(ls, nvars);
  luaK_reserveregs(fs, nvars);
  block(ls);
  leaveblock(fs);  /* end of scope for declared variables */
  luaK_patchtohere(fs, prep);
  endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
                     luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
  luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
  luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r12d
movl %ecx, %r15d
movl %edx, 0x4(%rsp)
movl %esi, %r14d
movq %rdi, %rbp
movq 0x30(%rdi), %rbx
movb 0x4a(%rbx), %dl
addb $0x3, %dl
movb %dl, 0x4a(%rbx)
movl 0x30(%rbx), %eax
movq (%rbx), %rcx
movq 0x30(%rcx), %rcx
movzbl %dl, %edx
leaq (%rbx,%rdx,2), %rdx
addq $0xbe, %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %edi
shll $0x4, %edi
movl %eax, 0x8(%rcx,%rdi)
incq %rsi
cmpq $0x3, %rsi
jne 0xc999
movq %rbp, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0xb73c
movq %rbx, %rdi
testl %r12d, %r12d
je 0xc9d6
movl $0x20, %esi
movl %r14d, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x119e8
jmp 0xc9db
callq 0x119a1
movl %eax, %r13d
leaq 0x8(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movb %cl, 0xe(%rax)
movb 0x4a(%rbx), %dl
movb %dl, 0xc(%rax)
movb %cl, 0xd(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x28(%rbx)
movq 0x30(%rbp), %rsi
movb 0x4a(%rsi), %dil
addb %r15b, %dil
movb %dil, 0x4a(%rsi)
testl %r15d, %r15d
je 0xca46
movl 0x30(%rsi), %eax
movq (%rsi), %rcx
movq 0x30(%rcx), %rcx
movslq %r15d, %rdx
negq %rdx
movzbl %dil, %edi
leaq (%rsi,%rdi,2), %rsi
addq $0xc4, %rsi
movzwl (%rsi,%rdx,2), %edi
shll $0x4, %edi
movl %eax, 0x8(%rcx,%rdi)
incq %rdx
jne 0xca36
movq %rbx, %rdi
movl %r15d, %esi
callq 0x11bab
movq %rbp, %rdi
callq 0xb5d1
movq %rbx, %rdi
callq 0xc8d0
movq %rbx, %rdi
movl %r13d, %esi
callq 0x11a86
movq %rbx, %rdi
testl %r12d, %r12d
je 0xca96
movl $0x1f, %esi
movl %r14d, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x119e8
movl %eax, %ebp
movq %rbx, %rdi
movl 0x4(%rsp), %esi
callq 0x12b94
jmp 0xcabe
movl $0x21, %esi
movl %r14d, %edx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x11983
movq %rbx, %rdi
movl 0x4(%rsp), %esi
callq 0x12b94
movq %rbx, %rdi
callq 0x119a1
movl %eax, %ebp
incl %r13d
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x11a62
addq $0x18, %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/lparser.c
// Function: assignment
static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
  expdesc e;
  check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
                      "syntax error");
  if (testnext(ls, ',')) {  /* assignment -> `,' primaryexp assignment */
    struct LHS_assign nv;
    nv.prev = lh;
    primaryexp(ls, &nv.v);
    if (nv.v.k == VLOCAL)
      check_conflict(ls, lh, &nv.v);
    luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
                    "variables in assignment");
    assignment(ls, &nv, nvars+1);
  }
  else {  /* assignment -> `=' explist1 */
    int nexps;
    checknext(ls, '=');
    nexps = explist1(ls, &e);
    if (nexps != nvars) {
      adjust_assign(ls, nvars, nexps, &e);
      if (nexps > nvars)
        ls->fs->freereg -= nexps - nvars;  /* remove extra values */
    }
    else {
      luaK_setoneret(ls->fs, &e);  /* close last expression */
      luaK_storevar(ls->fs, &lh->v, &e);
      return;  /* avoid default */
    }
  }
  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
  luaK_storevar(ls->fs, &lh->v, &e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %eax
addl $-0x6, %eax
cmpl $0x4, %eax
jb 0xcb85
leaq 0xf03f(%rip), %rsi      # 0x1bbbc
movq %r14, %rdi
callq 0x13085
leaq 0x8(%r15), %rbx
cmpl $0x2c, 0x10(%r14)
jne 0xcc7a
movq %r14, %rdi
callq 0x1315f
leaq 0x8(%rsp), %r12
movq %r15, -0x8(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0xbfd7
cmpl $0x6, (%r12)
jne 0xcc29
movq 0x30(%r14), %r12
movl 0x3c(%r12), %eax
xorl %edx, %edx
cmpl $0x9, 0x8(%r15)
jne 0xcbfa
movl 0x10(%rsp), %ecx
cmpl %ecx, 0x10(%r15)
jne 0xcbe1
movl %eax, 0x10(%r15)
movl $0x1, %edx
movl 0x10(%rsp), %ecx
cmpl %ecx, 0x14(%r15)
jne 0xcbfa
movl %eax, 0x14(%r15)
movq (%r15), %r15
movl $0x1, %edx
testq %r15, %r15
jne 0xcbc3
jmp 0xcc0a
movq (%r15), %r15
testq %r15, %r15
jne 0xcbc3
testl %edx, %edx
je 0xcc29
movl 0x10(%rsp), %ecx
movl 0x3c(%r12), %edx
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x11983
movq %r12, %rdi
movl $0x1, %esi
callq 0x11bab
movq 0x38(%r14), %rax
movzwl 0x60(%rax), %eax
movl $0xc8, %esi
subl %eax, %esi
cmpl %ebp, %esi
jge 0xcc4c
movq 0x30(%r14), %rdi
leaq 0xef82(%rip), %rdx      # 0x1bbc9
callq 0xc256
incl %ebp
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0xcb57
movq 0x30(%r14), %rdi
movl 0x3c(%rdi), %eax
decl %eax
movq $-0x1, 0x10(%rsp)
movl $0xc, (%rsp)
movl %eax, 0x8(%rsp)
jmp 0xcca6
movq %r14, %rdi
movl $0x3d, %esi
callq 0xb73c
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc887
movq 0x30(%r14), %rdi
cmpl %eax, %ebp
jne 0xccbe
movq %rsp, %rsi
callq 0x11e6b
movq 0x30(%r14), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x12206
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movq %rsp, %rcx
movl %ebp, %esi
movl %eax, %edx
callq 0xcadd
subl %r15d, %ebp
jge 0xcc5b
movq 0x30(%r14), %rax
addl %ebp, 0x3c(%rax)
jmp 0xcc5b
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: luaE_newthread
lua_State *luaE_newthread (lua_State *L) {
  lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
  luaC_link(L, obj2gco(L1), LUA_TTHREAD);
  preinit_state(L1, G(L));
  stack_init(L1, L);  /* init stack */
  setobj2n(L, gt(L1), gt(L));  /* share table of globals */
  L1->hookmask = L->hookmask;
  L1->basehookcount = L->basehookcount;
  L1->hook = L->hook;
  resethookcount(L1);
  lua_assert(iswhite(obj2gco(L1)));
  return L1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0xb8, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xa1f6
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x9a82
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r15, 0x40(%r14)
movl %r15d, 0x58(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%r14)
movw $0x100, 0x64(%r14)      # imm = 0x100
movups %xmm0, 0x68(%r14)
movq %r15, 0x98(%r14)
movb $0x0, 0xa(%r14)
movq %r15, 0x50(%r14)
movl %r15d, 0x80(%r14)
movups %xmm0, 0x28(%r14)
movq %r15, 0x5c(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcd92
movq 0x78(%rbx), %rax
movq %rax, 0x78(%r14)
movl 0x80(%rbx), %eax
movl %eax, 0x80(%r14)
movb 0x64(%rbx), %al
movb %al, 0x64(%r14)
movl 0x68(%rbx), %eax
movl %eax, 0x68(%r14)
movq 0x70(%rbx), %rcx
movq %rcx, 0x70(%r14)
movl %eax, 0x6c(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: luaE_freethread
void luaE_freethread (lua_State *L, lua_State *L1) {
  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
  lua_assert(L1->openupval == NULL);
  luai_userstatefree(L1);
  freestack(L, L1);
  luaM_freemem(L, fromstate(L1), state_size(lua_State));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rsi), %rsi
movq %rbx, %rdi
callq 0x8e9c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xce57
movl $0xb8, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa1f6