LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/petitPanCake.c
// Function: read_serial_port
char read_serial_port(void){
	char c='\0';									// シリアル受信した文字の代入用
	fd_set ComReadFds;								// select命令用構造体ComReadFdを定義
	struct timeval tv;								// タイムアウト値の保持用
	FD_ZERO(&ComReadFds);							// ComReadFdの初期化
	FD_SET(ComFd, &ComReadFds); 					// ファイルディスクリプタを設定
	tv.tv_sec=0; tv.tv_usec=TXL_WAIT;
	if(select(ComFd+1, &ComReadFds, 0, 0, &tv)) read(ComFd, &c, 1); // データを受信
	// usleep(5000);								// 5msの(IchigoJam処理)待ち時間
	return c;										// 戻り値＝受信データ(文字変数c)
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl 0x2c32(%rip), %edi      # 0x40dc
leal 0x3f(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
orq %rdx, 0x20(%rsp,%rax,8)
movb $0x0, 0xf(%rsp)
leaq 0x10(%rsp), %r8
movq $0x0, (%r8)
cmpb $0x0, 0x2c37(%rip)      # 0x411c
movl $0x708, %eax            # imm = 0x708
movl $0x9c4, %ecx            # imm = 0x9C4
cmovneq %rax, %rcx
movq %rcx, 0x8(%r8)
incl %edi
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1110
testl %eax, %eax
je 0x1522
movl 0x2bce(%rip), %edi      # 0x40dc
leaq 0xf(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rsi
callq 0x10d0
movb (%rbx), %bl
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/bokunimowakaru[P]petit15term/petitPanCake.c
// Function: ahex2i
int ahex2i(char c){
	if(c>='0' && c<='9') return c-'0';
	if(c>='a' && c<='f') return c-'a'+10;
	if(c>='A' && c<='F') return c-'F'+10;
	return -1;
}

// Assembly:
movl %edi, %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x155c
addl $-0x30, %eax
retq
leal -0x61(%rax), %ecx
cmpb $0x5, %cl
ja 0x1568
addl $-0x57, %eax
retq
leal -0x41(%rax), %ecx
addl $-0x3c, %eax
cmpb $0x6, %cl
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovbl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lauxlib.c
// Function: panic
static int panic (lua_State *L) {
  (void)L;  /* to avoid warnings */
  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
                   lua_tostring(L, -1));
  return 0;
}

// Assembly:
pushq %rbx
movq 0x228fe(%rip), %rax     # 0x26ff8
movq (%rax), %rbx
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x5a88
leaq 0x1790a(%rip), %rsi     # 0x1c018
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x42c0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/ldblib.c
// Function: db_debug
static int db_debug (lua_State *L) {
  for (;;) {
    char buffer[250];
    fputs("lua_debug> ", stderr);
    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
        strcmp(buffer, "cont\n") == 0)
      return 0;
    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
        lua_pcall(L, 0, 0, 0)) {
      fputs(lua_tostring(L, -1), stderr);
      fputs("\n", stderr);
    }
    lua_settop(L, 0);  /* remove eventual returns */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movq 0x228be(%rip), %r13     # 0x26ff8
movq (%r13), %rsi
leaq 0x1801b(%rip), %rdi     # 0x1c760
callq 0x41a0
movq 0x22887(%rip), %rbp     # 0x26fd8
movq (%rbp), %rdx
movq %rsp, %rdi
movl $0xfa, %esi
callq 0x4250
testq %rax, %rax
je 0x481f
leaq 0x17ffa(%rip), %r14     # 0x1c76c
movq %rsp, %r15
pushq $0x6
popq %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4380
testl %eax, %eax
je 0x481f
movq %r15, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
leaq 0x17fcb(%rip), %rcx     # 0x1c772
callq 0x117dc
testl %eax, %eax
jne 0x47c2
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x633d
testl %eax, %eax
je 0x47eb
movq %rbx, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x5a88
movq (%r13), %rsi
movq %rax, %rdi
callq 0x41a0
movq (%r13), %rsi
leaq 0x17862(%rip), %rdi     # 0x1c048
callq 0x41a0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x54e9
movq (%r13), %rsi
leaq 0x17f60(%rip), %rdi     # 0x1c760
callq 0x41a0
movq (%rbp), %rdx
movq %r15, %rdi
movl $0xfa, %esi
callq 0x4250
testq %rax, %rax
jne 0x4779
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: main
int main (int argc, char **argv) {
  int status;
  struct Smain s;
  lua_State *L = lua_open();  /* create state */
  if (L == NULL) {
    l_message(argv[0], "cannot create state: not enough memory");
    return EXIT_FAILURE;
  }
  s.argc = argc;
  s.argv = argv;
  status = lua_cpcall(L, &pmain, &s);
  report(L, status);
  lua_close(L);
  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
callq 0x11856
testq %rax, %rax
je 0x498c
movq %rax, %rbx
movq %rsp, %r15
movl %ebp, (%r15)
movq %r14, 0x8(%r15)
leaq 0x49(%rip), %rsi        # 0x49a2
movq %rax, %rdi
movq %r15, %rdx
callq 0x63c5
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x4e86
movq %rbx, %rdi
callq 0xd137
xorl %eax, %eax
orl 0x10(%r15), %ebp
setne %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
leaq 0x1666e(%rip), %rsi     # 0x1b004
callq 0x45a0
movl $0x1, %eax
jmp 0x4981
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: report
static int report (lua_State *L, int status) {
  if (status && !lua_isnil(L, -1)) {
    const char *msg = lua_tostring(L, -1);
    if (msg == NULL) msg = "(error object is not a string)";
    l_message(progname, msg);
    lua_pop(L, 1);
  }
  return status;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
je 0x4ea1
movq %rdi, %r14
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
testl %eax, %eax
jne 0x4eab
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x467f
jmp 0x4ea1
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: docall
static int docall (lua_State *L, int narg, int clear) {
  int status;
  int base = lua_gettop(L) - narg;  /* function index */
  lua_pushcfunction(L, traceback);  /* push traceback function */
  lua_insert(L, base);  /* put it under chunk and args */
  signal(SIGINT, laction);
  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
  signal(SIGINT, SIG_DFL);
  lua_remove(L, base);  /* remove traceback function */
  /* force a complete garbage collection in case of errors */
  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x54dc
movl %eax, %ebp
subl %r14d, %ebp
leaq 0x78(%rip), %rsi        # 0x51bf
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5ddf
movq %rbx, %rdi
movl %ebp, %esi
callq 0x572e
leaq 0x108(%rip), %rsi       # 0x526d
movl $0x2, %edi
callq 0x42a0
cmpl $0x1, %r15d
sbbl %r12d, %r12d
movq %rbx, %rdi
movl %r14d, %esi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x633d
movl %eax, %r14d
movl $0x2, %edi
xorl %esi, %esi
callq 0x42a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5640
testl %r14d, %r14d
je 0x51b3
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x64f0
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: traceback
static int traceback (lua_State *L) {
  if (!lua_isstring(L, 1))  /* 'message' not a string? */
    return 1;  /* keep it intact */
  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
  if (!lua_istable(L, -1)) {
    lua_pop(L, 1);
    return 1;
  }
  lua_getfield(L, -1, "traceback");
  if (!lua_isfunction(L, -1)) {
    lua_pop(L, 2);
    return 1;
  }
  lua_pushvalue(L, 1);  /* pass error message */
  lua_pushinteger(L, 2);  /* skip this function and traceback */
  lua_call(L, 2, 1);  /* call debug.traceback */
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x58d4
testl %eax, %eax
je 0x5266
leaq 0x15e62(%rip), %rdx     # 0x1b03e
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x5eef
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
cmpl $0x5, %eax
jne 0x524f
leaq 0x15e42(%rip), %rdx     # 0x1b044
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5eef
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x584a
cmpl $0x6, %eax
jne 0x5259
movq %rbx, %rdi
movl $0x1, %esi
callq 0x582a
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5c40
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x6305
jmp 0x5266
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
jmp 0x5261
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x54e9
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: pushline
static int pushline (lua_State *L, int firstline) {
  char buffer[LUA_MAXINPUT];
  char *b = buffer;
  size_t l;
  const char *prmt = get_prompt(L, firstline);
  if (lua_readline(L, b, prmt) == 0)
    return 0;  /* no input */
  l = strlen(b);
  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
    b[l-1] = '\0';  /* remove it */
  if (firstline && b[0] == '=')  /* first line starts with `=' ? */
    lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
  else
    lua_pushstring(L, b);
  lua_freeline(L, b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
leaq 0x15f64(%rip), %rax     # 0x1b235
leaq 0x15f55(%rip), %rdx     # 0x1b22d
cmoveq %rax, %rdx
leaq 0x15f5b(%rip), %rax     # 0x1b23e
leaq 0x15f55(%rip), %r15     # 0x1b23f
cmoveq %rax, %r15
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x5eef
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x5a88
testq %rax, %rax
cmovneq %rax, %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x54e9
movq 0x21cab(%rip), %r12     # 0x26fd0
movq (%r12), %rsi
movq %r15, %rdi
callq 0x41a0
movq (%r12), %rdi
callq 0x4350
movq 0x21c97(%rip), %rax     # 0x26fd8
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x4250
testq %rax, %rax
je 0x53a2
movq %rsp, %rdi
callq 0x4140
testq %rax, %rax
je 0x536f
cmpb $0xa, -0x1(%rsp,%rax)
jne 0x536f
movb $0x0, -0x1(%rsp,%rax)
testl %ebp, %ebp
je 0x5391
cmpb $0x3d, (%rsp)
jne 0x5391
leaq 0x1(%rsp), %rdx
leaq 0x15e9e(%rip), %rsi     # 0x1b223
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5d2f
jmp 0x539c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5cb1
movl $0x1, %r14d
movl %r14d, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_checkstack
LUA_API int lua_checkstack (lua_State *L, int size) {
  int res = 1;
  lua_lock(L);
  if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)
    res = 0;  /* stack overflow */
  else if (size > 0) {
    luaD_checkstack(L, size);
    if (L->ci->top < L->top + size)
      L->ci->top = L->top + size;
  }
  lua_unlock(L);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpl $0x1f40, %esi           # imm = 0x1F40
jg 0x5439
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, %rcx
subq 0x18(%rdi), %rcx
sarq $0x4, %rcx
movslq %esi, %r15
addq %r15, %rcx
cmpq $0x1f40, %rcx           # imm = 0x1F40
jg 0x5439
movl $0x1, %ebx
testl %esi, %esi
jle 0x5439
movq 0x38(%r14), %rcx
subq %rax, %rcx
movl %esi, %edx
shll $0x4, %edx
cmpq %rdx, %rcx
jg 0x5424
movq %r14, %rdi
callq 0x7c11
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
shlq $0x4, %r15
addq %rax, %r15
cmpq %r15, 0x10(%rcx)
jae 0x5439
movq %r15, 0x10(%rcx)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_xmove
LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
  int i;
  if (from == to) return;
  lua_lock(to);
  api_checknelems(from, n);
  api_check(from, G(from) == G(to));
  api_check(from, to->ci->top - to->top >= n);
  from->top -= n;
  for (i = 0; i < n; i++) {
    setobj2s(to, to->top++, from->top + i);
  }
  lua_unlock(to);
}

// Assembly:
cmpq %rsi, %rdi
je 0x5488
movslq %edx, %rax
movq %rax, %rcx
shlq $0x4, %rcx
subq %rcx, 0x10(%rdi)
testl %eax, %eax
jle 0x5488
movl %edx, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %r8
leaq 0x10(%r8), %r9
movq %r9, 0x10(%rsi)
movq (%rdx,%rcx), %r9
movq %r9, (%r8)
movl 0x8(%rdx,%rcx), %edx
movl %edx, 0x8(%r8)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x5460
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_newthread
LUA_API lua_State *lua_newthread (lua_State *L) {
  lua_State *L1;
  lua_lock(L);
  luaC_checkGC(L);
  L1 = luaE_newthread(L);
  setthvalue(L, L->top, L1);
  api_incr_top(L);
  lua_unlock(L);
  luai_userstatethread(L, L1);
  return L1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x54bf
movq %rbx, %rdi
callq 0x93fe
movq %rbx, %rdi
callq 0xccdc
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x8, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_settop
LUA_API void lua_settop (lua_State *L, int idx) {
  lua_lock(L);
  if (idx >= 0) {
    api_check(L, idx <= L->stack_last - L->base);
    while (L->top < L->base + idx)
      setnilvalue(L->top++);
    L->top = L->base + idx;
  }
  else {
    api_check(L, -(idx+1) <= (L->top - L->base));
    L->top += idx+1;  /* `subtract' index (index is negative) */
  }
  lua_unlock(L);
}

// Assembly:
testl %esi, %esi
js 0x5629
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %r8
movl %esi, %edx
shlq $0x4, %rdx
leaq (%r8,%rdx), %rax
cmpq %rax, %rcx
jae 0x563b
addq %rdx, %r8
leaq 0x10(%rcx), %rdx
cmpq %rdx, %r8
cmovbeq %rdx, %r8
movq %rcx, %rdx
notq %rdx
addq %r8, %rdx
movq %rdx, %xmm0
shrq $0x4, %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
addq $0x38, %rcx
xorl %esi, %esi
movdqa 0x15d24(%rip), %xmm1    # 0x1b270
movdqa 0x15d2c(%rip), %xmm2    # 0x1b280
movdqa 0x15d34(%rip), %xmm3    # 0x1b290
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r8d
notl %r8d
testb $0x1, %r8b
je 0x55b0
movl $0x0, -0x30(%rcx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %r8d
testb $0x1, %r8b
je 0x55c7
movl $0x0, -0x20(%rcx)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %r8d
testb $0x1, %r8b
je 0x5604
movl $0x0, -0x10(%rcx)
pextrw $0x4, %xmm5, %r8d
testb $0x1, %r8b
je 0x5616
movl $0x0, (%rcx)
addq $0x4, %rsi
addq $0x40, %rcx
cmpq %rsi, %rdx
jne 0x5564
jmp 0x563b
movq 0x10(%rdi), %rax
movslq %esi, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_remove
LUA_API void lua_remove (lua_State *L, int idx) {
  StkId p;
  lua_lock(L);
  p = index2adr(L, idx);
  api_checkvalidindex(L, p);
  while (++p < L->top) setobjs2s(L, p-1, p);
  L->top--;
  lua_unlock(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x566f
addq $0x10, %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jae 0x5665
movq (%rax), %rcx
movq %rcx, -0x10(%rax)
movl 0x8(%rax), %ecx
movl %ecx, -0x8(%rax)
jmp 0x5649
addq $-0x10, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: index2adr
static TValue *index2adr (lua_State *L, int idx) {
  if (idx > 0) {
    TValue *o = L->base + (idx - 1);
    api_check(L, idx <= L->ci->top - L->base);
    if (o >= L->top) return cast(TValue *, luaO_nilobject);
    else return o;
  }
  else if (idx > LUA_REGISTRYINDEX) {
    api_check(L, idx != 0 && -idx <= L->top - L->base);
    return L->top + idx;
  }
  else switch (idx) {  /* pseudo-indices */
    case LUA_REGISTRYINDEX: return registry(L);
    case LUA_ENVIRONINDEX: {
      Closure *func = curr_func(L);
      sethvalue(L, &L->env, func->c.env);
      return &L->env;
    }
    case LUA_GLOBALSINDEX: return gt(L);
    default: {
      Closure *func = curr_func(L);
      idx = LUA_GLOBALSINDEX - idx;
      return (idx <= func->c.nupvalues)
                ? &func->c.upvalue[idx-1]
                : cast(TValue *, luaO_nilobject);
    }
  }
}

// Assembly:
testl %esi, %esi
jle 0x5694
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x4, %rcx
addq %rax, %rcx
addq $-0x10, %rcx
cmpq 0x10(%rdi), %rcx
leaq 0x15fd1(%rip), %rax     # 0x1b660
cmovbq %rcx, %rax
retq
cmpl $0xffffd8f1, %esi       # imm = 0xFFFFD8F1
jl 0x56a8
movslq %esi, %rax
shlq $0x4, %rax
addq 0x10(%rdi), %rax
retq
cmpl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
je 0x56f2
cmpl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
je 0x56ca
cmpl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
jne 0x56fa
movl $0xa0, %eax
addq 0x20(%rdi), %rax
retq
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
leaq 0x88(%rdi), %rax
movq 0x18(%rcx), %rcx
movq %rcx, 0x88(%rdi)
movl $0x5, 0x90(%rdi)
retq
addq $0x78, %rdi
movq %rdi, %rax
retq
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl $0xffffd8ee, %ecx       # imm = 0xFFFFD8EE
subl %esi, %ecx
movzbl 0xb(%rax), %edx
movl $0xffffd8ed, %edi       # imm = 0xFFFFD8ED
subl %esi, %edi
shlq $0x4, %rdi
cmpl %edx, %ecx
leaq 0x28(%rax,%rdi), %rcx
leaq 0x15f37(%rip), %rax     # 0x1b660
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_insert
LUA_API void lua_insert (lua_State *L, int idx) {
  StkId p;
  StkId q;
  lua_lock(L);
  p = index2adr(L, idx);
  api_checkvalidindex(L, p);
  for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
  setobjs2s(L, p, L->top);
  lua_unlock(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x566f
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
jbe 0x575d
movq -0x10(%rcx), %rdx
movq %rdx, (%rcx)
movl -0x8(%rcx), %edx
movl %edx, 0x8(%rcx)
leaq -0x10(%rcx), %rdx
movq %rdx, %rcx
cmpq %rax, %rdx
ja 0x5740
movq 0x10(%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_replace
LUA_API void lua_replace (lua_State *L, int idx) {
  StkId o;
  lua_lock(L);
  /* explicit test for incompatible code */
  if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
    luaG_runerror(L, "no calling environment");
  api_checknelems(L, 1);
  o = index2adr(L, idx);
  api_checkvalidindex(L, o);
  if (idx == LUA_ENVIRONINDEX) {
    Closure *func = curr_func(L);
    api_check(L, ttistable(L->top - 1)); 
    func->c.env = hvalue(L->top - 1);
    luaC_barrier(L, func, L->top - 1);
  }
  else {
    setobj(L, o, L->top - 1);
    if (idx < LUA_GLOBALSINDEX)  /* function upvalue? */
      luaC_barrier(L, curr_func(L), L->top - 1);
  }
  L->top--;
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
jne 0x57ce
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x5794
leaq 0x15bf3(%rip), %rsi     # 0x1b37d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7672
movq %rbx, %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x566f
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rsi
movq -0x10(%rax), %rax
movq %rax, 0x18(%rsi)
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x581e
movq -0x10(%rax), %rdx
testb $0x3, 0x9(%rdx)
jne 0x5810
jmp 0x581e
movl %esi, %ebp
movq %rbx, %rdi
callq 0x566f
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, (%rax)
movl -0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
cmpl $0xffffd8ed, %ebp       # imm = 0xFFFFD8ED
jg 0x581e
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x581e
movq -0x10(%rax), %rdx
testb $0x3, 0x9(%rdx)
je 0x581e
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0x581e
movq %rbx, %rdi
callq 0x998e
addq $-0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_rawequal
LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
  StkId o1 = index2adr(L, index1);
  StkId o2 = index2adr(L, index2);
  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
         : luaO_rawequalObj(o1, o2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %r14
callq 0x566f
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x566f
leaq 0x15d28(%rip), %rcx     # 0x1b660
cmpq %rcx, %rbx
sete %dl
cmpq %rcx, %rax
sete %cl
orb %dl, %cl
je 0x594f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xa2d1
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_equal
LUA_API int lua_equal (lua_State *L, int index1, int index2) {
  StkId o1, o2;
  int i;
  lua_lock(L);  /* may call tag method */
  o1 = index2adr(L, index1);
  o2 = index2adr(L, index2);
  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);
  lua_unlock(L);
  return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
callq 0x566f
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x566f
movq %rax, %rdx
leaq 0x15cdd(%rip), %rax     # 0x1b660
cmpq %rax, %r14
sete %cl
cmpq %rax, %rdx
sete %sil
xorl %eax, %eax
orb %cl, %sil
jne 0x59b4
movl 0x8(%r14), %ecx
cmpl 0x8(%rdx), %ecx
jne 0x59b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf04a
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_lessthan
LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
  StkId o1, o2;
  int i;
  lua_lock(L);  /* may call tag method */
  o1 = index2adr(L, index1);
  o2 = index2adr(L, index2);
  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
       : luaV_lessthan(L, o1, o2);
  lua_unlock(L);
  return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
callq 0x566f
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x566f
leaq 0x15c85(%rip), %rcx     # 0x1b660
cmpq %rcx, %r14
sete %dl
cmpq %rcx, %rax
sete %cl
orb %dl, %cl
je 0x59f2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xeec9
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_tonumber
LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
  TValue n;
  const TValue *o = index2adr(L, idx);
  if (tonumber(o, &n))
    return nvalue(o);
  else
    return 0;
}

// Assembly:
subq $0x18, %rsp
callq 0x566f
cmpl $0x3, 0x8(%rax)
je 0x5a25
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xeab4
testq %rax, %rax
je 0x5a2e
movsd (%rax), %xmm0
addq $0x18, %rsp
retq
xorps %xmm0, %xmm0
jmp 0x5a29
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_tointeger
LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
  TValue n;
  const TValue *o = index2adr(L, idx);
  if (tonumber(o, &n)) {
    lua_Integer res;
    lua_Number num = nvalue(o);
    lua_number2integer(res, num);
    return res;
  }
  else
    return 0;
}

// Assembly:
subq $0x18, %rsp
callq 0x566f
cmpl $0x3, 0x8(%rax)
je 0x5a54
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xeab4
testq %rax, %rax
je 0x5a5e
cvttsd2si (%rax), %rax
addq $0x18, %rsp
retq
xorl %eax, %eax
jmp 0x5a59
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_tolstring
LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
  StkId o = index2adr(L, idx);
  if (!ttisstring(o)) {
    lua_lock(L);  /* `luaV_tostring' may create a new string */
    if (!luaV_tostring(L, o)) {  /* conversion failed? */
      if (len != NULL) *len = 0;
      lua_unlock(L);
      return NULL;
    }
    luaC_checkGC(L);
    o = index2adr(L, idx);  /* previous call may reallocate the stack */
    lua_unlock(L);
  }
  if (len != NULL) *len = tsvalue(o)->len;
  return svalue(o);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x566f
cmpl $0x4, 0x8(%rax)
je 0x5ace
movq %r14, %rdi
movq %rax, %rsi
callq 0xeb01
testl %eax, %eax
je 0x5ae9
movq 0x20(%r14), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x5ac4
movq %r14, %rdi
callq 0x93fe
movq %r14, %rdi
movl %ebp, %esi
callq 0x566f
testq %rbx, %rbx
je 0x5add
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rax
addq $0x18, %rax
popq %rbx
popq %r14
popq %rbp
retq
testq %rbx, %rbx
je 0x5af5
movq $0x0, (%rbx)
xorl %eax, %eax
jmp 0x5ae4
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_objlen
LUA_API size_t lua_objlen (lua_State *L, int idx) {
  StkId o = index2adr(L, idx);
  switch (ttype(o)) {
    case LUA_TSTRING: return tsvalue(o)->len;
    case LUA_TUSERDATA: return uvalue(o)->len;
    case LUA_TTABLE: return luaH_getn(hvalue(o));
    case LUA_TNUMBER: {
      size_t l;
      lua_lock(L);  /* `luaV_tostring' may create a new string */
      l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
      lua_unlock(L);
      return l;
    }
    default: return 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x566f
movq %rax, %rbx
movl 0x8(%rax), %ecx
xorl %eax, %eax
addl $-0x3, %ecx
cmpl $0x4, %ecx
ja 0x5b54
leaq 0x15784(%rip), %rdx     # 0x1b2a0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeb01
testl %eax, %eax
je 0x5b52
movq (%rbx), %rax
movq 0x10(%rax), %rax
jmp 0x5b54
movq (%rbx), %rdi
callq 0xe040
cltq
jmp 0x5b54
movq (%rbx), %rax
movq 0x20(%rax), %rax
jmp 0x5b54
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_touserdata
LUA_API void *lua_touserdata (lua_State *L, int idx) {
  StkId o = index2adr(L, idx);
  switch (ttype(o)) {
    case LUA_TUSERDATA: return (rawuvalue(o) + 1);
    case LUA_TLIGHTUSERDATA: return pvalue(o);
    default: return NULL;
  }
}

// Assembly:
pushq %rax
callq 0x566f
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x5b97
cmpl $0x7, %ecx
jne 0x5b9c
movq (%rax), %rax
addq $0x28, %rax
jmp 0x5b9e
movq (%rax), %rax
jmp 0x5b9e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_topointer
LUA_API const void *lua_topointer (lua_State *L, int idx) {
  StkId o = index2adr(L, idx);
  switch (ttype(o)) {
    case LUA_TTABLE: return hvalue(o);
    case LUA_TFUNCTION: return clvalue(o);
    case LUA_TTHREAD: return thvalue(o);
    case LUA_TUSERDATA:
    case LUA_TLIGHTUSERDATA:
      return lua_touserdata(L, idx);
    default: return NULL;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x566f
movq %rax, %rcx
movl 0x8(%rax), %edx
xorl %eax, %eax
addl $-0x2, %edx
cmpl $0x6, %edx
ja 0x5be6
leaq 0x156da(%rip), %rsi     # 0x1b2b4
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq (%rcx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movl %ebx, %esi
callq 0x566f
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x5c0e
cmpl $0x7, %ecx
jne 0x5c13
movq (%rax), %rax
addq $0x28, %rax
jmp 0x5be6
movq (%rax), %rax
jmp 0x5be6
xorl %eax, %eax
jmp 0x5be6
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_pushlstring
LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
  lua_lock(L);
  luaC_checkGC(L);
  setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x5c81
movq %rbx, %rdi
callq 0x93fe
movq 0x10(%rbx), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xd282
movq %rax, (%r12)
movl $0x4, 0x8(%r12)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_pushstring
LUA_API void lua_pushstring (lua_State *L, const char *s) {
  if (s == NULL)
    lua_pushnil(L);
  else
    lua_pushlstring(L, s, strlen(s));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5cdd
movq %rsi, %r14
movq %rsi, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5c5a
movq 0x10(%rbx), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_pushcclosure
LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
  Closure *cl;
  lua_lock(L);
  luaC_checkGC(L);
  api_checknelems(L, n);
  cl = luaF_newCclosure(L, n, getcurrenv(L));
  cl->c.f = fn;
  L->top -= n;
  while (n--)
    setobj2n(L, &cl->c.upvalue[n], L->top+n);
  setclvalue(L, L->top, cl);
  lua_assert(iswhite(obj2gco(cl)));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x5e01
movq %rbx, %rdi
callq 0x93fe
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x5e18
movq 0x8(%rax), %rax
movq (%rax), %rax
addq $0x18, %rax
jmp 0x5e1c
leaq 0x78(%rbx), %rax
movq (%rax), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8cd4
movq %r14, 0x20(%rax)
movq 0x10(%rbx), %rsi
movslq %ebp, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
subq %rdx, %rsi
movq %rsi, 0x10(%rbx)
testl %ecx, %ecx
je 0x5e69
movq 0x10(%rbx), %rsi
movq -0x10(%rsi,%rdx), %rdi
movq %rdi, 0x18(%rax,%rdx)
movl -0x8(%rsi,%rdx), %esi
movl %esi, 0x20(%rax,%rdx)
addq $-0x10, %rdx
decq %rcx
jne 0x5e46
movq 0x10(%rbx), %rsi
movq %rax, (%rsi)
movl $0x6, 0x8(%rsi)
addq $0x10, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_getfield
LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
  StkId t;
  TValue key;
  lua_lock(L);
  t = index2adr(L, idx);
  api_checkvalidindex(L, t);
  setsvalue(L, &key, luaS_new(L, k));
  luaV_gettable(L, t, &key, L->top);
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
callq 0x566f
movq %rax, %r15
movq %rbx, %rdi
callq 0x4140
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xd282
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x4, 0x8(%rdx)
movq 0x10(%r14), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xeb5f
addq $0x10, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_rawgeti
LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
  StkId o;
  lua_lock(L);
  o = index2adr(L, idx);
  api_check(L, ttistable(o));
  setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
callq 0x566f
movq (%rax), %rdi
movl %ebx, %esi
callq 0xda82
movq 0x10(%r14), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_createtable
LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
  lua_lock(L);
  luaC_checkGC(L);
  sethvalue(L, L->top, luaH_new(L, narray, nrec));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x5fcd
movq %rbx, %rdi
callq 0x93fe
movq 0x10(%rbx), %r15
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xd77c
movq %rax, (%r15)
movl $0x5, 0x8(%r15)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_getmetatable
LUA_API int lua_getmetatable (lua_State *L, int objindex) {
  const TValue *obj;
  Table *mt = NULL;
  int res;
  lua_lock(L);
  obj = index2adr(L, objindex);
  switch (ttype(obj)) {
    case LUA_TTABLE:
      mt = hvalue(obj)->metatable;
      break;
    case LUA_TUSERDATA:
      mt = uvalue(obj)->metatable;
      break;
    default:
      mt = G(L)->mt[ttype(obj)];
      break;
  }
  if (mt == NULL)
    res = 0;
  else {
    sethvalue(L, L->top, mt);
    api_incr_top(L);
    res = 1;
  }
  lua_unlock(L);
  return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x566f
movslq 0x8(%rax), %rcx
cmpq $0x7, %rcx
je 0x6011
cmpl $0x5, %ecx
jne 0x601a
movq (%rax), %rax
addq $0x10, %rax
jmp 0x6028
movq 0x20(%rbx), %rax
leaq (%rax,%rcx,8), %rax
addq $0xe0, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x604a
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x5, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
jmp 0x604c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_getfenv
LUA_API void lua_getfenv (lua_State *L, int idx) {
  StkId o;
  lua_lock(L);
  o = index2adr(L, idx);
  api_checkvalidindex(L, o);
  switch (ttype(o)) {
    case LUA_TFUNCTION:
      sethvalue(L, L->top, clvalue(o)->c.env);
      break;
    case LUA_TUSERDATA:
      sethvalue(L, L->top, uvalue(o)->env);
      break;
    case LUA_TTHREAD:
      setobj2s(L, L->top,  gt(thvalue(o)));
      break;
    default:
      setnilvalue(L->top);
      break;
  }
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x566f
movl 0x8(%rax), %ecx
cmpl $0x8, %ecx
je 0x607e
cmpl $0x7, %ecx
je 0x6069
cmpl $0x6, %ecx
jne 0x6094
movq 0x10(%rbx), %rcx
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, (%rcx)
movl $0x5, %eax
jmp 0x609a
movq (%rax), %rax
movq 0x10(%rbx), %rcx
movq 0x78(%rax), %rdx
movq %rdx, (%rcx)
movl 0x80(%rax), %eax
jmp 0x609a
movq 0x10(%rbx), %rcx
xorl %eax, %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_settable
LUA_API void lua_settable (lua_State *L, int idx) {
  StkId t;
  lua_lock(L);
  api_checknelems(L, 2);
  t = index2adr(L, idx);
  api_checkvalidindex(L, t);
  luaV_settable(L, t, L->top - 2, L->top - 1);
  L->top -= 2;  /* pop index and value */
  lua_unlock(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x566f
movq 0x10(%rbx), %rcx
leaq -0x20(%rcx), %rdx
addq $-0x10, %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xed07
addq $-0x20, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_setfield
LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
  StkId t;
  TValue key;
  lua_lock(L);
  api_checknelems(L, 1);
  t = index2adr(L, idx);
  api_checkvalidindex(L, t);
  setsvalue(L, &key, luaS_new(L, k));
  luaV_settable(L, t, &key, L->top - 1);
  L->top--;  /* pop value */
  lua_unlock(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x566f
movq %rax, %r15
movq %r14, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd282
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x4, 0x8(%rdx)
movq 0x10(%rbx), %rcx
addq $-0x10, %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xed07
addq $-0x10, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_rawset
LUA_API void lua_rawset (lua_State *L, int idx) {
  StkId t;
  lua_lock(L);
  api_checknelems(L, 2);
  t = index2adr(L, idx);
  api_check(L, ttistable(t));
  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
  luaC_barriert(L, hvalue(t), L->top-1);
  L->top -= 2;
  lua_unlock(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x566f
movq %rax, %r14
movq 0x10(%rbx), %r15
movq (%rax), %rsi
leaq -0x20(%r15), %rdx
movq %rbx, %rdi
callq 0xdc86
movq -0x10(%r15), %rcx
movq %rcx, (%rax)
movl -0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x6181
movq -0x10(%rax), %rcx
testb $0x3, 0x9(%rcx)
je 0x6181
movq (%r14), %rsi
testb $0x4, 0x9(%rsi)
je 0x6181
movq %rbx, %rdi
callq 0x9a6d
movq 0x10(%rbx), %rax
addq $-0x20, %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_rawseti
LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
  StkId o;
  lua_lock(L);
  api_checknelems(L, 1);
  o = index2adr(L, idx);
  api_check(L, ttistable(o));
  setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
  luaC_barriert(L, hvalue(o), L->top-1);
  L->top--;
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x566f
movq %rax, %r14
movq 0x10(%rbx), %r15
movq (%rax), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0xdf96
movq -0x10(%r15), %rcx
movq %rcx, (%rax)
movl -0x8(%r15), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x61eb
movq -0x10(%rax), %rcx
testb $0x3, 0x9(%rcx)
je 0x61eb
movq (%r14), %rsi
testb $0x4, 0x9(%rsi)
je 0x61eb
movq %rbx, %rdi
callq 0x9a6d
movq 0x10(%rbx), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_setmetatable
LUA_API int lua_setmetatable (lua_State *L, int objindex) {
  TValue *obj;
  Table *mt;
  lua_lock(L);
  api_checknelems(L, 1);
  obj = index2adr(L, objindex);
  api_checkvalidindex(L, obj);
  if (ttisnil(L->top - 1))
    mt = NULL;
  else {
    api_check(L, ttistable(L->top - 1));
    mt = hvalue(L->top - 1);
  }
  switch (ttype(obj)) {
    case LUA_TTABLE: {
      hvalue(obj)->metatable = mt;
      if (mt)
        luaC_objbarriert(L, hvalue(obj), mt);
      break;
    }
    case LUA_TUSERDATA: {
      uvalue(obj)->metatable = mt;
      if (mt)
        luaC_objbarrier(L, rawuvalue(obj), mt);
      break;
    }
    default: {
      G(L)->mt[ttype(obj)] = mt;
      break;
    }
  }
  L->top--;
  lua_unlock(L);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x566f
movq 0x10(%rbx), %rcx
cmpl $0x0, -0x8(%rcx)
je 0x6217
movq -0x10(%rcx), %rdx
jmp 0x6219
xorl %edx, %edx
movslq 0x8(%rax), %rcx
cmpq $0x7, %rcx
je 0x624d
cmpl $0x5, %ecx
jne 0x6272
movq (%rax), %rcx
movq %rdx, 0x10(%rcx)
testq %rdx, %rdx
je 0x627e
testb $0x3, 0x9(%rdx)
je 0x627e
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0x627e
movq %rbx, %rdi
callq 0x9a6d
jmp 0x627e
movq (%rax), %rcx
movq %rdx, 0x10(%rcx)
testq %rdx, %rdx
je 0x627e
testb $0x3, 0x9(%rdx)
je 0x627e
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0x627e
movq %rbx, %rdi
callq 0x998e
jmp 0x627e
movq 0x20(%rbx), %rax
movq %rdx, 0xe0(%rax,%rcx,8)
addq $-0x10, 0x10(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_setfenv
LUA_API int lua_setfenv (lua_State *L, int idx) {
  StkId o;
  int res = 1;
  lua_lock(L);
  api_checknelems(L, 1);
  o = index2adr(L, idx);
  api_checkvalidindex(L, o);
  api_check(L, ttistable(L->top - 1));
  switch (ttype(o)) {
    case LUA_TFUNCTION:
      clvalue(o)->c.env = hvalue(L->top - 1);
      break;
    case LUA_TUSERDATA:
      uvalue(o)->env = hvalue(L->top - 1);
      break;
    case LUA_TTHREAD:
      sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));
      break;
    default:
      res = 0;
      break;
  }
  if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
  L->top--;
  lua_unlock(L);
  return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x566f
movl 0x8(%rax), %ecx
cmpl $0x8, %ecx
je 0x62ba
cmpl $0x7, %ecx
je 0x62a9
xorl %ebp, %ebp
cmpl $0x6, %ecx
jne 0x62f7
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rcx
movq (%rax), %rdx
movq %rcx, 0x18(%rdx)
jmp 0x62d3
movq (%rax), %rcx
movq 0x10(%rbx), %rdx
movq -0x10(%rdx), %rdx
movq %rdx, 0x78(%rcx)
movl $0x5, 0x80(%rcx)
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rdx
movl $0x1, %ebp
testb $0x3, 0x9(%rdx)
je 0x62f7
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0x62f7
movq %rbx, %rdi
callq 0x998e
addq $-0x10, 0x10(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_call
LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
  StkId func;
  lua_lock(L);
  api_checknelems(L, nargs+1);
  checkresults(L, nargs, nresults);
  func = L->top - (nargs+1);
  luaD_call(L, func, nresults);
  adjustresults(L, nresults);
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
notl %esi
movslq %esi, %rsi
shlq $0x4, %rsi
addq 0x10(%rdi), %rsi
callq 0x83a9
cmpl $-0x1, %ebp
jne 0x6336
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x6336
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_pcall
LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
  struct CallS c;
  int status;
  ptrdiff_t func;
  lua_lock(L);
  api_checknelems(L, nargs+1);
  checkresults(L, nargs, nresults);
  if (errfunc == 0)
    func = 0;
  else {
    StkId o = index2adr(L, errfunc);
    api_checkvalidindex(L, o);
    func = savestack(L, o);
  }
  c.func = L->top - (nargs+1);  /* function to be called */
  c.nresults = nresults;
  status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
  adjustresults(L, nresults);
  lua_unlock(L);
  return status;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
testl %ecx, %ecx
je 0x6367
movq %rbx, %rdi
movl %ecx, %esi
callq 0x566f
movq %rax, %r8
movq 0x40(%rbx), %rax
subq %rax, %r8
jmp 0x636e
movq 0x40(%rbx), %rax
xorl %r8d, %r8d
notl %r14d
movslq %r14d, %rcx
shlq $0x4, %rcx
addq 0x10(%rbx), %rcx
movq %rsp, %rdx
movq %rcx, (%rdx)
movl %ebp, 0x8(%rdx)
subq %rax, %rcx
leaq 0x28(%rip), %rsi        # 0x63b7
movq %rbx, %rdi
callq 0x8600
cmpl $-0x1, %ebp
jne 0x63ae
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rdx
cmpq 0x10(%rdx), %rcx
jb 0x63ae
movq %rcx, 0x10(%rdx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_cpcall
LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
  struct CCallS c;
  int status;
  lua_lock(L);
  c.func = func;
  c.ud = ud;
  status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);
  lua_unlock(L);
  return status;
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq 0x10(%rdi), %rcx
subq 0x40(%rdi), %rcx
leaq 0x10(%rip), %rsi        # 0x63f4
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x8600
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: f_Ccall
static void f_Ccall (lua_State *L, void *ud) {
  struct CCallS *c = cast(struct CCallS *, ud);
  Closure *cl;
  cl = luaF_newCclosure(L, 0, getcurrenv(L));
  cl->c.f = c->func;
  setclvalue(L, L->top, cl);  /* push function */
  api_incr_top(L);
  setpvalue(L->top, c->ud);  /* push only argument */
  api_incr_top(L);
  luaD_call(L, L->top - 2, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x6415
movq 0x8(%rax), %rax
movq (%rax), %rax
addq $0x18, %rax
jmp 0x6419
leaq 0x78(%rbx), %rax
movq (%rax), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8cd4
movq (%r14), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x6, 0x8(%rcx)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x10(%rax)
movl $0x2, 0x18(%rax)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x10, %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x83a9
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_load
LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
                      const char *chunkname) {
  ZIO z;
  int status;
  lua_lock(L);
  if (!chunkname) chunkname = "?";
  luaZ_init(L, &z, reader, data);
  status = luaD_protectedparser(L, &z, chunkname);
  lua_unlock(L);
  return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
testq %rcx, %rcx
leaq 0x163e5(%rip), %r14     # 0x1c878
cmovneq %rcx, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
movq %rax, %rcx
callq 0x1075e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8721
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_dump
LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
  int status;
  TValue *o;
  lua_lock(L);
  api_checknelems(L, 1);
  o = L->top - 1;
  if (isLfunction(o))
    status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);
  else
    status = 1;
  lua_unlock(L);
  return status;
}

// Assembly:
movq 0x10(%rdi), %rax
cmpl $0x6, -0x8(%rax)
jne 0x64d3
movq -0x10(%rax), %rax
cmpb $0x0, 0xa(%rax)
je 0x64d9
movl $0x1, %eax
retq
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x20(%rax), %rsi
xorl %r8d, %r8d
jmp 0x884c