LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x28(%rbx), %r14
xorl %ebp, %ebp
movq (%r14), %r14
testq %r14, %r14
je 0xab8d
cmpb $0x0, 0xe(%r14)
jne 0xab99
movzbl 0xd(%r14), %eax
orl %eax, %ebp
jmp 0xab75
leaq 0xeff7(%rip), %rsi      # 0x19b8b
callq 0x1176f
testl %ebp, %ebp
je 0xabb2
movzbl 0xc(%r14), %edx
pushq $0x23
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10460
addq $0x8, %r14
movq %rbx, %rdi
callq 0x1047e
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x104d6
// File: /workspace/github_c_makefile_star2_O2/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 0xb3d6
cmpl $0x28, %eax
jne 0xb3e3
movl 0x4(%r14), %ebp
movq %r14, %rdi
callq 0x11842
movq %r14, %rdi
movq %rbx, %rsi
callq 0xac1d
pushq $0x29
popq %rsi
pushq $0x28
popq %rdx
movq %r14, %rdi
movl %ebp, %ecx
callq 0xaae0
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x1087e
jmp 0xb3f2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb94a
jmp 0xb3f2
leaq 0xe6ae(%rip), %rsi      # 0x19a98
movq %r14, %rdi
callq 0x1176f
leaq 0x8(%rsp), %r12
movl 0x10(%r14), %eax
cmpl $0x28, %eax
je 0xb428
cmpl $0x11e, %eax            # imm = 0x11E
je 0xb428
cmpl $0x3a, %eax
je 0xb435
cmpl $0x5b, %eax
je 0xb463
cmpl $0x7b, %eax
je 0xb428
cmpl $0x2e, %eax
jne 0xb48c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb7b8
jmp 0xb3f7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1092f
jmp 0xb456
movq %r14, %rdi
callq 0x11842
movq %r14, %rdi
movq %r12, %rsi
callq 0xb5e9
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x10c49
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb805
jmp 0xb3f7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10a70
movq %r14, %rdi
movq %r12, %rsi
callq 0xb60d
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x10db7
jmp 0xb3f7
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xac1d
movl 0x24(%rbx), %eax
cmpl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
jl 0xb4ca
movq 0x30(%r14), %rdi
leaq 0xe52b(%rip), %rdx      # 0x199e8
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0xb5a0
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_O2/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 0xb5c7
leaq 0xe463(%rip), %rsi      # 0x19a21
xorl %eax, %eax
callq 0x9c6e
jmp 0xb5da
leaq 0xe431(%rip), %rsi      # 0x199ff
movl %ecx, %edx
movq %r8, %rcx
xorl %eax, %eax
callq 0x9c6e
movq 0x18(%rbx), %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
jmp 0x116c8
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: adjustlocalvars
static void adjustlocalvars (LexState *ls, int nvars) {
  FuncState *fs = ls->fs;
  fs->nactvar = cast_byte(fs->nactvar + nvars);
  for (; nvars; nvars--) {
    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
  }
}

