LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_exp2RK
int luaK_exp2RK (FuncState *fs, expdesc *e) {
  luaK_exp2val(fs, e);
  switch (e->k) {
    case VKNUM:
    case VTRUE:
    case VFALSE:
    case VNIL: {
      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
                                        boolK(fs, (e->k == VTRUE));
        e->k = VK;
        return RKASK(e->u.s.info);
      }
      else break;
    }
    case VK: {
      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
        return RKASK(e->u.s.info);
      else break;
    }
    default: break;
  }
  /* not a constant in the right range: put it in a register */
  return luaK_exp2anyreg(fs, e);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10ac5
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0x10afc
cmpl $0x4, %eax
je 0x10b31
cmpl $0x5, %eax
jne 0x10b3b
cmpl $0xff, 0x40(%r14)
jg 0x10b3b
cmpl $0x5, %eax
je 0x10b4d
cmpl $0x1, %eax
jne 0x10b5c
leaq 0x18(%rsp), %rdx
andl $0x0, 0x8(%rdx)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
movq %r14, %rdi
jmp 0x10b78
movl 0x8(%rbx), %eax
cmpl $0xff, %eax
jle 0x10b86
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x10a70
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x10795
jmp 0x10b7d
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x106a7
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
orl $0x100, %eax            # imm = 0x100
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_storevar
void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
      exp2reg(fs, ex, var->u.s.info);
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
      break;
    }
    case VGLOBAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
      break;
    }
    case VINDEXED: {
      int e = luaK_exp2RK(fs, ex);
      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
      break;
    }
    default: {
      lua_assert(0);  /* invalid var kind to store */
      break;
    }
  }
  freeexp(fs, ex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl (%rsi), %eax
addl $-0x6, %eax
cmpl $0x3, %eax
ja 0x10c39
movq %rsi, %r15
leaq 0x9486(%rip), %rcx      # 0x1a03c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10969
movl 0x8(%r15), %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10974
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10a70
movl 0x8(%r15), %ecx
pushq $0x7
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x104c0
jmp 0x10c39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10ad6
movl 0x8(%r15), %edx
movl 0xc(%r15), %ecx
pushq $0x9
popq %rsi
movq %r14, %rdi
movl %eax, %r8d
jmp 0x10c34
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10a70
movl 0x8(%r15), %ecx
pushq $0x8
popq %rsi
movq %r14, %rdi
movl %eax, %edx
xorl %r8d, %r8d
callq 0x10460
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10969
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_self
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  int func;
  luaK_exp2anyreg(fs, e);
  freeexp(fs, e);
  func = fs->freereg;
  luaK_reserveregs(fs, 2);
  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
  freeexp(fs, key);
  e->u.s.info = func;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x10a70
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10969
movl 0x3c(%r15), %ebp
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x1066d
movl 0x8(%rbx), %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x10ad6
pushq $0xb
popq %rsi
movq %r15, %rdi
movl %ebp, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq 0x10460
movq %r15, %rdi
movq %r14, %rsi
callq 0x10969
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
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/lcode.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
  expdesc e2;
  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
  switch (op) {
    case OPR_MINUS: {
      if (!isnumeral(e))
        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
      codearith(fs, OP_UNM, e, &e2);
      break;
    }
    case OPR_NOT: codenot(fs, e); break;
    case OPR_LEN: {
      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
      codearith(fs, OP_LEN, e, &e2);
      break;
    }
    default: lua_assert(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
orq $-0x1, 0x10(%rsp)
movl $0x5, (%rsp)
andq $0x0, 0x8(%rsp)
cmpl $0x2, %esi
je 0x10e47
cmpl $0x1, %esi
je 0x10e17
testl %esi, %esi
jne 0x10e63
movq %rbx, %rdi
callq 0x10ed8
testl %eax, %eax
jne 0x10e13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10a70
pushq $0x12
jmp 0x10e54
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1087e
movl (%rbx), %eax
decl %eax
cmpl $0xb, %eax
ja 0x10eb2
leaq 0x9216(%rip), %rcx      # 0x1a04c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%rbx)
jmp 0x10eb2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10a70
pushq $0x14
popq %rsi
movq %rsp, %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x10ef0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x2, (%rbx)
jmp 0x10eb2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x115b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10969
movl 0x8(%rbx), %ecx
pushq $0x13
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x10460
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
jmp 0x10eb2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10d1a
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %eax
movl %esi, 0x14(%rbx)
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x115e2
movl 0x10(%rbx), %esi
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x115e2
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: codearith
static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
  if (constfolding(op, e1, e2))
    return;
  else {
    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
    int o1 = luaK_exp2RK(fs, e1);
    if (o1 > o2) {
      freeexp(fs, e1);
      freeexp(fs, e2);
    }
    else {
      freeexp(fs, e2);
      freeexp(fs, e1);
    }
    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
    e1->k = VRELOCABLE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq %rdx, %rdi
callq 0x10ed8
testl %eax, %eax
je 0x10f93
movq %r12, %rdi
callq 0x10ed8
testl %eax, %eax
je 0x10f93
xorpd %xmm0, %xmm0
leal -0xc(%r14), %eax
cmpl $0x8, %eax
ja 0x10f8c
movsd 0x8(%rbx), %xmm2
movsd 0x8(%r12), %xmm1
leaq 0x913a(%rip), %rcx      # 0x1a07c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
jmp 0x10f82
movapd %xmm2, %xmm0
callq 0x4110
jmp 0x10f86
subsd %xmm1, %xmm2
jmp 0x10f82
xorpd 0x8ec6(%rip), %xmm2     # 0x19e30
jmp 0x10f82
xorl %ebp, %ebp
jmp 0x10fae
mulsd %xmm1, %xmm2
jmp 0x10f82
ucomisd %xmm0, %xmm1
jne 0x10f7e
jnp 0x10fa1
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
ucomisd %xmm0, %xmm0
jp 0x10f93
movsd %xmm0, 0x8(%rbx)
jmp 0x10ff8
xorl %ebp, %ebp
cmpl $0x12, %r14d
je 0x10fae
cmpl $0x14, %r14d
je 0x10fae
movq %r15, %rdi
movq %r12, %rsi
callq 0x10ad6
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10ad6
movl %eax, %r13d
cmpl %ebp, %eax
movq %r12, %rsi
cmovgq %rbx, %rsi
cmovleq %rbx, %r12
movq %r15, %rdi
callq 0x10969
movq %r15, %rdi
movq %r12, %rsi
callq 0x10969
movq %r15, %rdi
movl %r14d, %esi
xorl %edx, %edx
movl %r13d, %ecx
movl %ebp, %r8d
callq 0x10460
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
ucomisd %xmm0, %xmm1
jne 0x1100f
jnp 0x10fa1
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x4470
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x10f86
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: luaK_code
static int luaK_code (FuncState *fs, Instruction i, int line) {
  Proto *f = fs->f;
  dischargejpc(fs);  /* `pc' will change */
  /* put new instruction in code array */
  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
                  MAX_INT, "code size overflow");
  f->code[fs->pc] = i;
  /* save corresponding line information */
  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
                  MAX_INT, "code size overflow");
  f->lineinfo[fs->pc] = line;
  return fs->pc++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r15
movl 0x38(%rdi), %esi
movl 0x30(%rdi), %edx
movl $0xff, %ecx
movl %edx, %r8d
callq 0x10551
orl $-0x1, 0x38(%rbx)
movl 0x30(%rbx), %ecx
cmpl 0x50(%r15), %ecx
jge 0x11325
movq 0x18(%r15), %rax
jmp 0x1134d
leaq 0x50(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x18(%r15), %rsi
leaq 0x8e4e(%rip), %r9       # 0x1a186
pushq $0x4
popq %rcx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0x9718
movq %rax, 0x18(%r15)
movl 0x30(%rbx), %ecx
movslq %ecx, %rcx
movl %r14d, (%rax,%rcx,4)
movl 0x30(%rbx), %ecx
cmpl 0x54(%r15), %ecx
jge 0x11363
movq 0x28(%r15), %rax
jmp 0x1138b
leaq 0x54(%r15), %rdx
movq 0x20(%rbx), %rdi
movq 0x28(%r15), %rsi
leaq 0x8e10(%rip), %r9       # 0x1a186
pushq $0x4
popq %rcx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
callq 0x9718
movq %rax, 0x28(%r15)
movl 0x30(%rbx), %ecx
movslq %ecx, %rcx
movl %ebp, (%rax,%rcx,4)
movl 0x30(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x30(%rbx)
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/lcode.c
// Function: luaK_setlist
void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
  lua_assert(tostore != 0);
  if (c <= MAXARG_C)
    luaK_codeABC(fs, OP_SETLIST, base, b, c);
  else {
    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
  }
  fs->freereg = base + 1;  /* free registers with list values */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %r8d
movl %edx, %r9d
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%r9), %eax
pushq $0x32
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
incl %ebp
xorl %ecx, %ecx
cmpl $-0x1, %r8d
cmovnel %r8d, %ecx
pushq $0x22
popq %rsi
movl %ebx, %edx
cmpl $0x63ce, %r9d           # imm = 0x63CE
jg 0x113e4
movl %ebp, %r8d
callq 0x10460
jmp 0x113fd
xorl %r8d, %r8d
callq 0x10460
movq 0x18(%r14), %rax
movl 0x8(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x112ed
incl %ebx
movl %ebx, 0x3c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lcode.c
// Function: discharge2reg
static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: {
      luaK_nil(fs, reg, 1);
      break;
    }
    case VFALSE:  case VTRUE: {
      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
      break;
    }
    case VK: {
      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
      break;
    }
    case VKNUM: {
      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VRELOCABLE: {
      Instruction *pc = &getcode(fs, e);
      SETARG_A(*pc, reg);
      break;
    }
    case VNONRELOC: {
      if (reg != e->u.s.info)
        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
      break;
    }
    default: {
      lua_assert(e->k == VVOID || e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.s.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1087e
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0x1154a
leaq 0x8c61(%rip), %rdx      # 0x1a118
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
pushq $0x2
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %r8d, %r8d
callq 0x10460
jmp 0x11541
movq (%r14), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rbx), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movzbl %bpl, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
jmp 0x11541
movl 0x8(%rbx), %ecx
cmpl %ebp, %ecx
je 0x11541
movq %r14, %rdi
xorl %esi, %esi
jmp 0x114ce
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x103d8
jmp 0x11541
movl 0x8(%rbx), %ecx
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
jmp 0x1153c
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x10795
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
callq 0x104c0
movl %ebp, 0x8(%rbx)
movl $0xc, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_init
void luaX_init (lua_State *L) {
  int i;
  for (i=0; i<NUM_RESERVED; i++) {
    TString *ts = luaS_new(L, luaX_tokens[i]);
    luaS_fix(ts);  /* reserved words are never collected */
    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
    ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb $0x1, %bpl
xorl %r15d, %r15d
leaq 0x14cb4(%rip), %r12     # 0x262e0
cmpq $0xa8, %r15
je 0x11660
movq (%r15,%r12), %r14
movq %r14, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc466
orb $0x20, 0x9(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %r15
incb %bpl
jmp 0x1162c
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/llex.c
// Function: luaX_token2str
const char *luaX_token2str (LexState *ls, int token) {
  if (token < FIRST_RESERVED) {
    lua_assert(token == cast(unsigned char, token));
    return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
                              luaO_pushfstring(ls->L, "%c", token);
  }
  else
    return luaX_tokens[token-FIRST_RESERVED];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl $0x100, %esi            # imm = 0x100
jg 0x11698
movq %rdi, %r14
callq 0x4570
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x2, (%rax,%rcx,2)
movq 0x38(%r14), %rdi
jne 0x116b1
leaq 0x8b9c(%rip), %rsi      # 0x1a232
jmp 0x116b8
addl $0xfffffeff, %ebx       # imm = 0xFFFFFEFF
leaq 0x14c3b(%rip), %rax     # 0x262e0
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8b71(%rip), %rsi      # 0x1a229
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9c6e
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_lexerror
void luaX_lexerror (LexState *ls, const char *msg, int token) {
  char buff[MAXSRC];
  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
  if (token)
    luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
  luaD_throw(ls->L, LUA_ERRSYNTAX);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
addq $0x18, %rsi
movq %rsp, %r12
pushq $0x50
popq %rdx
movq %r12, %rdi
callq 0x9cf2
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x7e20(%rip), %rsi      # 0x19520
movq %r12, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x9c6e
testl %r14d, %r14d
je 0x11757
movq %rax, %r15
movq 0x38(%rbx), %r12
leal -0x11c(%r14), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0x11738
xorl %esi, %esi
callq 0x12005
movq 0x48(%rbx), %rax
movq (%rax), %rcx
jmp 0x11743
movl %r14d, %esi
callq 0x11669
movq %rax, %rcx
leaq 0x8aeb(%rip), %rsi      # 0x1a235
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x9c6e
movq 0x38(%rbx), %rdi
pushq $0x3
popq %rsi
callq 0x74ee
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_newstring
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
  lua_State *L = ls->L;
  TString *ts = luaS_newlstr(L, str, l);
  TValue *o = luaH_setstr(L, ls->fs->h, ts);  /* entry for `str' */
  if (ttisnil(o)) {
    setbvalue(o, 1);  /* make sure `str' will not be collected */
    luaC_checkGC(L);
  }
  return ts;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0xc466
movq %rax, %r14
movq 0x30(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcfe9
cmpl $0x0, 0x8(%rax)
jne 0x117c5
pushq $0x1
popq %rcx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x117c5
movq %rbx, %rdi
callq 0x8b89
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: luaX_setinput
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
  ls->decpoint = '.';
  ls->L = L;
  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
  ls->z = z;
  ls->fs = NULL;
  ls->linenumber = 1;
  ls->lastline = 1;
  ls->source = source;
  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
  next(ls);  /* read first char */
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movb $0x2e, 0x58(%rsi)
movq %rdi, 0x38(%rsi)
movl $0x11f, 0x20(%rsi)      # imm = 0x11F
movq %rdx, 0x40(%rsi)
andq $0x0, 0x30(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rsi)
movq %rcx, 0x50(%rsi)
movq 0x48(%rsi), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
pushq $0x20
popq %rcx
callq 0x97a6
movq 0x48(%rbx), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1182f
callq 0xf294
jmp 0x1183e
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: save
static void save (LexState *ls, int c) {
  Mbuffer *b = ls->buff;
  if (b->n + 1 > b->buffsize) {
    size_t newsize;
    if (b->buffsize >= MAX_SIZET/2)
      luaX_lexerror(ls, "lexical element too long", 0);
    newsize = b->buffsize * 2;
    luaZ_resizebuffer(ls->L, b, newsize);
  }
  b->buffer[b->n++] = cast(char, c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x48(%rdi), %r12
movq 0x8(%r12), %rcx
movq 0x10(%r12), %rdx
leaq 0x1(%rcx), %rsi
cmpq %rdx, %rsi
jbe 0x12063
movq %rdi, %r15
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rax, %rdx
jb 0x1204e
leaq 0x8203(%rip), %rsi      # 0x1a242
movq %r15, %rdi
xorl %edx, %edx
callq 0x116c8
movq 0x10(%r12), %rdx
leaq (%rdx,%rdx), %r14
movq 0x38(%r15), %rdi
cmpq $-0x2, %r14
jne 0x12069
callq 0x97f0
jmp 0x12075
movq (%r12), %rax
jmp 0x12087
movq (%r12), %rsi
movq %r14, %rcx
callq 0x97a6
movq %rax, (%r12)
movq %r14, 0x10(%r12)
movq 0x8(%r12), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x8(%r12)
movb %bl, (%rax,%rcx)
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/llex.c
// Function: check_next
static int check_next (LexState *ls, const char *set) {
  if (!strchr(set, ls->current))
    return 0;
  save_and_next(ls);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq %rsi, %rdi
movl %ebp, %esi
callq 0x4160
testq %rax, %rax
je 0x123ae
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12005
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x123b2
callq 0xf294
jmp 0x123c1
xorl %eax, %eax
jmp 0x123c6
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/llex.c
// Function: read_numeral
static void read_numeral (LexState *ls, SemInfo *seminfo) {
  lua_assert(isdigit(ls->current));
  do {
    save_and_next(ls);
  } while (isdigit(ls->current) || ls->current == '.');
  if (check_next(ls, "Ee"))  /* `E'? */
    check_next(ls, "+-");  /* optional exponent sign */
  while (isalnum(ls->current) || ls->current == '_')
    save_and_next(ls);
  save(ls, '\0');
  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
    trydecpoint(ls, seminfo); /* try to update decimal point separator */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12005
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x123f9
callq 0xf294
movl %eax, %ebp
jmp 0x12408
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movl %ebp, (%rbx)
callq 0x4570
cmpl $0x2e, %ebp
je 0x123dc
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
jne 0x123dc
leaq 0x7edf(%rip), %rsi      # 0x1a30e
movq %rbx, %rdi
callq 0x1237c
testl %eax, %eax
je 0x1244a
leaq 0x7ecf(%rip), %rsi      # 0x1a311
movq %rbx, %rdi
callq 0x1237c
movl (%rbx), %esi
cmpl $0x5f, %esi
je 0x12460
movq (%r15), %rax
movslq %esi, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
je 0x1248e
movq %rbx, %rdi
callq 0x12005
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1247b
callq 0xf294
movl %eax, %esi
jmp 0x1248a
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %esi
movl %esi, (%rbx)
jmp 0x1244c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x12005
movsbl 0x58(%rbx), %edx
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x1252c
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x98ad
testl %eax, %eax
jne 0x124f4
callq 0x40f0
movb 0x58(%rbx), %cl
testq %rax, %rax
je 0x124ce
movq (%rax), %rax
movb (%rax), %al
jmp 0x124d0
movb $0x2e, %al
movb %al, 0x58(%rbx)
movsbl %cl, %esi
movsbl %al, %edx
movq %rbx, %rdi
callq 0x1252c
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x98ad
testl %eax, %eax
je 0x124ff
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsbl 0x58(%rbx), %esi
pushq $0x2e
popq %rdx
movq %rbx, %rdi
callq 0x1252c
leaq 0x7dff(%rip), %rsi      # 0x1a314
movq %rbx, %rdi
movl $0x11c, %edx            # imm = 0x11C
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x116c8
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_ipairs
static int luaB_ipairs (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
  lua_pushvalue(L, 1);  /* state, */
  lua_pushinteger(L, 0);  /* and initial value */
  return 3;
}

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

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x51fc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x624f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5641
testl %eax, %eax
je 0x12895
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
cmpl $0x1, %eax
jne 0x12835
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5b5f
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x541c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5a34
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x5cda
jmp 0x1288a
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5bb0
testl %eax, %eax
je 0x1286d
movq %rbx, %rdi
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x5afe
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5641
movl %eax, %ebp
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
testl %ebp, %ebp
jne 0x1287f
leaq 0x7d93(%rip), %rdx      # 0x1a607
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5bb0
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5db1
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_assert
static int luaB_assert (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_toboolean(L, 1))
    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
  return lua_gettop(L);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xf84a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5641
testl %eax, %eax
je 0x128cb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x51ef
leaq 0x7b56(%rip), %rdx      # 0x1a428
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xf667
leaq 0x885e(%rip), %rsi      # 0x1b144
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf48b
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_collectgarbage
static int luaB_collectgarbage (lua_State *L) {
  static const char *const opts[] = {"stop", "restart", "collect",
    "count", "step", "setpause", "setstepmul", NULL};
  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
  int o = luaL_checkoption(L, 1, "collect", opts);
  int ex = luaL_optint(L, 2, 0);
  int res = lua_gc(L, optsnum[o], ex);
  switch (optsnum[o]) {
    case LUA_GCCOUNT: {
      int b = lua_gc(L, LUA_GCCOUNTB, 0);
      lua_pushnumber(L, res + ((lua_Number)b/1024));
      return 1;
    }
    case LUA_GCSTEP: {
      lua_pushboolean(L, res);
      return 1;
    }
    default: {
      lua_pushnumber(L, res);
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x7b40(%rip), %rdx      # 0x1a447
leaq 0x13cd2(%rip), %rcx     # 0x265e0
pushq $0x1
popq %rsi
callq 0xf5ea
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf939
movslq %ebp, %rcx
leaq 0x7a21(%rip), %rdx      # 0x1a350
movl (%rdx,%rcx,4), %r14d
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x609d
movl %eax, %ebp
cmpl $0x5, %r14d
je 0x12971
cmpl $0x3, %r14d
jne 0x1297d
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x609d
cvtsi2sd %ebp, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0x79bd(%rip), %xmm0     # 0x1a328
addsd %xmm1, %xmm0
jmp 0x12981
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5a34
jmp 0x12989
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x57ea
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_dofile
static int luaB_dofile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  int n = lua_gettop(L);
  if (luaL_loadfile(L, fname) != 0) lua_error(L);
  lua_call(L, 0, LUA_MULTRET);
  return lua_gettop(L) - n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf667
movq %rax, %r14
movq %rbx, %rdi
callq 0x51ef
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10049
testl %eax, %eax
je 0x129c8
movq %rbx, %rdi
callq 0x616b
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5eb4
movq %rbx, %rdi
callq 0x51ef
subl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_getfenv
static int luaB_getfenv (lua_State *L) {
  getfunc(L, 1);
  if (lua_iscfunction(L, -1))  /* is a C function? */
    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
  else
    lua_getfenv(L, -1);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x132ae
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5474
testl %eax, %eax
je 0x12a97
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x541c
jmp 0x12aa2
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5c03
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_load
static int luaB_load (lua_State *L) {
  int status;
  const char *cname = luaL_optstring(L, 2, "=(load)");
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
  status = lua_load(L, generic_reader, NULL, cname);
  return load_aux(L, status);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x79b6(%rip), %rdx      # 0x1a4d5
pushq $0x2
popq %rsi
xorl %ecx, %ecx
callq 0xf667
movq %rax, %r14
pushq $0x1
popq %rsi
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0xf800
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x51fc
leaq 0x852(%rip), %rsi       # 0x1339e
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x6026
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1337d
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_loadstring
static int luaB_loadstring (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  const char *chunkname = luaL_optstring(L, 2, s);
  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0xf6c0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xf667
movq (%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rcx
callq 0x102b8
movq %rbx, %rdi
movl %eax, %esi
callq 0x1337d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_pcall
static int luaB_pcall (lua_State *L) {
  int status;
  luaL_checkany(L, 1);
  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
  lua_pushboolean(L, (status == 0));
  lua_insert(L, 1);
  return lua_gettop(L);  /* return status + all results */
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xf84a
movq %rbx, %rdi
callq 0x51ef
leal -0x1(%rax), %esi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x5eec
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x5a34
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5329
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x51ef
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_print
static int luaB_print (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    lua_pushvalue(L, -1);  /* function to be called */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tostring(L, -1);  /* get result */
    if (s == NULL)
      return luaL_error(L, LUA_QL("tostring") " must return a string to "
                           LUA_QL("print"));
    if (i>1) fputs("\t", stdout);
    fputs(s, stdout);
    lua_pop(L, 1);  /* pop result */
  }
  fputs("\n", stdout);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x51ef
movl %eax, %r14d
leaq 0x79b1(%rip), %rdx      # 0x1a5dc
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x5aa6
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
negl %r14d
pushq $0x1
popq %rbp
pushq $-0x1
popq %r15
movl %ebp, %r12d
leal (%r14,%r12), %eax
cmpl $0x1, %eax
je 0x12ccc
movq %rbx, %rdi
movl %r15d, %esi
callq 0x541c
movq %rbx, %rdi
movl %r12d, %esi
callq 0x541c
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x5eb4
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x5665
testq %rax, %rax
je 0x12cf3
movq %rax, %r13
cmpl $0x2, %r12d
jb 0x12caa
movq 0x14335(%rip), %rax     # 0x26fd0
movq (%rax), %rsi
leaq 0x7b63(%rip), %rdi      # 0x1a808
callq 0x41a0
movq 0x1431f(%rip), %rax     # 0x26fd0
movq (%rax), %rsi
movq %r13, %rdi
callq 0x41a0
movq %rbx, %rdi
pushq $-0x2
popq %rsi
callq 0x51fc
incl %r12d
jmp 0x12c4e
movq 0x142fd(%rip), %rax     # 0x26fd0
movq (%rax), %rsi
leaq 0x732b(%rip), %rdi      # 0x1a008
callq 0x41a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7822(%rip), %rsi      # 0x1a51c
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf48b
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_setfenv
static int luaB_setfenv (lua_State *L) {
  luaL_checktype(L, 2, LUA_TTABLE);
  getfunc(L, 0);
  lua_pushvalue(L, 2);
  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
    /* change environment of current thread */
    lua_pushthread(L);
    lua_insert(L, -2);
    lua_setfenv(L, -2);
    return 0;
  }
  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
    luaL_error(L,
          LUA_QL("setfenv") " cannot change environment of given object");
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rbp
pushq $0x5
popq %rdx
movl %ebp, %esi
callq 0xf800
movq %rbx, %rdi
xorl %esi, %esi
callq 0x132ae
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5493
testl %eax, %eax
je 0x12ec7
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x55e3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x12ec7
jp 0x12ec7
movq %rbx, %rdi
callq 0x5a62
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5329
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5e3b
xorl %ebp, %ebp
jmp 0x12ef8
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5474
testl %eax, %eax
je 0x12ee9
leaq 0x767d(%rip), %rsi      # 0x1a55a
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
jmp 0x12ef8
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5e3b
testl %eax, %eax
je 0x12ed6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_setmetatable
static int luaB_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  if (luaL_getmetafield(L, 1, "__metatable"))
    luaL_error(L, "cannot change a protected metatable");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x543c
movl %eax, %ebp
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0xf800
testl %ebp, %ebp
je 0x12f3a
cmpl $0x5, %ebp
je 0x12f3a
leaq 0x765f(%rip), %rdx      # 0x1a58e
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
leaq 0x7588(%rip), %rdx      # 0x1a4c9
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf967
testl %eax, %eax
je 0x12f61
leaq 0x764d(%rip), %rsi      # 0x1a5a4
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5db1
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_tonumber
static int luaB_tonumber (lua_State *L) {
  int base = luaL_optint(L, 2, 10);
  if (base == 10) {  /* standard conversion */
    luaL_checkany(L, 1);
    if (lua_isnumber(L, 1)) {
      lua_pushnumber(L, lua_tonumber(L, 1));
      return 1;
    }
  }
  else {
    const char *s1 = luaL_checkstring(L, 1);
    char *s2;
    unsigned long n;
    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
    n = strtoul(s1, &s2, base);
    if (s1 != s2) {  /* at least one valid digit? */
      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
      if (*s2 == '\0') {  /* no invalid trailing characters? */
        lua_pushnumber(L, (lua_Number)n);
        return 1;
      }
    }
  }
  lua_pushnil(L);  /* else not a number */
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
pushq $0xa
popq %rdx
callq 0xf939
movq %rax, %r14
cmpl $0xa, %r14d
jne 0x12fd0
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf84a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5493
testl %eax, %eax
je 0x13035
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x55e3
jmp 0x13060
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf6c0
movq %rax, %r15
leal -0x2(%r14), %eax
cmpl $0x23, %eax
jb 0x12ffb
leaq 0x75d8(%rip), %rdx      # 0x1a5c8
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x4460
movq (%r12), %r12
cmpq %r12, %r15
je 0x13035
movq %rax, %r14
callq 0x4570
movq (%rax), %rax
movzbl (%r12), %ecx
incq %r12
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x13022
testb %cl, %cl
je 0x1303f
movq %rbx, %rdi
callq 0x57d9
jmp 0x13068
movq %r14, %xmm1
punpckldq 0x6704(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x670c(%rip), %xmm1     # 0x19760
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57ea
pushq $0x1
popq %rax
addq $0x10, %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/lbaselib.c
// Function: luaB_tostring
static int luaB_tostring (lua_State *L) {
  luaL_checkany(L, 1);
  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
    return 1;  /* use its value */
  switch (lua_type(L, 1)) {
    case LUA_TNUMBER:
      lua_pushstring(L, lua_tostring(L, 1));
      break;
    case LUA_TSTRING:
      lua_pushvalue(L, 1);
      break;
    case LUA_TBOOLEAN:
      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
      break;
    case LUA_TNIL:
      lua_pushliteral(L, "nil");
      break;
    default:
      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
      break;
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xf84a
leaq 0x754a(%rip), %rdx      # 0x1a5da
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf9c5
testl %eax, %eax
je 0x130a6
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
cmpl $0x4, %eax
ja 0x1312a
movl %eax, %eax
leaq 0x7271(%rip), %rcx      # 0x1a330
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6b40(%rip), %rsi      # 0x19c0f
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x5819
jmp 0x1309e
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5665
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x13113
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5641
testl %eax, %eax
leaq 0x70ce(%rip), %rax      # 0x1a1d3
leaq 0x70e1(%rip), %rsi      # 0x1a1ed
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x5870
jmp 0x1309e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x541c
jmp 0x1309e
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x543c
movq %rbx, %rdi
movl %eax, %esi
callq 0x5458
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x578f
leaq 0x7490(%rip), %rsi      # 0x1a5e5
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x58eb
jmp 0x1309e
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_unpack
static int luaB_unpack (lua_State *L) {
  int i, e, n;
  luaL_checktype(L, 1, LUA_TTABLE);
  i = luaL_optint(L, 2, 1);
  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
  if (i > e) return 0;  /* empty range */
  n = e - i + 1;  /* number of elements */
  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
    return luaL_error(L, "too many results to unpack");
  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
  while (i++ < e)  /* push arg[i + 1...e] */
    lua_rawgeti(L, 1, i);
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
callq 0xf800
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0xf939
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x543c
testl %eax, %eax
jle 0x131e5
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xf8fe
jmp 0x131f0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x56d3
movq %rax, %r15
xorl %eax, %eax
movl %r15d, %ebp
subl %r14d, %ebp
jl 0x1322e
js 0x13237
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x50e2
testl %eax, %eax
je 0x13237
incl %r15d
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x5b2a
incl %r14d
cmpl %r14d, %r15d
jne 0x13216
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x73ae(%rip), %rsi      # 0x1a5ec
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf48b
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_xpcall
static int luaB_xpcall (lua_State *L) {
  int status;
  luaL_checkany(L, 2);
  lua_settop(L, 2);
  lua_insert(L, 1);  /* put error function under function to be called */
  status = lua_pcall(L, 0, LUA_MULTRET, 1);
  lua_pushboolean(L, (status == 0));
  lua_replace(L, 1);
  return lua_gettop(L);  /* return status + all results */
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0xf84a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x51fc
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5329
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %ecx
callq 0x5eec
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x5a34
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5360
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x51ef
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: getfunc
static void getfunc (lua_State *L, int opt) {
  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
  else {
    lua_Debug ar;
    int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
    luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
    if (lua_getstack(L, level, &ar) == 0)
      luaL_argerror(L, 1, "invalid level");
    lua_getinfo(L, "f", &ar);
    if (lua_isnil(L, -1))
      luaL_error(L, "no function environment for tail call at level %d",
                    level);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x543c
pushq $0x1
popq %rsi
cmpl $0x6, %eax
jne 0x132e1
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x541c
testl %ebp, %ebp
je 0x132f2
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0xf939
jmp 0x132fa
movq %rbx, %rdi
callq 0xf8fe
movq %rax, %r14
testl %r14d, %r14d
jns 0x13314
leaq 0x7165(%rip), %rdx      # 0x1a46e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x63ff
testl %eax, %eax
jne 0x1333a
leaq 0x715a(%rip), %rdx      # 0x1a489
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
leaq 0x76ea(%rip), %rsi      # 0x1aa2b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x656c
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
testl %eax, %eax
jne 0x13371
leaq 0x7133(%rip), %rsi      # 0x1a497
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0xf48b
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: generic_reader
static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
  (void)ud;  /* to avoid warnings */
  luaL_checkstack(L, 2, "too many nested functions");
  lua_pushvalue(L, 1);  /* get function */
  lua_call(L, 0, 1);  /* call it */
  if (lua_isnil(L, -1)) {
    *size = 0;
    return NULL;
  }
  else if (lua_isstring(L, -1)) {
    lua_replace(L, 3);  /* save string in a reserved stack slot */
    return lua_tolstring(L, 3, size);
  }
  else luaL_error(L, "reader function must return a string");
  return NULL;  /* to avoid warnings */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x712e(%rip), %rdx      # 0x1a4dd
pushq $0x2
popq %rsi
callq 0xf7ca
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x5eb4
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
testl %eax, %eax
je 0x1340c
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x54c4
testl %eax, %eax
je 0x13412
pushq $0x3
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5360
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x5665
andq $0x0, (%r14)
jmp 0x13423
leaq 0x70de(%rip), %rsi      # 0x1a4f7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf48b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lbaselib.c
// Function: luaB_cocreate
static int luaB_cocreate (lua_State *L) {
  lua_State *NL = lua_newthread(L);
  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
    "Lua function expected");
  lua_pushvalue(L, 1);  /* move function to top */
  lua_xmove(L, NL, 1);  /* move function from L to NL */
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x51b8
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
cmpl $0x6, %eax
jne 0x13458
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5474
testl %eax, %eax
je 0x1346a
leaq 0x71e3(%rip), %rdx      # 0x1a642
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf3d4
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5153
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq