LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12690
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4c(%rbp)
subl $0x28, %eax
je 0x11d1e
jmp 0x11c6e
movl -0x4c(%rbp), %eax
subl $0x2e, %eax
je 0x11ca9
jmp 0x11c78
movl -0x4c(%rbp), %eax
subl $0x3a, %eax
je 0x11ce8
jmp 0x11c82
movl -0x4c(%rbp), %eax
subl $0x5b, %eax
je 0x11cbb
jmp 0x11c8c
movl -0x4c(%rbp), %eax
subl $0x7b, %eax
je 0x11d1e
jmp 0x11c9a
movl -0x4c(%rbp), %eax
subl $0x11e, %eax            # imm = 0x11E
je 0x11d1e
jmp 0x11d3a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12730
jmp 0x11d40
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cd40
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x120b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1d3a0
jmp 0x11d40
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x12070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x1d100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12790
jmp 0x11d40
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cb50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12790
jmp 0x11d40
addq $0x50, %rsp
popq %rbp
retq
jmp 0x11c59
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11380
movq -0x10(%rbp), %rax
cmpl $0x7ffffffd, 0x24(%rax) # imm = 0x7FFFFFFD
jle 0x11e03
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
leaq 0x19c34(%rip), %rdx     # 0x2ba32
callq 0x11fe0
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x60(%rax)
jne 0x12023
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq 0x19a33(%rip), %rsi     # 0x2ba49
movb $0x0, %al
callq 0xfdb0
movq %rax, -0x28(%rbp)
jmp 0x1204e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x60(%rax), %edx
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
leaq 0x19a28(%rip), %rsi     # 0x2ba6b
movb $0x0, %al
callq 0xfdb0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x1e500
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x4a(%rax), %eax
addl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4a(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x12232
movq -0x18(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rsi
movzbl 0x4a(%rsi), %esi
subl -0xc(%rbp), %esi
movslq %esi, %rsi
movzwl 0xc4(%rdx,%rsi,2), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x121eb
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: parlist
static void parlist (LexState *ls) {
  /* parlist -> [ param { `,' param } ] */
  FuncState *fs = ls->fs;
  Proto *f = fs->f;
  int nparams = 0;
  f->is_vararg = 0;
  if (ls->t.token != ')') {  /* is `parlist' not empty? */
    do {
      switch (ls->t.token) {
        case TK_NAME: {  /* param -> NAME */
          new_localvar(ls, str_checkname(ls), nparams++);
          break;
        }
        case TK_DOTS: {  /* param -> `...' */
          luaX_next(ls);
#if defined(LUA_COMPAT_VARARG)
          /* use `arg' as default name */
          new_localvarliteral(ls, "arg", nparams++);
          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
#endif
          f->is_vararg |= VARARG_ISVARARG;
          break;
        }
        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
      }
    } while (!f->is_vararg && testnext(ls, ','));
  }
  adjustlocalvars(ls, nparams);
  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x72(%rax)
movq -0x8(%rbp), %rax
cmpl $0x29, 0x10(%rax)
je 0x12369
jmp 0x12282
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x117, %eax            # imm = 0x117
je 0x122cf
jmp 0x12295
movl -0x20(%rbp), %eax
subl $0x11d, %eax            # imm = 0x11D
jne 0x12324
jmp 0x122a5
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12100
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
callq 0x12140
jmp 0x12334
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18eef(%rip), %rsi     # 0x2b1da
movl $0x3, %edx
callq 0x1e650
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
callq 0x12140
movq -0x18(%rbp), %rax
movb $0x5, 0x72(%rax)
movq -0x18(%rbp), %rax
movzbl 0x72(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x72(%rax)
jmp 0x12334
movq -0x8(%rbp), %rdi
leaq 0x19782(%rip), %rsi     # 0x2bab1
callq 0x1e620
jmp 0x12336
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x72(%rcx)
movb %al, -0x31(%rbp)
jne 0x1235c
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x109a0
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x12282
jmp 0x12369
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x121c0
movq -0x10(%rbp), %rax
movzbl 0x4a(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x72(%rcx), %ecx
andl $0x1, %ecx
subl %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x71(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x4a(%rax), %esi
callq 0x1c5c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: pushclosure
static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
  FuncState *fs = ls->fs;
  Proto *f = fs->f;
  int oldsize = f->sizep;
  int i;
  luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
                  MAXARG_Bx, "constant table overflow");
  while (oldsize < f->sizep) f->p[oldsize++] = NULL;
  f->p[fs->np++] = func->f;
  luaC_objbarrier(ls->L, f, func->f);
  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
  for (i=0; i<func->f->nups; i++) {
    OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
    luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
  }
}

// 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 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x44(%rax), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jle 0x12432
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
addq $0x58, %rdx
movl $0x8, %ecx
movl $0x3ffff, %r8d          # imm = 0x3FFFF
leaq 0x196a8(%rip), %r9      # 0x2baca
callq 0xf380
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x12434
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jge 0x12460
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x12434
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rsi
movl 0x44(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x44(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x124c0
movq -0x28(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x124c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0xde90
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x44(%rax), %ecx
subl $0x1, %ecx
movl $0x24, %esi
xorl %edx, %edx
callq 0x1c260
movq -0x40(%rbp), %rdi
movl %eax, %edx
movl $0xb, %esi
callq 0x11890
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x70(%rcx), %ecx
cmpl %ecx, %eax
jge 0x12552
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl 0x4b(%rax,%rcx,2), %edx
movl $0x4, %eax
xorl %ecx, %ecx
cmpl $0x6, %edx
cmovel %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl 0x4c(%rax,%rcx,2), %ecx
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x1c1a0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x124f9
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: prefixexp
static void prefixexp (LexState *ls, expdesc *v) {
  /* prefixexp -> NAME | '(' expr ')' */
  switch (ls->t.token) {
    case '(': {
      int line = ls->linenumber;
      luaX_next(ls);
      expr(ls, v);
      check_match(ls, ')', '(', line);
      luaK_dischargevars(ls->fs, v);
      return;
    }
    case TK_NAME: {
      singlevar(ls, v);
      return;
    }
    default: {
      luaX_syntaxerror(ls, "unexpected symbol");
      return;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x28, %eax
je 0x126bd
jmp 0x126b1
movl -0x18(%rbp), %eax
subl $0x11d, %eax            # imm = 0x11D
je 0x12706
jmp 0x12715
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11380
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl $0x29, %esi
movl $0x28, %edx
callq 0x10be0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c9f0
jmp 0x12725
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12940
jmp 0x12725
movq -0x8(%rbp), %rdi
leaq 0x193c2(%rip), %rsi     # 0x2bae2
callq 0x1e620
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cd40
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1d3a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12100
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x129a0
cmpl $0x8, %eax
jne 0x1299a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c5f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x129dd
movq -0x20(%rbp), %rdi
movl $0x8, %esi
movl $0xff, %edx
callq 0x11890
movl $0x8, -0x4(%rbp)
jmp 0x12a6f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12a80
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x12a1f
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %edx
movl $0x6, %esi
callq 0x11890
cmpl $0x0, -0x24(%rbp)
jne 0x12a16
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x12af0
movl $0x6, -0x4(%rbp)
jmp 0x12a6f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x129a0
cmpl $0x8, %eax
jne 0x12a44
movl $0x8, -0x4(%rbp)
jmp 0x12a6f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12b50
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x7, (%rax)
movl $0x7, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: searchvar
static int searchvar (FuncState *fs, TString *n) {
  int i;
  for (i=fs->nactvar-1; i >= 0; i--) {
    if (n == getlocvar(fs, i).varname)
      return i;
  }
  return -1;  /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4a(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x12ae0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x30(%rcx), %rcx
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rsi
movzwl 0xc4(%rdx,%rsi,2), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x12ad3
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12ae7
jmp 0x12ad5
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12a9a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11380
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x109a0
cmpl $0x0, %eax
je 0x12d70
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cb50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11380
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12d34
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: enterblock
static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
  bl->breaklist = NO_JUMP;
  bl->isbreakable = isbreakable;
  bl->nactvar = fs->nactvar;
  bl->upval = 0;
  bl->previous = fs->bl;
  fs->bl = bl;
  lua_assert(fs->freereg == fs->nactvar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0xe(%rax)
movq -0x8(%rbp), %rax
movb 0x4a(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0xd(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %esi
callq 0x106c0
movq -0x10(%rbp), %rax
cmpb $0x0, 0xd(%rax)
je 0x12e42
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %edx
movl $0x23, %esi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x1c1a0
movq -0x8(%rbp), %rax
movzbl 0x4a(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x1c3d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: fornum
static void fornum (LexState *ls, TString *varname, int line) {
  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
  FuncState *fs = ls->fs;
  int base = fs->freereg;
  new_localvarliteral(ls, "(for index)", 0);
  new_localvarliteral(ls, "(for limit)", 1);
  new_localvarliteral(ls, "(for step)", 2);
  new_localvar(ls, varname, 3);
  checknext(ls, '=');
  exp1(ls);  /* initial value */
  checknext(ls, ',');
  exp1(ls);  /* limit */
  if (testnext(ls, ','))
    exp1(ls);  /* optional step */
  else {  /* default step = 1 */
    luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
    luaK_reserveregs(fs, 1);
  }
  forbody(ls, base, line, 1, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18cdc(%rip), %rsi     # 0x2bb88
movl $0xb, %edx
callq 0x1e650
movq -0x40(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x12140
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18cbd(%rip), %rsi     # 0x2bb94
movl $0xb, %edx
callq 0x1e650
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x12140
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18c9b(%rip), %rsi     # 0x2bba0
movl $0xa, %edx
callq 0x1e650
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl $0x2, %edx
callq 0x12140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x12140
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x11350
movq -0x8(%rbp), %rdi
callq 0x13170
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x11350
movq -0x8(%rbp), %rdi
callq 0x13170
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x109a0
cmpl $0x0, %eax
je 0x12f7e
movq -0x8(%rbp), %rdi
callq 0x13170
jmp 0x12fc2
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movsd 0x18a34(%rip), %xmm0    # 0x2b9d0
callq 0x1c7f0
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %edx
movl %eax, %ecx
movl $0x1, %esi
callq 0x1c260
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x1c5c0
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x14(%rbp), %edx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x131b0
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: forlist
static void forlist (LexState *ls, TString *indexname) {
  /* forlist -> NAME {,NAME} IN explist1 forbody */
  FuncState *fs = ls->fs;
  expdesc e;
  int nvars = 0;
  int line;
  int base = fs->freereg;
  /* create control variables */
  new_localvarliteral(ls, "(for generator)", nvars++);
  new_localvarliteral(ls, "(for state)", nvars++);
  new_localvarliteral(ls, "(for control)", nvars++);
  /* create declared variables */
  new_localvar(ls, indexname, nvars++);
  while (testnext(ls, ','))
    new_localvar(ls, str_checkname(ls), nvars++);
  checknext(ls, TK_IN);
  line = ls->linenumber;
  adjust_assign(ls, 3, explist1(ls, &e), &e);
  luaK_checkstack(fs, 3);  /* extra space to call generator */
  forbody(ls, base, line, nvars - 3, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18b8b(%rip), %rsi     # 0x2bbab
movl $0xf, %edx
callq 0x1e650
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl -0x34(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
callq 0x12140
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18b67(%rip), %rsi     # 0x2bbbb
movl $0xb, %edx
callq 0x1e650
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl -0x34(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
callq 0x12140
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18b3f(%rip), %rsi     # 0x2bbc7
movl $0xd, %edx
callq 0x1e650
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl -0x34(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
callq 0x12140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
callq 0x12140
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x109a0
cmpl $0x0, %eax
je 0x130fe
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12100
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl -0x34(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
callq 0x12140
jmp 0x130c1
movq -0x8(%rbp), %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x11350
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12d10
movq -0x68(%rbp), %rdi
movl %eax, %edx
movl $0x3, %esi
leaq -0x30(%rbp), %rcx
callq 0x132f0
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x1c560
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x34(%rbp), %ecx
subl $0x3, %ecx
xorl %r8d, %r8d
callq 0x131b0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11380
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1cb50
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x121c0
movq -0x8(%rbp), %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x11350
cmpl $0x0, -0x18(%rbp)
je 0x13212
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x20, %esi
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x1c260
movl %eax, -0x3c(%rbp)
jmp 0x1321e
movq -0x30(%rbp), %rdi
callq 0x1c200
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x12d80
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x121c0
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c5c0
movq -0x8(%rbp), %rdi
callq 0x10ba0
movq -0x30(%rbp), %rdi
callq 0x12de0
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1c3d0
cmpl $0x0, -0x18(%rbp)
je 0x1328a
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x1f, %esi
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x1c260
movl %eax, -0x40(%rbp)
jmp 0x132a4
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %r8d
movl $0x21, %esi
xorl %ecx, %ecx
callq 0x1c1a0
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1dbb0
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x132cc
movl -0x38(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x132d8
movq -0x30(%rbp), %rdi
callq 0x1c200
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
movl -0x34(%rbp), %edx
addl $0x1, %edx
callq 0x1c380
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: funcname
static int funcname (LexState *ls, expdesc *v) {
  /* funcname -> NAME {field} [`:' NAME] */
  int needself = 0;
  singlevar(ls, v);
  while (ls->t.token == '.')
    field(ls, v);
  if (ls->t.token == ':') {
    needself = 1;
    field(ls, v);
  }
  return needself;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12940
movq -0x8(%rbp), %rax
cmpl $0x2e, 0x10(%rax)
jne 0x133fd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12730
jmp 0x133e4
movq -0x8(%rbp), %rax
cmpl $0x3a, 0x10(%rax)
jne 0x1341b
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12730
movl -0x14(%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/lparser.c
// Function: check_conflict
static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
  FuncState *fs = ls->fs;
  int extra = fs->freereg;  /* eventual position to save local variable */
  int conflict = 0;
  for (; lh; lh = lh->prev) {
    if (lh->v.k == VINDEXED) {
      if (lh->v.u.s.info == v->u.s.info) {  /* conflict? */
        conflict = 1;
        lh->v.u.s.info = extra;  /* previous assignment will use safe copy */
      }
      if (lh->v.u.s.aux == v->u.s.info) {  /* conflict? */
        conflict = 1;
        lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
      }
    }
  }
  if (conflict) {
    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
    luaK_reserveregs(fs, 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13675
movq -0x10(%rbp), %rax
cmpl $0x9, 0x8(%rax)
jne 0x13666
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x13643
movl $0x1, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x13664
movl $0x1, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x13666
jmp 0x13668
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13611
cmpl $0x0, -0x28(%rbp)
je 0x136a6
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
xorl %r8d, %r8d
movl %r8d, %esi
callq 0x1c1a0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x1c5c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0xb8, %ecx
movq %rdx, %rsi
callq 0xf470
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0xe100
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x13780
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13870
movq -0x8(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb 0x64(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x64(%rax)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: preinit_state
static void preinit_state (lua_State *L, global_State *g) {
  G(L) = g;
  L->stack = NULL;
  L->stacksize = 0;
  L->errorJmp = NULL;
  L->hook = NULL;
  L->hookmask = 0;
  L->basehookcount = 0;
  L->allowhook = 1;
  resethookcount(L);
  L->openupval = NULL;
  L->size_ci = 0;
  L->nCcalls = L->baseCcalls = 0;
  L->status = 0;
  L->base_ci = L->ci = NULL;
  L->savedpc = NULL;
  L->errfunc = 0;
  setnilvalue(gt(L));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x64(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x65(%rax)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x5c(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x62(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x80(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstate.c
// Function: stack_init
static void stack_init (lua_State *L1, lua_State *L) {
  /* initialize CallInfo array */
  L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
  L1->ci = L1->base_ci;
  L1->size_ci = BASIC_CI_SIZE;
  L1->end_ci = L1->base_ci + L1->size_ci - 1;
  /* initialize stack array */
  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
  L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
  L1->top = L1->stack;
  L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
  /* initialize first ci */
  L1->ci->func = L1->top;
  setnilvalue(L1->top++);  /* `function' entry for this `ci' */
  L1->base = L1->ci->base = L1->top;
  L1->ci->top = L1->top + LUA_MINSTACK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x140, %ecx            # imm = 0x140
movq %rdx, %rsi
callq 0xf470
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x5c(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movslq 0x5c(%rax), %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
addq $-0x28, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x2d0, %ecx            # imm = 0x2D0
movq %rdx, %rsi
callq 0xf470
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x2d, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
subl $0x5, %eax
cltq
shlq $0x4, %rax
addq %rax, %rcx
addq $-0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x140, %rcx            # imm = 0x140
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0xcfd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13a00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xb8, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0xf470
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13870
movq -0x8(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x14960
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x5, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0xa0, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x14960
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x5, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x13f60
movq -0x8(%rbp), %rdi
callq 0x15a20
movq -0x8(%rbp), %rdi
callq 0x1e3d0
movq -0x8(%rbp), %rdi
leaq 0x1729d(%rip), %rsi     # 0x2b019
movl $0x11, %edx
callq 0x140d0
movzbl 0x9(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x9(%rax)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rcx
shlq $0x2, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0xcfd0
movq -0x8(%rbp), %rdi
callq 0xd7d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0xc(%rax), %rdx
shlq $0x3, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xf470
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
shlq $0x0, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xf470
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13a00
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x8(%rbp), %rsi
movl $0x268, %edx            # imm = 0x268
xorl %ecx, %ecx
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0xcfd0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xd420
movq -0x8(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x62(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x60(%rax)
movq -0x8(%rbp), %rdi
leaq 0x29(%rip), %rsi        # 0x13f40
xorl %eax, %eax
movl %eax, %edx
callq 0xb000
cmpl $0x0, %eax
jne 0x13ecd
movq -0x8(%rbp), %rdi
callq 0x13db0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstring.c
// Function: luaS_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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movzbl 0x21(%rax), %eax
cmpl $0x2, %eax
jne 0x13f85
jmp 0x140c7
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
movabsq $0x1fffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rcx, %rax
ja 0x13fba
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
shlq $0x3, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xf470
movq %rax, -0x48(%rbp)
jmp 0x13fc7
movq -0x8(%rbp), %rdi
callq 0xf500
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14005
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13fe2
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x14092
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x14082
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x1402b
jmp 0x14084
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1400c
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0xc(%rax), %rdx
shlq $0x3, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xf470
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)