// Assembly:
movq 0x30(%rdi), %rax
movb 0x4a(%rax), %dl
addb %sil, %dl
movb %dl, 0x4a(%rax)
movslq %esi, %rcx
negq %rcx
movzbl %dl, %edx
leaq (%rax,%rdx,2), %rdx
addq $0xc4, %rdx
testq %rcx, %rcx
je 0xb7b7
movl 0x30(%rax), %esi
movq (%rax), %rdi
movq 0x30(%rdi), %rdi
movzwl (%rdx,%rcx,2), %r8d
shll $0x4, %r8d
movl %esi, 0x8(%rdi,%r8)
incq %rcx
jmp 0xb795
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x10a70
movq %r14, %rdi
callq 0x11842
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xb5e9
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x10db7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: funcargs
static void funcargs (LexState *ls, expdesc *f) {
  FuncState *fs = ls->fs;
  expdesc args;
  int base, nparams;
  int line = ls->linenumber;
  switch (ls->t.token) {
    case '(': {  /* funcargs -> `(' [ explist1 ] `)' */
      if (line != ls->lastline)
        luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
      luaX_next(ls);
      if (ls->t.token == ')')  /* arg list is empty? */
        args.k = VVOID;
      else {
        explist1(ls, &args);
        luaK_setmultret(fs, &args);
      }
      check_match(ls, ')', '(', line);
      break;
    }
    case '{': {  /* funcargs -> constructor */
      constructor(ls, &args);
      break;
    }
    case TK_STRING: {  /* funcargs -> STRING */
      codestring(ls, &args, ls->t.seminfo.ts);
      luaX_next(ls);  /* must use `seminfo' before `next' */
      break;
    }
    default: {
      luaX_syntaxerror(ls, "function arguments expected");
      return;
    }
  }
  lua_assert(f->k == VNONRELOC);
  base = f->u.s.info;  /* base register for call */
  if (hasmultret(args.k))
    nparams = LUA_MULTRET;  /* open call */
  else {
    if (args.k != VVOID)
      luaK_exp2nextreg(fs, &args);  /* close last argument */
    nparams = fs->freereg - (base+1);
  }
  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
  luaK_fixline(fs, line);
  fs->freereg = base+1;  /* call remove function and arguments and leaves
                            (unless changed) one result */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rbx
movl 0x4(%rdi), %ebp
movl 0x10(%rdi), %eax
cmpl $0x11e, %eax            # imm = 0x11E
je 0xb86c
cmpl $0x7b, %eax
je 0xb85d
cmpl $0x28, %eax
jne 0xb898
cmpl 0x8(%r15), %ebp
je 0xb847
leaq 0xe274(%rip), %rsi      # 0x19ab3
movq %r15, %rdi
callq 0x1176f
movq %r15, %rdi
callq 0x11842
cmpl $0x29, 0x10(%r15)
jne 0xb8b3
andl $0x0, 0x8(%rsp)
jmp 0xb8d1
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xaef1
jmp 0xb8e1
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x10687
orq $-0x1, 0x18(%rsp)
movl $0x4, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movq %r15, %rdi
callq 0x11842
movl 0x8(%r14), %r15d
jmp 0xb8f7
leaq 0xe245(%rip), %rsi      # 0x19ae4
movq %r15, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1176f
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xbb48
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107b6
pushq $0x29
popq %rsi
pushq $0x28
popq %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0xaae0
movl 0x8(%rsp), %eax
movl 0x8(%r14), %r15d
leal -0xd(%rax), %edx
xorl %ecx, %ecx
cmpl $0x2, %edx
jb 0xb90a
testl %eax, %eax
je 0xb904
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1092f
movl 0x3c(%rbx), %ecx
subl %r15d, %ecx
pushq $0x1c
popq %rsi
pushq $0x2
popq %r8
movq %rbx, %rdi
movl %r15d, %edx
callq 0x10460
orq $-0x1, 0x10(%r14)
movl $0xd, (%r14)
movl %eax, 0x8(%r14)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x112dd
incl %r15d
movl %r15d, 0x3c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb645
movq %rax, %r14
movq 0x30(%r15), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xb98b
cmpl $0x8, %eax
jne 0xb985
movq %r15, %rdi
movq %r14, %rsi
callq 0x10687
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
testq %rdi, %rdi
je 0xba08
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x4a(%rdi), %edx
testq %rdx, %rdx
jle 0xba1e
movq (%rbx), %rax
movq 0x30(%rax), %rax
movzwl 0xc2(%rbx,%rdx,2), %esi
decq %rdx
shll $0x4, %esi
cmpq %r15, (%rax,%rsi)
jne 0xb9a8
orq $-0x1, 0x10(%r14)
movl $0x6, (%r14)
movl %edx, 0x8(%r14)
pushq $0x6
popq %rax
testl %ecx, %ecx
jne 0xbb39
incq %rdx
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xbb39
movzbl 0xc(%rbx), %ecx
cmpq %rcx, %rdx
jle 0xb9ea
movb $0x1, 0xd(%rbx)
jmp 0xbb39
orq $-0x1, 0x10(%r14)
movl $0x8, (%r14)
movl $0xff, 0x8(%r14)
jmp 0xba34
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xb98b
cmpl $0x8, %eax
jne 0xba3b
pushq $0x8
jmp 0xbb38
movq (%rbx), %r12
leaq 0x48(%r12), %r13
movl 0x48(%r12), %eax
movslq %eax, %rbp
movzbl 0x70(%r12), %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xba76
movzbl 0x4b(%rbx,%rdx,2), %esi
cmpl %esi, (%r14)
jne 0xba71
movzbl 0x4c(%rbx,%rdx,2), %esi
cmpl %esi, 0x8(%r14)
je 0xbb2b
incq %rdx
jmp 0xba53
cmpb $0x3b, %cl
jbe 0xba97
leaq 0xe028(%rip), %rdx      # 0x19aaa
pushq $0x3c
popq %rsi
movq %rbx, %rdi
callq 0xb5a0
movb 0x70(%r12), %cl
movl 0x48(%r12), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jg 0xbac9
movq 0x20(%rbx), %rdi
movq 0x38(%r12), %rsi
leaq 0xf6cc(%rip), %r9       # 0x1b17a
pushq $0x8
popq %rcx
movq %r13, %rdx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0x9718
movq %rax, 0x38(%r12)
movl 0x48(%r12), %eax
cltq
movq 0x38(%r12), %rdx
cmpq %rax, %rbp
jge 0xbadf
andq $0x0, (%rdx,%rbp,8)
incq %rbp
jmp 0xbacb
movzbl 0x70(%r12), %ecx
movl %ecx, %eax
movq %r15, (%rdx,%rcx,8)
testb $0x3, 0x9(%r15)
je 0xbb11
testb $0x4, 0x9(%r12)
je 0xbb11
movq 0x20(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x9066
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, %edx
movl %edx, 0x8(%r14)
movl $0x7, (%r14)
pushq $0x7
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xac1d
pushq $0x1
popq %rbp
pushq $0x2c
popq %r15
movq %r14, %rdi
movl %r15d, %esi
callq 0xaa8f
testl %eax, %eax
je 0xbb8b
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x1092f
movq %r14, %rdi
movq %rbx, %rsi
callq 0xac1d
incl %ebp
jmp 0xbb61
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/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), %rdi
movq 0x28(%rbx), %r14
movq (%r14), %rax
movq %rax, 0x28(%rbx)
movzbl 0xc(%r14), %esi
callq 0xaa36
cmpb $0x0, 0xd(%r14)
je 0xbbd4
movzbl 0xc(%r14), %edx
pushq $0x23
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10460
movzbl 0x4a(%rbx), %eax
movl %eax, 0x3c(%rbx)
movl 0x8(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10540
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: exp1
static int exp1 (LexState *ls) {
  expdesc e;
  int k;
  expr(ls, &e);
  k = e.k;
  luaK_exp2nextreg(ls->fs, &e);
  return k;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0xac1d
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x1092f
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movl %ecx, %r13d
movl %edx, 0x4(%rsp)
movl %esi, %r12d
movq %rdi, %r14
movq 0x30(%rdi), %rbx
pushq $0x3
popq %rsi
callq 0xb774
movq %r14, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0xac0b
testl %ebp, %ebp
je 0xbc67
pushq $0x20
popq %rsi
movq %rbx, %rdi
movl %r12d, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x104c0
jmp 0xbc6f
movq %rbx, %rdi
callq 0x1047e
movl %eax, %r15d
leaq 0x8(%rsp), %rax
orl $-0x1, 0x8(%rax)
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 %r14, %rdi
movl %r13d, %esi
callq 0xb774
movq %rbx, %rdi
movl %r13d, %esi
callq 0x1066d
movq %r14, %rdi
callq 0xaaa4
movq %rbx, %rdi
callq 0xbb98
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10540
testl %ebp, %ebp
je 0xbcde
pushq $0x1f
popq %rsi
movq %rbx, %rdi
movl %r12d, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x104c0
jmp 0xbcf1
pushq $0x21
popq %rsi
movq %rbx, %rdi
movl %r12d, %edx
xorl %ecx, %ecx
movl %r13d, %r8d
callq 0x10460
movl %eax, %r14d
movq %rbx, %rdi
movl 0x4(%rsp), %esi
callq 0x112dd
testl %ebp, %ebp
jne 0xbd0f
movq %rbx, %rdi
callq 0x1047e
movl %eax, %r14d
incl %r15d
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x1052c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/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 0xbdd6
leaq 0xddce(%rip), %rsi      # 0x19b9c
movq %r14, %rdi
callq 0x1176f
leaq 0x8(%r15), %rbx
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0xaa8f
testl %eax, %eax
je 0xbe48
leaq 0x8(%rsp), %r12
movq %r15, -0x8(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0xb37c
cmpl $0x6, (%r12)
jne 0xbe9d
movq 0x30(%r14), %r12
movl 0x3c(%r12), %eax
xorl %edx, %edx
pushq $0x1
popq %rcx
testq %r15, %r15
je 0xbe78
cmpl $0x9, 0x8(%r15)
jne 0xbe43
movl 0x10(%rsp), %esi
cmpl %esi, 0x10(%r15)
jne 0xbe37
movl %eax, 0x10(%r15)
movl 0x10(%rsp), %esi
movl %ecx, %edx
cmpl %esi, 0x14(%r15)
jne 0xbe43
movl %eax, 0x14(%r15)
movl %ecx, %edx
movq (%r15), %r15
jmp 0xbe17
pushq $0x3d
popq %rsi
movq %r14, %rdi
callq 0xac0b
movq %rsp, %rsi
movq %r14, %rdi
callq 0xbb48
cmpl %eax, %ebp
jne 0xbf01
movq 0x30(%r14), %rdi
movq %rsp, %rsi
callq 0x10831
movq 0x30(%r14), %rdi
jmp 0xbee9
testl %edx, %edx
je 0xbe9d
movl 0x3c(%r12), %edx
movl 0x10(%rsp), %ecx
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x10460
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x1066d
movq 0x38(%r14), %rax
movzwl 0x60(%rax), %eax
movl $0xc8, %esi
subl %eax, %esi
cmpl %ebp, %esi
jge 0xbec0
movq 0x30(%r14), %rdi
leaq 0xdcee(%rip), %rdx      # 0x19ba9
callq 0xb5a0
incl %ebp
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0xbda8
movq 0x30(%r14), %rdi
movl 0x3c(%rdi), %eax
orq $-0x1, 0x10(%rsp)
decl %eax
movl $0xc, (%rsp)
movl %eax, 0x8(%rsp)
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x10b93
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movq %rsp, %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xbd2f
subl %r15d, %ebp
jge 0xbecf
movq 0x30(%r14), %rax
addl %ebp, 0x3c(%rax)
jmp 0xbecf
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xb8, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x97a6
movq %rax, %r14
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9158
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xbf9b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbfde
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
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x867b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc0a0
movl $0xb8, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x97a6
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: lua_newstate
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
  void *l = (*f)(ud, NULL, 0, state_size(LG));
  if (l == NULL) return NULL;
  L = tostate(l);
  g = &((LG *)L)->g;
  L->next = NULL;
  L->tt = LUA_TTHREAD;
  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
  L->marked = luaC_white(g);
  set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
  preinit_state(L, g);
  g->frealloc = f;
  g->ud = ud;
  g->mainthread = L;
  g->uvhead.u.l.prev = &g->uvhead;
  g->uvhead.u.l.next = &g->uvhead;
  g->GCthreshold = 0;  /* mark it as unfinished state */
  g->strt.size = 0;
  g->strt.nuse = 0;
  g->strt.hash = NULL;
  setnilvalue(registry(L));
  luaZ_initbuffer(L, &g->buff);
  g->panic = NULL;
  g->gcstate = GCSpause;
  g->rootgc = obj2gco(L);
  g->sweepstrgc = 0;
  g->sweepgc = &g->rootgc;
  g->gray = NULL;
  g->grayagain = NULL;
  g->weak = NULL;
  g->tmudata = NULL;
  g->totalbytes = sizeof(LG);
  g->gcpause = LUAI_GCPAUSE;
  g->gcstepmul = LUAI_GCMUL;
  g->gcdept = 0;
  for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
  if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
    /* memory allocation error: free partial state */
    close_state(L);
    L = NULL;
  }
  else
    luai_userstateopen(L);
  return L;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x268, %ecx            # imm = 0x268
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *%r15
testq %rax, %rax
je 0xc214
movq %rax, %rbx
andq $0x0, (%rax)
leaq 0xb8(%rax), %rsi
movw $0x6108, 0x8(%rax)      # imm = 0x6108
movb $0x21, 0xd8(%rax)
movq %rax, %rdi
callq 0xbf9b
movq %r15, 0xc8(%rbx)
movq %r14, 0xd0(%rbx)
movq %rbx, 0x168(%rbx)
leaq 0x170(%rbx), %rax
movq %rax, 0x188(%rbx)
movq %rax, 0x190(%rbx)
andq $0x0, 0x128(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rbx)
movq 0x20(%rbx), %rax
andl $0x0, 0xa8(%rax)
andq $0x0, 0x110(%rbx)
andq $0x0, 0x120(%rbx)
andq $0x0, 0x150(%rbx)
movb $0x0, 0xd9(%rbx)
movq %rbx, 0xe0(%rbx)
andl $0x0, 0xdc(%rbx)
movq %rbx, %rax
addq $0xe0, %rax
movq %rax, 0xe8(%rbx)
movups %xmm0, 0xf0(%rbx)
movups %xmm0, 0x100(%rbx)
movq $0x268, 0x130(%rbx) # imm = 0x268
movabsq $0xc8000000c8, %rax     # imm = 0xC8000000C8
movq %rax, 0x148(%rbx)
andq $0x0, 0x140(%rbx)
pushq $0x33
popq %rax
cmpq $0x3c, %rax
je 0xc1ef
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0xc1df
leaq 0x2d(%rip), %rsi        # 0xc223
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7583
testl %eax, %eax
je 0xc211
movq %rbx, %rdi
callq 0xc2be
xorl %r12d, %r12d
jmp 0xc214
movq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: f_luaopen
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
  luaS_fix(luaS_newliteral(L, MEMERRMSG));
  g->GCthreshold = 4*g->totalbytes;
}

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

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

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

// Assembly:
movq 0x20(%rdi), %rax
cmpb $0x2, 0x21(%rax)
je 0xc465
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r12
cmpl $-0x1, %esi
jl 0xc3e2
leaq (,%r12,8), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x97a6
jmp 0xc3ea
movq %r14, %rdi
callq 0x97f0
movq %rax, %r15
movq 0x20(%r14), %r13
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
cmpq %rax, %rcx
je 0xc40c
andq $0x0, (%r15,%rax,8)
incq %rax
jmp 0xc3fd
decq %r12
xorl %eax, %eax
movslq 0xc(%r13), %rdx
movq (%r13), %rsi
cmpq %rdx, %rax
jge 0xc446
movq (%rsi,%rax,8), %rcx
testq %rcx, %rcx
je 0xc441
movq (%rcx), %rdx
movslq 0xc(%rcx), %rsi
andq %r12, %rsi
movq (%r15,%rsi,8), %rdi
movq %rdi, (%rcx)
movq %rcx, (%r15,%rsi,8)
movq %rdx, %rcx
jmp 0xc422
incq %rax
jmp 0xc411
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
movl %ebx, 0xc(%r13)
movq %r15, (%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstring.c
// Function: luaS_newlstr
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
  GCObject *o;
  unsigned int h = cast(unsigned int, l);  /* seed */
  size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
  size_t l1;
  for (l1=l; l1>=step; l1-=step)  /* compute hash */
    h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
  for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
       o != NULL;
       o = o->gch.next) {
    TString *ts = rawgco2ts(o);
    if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
      /* string may be dead */
      if (isdead(G(L), o)) changewhite(o);
      return ts;
    }
  }
  return newlstr(L, str, l, h);  /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x5, %rax
movq %rax, %rcx
notq %rcx
movl %r14d, %ebp
cmpq %rax, %rdx
jbe 0xc4aa
movl %ebp, %esi
shll $0x5, %esi
movl %ebp, %edi
shrl $0x2, %edi
addl %esi, %edi
movzbl -0x1(%r12,%rdx), %esi
addl %edi, %esi
xorl %esi, %ebp
addq %rcx, %rdx
jmp 0xc48a
movq 0x20(%rbx), %r13
movslq 0xc(%r13), %rax
decq %rax
movslq %ebp, %r15
andq %rax, %r15
shlq $0x3, %r15
addq (%r13), %r15
movq (%r15), %r15
testq %r15, %r15
je 0xc504
cmpq %r14, 0x10(%r15)
jne 0xc4c3
leaq 0x18(%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x4370
testl %eax, %eax
jne 0xc4c3
movb 0x9(%r15), %al
movb 0x20(%r13), %cl
notb %cl
andb %al, %cl
testb $0x3, %cl
je 0xc5a0
xorb $0x3, %al
movb %al, 0x9(%r15)
jmp 0xc5a0
leaq 0x1b(%r14), %rax
cmpq $0x19, %rax
ja 0xc516
movq %rbx, %rdi
callq 0x97f0
leaq 0x19(%r14), %rcx
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x97a6
movq %rax, %r15
movq %r14, 0x10(%rax)
movl %ebp, 0xc(%rax)
movq 0x20(%rbx), %rax
movb 0x20(%rax), %al
andb $0x3, %al
movb %al, 0x9(%r15)
movb $0x4, 0x8(%r15)
movb %r13b, 0xa(%r15)
leaq 0x18(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x42f0
movb %r13b, 0x18(%r15,%r14)
movq 0x20(%rbx), %rax
movl 0xc(%rax), %ecx
decl %ecx
andl %ebp, %ecx
movq (%rax), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%r15)
movq (%rax), %rdx
movq %r15, (%rdx,%rcx,8)
movl 0x8(%rax), %ecx
movl 0xc(%rax), %esi
incl %ecx
cmpl %esi, %ecx
setbe %dl
movl %ecx, 0x8(%rax)
cmpl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
setge %al
orb %dl, %al
jne 0xc5a0
addl %esi, %esi
movq %rbx, %rdi
callq 0xc3a8
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_O2/gplessis[P]dotdeb-redis/deps/lua/src/lstring.c
// Function: luaS_newudata
Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
  Udata *u;
  if (s > MAX_SIZET - sizeof(Udata))
    luaM_toobig(L);
  u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
  u->uv.marked = luaC_white(G(L));  /* is not finalized */
  u->uv.tt = LUA_TUSERDATA;
  u->uv.len = s;
  u->uv.metatable = NULL;
  u->uv.env = e;
  /* chain it on udata list (after main thread) */
  u->uv.next = G(L)->mainthread->next;
  G(L)->mainthread->next = obj2gco(u);
  return u;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $-0x2a, %rsi
jb 0xc5ce
movq %rbx, %rdi
callq 0x97f0
leaq 0x28(%r15), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x97a6
movq 0x20(%rbx), %rcx
movb 0x20(%rcx), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb $0x7, 0x8(%rax)
movq %r15, 0x20(%rax)
andq $0x0, 0x10(%rax)
movq %r14, 0x18(%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rbx), %rcx
movq 0xb0(%rcx), %rcx
movq %rax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: resize
static void resize (lua_State *L, Table *t, int nasize, int nhsize) {
  int i;
  int oldasize = t->sizearray;
  int oldhsize = t->lsizenode;
  Node *nold = t->node;  /* save old hash ... */
  if (nasize > oldasize)  /* array part must grow? */
    setarrayvector(L, t, nasize);
  /* create new hash part with appropriate size */
  setnodevector(L, t, nhsize);  
  if (nasize < oldasize) {  /* array part must shrink? */
    t->sizearray = nasize;
    /* re-insert elements from vanishing slice */
    for (i=nasize; i<oldasize; i++) {
      if (!ttisnil(&t->array[i]))
        setobjt2t(L, luaH_setnum(L, t, i+1), &t->array[i]);
    }
    /* shrink array */
    luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
  }
  /* re-insert elements from hash part */
  for (i = twoto(oldhsize) - 1; i >= 0; i--) {
    Node *old = nold+i;
    if (!ttisnil(gval(old)))
      setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));
  }
  if (nold != dummynode)
    luaM_freearray(L, nold, twoto(oldhsize), Node);  /* free old array */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x38(%rsi), %r13
movzbl 0xb(%rsi), %r12d
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rsp)
cmpl %edx, %r13d
jge 0xc7ce
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xc97e
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xc9e3
cmpl %ebp, %r13d
jle 0xc87a
movq %r12, 0x8(%rsp)
movl %ebp, 0x38(%r15)
movslq %ebp, %r12
movq %rbp, 0x18(%rsp)
leal 0x1(%rbp), %r14d
movq %r12, %rax
shlq $0x4, %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rax), %rbp
cmpq %r13, %r12
jge 0xc846
movq 0x18(%r15), %rbx
cmpl $0x0, (%rbx,%rbp)
je 0xc83a
movq (%rsp), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xcf9d
movq -0x8(%rbx,%rbp), %rcx
movq %rcx, (%rax)
movl (%rbx,%rbp), %ecx
movl %ecx, 0x8(%rax)
incl %r14d
addq $0x10, %rbp
incq %r12
jmp 0xc80e
cmpl $-0x1, 0x18(%rsp)
jl 0xc868
movq 0x18(%r15), %rsi
shlq $0x4, %r13
movq (%rsp), %rdi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
callq 0x97a6
jmp 0xc871
movq (%rsp), %rdi
callq 0x97f0
movq 0x8(%rsp), %r12
movq %rax, 0x18(%r15)
pushq $0x1
popq %r14
movl %r12d, %ecx
shlq %cl, %r14
imulq $0x28, %r14, %rax
movq 0x20(%rsp), %r13
leaq (%rax,%r13), %r12
addq $-0x28, %r12
movl %r14d, %ebp
movq (%rsp), %rbx
testl %ebp, %ebp
jle 0xc8cf
cmpl $0x0, 0x8(%r12)
je 0xc8c7
leaq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xccb1
movq (%r12), %rcx
movq %rcx, (%rax)
movl 0x8(%r12), %ecx
movl %ecx, 0x8(%rax)
decl %ebp
addq $-0x28, %r12
jmp 0xc89c
leaq 0xd302(%rip), %rax      # 0x19bd8
cmpq %rax, %r13
je 0xc8fd
movslq %r14d, %rax
imulq $0x28, %rax, %rdx
movq %rbx, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x97a6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_new
Table *luaH_new (lua_State *L, int narray, int nhash) {
  Table *t = luaM_new(L, Table);
  luaC_link(L, obj2gco(t), LUA_TTABLE);
  t->metatable = NULL;
  t->flags = cast_byte(~0);
  /* temporary values (kept only if some malloc fails) */
  t->array = NULL;
  t->sizearray = 0;
  t->lsizenode = 0;
  t->node = cast(Node *, dummynode);
  setarrayvector(L, t, narray);
  setnodevector(L, t, nhash);
  return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x40
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x97a6
movq %rax, %r15
pushq $0x5
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x9158
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movw $0xff, 0xa(%r15)
andl $0x0, 0x38(%r15)
leaq 0xd286(%rip), %rax      # 0x19bd8
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xc97e
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0xc9e3
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: setarrayvector
static void setarrayvector (lua_State *L, Table *t, int size) {
  int i;
  luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
  for (i=t->sizearray; i<size; i++)
     setnilvalue(&t->array[i]);
  t->sizearray = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
cmpl $-0x1, %edx
jl 0xc9aa
movq 0x18(%r14), %rsi
movslq 0x38(%r14), %rdx
shlq $0x4, %rdx
movslq %ebx, %r15
movq %r15, %rcx
shlq $0x4, %rcx
callq 0x97a6
jmp 0xc9b2
callq 0x97f0
movslq %ebx, %r15
movq %rax, 0x18(%r14)
movslq 0x38(%r14), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addq $0x8, %rax
cmpq %r15, %rcx
jge 0xc9d9
andl $0x0, (%rax)
incq %rcx
addq $0x10, %rax
jmp 0xc9c8
movl %ebx, 0x38(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_free
void luaH_free (lua_State *L, Table *t) {
  if (t->node != dummynode)
    luaM_freearray(L, t->node, sizenode(t), Node);
  luaM_freearray(L, t->array, t->sizearray, TValue);
  luaM_free(L, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
leaq 0xd112(%rip), %rax      # 0x19bd8
cmpq %rax, %rsi
je 0xcae3
movb 0xb(%rbx), %cl
pushq $0x1
popq %rax
shll %cl, %eax
cltq
imulq $0x28, %rax, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
movq 0x18(%rbx), %rsi
movslq 0x38(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x97a6
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x97a6
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: hashnum
static Node *hashnum (const Table *t, lua_Number n) {
  unsigned int a[numints];
  int i;
  if (luai_numeq(n, 0))  /* avoid problems with -0 */
    return gnode(t, 0);
  memcpy(a, &n, sizeof(a));
  for (i = 1; i < numints; i++) a[0] += a[i];
  return hashmod(t, a[0]);
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcb6f
jp 0xcb6f
movq 0x20(%rdi), %rax
retq
movq %xmm0, %rcx
movq %rcx, %rax
shrq $0x20, %rax
addl %ecx, %eax
movb 0xb(%rdi), %cl
pushq $-0x1
popq %rsi
shll %cl, %esi
notl %esi
orl $0x1, %esi
xorl %edx, %edx
divl %esi
imulq $0x28, %rdx, %rax
addq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_getstr
const TValue *luaH_getstr (Table *t, TString *key) {
  Node *n = hashstr(t, key);
  do {  /* check whether `key' is somewhere in the chain */
    if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
      return gval(n);  /* that's it */
    else n = gnext(n);
  } while (n);
  return luaO_nilobject;
}

// Assembly:
movb 0xb(%rdi), %cl
pushq $-0x1
popq %rax
shll %cl, %eax
notl %eax
andl 0xc(%rsi), %eax
imulq $0x28, %rax, %rax
addq 0x20(%rdi), %rax
leaq 0xca8d(%rip), %rcx      # 0x19640
cmpl $0x4, 0x18(%rax)
jne 0xcbbf
cmpq %rsi, 0x10(%rax)
je 0xcbcb
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xcbb3
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_get
const TValue *luaH_get (Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TNIL: return luaO_nilobject;
    case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
    case LUA_TNUMBER: {
      int k;
      lua_Number n = nvalue(key);
      lua_number2int(k, n);
      if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */
        return luaH_getnum(t, k);  /* use specialized version */
      /* else go through */
    }
    default: {
      Node *n = mainposition(t, key);
      do {  /* check whether `key' is somewhere in the chain */
        if (luaO_rawequalObj(key2tval(n), key))
          return gval(n);  /* that's it */
        else n = gnext(n);
      } while (n);
      return luaO_nilobject;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x8(%rsi), %eax
leaq 0xca65(%rip), %rbx      # 0x19640
testl %eax, %eax
je 0xcc45
movq %rsi, %r14
cmpl $0x3, %eax
je 0xcbf9
cmpl $0x4, %eax
jne 0xcc1c
movq (%r14), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xcb97
movsd (%r14), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcc1c
jp 0xcc1c
cvttsd2si %xmm0, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xcb10
movq %r14, %rsi
callq 0xcc4e
movq %rax, %r15
leaq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x9860
testl %eax, %eax
jne 0xcc42
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0xcc27
jmp 0xcc45
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: mainposition
static Node *mainposition (const Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TNUMBER:
      return hashnum(t, nvalue(key));
    case LUA_TSTRING:
      return hashstr(t, rawtsvalue(key));
    case LUA_TBOOLEAN:
      return hashboolean(t, bvalue(key));
    case LUA_TLIGHTUSERDATA:
      return hashpointer(t, pvalue(key));
    default:
      return hashpointer(t, gcvalue(key));
  }
}

// Assembly:
movl 0x8(%rsi), %eax
decl %eax
cmpl $0x3, %eax
ja 0xcc76
leaq 0xcf69(%rip), %rcx      # 0x19bc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0xb(%rdi), %cl
pushq $-0x1
popq %rax
shll %cl, %eax
notl %eax
andl (%rsi), %eax
jmp 0xcca8
movl (%rsi), %eax
movb 0xb(%rdi), %cl
pushq $-0x1
popq %rsi
shll %cl, %esi
notl %esi
orl $0x1, %esi
xorl %edx, %edx
divl %esi
imulq $0x28, %rdx, %rax
jmp 0xccac
movsd (%rsi), %xmm0
jmp 0xcb5e
movb 0xb(%rdi), %cl
pushq $-0x1
popq %rax
shll %cl, %eax
movq (%rsi), %rcx
notl %eax
andl 0xc(%rcx), %eax
imulq $0x28, %rax, %rax
addq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_set
TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
  const TValue *p = luaH_get(t, key);
  t->flags = 0;
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
    else if (ttisnumber(key) && luai_numisnan(nvalue(key)))
      luaG_runerror(L, "table index is NaN");
    return newkey(L, t, key);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xcbcc
movb $0x0, 0xa(%r14)
leaq 0xc96a(%rip), %rcx      # 0x19640
cmpq %rcx, %rax
je 0xcce1
popq %rbx
popq %r14
popq %r15
retq
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xcd00
cmpl $0x3, %eax
jne 0xcd11
movsd (%rbx), %xmm0
ucomisd %xmm0, %xmm0
jnp 0xcd11
leaq 0xcf15(%rip), %rsi      # 0x19c13
jmp 0xcd07
leaq 0xcef9(%rip), %rsi      # 0x19c00
movq %r15, %rdi
xorl %eax, %eax
callq 0x7165
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xcd21
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_setnum
TValue *luaH_setnum (lua_State *L, Table *t, int key) {
  const TValue *p = luaH_getnum(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    TValue k;
    setnvalue(&k, cast_num(key));
    return newkey(L, t, &k);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0xcb10
leaq 0xc682(%rip), %rcx      # 0x19640
cmpq %rcx, %rax
jne 0xcfe0
cvtsi2sd %ebp, %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcd21
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: luaH_setstr
TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {
  const TValue *p = luaH_getstr(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    TValue k;
    setsvalue(L, &k, key);
    return newkey(L, t, &k);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xcb97
leaq 0xc633(%rip), %rcx      # 0x19640
cmpq %rcx, %rax
jne 0xd02a
movq %rsp, %rdx
movq %r15, (%rdx)
movl $0x4, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcd21
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/ltable.c
// Function: countint
static int countint (const TValue *key, int *nums) {
  int k = arrayindex(key);
  if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
    nums[ceillog2(k)]++;  /* count as such */
    return 1;
  }
  else
    return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0xd113
decl %eax
xorl %ecx, %ecx
cmpl $0x3ffffff, %eax        # imm = 0x3FFFFFF
ja 0xd15a
movl %eax, %edi
callq 0x983d
cltq
incl 0x4(%rbx,%rax,4)
pushq $0x1
popq %rcx
movl %ecx, %eax
popq %rbx
retq
nop