LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_storevar
void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
      exp2reg(fs, ex, var->u.s.info);
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
      break;
    }
    case VGLOBAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
      break;
    }
    case VINDEXED: {
      int e = luaK_exp2RK(fs, ex);
      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
      break;
    }
    default: {
      lua_assert(0);  /* invalid var kind to store */
      break;
    }
  }
  freeexp(fs, ex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x6, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x1d0df
movq -0x30(%rbp), %rax
leaq 0xf051(%rip), %rcx      # 0x2c078
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cbb0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x1cbe0
jmp 0x1d0ee
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cd40
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x8, %esi
xorl %r8d, %r8d
callq 0x1c1a0
jmp 0x1d0e1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cd40
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x7, %esi
callq 0x1c260
jmp 0x1d0e1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ce30
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movl -0x24(%rbp), %r8d
movl $0x9, %esi
callq 0x1c1a0
jmp 0x1d0e1
jmp 0x1d0e1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cbb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_self
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  int func;
  luaK_exp2anyreg(fs, e);
  freeexp(fs, e);
  func = fs->freereg;
  luaK_reserveregs(fs, 2);
  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
  freeexp(fs, key);
  e->u.s.info = func;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cd40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cbb0
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1c5c0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ce30
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x20(%rbp), %ecx
movl %eax, %r8d
movl $0xb, %esi
callq 0x1c1a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cbb0
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0xc, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
  expdesc e2;
  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
  switch (op) {
    case OPR_MINUS: {
      if (!isnumeral(e))
        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
      codearith(fs, OP_UNM, e, &e2);
      break;
    }
    case OPR_NOT: codenot(fs, e); break;
    case OPR_LEN: {
      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
      codearith(fs, OP_LEN, e, &e2);
      break;
    }
    default: lua_assert(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x5, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x1d430
jmp 0x1d41c
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x1d463
jmp 0x1d426
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x1d472
jmp 0x1d497
movq -0x18(%rbp), %rdi
callq 0x1d4a0
cmpl $0x0, %eax
jne 0x1d44b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cd40
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x12, %esi
leaq -0x30(%rbp), %rcx
callq 0x1d4e0
jmp 0x1d499
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d5c0
jmp 0x1d499
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cd40
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x14, %esi
leaq -0x30(%rbp), %rcx
callq 0x1d4e0
jmp 0x1d499
jmp 0x1d499
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: codearith
static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
  if (constfolding(op, e1, e2))
    return;
  else {
    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
    int o1 = luaK_exp2RK(fs, e1);
    if (o1 > o2) {
      freeexp(fs, e1);
      freeexp(fs, e2);
    }
    else {
      freeexp(fs, e2);
      freeexp(fs, e1);
    }
    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
    e1->k = VRELOCABLE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1e160
cmpl $0x0, %eax
je 0x1d511
jmp 0x1d5b2
cmpl $0x12, -0xc(%rbp)
je 0x1d52f
cmpl $0x14, -0xc(%rbp)
je 0x1d52f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1ce30
movl %eax, -0x2c(%rbp)
jmp 0x1d536
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d536
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ce30
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x1d570
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cbb0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cbb0
jmp 0x1d58a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cbb0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cbb0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %r8d
xorl %edx, %edx
callq 0x1c1a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0xb, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_code
static int luaK_code (FuncState *fs, Instruction i, int line) {
  Proto *f = fs->f;
  dischargejpc(fs);  /* `pc' will change */
  /* put new instruction in code array */
  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
                  MAX_INT, "code size overflow");
  f->code[fs->pc] = i;
  /* save corresponding line information */
  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
                  MAX_INT, "code size overflow");
  f->lineinfo[fs->pc] = line;
  return fs->pc++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e380
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jle 0x1dc53
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x50, %rdx
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
leaq 0xe57f(%rip), %r9       # 0x2c1c2
callq 0xf380
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jle 0x1dcb6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x54, %rdx
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
leaq 0xe51c(%rip), %r9       # 0x2c1c2
callq 0xf380
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rcx
movl 0x30(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x30(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_setlist
void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
  lua_assert(tostore != 0);
  if (c <= MAXARG_C)
    luaK_codeABC(fs, OP_SETLIST, base, b, c);
  else {
    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
  }
  fs->freereg = base + 1;  /* free registers with list values */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl $0x32, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1dd26
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x1dd2c
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1ff, -0x18(%rbp)     # imm = 0x1FF
jg 0x1dd55
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x22, %esi
callq 0x1c1a0
jmp 0x1dd83
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl $0x22, %esi
xorl %r8d, %r8d
callq 0x1c1a0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %edx
callq 0x1dbe0
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: discharge2reg
static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: {
      luaK_nil(fs, reg, 1);
      break;
    }
    case VFALSE:  case VTRUE: {
      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
      break;
    }
    case VK: {
      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
      break;
    }
    case VKNUM: {
      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VRELOCABLE: {
      Instruction *pc = &getcode(fs, e);
      SETARG_A(*pc, reg);
      break;
    }
    case VNONRELOC: {
      if (reg != e->u.s.info)
        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
      break;
    }
    default: {
      lua_assert(e->k == VVOID || e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.s.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c9f0
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0xb, %eax
ja 0x1e011
movq -0x28(%rbp), %rax
leaq 0xe21e(%rip), %rcx      # 0x2c130
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x1c080
jmp 0x1e013
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movl $0x2, %esi
xorl %r8d, %r8d
callq 0x1c1a0
jmp 0x1e013
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x1, %esi
callq 0x1c260
jmp 0x1e013
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x1c7f0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movl %eax, %ecx
movl $0x1, %esi
callq 0x1c260
jmp 0x1e013
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xffffc03f, %ecx       # imm = 0xFFFFC03F
movl -0x14(%rbp), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1e013
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x1e00f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
xorl %r8d, %r8d
movl %r8d, %esi
callq 0x1c1a0
jmp 0x1e013
jmp 0x1e027
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0xc, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_init
void luaX_init (lua_State *L) {
  int i;
  for (i=0; i<NUM_RESERVED; i++) {
    TString *ts = luaS_new(L, luaX_tokens[i]);
    luaS_fix(ts);  /* reserved words are never collected */
    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
    ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x15, -0xc(%rbp)
jge 0x1e454
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x17ea4(%rip), %rax     # 0x362a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x17e91(%rip), %rax     # 0x362a0
movq (%rax,%rcx,8), %rdi
callq 0x5150
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x140d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x9(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x9(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0xa(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e3e3
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_token2str
const char *luaX_token2str (LexState *ls, int token) {
  if (token < FIRST_RESERVED) {
    lua_assert(token == cast(unsigned char, token));
    return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
                              luaO_pushfstring(ls->L, "%c", token);
  }
  else
    return luaX_tokens[token-FIRST_RESERVED];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x101, -0x14(%rbp)     # imm = 0x101
jge 0x1e4d6
callq 0x5570
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1e4af
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0xdd9c(%rip), %rsi      # 0x2c23e
movb $0x0, %al
callq 0xfdb0
movq %rax, -0x20(%rbp)
jmp 0x1e4cc
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0xdd86(%rip), %rsi      # 0x2c247
movb $0x0, %al
callq 0xfdb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e4f0
movl -0x14(%rbp), %eax
subl $0x101, %eax            # imm = 0x101
movslq %eax, %rcx
leaq 0x17db8(%rip), %rax     # 0x362a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_lexerror
void luaX_lexerror (LexState *ls, const char *msg, int token) {
  char buff[MAXSRC];
  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
  if (token)
    luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
  luaD_throw(ls->L, LUA_ERRSYNTAX);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
addq $0x18, %rsi
movl $0x50, %edx
callq 0xfe50
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq -0x70(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %r8
leaq 0xd076(%rip), %rsi      # 0x2b5c4
movb $0x0, %al
callq 0xfdb0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1e598
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1e5c0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
leaq 0xdcb9(%rip), %rsi      # 0x2c24a
movb $0x0, %al
callq 0xfdb0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl $0x3, %esi
callq 0xaec0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: txtToken
static const char *txtToken (LexState *ls, int token) {
  switch (token) {
    case TK_NAME:
    case TK_STRING:
    case TK_NUMBER:
      save(ls, '\0');
      return luaZ_buffer(ls->buff);
    default:
      return luaX_token2str(ls, token);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0xfffffee4, %eax       # imm = 0xFFFFFEE4
subl $0x2, %eax
ja 0x1e5fa
jmp 0x1e5de
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1f200
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e60a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1e460
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_newstring
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
  lua_State *L = ls->L;
  TString *ts = luaS_newlstr(L, str, l);
  TValue *o = luaH_setstr(L, ls->fs->h, ts);  /* entry for `str' */
  if (ttisnil(o)) {
    setbvalue(o, 1);  /* make sure `str' will not be collected */
    luaC_checkGC(L);
  }
  return ts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x140d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x153b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1e6ee
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x1, (%rax)
movq -0x38(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x70(%rcx), %rax
jb 0x1e6ec
movq -0x20(%rbp), %rdi
callq 0xd970
jmp 0x1e6ee
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_setinput
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
  ls->decpoint = '.';
  ls->L = L;
  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
  ls->z = z;
  ls->fs = NULL;
  ls->linenumber = 1;
  ls->lastline = 1;
  ls->source = source;
  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
  next(ls);  /* read first char */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb $0x2e, 0x58(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movl $0x11f, 0x20(%rax)      # imm = 0x11F
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
movl $0x20, %ecx
callq 0xf470
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq $0x20, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1e7f6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x1e806
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1a4e0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: save
static void save (LexState *ls, int c) {
  Mbuffer *b = ls->buff;
  if (b->n + 1 > b->buffsize) {
    size_t newsize;
    if (b->buffsize >= MAX_SIZET/2)
      luaX_lexerror(ls, "lexical element too long", 0);
    newsize = b->buffsize * 2;
    luaZ_resizebuffer(ls->L, b, newsize);
  }
  b->buffer[b->n++] = cast(char, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x1f2ce
movq -0x18(%rbp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jb 0x1f25b
movq -0x8(%rbp), %rdi
leaq 0xd003(%rip), %rsi      # 0x2c257
xorl %edx, %edx
callq 0x1e500
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq $-0x3, %rax
ja 0x1f2a6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
movq -0x20(%rbp), %rcx
shlq $0x0, %rcx
callq 0xf470
movq %rax, -0x28(%rbp)
jmp 0x1f2b7
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xf500
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: check_next
static int check_next (LexState *ls, const char *set) {
  if (!strchr(set, ls->current))
    return 0;
  save_and_next(ls);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x5170
cmpq $0x0, %rax
jne 0x1fdbe
movl $0x0, -0x4(%rbp)
jmp 0x1fe27
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x1f200
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1fe07
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1fe17
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1a4e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: read_numeral
static void read_numeral (LexState *ls, SemInfo *seminfo) {
  lua_assert(isdigit(ls->current));
  do {
    save_and_next(ls);
  } while (isdigit(ls->current) || ls->current == '.');
  if (check_next(ls, "Ee"))  /* `E'? */
    check_next(ls, "+-");  /* optional exponent sign */
  while (isalnum(ls->current) || ls->current == '_')
    save_and_next(ls);
  save(ls, '\0');
  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
    trydecpoint(ls, seminfo); /* try to update decimal point separator */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x1f200
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1fe89
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x1fe99
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1a4e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
callq 0x5570
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x1fed2
movq -0x8(%rbp), %rax
cmpl $0x2e, (%rax)
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1fe40
movq -0x8(%rbp), %rdi
leaq 0xc43b(%rip), %rsi      # 0x2c323
callq 0x1fd90
cmpl $0x0, %eax
je 0x1ff02
movq -0x8(%rbp), %rdi
leaq 0xc429(%rip), %rsi      # 0x2c326
callq 0x1fd90
jmp 0x1ff04
callq 0x5570
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x16(%rbp)
jne 0x1ff31
movq -0x8(%rbp), %rax
cmpl $0x5f, (%rax)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x1ff3a
jmp 0x1ffa1
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x1f200
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x1ff83
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1ff93
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1a4e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1ff04
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1f200
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x2e, %esi
movsbl 0x58(%rax), %edx
callq 0x1fff0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf6f0
cmpl $0x0, %eax
jne 0x1ffe8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20060
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: trydecpoint
static void trydecpoint (LexState *ls, SemInfo *seminfo) {
  /* format error: try to update decimal point separator */
  struct lconv *cv = localeconv();
  char old = ls->decpoint;
  ls->decpoint = (cv ? cv->decimal_point[0] : '.');
  buffreplace(ls, old, ls->decpoint);  /* try updated decimal separator */
  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
    /* format error with correct decimal point: no more options */
    buffreplace(ls, ls->decpoint, '.');  /* undo change (for error message) */
    luaX_lexerror(ls, "malformed number", TK_NUMBER);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x5100
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb 0x58(%rax), %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x20099
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x200a3
movl $0x2e, %eax
movl %eax, -0x20(%rbp)
jmp 0x200a3
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x58(%rax)
movq -0x8(%rbp), %rdi
movb -0x19(%rbp), %cl
movq -0x8(%rbp), %rax
movsbl %cl, %esi
movsbl 0x58(%rax), %edx
callq 0x1fff0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf6f0
cmpl $0x0, %eax
jne 0x2010a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x2e, %edx
movsbl 0x58(%rax), %esi
callq 0x1fff0
movq -0x8(%rbp), %rdi
leaq 0xc229(%rip), %rsi      # 0x2c329
movl $0x11c, %edx            # imm = 0x11C
callq 0x1e500
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: base_open
static void base_open (lua_State *L) {
  /* set global _G */
  lua_pushvalue(L, LUA_GLOBALSINDEX);
  lua_setglobal(L, "_G");
  /* open lib into global table */
  luaL_register(L, "_G", base_funcs);
  lua_pushliteral(L, LUA_VERSION);
  lua_setglobal(L, "_VERSION");  /* set global _VERSION */
  /* `ipairs' and `pairs' need auxiliary functions as upvalues */
  auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
  auxopen(L, "pairs", luaB_pairs, luaB_next);
  /* `newproxy' needs a weaktable as upvalue */
  lua_createtable(L, 0, 1);  /* new table `w' */
  lua_pushvalue(L, -1);  /* `w' will be its own metatable */
  lua_setmetatable(L, -2);
  lua_pushliteral(L, "kv");
  lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */
  lua_pushcclosure(L, luaB_newproxy, 1);
  lua_setglobal(L, "newproxy");  /* set global `newproxy' */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0xc212(%rip), %rdx      # 0x2c38c
callq 0x81e0
movq -0x8(%rbp), %rdi
leaq 0xc202(%rip), %rsi      # 0x2c38c
leaq 0x1627f(%rip), %rdx     # 0x36410
callq 0x1b100
movq -0x8(%rbp), %rdi
leaq 0xc1ee(%rip), %rsi      # 0x2c38f
movl $0x7, %edx
callq 0x78d0
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0xc1dc(%rip), %rdx      # 0x2c397
callq 0x81e0
movq -0x8(%rbp), %rdi
leaq 0xc1d5(%rip), %rsi      # 0x2c3a0
leaq 0x11e(%rip), %rdx       # 0x202f0
leaq 0x177(%rip), %rcx       # 0x20350
callq 0x20290
movq -0x8(%rbp), %rdi
leaq 0xc1b8(%rip), %rsi      # 0x2c3a1
leaq 0x1e0(%rip), %rdx       # 0x203d0
leaq 0x229(%rip), %rcx       # 0x20420
callq 0x20290
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x7f20
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8420
movq -0x8(%rbp), %rdi
leaq 0xc174(%rip), %rsi      # 0x2c3a7
movl $0x2, %edx
callq 0x78d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xba73(%rip), %rdx      # 0x2bcc0
callq 0x81e0
movq -0x8(%rbp), %rdi
leaq 0x233(%rip), %rsi       # 0x20490
movl $0x1, %edx
callq 0x7ae0
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0xc133(%rip), %rdx      # 0x2c3aa
callq 0x81e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_ipairs
static int luaB_ipairs (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
  lua_pushvalue(L, 1);  /* state, */
  lua_pushinteger(L, 0);  /* and initial value */
  return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6f80
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7880
movl $0x3, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_pairs
static int luaB_pairs (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
  lua_pushvalue(L, 1);  /* state, */
  lua_pushnil(L);  /* and initial value */
  return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6f80
movq -0x8(%rbp), %rdi
callq 0x7800
movl $0x3, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_newproxy
static int luaB_newproxy (lua_State *L) {
  lua_settop(L, 1);
  lua_newuserdata(L, 0);  /* create proxy */
  if (lua_toboolean(L, 1) == 0)
    return 1;  /* no metatable */
  else if (lua_isboolean(L, 1)) {
    lua_newtable(L);  /* create a new metatable `m' ... */
    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
    lua_pushboolean(L, 1);
    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
  }
  else {
    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
    if (lua_getmetatable(L, 1)) {
      lua_rawget(L, lua_upvalueindex(1));
      validproxy = lua_toboolean(L, -1);
      lua_pop(L, 1);  /* remove value */
    }
    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
    lua_getmetatable(L, 1);  /* metatable is valid; get it */
  }
  lua_setmetatable(L, 2);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6ab0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8da0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7440
cmpl $0x0, %eax
jne 0x204d6
movl $0x1, -0x4(%rbp)
jmp 0x205bd
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6fe0
cmpl $0x1, %eax
jne 0x20525
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x7f20
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7c50
movq -0x10(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x8280
jmp 0x205a6
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7fa0
cmpl $0x0, %eax
je 0x2056c
movq -0x10(%rbp), %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x7e30
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7440
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
jne 0x20595
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0xc0a0(%rip), %rdx      # 0x2c627
callq 0x1a7b0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7fa0
jmp 0x205a8
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x8420
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_assert
static int luaB_assert (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_toboolean(L, 1))
    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
  return lua_gettop(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1ae40
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7440
cmpl $0x0, %eax
jne 0x20638
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0xbe33(%rip), %rdx      # 0x2c448
xorl %eax, %eax
movl %eax, %ecx
callq 0x1ab60
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0xccb4(%rip), %rsi      # 0x2d2e0
movb $0x0, %al
callq 0x1a8b0
movl %eax, -0x4(%rbp)
jmp 0x20644
movq -0x10(%rbp), %rdi
callq 0x6a80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_collectgarbage
static int luaB_collectgarbage (lua_State *L) {
  static const char *const opts[] = {"stop", "restart", "collect",
    "count", "step", "setpause", "setstepmul", NULL};
  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
  int o = luaL_checkoption(L, 1, "collect", opts);
  int ex = luaL_optint(L, 2, 0);
  int res = lua_gc(L, optsnum[o], ex);
  switch (optsnum[o]) {
    case LUA_GCCOUNT: {
      int b = lua_gc(L, LUA_GCCOUNTB, 0);
      lua_pushnumber(L, res + ((lua_Number)b/1024));
      return 1;
    }
    case LUA_GCSTEP: {
      lua_pushboolean(L, res);
      return 1;
    }
    default: {
      lua_pushnumber(L, res);
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xbe00(%rip), %rdx      # 0x2c467
leaq 0x15f32(%rip), %rcx     # 0x365a0
movl $0x1, %esi
callq 0x1aa80
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %esi
callq 0x1af90
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xbcd1(%rip), %rax      # 0x2c370
movq %rax, -0x30(%rbp)
movl (%rax,%rcx,4), %esi
movl -0x18(%rbp), %edx
callq 0x8a40
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x206d2
jmp 0x206c8
movl -0x24(%rbp), %eax
subl $0x5, %eax
je 0x20711
jmp 0x20726
movq -0x10(%rbp), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x8a40
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
cvtsi2sdl -0x1c(%rbp), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
movsd 0xbc45(%rip), %xmm2     # 0x2c340
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
callq 0x7830
movl $0x1, -0x4(%rbp)
jmp 0x2073b
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x7c50
movl $0x1, -0x4(%rbp)
jmp 0x2073b
movq -0x10(%rbp), %rdi
cvtsi2sdl -0x1c(%rbp), %xmm0
callq 0x7830
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_dofile
static int luaB_dofile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  int n = lua_gettop(L);
  if (luaL_loadfile(L, fname) != 0) lua_error(L);
  lua_call(L, 0, LUA_MULTRET);
  return lua_gettop(L) - n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1ab60
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a80
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ba40
cmpl $0x0, %eax
je 0x2079c
movq -0x8(%rbp), %rdi
callq 0x8bb0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8680
movq -0x8(%rbp), %rdi
callq 0x6a80
subl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_getfenv
static int luaB_getfenv (lua_State *L) {
  getfunc(L, 1);
  if (lua_iscfunction(L, -1))  /* is a C function? */
    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
  else
    lua_getfenv(L, -1);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x214a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7070
cmpl $0x0, %eax
je 0x208bd
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x6f80
jmp 0x208cb
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8080
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_load
static int luaB_load (lua_State *L) {
  int status;
  const char *cname = luaL_optstring(L, 2, "=(load)");
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
  status = lua_load(L, generic_reader, NULL, cname);
  return load_aux(L, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xbb39(%rip), %rdx      # 0x2c4f5
xorl %eax, %eax
movl %eax, %ecx
callq 0x1ab60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x6ab0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0xc27(%rip), %rsi       # 0x21620
xorl %eax, %eax
movl %eax, %edx
callq 0x8950
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x215d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_loadstring
static int luaB_loadstring (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  const char *chunkname = luaL_optstring(L, 2, s);
  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x1abe0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x1ab60
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1be30
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x215d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_pcall
static int luaB_pcall (lua_State *L) {
  int status;
  luaL_checkany(L, 1);
  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
  lua_pushboolean(L, (status == 0));
  lua_insert(L, 1);
  return lua_gettop(L);  /* return status + all results */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1ae40
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a80
movq -0x18(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x8700
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
cmpl $0x0, -0xc(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x7c50
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6d40
movq -0x8(%rbp), %rdi
callq 0x6a80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_print
static int luaB_print (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    lua_pushvalue(L, -1);  /* function to be called */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tostring(L, -1);  /* get result */
    if (s == NULL)
      return luaL_error(L, LUA_QL("tostring") " must return a string to "
                           LUA_QL("print"));
    if (i>1) fputs("\t", stdout);
    fputs(s, stdout);
    lua_pop(L, 1);  /* pop result */
  }
  fputs("\n", stdout);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a80
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0xbac4(%rip), %rdx      # 0x2c5fc
callq 0x7d90
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x20bf9
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6f80
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x8680
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x20bae
movq -0x10(%rbp), %rdi
leaq 0xb99a(%rip), %rsi      # 0x2c53c
movb $0x0, %al
callq 0x1a8b0
movl %eax, -0x4(%rbp)
jmp 0x20c16
cmpl $0x1, -0x18(%rbp)
jle 0x20bca
movq 0x16415(%rip), %rax     # 0x36fd0
movq (%rax), %rsi
leaq 0xbc63(%rip), %rdi      # 0x2c828
callq 0x51b0
movq -0x20(%rbp), %rdi
movq 0x163fb(%rip), %rax     # 0x36fd0
movq (%rax), %rsi
callq 0x51b0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x20b44
movq 0x163d0(%rip), %rax     # 0x36fd0
movq (%rax), %rsi
leaq 0xb43a(%rip), %rdi      # 0x2c044
callq 0x51b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_setfenv
static int luaB_setfenv (lua_State *L) {
  luaL_checktype(L, 2, LUA_TTABLE);
  getfunc(L, 0);
  lua_pushvalue(L, 2);
  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
    /* change environment of current thread */
    lua_pushthread(L);
    lua_insert(L, -2);
    lua_setfenv(L, -2);
    return 0;
  }
  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
    luaL_error(L,
          LUA_QL("setfenv") " cannot change environment of given object");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x214a0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x70c0
cmpl $0x0, %eax
je 0x20ec2
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7350
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x20ec2
jp 0x20ec2
movq -0x10(%rbp), %rdi
callq 0x7ce0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d40
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8560
movl $0x0, -0x4(%rbp)
jmp 0x20f03
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7070
cmpl $0x0, %eax
jne 0x20ee8
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8560
cmpl $0x0, %eax
jne 0x20efa
movq -0x10(%rbp), %rdi
leaq 0xb687(%rip), %rsi      # 0x2c57a
movb $0x0, %al
callq 0x1a8b0
jmp 0x20efc
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_setmetatable
static int luaB_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  if (luaL_getmetafield(L, 1, "__metatable"))
    luaL_error(L, "cannot change a protected metatable");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6fe0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x20f74
movb $0x1, %al
cmpl $0x5, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x20f74
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xb648(%rip), %rdx      # 0x2c5ae
callq 0x1a7b0
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xb562(%rip), %rdx      # 0x2c4e9
callq 0x1afe0
cmpl $0x0, %eax
je 0x20fa3
movq -0x8(%rbp), %rdi
leaq 0xb628(%rip), %rsi      # 0x2c5c4
movb $0x0, %al
callq 0x1a8b0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6ab0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8420
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)